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-2012 Torus Knot Software Ltd

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
-----------------------------------------------------------------------------
*/
#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, public Particle
    {
    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::CmdUp msUpCmd;
        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;
        static EmitterCommands::CmdName msNameCmd;
        static EmitterCommands::CmdEmittedEmitter msEmittedEmitterCmd;


        ParticleSystem* mParent;
        Vector3 mPosition;
        Real mEmissionRate;
        String mType;
        Vector3 mDirection;
        // Notional up vector, used to speed up generation of variant directions, and also to orient some emitters.
        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;

        String mName;

        String mEmittedEmitter;

        // If 'true', this emitter is emitted by another emitter.
        // NB. That doesn't imply that the emitter itself emits other emitters (that could or could not be the case)
        bool mEmitted;

        // 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 setUp(const Vector3& up);

        virtual const Vector3& getUp(void) const;

        virtual void setAngle(const Radian& angle);

        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 in case 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;

        const String &getName(void) const;

        virtual void setName(const String& newName);

        const String &getEmittedEmitter(void) const;

        virtual void setEmittedEmitter(const String& emittedEmitter);

        virtual bool isEmitted(void) const;

        virtual void setEmitted(bool emitted);


    };
}


#endif