OgreParticleEmitter.h

Go to the documentation of this file.

/*
-----------------------------------------------------------------------------
This source file is part of OGRE 
    (Object-oriented Graphics Rendering Engine)
For the latest info, see http://www.ogre3d.org/

Copyright (c) 2000-2005 The OGRE Team
Also see acknowledgements in Readme.html

This program is free software; you can redistribute it and/or modify it under 
the terms of the GNU Lesser General Public License as published by the Free Software 
Foundation; either version 2 of the License, or (at your option) any later 
version.

This program is distributed in the hope that it will be useful, but WITHOUT 
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS 
FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with 
this program; if not, write to the Free Software Foundation, Inc., 59 Temple 
Place - Suite 330, Boston, MA 02111-1307, USA, or go to 
http://www.gnu.org/copyleft/lesser.txt.
-----------------------------------------------------------------------------
*/
#ifndef __ParticleEmitter_H__
#define __ParticleEmitter_H__

#include "OgrePrerequisites.h"
#include "OgreString.h"
#include "OgreVector3.h"
#include "OgreColourValue.h"
#include "OgreStringInterface.h"
#include "OgreParticleEmitterCommands.h"
#include "OgreParticle.h"


namespace Ogre {


    class _OgreExport ParticleEmitter : public StringInterface
    {
    protected:

        // Command object for setting / getting parameters
        static EmitterCommands::CmdAngle msAngleCmd;
        static EmitterCommands::CmdColour msColourCmd;
        static EmitterCommands::CmdColourRangeStart msColourRangeStartCmd;
        static EmitterCommands::CmdColourRangeEnd msColourRangeEndCmd;
        static EmitterCommands::CmdDirection msDirectionCmd;
        static EmitterCommands::CmdEmissionRate msEmissionRateCmd;
        static EmitterCommands::CmdMaxTTL msMaxTTLCmd;
        static EmitterCommands::CmdMaxVelocity msMaxVelocityCmd;
        static EmitterCommands::CmdMinTTL msMinTTLCmd;
        static EmitterCommands::CmdMinVelocity msMinVelocityCmd;
        static EmitterCommands::CmdPosition msPositionCmd;
        static EmitterCommands::CmdTTL msTTLCmd;
        static EmitterCommands::CmdVelocity msVelocityCmd;
        static EmitterCommands::CmdDuration msDurationCmd;
        static EmitterCommands::CmdMinDuration msMinDurationCmd;
        static EmitterCommands::CmdMaxDuration msMaxDurationCmd;
        static EmitterCommands::CmdRepeatDelay msRepeatDelayCmd;
        static EmitterCommands::CmdMinRepeatDelay msMinRepeatDelayCmd;
        static EmitterCommands::CmdMaxRepeatDelay msMaxRepeatDelayCmd;


        ParticleSystem* mParent;
        Vector3 mPosition;
        Real mEmissionRate;
        String mType;
        Vector3 mDirection;
        // Notional up vector, just used to speed up generation of variant directions
        Vector3 mUp;
        Radian mAngle;
        Real mMinSpeed;
        Real mMaxSpeed;
        Real mMinTTL;
        Real mMaxTTL;
        ColourValue mColourRangeStart;
        ColourValue mColourRangeEnd;

        bool mEnabled;

        Real mStartTime;
        Real mDurationMin;
        Real mDurationMax;
        Real mDurationRemain;

        Real mRepeatDelayMin;
        Real mRepeatDelayMax;
        Real mRepeatDelayRemain;

        // Fractions of particles wanted to be emitted last time
        Real mRemainder;

        // NB Method below here are to help out people implementing emitters by providing the
        // most commonly used approaches as piecemeal methods

        virtual void genEmissionDirection(Vector3& destVector);

        virtual void genEmissionVelocity(Vector3& destVector);

        virtual Real genEmissionTTL(void);

        virtual void genEmissionColour(ColourValue& destColour);

        virtual unsigned short genConstantEmissionCount(Real timeElapsed);

        void addBaseParameters(void);

        void initDurationRepeat(void);


    public:
        ParticleEmitter(ParticleSystem* psys);
        virtual ~ParticleEmitter();

        virtual void setPosition(const Vector3& pos);

        virtual const Vector3& getPosition(void) const;

        virtual void setDirection(const Vector3& direction);

        virtual const Vector3& getDirection(void) const;

        virtual void setAngle(const Radian& angle);
#ifndef OGRE_FORCE_ANGLE_TYPES
        inline void setAngle(Real angle) {
            setAngle ( Angle(angle) );
        }
#endif//OGRE_FORCE_ANGLE_TYPES

        virtual const Radian& getAngle(void) const;

        virtual void setParticleVelocity(Real speed);


        virtual void setParticleVelocity(Real min, Real max);
        virtual void setMinParticleVelocity(Real min);
        virtual void setMaxParticleVelocity(Real max);

        virtual Real getParticleVelocity(void) const;

        virtual Real getMinParticleVelocity(void) const;

        virtual Real getMaxParticleVelocity(void) const;

        virtual void setEmissionRate(Real particlesPerSecond);

        virtual Real getEmissionRate(void) const;

        virtual void setTimeToLive(Real ttl);
        virtual void setTimeToLive(Real minTtl, Real maxTtl);

        virtual void setMinTimeToLive(Real min);
        virtual void setMaxTimeToLive(Real max);
        
        virtual Real getTimeToLive(void) const;

        virtual Real getMinTimeToLive(void) const;
        virtual Real getMaxTimeToLive(void) const;

        virtual void setColour(const ColourValue& colour);
        virtual void setColour(const ColourValue& colourStart, const ColourValue& colourEnd);
        virtual void setColourRangeStart(const ColourValue& colour);
        virtual void setColourRangeEnd(const ColourValue& colour);
        virtual const ColourValue& getColour(void) const;
        virtual const ColourValue& getColourRangeStart(void) const;
        virtual const ColourValue& getColourRangeEnd(void) const;

        virtual unsigned short _getEmissionCount(Real timeElapsed) = 0;

        virtual void _initParticle(Particle* pParticle) {
            // Initialise size incase it's been altered
            pParticle->resetDimensions();
        }


        const String &getType(void) const { return mType; }

        virtual void setEnabled(bool enabled);

        virtual bool getEnabled(void) const;

        virtual void setStartTime(Real startTime);
        virtual Real getStartTime(void) const;

        virtual void setDuration(Real duration);

        virtual Real getDuration(void) const;

        virtual void setDuration(Real min, Real max);
        virtual void setMinDuration(Real min);
        virtual void setMaxDuration(Real max);
        virtual Real getMinDuration(void) const;
        virtual Real getMaxDuration(void) const;

        virtual void setRepeatDelay(Real duration);

        virtual Real getRepeatDelay(void) const;

        virtual void setRepeatDelay(Real min, Real max);
        virtual void setMinRepeatDelay(Real min);
        virtual void setMaxRepeatDelay(Real max);
        virtual Real getMinRepeatDelay(void) const;
        virtual Real getMaxRepeatDelay(void) const;



    };

}


#endif

---

Copyright © 2000-2005 by The OGRE Team

This work is licensed under a Creative Commons Attribution-ShareAlike 2.5 License.
Last modified Sun Feb 12 12:59:49 2006