particle_system.h

Go to the documentation of this file.

/* Copyright, 2001 Nevrax Ltd.
 *
 * This file is part of NEVRAX NEL.
 * NEVRAX NEL is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2, or (at your option)
 * any later version.

 * NEVRAX NEL 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
 * General Public License for more details.

 * You should have received a copy of the GNU General Public License
 * along with NEVRAX NEL; see the file COPYING. If not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
 * MA 02111-1307, USA.
 */

#ifndef NL_PARTICLE_SYSTEM_H
#define NL_PARTICLE_SYSTEM_H

#include "nel/misc/types_nl.h"
#include "nel/misc/matrix.h"
#include "nel/misc/aabbox.h"
#include "nel/misc/smart_ptr.h"
#include "nel/misc/rgba.h"
#include "nel/misc/object_arena_allocator.h"
#include "nel/3d/animation_time.h"
#include "nel/3d/animation_time.h"
#include "nel/3d/animated_value.h"
#include "nel/3d/particle_system_process.h"
#include "nel/3d/ps_lod.h"
#include "nel/3d/ps_attrib_maker.h"
#include "nel/3d/ps_spawn_info.h"

#include <map>



namespace NL3D
{

class CParticleSystemShape;
class CParticleSystemModel;
class CPSLocated;
class CPSLocatedBindable;
class CFontGenerator;
class CFontManager;
class CPSCopyHelper;
class CScene;
class CPSLocated;
class IDriver;
struct UPSSoundServer;




const uint MaxPSUserParam = 4;


class CParticleSystem : public NLMISC::CRefCount
{
public:
    PS_FAST_OBJ_ALLOC
    // the pass that is applied on particles
    enum TPass { Anim, SolidRender, BlendRender, ToolRender };
public:
    //*****************************************************************************************************



            CParticleSystem();
            virtual ~CParticleSystem();
            void serial(NLMISC::IStream &f)  throw(NLMISC::EStream);
            bool merge(CParticleSystemShape *toMerge);

            /*** duplication method NOT SUPPORTED for now (duplication is using streams, but it may not last)
             * \param ch for private use, set to null by default
             */
            //  CParticleSystem *clone(CPSCopyHelper *ch = NULL) ;

    //*****************************************************************************************************



            void    enableSharing(bool enabled = true) { _Sharing = enabled; }

            bool    isSharingEnabled() const { return _Sharing; }

    //*****************************************************************************************************



        void setDriver(IDriver *driver) { _Driver = driver; }

        IDriver *getDriver(void) { return _Driver; }
    //*****************************************************************************************************



        void setScene(CScene *scene) { _Scene = scene; }

        CScene *getScene() const { return _Scene; }

    //*****************************************************************************************************



            void    hide(bool hidden) { _HiddenAtCurrentFrame = hidden; }
            void onShow(bool shown);
            void setSysMat(const NLMISC::CMatrix *m);

            void setUserMatrix(const NLMISC::CMatrix *m);

            const NLMISC::CMatrix &getSysMat() const
            {
                return _CoordSystemInfo.Matrix ? *_CoordSystemInfo.Matrix : NLMISC::CMatrix::Identity;
            }

            const NLMISC::CMatrix &getInvertedSysMat() const { return _CoordSystemInfo.InvMatrix; }

            const NLMISC::CMatrix &getUserMatrix() const
            {
                NL_PS_FUNC_MAIN(getUserMatrix)
                return (_UserCoordSystemInfo && _UserCoordSystemInfo->CoordSystemInfo.Matrix) ? *(_UserCoordSystemInfo->CoordSystemInfo.Matrix) : getSysMat();
            }

            const NLMISC::CMatrix &getInvertedUserMatrix() const { return (_UserCoordSystemInfo && _UserCoordSystemInfo->CoordSystemInfo.Matrix) ? _UserCoordSystemInfo->CoordSystemInfo.InvMatrix : getInvertedSysMat(); }

            // conversion matrix (from user matrix to fx matrix)
            const NLMISC::CMatrix &getUserToFXMatrix() const { return (_UserCoordSystemInfo && _UserCoordSystemInfo->CoordSystemInfo.Matrix) ? _UserCoordSystemInfo->UserBasisToFXBasis : NLMISC::CMatrix::Identity; }
            // conversion matrix (from fx matrix to user matrix)
            const NLMISC::CMatrix &getFXToUserMatrix() const { return (_UserCoordSystemInfo && _UserCoordSystemInfo->CoordSystemInfo.Matrix) ? _UserCoordSystemInfo->FXBasisToUserBasis : NLMISC::CMatrix::Identity; }

            void setViewMat(const NLMISC::CMatrix &m);

            const NLMISC::CMatrix &getViewMat(void) const { return _ViewMat; }

            const NLMISC::CMatrix &getInvertedViewMat(void) const { return _InvertedViewMat; }


    //*****************************************************************************************************



        virtual void step(TPass pass, TAnimationTime ellapsedTime, CParticleSystemShape &shape, CParticleSystemModel &model);



        static uint32 NbParticlesDrawn;

    //*****************************************************************************************************

        bool                        attach(CParticleSystemProcess *process);

        CParticleSystemProcess      *detach(uint index);

        bool                        isProcess(const CParticleSystemProcess *process) const;

        uint                        getIndexOf(const CParticleSystemProcess &process) const;

        void                        remove(CParticleSystemProcess *process);

        uint32                      getNbProcess(void) const { return _ProcessVect.size(); }

        CParticleSystemProcess      *getProcess(uint32 index)
        {
            nlassert(index < _ProcessVect.size());
            return _ProcessVect[index];
        }

        const CParticleSystemProcess *getProcess(uint32 index) const
        {
            nlassert(index < _ProcessVect.size());
            return _ProcessVect[index];
        }


    //*****************************************************************************************************



        TAnimationTime getSystemDate(void) const { return _SystemDate; }

        void setSystemDate(float date);

        uint64 getDate(void) const
        {
            NL_PS_FUNC_MAIN(getDate)
            return _Date;
        }

    //*****************************************************************************************************

        void setUserParam(uint userParamIndex, float value)
        {
            NL_PS_FUNC_MAIN(setUserParam)
            nlassert(userParamIndex < MaxPSUserParam);
            NLMISC::clamp(value, 0, MaxInputValue);
            _UserParam[userParamIndex] = value;
        }

        float getUserParam(uint userParamIndex) const
        {
            NL_PS_FUNC_MAIN(getUserParam)
            nlassert(userParamIndex < MaxPSUserParam);
            return _UserParam[userParamIndex];
        }

        void  bindGlobalValueToUserParam(const std::string &globalValueName, uint userParamIndex);
        // Get name of a global value, or NULL if no global value is bound to that user param
        std::string getGlobalValueName(uint userParamIndex) const;
        // Set a global value
        static void  setGlobalValue(const std::string &name, float value);
        // Get a global value
        static float getGlobalValue(const std::string &name);
        static void                  setGlobalVectorValue(const std::string &name, const NLMISC::CVector &value);
        // Get a global vector value
        static NLMISC::CVector       getGlobalVectorValue(const std::string &name);
        // define a handle to a global value
        class CGlobalVectorValueHandle
        {
        public:
            CGlobalVectorValueHandle() { reset(); }
            const NLMISC::CVector &get() const                       { nlassert(_Value); return *_Value; }
            void                   set(const NLMISC::CVector &value) { nlassert(_Value); *_Value = value; }
            const std::string     &getName() const                   { nlassert(_Name); return *_Name; }
            bool                   isValid() const { return _Name != NULL && _Value != NULL; }
            void                   reset() { _Name = NULL; _Value = NULL; }
        private:
            friend class CParticleSystem;
            const std::string *_Name;
            NLMISC::CVector   *_Value;
        };
        // Get a handle on a global value that provide a quick access on it (no map lookup)
        static CGlobalVectorValueHandle     getGlobalVectorValueHandle(const std::string &name);



    //*****************************************************************************************************

        // @{
         void setCurrentEditedElement(CPSLocated *loc = NULL , uint32 index = 0, class CPSLocatedBindable *bd = NULL )
         {
            NL_PS_FUNC_MAIN(setCurrentEditedElement)
            _CurrEditedElementLocated = loc;
            _CurrEditedElementLocatedBindable = bd;
            _CurrEditedElementIndex = index;
         }

         void getCurrentEditedElement(CPSLocated *&loc , uint32 &index, CPSLocatedBindable *&lb)
         {
            NL_PS_FUNC_MAIN(getCurrentEditedElement)
            loc = _CurrEditedElementLocated;
            index = _CurrEditedElementIndex;
            lb = _CurrEditedElementLocatedBindable;
         }

        void setFontGenerator(CFontGenerator *fg) { _FontGenerator = fg; }

        CFontGenerator *getFontGenerator(void) { return _FontGenerator; }

        const CFontGenerator *getFontGenerator(void) const { return _FontGenerator; }

        void setFontManager(CFontManager *fg) { _FontManager = fg; }

        CFontManager *getFontManager(void) { return _FontManager; }

        const CFontManager *getFontManager(void) const { return _FontManager; }
        // @}

        void setName(const std::string &s) { _Name = s; }

        std::string getName(void) const { return _Name; }

    //*****************************************************************************************************

    // @{
        bool hasOpaqueObjects(void) const;

        bool hasTransparentObjects(void) const;
    // @}

    //*****************************************************************************************************

    // @{
        bool hasLightableObjects() const;
    // @}

    //*****************************************************************************************************

    // @{
        void enableAccurateIntegration(bool enable = true) { _AccurateIntegration = enable; }
        bool isAccurateIntegrationEnabled(void) const { return _AccurateIntegration; }

        void setAccurateIntegrationParams(TAnimationTime threshold,
                                          uint32 maxNbIntegrations,
                                          bool canSlowDown,
                                          bool keepEllapsedTimeForLifeUpdate
                                         )
        {
            NL_PS_FUNC_MAIN(setAccurateIntegrationParams)
            _TimeThreshold = threshold;
            _MaxNbIntegrations = maxNbIntegrations;
            _CanSlowDown = canSlowDown;
            if (_KeepEllapsedTimeForLifeUpdate != keepEllapsedTimeForLifeUpdate)
            {
                _KeepEllapsedTimeForLifeUpdate = keepEllapsedTimeForLifeUpdate;
                _PresetBehaviour = UserBehaviour;
            }
        }

        void getAccurateIntegrationParams(TAnimationTime &threshold,
                                          uint32 &maxNbIntegrations,
                                          bool &canSlowDown,
                                          bool &keepEllapsedTimeForLifeUpdate
                                         )
        {
            NL_PS_FUNC_MAIN(getAccurateIntegrationParams)
            threshold = _TimeThreshold;
            maxNbIntegrations = _MaxNbIntegrations;
            canSlowDown = _CanSlowDown;
            keepEllapsedTimeForLifeUpdate = _KeepEllapsedTimeForLifeUpdate;
        }

        // get time thrhsold / integration time
        float getTimeTheshold() const { return _TimeThreshold; }
        uint  getMaxNbIntegrations() const { return _MaxNbIntegrations; }

        void    setBypassMaxNumIntegrationSteps(bool bypass = true)
        {
            NL_PS_FUNC_MAIN(setBypassMaxNumIntegrationSteps)
            if (_BypassIntegrationStepLimit != bypass)
            {
                if (bypass)
                {
                    if (!canFinish())
                    {
                        nlwarning("<CParticleSystem::setBypassMaxNumIntegrationSteps> Can't set flag to true. The system must have a finite duration");
                        nlassert(0); // the system can't stop!
                        return;
                    }
                }
                _BypassIntegrationStepLimit = bypass;
                _PresetBehaviour = UserBehaviour;
            }
        }
        bool    getBypassMaxNumIntegrationSteps() const { return _BypassIntegrationStepLimit; }

        bool canFinish(CPSLocatedBindable **lastingForeverObj = NULL) const;

        bool hasLoop(CPSLocatedBindable **loopingObj = NULL) const;


    // @}

    //*****************************************************************************************************

        // @{

        void setMaxViewDist(float maxDist)
        {
            NL_PS_FUNC_MAIN(setMaxViewDist)
            nlassert(maxDist > 0.f);
            _MaxViewDist = maxDist;
            _InvCurrentViewDist = _InvMaxViewDist = 1.f / maxDist;
        }

        float getMaxViewDist(void) const { return _MaxViewDist; }

        void setLODRatio(float ratio) { nlassert(ratio > 0 && ratio <= 1.f); _LODRatio =  ratio; }

        float getLODRatio(void) const  { return _LODRatio; }


        void getLODVect(NLMISC::CVector &v, float &offset, TPSMatrixMode matrixMode);

        TPSLod getLOD(void) const;

        float getOneMinusCurrentLODRatio(void) const { return _OneMinusCurrentLODRatio; }

        void    enableAutoLOD(bool enabled = true) { _AutoLOD = enabled; }

        bool    isAutoLODEnabled() const { return _AutoLOD; }

        void    setupAutoLOD(float startDistPercent, uint8 degradationExponent)
        {
            NL_PS_FUNC_MAIN(setupAutoLOD)
            nlassert(startDistPercent < 1.f);
            nlassert(degradationExponent > 0);
            _AutoLODStartDistPercent    =   startDistPercent;
            _AutoLODDegradationExponent =   degradationExponent;
        }

        void    setMaxDistLODBias(float lodBias);
        float   getMaxDistLODBias() const { return _MaxDistLODBias; }



        float   getAutoLODStartDistPercent() const { return _AutoLODStartDistPercent; }
        uint8   getAutoLODDegradationExponent() const { return _AutoLODDegradationExponent; }

        void    setAutoLODMode(bool skipParticles) { _AutoLODSkipParticles = skipParticles; }
        bool    getAutoLODMode() const { return _AutoLODSkipParticles; }

          void  setColorAttenuationScheme(CPSAttribMaker<NLMISC::CRGBA> *colScheme)
          {
            NL_PS_FUNC_MAIN(setColorAttenuationScheme)
            delete _ColorAttenuationScheme;
            _ColorAttenuationScheme = colScheme;
            if (!colScheme)
            {
                _GlobalColor = NLMISC::CRGBA::White;
            }
          }

          CPSAttribMaker<NLMISC::CRGBA> *getColorAttenuationScheme() { return _ColorAttenuationScheme; }
          const CPSAttribMaker<NLMISC::CRGBA> *getColorAttenuationScheme() const { return _ColorAttenuationScheme; }

          void              setUserColor(NLMISC::CRGBA userColor) { _UserColor = userColor; }
          NLMISC::CRGBA     getUserColor() const { return _UserColor; }

          // shortcut : test il global color is used (not white)
          bool              isUserColorUsed() const { return _UserColor != NLMISC::CRGBA::White; }

          NLMISC::CRGBA     getGlobalColor() const { return _GlobalColor; }
          NLMISC::CRGBA     getGlobalColorLighted() const { return _GlobalColorLighted; }
          // test if all objects should use global color lighting
          bool              getForceGlobalColorLightingFlag() { return _ForceGlobalColorLighting; }
          // force global color lighting
          void              setForceGlobalColorLightingFlag(bool enable) { _ForceGlobalColorLighting = enable; }
          // set lighting color (used by look at, and object that don't have normals)
          void              setLightingColor(NLMISC::CRGBA col) { _LightingColor = col; }
          NLMISC::CRGBA     getLightingColor() const { return _LightingColor; }
        // @}

    //*****************************************************************************************************

        // \name Load balancing
        // @{
            // get an evaluation of how many tris are needed with the system for the given distance
            float getWantedNumTris(float dist);

            void setNumTris(uint numFaces);

            //void notifyMaxNumFacesChanged(void);

            bool isLoadBalancingEnabled() const { return _EnableLoadBalancing; }

            void enableLoadBalancing(bool enabled = true);
        // @}

    //*****************************************************************************************************

        // @{
        void computeBBox(NLMISC::CAABBox &aabbox);

        void forceComputeBBox(NLMISC::CAABBox &aabbox);

        void setAutoComputeBBox(bool enable = true) { _ComputeBBox = enable; }


        bool getAutoComputeBBox(void) const { return _ComputeBBox; }


        void setPrecomputedBBox(const NLMISC::CAABBox &precompBBox)
        {
            NL_PS_FUNC_MAIN(setPrecomputedBBox)
            nlassert(!_ComputeBBox);
            _PreComputedBBox = precompBBox;
        }

        void getLastComputedBBox(NLMISC::CAABBox &dest) { dest = _PreComputedBBox; }
        // @}

    //*****************************************************************************************************

        // @{
        void                setDestroyModelWhenOutOfRange(bool enable = true)
        {
            NL_PS_FUNC_MAIN(setDestroyModelWhenOutOfRange)
            _DestroyModelWhenOutOfRange  = enable;
            _PresetBehaviour = UserBehaviour;
        }

        bool                getDestroyModelWhenOutOfRange(void) const { return _DestroyModelWhenOutOfRange; }


        enum TDieCondition { none, noMoreParticles, noMoreParticlesAndEmitters   };


        void                setDestroyCondition(TDieCondition dieCondition)
        {
            NL_PS_FUNC_MAIN(setDestroyCondition)
            _DieCondition = dieCondition;
            _PresetBehaviour = UserBehaviour;
        }

        // test if the destroy condition is currently verified
        bool                isDestroyConditionVerified() const;

        TDieCondition       getDestroyCondition(void) const { return _DieCondition; }

        void setDelayBeforeDeathConditionTest(TAnimationTime delay)
        {
            NL_PS_FUNC_MAIN(setDelayBeforeDeathConditionTest)

            _DelayBeforeDieTest  = delay;
        }

        void systemDurationChanged();

        TAnimationTime      getDelayBeforeDeathConditionTest() const;

        void                setAutoComputeDelayBeforeDeathConditionTest(bool computeAuto);
        bool                getAutoComputeDelayBeforeDeathConditionTest() const { return _AutoComputeDelayBeforeDeathTest; }

        void                destroyWhenOutOfFrustum(bool enable = true)
        {
            _DestroyWhenOutOfFrustum = enable;
            _PresetBehaviour = UserBehaviour;
        }

        bool                doesDestroyWhenOutOfFrustum(void) const { return _DestroyWhenOutOfFrustum; }


        bool                hasEmitters(void) const;

        bool                hasParticles() const;

        bool                hasTemporaryParticles() const;

        enum TAnimType
        {  AnimVisible = 0,   /* visible systems only are animated */
           AnimInCluster, /* systems that are in cluster are animated */
           AnimAlways,    /* animate always when not too far */
           LastValue
        };

        void                performMotionWhenOutOfFrustum(bool enable = true)
        {
            NL_PS_FUNC_MAIN(performMotionWhenOutOfFrustum)
            _AnimType = enable ? AnimInCluster : AnimVisible;
            _PresetBehaviour = UserBehaviour;
        }

        bool                doesPerformMotionWhenOutOfFrustum(void) const { return _AnimType == AnimInCluster; }

        void                setAnimType(TAnimType animType)
        {
            NL_PS_FUNC_MAIN(setAnimType)
            nlassert(animType < LastValue);
            _AnimType = animType;
            _PresetBehaviour = UserBehaviour;
        }

        TAnimType           getAnimType() const { return _AnimType; }

        enum TPresetBehaviour
        {
            EnvironmentFX = 0,    // environment FX, not animated when not visible, persistent.
            RunningEnvironmentFX, /* an environment fx that should
                                   * run when in parsed cluster : cascade for example,
                                   * so that it doesn't start when the player first see
                                   * it
                                   */
            SpellFX,              // always animated, not persistent, garanteed to match the good frame even if framerate is low
            LoopingSpellFX,       // alway animated, persistent until emitter are stopped
            MinorFX,              // animated when visible, discarded when not visible
            UserBehaviour,
            MovingLoopingFX,       // persistent, moving fx
            SpawnedEnvironmentFX,  // environment fx, not animated when not visible, not persistent
            GroundFX,              
            Projectile,            // like moving looping fx, but not persistent
            PresetLast
        };

        void activatePresetBehaviour(TPresetBehaviour behaviour);

        TPresetBehaviour getBehaviourType() const
        {
            NL_PS_FUNC_MAIN(getBehaviourType)
            return _PresetBehaviour;
        }




        // @}

    //*****************************************************************************************************
        // @{
        static void                 registerSoundServer(UPSSoundServer *soundServer);

        static UPSSoundServer *     getSoundServer(void)
        {
            NL_PS_FUNC(getSoundServer)
            return _SoundServer;
        }

        void stopSound();

        // reactivate all sound in this system
        void reactivateSound();

        // @}

    //*****************************************************************************************************
        // @{
            void registerLocatedBindableExternID(uint32 id, CPSLocatedBindable *lb);

            void unregisterLocatedBindableExternID(CPSLocatedBindable *lb);
        // @}

    //*****************************************************************************************************
        // @{
                uint               getNumLocatedBindableByExternID(uint32 id) const;
                CPSLocatedBindable       *getLocatedBindableByExternID(uint32 id, uint index);
                const CPSLocatedBindable *getLocatedBindableByExternID(uint32 id, uint index) const;
                uint   getNumID() const;
                uint32 getID(uint index) const;
                void getIDs(std::vector<uint32> &dest) const;
        // @}

    //*****************************************************************************************************
        // @{
                void enableEmitThreshold(bool enabled = true) { _EmitThreshold = enabled; }
                bool isEmitThresholdEnabled() const { return _EmitThreshold; }

            // activate // deactivate all emitters in the system
            void activateEmitters(bool active);
            // test is there are active emitters in the system
            bool hasActiveEmitters() const;
            // test if there are emitters in the system (e.g. derivers of CPSEmitter bound to the system)
            bool hasEmittersTemplates() const;
            float evalDuration() const;
            void setAutoCountFlag(bool enabled) { _AutoCount = enabled; }
            bool getAutoCountFlag() const { return _AutoCount; }
            void matchArraySize();
            // get max number of individual particles in the system
            uint getMaxNumParticles() const;
            // get current number of particles in the system
            uint getCurrNumParticles() const;
            // tool fct : get the list of located that target another located
            void getTargeters(const CPSLocated *target, std::vector<CPSTargetLocatedBindable *> &targeters);
            // allow to serialize identifiers. The default is false (to speedup instanciation of ps by not creating unecessary strings)
            static void setSerializeIdentifierFlag(bool on) { _SerialIdentifiers = on; }
            static bool getSerializeIdentifierFlag() { return _SerialIdentifiers; }
            // list all textures used by the ps, and append them in the given vector
            void enumTexs(std::vector<NLMISC::CSmartPtr<ITexture> > &dest, IDriver &drv);
            // Change z-bias of all materials. The z-bias value is given in world coordinates
            void setZBias(float value);
            // debug : force to display bbox of all particle systems
            static void forceDisplayBBox(bool on) { _ForceDisplayBBox = on; }
            void        getSortingByEmitterPrecedence(std::vector<uint> &result) const;
        // @}



private:
    typedef std::map<std::string, float> TGlobalValuesMap;
    typedef std::map<std::string, NLMISC::CVector> TGlobalVectorValuesMap;
private:
    friend class CParticleSystemModel;
    void                    stepLocated(TPSProcessPass pass);
    // update the lod & return the distance from viewer
    float                   updateLODRatio();
    float                   getDistFromViewer() const;
    void                    updateColor(float distFromViewer);
    void                    updateNumWantedTris();
    // update index of all the process
    void                    updateProcessIndices();
    // for debug only
    void                    checkIntegrity();
    // map that contain global value that can be affected to user param
    static TGlobalValuesMap       _GlobalValuesMap;
    // map that contain global vector values
    static TGlobalVectorValuesMap _GlobalVectorValuesMap;
    // A bbox that has been specified by the user
    NLMISC::CAABBox          _PreComputedBBox;
    // the driver used for rendering
    IDriver                  *_Driver;

    typedef CPSVector<CParticleSystemProcess *>::V TProcessVect;
    TProcessVect             _ProcessVect;
    CFontGenerator           *_FontGenerator;
    CFontManager             *_FontManager;

    // Infos about a coordinate system (current matrix, previous pos...)
    class CCoordSystemInfo
    {
    public:
        const NLMISC::CMatrix *Matrix;          // gives the matrix to use
        NLMISC::CMatrix        InvMatrix;       // inverted matrix for that coord system
        NLMISC::CVector        OldPos;          // translation part of matrix at previous frame
        NLMISC::CVector        CurrentDeltaPos; // current pos (for integration step) of the coord system relative to its final pos
    public:
        CCoordSystemInfo()
        {
            Matrix = NULL;
        }
    };


    class CUserCoordSystemInfo
    {
    public:
        CCoordSystemInfo    CoordSystemInfo;
        NLMISC::CMatrix     UserBasisToFXBasis; // conversion matrix : from user basis to FX Basis
        NLMISC::CMatrix     FXBasisToUserBasis; // conversion matrix : from FX basis to user Basis
        uint16              NumRef; // number of objects in the system that use position of the user matrix
                                    // because this is used rarely, we allocate memory to track the user matrix position only when needed
    public:
        CUserCoordSystemInfo()
        {
            NumRef = 0;
        }
    };

    CCoordSystemInfo           _CoordSystemInfo;                // coordinate system infos for this fx
    CUserCoordSystemInfo       *_UserCoordSystemInfo;           // coordinate system infos for an hypothetic user matrix






    // the view matrix (TODO : this is duplcated from CScene)
    NLMISC::CMatrix          _ViewMat;

    // the inverted view matrix (TODO : this is duplcated from CScene)
    NLMISC::CMatrix          _InvertedViewMat;


    // number of rendered pass on the system, incremented each time the system is redrawn
    uint64                   _Date;

    sint64                   _LastUpdateDate;

    // current edited element located (edition purpose only)
    CPSLocated               *_CurrEditedElementLocated;
    // current edited located bindable, NULL means all binadable of a located. (edition purpose only)
    CPSLocatedBindable       *_CurrEditedElementLocatedBindable;
    // current edited element index in its located (edition purpose only)
    uint32                   _CurrEditedElementIndex;


    CScene                  *_Scene;


    // contains the name of the system. (VERSION >= 2 only)
    std::string _Name;

    TAnimationTime                              _TimeThreshold;
    TAnimationTime                              _SystemDate;
    uint32                                      _MaxNbIntegrations;


    float                                       _LODRatio;
    float                                       _OneMinusCurrentLODRatio;
    float                                       _MaxViewDist;
    float                                       _MaxDistLODBias;
    float                                       _InvMaxViewDist;
    float                                       _InvCurrentViewDist; // inverse of the current view dist. It can be the same than _InvMaxViewDist
                                                                // but when there's LOD, the view distance may be reduced
    float                                       _AutoLODEmitRatio;

    TDieCondition                               _DieCondition;
    mutable TAnimationTime                      _DelayBeforeDieTest;
    uint                                        _NumWantedTris;
    TAnimType                                   _AnimType;

    static UPSSoundServer                      *_SoundServer;

    float                                       _UserParam[MaxPSUserParam];
    const TGlobalValuesMap::value_type          **_UserParamGlobalValue; // usually set to NULL unless some user params mirror a global value,
                                                                         // in this case this contains as many pointer into the global map as there are user params
    uint8                                       _BypassGlobalUserParam;  // mask to bypass a global user param. This state is not serialized

    TPresetBehaviour                            _PresetBehaviour;

    typedef
        CPSMultiMap<uint32, CPSLocatedBindable *>::M TLBMap;
    TLBMap                                          _LBMap;

    float                                       _AutoLODStartDistPercent;
    uint8                                       _AutoLODDegradationExponent;

    CPSAttribMaker<NLMISC::CRGBA>               *_ColorAttenuationScheme;
    NLMISC::CRGBA                               _GlobalColor;
    NLMISC::CRGBA                               _GlobalColorLighted;
    NLMISC::CRGBA                               _LightingColor;
    NLMISC::CRGBA                               _UserColor;

    bool                                        _ComputeBBox                         : 1;   
    bool                                        _BBoxTouched                         : 1;
    bool                                        _AccurateIntegration                 : 1;
    bool                                        _CanSlowDown                         : 1;
    bool                                        _DestroyModelWhenOutOfRange          : 1;
    bool                                        _DestroyWhenOutOfFrustum             : 1;
    bool                                        _Sharing                             : 1;
    bool                                        _AutoLOD                             : 1;
    bool                                        _KeepEllapsedTimeForLifeUpdate       : 1;
    bool                                        _AutoLODSkipParticles                : 1;
    bool                                        _EnableLoadBalancing                 : 1;
    bool                                        _EmitThreshold                       : 1;
    bool                                        _BypassIntegrationStepLimit          : 1;
    bool                                        _ForceGlobalColorLighting            : 1;
    bool                                        _AutoComputeDelayBeforeDeathTest     : 1;
    bool                                        _AutoCount                           : 1;
    bool                                        _HiddenAtCurrentFrame                : 1;
    bool                                        _HiddenAtPreviousFrame               : 1;

    static bool                                 _SerialIdentifiers;
    static bool                                 _ForceDisplayBBox;


    #ifdef NL_DEBUG
        static uint                                 _NumInstances;
    #endif
public:
    // For use by emitters only : This compute a delta of position of the fx matrix to ensure that spawning position are correct when the system moves
    void        interpolateFXPosDelta(NLMISC::CVector &dest, TAnimationTime deltaT);
    // For use by emitters only : This compute a delta of position of the user matrix to ensure that spawning position are correct when the system moves
    void        interpolateUserPosDelta(NLMISC::CVector &dest, TAnimationTime deltaT);
    // For use by emitters only : Get the current emit ratio when auto-LOD is used. Valid only during the 'Emit' pass
    float       getAutoLODEmitRatio() const { return _AutoLODEmitRatio; }
    // For private used by CPSLocated instances : should be called when the matrix mode of a located has changed
    void        matrixModeChanged(CParticleSystemProcess *proc, TPSMatrixMode oldMode, TPSMatrixMode newMode);
    // FOR PRIVATE USE : called when one more object of the system needs the _UserCoordSystemInfo field => so allocate it if needed.
    void        addRefForUserSysCoordInfo(uint numRefs = 1);
    // FOR PRIVATE USE : called when one less object of the system needs the _UserCoordSystemInfo field => deallocate it when there are no references left
    void        releaseRefForUserSysCoordInfo(uint numRefs = 1);
    // tmp for debug : dump hierarchy of fx
    void        dumpHierarchy();
public:
    // spawn info. They are shared by all PS ! This is because there can be only one PS processed at a time in the lib, so no need to store that per instance
    typedef std::vector<CPSSpawnInfo> TSpawnInfoVect;
    struct CSpawnVect : public NLMISC::CRefCount
    {
        TSpawnInfoVect SpawnInfos;
        uint           MaxNumSpawns;
    };
    static std::vector<NLMISC::CSmartPtr<CSpawnVect> > _Spawns; // for each process of the system (the array is ordered as CParticleSystem::_ProcessVect is) , store a list of particles to spawn. We can't spawn them directly,
                                                                // because ageing particle must be processed and removed first to make room
                                                                // for new particles and thus avoid a 'pulse' effect when framerate is low or when spawning is fast  (see the update loop CParticleSystem::step for details)
                                                                // NB : we use a smart pointer to avoid resize of a vector of vector, which is baaad...
                                                                // This is public but intended to be used by CPSLocated only.
    static std::vector<uint>                           _ParticleToRemove;           // used during the update step, contains the indices of the particles to remove
    static std::vector<sint>                           _ParticleRemoveListIndex;    // for each particle, -1 if it hasn't been removed, or else give the insertion number in _ParticleToRemove
    static std::vector<uint>                           _CollidingParticles; // index of particle that collided
    static std::vector<NLMISC::CVector>                _SpawnPos;           // spawn position of newly created particles
public:
    // current sim steps infos
    static TAnimationTime                               EllapsedTime;
    static TAnimationTime                               InverseTotalEllapsedTime;
    static TAnimationTime                               RealEllapsedTime;
    static float                                        RealEllapsedTimeRatio;
    static bool                                         InsideSimLoop;
    static bool                                         InsideRemoveLoop;
    static bool                                         InsideNewElementsLoop;
    static CParticleSystemModel                         *OwnerModel; // owner model for that system
};

// NOT USED FOR NOW
/*
class CPSCopyHelper
{
    public:
        // duplicate an object using the copy ctor, if it has not been before
        template <class T> T *ctorCopy(const T &src)
        {
            TCopiedIt it = _Alreadycopied.find(src);
            if (it  != _AlreadyCopied.end())
            {
                return (T *) it;
            }
            else
            {
                T *result = new T(src);
                _AlreadyCopied.insert((void *) result);
                return result;
            }
        }
        // duplicate an object using its clone method, if it has not been before

        template <class T> T *clone(const T &src)
        {
            TCopiedIt it = _AlreadyCopied.find(src);
            if (it  != _AlreadyCopied.end())
            {
                return (T *) *it;
            }
            else
            {
                T *result = src.clone(this);
                _AlreadyCopied.insert((void *) result);
                return result;
            }
        }


        // insert a value that has been copied by other means
        void insert(void *ptr)
        {
            std::pair<TCopiedIt, bool> result = _AlreadyCopied.insert(ptr);
            nlassert(result.second);
        }

    private:
        typedef std::set<void *> TAlreadyCopied;
        typedef TAlreadyCopied::iterator TCopiedIt;
        TAlreadyCopied _AlreadyCopied;
};

*/



} // NL3D


#endif // NL_PARTICLE_SYSTEM_H

/* End of particle_system.h */