ruby-ogre 0.0.1-x86-linux

data/deps/include/OGRE/OgreParticleSystem.h

@@ -0,0 +1,911 @@
+/*
+-----------------------------------------------------------------------------
+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 {
+
+	/** \addtogroup Core
+	*  @{
+	*/
+	/** \addtogroup Effects
+	*  @{
+	*/
+	/** Class defining particle system based special effects.
+    @remarks
+        Particle systems are special effects generators which are based on a 
+        number of moving points to create the impression of things like like 
+        sparkles, smoke, blood spurts, dust etc.
+    @par
+        This class simply manages a single collection of particles in world space
+        with a shared local origin for emission. The visual aspect of the 
+        particles is handled by a ParticleSystemRenderer instance.
+    @par
+        Particle systems are created using the SceneManager, never directly.
+        In addition, like all subclasses of MovableObject, the ParticleSystem 
+		will only be considered for rendering once it has been attached to a 
+		SceneNode. 
+    */
+    class _OgreExport ParticleSystem : public StringInterface, public MovableObject
+    {
+    public:
+
+        /** Command object for quota (see ParamCommand).*/
+        class _OgrePrivate CmdQuota : public ParamCommand
+        {
+        public:
+            String doGet(const void* target) const;
+            void doSet(void* target, const String& val);
+        };
+        /** Command object for emittedEmitterQuota (see ParamCommand).*/
+        class _OgrePrivate CmdEmittedEmitterQuota : public ParamCommand
+        {
+        public:
+            String doGet(const void* target) const;
+            void doSet(void* target, const String& val);
+        };
+        /** Command object for material (see ParamCommand).*/
+        class _OgrePrivate CmdMaterial : public ParamCommand
+        {
+        public:
+            String doGet(const void* target) const;
+            void doSet(void* target, const String& val);
+        };
+        /** Command object for cull_each (see ParamCommand).*/
+        class _OgrePrivate CmdCull : public ParamCommand
+        {
+        public:
+            String doGet(const void* target) const;
+            void doSet(void* target, const String& val);
+        };
+        /** Command object for particle_width (see ParamCommand).*/
+        class _OgrePrivate CmdWidth : public ParamCommand
+        {
+        public:
+            String doGet(const void* target) const;
+            void doSet(void* target, const String& val);
+        };
+        /** Command object for particle_height (see ParamCommand).*/
+        class _OgrePrivate CmdHeight : public ParamCommand
+        {
+        public:
+            String doGet(const void* target) const;
+            void doSet(void* target, const String& val);
+        };
+        /** Command object for renderer (see ParamCommand).*/
+        class _OgrePrivate CmdRenderer : public ParamCommand
+        {
+        public:
+            String doGet(const void* target) const;
+            void doSet(void* target, const String& val);
+        };
+		/** Command object for sorting (see ParamCommand).*/
+		class CmdSorted : public ParamCommand
+		{
+		public:
+			String doGet(const void* target) const;
+			void doSet(void* target, const String& val);
+		};
+		/** Command object for local space (see ParamCommand).*/
+		class CmdLocalSpace : public ParamCommand
+		{
+		public:
+			String doGet(const void* target) const;
+			void doSet(void* target, const String& val);
+		};
+		/** Command object for iteration interval(see ParamCommand).*/
+		class CmdIterationInterval : public ParamCommand
+		{
+		public:
+			String doGet(const void* target) const;
+			void doSet(void* target, const String& val);
+		};
+		/** Command object for nonvisible timeout (see ParamCommand).*/
+		class CmdNonvisibleTimeout : public ParamCommand
+		{
+		public:
+			String doGet(const void* target) const;
+			void doSet(void* target, const String& val);
+		};
+
+        /// Default constructor required for STL creation in manager
+        ParticleSystem();
+        /** Creates a particle system with no emitters or affectors.
+        @remarks
+            You should use the ParticleSystemManager to create particle systems rather than creating
+            them directly.
+        */
+        ParticleSystem(const String& name, const String& resourceGroupName);
+
+        virtual ~ParticleSystem();
+
+        /** Sets the ParticleRenderer to be used to render this particle system.
+        @remarks
+            The main ParticleSystem just manages the creation and movement of 
+            particles; they are rendered using functions in ParticleRenderer
+            and the ParticleVisual instances they create.
+		@param typeName String identifying the type of renderer to use; a new 
+			instance of this type will be created; a factory must have been registered
+			with ParticleSystemManager.
+        */
+        void setRenderer(const String& typeName);
+
+        /** Gets the ParticleRenderer to be used to render this particle system. */
+        ParticleSystemRenderer* getRenderer(void) const;
+        /** Gets the name of the ParticleRenderer to be used to render this particle system. */
+        const String& getRendererName(void) const;
+
+        /** Adds an emitter to this particle system.
+        @remarks
+            Particles are created in a particle system by emitters - see the ParticleEmitter
+            class for more details.
+        @param 
+            emitterType String identifying the emitter type to create. Emitter types are defined
+            by registering new factories with the manager - see ParticleEmitterFactory for more details.
+            Emitter types can be extended by OGRE, plugin authors or application developers.
+        */
+        ParticleEmitter* addEmitter(const String& emitterType);
+
+        /** Retrieves an emitter by it's index (zero-based).
+        @remarks
+            Used to retrieve a pointer to an emitter for a particle system to procedurally change
+            emission parameters etc.
+            You should check how many emitters are registered against this system before calling
+            this method with an arbitrary index using getNumEmitters.
+        @param
+            index Zero-based index of the emitter to retrieve.
+        */
+        ParticleEmitter* getEmitter(unsigned short index) const;
+
+        /** Returns the number of emitters for this particle system. */
+        unsigned short getNumEmitters(void) const;
+
+        /** Removes an emitter from the system.
+        @remarks
+            Drops the emitter with the index specified from this system.
+            You should check how many emitters are registered against this system before calling
+            this method with an arbitrary index using getNumEmitters.
+        @param
+            index Zero-based index of the emitter to retrieve.
+        */
+        void removeEmitter(unsigned short index);
+
+        /** Removes all the emitters from this system. */
+        void removeAllEmitters(void);
+
+
+        /** Adds an affector to this particle system.
+        @remarks
+            Particles are modified over time in a particle system by affectors - see the ParticleAffector
+            class for more details.
+        @param 
+            affectorType String identifying the affector type to create. Affector types are defined
+            by registering new factories with the manager - see ParticleAffectorFactory for more details.
+            Affector types can be extended by OGRE, plugin authors or application developers.
+        */
+        ParticleAffector* addAffector(const String& affectorType);
+
+        /** Retrieves an affector by it's index (zero-based).
+        @remarks
+            Used to retrieve a pointer to an affector for a particle system to procedurally change
+            affector parameters etc.
+            You should check how many affectors are registered against this system before calling
+            this method with an arbitrary index using getNumAffectors.
+        @param
+            index Zero-based index of the affector to retrieve.
+        */
+        ParticleAffector* getAffector(unsigned short index) const;
+
+        /** Returns the number of affectors for this particle system. */
+        unsigned short getNumAffectors(void) const;
+
+        /** Removes an affector from the system.
+        @remarks
+            Drops the affector with the index specified from this system.
+            You should check how many affectors are registered against this system before calling
+            this method with an arbitrary index using getNumAffectors.
+        @param
+            index Zero-based index of the affector to retrieve.
+        */
+        void removeAffector(unsigned short index);
+
+        /** Removes all the affectors from this system. */
+        void removeAllAffectors(void);
+
+        /** Empties this set of all particles.
+        */
+        void clear();
+
+        /** Gets the number of individual particles in the system right now.
+        @remarks
+            The number of particles active in a system at a point in time depends on 
+            the number of emitters, their emission rates, the time-to-live (TTL) each particle is
+            given on emission (and whether any affectors modify that TTL) and the maximum
+            number of particles allowed in this system at once (particle quota).
+        */
+        size_t getNumParticles(void) const;
+
+		/** Manually add a particle to the system. 
+		@remarks
+			Instead of using an emitter, you can manually add a particle to the system.
+			You must initialise the returned particle instance immediately with the
+			'emission' state.
+		@note
+			There is no corresponding 'destroyParticle' method - if you want to dispose of a
+			particle manually (say, if you've used setSpeedFactor(0) to make particles live forever)
+			you should use getParticle() and modify it's timeToLive to zero, meaning that it will
+			get cleaned up in the next update.
+		*/
+		Particle* createParticle(void);
+
+		/** Manually add an emitter particle to the system. 
+		@remarks
+			The purpose of a particle emitter is to emit particles. Besides visual particles, also other other
+			particle types can be emitted, other emitters for example. The emitted emitters have a double role;
+			they behave as particles and can be influenced by affectors, but they are still emitters and capable 
+			to emit other particles (or emitters). It is possible to create a chain of emitters - emitters 
+			emitting other emitters, which also emit emitters.
+		@param emitterName The name of a particle emitter that must be emitted.
+		*/
+		Particle* createEmitterParticle(const String& emitterName);
+
+		/** Retrieve a particle from the system for manual tweaking.
+		@remarks
+			Normally you use an affector to alter particles in flight, but
+			for small manually controlled particle systems you might want to use
+			this method.
+		*/
+		Particle* getParticle(size_t index);
+
+        /** Returns the maximum number of particles this system is allowed to have active at once.
+        @remarks
+            See ParticleSystem::setParticleQuota for more info.
+        */
+        size_t getParticleQuota(void) const;
+
+        /** Sets the maximum number of particles this system is allowed to have active at once.
+        @remarks
+            Particle systems all have a particle quota, i.e. a maximum number of particles they are 
+            allowed to have active at a time. This allows the application to set a keep particle systems
+            under control should they be affected by complex parameters which alter their emission rates
+            etc. If a particle system reaches it's particle quota, none of the emitters will be able to 
+            emit any more particles. As existing particles die, the spare capacity will be allocated
+            equally across all emitters to be as consistent to the original particle system style as possible.
+            The quota can be increased but not decreased after the system has been created.
+        @param quota The maximum number of particles this system is allowed to have.
+        */
+        void setParticleQuota(size_t quota);
+
+        /** Returns the maximum number of emitted emitters this system is allowed to have active at once.
+        @remarks
+            See ParticleSystem::setEmittedEmitterQuota for more info.
+        */
+        size_t getEmittedEmitterQuota(void) const;
+
+        /** Sets the maximum number of emitted emitters this system is allowed to have active at once.
+        @remarks
+            Particle systems can have - besides a particle quota - also an emitted emitter quota.
+        @param quota The maximum number of emitted emitters this system is allowed to have.
+        */
+        void setEmittedEmitterQuota(size_t quota);
+
+		/** Assignment operator for copying.
+        @remarks
+            This operator deep copies all particle emitters and effectors, but not particles. The
+            system's name is also not copied.
+        */
+        ParticleSystem& operator=(const ParticleSystem& rhs);
+
+        /** Updates the particles in the system based on time elapsed.
+        @remarks
+            This is called automatically every frame by OGRE.
+        @param
+            timeElapsed The amount of time, in seconds, since the last frame.
+        */
+        void _update(Real timeElapsed);
+
+        /** Returns an iterator for stepping through all particles in this system.
+        @remarks
+            This method is designed to be used by people providing new ParticleAffector subclasses,
+            this is the easiest way to step through all the particles in a system and apply the
+            changes the affector wants to make.
+        */
+        ParticleIterator _getIterator(void);
+
+        /** Sets the name of the material to be used for this billboard set.
+            @param
+                name The new name of the material to use for this set.
+        */
+        virtual void setMaterialName( const String& name, const String& groupName = ResourceGroupManager::AUTODETECT_RESOURCE_GROUP_NAME );
+
+        /** Sets the name of the material to be used for this billboard set.
+            @return The name of the material that is used for this set.
+        */
+        virtual const String& getMaterialName(void) const;
+
+        /** Overridden from MovableObject
+            @see
+                MovableObject
+        */
+        virtual void _notifyCurrentCamera(Camera* cam);
+
+        /** Overridden from MovableObject
+        @see
+        MovableObject
+        */
+        void _notifyAttached(Node* parent, bool isTagPoint = false);
+
+        /** Overridden from MovableObject
+            @see
+                MovableObject
+        */
+        virtual const AxisAlignedBox& getBoundingBox(void) const { return mAABB; }
+
+        /** Overridden from MovableObject
+            @see
+                MovableObject
+        */
+        virtual Real getBoundingRadius(void) const { return mBoundingRadius; }
+
+        /** Overridden from MovableObject
+            @see
+                MovableObject
+        */
+        virtual void _updateRenderQueue(RenderQueue* queue);
+
+		/// @copydoc MovableObject::visitRenderables
+		void visitRenderables(Renderable::Visitor* visitor, 
+			bool debugRenderables = false);
+
+        /** Fast-forwards this system by the required number of seconds.
+        @remarks
+            This method allows you to fast-forward a system so that it effectively looks like
+            it has already been running for the time you specify. This is useful to avoid the
+            'startup sequence' of a system, when you want the system to be fully populated right
+            from the start.
+        @param
+            time The number of seconds to fast-forward by.
+        @param
+            interval The sampling interval used to generate particles, apply affectors etc. The lower this
+            is the more realistic the fast-forward, but it takes more iterations to do it.
+        */
+        void fastForward(Real time, Real interval = 0.1);
+
+		/** Sets a 'speed factor' on this particle system, which means it scales the elapsed
+			real time which has passed by this factor before passing it to the emitters, affectors,
+			and the particle life calculation.
+		@remarks
+			An interesting side effect - if you want to create a completely manual particle system
+			where you control the emission and life of particles yourself, you can set the speed
+			factor to 0.0f, thus disabling normal particle emission, alteration, and death.
+		*/
+		void setSpeedFactor(Real speedFactor) { mSpeedFactor = speedFactor; }
+
+		/** Gets the 'speed factor' on this particle system.
+		*/
+		Real getSpeedFactor(void) const { return mSpeedFactor; }
+
+        /** Sets a 'iteration interval' on this particle system.
+        @remarks
+            The default Particle system update interval, based on elapsed frame time,
+			will cause different behavior between low frame-rate and high frame-rate. 
+			By using this option, you can make the particle system update at
+			a fixed interval, keeping the behavior the same no matter what frame-rate 
+			is.
+        @par
+            When iteration interval is set to zero, it means the update occurs based 
+			on an elapsed frame time, otherwise each iteration will take place 
+			at the given interval, repeating until it has used up all the elapsed 
+			frame time.
+        @param
+            iterationInterval The iteration interval, default to zero.
+        */
+        void setIterationInterval(Real iterationInterval);
+
+        /** Gets a 'iteration interval' on this particle system.
+        */
+        Real getIterationInterval(void) const { return mIterationInterval; }
+
+		/** Set the default iteration interval for all ParticleSystem instances.
+		*/
+        static void setDefaultIterationInterval(Real iterationInterval) { msDefaultIterationInterval = iterationInterval; }
+
+		/** Get the default iteration interval for all ParticleSystem instances.
+		*/
+        static Real getDefaultIterationInterval(void) { return msDefaultIterationInterval; }
+
+		/** Sets when the particle system should stop updating after it hasn't been
+			visible for a while.
+		@remarks
+			By default, visible particle systems update all the time, even when 
+			not in view. This means that they are guaranteed to be consistent when 
+			they do enter view. However, this comes at a cost, updating particle
+			systems can be expensive, especially if they are perpetual.
+		@par
+			This option lets you set a 'timeout' on the particle system, so that
+			if it isn't visible for this amount of time, it will stop updating
+			until it is next visible.
+		@param timeout The time after which the particle system will be disabled
+			if it is no longer visible. 0 to disable the timeout and always update.
+		*/
+		void setNonVisibleUpdateTimeout(Real timeout);
+		/** Gets when the particle system should stop updating after it hasn't been
+			visible for a while.
+		*/
+		Real getNonVisibleUpdateTimeout(void) const { return mNonvisibleTimeout; }
+
+		/** Set the default nonvisible timeout for all ParticleSystem instances.
+		*/
+		static void setDefaultNonVisibleUpdateTimeout(Real timeout) 
+		{ msDefaultNonvisibleTimeout = timeout; }
+
+		/** Get the default nonvisible timeout for all ParticleSystem instances.
+		*/
+		static Real getDefaultNonVisibleUpdateTimeout(void) { return msDefaultNonvisibleTimeout; }
+
+		/** Overridden from MovableObject */
+        const String& getMovableType(void) const;
+
+        /** Internal callback used by Particles to notify their parent that they have been resized.
+        */
+        virtual void _notifyParticleResized(void);
+
+        /** Internal callback used by Particles to notify their parent that they have been rotated.
+        */
+        virtual void _notifyParticleRotated(void);
+
+        /** Sets the default dimensions of the particles in this set.
+            @remarks
+                All particles in a set are created with these default dimensions. The set will render most efficiently if
+                all the particles in the set are the default size. It is possible to alter the size of individual
+                particles at the expense of extra calculation. See the Particle class for more info.
+            @param width
+                The new default width for the particles in this set.
+            @param height
+                The new default height for the particles in this set.
+        */
+        virtual void setDefaultDimensions(Real width, Real height);
+
+        /** See setDefaultDimensions - this sets 1 component individually. */
+        virtual void setDefaultWidth(Real width);
+        /** See setDefaultDimensions - this gets 1 component individually. */
+        virtual Real getDefaultWidth(void) const;
+        /** See setDefaultDimensions - this sets 1 component individually. */
+        virtual void setDefaultHeight(Real height);
+        /** See setDefaultDimensions - this gets 1 component individually. */
+        virtual Real getDefaultHeight(void) const;
+        /** Returns whether or not particles in this are tested individually for culling. */
+        virtual bool getCullIndividually(void) const;
+        /** Sets whether culling tests particles in this individually as well as in a group.
+        @remarks
+            Particle sets are always culled as a whole group, based on a bounding box which 
+            encloses all particles in the set. For fairly localised sets, this is enough. However, you
+            can optionally tell the set to also cull individual particles in the set, i.e. to test
+            each individual particle before rendering. The default is not to do this.
+        @par
+            This is useful when you have a large, fairly distributed set of particles, like maybe 
+            trees on a landscape. You probably still want to group them into more than one
+            set (maybe one set per section of landscape), which will be culled coarsely, but you also
+            want to cull the particles individually because they are spread out. Whilst you could have
+            lots of single-tree sets which are culled separately, this would be inefficient to render
+            because each tree would be issued as it's own rendering operation.
+        @par
+            By calling this method with a parameter of true, you can have large particle sets which 
+            are spaced out and so get the benefit of batch rendering and coarse culling, but also have
+            fine-grained culling so unnecessary rendering is avoided.
+        @param cullIndividual If true, each particle is tested before being sent to the pipeline as well 
+            as the whole set having to pass the coarse group bounding test.
+        */
+        virtual void setCullIndividually(bool cullIndividual);
+        /// Return the resource group to be used to load dependent resources
+        virtual const String& getResourceGroupName(void) const { return mResourceGroupName; }
+		/** Get the origin of this particle system, e.g. a script file name.
+		@remarks
+			This property will only contain something if the creator of
+			this particle system chose to populate it. Script loaders are advised
+			to populate it.
+		*/
+		const String& getOrigin(void) const { return mOrigin; }
+		/// Notify this particle system of it's origin
+		void _notifyOrigin(const String& origin) { mOrigin = origin; }
+
+		/** @copydoc MovableObject::setRenderQueueGroup */
+		void setRenderQueueGroup(uint8 queueID);
+
+		/** Set whether or not particles are sorted according to the camera.
+		@remarks
+			Enabling sorting alters the order particles are sent to the renderer.
+			When enabled, particles are sent to the renderer in order of 
+			furthest distance from the camera.
+		*/
+		void setSortingEnabled(bool enabled) { mSorted = enabled; }
+		/// Gets whether particles are sorted relative to the camera.
+		bool getSortingEnabled(void) const { return mSorted; }
+
+        /** Set the (initial) bounds of the particle system manually. 
+        @remarks
+            If you can, set the bounds of a particle system up-front and 
+            call setBoundsAutoUpdated(false); this is the most efficient way to
+            organise it. Otherwise, set an initial bounds and let the bounds increase
+            for a little while (the default is 5 seconds), after which time the 
+            AABB is fixed to save time.
+        @param aabb Bounds in local space.
+        */
+        void setBounds(const AxisAlignedBox& aabb);
+
+        /** Sets whether the bounds will be automatically updated
+            for the life of the particle system
+        @remarks
+            If you have a stationary particle system, it would be a good idea to
+            call this method and set the value to 'false', since the maximum
+            bounds of the particle system will eventually be static. If you do
+            this, you can either set the bounds manually using the setBounds()
+            method, or set the second parameter of this method to a positive
+            number of seconds, so that the bounds are calculated for a few
+            seconds and then frozen.
+        @param autoUpdate If true (the default), the particle system will
+            update it's bounds every frame. If false, the bounds update will 
+            cease after the 'stopIn' number of seconds have passed.
+        @param stopIn Only applicable if the first parameter is true, this is the
+            number of seconds after which the automatic update will cease.
+        */
+        void setBoundsAutoUpdated(bool autoUpdate, Real stopIn = 0.0f);
+
+		/** Sets whether particles (and any affector effects) remain relative 
+			to the node the particle system is attached to.
+		@remarks
+			By default particles are in world space once emitted, so they are not
+			affected by movement in the parent node of the particle system. This
+			makes the most sense when dealing with completely independent particles, 
+			but if you want to constrain them to follow local motion too, you
+			can set this to true.
+		*/
+		void setKeepParticlesInLocalSpace(bool keepLocal);
+
+		/** Gets whether particles (and any affector effects) remain relative 
+			to the node the particle system is attached to.
+		*/
+		bool getKeepParticlesInLocalSpace(void) const { return mLocalSpace; }
+
+        /** Internal method for updating the bounds of the particle system.
+        @remarks
+            This is called automatically for a period of time after the system's
+            creation (10 seconds by default, settable by setBoundsAutoUpdated) 
+            to increase (and only increase) the bounds of the system according 
+            to the emitted and affected particles. After this period, the 
+            system is assumed to achieved its maximum size, and the bounds are
+            no longer computed for efficiency. You can tweak the behaviour by 
+            either setting the bounds manually (setBounds, preferred), or 
+            changing the time over which the bounds are updated (performance cost).
+            You can also call this method manually if you need to update the 
+            bounds on an ad-hoc basis.
+        */
+        void _updateBounds(void);
+
+		/** This is used to turn on or off particle emission for this system.
+		@remarks
+			By default particle system is always emitting particles (if a emitters exists)
+			and this can be used to stop the emission for all emitters. To turn it on again, 
+			call it passing true.
+
+			Note that this does not detach the particle system from the scene node, it will 
+			still use some CPU.
+		*/
+		void setEmitting(bool v);
+
+		/** Returns true if the particle system emitting flag is turned on.
+		@remarks
+			This function will not actually return whether the particles are being emitted.
+			It only returns the value of emitting flag.
+		*/
+		bool getEmitting() const;
+
+		/// Override to return specific type flag
+		uint32 getTypeFlags(void) const;
+    protected:
+
+        /// Command objects
+        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;
+
+        /// World AABB, only used to compare world-space positions to calc bounds
+        AxisAlignedBox mWorldAABB;
+
+        /// Name of the resource group to use to load materials
+        String mResourceGroupName;
+        /// Name of the material to use
+        String mMaterialName;
+        /// Have we set the material etc on the renderer?
+        bool mIsRendererConfigured;
+        /// Pointer to the material to use
+        MaterialPtr mMaterial;
+        /// Default width of each particle
+        Real mDefaultWidth;
+        /// Default height of each particle
+        Real mDefaultHeight;
+		/// Speed factor
+		Real mSpeedFactor;
+        /// Iteration interval
+        Real mIterationInterval;
+        /// Iteration interval set? Otherwise track default
+        bool mIterationIntervalSet;
+		/// Particles sorted according to camera?
+		bool mSorted;
+		/// Particles in local space?
+		bool mLocalSpace;
+		/// Update timeout when nonvisible (0 for no timeout)
+		Real mNonvisibleTimeout;
+		/// Update timeout when nonvisible set? Otherwise track default
+		bool mNonvisibleTimeoutSet;
+		/// Amount of time non-visible so far
+		Real mTimeSinceLastVisible;
+		/// Last frame in which known to be visible
+		unsigned long mLastVisibleFrame;
+		/// Controller for time update
+		Controller<Real>* mTimeController;
+        /// Indication whether the emitted emitter pool (= pool with particle emitters that are emitted) is initialised
+		bool mEmittedEmitterPoolInitialised;
+		/// Used to control if the particle system should emit particles or not.
+		bool mIsEmitting;
+
+        typedef list<Particle*>::type ActiveParticleList;
+        typedef list<Particle*>::type FreeParticleList;
+        typedef vector<Particle*>::type ParticlePool;
+
+        /** Sort by direction functor */
+        struct SortByDirectionFunctor
+        {
+            /// Direction to sort in
+            Vector3 sortDir;
+
+            SortByDirectionFunctor(const Vector3& dir);
+            float operator()(Particle* p) const;
+        };
+
+        /** Sort by distance functor */
+        struct SortByDistanceFunctor
+        {
+            /// Position to sort in
+            Vector3 sortPos;
+
+            SortByDistanceFunctor(const Vector3& pos);
+            float operator()(Particle* p) const;
+        };
+
+		static RadixSort<ActiveParticleList, Particle*, float> mRadixSorter;
+
+		/** Active particle list.
+            @remarks
+                This is a linked list of pointers to particles in the particle pool.
+            @par
+                This allows very fast insertions and deletions from anywhere in 
+                the list to activate / deactivate particles as well as reuse of 
+                Particle instances in the pool without construction & destruction 
+                which avoids memory thrashing.
+        */
+        ActiveParticleList mActiveParticles;
+
+        /** Free particle queue.
+            @remarks
+                This contains a list of the particles free for use as new instances
+                as required by the set. Particle instances are preconstructed up 
+                to the estimated size in the mParticlePool vector and are 
+                referenced on this deque at startup. As they get used this list
+                reduces, as they get released back to to the set they get added
+				back to the list.
+        */
+        FreeParticleList mFreeParticles;
+
+        /** Pool of particle instances for use and reuse in the active particle list.
+            @remarks
+                This vector will be preallocated with the estimated size of the set,and will extend as required.
+        */
+        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;
+
+		/** Pool of emitted emitters for use and reuse in the active emitted emitter list.
+        @remarks
+			The emitters in this pool act as particles and as emitters. The pool is a map containing lists 
+			of emitters, identified by their name.
+        @par
+            The emitters in this pool are cloned using emitters that are kept in the main emitter list
+			of the ParticleSystem.
+        */
+		EmittedEmitterPool mEmittedEmitterPool;
+
+        /** Free emitted emitter list.
+            @remarks
+                This contains a list of the emitters free for use as new instances as required by the set.
+        */
+        FreeEmittedEmitterMap mFreeEmittedEmitters;
+
+		/** Active emitted emitter list.
+            @remarks
+                This is a linked list of pointers to emitters in the emitted emitter pool.
+				Emitters that are used are stored (their pointers) in both the list with active particles and in 
+				the list with active emitted emitters.        */
+        ActiveEmittedEmitterList mActiveEmittedEmitters;
+
+		typedef vector<ParticleEmitter*>::type ParticleEmitterList;
+        typedef vector<ParticleAffector*>::type ParticleAffectorList;
+        
+        /// List of particle emitters, ie sources of particles
+        ParticleEmitterList mEmitters;
+        /// List of particle affectors, ie modifiers of particles
+        ParticleAffectorList mAffectors;
+
+        /// The renderer used to render this particle system
+        ParticleSystemRenderer* mRenderer;
+
+        /// Do we cull each particle individually?
+        bool mCullIndividual;
+
+        /// The name of the type of renderer used to render this system
+        String mRendererType;
+        
+        /// The number of particles in the pool.
+        size_t mPoolSize;
+
+        /// The number of emitted emitters in the pool.
+        size_t mEmittedEmitterPoolSize;
+
+		/// Optional origin of this particle system (eg script name)
+		String mOrigin;
+
+        /// Default iteration interval
+        static Real msDefaultIterationInterval;
+        /// Default nonvisible update timeout
+        static Real msDefaultNonvisibleTimeout;
+
+        /** Internal method used to expire dead particles. */
+        void _expire(Real timeElapsed);
+
+        /** Spawn new particles based on free quota and emitter requirements. */
+        void _triggerEmitters(Real timeElapsed);
+
+		/** Helper function that actually performs the emission of particles
+        */
+		void _executeTriggerEmitters(ParticleEmitter* emitter, unsigned requested, Real timeElapsed);
+
+		/** Updates existing particle based on their momentum. */
+        void _applyMotion(Real timeElapsed);
+
+        /** Applies the effects of affectors. */
+        void _triggerAffectors(Real timeElapsed);
+
+		/** Sort the particles in the system **/
+		void _sortParticles(Camera* cam);
+
+        /** Resize the internal pool of particles. */
+        void increasePool(size_t size);
+
+		/** Resize the internal pool of emitted emitters.
+            @remarks
+                The pool consists of multiple vectors containing pointers to particle emitters. Increasing the 
+				pool with size implies that the vectors are equally increased. The quota of emitted emitters is 
+				defined on a particle system level and not on a particle emitter level. This is to prevent that
+				the number of created emitters becomes too high; the quota is shared amongst the emitted emitters.
+		*/
+		void increaseEmittedEmitterPool(size_t size);
+
+		/** Internal method for initialising string interface. */
+        void initParameters(void);
+
+        /** Internal method to configure the renderer. */
+        void configureRenderer(void);
+
+		/// Internal method for creating ParticleVisualData instances for the pool
+		void createVisualParticles(size_t poolstart, size_t poolend);
+		/// Internal method for destroying ParticleVisualData instances for the pool
+		void destroyVisualParticles(size_t poolstart, size_t poolend);
+
+		/** Create a pool of emitted emitters and assign them to the free emitter list.
+            @remarks
+                The emitters in the pool are grouped by name. This name is the name of the base emitter in the
+				main list with particle emitters, which forms the template of the created emitted emitters.
+        */
+		void initialiseEmittedEmitters(void);
+
+		/** Determine which emitters in the Particle Systems main emitter become a template for creating an
+			pool of emitters that can be emitted.
+        */
+		void initialiseEmittedEmitterPool(void);
+
+		/** Add  emitters from the pool to the free emitted emitter queue. */
+		void addFreeEmittedEmitters(void);
+
+		/** Removes all emitted emitters from this system.	*/
+		void removeAllEmittedEmitters(void);
+
+		/** Find the list with free emitted emitters.
+            @param name The name that identifies the list with free emitted emitters.
+        */
+		FreeEmittedEmitterList* findFreeEmittedEmitter (const String& name);
+
+		/** Removes an emitter from the active emitted emitter list.
+            @remarks
+                The emitter will not be destroyed!
+            @param emitter Pointer to a particle emitter.
+        */
+		void removeFromActiveEmittedEmitters (ParticleEmitter* emitter);
+
+		/** Moves all emitted emitters from the active list to the free list
+            @remarks
+                The active emitted emitter list will not be cleared and still keeps references to the emitters!
+        */
+		void addActiveEmittedEmittersToFreeList (void);
+
+		/** This function clears all data structures that are used in combination with emitted emitters and
+		    sets the flag to indicate that the emitted emitter pool must be initialised again.
+            @remarks
+                This function should be called if new emitters are added to a ParticleSystem or deleted from a
+				ParticleSystem. The emitted emitter data structures become out of sync and need to be build up
+				again. The data structures are not reorganised in this function, but by setting a flag, 
+				they are rebuild in the regular process flow.
+        */
+		void _notifyReorganiseEmittedEmitterData (void);
+    };
+	/** @} */
+	/** @} */
+
+}
+
+#endif