ps_located.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_LOCATED_H
#define NL_PARTICLE_SYSTEM_LOCATED_H

#include <stack>

namespace NL3D
{
const uint32 DefaultMaxLocatedInstance = 1; // the default value for a located container
}

#include "nel/misc/types_nl.h"
#include "nel/misc/vector.h"
#include "nel/3d/particle_system_process.h"
#include "nel/3d/ps_attrib.h" // an attribute template container
#include "nel/3d/ps_lod.h"
#include "nel/3d/ps_spawn_info.h"
#include "nel/misc/stream.h"
//
#include "nel/misc/object_arena_allocator.h"

namespace NLMISC
{
    class CAABBox;
    class CMatrix;
    class CVector;
}






namespace NL3D
{



template <class T> class CPSAttribMaker;


class CPSLocatedBindable;
class CPSTargetLocatedBindable;
class CPSZone;
class CPSForce;
class IDriver;
class CFontManager;
class CFontGenerator;
class CScene;
class CParticleSystem;


struct CPSCollisionInfo
{
    CPSCollisionInfo *Next;
    float             Dist;           // Distance to the nearest collider, or -1 if not collision occured
    NLMISC::CVector   NewPos;
    NLMISC::CVector   NewSpeed;       // The speed of particle after a collision occured. After the updated of collision it is swapped with the post-collision speed
    CPSZone           *CollisionZone; // The zone on which the bounce occured, can be useful to check the behaviour in case of collision
    uint32            Index;
    CPSCollisionInfo()
    {
        Dist = -1.f;
    }
    // update the collision info, and eventually link it in the list of active collisions
    void update(const CPSCollisionInfo &other);
};


class CPSLocated : public CParticleSystemProcess
{
public:
    PS_FAST_OBJ_ALLOC
    CPSLocated();

    virtual ~CPSLocated();

    // from CParticleSystemProcess
    virtual bool isLocated() const { NL_PS_FUNC(isLocated); return true; }

    bool bind(CPSLocatedBindable *lb);

    CPSLocatedBindable *unbind(uint index);

    bool isBound(const CPSLocatedBindable *lb) const;

    uint getIndexOf(const CPSLocatedBindable *lb) const;

    void remove(const CPSLocatedBindable *lb);

    virtual void             releaseRefTo(const CParticleSystemProcess *other);

    virtual void             releaseAllRef();


    uint32 getNbBoundObjects(void) const { NL_PS_FUNC(getNbBoundObjects); return _LocatedBoundCont.size(); }

    const CPSLocatedBindable *getBoundObject(uint32 index) const
    {
        nlassert(index < _LocatedBoundCont.size());
        return _LocatedBoundCont[index];
    }


    CPSLocatedBindable *getBoundObject(uint32 index)
    {
        nlassert(index < _LocatedBoundCont.size());
        return _LocatedBoundCont[index];
    }


    void postNewElement(const NLMISC::CVector &pos,
                         const NLMISC::CVector &speed,
                         CPSLocated &emitterLocated,
                         uint32 indexInEmitter,
                         TPSMatrixMode speedCoordSystem,
                         TAnimationTime lifeTime);

    sint32 newElement(const NLMISC::CVector &pos,
                      const NLMISC::CVector &speed,
                      CPSLocated *emitterLocated,
                      uint32 indexInEmitter,
                      TPSMatrixMode speedCoordSystem,
                      bool doEmitOnce = false
                     );


    void deleteElement(uint32 index);

    // get the age of an element in seconds
    inline TAnimationTime getAgeInSeconds(uint elementIndex) const;

    CScene *getScene(void);

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


    void incrementNbDrawnParticles(uint num);


    uint32 getNewElementIndex(void) const { return _Size; }


    bool computeBBox(NLMISC::CAABBox &aabbox) const;



    void setInitialLife(TAnimationTime lifeTime);

    void setLifeScheme(CPSAttribMaker<float> *scheme);

    TAnimationTime getInitialLife(void) const { return _InitialLife; }

    CPSAttribMaker<float> *getLifeScheme(void) { return _LifeScheme; }
    const CPSAttribMaker<float> *getLifeScheme(void) const { return _LifeScheme; }


    void setInitialMass(float mass);

    void  setMassScheme(CPSAttribMaker<float> *scheme);

    float getInitialMass(void) const { return _InitialMass; }

    CPSAttribMaker<float> *getMassScheme(void) { return _MassScheme; }
    const CPSAttribMaker<float> *getMassScheme(void) const { return _MassScheme; }



    bool setLastForever();
    bool getLastForever(void) const { return _LastForever; }

    TPSAttribFloat &getInvMass(void) { return _InvMass; }
    const TPSAttribFloat &getInvMass(void) const { return _InvMass; }

    TPSAttribVector &getPos(void) { return _Pos; }
    const TPSAttribVector &getPos(void) const { return _Pos; }

    TPSAttribVector &getSpeed(void) { return _Speed; }
    const TPSAttribVector &getSpeed(void) const { return _Speed; }

    TPSAttribTime &getTime(void) { return _Time; }
    const TPSAttribTime &getTime(void) const { return _Time; }

    TPSAttribTime &getTimeIncrement(void) { return _TimeIncrement; }
    const TPSAttribTime &getTimeIncrement(void) const { return _TimeIncrement; }

    virtual void step(TPSProcessPass pass);

    // move and collides particles (with previously computed collisions)
    void computeMotion();
    //move and collide particles that have been newly spawned
    void computeNewParticleMotion(uint firstInstanceIndex);
    // Update position and speed of particles after collisions
    void updateCollisions();

    uint32 getSize(void) const
    {
        return _Size;
    }

    uint32 getMaxSize(void) const
    {
        NL_PS_FUNC(getMaxSize)
        return _MaxSize;
    }


    void resize(uint32 newSize);

    void serial(NLMISC::IStream &f) throw(NLMISC::EStream);

    IDriver *getDriver() const;

    float getUserParam(uint numParam) const;



    NLMISC_DECLARE_CLASS(CPSLocated);

    void setupDriverModelMatrix(void);

    NLMISC::CVector computeI(void) const;
    NLMISC::CVector computeIWithZAxisAligned(void)  const;

    NLMISC::CVector computeJ(void) const;

    NLMISC::CVector computeK(void) const;
    NLMISC::CVector computeKWithZAxisAligned(void)  const;

    void queryCollisionInfo(void);


    void releaseCollisionInfo(void);

    bool hasCollisionInfos() const { return _CollisionNextPos != NULL; }

    // Compute spawns. Should be called only inside the sim loop.
    void computeSpawns(uint firstInstanceIndex, bool includeEmitOnce);

    // Compute forces that apply on that located. Should be called only inside the sim loop.
    void computeForces();

    // compute collisions
    void computeCollisions(uint firstInstanceIndex, const NLMISC::CVector *posBefore, const NLMISC::CVector *posAfter);

    // get a conversion matrix between 2 matrix modes
    static const NLMISC::CMatrix &getConversionMatrix(const CParticleSystem &ps, TPSMatrixMode to, TPSMatrixMode from);

    static const NLMISC::CMatrix &getConversionMatrix(const CPSLocated *A, const CPSLocated *B);


    const NLMISC::CMatrix &getLocalToWorldMatrix() const;

    const NLMISC::CMatrix &getWorldToLocalMatrix() const;


    void registerDtorObserver(CPSLocatedBindable *observer);


    void unregisterDtorObserver(CPSLocatedBindable *anObserver);



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

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


    virtual bool hasParticles(void) const;

    virtual bool hasEmitters(void) const;

    void forceLODDegradation(bool enable = true) { _LODDegradation = enable; }

    bool hasLODDegradation(void) const { return _LODDegradation; }


    //void notifyMaxNumFacesChanged(void);

    virtual uint getNumWantedTris() const;

    // Inherited from CParticlesystemProcess. Change the coord system for thta system.
    virtual void setMatrixMode(TPSMatrixMode matrixMode);

    bool         supportParametricMotion(void) const;

    void         enableParametricMotion(bool enable = true);

    bool         isParametricMotionEnabled(void) const { return _ParametricMotion;}

    virtual void performParametricMotion(TAnimationTime date);

    void updateLife();
    void removeOldParticles();
    void addNewlySpawnedParticles();


    void integrateSingle(float startDate, float deltaT, uint numStep,
                         uint32 indexInLocated,
                         NLMISC::CVector *destPos,
                         uint posStride = sizeof(NLMISC::CVector)) const;

    // compute position for a single element at the given date
    // NB : only works with object that have parametric trajectories
    inline void computeParametricPos(float date, uint indexInLocated, NLMISC::CVector &dest) const;


    void                enableTriggerOnDeath(bool enable = true) { _TriggerOnDeath = enable; }

    bool                isTriggerOnDeathEnabled(void) const { return _TriggerOnDeath; }

    void                setTriggerEmitterID(uint32 id)
    {
        nlassert(_TriggerOnDeath);
        _TriggerID = id;
    }

    uint32              getTriggerEmitterID(void) const
    {
        nlassert(_TriggerOnDeath);
        return _TriggerID;
    }

    float               evalMaxDuration() const;

    // from CParticleSystemProcess
     virtual uint   getUserMatrixUsageCount() const;

     // from CParticleSystemProcess
     virtual void enumTexs(std::vector<NLMISC::CSmartPtr<ITexture> > &dest, IDriver &drv);

     // from CParticleSystemProcess
     virtual void setZBias(float value);


    // For debug only, check if particles life is in the range [0, 1]
     void   checkLife() const;


     // from CParticleSystemProcess
     virtual void onShow(bool shown);

protected:


    friend class CPSForce; // this is intended only for integrable forces that want to use
                           // registerIntegrableForce, and removeIntegrableForce
    //uint32                    _MaxNumFaces;
    // Current number of instances in the container
    uint32                  _Size;
    // Max number of instance in the container
    uint32                  _MaxSize;
    // Nb of collisions zones that reference that object
    uint32                  _CollisionInfoNbRef;
    // Keep vector of next positions during sim step (to avoid a copy after position have been computed). Used only if there are collisions
    TPSAttribVector         *_CollisionNextPos;
    // The life to use, or a scheme that generate it
    // if the scheme if NULL, initial life is used instead
    float                   _InitialLife;
    CPSAttribMaker<float>   *_LifeScheme;
    // The mass to use, or a scheme that generate it
    // if the scheme if null, initial mass is used instead
    float                   _InitialMass;
    CPSAttribMaker<float>   *_MassScheme;
    bool                     _LODDegradation   : 1; // True when LOD degradation apply to this located
    bool                     _ParametricMotion : 1; // When set to true, this tells the system to use parametric motion. Only parametric forces must have been applied.
    bool                     _TriggerOnDeath   : 1;  // When set to true, then when any particle is destroyed, all particles with ID '_TriggerID' will be destroyed too
    bool                     _LastForever      : 1;  // True if the located can't die.
    uint32                   _TriggerID;
    uint16                  _NonIntegrableForceNbRefs;
    uint16                  _NumIntegrableForceWithDifferentBasis;
    // Name of located
    std::string             _Name;
    // Container of all object that are bound to a located
    typedef CPSVector<CPSLocatedBindable *>::V TLocatedBoundCont;
    // The list of all located
    TLocatedBoundCont       _LocatedBoundCont;
    // Needed atributes for a located
    // a container of masses. the inverse for mass are used in order to speed up forces computation
    TPSAttribFloat          _InvMass;
    TPSAttribVector         _Pos;
    TPSAttribVector         _Speed;
    TPSAttribTime           _Time;
    TPSAttribTime           _TimeIncrement;
public:

    struct CParametricInfo
    {
        CParametricInfo() {}
        CParametricInfo(NLMISC::CVector pos, NLMISC::CVector speed, float date)
            : Pos(pos), Speed(speed), Date(date)
        {
        }
        NLMISC::CVector Pos;   // the inital pos of emission
        NLMISC::CVector Speed; // the inital direction of emission
        TAnimationTime  Date;  // the initial date of emission
    };

    typedef CPSAttrib<CParametricInfo> TPSAttribParametricInfo;

    CPSAttrib<CParametricInfo>  _PInfo;

protected:
    typedef CPSVector<CPSLocatedBindable *>::V          TDtorObserversVect;
    TDtorObserversVect                                  _DtorObserversVect;
    // a vector of integrable forces that apply on this located
    typedef CPSVector<CPSForce *>::V                    TForceVect;
    TForceVect                                          _IntegrableForces;
    void allocateParametricInfos(void);

    void releaseParametricInfos(void);

    void notifyMotionTypeChanged(void);

    // for debug : check that system integrity is ok, otherwise -> assert
    void checkIntegrity() const;

public:
     void registerIntegrableForce(CPSForce *f);

     void unregisterIntegrableForce(CPSForce *f);

     void integrableForceBasisChanged(TPSMatrixMode basis);

     void addNonIntegrableForceRef(void);

     void releaseNonIntegrableForceRef(void);

     TPSAttribParametricInfo &getParametricInfos() { return _PInfo; }

     virtual void   systemDateChanged();

     // PRIVATE USE :reset collisions
    void resetCollisions(uint numInstances);

    void doLODDegradation();

private:
    // Special version for deleteElement, should be only called during the update loop.
    // If gives the amount of time that will ellapse until the end of the simulation step, so that,
    // if a particle is emitted 'On death' of its emitter, it will have a correct pos at the next simultion step
    void deleteElement(uint32 index, TAnimationTime timeUntilNextSimStep);
    // Delete basic info for an element. Called by both versions of deleteElement
    void deleteElementBase(uint32 index);
    // compute time from the collision to the next sim step
    TAnimationTime computeDateFromCollisionToNextSimStep(uint particleIndex, float particleAgeInSeconds);
    // create a new element
    sint32   newElement(const CPSSpawnInfo &si, bool doEmitOnce, TAnimationTime ellapsedTime);
public:
    static CPSCollisionInfo              *_FirstCollision;
    // collisions infos, made public to access by collision zones
    static std::vector<CPSCollisionInfo> _Collisions;
};



// IMPLEMENTATION OF INLINE METHODS  //


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



// kind of bindable objects

const uint32 PSForce = 0;
const uint32 PSParticle = 1;
const uint32 PSEmitter = 2;
const uint32 PSLight = 3;
const uint32 PSZone  = 4;
const uint32 PSSound = 5;


class CPSLocatedBindable : public NLMISC::IStreamable
{
public:
    PS_FAST_OBJ_ALLOC


        CPSLocatedBindable();
        virtual void        serial(NLMISC::IStream &f) throw(NLMISC::EStream);
        virtual void        finalize(void);
        virtual ~CPSLocatedBindable();

        void                    setActive(bool active) { _Active = active; }
        bool                    isActive() const { return _Active; }
    virtual uint32          getType(void) const = 0;
    virtual uint32          getPriority(void) const = 0;
    virtual void            step(TPSProcessPass pass) = 0;
    virtual void            notifyTargetRemoved(CPSLocated *ptr);

    virtual void             releaseRefTo(const CParticleSystemProcess * /* other */) {}

    virtual void             releaseAllRef();
    /***
    * The following is used to complete an aabbox that was computed using the located positions
    * You may not need to do anything with that, unless your bindable has a space extents. For exAmple,
    * with a particle which has a radius of 2, you must enlarge the bbox to get the correct one.
    * The default behaviour does nothing
    * \return true if you modified the bbox
    */
    virtual bool            completeBBox(NLMISC::CAABBox &/* box */) const  { return false;}
    /***
     * Override the following to say that you don't want to be part of a bbox computation
     */
    virtual bool            doesProduceBBox(void) const { return true; }
     IDriver                *getDriver() const
     {
         nlassert(_Owner);
         nlassert(_Owner->getDriver());
         return _Owner->getDriver();
     }
     CFontGenerator         *getFontGenerator(void)
     {
        nlassert(_Owner);
        return _Owner->getFontGenerator();
     }

     const CFontGenerator   *getFontGenerator(void) const
     {
        nlassert(_Owner);
        return _Owner->getFontGenerator();
     }

    CFontManager            *getFontManager(void);

    const CFontManager      *getFontManager(void) const;

    const NLMISC::CMatrix   &getSysMat(void) const;
    const NLMISC::CMatrix   &getLocalToWorldMatrix() const;
    const NLMISC::CMatrix   &getInvertedSysMat(void) const;
    const NLMISC::CMatrix   &getViewMat(void) const;
    const NLMISC::CMatrix   &getInvertedViewMat(void) const;
    void                    setupDriverModelMatrix(void);
    inline NLMISC::CVector  computeI(void)  const { return _Owner->computeI(); }
    // Same version, but with Z-Axis aligned on world z-axis
    inline NLMISC::CVector  computeIWithZAxisAligned(void)  const { return _Owner->computeIWithZAxisAligned(); }
    inline NLMISC::CVector  computeJ(void)  const { return _Owner->computeJ(); }
     inline NLMISC::CVector computeK(void)  const { return _Owner->computeK(); }
     inline NLMISC::CVector computeKWithZAxisAligned(void)  const { return _Owner->computeKWithZAxisAligned(); }
     CPSLocated             *getOwner(void) { return _Owner; }
     const CPSLocated       *getOwner(void) const { return _Owner; }
     void                   setName(const std::string &name) { _Name = name; }
    std::string             getName(void) const { return _Name; }
    void                    setLOD(TPSLod lod) { _LOD = lod; }
    TPSLod                  getLOD(void) const { return _LOD; }
    virtual bool            hasParticles(void) const { return false; }
    virtual bool            hasEmitters(void) const { return false; }
    void                    setExternID(uint32 id);
    uint32                  getExternID(void) const { return _ExternID; }
    virtual void            basisChanged(TPSMatrixMode /* systemBasis */) {}

    virtual void            motionTypeChanged(bool /* parametric */) {}

    // returns the number of sub-objects (including this one, that requires the user matrix for its computations)
    virtual bool            getUserMatrixUsageCount() const { return 0; }

    // enum tex used by the object, and append them to dest
    virtual void            enumTexs(std::vector<NLMISC::CSmartPtr<ITexture> > &/* dest */, IDriver &/* drv */) {}

    // change z-bias in material (default does nothing)
    virtual void            setZBias(float /* value */) {}


    // called when the show / hide flag has been changed
    virtual void onShow(bool /* shown */) {}


protected:
    friend class CPSLocated;

    virtual void newElement(const CPSEmitterInfo &info) = 0;


    // Delete element at the given index
    virtual void deleteElement(uint32 index) = 0;
    // Delete element at the given index. Gives the remaining time until the next sim loop
    virtual void deleteElement(uint32 index, TAnimationTime /* timeUntilNextSimStep */) { deleteElement(index); }

    virtual void resize(uint32 size) = 0;

    virtual void bounceOccured(uint32 /* index */, TAnimationTime /* timeToNextsimStep */) {}

    void displayIcon2d(const NLMISC::CVector tab[], uint nbSegs, float scale);


    virtual void setOwner(CPSLocated *psl);

protected:
    CPSLocated  *_Owner;
    uint32      _ExternID;
    TPSLod      _LOD;
    // Name for this bindable
    std::string _Name;
    //
    bool        _Active; // Say if this bindable is active. If not active, the owning system won't try to call 'step' on that object. True by default
public:
    virtual void            systemDateChanged() {}
};




inline bool operator<(const CPSLocatedBindable &lhs, const CPSLocatedBindable &rhs)
{
    return rhs.getPriority() > lhs.getPriority();
}



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


class CPSTargetLocatedBindable : public CPSLocatedBindable
{
public:
    virtual void        attachTarget(CPSLocated *ptr);
    void                detachTarget(CPSLocated *ptr)
    {
        notifyTargetRemoved(ptr);
    }
    virtual void             releaseRefTo(const CParticleSystemProcess *other);
    virtual void             releaseAllRef();
    uint32              getNbTargets(void) const { return _Targets.size(); }
    CPSLocated          *getTarget(uint32 index)
    {
        nlassert(index < _Targets.size());
        return _Targets[index];
    }
    const CPSLocated    *getTarget(uint32 index) const
    {
        nlassert(index < _Targets.size());
        return _Targets[index];
    }
    virtual void        releaseTargetRsc(CPSLocated * /* target */) {}
    void                serial(NLMISC::IStream &f) throw(NLMISC::EStream);
    virtual void        finalize(void);
    virtual             ~CPSTargetLocatedBindable();
protected:
    friend class CPSLocated;
    virtual void        notifyTargetRemoved(CPSLocated *ptr);
    typedef CPSVector<CPSLocated *>::V TTargetCont;
    TTargetCont _Targets;

};


// INLINES //

//*****************************************************************************************************
inline const NLMISC::CMatrix &CPSLocated::getConversionMatrix(const CPSLocated *A,const CPSLocated *B)
{
    nlassert(A);
    nlassert(B);
    nlassert(A->_Owner == B->_Owner); // conversion must be made between entity of the same system
    const CParticleSystem *ps = A->_Owner;
    nlassert(ps);
    return getConversionMatrix(*ps, A->getMatrixMode(), B->getMatrixMode());
}

//*****************************************************************************************************
inline TAnimationTime   CPSLocated::getAgeInSeconds(uint elementIndex) const
{
    nlassert(elementIndex < _Size);
    if (_LastForever) return _Time[elementIndex];
    if (_LifeScheme) return _Time[elementIndex] / _TimeIncrement[elementIndex];
    return _Time[elementIndex] * _InitialLife;
}

//*****************************************************************************************************
inline void CPSLocated::computeParametricPos(float date, uint indexInLocated, NLMISC::CVector &dest) const
{
    integrateSingle(date, 1.f, 1, indexInLocated, &dest);
}


//*****************************************************************************************************
inline const NLMISC::CMatrix &CPSLocatedBindable::getLocalToWorldMatrix() const
{
    nlassert(_Owner);
    return _Owner->getLocalToWorldMatrix();
}

} // NL3D


#endif // NL_PARTICLE_SYSTEM_LOCATED_H

/* End of particle_system_located.h */