Home

nevrax.com

Nevrax.org News Mailing-list Documentation CVS Bugs License

Documentation                       Search   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> #include "nel/misc/types_nl.h" #include "nel/misc/vector.h" #include "3d/particle_system_process.h" #include "3d/ps_attrib.h" // an attribute template container #include "3d/ps_lod.h" #include "nel/misc/stream.h" namespace NLMISC { class CAABBox; class CMatrix; } namespace NL3D { template <class T> class CPSAttribMaker; class CPSLocatedBindable; class CPSTargetLocatedBindable; class CPSZone; class CPSForce; class IDriver; class CFontManager; class CFontGenerator; class CScene; const uint32 DefaultMaxLocatedInstance = 1; // the default value for a located container struct CPSCollisionInfo { float TimeSliceRatio; // distance to the collisionner along the speed vector float dist; // new pos and speed, valid if a collision occured NLMISC::CVector newPos, newSpeed; CPSZone *collisionZone; CPSCollisionInfo() { reset(); } void reset(void) { dist = -1; TimeSliceRatio = 1.0f; } void serial(NLMISC::IStream &f) throw(NLMISC::EStream) { f.serialVersion(1); f.serial(dist, newPos, newSpeed); } }; typedef CPSAttrib<CPSCollisionInfo> TPSAttribCollisionInfo; class CPSLocated : public CParticleSystemProcess { public: CPSLocated(); virtual ~CPSLocated(); void 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 { 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]; } sint32 newElement(const NLMISC::CVector &pos = NLMISC::CVector::Null, const NLMISC::CVector &speed = NLMISC::CVector::Null, CPSLocated *emitterLocated = NULL, uint32 indexInEmitter = 0, bool basisConversionForSpeed = true, TAnimationTime ellapsedTime = 0.f); void deleteElement(uint32 index); CScene *getScene(void); void getLODVect(NLMISC::CVector &v, float &offset, bool systemBasis); 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; } void setLastForever(void) { _LastForever = true; } 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, TAnimationTime ellapsedTime, TAnimationTime realEt); uint32 getSize(void) const { return _Size; } uint32 getMaxSize(void) const { return _MaxSize; } void setFrameRate(uint32 nbFramesToSkip = 0) { _NbFramesToSkip = nbFramesToSkip; } // retrieve the frame rate uint32 getFrameRate(void) const { return _NbFramesToSkip; } 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 computeJ(void) const ; NLMISC::CVector computeK(void) const ; void queryCollisionInfo(void); void releaseCollisionInfo(void); bool hasCollisionInfos() const { return _CollisionInfo != NULL; } TPSAttribCollisionInfo &getCollisionInfo(void) { nlassert(_CollisionInfo); return *_CollisionInfo; } const TPSAttribCollisionInfo &getCollisionInfo(void) const { nlassert(_CollisionInfo); return *_CollisionInfo; } inline void collisionUpdate(const CPSCollisionInfo &ci, uint32 index); static const NLMISC::CMatrix &getConversionMatrix(const CPSLocated *A, const CPSLocated *B); 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 querryMaxWantedNumFaces(void); virtual void setSystemBasis(bool sysBasis = true); bool supportParametricMotion(void) const; void enableParametricMotion(bool enable = true); bool isParametricMotionEnabled(void) const { return _ParametricMotion;} virtual void performParametricMotion(TAnimationTime date, TAnimationTime ellapsedTime, TAnimationTime realEllapsedTime); virtual void updateLife(TAnimationTime ellapsedTime); void integrateSingle(float startDate, float deltaT, uint numStep, uint32 indexInLocated, NLMISC::CVector *destPos, uint posStride = sizeof(NLMISC::CVector)); 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; } protected: friend class CPSForce; // this is intended only for integrable forces that want to use // registerIntegrableForce, and removeIntegrableForce uint32 _MaxNumFaces; std::string _Name; // number of frame to skip between motion ... uint32 _NbFramesToSkip; // container of all object that are bound to a located typedef std::vector< CPSLocatedBindable *> TLocatedBoundCont; // the list of all located TLocatedBoundCont _LocatedBoundCont; // max number of instance in the container uint32 _MaxSize; // current number of instances in the container uint32 _Size; // = true if the located can't die (gravity for instance...) bool _LastForever; // 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: TPSAttribCollisionInfo *_CollisionInfo; // nb of users of the _CollisionInfo field uint32 _CollisionInfoNbRef; // 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; struct CPostNewElementRequestInfo { NLMISC::CVector _Pos; NLMISC::CVector _Speed; void serial(NLMISC::IStream &f) throw(NLMISC::EStream) { f.serial(_Pos, _Speed); } CPostNewElementRequestInfo(const NLMISC::CVector &pos = NLMISC::CVector::Null, const NLMISC::CVector &speed = NLMISC::CVector::Null) : _Pos(pos), _Speed(speed) {} }; typedef std::stack<CPostNewElementRequestInfo> TNewElementRequestStack; TNewElementRequestStack _RequestStack; void updateNewElementRequestStack(void); bool _UpdateLock; void postNewElement(const NLMISC::CVector &pos = NLMISC::CVector::Null , const NLMISC::CVector &speed = NLMISC::CVector::Null); void resetCollisionInfo(void); typedef std::vector<CPSLocatedBindable *> TDtorObserversVect; TDtorObserversVect _DtorObserversVect; bool _LODDegradation; uint16 _NonIntegrableForceNbRefs; uint16 _NumIntegrableForceWithDifferentBasis; typedef std::vector<CPSForce *> TForceVect; TForceVect _IntegrableForces; bool _TriggerOnDeath; uint32 _TriggerID; bool _ParametricMotion; void allocateParametricInfos(void); void releaseParametricInfos(void); void notifyMotionTypeChanged(void); public: void registerIntegrableForce(CPSForce *f); void unregisterIntegrableForce(CPSForce *f); void integrableForceBasisChanged(bool basis); void addNonIntegrableForceRef(void); void releaseNonIntegrableForceRef(void); TPSAttribParametricInfo &getParametricInfos() { return _PInfo; } }; // IMPLEMENTATION OF INLINE METHODS // inline void CPSLocated::collisionUpdate(const CPSCollisionInfo &ci, uint32 index) { nlassert(_CollisionInfo); CPSCollisionInfo &firstCi = (*_CollisionInfo)[index]; if (firstCi.dist == -1 || ci.dist < firstCi.dist) { firstCi = ci; } } //****************************************************************************************** //****************************************************************************************** //****************************************************************************************** // bindable types are not encoded as an enum in order to provide // easy extensibility 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: 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, TAnimationTime ellapsedTime, TAnimationTime realEt) = 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 &getInvertedSysMat(void) const; const NLMISC::CMatrix &getLocatedMat(void) const; const NLMISC::CMatrix &getInvertedLocatedMat(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(); } inline NLMISC::CVector computeJ(void) const { return _Owner->computeJ(); } inline NLMISC::CVector computeK(void) const { return _Owner->computeK(); } 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(bool systemBasis) {} virtual void motionTypeChanged(bool parametric) {} protected: friend class CPSLocated; virtual void newElement(CPSLocated *emitterLocated, uint32 emitterIndex) = 0; virtual void deleteElement(uint32 index) = 0; virtual void resize(uint32 size) = 0; virtual void bounceOccured(uint32 index) {} 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 }; 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: virtual void notifyTargetRemoved(CPSLocated *ptr); typedef std::vector<CPSLocated *> TTargetCont; TTargetCont _Targets; }; } // NL3D #endif // NL_PARTICLE_SYSTEM_LOCATED_H /* End of particle_system_located.h */