Home

nevrax.com

Nevrax.org News Mailing-list Documentation CVS Bugs License

Documentation                       Search   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/3d/animation_time.h" #include "3d/mot.h" #include "3d/animated_value.h" #include "3d/particle_system_process.h" #include "3d/ps_lod.h" #include "3d/ps_attrib_maker.h" #include <map> namespace NL3D { class CParticleSystemShape; 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: // 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); void 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(void) { return _Scene; } //***************************************************************************************************** void setSysMat(const NLMISC::CMatrix &m); const NLMISC::CMatrix &getSysMat(void) const { return _SysMat; } const NLMISC::CMatrix &getOldSysMat(void) const { return _SysMat; } const NLMISC::CMatrix &getInvertedSysMat(void) const { return _InvSysMat; } 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); static uint32 NbParticlesDrawn; //***************************************************************************************************** void attach(CParticleSystemProcess *process); CParticleSystemProcess *detach(uint index); bool isProcess(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; } uint64 getDate(void) const { return _Date; } //***************************************************************************************************** void setUserParam(uint userParamIndex, float value) { nlassert(userParamIndex < MaxPSUserParam); NLMISC::clamp(value, 0, MaxInputValue); _UserParam[userParamIndex] = value; } float getUserParam(uint userParamIndex) const { 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 ) { _CurrEditedElementLocated = loc; _CurrEditedElementLocatedBindable = bd; _CurrEditedElementIndex = index; } void getCurrentEditedElement(CPSLocated *&loc , uint32 &index, CPSLocatedBindable *&lb) { 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; // @} //***************************************************************************************************** // @{ void enableAccurateIntegration(bool enable = true) { _AccurateIntegration = enable; } bool isAccurateIntegrationEnabled(void) const { return _AccurateIntegration; } void setAccurateIntegrationParams(TAnimationTime threshold, uint32 maxNbIntegrations, bool canSlowDown, bool keepEllapsedTimeForLifeUpdate ) { _TimeThreshold = threshold; _MaxNbIntegrations = maxNbIntegrations; _CanSlowDown = canSlowDown; _KeepEllapsedTimeForLifeUpdate = keepEllapsedTimeForLifeUpdate; } void getAccurateIntegrationParams(TAnimationTime &threshold, uint32 &maxNbIntegrations, bool &canSlowDown, bool &keepEllapsedTimeForLifeUpdate ) { threshold = _TimeThreshold ; maxNbIntegrations = _MaxNbIntegrations; canSlowDown = _CanSlowDown; keepEllapsedTimeForLifeUpdate = _KeepEllapsedTimeForLifeUpdate; } // @} //***************************************************************************************************** // @{ void setMaxViewDist(float maxDist) { 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, bool systemBasis); 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) { nlassert(startDistPercent < 1.f); nlassert(degradationExponent > 0); _AutoLODStartDistPercent = startDistPercent; _AutoLODDegradationExponent = degradationExponent; } 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) { delete _ColorAttenuationScheme; _ColorAttenuationScheme = colScheme; if (!colScheme) { _GlobalColor = NLMISC::CRGBA::White; } } CPSAttribMaker<NLMISC::CRGBA> *getColorAttenuationScheme() { return _ColorAttenuationScheme; } const CPSAttribMaker<NLMISC::CRGBA> *getColorAttenuationScheme() const { return _ColorAttenuationScheme; } const NLMISC::CRGBA &getGlobalColor() const { return _GlobalColor; } // @} //***************************************************************************************************** // \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 setAutoComputeBBox(bool enable = true) { _ComputeBBox = enable; } bool getAutoComputeBBox(void) const { return _ComputeBBox; } void setPrecomputedBBox(const NLMISC::CAABBox &precompBBox) { nlassert(!_ComputeBBox); _PreComputedBBox = precompBBox; } void getLastComputedBBox(NLMISC::CAABBox &dest) { dest = _PreComputedBBox; } // @} //***************************************************************************************************** // @{ void setDestroyModelWhenOutOfRange(bool enable = true) { _DestroyModelWhenOutOfRange = enable; _PresetBehaviour = UserBehaviour; } bool getDestroyModelWhenOutOfRange(void) const { return _DestroyModelWhenOutOfRange; } enum TDieCondition { none, noMoreParticles, noMoreParticlesAndEmitters }; void setDestroyCondition(TDieCondition dieCondition) { _DieCondition = dieCondition; _PresetBehaviour = UserBehaviour; } TDieCondition getDestroyCondition(void) const { return _DieCondition; } void setDelayBeforeDeathConditionTest(TAnimationTime delay) { _DelayBeforeDieTest = delay; } TAnimationTime getDelayBeforeDeathConditionTest(void) const { return _DelayBeforeDieTest; } void destroyWhenOutOfFrustum(bool enable = true) { _DestroyWhenOutOfFrustum = enable; _PresetBehaviour = UserBehaviour; } bool doesDestroyWhenOutOfFrustum(void) const { return _DestroyWhenOutOfFrustum; } bool hasEmitters(void) const; bool hasParticles(void) 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) { _AnimType = enable ? AnimInCluster : AnimVisible; _PresetBehaviour = UserBehaviour; } bool doesPerformMotionWhenOutOfFrustum(void) const { return _AnimType == AnimInCluster; } void setAnimType(TAnimType animType) { nlassert(animType < LastValue); _AnimType = animType; _PresetBehaviour = UserBehaviour; } TAnimType getAnimType() const { return _AnimType; } enum TPresetBehaviour { EnvironmentFX = 0, 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, LoopingSpellFX, MinorFX, UserBehaviour, PresetLast }; void activatePresetBehaviour(TPresetBehaviour behaviour); TPresetBehaviour getBehaviourType() const { return _PresetBehaviour; } // @} //***************************************************************************************************** // @{ static void registerSoundServer(UPSSoundServer *soundServer) { _SoundServer = soundServer; } static UPSSoundServer * getSoundServer(void) { return _SoundServer; } void stopSound(); 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; // @} private: typedef std::map<std::string, float> TGlobalValuesMap; typedef std::map<std::string, NLMISC::CVector> TGlobalVectorValuesMap; private: friend class CParticleSystemDetailObs; void stepLocated(TPSProcessPass pass, TAnimationTime et, TAnimationTime realEt); void updateLODRatio(); void updateColor(); // map that contain global value that can be affected to user param static TGlobalValuesMap _GlobalValuesMap; // map that contain gloābal 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 std::vector< CParticleSystemProcess *> TProcessVect; TProcessVect _ProcessVect; CFontGenerator *_FontGenerator; CFontManager *_FontManager; // the view matrix NLMISC::CMatrix _ViewMat; // the inverted view matrix NLMISC::CMatrix _InvertedViewMat; // the matrix of the system NLMISC::CMatrix _SysMat; // The previous matrix of the system. It is used to perform emission of particles in the world basis at the right position when the systm is moving NLMISC::CMatrix _OldSysMat; // the inverted matrix of the system NLMISC::CMatrix _InvSysMat; // Current position of the system. It is interpolated during integration, and is used by emitter to emit at the correct position NLMISC::CVector _CurrentDeltaPos; // Delta position of the system NLMISC::CVector _DeltaPos; // 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 _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 TDieCondition _DieCondition; TAnimationTime _DelayBeforeDieTest; uint _MaxNumFacesWanted; 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 std::multimap<uint32, CPSLocatedBindable *> TLBMap; TLBMap _LBMap; float _AutoLODStartDistPercent; uint8 _AutoLODDegradationExponent; CPSAttribMaker<NLMISC::CRGBA> *_ColorAttenuationScheme; NLMISC::CRGBA _GlobalColor; bool _ComputeBBox; bool _BBoxTouched; bool _AccurateIntegration; bool _CanSlowDown; bool _DestroyModelWhenOutOfRange; bool _DestroyWhenOutOfFrustum; bool _Sharing; bool _AutoLOD; bool _KeepEllapsedTimeForLifeUpdate; bool _AutoLODSkipParticles; bool _EnableLoadBalancing; float _InverseEllapsedTime; public: // For use by emitters only : This compute a delta of position to ensure that spaning position are correct when the system moves void interpolatePosDelta(NLMISC::CVector &dest, TAnimationTime deltaT); }; // 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 */