OgreParticleSystem.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 __ParticleSystem_H__
#define __ParticleSystem_H__

#include "OgrePrerequisites.h"

#include "OgreVector3.h"
#include "OgreString.h"
#include "OgreParticleIterator.h"
#include "OgreStringInterface.h"
#include "OgreMovableObject.h"
#include "OgreRadixSort.h"
#include "OgreController.h"
#include "OgreResourceGroupManager.h"


namespace Ogre {

    class _OgreExport ParticleSystem : public StringInterface, public MovableObject
    {
    public:

        class _OgrePrivate CmdQuota : public ParamCommand
        {
        public:
            String doGet(const void* target) const;
            void doSet(void* target, const String& val);
        };
        class _OgrePrivate CmdEmittedEmitterQuota : public ParamCommand
        {
        public:
            String doGet(const void* target) const;
            void doSet(void* target, const String& val);
        };
        class _OgrePrivate CmdMaterial : public ParamCommand
        {
        public:
            String doGet(const void* target) const;
            void doSet(void* target, const String& val);
        };
        class _OgrePrivate CmdCull : public ParamCommand
        {
        public:
            String doGet(const void* target) const;
            void doSet(void* target, const String& val);
        };
        class _OgrePrivate CmdWidth : public ParamCommand
        {
        public:
            String doGet(const void* target) const;
            void doSet(void* target, const String& val);
        };
        class _OgrePrivate CmdHeight : public ParamCommand
        {
        public:
            String doGet(const void* target) const;
            void doSet(void* target, const String& val);
        };
        class _OgrePrivate CmdRenderer : public ParamCommand
        {
        public:
            String doGet(const void* target) const;
            void doSet(void* target, const String& val);
        };
        class CmdSorted : public ParamCommand
        {
        public:
            String doGet(const void* target) const;
            void doSet(void* target, const String& val);
        };
        class CmdLocalSpace : public ParamCommand
        {
        public:
            String doGet(const void* target) const;
            void doSet(void* target, const String& val);
        };
        class CmdIterationInterval : public ParamCommand
        {
        public:
            String doGet(const void* target) const;
            void doSet(void* target, const String& val);
        };
        class CmdNonvisibleTimeout : public ParamCommand
        {
        public:
            String doGet(const void* target) const;
            void doSet(void* target, const String& val);
        };

        ParticleSystem();
        ParticleSystem(const String& name, const String& resourceGroupName);

        virtual ~ParticleSystem();

        void setRenderer(const String& typeName);

        ParticleSystemRenderer* getRenderer(void) const;
        const String& getRendererName(void) const;

        ParticleEmitter* addEmitter(const String& emitterType);

        ParticleEmitter* getEmitter(unsigned short index) const;

        unsigned short getNumEmitters(void) const;

        void removeEmitter(unsigned short index);

        void removeAllEmitters(void);


        ParticleAffector* addAffector(const String& affectorType);

        ParticleAffector* getAffector(unsigned short index) const;

        unsigned short getNumAffectors(void) const;

        void removeAffector(unsigned short index);

        void removeAllAffectors(void);

        void clear();

        size_t getNumParticles(void) const;

        Particle* createParticle(void);

        Particle* createEmitterParticle(const String& emitterName);

        Particle* getParticle(size_t index);

        size_t getParticleQuota(void) const;

        void setParticleQuota(size_t quota);

        size_t getEmittedEmitterQuota(void) const;

        void setEmittedEmitterQuota(size_t quota);

        ParticleSystem& operator=(const ParticleSystem& rhs);

        void _update(Real timeElapsed);

        ParticleIterator _getIterator(void);

        virtual void setMaterialName( const String& name, const String& groupName = ResourceGroupManager::AUTODETECT_RESOURCE_GROUP_NAME );

        virtual const String& getMaterialName(void) const;

        virtual void _notifyCurrentCamera(Camera* cam);

        void _notifyAttached(Node* parent, bool isTagPoint = false);

        virtual const AxisAlignedBox& getBoundingBox(void) const { return mAABB; }

        virtual Real getBoundingRadius(void) const { return mBoundingRadius; }

        virtual void _updateRenderQueue(RenderQueue* queue);

        void visitRenderables(Renderable::Visitor* visitor, 
            bool debugRenderables = false);

        void fastForward(Real time, Real interval = 0.1);

        void setSpeedFactor(Real speedFactor) { mSpeedFactor = speedFactor; }

        Real getSpeedFactor(void) const { return mSpeedFactor; }

        void setIterationInterval(Real iterationInterval);

        Real getIterationInterval(void) const { return mIterationInterval; }

        static void setDefaultIterationInterval(Real iterationInterval) { msDefaultIterationInterval = iterationInterval; }

        static Real getDefaultIterationInterval(void) { return msDefaultIterationInterval; }

        void setNonVisibleUpdateTimeout(Real timeout);
        Real getNonVisibleUpdateTimeout(void) const { return mNonvisibleTimeout; }

        static void setDefaultNonVisibleUpdateTimeout(Real timeout) 
        { msDefaultNonvisibleTimeout = timeout; }

        static Real getDefaultNonVisibleUpdateTimeout(void) { return msDefaultNonvisibleTimeout; }

        const String& getMovableType(void) const;

        virtual void _notifyParticleResized(void);

        virtual void _notifyParticleRotated(void);

        virtual void setDefaultDimensions(Real width, Real height);

        virtual void setDefaultWidth(Real width);
        virtual Real getDefaultWidth(void) const;
        virtual void setDefaultHeight(Real height);
        virtual Real getDefaultHeight(void) const;
        virtual bool getCullIndividually(void) const;
        virtual void setCullIndividually(bool cullIndividual);
        virtual const String& getResourceGroupName(void) const { return mResourceGroupName; }
        const String& getOrigin(void) const { return mOrigin; }
        void _notifyOrigin(const String& origin) { mOrigin = origin; }

        void setRenderQueueGroup(uint8 queueID);

        void setSortingEnabled(bool enabled) { mSorted = enabled; }
        bool getSortingEnabled(void) const { return mSorted; }

        void setBounds(const AxisAlignedBox& aabb);

        void setBoundsAutoUpdated(bool autoUpdate, Real stopIn = 0.0f);

        void setKeepParticlesInLocalSpace(bool keepLocal);

        bool getKeepParticlesInLocalSpace(void) const { return mLocalSpace; }

        void _updateBounds(void);

        void setEmitting(bool v);

        bool getEmitting() const;

        uint32 getTypeFlags(void) const;
    protected:

        static CmdCull msCullCmd;
        static CmdHeight msHeightCmd;
        static CmdMaterial msMaterialCmd;
        static CmdQuota msQuotaCmd;
        static CmdEmittedEmitterQuota msEmittedEmitterQuotaCmd;
        static CmdWidth msWidthCmd;
        static CmdRenderer msRendererCmd;
        static CmdSorted msSortedCmd;
        static CmdLocalSpace msLocalSpaceCmd;
        static CmdIterationInterval msIterationIntervalCmd;
        static CmdNonvisibleTimeout msNonvisibleTimeoutCmd;


        AxisAlignedBox mAABB;
        Real mBoundingRadius;
        bool mBoundsAutoUpdate;
        Real mBoundsUpdateTime;
        Real mUpdateRemainTime;

        AxisAlignedBox mWorldAABB;

        String mResourceGroupName;
        String mMaterialName;
        bool mIsRendererConfigured;
        MaterialPtr mMaterial;
        Real mDefaultWidth;
        Real mDefaultHeight;
        Real mSpeedFactor;
        Real mIterationInterval;
        bool mIterationIntervalSet;
        bool mSorted;
        bool mLocalSpace;
        Real mNonvisibleTimeout;
        bool mNonvisibleTimeoutSet;
        Real mTimeSinceLastVisible;
        unsigned long mLastVisibleFrame;
        Controller<Real>* mTimeController;
        bool mEmittedEmitterPoolInitialised;
        bool mIsEmitting;

        typedef list<Particle*>::type ActiveParticleList;
        typedef list<Particle*>::type FreeParticleList;
        typedef vector<Particle*>::type ParticlePool;

        struct SortByDirectionFunctor
        {
            Vector3 sortDir;

            SortByDirectionFunctor(const Vector3& dir);
            float operator()(Particle* p) const;
        };

        struct SortByDistanceFunctor
        {
            Vector3 sortPos;

            SortByDistanceFunctor(const Vector3& pos);
            float operator()(Particle* p) const;
        };

        static RadixSort<ActiveParticleList, Particle*, float> mRadixSorter;

        ActiveParticleList mActiveParticles;

        FreeParticleList mFreeParticles;

        ParticlePool mParticlePool;

        typedef list<ParticleEmitter*>::type FreeEmittedEmitterList;
        typedef list<ParticleEmitter*>::type ActiveEmittedEmitterList;
        typedef vector<ParticleEmitter*>::type EmittedEmitterList;
        typedef map<String, FreeEmittedEmitterList>::type FreeEmittedEmitterMap;
        typedef map<String, EmittedEmitterList>::type EmittedEmitterPool;

        EmittedEmitterPool mEmittedEmitterPool;

        FreeEmittedEmitterMap mFreeEmittedEmitters;

        ActiveEmittedEmitterList mActiveEmittedEmitters;

        typedef vector<ParticleEmitter*>::type ParticleEmitterList;
        typedef vector<ParticleAffector*>::type ParticleAffectorList;
        
        ParticleEmitterList mEmitters;
        ParticleAffectorList mAffectors;

        ParticleSystemRenderer* mRenderer;

        bool mCullIndividual;

        String mRendererType;
        
        size_t mPoolSize;

        size_t mEmittedEmitterPoolSize;

        String mOrigin;

        static Real msDefaultIterationInterval;
        static Real msDefaultNonvisibleTimeout;

        void _expire(Real timeElapsed);

        void _triggerEmitters(Real timeElapsed);

        void _executeTriggerEmitters(ParticleEmitter* emitter, unsigned requested, Real timeElapsed);

        void _applyMotion(Real timeElapsed);

        void _triggerAffectors(Real timeElapsed);

        void _sortParticles(Camera* cam);

        void increasePool(size_t size);

        void increaseEmittedEmitterPool(size_t size);

        void initParameters(void);

        void configureRenderer(void);

        void createVisualParticles(size_t poolstart, size_t poolend);
        void destroyVisualParticles(size_t poolstart, size_t poolend);

        void initialiseEmittedEmitters(void);

        void initialiseEmittedEmitterPool(void);

        void addFreeEmittedEmitters(void);

        void removeAllEmittedEmitters(void);

        FreeEmittedEmitterList* findFreeEmittedEmitter (const String& name);

        void removeFromActiveEmittedEmitters (ParticleEmitter* emitter);

        void addActiveEmittedEmittersToFreeList (void);

        void _notifyReorganiseEmittedEmitterData (void);
    };
}

#endif