NL3D::CPSLocated Class Reference

#include <ps_located.h>

Inheritance diagram for NL3D::CPSLocated:

NL3D::CParticleSystemProcess NLMISC::IStreamable NLMISC::IClassable

Detailed Description

this class is a located : it belongs to a particle system, and it represents any kind of object that has a position in the world. A located don't do anything by itself. You must bind objects to it, such as a particle, a force and so on. It is important to remember that a located holds all instance of object of one type (force, emitter, particles or both...), not only one. Not sharable accross systems

Definition at line 130 of file ps_located.h.

Public Types

typedef CPSAttrib< CParametricInfoTPSAttribParametricInfo
 WARNING : private use by forces only.


Public Member Functions

void addNonIntegrableForceRef (void)
 ***************************************************************************************

bool bind (CPSLocatedBindable *lb)
 ***************************************************************************************

void collisionUpdate (const CPSCollisionInfo &ci, uint32 index)
bool computeBBox (NLMISC::CAABBox &aabbox) const
 ***************************************************************************************

NLMISC::CVector computeI (void) const
 ***************************************************************************************

NLMISC::CVector computeJ (void) const
 ***************************************************************************************

NLMISC::CVector computeK (void) const
 ***************************************************************************************

 CPSLocated ()
 ***************************************************************************************

void deleteElement (uint32 index)
 ***************************************************************************************

void enableParametricMotion (bool enable=true)
 ***************************************************************************************

void enableTriggerOnDeath (bool enable=true)
 Enable a trigger on death. It is used to create emission on an emitter with a given ID.

virtual void enumTexs (std::vector< NLMISC::CSmartPtr< ITexture > > &dest, IDriver &drv)
 ***************************************************************************************

float evalMaxDuration () const
 ***************************************************************************************

void forceLODDegradation (bool enable=true)
CPSLocatedBindablegetBoundObject (uint32 index)
const CPSLocatedBindablegetBoundObject (uint32 index) const
virtual std::string getClassName ()=0
const TPSAttribCollisionInfogetCollisionInfo (void) const
 get a const ref to the collision infos

TPSAttribCollisionInfogetCollisionInfo (void)
 get a ref to the collision infos

IDrivergetDriver () const
 ***************************************************************************************

uint32 getFrameRate (void) const
uint getIndexOf (const CPSLocatedBindable *lb) const
 ***************************************************************************************

TAnimationTime getInitialLife (void) const
 get the life of created particles (valid if they have a limited life time)

float getInitialMass (void) const
 get the mass of created particle

const TPSAttribFloatgetInvMass (void) const
 get mass inverse attrib const ref

TPSAttribFloatgetInvMass (void)
 get mass inverse attrib ref

bool getLastForever (void) const
 retrieve immortality for locateds

const CPSAttribMaker< float > * getLifeScheme (void) const
CPSAttribMaker< float > * getLifeScheme (void)
 get the life scheme of created particle, null if none (valid if they have a limited life time)

const NLMISC::CMatrixgetLocalToWorldMatrix () const
void getLODVect (NLMISC::CVector &v, float &offset, TPSMatrixMode matrixMode)
 ***************************************************************************************

const CPSAttribMaker< float > * getMassScheme (void) const
CPSAttribMaker< float > * getMassScheme (void)
 get the scheme that compute mass of created particles, null if none

TPSMatrixMode getMatrixMode () const
uint32 getMaxSize (void) const
std::string getName (void) const
 get the located bindable name (edition purpose)

uint32 getNbBoundObjects (void) const
uint32 getNewElementIndex (void) const
const CParticleSystemgetOwner (void) const
 retrieve the particle system that owns this process (const version)

CParticleSystemgetOwner (void)
 Retrieve the particle system that owns this process.

TPSAttribParametricInfogetParametricInfos ()
 PRIVATE USE : access to parametric infos.

const TPSAttribVectorgetPos (void) const
 get Pos attrib const ref

TPSAttribVectorgetPos (void)
 get Pos attrib ref

CScenegetScene (void)
 ***************************************************************************************

uint32 getSize (void) const
 get the current number of instance in this located container

const TPSAttribVectorgetSpeed (void) const
 get Speed attrib const ref

TPSAttribVectorgetSpeed (void)
 get Speed attrib ref

const TPSAttribTimegetTime (void) const
 get Time attrib const ref

TPSAttribTimegetTime (void)
 get Time attrib ref

const TPSAttribTimegetTimeIncrement (void) const
 get TotalTime attrib const ref

TPSAttribTimegetTimeIncrement (void)
 get TotalTime attrib ref

uint32 getTriggerEmitterID (void) const
 Get the ID for the emitter to be triggered on death.

virtual uint getUserMatrixUsageCount () const
 ***************************************************************************************

float getUserParam (uint numParam) const
 ***************************************************************************************

const NLMISC::CMatrixgetWorldToLocalMatrix () const
bool hasCollisionInfos () const
 test wether this located has collision infos

virtual bool hasEmitters (void) const
 tells wether there are alive emitters / particles in the system

bool hasLODDegradation (void) const
virtual bool hasParticles (void) const
 tells wether there are alive entities / particles in the system

void incrementNbDrawnParticles (uint num)
 ***************************************************************************************

void integrableForceBasisChanged (TPSMatrixMode basis)
 ***************************************************************************************

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

bool isBound (const CPSLocatedBindable *lb) const
 ***************************************************************************************

virtual bool isLocated () const
bool isParametricMotionEnabled (void) const
 test wether parametric motion is enabled

bool isTriggerOnDeathEnabled (void) const
 Test wether a trigger on death has been enabled.

sint32 newElement (const NLMISC::CVector &pos, const NLMISC::CVector &speed, CPSLocated *emitterLocated, uint32 indexInEmitter, TPSMatrixMode speedCoordSystem, TAnimationTime ellapsedTime)
 ***************************************************************************************

 NLMISC_DECLARE_CLASS (CPSLocated)
void notifyMaxNumFacesChanged (void)
 ***************************************************************************************

virtual void performParametricMotion (TAnimationTime date, TAnimationTime ellapsedTime, TAnimationTime realEllapsedTime)
 ***************************************************************************************

virtual uint querryMaxWantedNumFaces (void)
 ***************************************************************************************

void queryCollisionInfo (void)
 ***************************************************************************************

void registerDtorObserver (CPSLocatedBindable *observer)
 ***************************************************************************************

void registerIntegrableForce (CPSForce *f)
 ***************************************************************************************

virtual void releaseAllRef ()
 ***************************************************************************************

void releaseCollisionInfo (void)
 ***************************************************************************************

void releaseNonIntegrableForceRef (void)
 ***************************************************************************************

virtual void releaseRefTo (const CParticleSystemProcess *other)
 ***************************************************************************************

void remove (const CPSLocatedBindable *lb)
 ***************************************************************************************

void resize (uint32 newSize)
void serial (NLMISC::IStream &f) throw (NLMISC::EStream)
 ***************************************************************************************

void setFrameRate (uint32 nbFramesToSkip=0)
void setInitialLife (TAnimationTime lifeTime)
 ***************************************************************************************

void setInitialMass (float mass)
 ***************************************************************************************

bool setLastForever ()
 ***************************************************************************************

void setLifeScheme (CPSAttribMaker< float > *scheme)
 ***************************************************************************************

void setMassScheme (CPSAttribMaker< float > *scheme)
 ***************************************************************************************

virtual void setMatrixMode (TPSMatrixMode matrixMode)
 ***************************************************************************************

void setName (const std::string &name)
 set the located bindable name (edition purpose)

void setOwner (CParticleSystem *ps)
 Set the process owner. Called by the particle system during attachment.

void setTriggerEmitterID (uint32 id)
 Set an ID for the emitter to be triggered on death.

void setupDriverModelMatrix (void)
 Setup the driver model matrix. It is set accrodingly to the basis of the located.

virtual void setZBias (float value)
 ***************************************************************************************

virtual void step (TPSProcessPass pass, TAnimationTime ellapsedTime, TAnimationTime realEt)
 ***************************************************************************************

bool supportParametricMotion (void) const
 Test wether this located support parametric motion.

virtual void systemDateChanged ()
 ***************************************************************************************

CPSLocatedBindableunbind (uint index)
 ***************************************************************************************

void unregisterDtorObserver (CPSLocatedBindable *anObserver)
 ***************************************************************************************

void unregisterIntegrableForce (CPSForce *f)
 ***************************************************************************************

virtual void updateLife (TAnimationTime ellapsedTime)
 ***************************************************************************************

virtual ~CPSLocated ()
 dtor

Useful methods for edition
const CFontGeneratorgetFontGenerator (void) const
 Shortcut to get a font generator if one was set, const version (edition mode).

CFontGeneratorgetFontGenerator (void)
 Shortcut to get a font generator if one was set (edition mode).

const CFontManagergetFontManager (void) const
 Shortcut to get a font Manager if one was set, const version (edition mode).

CFontManagergetFontManager (void)
 Shortcut to get a font Manager if one was set (edition mode).

Useful methods for edition
const CFontGeneratorgetFontGenerator (void) const
 Shortcut to get a font generator if one was set, const version (edition mode).

CFontGeneratorgetFontGenerator (void)
 Shortcut to get a font generator if one was set (edition mode).

const CFontManagergetFontManager (void) const
 Shortcut to get a font Manager if one was set, const version (edition mode).

CFontManagergetFontManager (void)
 Shortcut to get a font Manager if one was set (edition mode).


Static Public Member Functions

const NLMISC::CMatrixgetConversionMatrix (const CPSLocated *A, const CPSLocated *B)
const NLMISC::CMatrixgetConversionMatrix (const CParticleSystem &ps, TPSMatrixMode to, TPSMatrixMode from)

Data Fields

CPSAttrib< CParametricInfo_PInfo

Protected Types

typedef CPSVector< CPSLocatedBindable
* >::V 
TDtorObserversVect
typedef CPSVector< CPSForce
* >::V 
TForceVect
 a vector of integrable forces that apply on this located

typedef CPSVector< CPSLocatedBindable
* >::V 
TLocatedBoundCont
typedef std::stack< CPostNewElementRequestInfoTNewElementRequestStack

Protected Member Functions

void allocateParametricInfos (void)
 allocate parametric infos

void checkIntegrity () const
 ***************************************************************************************

void notifyMotionTypeChanged (void)
 ***************************************************************************************

void postNewElement (const NLMISC::CVector &pos=NLMISC::CVector::Null, const NLMISC::CVector &speed=NLMISC::CVector::Null)
 ***************************************************************************************

void releaseParametricInfos (void)
 release paametric infos

void resetCollisionInfo (void)
 ***************************************************************************************

void updateNewElementRequestStack (void)
 ***************************************************************************************


Protected Attributes

TPSAttribCollisionInfo_CollisionInfo
uint32 _CollisionInfoNbRef
TDtorObserversVect _DtorObserversVect
float _InitialLife
float _InitialMass
TForceVect _IntegrableForces
TPSAttribFloat _InvMass
bool _LastForever
CPSAttribMaker< float > * _LifeScheme
TLocatedBoundCont _LocatedBoundCont
bool _LODDegradation
 true when LOD degradation apply to this located

CPSAttribMaker< float > * _MassScheme
TPSMatrixMode _MatrixMode
uint32 _MaxNumFaces
 cache the max number of faces this located may want

uint32 _MaxSize
std::string _Name
uint32 _NbFramesToSkip
uint16 _NonIntegrableForceNbRefs
uint16 _NumIntegrableForceWithDifferentBasis
 number of forces that apply on that located that have the same basis that this one (required for parametric animation)

CParticleSystem_Owner
bool _ParametricMotion
 When set to true, this tells the system to use parametric motion. Only parametric forces must have been applied.

TPSAttribVector _Pos
TNewElementRequestStack _RequestStack
 this stack is used after each update to generate located

uint32 _Size
TPSAttribVector _Speed
TPSAttribTime _Time
TPSAttribTime _TimeIncrement
uint32 _TriggerID
bool _TriggerOnDeath
bool _UpdateLock

Friends

class CPSForce


Member Typedef Documentation

typedef CPSVector<CPSLocatedBindable *>::V NL3D::CPSLocated::TDtorObserversVect [protected]
 

Definition at line 722 of file ps_located.h.

Referenced by releaseAllRef(), and ~CPSLocated().

typedef CPSVector<CPSForce *>::V NL3D::CPSLocated::TForceVect [protected]
 

a vector of integrable forces that apply on this located

Definition at line 735 of file ps_located.h.

typedef CPSVector<CPSLocatedBindable *>::V NL3D::CPSLocated::TLocatedBoundCont [protected]
 

Definition at line 600 of file ps_located.h.

typedef std::stack<CPostNewElementRequestInfo> NL3D::CPSLocated::TNewElementRequestStack [protected]
 

Definition at line 690 of file ps_located.h.

Referenced by serial().

typedef CPSAttrib<CParametricInfo> NL3D::CPSLocated::TPSAttribParametricInfo
 

WARNING : private use by forces only.

Definition at line 645 of file ps_located.h.

Referenced by getParametricInfos().


Constructor & Destructor Documentation

NL3D::CPSLocated::CPSLocated  ) 
 

***************************************************************************************

Constructor

Definition at line 68 of file ps_located.cpp.

References NL3D::DefaultMaxLocatedInstance, and uint32.

00068                        : _MaxNumFaces(0),
00069                                                            _Name(std::string("located")),
00070                                                            _NbFramesToSkip(0),
00071                                                            _MaxSize(DefaultMaxLocatedInstance),
00072                                                            _Size(0),
00073                                                            _LastForever(true),
00074                                                            _CollisionInfo(NULL),
00075                                                            _CollisionInfoNbRef(0),
00076                                                            _InitialLife(1.f),
00077                                                            _LifeScheme(NULL),
00078                                                            _InitialMass(1.f),
00079                                                            _MassScheme(NULL),
00080                                                            _UpdateLock(false),
00081                                                            _LODDegradation(false),
00082                                                            _NonIntegrableForceNbRefs(0),
00083                                                            _NumIntegrableForceWithDifferentBasis(0),
00084                                                            _TriggerOnDeath(false),
00085                                                            _TriggerID((uint32) 'NONE'),
00086                                                            _ParametricMotion(false)                                                        
00087 {               
00088 }

NL3D::CPSLocated::~CPSLocated  )  [virtual]
 

dtor

Definition at line 715 of file ps_located.cpp.

References _CollisionInfo, _CollisionInfoNbRef, _DtorObserversVect, _IntegrableForces, _LifeScheme, _LocatedBoundCont, _MassScheme, _NonIntegrableForceNbRefs, CHECK_PS_INTEGRITY, nlassert, and TDtorObserversVect.

00716 {
00717         CHECK_PS_INTEGRITY
00718         // we must do a copy, because the subsequent call can modify this vector
00719         TDtorObserversVect copyVect(_DtorObserversVect.begin(), _DtorObserversVect.end());
00720         // call all the dtor observers
00721         for (TDtorObserversVect::iterator it = copyVect.begin(); it != copyVect.end(); ++it)
00722         {
00723                 (*it)->notifyTargetRemoved(this);
00724         }
00725 
00726         nlassert(_CollisionInfoNbRef == 0); //If this is not = 0, then someone didnt call releaseCollisionInfo
00727                                                                                  // If this happen, you can register with the registerDTorObserver
00728                                                                                  // (observer pattern)
00729                                                                                  // and override notifyTargetRemove to call releaseCollisionInfo
00730         nlassert(_IntegrableForces.size() == 0);
00731         nlassert(_NonIntegrableForceNbRefs == 0);
00732         nlassert(!_CollisionInfo);
00733 
00734         // delete all bindable
00735         for (TLocatedBoundCont::iterator it2 = _LocatedBoundCont.begin(); it2 != _LocatedBoundCont.end(); ++it2)
00736         {                                       
00737                 (*it2)->finalize();
00738                 delete *it2;            
00739         } 
00740 
00741 
00742         delete _LifeScheme;
00743         delete _MassScheme;
00744         CHECK_PS_INTEGRITY
00745 }


Member Function Documentation

void NL3D::CPSLocated::addNonIntegrableForceRef void   ) 
 

***************************************************************************************

Definition at line 1866 of file ps_located.cpp.

References _NonIntegrableForceNbRefs, CHECK_PS_INTEGRITY, and releaseParametricInfos().

Referenced by NL3D::CPSZone::attachTarget(), and NL3D::CPSForce::attachTarget().

void NL3D::CPSLocated::allocateParametricInfos void   )  [protected]
 

allocate parametric infos

Definition at line 341 of file ps_located.cpp.

References _ParametricMotion, _PInfo, NL3D::CPSAttrib< T >::begin(), CHECK_PS_INTEGRITY, NL3D::CPSAttrib< T >::end(), NL3D::CParticleSystem::getSystemDate(), NL3D::CPSAttrib< CParametricInfo >::insert(), nlassert, notifyMotionTypeChanged(), NL3D::CPSAttrib< CParametricInfo >::resize(), and supportParametricMotion().

Referenced by enableParametricMotion().

00342 {
00343         CHECK_PS_INTEGRITY
00344         if (_ParametricMotion) return;
00345         nlassert(supportParametricMotion());
00346         nlassert(_Owner);
00347         const float date = _Owner->getSystemDate();
00348         _PInfo.resize(_MaxSize);
00349         // copy back infos from current position and speeds
00350         TPSAttribVector::const_iterator posIt = _Pos.begin(), endPosIt = _Pos.end();
00351         TPSAttribVector::const_iterator speedIt = _Speed.begin();
00352         while (posIt != endPosIt)
00353         {
00354                 _PInfo.insert( CParametricInfo(*posIt, *speedIt, date) );
00355                 ++posIt;
00356         }
00357         _ParametricMotion = true;
00358         notifyMotionTypeChanged();
00359         CHECK_PS_INTEGRITY
00360 }

bool NL3D::CPSLocated::bind CPSLocatedBindable lb  ) 
 

***************************************************************************************

attach a bindable object to this located, such as a force or a particle a bindable must be attached only once (-> nlassert) The bindable is then owned by the system and will be deleted by it.

Returns:
true if the operation could be performed. It can fail when this cause the system the system to last forever, which is incompatible with the 'BypassMaxNumIntegrationSteps' in CParticleSystem

Definition at line 751 of file ps_located.cpp.

References _LocatedBoundCont, _ParametricMotion, NL3D::CParticleSystem::canFinish(), CHECK_PS_INTEGRITY, NL3D::CParticleSystem::getBypassMaxNumIntegrationSteps(), NL3D::CPSLocatedBindable::getExternID(), getIndexOf(), NL3D::CPSLocatedBindable::motionTypeChanged(), NL3D::CPSLocatedBindable::newElement(), nlassert, nlwarning, notifyMaxNumFacesChanged(), NL3D::CParticleSystem::registerLocatedBindableExternID(), NL3D::CPSLocatedBindable::resize(), NL3D::CPSLocatedBindable::setOwner(), NL3D::CParticleSystem::systemDurationChanged(), uint, uint32, and unbind().

00752 {
00753         CHECK_PS_INTEGRITY
00754         nlassert(std::find(_LocatedBoundCont.begin(), _LocatedBoundCont.end(), lb) == _LocatedBoundCont.end()); 
00755         TLocatedBoundCont::iterator it = _LocatedBoundCont.begin();
00756         while (it != _LocatedBoundCont.end() && **it < *lb) // the "<" operator sort them correctly
00757         {
00758                 ++it;
00759         }
00760 
00761         _LocatedBoundCont.insert(it, lb);
00762         lb->setOwner(this);
00763         lb->resize(_MaxSize);
00764 
00765         // any located bindable that is bound to us should have no element in it for now !!
00766         // we resize it anyway...
00767 
00768         uint32 initialSize  = _Size;
00769         for (uint k = 0; k < initialSize; ++k)
00770         {
00771                 _Size = k;
00772                 lb->newElement(NULL, 0);
00773         }
00774         _Size = initialSize;
00775 
00776 
00777         if (_ParametricMotion) lb->motionTypeChanged(true);
00778 
00780         notifyMaxNumFacesChanged();
00781 
00782         if (_Owner)
00783         {
00784                 CParticleSystem *ps = _Owner;
00785                 if (ps->getBypassMaxNumIntegrationSteps())
00786                 {
00787                         if (!ps->canFinish())
00788                         {
00789                                 unbind(getIndexOf(lb));
00790                                 nlwarning("<CPSLocated::bind> Can't bind the located : this causes the system to last forever, and it has been flagged with 'BypassMaxNumIntegrationSteps'. Located is not bound.");
00791                                 return false;
00792                         }               
00793                 }
00794                 // if there's an extern id, register in lb list
00795                 if (lb->getExternID() != 0)
00796                 {
00797                         // register in ID list
00798                         ps->registerLocatedBindableExternID(lb->getExternID(), lb);
00799                 }
00800                 _Owner->systemDurationChanged();
00801         }
00802 
00803         CHECK_PS_INTEGRITY
00804         return true;
00805 }

void NL3D::CPSLocated::checkIntegrity  )  const [protected]
 

***************************************************************************************

Definition at line 133 of file ps_located.cpp.

References _CollisionInfo, _InvMass, _TimeIncrement, NL3D::CPSAttrib< T >::getMaxSize(), NL3D::CPSAttrib< float >::getMaxSize(), NL3D::CPSAttrib< T >::getSize(), NL3D::CPSAttrib< float >::getSize(), and nlassert.

00134 {
00135         nlassert(_InvMass.getMaxSize() == _Pos.getMaxSize());
00136         nlassert(_Pos.getMaxSize() == _Speed.getMaxSize());
00137         nlassert(_Speed.getMaxSize() == _Time.getMaxSize());
00138         nlassert(_Time.getMaxSize() == _TimeIncrement.getMaxSize());
00139         //
00140         nlassert(_InvMass.getSize() == _Pos.getSize());
00141         nlassert(_Pos.getSize() == _Speed.getSize());
00142         nlassert(_Speed.getSize() == _Time.getSize());
00143         nlassert(_Time.getSize() == _TimeIncrement.getSize());
00144         //
00145         if (_CollisionInfo)
00146         {
00147                 nlassert(_InvMass.getMaxSize() == _CollisionInfo->getMaxSize());
00148                 nlassert(_InvMass.getSize() == _CollisionInfo->getSize());
00149         }
00150 }

void NL3D::CPSLocated::collisionUpdate const CPSCollisionInfo ci,
uint32  index
[inline]
 

A collider must call this when a collision occurs If the collider was nearer that another one it will be taken in account the index of instance that collided

Definition at line 784 of file ps_located.h.

References _CollisionInfo, NL3D::CPSCollisionInfo::dist, index, nlassert, and uint32.

00785 {
00786         nlassert(_CollisionInfo);
00787         CPSCollisionInfo  &firstCi = (*_CollisionInfo)[index];
00788         if (firstCi.dist == -1 || ci.dist < firstCi.dist)
00789         {
00790                 firstCi = ci;
00791         }
00792 }

bool NL3D::CPSLocated::computeBBox NLMISC::CAABBox aabbox  )  const [virtual]
 

***************************************************************************************

Compute the aabbox of this located, (expressed in world basis

Returns:
true if there is any aabbox
Parameters:
aabbox a ref to the result box

Implements NL3D::CParticleSystemProcess.

Definition at line 1716 of file ps_located.cpp.

References _LocatedBoundCont, CHECK_PS_INTEGRITY, NLMISC::CAABBox::computeAABBoxUnion(), NLMISC::CVector::maxof(), min, NLMISC::CAABBox::setMinMax(), and v.

01717 {
01718         CHECK_PS_INTEGRITY
01719         if (!_Size) return false; // something to compute ?
01720 
01721 
01722         TLocatedBoundCont::const_iterator it;
01723         TPSAttribVector::const_iterator it2;
01724 
01725         // check whether any object bound to us need a bbox
01726 
01727         for (it = _LocatedBoundCont.begin(); it != _LocatedBoundCont.end(); ++it)
01728         {
01729                 if ((*it)->doesProduceBBox()) 
01730                 {
01731                         break;
01732                 }
01733         }
01734 
01735         if (it == _LocatedBoundCont.end()) 
01736         {
01737                 return false;
01738         }
01739 
01740         CVector min = _Pos[0], max = _Pos[0];
01741 
01742         for (it2 = _Pos.begin(); it2 != _Pos.end(); ++ it2)
01743         {
01744                 const CVector &v = (*it2);
01745                 min.minof(min, v);      
01746                 max.maxof(max, v);              
01747         }
01748 
01749         box.setMinMax(min, max);        
01750 
01751         // we've considered that located had no extent in space
01752         // now, we must call each objects that are bound to the located in order
01753         // to complete the bbox if they have no null extent
01754 
01755         NLMISC::CAABBox tmpBox, startBox = box;
01756 
01757         for (it = _LocatedBoundCont.begin(); it != _LocatedBoundCont.end(); ++it)
01758         {
01759                 if ((*it)->doesProduceBBox())
01760                 {
01761                         tmpBox = startBox;
01762                         if ((*it)->completeBBox(tmpBox))
01763                         {
01764                                 box = NLMISC::CAABBox::computeAABBoxUnion(tmpBox, box);
01765                         }
01766                 }
01767         }
01768         CHECK_PS_INTEGRITY
01769         return true;
01770 }

NLMISC::CVector NL3D::CPSLocated::computeI void   )  const
 

***************************************************************************************

Compute a vector that will map to (1 0 0) after view and model transform. This allow to have object that always faces the user, whatever basis they are in

Definition at line 612 of file ps_located.cpp.

References CHECK_PS_INTEGRITY, NLMISC::CMatrix::getI(), NL3D::CParticleSystem::getInvertedViewMat(), NL3D::CParticleSystemProcess::getMatrixMode(), NL3D::CParticleSystem::getSysMat(), getWorldToLocalMatrix(), NLMISC::CMatrix::mulVector(), and NL3D::PSIdentityMatrix.

Referenced by NL3D::CPSLocatedBindable::computeI(), and NL3D::CPSRibbonLookAt::displayRibbons().

00613 {
00614         CHECK_PS_INTEGRITY
00615         const NLMISC::CMatrix &sysMat = _Owner->getSysMat();
00616         if (getMatrixMode() == PSIdentityMatrix)
00617         {
00618                 if (!sysMat.hasScalePart())
00619                 {
00620                         return _Owner->getInvertedViewMat().getI();
00621                 }
00622                 else
00623                 {               
00624                         return sysMat.getScaleUniform() * _Owner->getInvertedViewMat().getI();
00625                 }
00626         }
00627         else
00628         {
00629                 if (!sysMat.hasScalePart())
00630                 {
00631                         // we must express the I vector in the system basis, so we need to multiply it by the inverted matrix of the system
00632                         return getWorldToLocalMatrix().mulVector(_Owner->getInvertedViewMat().getI());
00633                 }
00634                 else
00635                 {
00636                         return sysMat.getScaleUniform() * getWorldToLocalMatrix().mulVector(_Owner->getInvertedViewMat().getI());
00637                 }
00638         }
00639         CHECK_PS_INTEGRITY
00640 }

NLMISC::CVector NL3D::CPSLocated::computeJ void   )  const
 

***************************************************************************************

Compute a vector that will map to (0 1 0) after view and model transform. This allow to have object that always faces the user, whatever basis they are in

Definition at line 643 of file ps_located.cpp.

References CHECK_PS_INTEGRITY, NL3D::CParticleSystem::getInvertedViewMat(), NLMISC::CMatrix::getJ(), NL3D::CParticleSystemProcess::getMatrixMode(), NL3D::CParticleSystem::getSysMat(), getWorldToLocalMatrix(), NLMISC::CMatrix::mulVector(), and NL3D::PSIdentityMatrix.

Referenced by NL3D::CPSLocatedBindable::computeJ().

00644 {
00645         CHECK_PS_INTEGRITY
00646         const NLMISC::CMatrix &sysMat = _Owner->getSysMat();
00647         if (getMatrixMode() == PSIdentityMatrix)
00648         {
00649                 if (!sysMat.hasScalePart())
00650                 {
00651                         return _Owner->getInvertedViewMat().getJ();
00652                 }
00653                 else
00654                 {
00655                         return sysMat.getScaleUniform() * _Owner->getInvertedViewMat().getJ();
00656                 }
00657         }
00658         else
00659         {
00660                 if (!sysMat.hasScalePart())
00661                 {
00662                         // we must express the J vector in the system basis, so we need to multiply it by the inverted matrix of the system
00663                         return getWorldToLocalMatrix().mulVector(_Owner->getInvertedViewMat().getJ());
00664                 }
00665                 else
00666                 {
00667                         return sysMat.getScaleUniform() * getWorldToLocalMatrix().mulVector(_Owner->getInvertedViewMat().getJ());
00668                 }
00669         }
00670         CHECK_PS_INTEGRITY
00671 }

NLMISC::CVector NL3D::CPSLocated::computeK void   )  const
 

***************************************************************************************

Compute a vector that will map to (0 0 1) after view and model transform. This allow to have object that always faces the user, whatever basis they are in

Definition at line 674 of file ps_located.cpp.

References CHECK_PS_INTEGRITY, NL3D::CParticleSystem::getInvertedViewMat(), NLMISC::CMatrix::getK(), NL3D::CParticleSystemProcess::getMatrixMode(), NL3D::CParticleSystem::getSysMat(), getWorldToLocalMatrix(), NLMISC::CMatrix::mulVector(), and NL3D::PSIdentityMatrix.

Referenced by NL3D::CPSLocatedBindable::computeK(), and NL3D::CPSRibbonLookAt::displayRibbons().

00675 {
00676         CHECK_PS_INTEGRITY
00677         const NLMISC::CMatrix &sysMat = _Owner->getSysMat();
00678         if (getMatrixMode() == PSIdentityMatrix)
00679         {
00680                 if (!sysMat.hasScalePart())
00681                 {
00682                         return _Owner->getInvertedViewMat().getK();
00683                 }
00684                 else
00685                 {
00686                         return sysMat.getScaleUniform() * _Owner->getInvertedViewMat().getK();
00687                 }
00688         }
00689         else
00690         {
00691                 if (!sysMat.hasScalePart())
00692                 {
00693                         // we must express the K vector in the system basis, so we need to multiply it by the inverted matrix of the system
00694                         return getWorldToLocalMatrix().mulVector(_Owner->getInvertedViewMat().getK());
00695                 }
00696                 else
00697                 {
00698                         return sysMat.getScaleUniform() * getWorldToLocalMatrix().mulVector(_Owner->getInvertedViewMat().getK());
00699                 }
00700         }
00701         CHECK_PS_INTEGRITY
00702 }

void NL3D::CPSLocated::deleteElement uint32  index  ) 
 

***************************************************************************************

Delete one located in the container not present -> nlassert

Definition at line 1051 of file ps_located.cpp.

References _CollisionInfo, _InvMass, _LocatedBoundCont, _ParametricMotion, _PInfo, _TimeIncrement, _TriggerID, _TriggerOnDeath, _UpdateLock, CHECK_PS_INTEGRITY, NL3D::CParticleSystem::getLocatedBindableByExternID(), NL3D::CParticleSystem::getNumLocatedBindableByExternID(), NL3D::CPSLocatedBindable::getOwner(), getSize(), NL3D::CPSLocatedBindable::getType(), NL3D::IDToLittleEndian(), index, nlassert, NL3D::PSEmitter, NL3D::CPSAttrib< CParametricInfo >::remove(), NL3D::CPSAttrib< T >::remove(), NL3D::CPSAttrib< float >::remove(), NL3D::CPSEmitter::singleEmit(), uint, and uint32.

Referenced by NL3D::CompensateEmission(), NL3D::CParticleSystemInstanceUser::removeByID(), resize(), step(), and updateLife().

01052 {
01053         CHECK_PS_INTEGRITY
01054         
01055         nlassert(index < _Size);
01056         
01057         // delete all bindable before : they may need our coordinate
01058         // to perform a destruction task
01059         
01060         _UpdateLock = true;
01061         
01062 
01063         for (TLocatedBoundCont::iterator it = _LocatedBoundCont.begin(); it != _LocatedBoundCont.end(); ++it)
01064         {
01065                 (*it)->deleteElement(index);
01066         }       
01067 
01068         
01069         _UpdateLock = false;    
01070 
01071         // remove common located's attributes
01072 
01073         _InvMass.remove(index);
01074         _Pos.remove(index);
01075         _Speed.remove(index);
01076         _Time.remove(index);
01077         _TimeIncrement.remove(index);
01078 
01079         if (_CollisionInfo)
01080         {
01081                 _CollisionInfo->remove(index);
01082         }
01083 
01084         if (_ParametricMotion)
01085         {
01086                 _PInfo.remove(index);
01087         }
01088 
01089         --_Size;
01090 
01091         if (_TriggerOnDeath)
01092         {
01093                 const uint32 id = IDToLittleEndian(_TriggerID);
01094                 nlassert(_Owner);               
01095                 uint numLb  = _Owner->getNumLocatedBindableByExternID(id);              
01096                 for (uint k = 0; k < numLb; ++k)
01097                 {
01098                         CPSLocatedBindable *lb = _Owner->getLocatedBindableByExternID(id, k);           
01099                         if (lb->getType() == PSEmitter)
01100                         {
01101                                 CPSEmitter *e = NLMISC::safe_cast<CPSEmitter *>(lb);
01102                                 nlassert(e->getOwner());
01103                                 uint nbInstances = e->getOwner()->getSize();                            
01104                                 for (uint l = 0; l < nbInstances; ++l)
01105                                 {
01106                                         e->singleEmit(l, 1);
01107                                 }
01108                         }
01109                 }
01110         }
01111         CHECK_PS_INTEGRITY
01112 }

void NL3D::CPSLocated::enableParametricMotion bool  enable = true  ) 
 

***************************************************************************************

When set to true, this tells the system to use parametric motion. This is needed in a few case only, and can only work if all the forces that apply to the system are integrable. An assertion happens otherwise

Definition at line 385 of file ps_located.cpp.

References allocateParametricInfos(), CHECK_PS_INTEGRITY, nlassert, releaseParametricInfos(), and supportParametricMotion().

00386 {
00387         CHECK_PS_INTEGRITY
00388         nlassert(supportParametricMotion());
00389         if (enable)
00390         {
00391                 allocateParametricInfos();
00392         }
00393         else
00394         {
00395                 releaseParametricInfos();
00396         }
00397         CHECK_PS_INTEGRITY
00398 }

void NL3D::CPSLocated::enableTriggerOnDeath bool  enable = true  )  [inline]
 

Enable a trigger on death. It is used to create emission on an emitter with a given ID.

Definition at line 552 of file ps_located.h.

References _TriggerOnDeath.

00552 { _TriggerOnDeath = enable; }

void NL3D::CPSLocated::enumTexs std::vector< NLMISC::CSmartPtr< ITexture > > &  dest,
IDriver drv
[virtual]
 

***************************************************************************************

Implements NL3D::CParticleSystemProcess.

Definition at line 2295 of file ps_located.cpp.

References _LocatedBoundCont.

02296 {
02297         for(TLocatedBoundCont::const_iterator it = _LocatedBoundCont.begin(); it != _LocatedBoundCont.end(); ++it)
02298         {
02299                 (*it)->enumTexs(dest, drv);
02300         }
02301 }

float NL3D::CPSLocated::evalMaxDuration  )  const
 

***************************************************************************************

eval max duration of the located (if no scheme is used, this is the lifetime) nb : return -1 if located last for ever

Definition at line 125 of file ps_located.cpp.

References _InitialLife, _LastForever, _LifeScheme, and NL3D::CPSAttribMaker< float >::getMaxValue().

Referenced by NL3D::CParticleSystem::evalDuration().

00126 {
00127         if (_LastForever) return -1.f;
00128         return _LifeScheme ? _LifeScheme->getMaxValue() : _InitialLife;
00129 }

void NL3D::CPSLocated::forceLODDegradation bool  enable = true  )  [inline]
 

Enable the to force LOD degradation. This will suppress instances immediately, (during the motion pass) so that there won't be more than maxNbInstance * dist / maxDist instances. This may not be desirable every time since particle dissapear on screen, which may be noticeable.

Definition at line 509 of file ps_located.h.

References _LODDegradation.

00509 { _LODDegradation = enable; }

CPSLocatedBindable* NL3D::CPSLocated::getBoundObject uint32  index  )  [inline]
 

get a pointer to a bound object

Definition at line 209 of file ps_located.h.

References _LocatedBoundCont, index, nlassert, and uint32.

00210         {
00211                 nlassert(index < _LocatedBoundCont.size());
00212                 return _LocatedBoundCont[index];
00213         }

const CPSLocatedBindable* NL3D::CPSLocated::getBoundObject uint32  index  )  const [inline]
 

get a pointer to a bound object (const version)

Definition at line 199 of file ps_located.h.

References _LocatedBoundCont, index, nlassert, and uint32.

Referenced by NL3D::CParticleSystem::activateEmitters(), NL3D::CParticleSystem::canFinish(), NL3D::CPSEmitter::checkLoop(), NL3D::CParticleSystem::evalDuration(), NL3D::CParticleSystem::getCurrNumParticles(), NL3D::CParticleSystem::getMaxNumParticles(), NL3D::CParticleSystem::getTargeters(), NL3D::CParticleSystem::hasActiveEmitters(), NL3D::CParticleSystem::hasEmittersTemplates(), NL3D::CParticleSystem::hasLightableObjects(), NL3D::CParticleSystem::hasLoop(), NL3D::CParticleSystem::hasOpaqueObjects(), NL3D::CParticleSystem::hasTransparentObjects(), NL3D::CParticleSystem::reactivateSound(), and NL3D::CParticleSystem::stopSound().

00200         {
00201                 nlassert(index < _LocatedBoundCont.size());
00202                 return _LocatedBoundCont[index];
00203         }

virtual std::string NLMISC::IClassable::getClassName  )  [pure virtual, inherited]
 

Implemented in NLAIAGENT::CNumericIndex, NLAIC::IPointerGestion, NLAIC::CIdentType, and CAutomataDesc.

Referenced by NLMISC::CClassRegistry::checkObject(), and NL3D::GetTextureSize().

const TPSAttribCollisionInfo& NL3D::CPSLocated::getCollisionInfo void   )  const [inline]
 

get a const ref to the collision infos

Definition at line 445 of file ps_located.h.

References _CollisionInfo, nlassert, and NL3D::TPSAttribCollisionInfo.

00446         {
00447                 nlassert(_CollisionInfo);
00448                 return *_CollisionInfo;
00449         }

TPSAttribCollisionInfo& NL3D::CPSLocated::getCollisionInfo void   )  [inline]
 

get a ref to the collision infos

Definition at line 438 of file ps_located.h.

References _CollisionInfo, nlassert, and NL3D::TPSAttribCollisionInfo.

Referenced by NL3D::CompensateEmission().

00439         {
00440                 nlassert(_CollisionInfo);
00441                 return *_CollisionInfo;
00442         }

const NLMISC::CMatrix & NL3D::CPSLocated::getConversionMatrix const CPSLocated A,
const CPSLocated B
[inline, static]
 

get a matrix that helps to express located B coordinate in located A basis A and B must belong to the same system

Definition at line 1133 of file ps_located.h.

References NL3D::CParticleSystemProcess::_Owner, getConversionMatrix(), NL3D::CParticleSystemProcess::getMatrixMode(), and nlassert.

01134 {
01135         nlassert(A);
01136         nlassert(B);
01137         nlassert(A->_Owner == B->_Owner); // conversion must be made between entity of the same system
01138         const CParticleSystem *ps = A->_Owner;
01139         nlassert(ps);
01140         return getConversionMatrix(*ps, A->getMatrixMode(), B->getMatrixMode());
01141 }

const NLMISC::CMatrix & NL3D::CPSLocated::getConversionMatrix const CParticleSystem ps,
TPSMatrixMode  to,
TPSMatrixMode  from
[static]
 

Definition at line 570 of file ps_located.cpp.

References NL3D::CParticleSystem::getFXToUserMatrix(), NL3D::CParticleSystem::getInvertedSysMat(), NL3D::CParticleSystem::getInvertedUserMatrix(), NL3D::CParticleSystem::getSysMat(), NL3D::CParticleSystem::getUserMatrix(), NL3D::CParticleSystem::getUserToFXMatrix(), nlassert, NL3D::PSFXWorldMatrix, NL3D::PSIdentityMatrix, and NL3D::PSUserMatrix.

Referenced by getConversionMatrix(), and newElement().

00571 {       
00572         switch(destMode)
00573         {
00574                 case PSFXWorldMatrix:
00575                         switch(srcMode)
00576                         {
00577                                 case PSFXWorldMatrix:                           return NLMISC::CMatrix::Identity;
00578                                 case PSIdentityMatrix:                          return ps.getInvertedSysMat();  
00579                                 case PSUserMatrix:      return ps.getUserToFXMatrix();
00580                                 default:
00581                                 nlassert(0);
00582                         }
00583                 break;
00584                 case PSIdentityMatrix:
00585                         switch(srcMode)
00586                         {
00587                                 case PSFXWorldMatrix:                           return ps.getSysMat();
00588                                 case PSIdentityMatrix:                          return NLMISC::CMatrix::Identity;
00589                                 case PSUserMatrix:      return ps.getUserMatrix();      
00590                                 default:
00591                                 nlassert(0);
00592                         }
00593                 break;
00594                 case PSUserMatrix:
00595                         switch(srcMode)
00596                         {
00597                                 case PSFXWorldMatrix:                           return ps.getFXToUserMatrix();
00598                                 case PSIdentityMatrix:                          return ps.getInvertedUserMatrix();
00599                                 case PSUserMatrix:      return NLMISC::CMatrix::Identity;
00600                                 default:
00601                                 nlassert(0);
00602                         }
00603                 break;
00604                 default:
00605                         nlassert(0);
00606         }
00607         nlassert(0);
00608         return NLMISC::CMatrix::Identity;
00609 }

IDriver * NL3D::CPSLocated::getDriver  )  const
 

***************************************************************************************

Definition at line 705 of file ps_located.cpp.

References CHECK_PS_INTEGRITY, NL3D::CParticleSystem::getDriver(), and nlassert.

Referenced by NL3D::CPSLocatedBindable::getDriver(), and setupDriverModelMatrix().

00706 { 
00707         CHECK_PS_INTEGRITY
00708         nlassert(_Owner);
00709         nlassert (_Owner->getDriver() ); // you haven't called setDriver on the system
00710         return _Owner->getDriver();
00711 }

const CFontGenerator * NL3D::CParticleSystemProcess::getFontGenerator void   )  const [inherited]
 

Shortcut to get a font generator if one was set, const version (edition mode).

Definition at line 78 of file particle_system_process.cpp.

References NL3D::CParticleSystem::getFontGenerator(), and nlassert.

00079 {
00080                         nlassert(_Owner);
00081                         return _Owner->getFontGenerator();
00082 }

CFontGenerator * NL3D::CParticleSystemProcess::getFontGenerator void   )  [inherited]
 

Shortcut to get a font generator if one was set (edition mode).

Definition at line 71 of file particle_system_process.cpp.

References NL3D::CParticleSystem::getFontGenerator(), and nlassert.

Referenced by NL3D::CPSLocatedBindable::getFontGenerator().

00072 {
00073                         nlassert(_Owner);
00074                         return _Owner->getFontGenerator();
00075 }

const CFontManager * NL3D::CParticleSystemProcess::getFontManager void   )  const [inherited]
 

Shortcut to get a font Manager if one was set, const version (edition mode).

Definition at line 92 of file particle_system_process.cpp.

References NL3D::CParticleSystem::getFontManager(), and nlassert.

00093 {
00094                         nlassert(_Owner);
00095                         return _Owner->getFontManager();
00096 }

CFontManager * NL3D::CParticleSystemProcess::getFontManager void   )  [inherited]
 

Shortcut to get a font Manager if one was set (edition mode).

Definition at line 85 of file particle_system_process.cpp.

References NL3D::CParticleSystem::getFontManager(), and nlassert.

Referenced by NL3D::CPSLocatedBindable::getFontManager().

00086 {
00087                         nlassert(_Owner);
00088                         return _Owner->getFontManager();
00089 }

uint32 NL3D::CPSLocated::getFrameRate void   )  const [inline]
 

Definition at line 382 of file ps_located.h.

References _NbFramesToSkip, and uint32.

00382 { return _NbFramesToSkip; }

uint NL3D::CPSLocated::getIndexOf const CPSLocatedBindable lb  )  const
 

***************************************************************************************

Get the index of a located bindable that is bound to that object. If it isn't bound, an assertion is raised

Definition at line 1923 of file ps_located.cpp.

References _LocatedBoundCont, CHECK_PS_INTEGRITY, nlassert, and uint.

Referenced by bind().

01924 {
01925         CHECK_PS_INTEGRITY
01926         for(uint k = 0; k < _LocatedBoundCont.size(); ++k)
01927         {
01928                 if (_LocatedBoundCont[k] == lb) return k;
01929         }
01930         nlassert(0);    
01931         return 0;
01932 }

TAnimationTime NL3D::CPSLocated::getInitialLife void   )  const [inline]
 

get the life of created particles (valid if they have a limited life time)

Definition at line 292 of file ps_located.h.

References _InitialLife, and NL3D::TAnimationTime.

Referenced by NL3D::CompensateEmission().

00292 { return _InitialLife; }

float NL3D::CPSLocated::getInitialMass void   )  const [inline]
 

get the mass of created particle

Definition at line 311 of file ps_located.h.

References _InitialMass.

00311 { return _InitialMass; }

const TPSAttribFloat& NL3D::CPSLocated::getInvMass void   )  const [inline]
 

get mass inverse attrib const ref

Definition at line 331 of file ps_located.h.

References _InvMass, and NL3D::TPSAttribFloat.

00331 { return _InvMass; }

TPSAttribFloat& NL3D::CPSLocated::getInvMass void   )  [inline]
 

get mass inverse attrib ref

Definition at line 329 of file ps_located.h.

References _InvMass, and NL3D::TPSAttribFloat.

Referenced by NL3D::CPSAttribMakerT< T, F >::get(), NL3D::CPSAttribMakerT< uint32, CPSValueBlendFunc< uint32 > >::make(), NL3D::CPSAttribMakerT< uint32, CPSValueBlendFunc< uint32 > >::make4(), and NL3D::CPSAttribMakerT< uint32, CPSValueBlendFunc< uint32 > >::makeN().

00329 { return _InvMass; }

bool NL3D::CPSLocated::getLastForever void   )  const [inline]
 

retrieve immortality for locateds

Definition at line 326 of file ps_located.h.

References _LastForever.

Referenced by NL3D::CParticleSystem::canFinish(), NL3D::CompensateEmission(), NL3D::CParticleSystem::evalDuration(), NL3D::CPSAttribMakerT< uint32, CPSValueBlendFunc< uint32 > >::make(), NL3D::CPSAttribMakerT< uint32, CPSValueBlendFunc< uint32 > >::make4(), NL3D::CPSAttribMakerT< uint32, CPSValueBlendFunc< uint32 > >::makeN(), and NL3D::CPSEmitter::testEmitForever().

00326 { return _LastForever; }

const CPSAttribMaker<float>* NL3D::CPSLocated::getLifeScheme void   )  const [inline]
 

Definition at line 296 of file ps_located.h.

References _LifeScheme.

00296 { return _LifeScheme; }

CPSAttribMaker<float>* NL3D::CPSLocated::getLifeScheme void   )  [inline]
 

get the life scheme of created particle, null if none (valid if they have a limited life time)

Definition at line 295 of file ps_located.h.

References _LifeScheme.

Referenced by NL3D::CompensateEmission().

00295 { return _LifeScheme; }

const NLMISC::CMatrix & NL3D::CPSLocated::getLocalToWorldMatrix  )  const
 

Definition at line 92 of file ps_located.cpp.

References NL3D::CParticleSystemProcess::getMatrixMode(), NL3D::CParticleSystem::getSysMat(), NL3D::CParticleSystem::getUserMatrix(), nlassert, NL3D::PSFXWorldMatrix, NL3D::PSIdentityMatrix, and NL3D::PSUserMatrix.

Referenced by NL3D::CPSFaceLookAtHelper::drawLookAt(), NL3D::CPSLocatedBindable::getLocalToWorldMatrix(), setupDriverModelMatrix(), and NL3D::CPSSound::step().

00093 {
00094         nlassert(_Owner);
00095         switch(getMatrixMode())
00096         {
00097                 case PSFXWorldMatrix:                           return _Owner->getSysMat();
00098                 case PSIdentityMatrix:                          return NLMISC::CMatrix::Identity;
00099                 case PSUserMatrix:      return _Owner->getUserMatrix();
00100                 default:
00101                         nlassert(0);
00102         }
00103         nlassert(0);
00104         return NLMISC::CMatrix::Identity;
00105 }

void NL3D::CPSLocated::getLODVect NLMISC::CVector v,
float &  offset,
TPSMatrixMode  matrixMode
 

***************************************************************************************

Definition at line 475 of file ps_located.cpp.

References CHECK_PS_INTEGRITY, NL3D::CParticleSystem::getLODVect(), nlassert, offset, and v.

Referenced by NL3D::CPSAttribMakerT< T, F >::get(), NL3D::CPSAttribMakerT< uint32, CPSValueBlendFunc< uint32 > >::make(), NL3D::CPSAttribMakerT< uint32, CPSValueBlendFunc< uint32 > >::make4(), and NL3D::CPSAttribMakerT< uint32, CPSValueBlendFunc< uint32 > >::makeN().

00476 {
00477         nlassert(_Owner);
00478         CHECK_PS_INTEGRITY
00479         _Owner->getLODVect(v, offset, matrixMode);
00480         CHECK_PS_INTEGRITY
00481 }

const CPSAttribMaker<float>* NL3D::CPSLocated::getMassScheme void   )  const [inline]
 

Definition at line 315 of file ps_located.h.

References _MassScheme.

00315 { return _MassScheme; }

CPSAttribMaker<float>* NL3D::CPSLocated::getMassScheme void   )  [inline]
 

get the scheme that compute mass of created particles, null if none

Definition at line 314 of file ps_located.h.

References _MassScheme.

00314 { return _MassScheme; }

TPSMatrixMode NL3D::CParticleSystemProcess::getMatrixMode  )  const [inline, inherited]
 

Definition at line 143 of file particle_system_process.h.

References NL3D::CParticleSystemProcess::_MatrixMode, and NL3D::TPSMatrixMode.

Referenced by NL3D::CPSForce::cancelIntegrable(), computeI(), computeJ(), computeK(), NL3D::CPSAttribMakerT< T, F >::get(), getConversionMatrix(), getLocalToWorldMatrix(), getWorldToLocalMatrix(), integrableForceBasisChanged(), NL3D::CPSAttribMakerT< uint32, CPSValueBlendFunc< uint32 > >::make(), NL3D::CPSAttribMakerT< uint32, CPSValueBlendFunc< uint32 > >::make4(), NL3D::CPSAttribMakerT< uint32, CPSValueBlendFunc< uint32 > >::makeN(), newElement(), NL3D::CPSEmitter::processEmit(), NL3D::CPSEmitter::processEmitConsistent(), registerIntegrableForce(), NL3D::CPSForce::renewIntegrable(), setMatrixMode(), and unregisterIntegrableForce().

00143 { return _MatrixMode; }                 

uint32 NL3D::CPSLocated::getMaxSize void   )  const [inline]
 

get the max number of instance in this located container

See also:
resize()

Definition at line 369 of file ps_located.h.

References uint32.

Referenced by NL3D::CPSConstraintMesh::fillIndexesInPrecompBasis(), NL3D::CPSFace::fillIndexesInPrecompBasis(), NL3D::GenEmitterPositions(), NL3D::GenEmitterPositionsWithLOD(), NL3D::CPSTailDot::getMaxNumFaces(), NL3D::CPSShockWave::getMaxNumFaces(), NL3D::CPSRibbonLookAt::getMaxNumFaces(), NL3D::CPSRibbon::getMaxNumFaces(), NL3D::CPSQuad::getMaxNumFaces(), NL3D::CPSConstraintMesh::getMaxNumFaces(), NL3D::CPSFanLight::getMaxNumFaces(), NL3D::CPSDot::getMaxNumFaces(), NL3D::CParticleSystem::getMaxNumParticles(), NL3D::CPSRibbonBase::motionTypeChanged(), newElement(), NL3D::CPSLight::setAttenEndScheme(), NL3D::CPSLight::setAttenStartScheme(), NL3D::CPSLight::setColorScheme(), NL3D::CPSSound::setGainScheme(), NL3D::CPSEmitter::setGenNbScheme(), NL3D::CPSConstraintMesh::setMorphScheme(), NL3D::CPSFanLight::setNbFans(), NL3D::CPSShockWave::setNbSegs(), NL3D::CPSEmitter::setPeriodScheme(), NL3D::CPSSound::setPitchScheme(), NL3D::CPSShockWave::setRadiusCut(), NL3D::CPSRibbonBase::setTailNbSeg(), NL3D::CPSShockWave::updateMatAndVbForColor(), NL3D::CPSEmitter::updateMaxCountVect(), and NL3D::CPSMesh::updatePos().

00370         { 
00371                 return _MaxSize; 
00372         }

std::string NL3D::CPSLocated::getName void   )  const [inline]
 

get the located bindable name (edition purpose)

Definition at line 495 of file ps_located.h.

00495 { return _Name; }

uint32 NL3D::CPSLocated::getNbBoundObjects void   )  const [inline]
 

count the number of bound objects

Definition at line 194 of file ps_located.h.

References _LocatedBoundCont, and uint32.

Referenced by NL3D::CParticleSystem::activateEmitters(), NL3D::CParticleSystem::canFinish(), NL3D::CPSEmitter::checkLoop(), NL3D::CParticleSystem::evalDuration(), NL3D::CParticleSystem::getCurrNumParticles(), NL3D::CParticleSystem::getMaxNumParticles(), NL3D::CParticleSystem::getTargeters(), NL3D::CParticleSystem::hasActiveEmitters(), NL3D::CParticleSystem::hasEmittersTemplates(), NL3D::CParticleSystem::hasLightableObjects(), NL3D::CParticleSystem::hasLoop(), NL3D::CParticleSystem::hasOpaqueObjects(), NL3D::CParticleSystem::hasTransparentObjects(), NL3D::CParticleSystem::reactivateSound(), and NL3D::CParticleSystem::stopSound().

00194 { return _LocatedBoundCont.size(); }

uint32 NL3D::CPSLocated::getNewElementIndex void   )  const [inline]
 

Get the index of the new element that is created Valid only after the newElement method (overridable) of a LocatedBindable is called : you get the index of the located being generated, if you need its pos, speed, or mass.

Definition at line 266 of file ps_located.h.

References uint32.

Referenced by NL3D::CPSRibbonBase::newElement(), NL3D::CPSConstraintMesh::newElement(), and NL3D::CPSFace::newElement().

00266 { return _Size; }

const CParticleSystem* NL3D::CParticleSystemProcess::getOwner void   )  const [inline, inherited]
 

retrieve the particle system that owns this process (const version)

Definition at line 114 of file particle_system_process.h.

00114 { return _Owner ; }

CParticleSystem* NL3D::CParticleSystemProcess::getOwner void   )  [inline, inherited]
 

Retrieve the particle system that owns this process.

Definition at line 111 of file particle_system_process.h.

Referenced by NL3D::CPSTargetLocatedBindable::attachTarget(), NL3D::CPSEmitter::checkLoop(), NL3D::CPSParticle::computeSrcStep(), NL3D::CPSMesh::deleteElement(), NL3D::CPSLocatedBindable::displayIcon2d(), NL3D::CPSTailDot::displayRibbons(), NL3D::CPSRibbonLookAt::displayRibbons(), NL3D::CPSRibbon::displayRibbons(), NL3D::CPSShockWave::draw(), NL3D::CPSDot::draw(), NL3D::CPSConstraintMeshHelper::drawMeshs(), NL3D::CPSConstraintMeshHelper::drawPrerotatedMeshs(), NL3D::CPSLocatedBindable::finalize(), NL3D::GenEmitterPositions(), NL3D::GenEmitterPositionsWithLOD(), NL3D::CPSLocatedBindable::getInvertedSysMat(), NL3D::CPSLocatedBindable::getInvertedViewMat(), NL3D::CPSLocatedBindable::getSysMat(), NL3D::CPSLocatedBindable::getViewMat(), NL3D::CPSConstraintMesh::newElement(), NL3D::CPSMesh::newElement(), NL3D::CPSEmitter::processRegularEmission(), NL3D::CPSEmitter::processRegularEmissionConsistent(), NL3D::CPSEmitter::processRegularEmissionConsistentWithNoLOD(), NL3D::CPSEmitter::processRegularEmissionWithNoLOD(), NL3D::CParticleSystem::registerLocatedBindableExternID(), NL3D::CPSEmitter::setEmissionType(), NL3D::CPSEmitter::setEmitDelay(), NL3D::CPSEmitter::setEmittedType(), NL3D::CPSLocatedBindable::setExternID(), NL3D::CPSEmitter::setMaxEmissionCount(), NL3D::CPSLocatedBindable::setOwner(), NL3D::CPSEmitter::setPeriod(), NL3D::CPSEmitter::setPeriodScheme(), NL3D::CPSTailDot::setupGlobalColor(), NL3D::CPSFanLight::setupMaterial(), NL3D::CPSRibbon::setupTexturedGlobalColor(), NL3D::CPSRibbon::setupUntexturedGlobalColor(), NL3D::CPSZoneRectangle::show(), NL3D::CPSZoneCylinder::show(), NL3D::CPSZoneDisc::show(), NL3D::CPSZoneSphere::show(), NL3D::CPSZonePlane::show(), NL3D::CPSLight::show(), NL3D::CPSCylindricVortex::show(), NL3D::CPSDirectionnalForce::show(), NL3D::CPSSphericalEmitter::showTool(), NL3D::CPSEmitterRectangle::showTool(), NL3D::CPSEmitter::showTool(), NL3D::CPSTailDot::step(), NL3D::CPSRibbonLookAt::step(), NL3D::CPSRibbon::step(), NL3D::CPSLight::step(), NL3D::CPSEmitter::step(), NL3D::CPSRibbonBase::systemDateChanged(), NL3D::CParticleSystem::unregisterLocatedBindableExternID(), NL3D::CPSConstraintMesh::update(), NL3D::CPSRibbonBase::updateGlobals(), NL3D::CPSRibbonBase::updateLOD(), NL3D::CPSQuad::updateMatBeforeRendering(), NL3D::CPSTailDot::updateMaterial(), NL3D::CPSMesh::updatePos(), NL3D::CPSEmitter::updatePSRefCountForUserMatrixUsage(), NL3D::CPSRibbon::updateTexturedMaterial(), NL3D::CPSRibbon::updateUntexturedMaterial(), NL3D::CPSQuad::updateVbColNUVForRender(), NL3D::CPSLight::~CPSLight(), NL3D::CPSLocatedBindable::~CPSLocatedBindable(), and NL3D::CPSMesh::~CPSMesh().

00111 { return _Owner ; }

TPSAttribParametricInfo& NL3D::CPSLocated::getParametricInfos  )  [inline]
 

PRIVATE USE : access to parametric infos.

Definition at line 772 of file ps_located.h.

References _PInfo, and TPSAttribParametricInfo.

Referenced by NL3D::CompensateEmission().

00772 { return _PInfo; }

const TPSAttribVector& NL3D::CPSLocated::getPos void   )  const [inline]
 

get Pos attrib const ref

Definition at line 336 of file ps_located.h.

References NL3D::TPSAttribVector.

00336 { return _Pos; }

TPSAttribVector& NL3D::CPSLocated::getPos void   )  [inline]
 

get Pos attrib ref

Definition at line 334 of file ps_located.h.

References NL3D::TPSAttribVector.

Referenced by NL3D::CPSZonePlane::buildBasis(), NL3D::CompensateEmission(), NL3D::CPSLocatedBindable::displayIcon2d(), NL3D::CPSShockWave::draw(), NL3D::CPSConstraintMesh::draw(), NL3D::CPSFanLight::draw(), NL3D::CPSFaceLookAt::draw(), NL3D::CPSDot::draw(), NL3D::GenEmitterPositions(), NL3D::GenEmitterPositionsWithLOD(), NL3D::CPSAttribMakerT< T, F >::get(), NL3D::CPSZoneRectangle::getMatrix(), NL3D::CPSZoneCylinder::getMatrix(), NL3D::CPSZoneDisc::getMatrix(), NL3D::CPSZoneSphere::getMatrix(), NL3D::CPSCylindricVortex::getMatrix(), NL3D::CPSSphericalEmitter::getMatrix(), NL3D::CPSEmitterRectangle::getMatrix(), NL3D::CPSAttribMakerT< uint32, CPSValueBlendFunc< uint32 > >::make(), NL3D::CPSAttribMakerT< uint32, CPSValueBlendFunc< uint32 > >::make4(), NL3D::CPSAttribMakerT< uint32, CPSValueBlendFunc< uint32 > >::makeN(), NL3D::CPSSound::newElement(), NL3D::CPSRibbonBase::newElement(), NL3D::CPSCylindricVortex::performDynamic(), NL3D::CPSSpring::performDynamic(), NL3D::CPSCentralGravity::performDynamic(), NL3D::CPSZoneRectangle::performMotion(), NL3D::CPSZoneCylinder::performMotion(), NL3D::CPSZoneDisc::performMotion(), NL3D::CPSZoneSphere::performMotion(), NL3D::CPSZonePlane::performMotion(), NL3D::CPSEmitter::processEmit(), NL3D::CPSRibbonBase::resetFromOwner(), NL3D::CPSZoneRectangle::setMatrix(), NL3D::CPSZoneCylinder::setMatrix(), NL3D::CPSZoneDisc::setMatrix(), NL3D::CPSZoneSphere::setMatrix(), NL3D::CPSZonePlane::setMatrix(), NL3D::CPSCylindricVortex::setMatrix(), NL3D::CPSSphericalEmitter::setMatrix(), NL3D::CPSEmitterRectangle::setMatrix(), NL3D::CPSZoneRectangle::show(), NL3D::CPSZoneCylinder::show(), NL3D::CPSZoneDisc::show(), NL3D::CPSZoneSphere::show(), NL3D::CPSZonePlane::show(), NL3D::CPSLight::show(), NL3D::CPSCylindricVortex::show(), NL3D::CPSGravity::show(), NL3D::CPSDirectionnalForce::show(), NL3D::CPSSphericalEmitter::showTool(), NL3D::CPSEmitterRectangle::showTool(), NL3D::CPSEmitter::showTool(), NL3D::CPSSound::step(), NL3D::CPSLight::step(), NL3D::CPSFace::step(), NL3D::CPSRibbonBase::updateGlobals(), and NL3D::CPSMesh::updatePos().

00334 { return _Pos; }

CScene * NL3D::CPSLocated::getScene void   ) 
 

***************************************************************************************

Definition at line 492 of file ps_located.cpp.

References CHECK_PS_INTEGRITY, NL3D::CParticleSystem::getScene(), and nlassert.

Referenced by NL3D::CPSMesh::deleteElement(), NL3D::CPSLight::deleteElement(), NL3D::CPSMesh::newElement(), NL3D::CPSMesh::releaseAllRef(), NL3D::CPSLight::releaseAllRef(), NL3D::CPSConstraintMesh::update(), NL3D::CPSMesh::updatePos(), and NL3D::CPSMesh::~CPSMesh().

00493 {
00494         nlassert(_Owner);
00495         CHECK_PS_INTEGRITY
00496         return _Owner->getScene();
00497 }

uint32 NL3D::CPSLocated::getSize void   )  const [inline]
 

get the current number of instance in this located container

Definition at line 361 of file ps_located.h.

References uint32.

Referenced by NL3D::CPSParticle::computeSrcStep(), NL3D::CPSRibbonBase::deleteElement(), NL3D::CPSConstraintMesh::deleteElement(), deleteElement(), NL3D::CPSFace::deleteElement(), NL3D::CPSLocatedBindable::displayIcon2d(), NL3D::CPSShockWave::draw(), NL3D::CPSFanLight::draw(), NL3D::CPSFaceLookAt::draw(), NL3D::CPSDot::draw(), NL3D::CPSRibbonBase::dupRibbon(), NL3D::CParticleSystemInstanceUser::emit(), NL3D::CParticleSystem::evalDuration(), NL3D::CParticleSystem::getCurrNumParticles(), NL3D::CPSEmitter::hasEmitters(), NL3D::CPSParticle::hasParticles(), NL3D::CParticleSystem::matchArraySize(), NL3D::CIsotropicForceT< T >::performDynamic(), NL3D::CPSBrownianForce::performDynamic(), NL3D::CPSMagneticForce::performDynamic(), NL3D::CPSCylindricVortex::performDynamic(), NL3D::CPSSpring::performDynamic(), NL3D::CPSCentralGravity::performDynamic(), NL3D::CPSGravity::performDynamic(), NL3D::CPSDirectionnalForce::performDynamic(), NL3D::CPSEmitter::processRegularEmission(), NL3D::CPSEmitter::processRegularEmissionConsistent(), NL3D::CPSEmitter::processRegularEmissionConsistentWithNoLOD(), NL3D::CPSEmitter::processRegularEmissionWithNoLOD(), NL3D::CParticleSystemInstanceUser::removeByID(), NL3D::CPSConstraintMesh::resize(), NL3D::CPSEmitter::resize(), NL3D::CPSLight::setAttenEndScheme(), NL3D::CPSLight::setAttenStartScheme(), NL3D::CPSLight::setColorScheme(), NL3D::CPSSound::setGainScheme(), NL3D::CPSEmitter::setGenNbScheme(), NL3D::CPSConstraintMesh::setMorphScheme(), NL3D::CPSLocatedBindable::setOwner(), NL3D::CPSEmitter::setPeriodScheme(), NL3D::CPSSound::setPitchScheme(), NL3D::CPSShockWave::setUFactor(), NL3D::CPSZoneRectangle::show(), NL3D::CPSCylindricVortex::show(), NL3D::CPSDirectionnalForce::show(), NL3D::CPSEmitterRectangle::showTool(), NL3D::CPSEmitter::showTool(), NL3D::CPSSound::step(), NL3D::CPSFace::step(), NL3D::CPSEmitter::step(), NL3D::CPSRibbonBase::updateGlobals(), NL3D::CPSEmitter::updateMaxCountVect(), and NL3D::CPSMesh::updatePos().

00362         { 
00363                 return _Size; 
00364         }

const TPSAttribVector& NL3D::CPSLocated::getSpeed void   )  const [inline]
 

get Speed attrib const ref

Definition at line 341 of file ps_located.h.

References NL3D::TPSAttribVector.

00341 { return _Speed; }

TPSAttribVector& NL3D::CPSLocated::getSpeed void   )  [inline]
 

get Speed attrib ref

Definition at line 339 of file ps_located.h.

References NL3D::TPSAttribVector.

Referenced by NL3D::CompensateEmission(), NL3D::CPSFaceLookAt::draw(), NL3D::GenEmitterPositions(), NL3D::GenEmitterPositionsWithLOD(), NL3D::CPSPlaneBasisFollowSpeed::get(), NL3D::CPSAttribMakerT< T, F >::get(), NL3D::CPSPlaneBasisFollowSpeed::make(), NL3D::CPSAttribMakerT< uint32, CPSValueBlendFunc< uint32 > >::make(), NL3D::CPSPlaneBasisFollowSpeed::make4(), NL3D::CPSAttribMakerT< uint32, CPSValueBlendFunc< uint32 > >::make4(), NL3D::CPSPlaneBasisFollowSpeed::makeN(), NL3D::CPSAttribMakerT< uint32, CPSValueBlendFunc< uint32 > >::makeN(), NL3D::CPSSound::newElement(), NL3D::CPSEmitter::processEmit(), NL3D::CPSEmitter::processEmitConsistent(), and NL3D::CPSSound::step().

00339 { return _Speed; }

const TPSAttribTime& NL3D::CPSLocated::getTime void   )  const [inline]
 

get Time attrib const ref

Definition at line 346 of file ps_located.h.

References NL3D::TPSAttribTime.

00346 { return _Time; }

TPSAttribTime& NL3D::CPSLocated::getTime void   )  [inline]
 

get Time attrib ref

Definition at line 344 of file ps_located.h.

References NL3D::TPSAttribTime.

Referenced by NL3D::CompensateEmission(), NL3D::CPSFanLight::draw(), NL3D::FillQuadCoordsLocalTime(), NL3D::CPSAttribMakerT< T, F >::get(), NL3D::CPSAttribMakerT< uint32, CPSValueBlendFunc< uint32 > >::make(), NL3D::CPSAttribMakerT< uint32, CPSValueBlendFunc< uint32 > >::make4(), and NL3D::CPSAttribMakerT< uint32, CPSValueBlendFunc< uint32 > >::makeN().

00344 { return _Time; }

const TPSAttribTime& NL3D::CPSLocated::getTimeIncrement void   )  const [inline]
 

get TotalTime attrib const ref

Definition at line 351 of file ps_located.h.

References _TimeIncrement, and NL3D::TPSAttribTime.

00351 { return _TimeIncrement; }

TPSAttribTime& NL3D::CPSLocated::getTimeIncrement void   )  [inline]
 

get TotalTime attrib ref

Definition at line 349 of file ps_located.h.

References _TimeIncrement, and NL3D::TPSAttribTime.

Referenced by NL3D::CompensateEmission().

00349 { return _TimeIncrement; }

uint32 NL3D::CPSLocated::getTriggerEmitterID void   )  const [inline]
 

Get the ID for the emitter to be triggered on death.

Definition at line 565 of file ps_located.h.

References _TriggerID, _TriggerOnDeath, nlassert, and uint32.

00566         { 
00567                 nlassert(_TriggerOnDeath);
00568                 return _TriggerID; 
00569         }

uint NL3D::CPSLocated::getUserMatrixUsageCount  )  const [virtual]
 

***************************************************************************************

Reimplemented from NL3D::CParticleSystemProcess.

Definition at line 2284 of file ps_located.cpp.

References _LocatedBoundCont, count, and uint.

02285 {
02286         uint count = 0;
02287         for(TLocatedBoundCont::const_iterator it = _LocatedBoundCont.begin(); it != _LocatedBoundCont.end(); ++it)
02288         {
02289                 count += (*it)->getUserMatrixUsageCount();              
02290         }
02291         return count + CParticleSystemProcess::getUserMatrixUsageCount();
02292 }

float NL3D::CPSLocated::getUserParam uint  numParam  )  const
 

***************************************************************************************

Definition at line 484 of file ps_located.cpp.

References CHECK_PS_INTEGRITY, NL3D::CParticleSystem::getUserParam(), nlassert, and uint.

Referenced by NL3D::CPSAttribMakerT< T, F >::get(), NL3D::CPSAttribMakerT< uint32, CPSValueBlendFunc< uint32 > >::make(), NL3D::CPSAttribMakerT< uint32, CPSValueBlendFunc< uint32 > >::make4(), and NL3D::CPSAttribMakerT< uint32, CPSValueBlendFunc< uint32 > >::makeN().

00485 {
00486         nlassert(_Owner);
00487         CHECK_PS_INTEGRITY
00488         return _Owner->getUserParam(numParam);
00489 }

const NLMISC::CMatrix & NL3D::CPSLocated::getWorldToLocalMatrix  )  const
 

Definition at line 108 of file ps_located.cpp.

References NL3D::CParticleSystem::getInvertedSysMat(), NL3D::CParticleSystem::getInvertedUserMatrix(), NL3D::CParticleSystemProcess::getMatrixMode(), nlassert, NL3D::PSFXWorldMatrix, NL3D::PSIdentityMatrix, and NL3D::PSUserMatrix.

Referenced by computeI(), computeJ(), and computeK().

00109 {
00110         nlassert(_Owner);
00111         switch(getMatrixMode())
00112         {
00113                 case PSFXWorldMatrix:                           return _Owner->getInvertedSysMat();
00114                 case PSIdentityMatrix:                          return NLMISC::CMatrix::Identity;
00115                 case PSUserMatrix:      return _Owner->getInvertedUserMatrix();
00116                 default:
00117                         nlassert(0);
00118         }
00119         nlassert(0);
00120         return NLMISC::CMatrix::Identity;
00121 }

bool NL3D::CPSLocated::hasCollisionInfos  )  const [inline]
 

test wether this located has collision infos

Definition at line 435 of file ps_located.h.

References _CollisionInfo.

Referenced by NL3D::CompensateEmission().

00435 { return _CollisionInfo != NULL; }

bool NL3D::CPSLocated::hasEmitters void   )  const [virtual]
 

tells wether there are alive emitters / particles in the system

Reimplemented from NL3D::CParticleSystemProcess.

Definition at line 463 of file ps_located.cpp.

References _LocatedBoundCont, CHECK_PS_INTEGRITY, and NL3D::PSEmitter.

00464 {
00465         CHECK_PS_INTEGRITY
00466         for (TLocatedBoundCont::const_iterator it = _LocatedBoundCont.begin(); it != _LocatedBoundCont.end(); ++it)
00467         {
00468                 if ((*it)->getType() == PSEmitter && (*it)->hasEmitters()) return true;
00469         }
00470         CHECK_PS_INTEGRITY
00471         return false;
00472 }

bool NL3D::CPSLocated::hasLODDegradation void   )  const [inline]
 

Test whether LOD degradation was activated

See also:
forceLODDegradation()

Definition at line 514 of file ps_located.h.

References _LODDegradation.

00514 { return _LODDegradation; }

bool NL3D::CPSLocated::hasParticles void   )  const [virtual]
 

tells wether there are alive entities / particles in the system

Reimplemented from NL3D::CParticleSystemProcess.

Definition at line 450 of file ps_located.cpp.

References _LocatedBoundCont, CHECK_PS_INTEGRITY, and NL3D::PSParticle.

Referenced by NL3D::CParticleSystem::hasTemporaryParticles().

00451 {       
00452         CHECK_PS_INTEGRITY
00453         for (TLocatedBoundCont::const_iterator it = _LocatedBoundCont.begin(); it != _LocatedBoundCont.end(); ++it)
00454         {
00455                 if ((*it)->getType() == PSParticle && (*it)->hasParticles()) return true;
00456         }
00457         CHECK_PS_INTEGRITY
00458         return false;
00459 }

void NL3D::CPSLocated::incrementNbDrawnParticles uint  num  ) 
 

***************************************************************************************

Shorcut to increase the particle counter (number of particle drawn, for benchmark purpose ) should be called only by bound object that display particles

Definition at line 500 of file ps_located.cpp.

References CHECK_PS_INTEGRITY, num, and uint.

Referenced by NL3D::CPSTailDot::displayRibbons(), NL3D::CPSRibbonLookAt::displayRibbons(), NL3D::CPSRibbon::displayRibbons(), NL3D::CPSConstraintMesh::draw(), NL3D::CPSDot::draw(), NL3D::CPSFaceHelper::drawFaces(), NL3D::CPSFanLightHelper::drawFanLight(), NL3D::CPSFaceLookAtHelper::drawLookAt(), NL3D::CPSFaceLookAtHelper::drawLookAtAlignOnMotion(), and NL3D::CPSMesh::updatePos().

00501 {
00502         CHECK_PS_INTEGRITY
00503         CParticleSystem::NbParticlesDrawn += num; // for benchmark purpose      
00504 }

void NL3D::CPSLocated::integrableForceBasisChanged TPSMatrixMode  basis  ) 
 

***************************************************************************************

Definition at line 1885 of file ps_located.cpp.

References _NumIntegrableForceWithDifferentBasis, CHECK_PS_INTEGRITY, NL3D::CParticleSystemProcess::getMatrixMode(), and releaseParametricInfos().

Referenced by setMatrixMode().

01886 {       
01887         CHECK_PS_INTEGRITY
01888         if (getMatrixMode() != matrixMode)
01889         {
01890                 ++_NumIntegrableForceWithDifferentBasis;
01891                 releaseParametricInfos();
01892         }
01893         else
01894         {
01895                 --_NumIntegrableForceWithDifferentBasis;
01896         }
01897         CHECK_PS_INTEGRITY
01898 }

void NL3D::CPSLocated::integrateSingle float  startDate,
float  deltaT,
uint  numStep,
uint32  indexInLocated,
NLMISC::CVector destPos,
uint  posStride = sizeof(NLMISC::CVector)
 

***************************************************************************************

Compute the trajectory of the given located. NB : only works with object that have parametric trajectories

Definition at line 256 of file ps_located.cpp.

References _IntegrableForces, _ParametricMotion, _PInfo, CHECK_PS_INTEGRITY, NL3D::CPSLocated::CParametricInfo::Date, NL3D::FillBufUsingSubdiv(), nlassert, NL3D::CPSLocated::CParametricInfo::Pos, NL3D::CPSLocated::CParametricInfo::Speed, stride, supportParametricMotion(), uint, uint32, uint8, NLMISC::CVector::x, NLMISC::CVector::y, and NLMISC::CVector::z.

Referenced by NL3D::CPSTailDot::displayRibbons(), NL3D::CPSRibbonLookAt::displayRibbons(), NL3D::CPSRibbon::displayRibbons(), NL3D::GenEmitterPositions(), and NL3D::GenEmitterPositionsWithLOD().

00260 {
00261         CHECK_PS_INTEGRITY
00262         nlassert(supportParametricMotion() && _ParametricMotion);
00263         if (_IntegrableForces.size() != 0)
00264         {
00265                 bool accumulate = false;
00266                 for (TForceVect::iterator it = _IntegrableForces.begin(); it != _IntegrableForces.end(); ++it)
00267                 {
00268                         nlassert((*it)->isIntegrable());
00269                         (*it)->integrateSingle(startDate, deltaT, numStep, this, indexInLocated, destPos, accumulate, stride);
00270                         accumulate = true;
00271                 }
00272         }
00273         else // no forces applied, just deduce position from date, initial pos and speed
00274         {
00275                         #ifdef NL_DEBUG
00276                                 NLMISC::CVector *endPos = (NLMISC::CVector *) ( (uint8 *) destPos + stride * numStep);
00277                         #endif
00278                         const CPSLocated::CParametricInfo &pi = _PInfo[indexInLocated];
00279                         destPos = FillBufUsingSubdiv(pi.Pos, pi.Date, startDate, deltaT, numStep, destPos, stride);
00280                         if (numStep != 0)
00281                         {                       
00282                                 float currDate = startDate - pi.Date;
00283                                 nlassert(currDate >= 0);
00284                                 do
00285                                 {
00286                                         #ifdef NL_DEBUG
00287                                                 nlassert(destPos < endPos);
00288                                         #endif                                  
00289                                         destPos->x = pi.Pos.x + currDate * pi.Speed.x;
00290                                         destPos->y = pi.Pos.y + currDate * pi.Speed.y;
00291                                         destPos->z = pi.Pos.z + currDate * pi.Speed.z;
00292                                         currDate += deltaT;
00293                                         destPos = (NLMISC::CVector *) ( (uint8 *) destPos + stride);
00294                                 }
00295                                 while (--numStep);
00296                         }       
00297         }
00298         CHECK_PS_INTEGRITY
00299 }

bool NL3D::CPSLocated::isBound const CPSLocatedBindable lb  )  const
 

***************************************************************************************

Definition at line 1914 of file ps_located.cpp.

References _LocatedBoundCont, and CHECK_PS_INTEGRITY.

01915 {
01916         CHECK_PS_INTEGRITY
01917         TLocatedBoundCont::const_iterator it = std::find(_LocatedBoundCont.begin(), _LocatedBoundCont.end(), lb);
01918         return it != _LocatedBoundCont.end();
01919         CHECK_PS_INTEGRITY
01920 }

virtual bool NL3D::CPSLocated::isLocated  )  const [inline, virtual]
 

Reimplemented from NL3D::CParticleSystemProcess.

Definition at line 148 of file ps_located.h.

00148 { return true; }

bool NL3D::CPSLocated::isParametricMotionEnabled void   )  const [inline, virtual]
 

test wether parametric motion is enabled

Reimplemented from NL3D::CParticleSystemProcess.

Definition at line 535 of file ps_located.h.

References _ParametricMotion.

Referenced by NL3D::CompensateEmission(), NL3D::GenEmitterPositions(), and NL3D::GenEmitterPositionsWithLOD().

00535 { return _ParametricMotion;}

bool NL3D::CPSLocated::isTriggerOnDeathEnabled void   )  const [inline]
 

Test wether a trigger on death has been enabled.

Definition at line 555 of file ps_located.h.

References _TriggerOnDeath.

00555 { return _TriggerOnDeath; }

sint32 NL3D::CPSLocated::newElement const NLMISC::CVector pos,
const NLMISC::CVector speed,
CPSLocated emitterLocated,
uint32  indexInEmitter,
TPSMatrixMode  speedCoordSystem,
TAnimationTime  ellapsedTime
 

***************************************************************************************

Generate one more instance in a located. The coordinate are given in the chosen basis for the located. If the emitterLocated ptr is not null, then the coordinate are taken from the emitterLocated basis and are expressed in this located basis. other attributes are generated according to other properties of this class Will succeed only if it hasn't reach the max number of allowed instances return will be -1 if call failed or an index to the created object. Index is only valid after creation. Any processing pass on the system will make it invalid. It can be used with any attribute modification method of located and located bindable

Parameters:
indexInEmitter The index of the emitter (in the emitterLocated object)
basisConversionForSpeed : if false, the speed vector is taken as if even if emitter and emittee basis are differents.
ellapsedTime 

Definition at line 852 of file ps_located.cpp.

References _CollisionInfo, _InitialLife, _InitialMass, _InvMass, _LifeScheme, _LocatedBoundCont, _MassScheme, _ParametricMotion, _PInfo, _TimeIncrement, _UpdateLock, CHECK_PS_INTEGRITY, NL3D::CPSAttribMaker< float >::get(), NL3D::CParticleSystem::getAutoCountFlag(), getConversionMatrix(), NL3D::CParticleSystem::getInvertedSysMat(), NL3D::CParticleSystem::getInvertedUserMatrix(), NL3D::CParticleSystemProcess::getMatrixMode(), getMaxSize(), NL3D::CParticleSystem::getSysMat(), NL3D::CParticleSystem::getSystemDate(), NL3D::CParticleSystem::getUserMatrix(), NL3D::CPSAttrib< CParametricInfo >::insert(), NL3D::CPSAttrib< float >::insert(), NL3D::CPSAttrib< T >::insert(), NL3D::CParticleSystem::interpolateFXPosDelta(), NL3D::CParticleSystem::interpolateUserPosDelta(), NLMISC::CMatrix::mulVector(), nlassert, postNewElement(), NL3D::PSFXWorldMatrix, NL3D::PSIdentityMatrix, NL3D::PSUserMatrix, resize(), sint32, NL3D::TAnimationTime, uint, and uint32.

Referenced by NL3D::CPSEmitter::processEmit(), NL3D::CPSEmitter::processEmitConsistent(), and updateNewElementRequestStack().

00853 {       
00854         CHECK_PS_INTEGRITY
00855         if (_UpdateLock)
00856         {
00857                 postNewElement(pos, speed);
00858                 return -1;
00859         }
00860                 
00861 
00862         sint32 creationIndex;
00863 
00864         // get the convertion matrix  from the emitter basis to the emittee basis
00865         // if the emitter is null, we assume that the coordinate are given in the chosen basis for this particle type
00866                 
00867         if (_MaxSize == _Size) 
00868         {
00869                 if (_Owner && _Owner->getAutoCountFlag() && getMaxSize() < ((1 << 16) - 1) )
00870                 {
00871                         // we are probably in edition mode -> auto-count mode helps to compute ideal particle array size
00872                         // but at the expense of costly allocations
00873                         uint maxSize = getMaxSize();
00874                         resize(maxSize == 0 ? 1 : NLMISC::raiseToNextPowerOf2(maxSize) - 1); // force a reserve with next power of 2 (no important in edition mode)
00875                         resize(maxSize + 1);
00876                 }
00877                 else
00878                 {               
00879                         return -1;
00880                 }
00881         }
00882         if (_CollisionInfo)
00883         {
00884                 _CollisionInfo->insert();
00885         }
00886 
00887         // During creation, we interpolate the position of the system (by using the ellapsed time) if particle are created in world basis and if the emitter is in local basis.
00888         // Example a fireball FX let particles in world basis, but the fireball is moving. If we dont interpolate position between 2 frames, emission will appear to be "sporadic".
00889         // For now, we manage the local to world case. The world to local is possible, but not very useful      
00890         switch(emitter ? emitter->getMatrixMode() : this->getMatrixMode())
00891         {
00892                 case PSFXWorldMatrix:
00893                         switch(this->getMatrixMode())
00894                         {
00895                                 case PSFXWorldMatrix:
00896                                 {                                                               
00897                                         creationIndex  =_Pos.insert(pos);
00898                                 }
00899                                 break;
00900                                 case PSIdentityMatrix:
00901                                 {                       
00902                                         CVector fxPosDelta;
00903                                         _Owner->interpolateFXPosDelta(fxPosDelta, ellapsedTime);
00904                                         creationIndex  =_Pos.insert(_Owner->getSysMat() * pos + fxPosDelta);
00905                                 }
00906                                 break;
00907                                 case PSUserMatrix:
00908                                 {                                       
00909                                         CVector fxPosDelta;
00910                                         _Owner->interpolateFXPosDelta(fxPosDelta, ellapsedTime);
00911                                         CVector userMatrixPosDelta;
00912                                         _Owner->interpolateUserPosDelta(userMatrixPosDelta, ellapsedTime);
00913                                         creationIndex  =_Pos.insert(_Owner->getInvertedUserMatrix() * (_Owner->getSysMat() * pos + fxPosDelta - userMatrixPosDelta));
00914                                 }
00915                                 break;
00916                                 default:
00917                                 nlassert(0);
00918                         }
00919                 break;
00920                 case PSIdentityMatrix:
00921                         switch(this->getMatrixMode())
00922                         {
00923                                 case PSFXWorldMatrix:
00924                                 {                                       
00925                                         CVector fxPosDelta;
00926                                         _Owner->interpolateFXPosDelta(fxPosDelta, ellapsedTime);
00927                                         creationIndex  =_Pos.insert(_Owner->getInvertedSysMat() * (pos - fxPosDelta));
00928                                 }
00929                                 break;
00930                                 case PSIdentityMatrix:
00931                                 {                                       
00932                                         creationIndex  =_Pos.insert(pos);
00933                                 }
00934                                 break;
00935                                 case PSUserMatrix:
00936                                 {                                       
00937                                         CVector userMatrixPosDelta;
00938                                         _Owner->interpolateUserPosDelta(userMatrixPosDelta, ellapsedTime);
00939                                         creationIndex  =_Pos.insert(_Owner->getInvertedUserMatrix() * (pos - userMatrixPosDelta));
00940                                 }
00941                                 break;
00942                                 default:
00943                                 nlassert(0);
00944                         }
00945                 break;
00946                 case PSUserMatrix:
00947                         switch(this->getMatrixMode())
00948                         {
00949                                 case PSFXWorldMatrix:
00950                                 {                                       
00951                                         CVector fxPosDelta;
00952                                         _Owner->interpolateFXPosDelta(fxPosDelta, ellapsedTime);
00953                                         CVector userMatrixPosDelta;
00954                                         _Owner->interpolateUserPosDelta(userMatrixPosDelta, ellapsedTime);
00955                                         creationIndex  =_Pos.insert(_Owner->getInvertedSysMat() * (_Owner->getUserMatrix() * pos + userMatrixPosDelta- fxPosDelta));
00956                                 }
00957                                 break;
00958                                 case PSIdentityMatrix:
00959                                 {                               
00960                                         CVector userMatrixPosDelta;
00961                                         _Owner->interpolateUserPosDelta(userMatrixPosDelta, ellapsedTime);
00962                                         creationIndex  =_Pos.insert(_Owner->getUserMatrix() * pos + userMatrixPosDelta);        
00963                                 }
00964                                 break;
00965                                 case PSUserMatrix:
00966                                 {                                       
00967                                         creationIndex  =_Pos.insert(pos);
00968                                 }
00969                                 break;
00970                                 default:
00971                                 nlassert(0);
00972                         }
00973                 break;
00974                 default:
00975                         nlassert(0);
00976         }
00977 
00978         
00979         nlassert(creationIndex != -1); // all attributs must contains the same number of elements       
00980 
00981         if (speedCoordSystem == this->getMatrixMode()) // is speed vector expressed in the good basis ?
00982         {               
00983                 _Speed.insert(speed);
00984         }
00985         else
00986         {
00987                 // must do conversion of speed
00988                 nlassert(_Owner);
00989                 const NLMISC::CMatrix &convMat = getConversionMatrix(*_Owner, this->getMatrixMode(), speedCoordSystem);
00990                 _Speed.insert(convMat.mulVector(speed));
00991         }
00992                         
00993         _InvMass.insert(1.f / ((_MassScheme && emitter) ? _MassScheme->get(emitter, indexInEmitter) : _InitialMass ) );
00994         _Time.insert(0.0f);     
00995         const float lifeTime = (_LifeScheme && emitter) ?  _LifeScheme->get(emitter, indexInEmitter) : _InitialLife ;
00996         _TimeIncrement.insert( lifeTime ? 1.f / lifeTime : 10E6f);
00997 
00998         // test wether parametric motion is used, and generate the infos that are needed then
00999         if (_ParametricMotion)
01000         {
01001                 _PInfo.insert( CParametricInfo(_Pos[creationIndex], _Speed[creationIndex], _Owner->getSystemDate() ) );
01002         }
01003 
01004 
01006         // generate datas for all bound objects  //
01008         _UpdateLock = true;     
01009 
01010         
01011         for (TLocatedBoundCont::iterator it = _LocatedBoundCont.begin(); it != _LocatedBoundCont.end(); ++it)
01012         {
01013                 (*it)->newElement(emitter, indexInEmitter);
01014         }
01015 
01016         
01017         _UpdateLock = false;    
01018         ++_Size;        // if this is modified, you must also modify the getNewElementIndex in this class
01019                                 // because that method give the index of the element being created for overrider of the newElement method
01020                                 // of the CPSLocatedClass (which is called just above)
01021 
01022         
01023         CHECK_PS_INTEGRITY
01024         return creationIndex;
01025 }

NL3D::CPSLocated::NLMISC_DECLARE_CLASS CPSLocated   ) 
 

void NL3D::CPSLocated::notifyMaxNumFacesChanged void   ) 
 

***************************************************************************************

nlassertex(maxNumFaces < ((1 << 16) - 1), ("%s", (*it)->getClassName().c_str()));

Definition at line 422 of file ps_located.cpp.

References _LocatedBoundCont, _MaxNumFaces, CHECK_PS_INTEGRITY, NL3D::PSParticle, and uint.

Referenced by bind(), NL3D::CPSParticle::notifyOwnerMaxNumFacesChanged(), and resize().

00423 {
00424         CHECK_PS_INTEGRITY
00425         if (!_Owner) return;
00426         
00427         // we examine wether we have particle attached to us, and ask for the max number of faces they may want
00428         _MaxNumFaces  = 0;
00429         for (TLocatedBoundCont::const_iterator it = _LocatedBoundCont.begin(); it != _LocatedBoundCont.end(); ++it)
00430         {
00431                 if ((*it)->getType() == PSParticle)
00432                 {
00433                         uint maxNumFaces = ((CPSParticle *) (*it))->getMaxNumFaces();
00435                         _MaxNumFaces += maxNumFaces;
00436                 }
00437         }
00438         CHECK_PS_INTEGRITY
00439 }

void NL3D::CPSLocated::notifyMotionTypeChanged void   )  [protected]
 

***************************************************************************************

Definition at line 244 of file ps_located.cpp.

References _LocatedBoundCont, _ParametricMotion, and CHECK_PS_INTEGRITY.

Referenced by allocateParametricInfos(), and releaseParametricInfos().

00245 {
00246         CHECK_PS_INTEGRITY
00247         for (TLocatedBoundCont::const_iterator it = _LocatedBoundCont.begin(); it != _LocatedBoundCont.end(); ++it)
00248         {
00249                 (*it)->motionTypeChanged(_ParametricMotion);
00250         }
00251         CHECK_PS_INTEGRITY
00252 }

void NL3D::CPSLocated::performParametricMotion TAnimationTime  date,
TAnimationTime  ellapsedTime,
TAnimationTime  realEllapsedTime
[virtual]
 

***************************************************************************************

Reimplemented from NL3D::CParticleSystemProcess.

Definition at line 302 of file ps_located.cpp.

References _IntegrableForces, _ParametricMotion, _PInfo, NL3D::CPSAttrib< T >::begin(), NL3D::CPSAttrib< CParametricInfo >::begin(), CHECK_PS_INTEGRITY, NL3D::CPSAttrib< CParametricInfo >::end(), nlassert, supportParametricMotion(), and NL3D::TAnimationTime.

00303 {
00304         CHECK_PS_INTEGRITY
00305         if (!_Size) return;     
00306         nlassert(supportParametricMotion() && _ParametricMotion);
00307 
00308         if (_IntegrableForces.size() != 0)
00309         {
00310                 bool accumulate = false;
00311                 for (TForceVect::iterator it = _IntegrableForces.begin(); it != _IntegrableForces.end(); ++it)
00312                 {
00313                         nlassert((*it)->isIntegrable());
00314                         (*it)->integrate(date, this, 0, _Size, &_Pos[0], &_Speed[0], accumulate);
00315                         accumulate = true;
00316                 }
00317         }
00318         else
00319         {
00320                 CPSLocated::TPSAttribParametricInfo::const_iterator it = _PInfo.begin(),
00321                                                                                         endIt = _PInfo.end();
00322                 TPSAttribVector::iterator posIt = _Pos.begin();
00323                 float deltaT;
00324                 do
00325                 {
00326                         deltaT = date - it->Date;
00327                         posIt->x = it->Pos.x + deltaT * it->Speed.x;
00328                         posIt->y = it->Pos.y + deltaT * it->Speed.y;
00329                         posIt->z = it->Pos.z + deltaT * it->Speed.z;
00330                         ++posIt;
00331                         ++it;
00332                 }
00333                 while (it != endIt);
00334         }
00335         //step(PSEmit, ellapsedTime, realEllapsedTime); 
00336         CHECK_PS_INTEGRITY
00337 }

void NL3D::CPSLocated::postNewElement const NLMISC::CVector pos = NLMISC::CVector::Null,
const NLMISC::CVector speed = NLMISC::CVector::Null
[protected]
 

***************************************************************************************

Post a request for the generation of a new located. it is called by newElement when _UpdateLock is set (when called during newElement or deleteElement)

Definition at line 1028 of file ps_located.cpp.

References _RequestStack.

Referenced by newElement().

01029 {
01030         _RequestStack.push(CPostNewElementRequestInfo(pos, speed));
01031 }

uint NL3D::CPSLocated::querryMaxWantedNumFaces void   )  [virtual]
 

***************************************************************************************

Implements NL3D::CParticleSystemProcess.

Definition at line 442 of file ps_located.cpp.

References _MaxNumFaces, and uint.

00443 {
00444         return _MaxNumFaces;
00445 }

void NL3D::CPSLocated::queryCollisionInfo void   ) 
 

***************************************************************************************

call this if you need collision infos. The collide info attribute is not included by default to save memory. The first call will create the attribute, and others will add references. You can then access the infos by calling getCollisioInfo You must call releaseCollideInfo after use.

Definition at line 1783 of file ps_located.cpp.

References _CollisionInfo, _CollisionInfoNbRef, CHECK_PS_INTEGRITY, NL3D::CPSAttrib< T >::insert(), NL3D::CPSAttrib< T >::resize(), NL3D::TPSAttribCollisionInfo, and uint.

Referenced by NL3D::CPSZone::attachTarget().

01784 {
01785         CHECK_PS_INTEGRITY
01786         if (_CollisionInfoNbRef)
01787         {
01788                 ++ _CollisionInfoNbRef;
01789         }
01790         else
01791         {
01792                 _CollisionInfo = new TPSAttribCollisionInfo;
01793                 _CollisionInfoNbRef = 1;
01794                 _CollisionInfo->resize(_MaxSize);               
01795 
01796                 for(uint k = 0; k < _Size; ++k)
01797                 {
01798                         _CollisionInfo->insert();
01799                 }               
01800         }
01801         CHECK_PS_INTEGRITY
01802 }

void NL3D::CPSLocated::registerDtorObserver CPSLocatedBindable observer  ) 
 

***************************************************************************************

Register a dtor observer; (that derives from CPSLocatedBindable) Each observer will be called when this object dtor is called (call of method notifyTargetRemoved() ) This allow for objects that hold this as a target to know when it is suppressed (example : collision objects hold located as targets) When an observer is detroyed, it MUST call unregisterDtorObserver, The same observer can only register once, otherwise, an assertion occurs

Definition at line 824 of file ps_located.cpp.

References _DtorObserversVect, CHECK_PS_INTEGRITY, and nlassert.

Referenced by NL3D::CPSTargetLocatedBindable::attachTarget(), and NL3D::CPSEmitter::setEmittedType().

00825 {
00826         CHECK_PS_INTEGRITY
00827         // check wether the observer wasn't registered twice
00828         nlassert(std::find(_DtorObserversVect.begin(), _DtorObserversVect.end(), anObserver) == _DtorObserversVect.end());
00829         _DtorObserversVect.push_back(anObserver);
00830         CHECK_PS_INTEGRITY
00831 }

void NL3D::CPSLocated::registerIntegrableForce CPSForce f  ) 
 

***************************************************************************************

Definition at line 1836 of file ps_located.cpp.

References _IntegrableForces, _NumIntegrableForceWithDifferentBasis, CHECK_PS_INTEGRITY, NL3D::CParticleSystemProcess::getMatrixMode(), NL3D::CPSLocatedBindable::getOwner(), nlassert, and releaseParametricInfos().

Referenced by NL3D::CPSForce::attachTarget().

01837 {
01838         CHECK_PS_INTEGRITY
01839         nlassert(std::find(_IntegrableForces.begin(), _IntegrableForces.end(), f) == _IntegrableForces.end()); // force registered twice
01840         _IntegrableForces.push_back(f);
01841         if (getMatrixMode() != f->getOwner()->getMatrixMode())
01842         {
01843                 ++_NumIntegrableForceWithDifferentBasis;
01844                 releaseParametricInfos();
01845         }
01846         CHECK_PS_INTEGRITY
01847 }

void NL3D::CPSLocated::releaseAllRef  )  [virtual]
 

***************************************************************************************

From CParticleSystemProcess. Release any reference this located may have to other process of the system For example, this is used when detaching a process of a system.

Implements NL3D::CParticleSystemProcess.

Definition at line 212 of file ps_located.cpp.

References _CollisionInfo, _CollisionInfoNbRef, _DtorObserversVect, _IntegrableForces, _LocatedBoundCont, _NonIntegrableForceNbRefs, CHECK_PS_INTEGRITY, nlassert, and TDtorObserversVect.

00213 {
00214         CHECK_PS_INTEGRITY
00215          // located bindables
00216         {       
00217                 for(TLocatedBoundCont::iterator it = _LocatedBoundCont.begin(); it != _LocatedBoundCont.end(); ++it)
00218                 {
00219                         (*it)->releaseAllRef();
00220                 }
00221         }
00222 
00223         // we must do a copy, because the subsequent call can modify this vector
00224         TDtorObserversVect copyVect(_DtorObserversVect.begin(), _DtorObserversVect.end());
00225         // call all the dtor observers
00226         for (TDtorObserversVect::iterator it = copyVect.begin(); it != copyVect.end(); ++it)
00227         {
00228                 (*it)->notifyTargetRemoved(this);
00229         }
00230         _DtorObserversVect.clear();     
00231         
00232         nlassert(_CollisionInfoNbRef == 0); //If this is not = 0, then someone didnt call releaseCollisionInfo
00233                                                                                  // If this happen, you can register with the registerDTorObserver
00234                                                                                  // (observer pattern)
00235                                                                                  // and override notifyTargetRemove to call releaseCollisionInfo
00236         nlassert(_IntegrableForces.size() == 0);
00237         nlassert(_NonIntegrableForceNbRefs == 0);
00238         nlassert(!_CollisionInfo);
00239         CHECK_PS_INTEGRITY
00240 }

void NL3D::CPSLocated::releaseCollisionInfo void   ) 
 

***************************************************************************************

Definition at line 1805 of file ps_located.cpp.

References _CollisionInfo, _CollisionInfoNbRef, CHECK_PS_INTEGRITY, and nlassert.

Referenced by NL3D::CPSZone::releaseTargetRsc().

01806 {
01807         CHECK_PS_INTEGRITY
01808         nlassert(_CollisionInfoNbRef); // check whether queryCollisionInfo was called
01809                                                                         // so the number of refs must not = 0                                                                   
01810     --_CollisionInfoNbRef;
01811         if (_CollisionInfoNbRef == 0)
01812         {
01813                 delete _CollisionInfo;
01814                 _CollisionInfo = NULL;
01815         }
01816         CHECK_PS_INTEGRITY
01817 }

void NL3D::CPSLocated::releaseNonIntegrableForceRef void   ) 
 

***************************************************************************************

Definition at line 1875 of file ps_located.cpp.

References _NonIntegrableForceNbRefs, CHECK_PS_INTEGRITY, and nlassert.

Referenced by NL3D::CPSZone::releaseTargetRsc(), and NL3D::CPSForce::releaseTargetRsc().

01876 {
01877         CHECK_PS_INTEGRITY
01878         nlassert(_NonIntegrableForceNbRefs != 0);
01879         --_NonIntegrableForceNbRefs;
01880         CHECK_PS_INTEGRITY
01881 }

void NL3D::CPSLocated::releaseParametricInfos void   )  [protected]
 

release paametric infos

Definition at line 364 of file ps_located.cpp.

References _ParametricMotion, _PInfo, CHECK_PS_INTEGRITY, NLMISC::contReset(), and notifyMotionTypeChanged().

Referenced by addNonIntegrableForceRef(), enableParametricMotion(), integrableForceBasisChanged(), and registerIntegrableForce().

00365 {
00366         CHECK_PS_INTEGRITY
00367         if (!_ParametricMotion) return;
00368         NLMISC::contReset(_PInfo);
00369         _ParametricMotion = false;
00370         notifyMotionTypeChanged();
00371         CHECK_PS_INTEGRITY
00372 }

void NL3D::CPSLocated::releaseRefTo const CParticleSystemProcess other  )  [virtual]
 

***************************************************************************************

From CParticleSystemProcess. Release any reference this located may have on the given process. For example, this is used when detaching a located of a system.

Implements NL3D::CParticleSystemProcess.

Definition at line 185 of file ps_located.cpp.

References _DtorObserversVect, _LocatedBoundCont, CHECK_PS_INTEGRITY, and NL3D::CPSLocatedBindable::notifyTargetRemoved().

00186 {
00187         CHECK_PS_INTEGRITY
00188         // located bindables
00189         {       
00190                 for(TLocatedBoundCont::iterator it = _LocatedBoundCont.begin(); it != _LocatedBoundCont.end(); ++it)
00191                 {
00192                         (*it)->releaseRefTo(other);
00193                 }
00194         }
00195         // dtor observers
00196         {       
00197                                 
00198                 for(TDtorObserversVect::iterator it = _DtorObserversVect.begin(); it != _DtorObserversVect.end(); ++it)
00199                 {       
00200                         if ((*it)->getOwner() == other)
00201                         {                                                                       
00202                                 CPSLocatedBindable *refMaker = *it;                             
00203                                 refMaker->notifyTargetRemoved(this);
00204                                 break;
00205                         }
00206                 }
00207         }
00208         CHECK_PS_INTEGRITY
00209 }

void NL3D::CPSLocated::remove const CPSLocatedBindable lb  ) 
 

***************************************************************************************

remove a bound object from the located if the object doesnt exist -> nlassert it is deleted

Definition at line 808 of file ps_located.cpp.

References _LocatedBoundCont, CHECK_PS_INTEGRITY, nlassert, and NL3D::CParticleSystem::systemDurationChanged().

00809 {
00810         CHECK_PS_INTEGRITY
00811         TLocatedBoundCont::iterator it = std::find(_LocatedBoundCont.begin(), _LocatedBoundCont.end(), p);
00812         nlassert(it != _LocatedBoundCont.end());        
00813         (*it)->finalize();
00814         delete *it;
00815         _LocatedBoundCont.erase(it);
00816         if (_Owner)
00817         {
00818                 _Owner->systemDurationChanged();
00819         }
00820         CHECK_PS_INTEGRITY
00821 }

void NL3D::CPSLocated::resetCollisionInfo void   )  [protected]
 

***************************************************************************************

Definition at line 1821 of file ps_located.cpp.

References _CollisionInfo, NL3D::CPSAttrib< T >::begin(), CHECK_PS_INTEGRITY, NL3D::CPSAttrib< T >::end(), and nlassert.

01822 {
01823         CHECK_PS_INTEGRITY
01824         nlassert(_CollisionInfo);
01825 
01826         TPSAttribCollisionInfo::iterator it = _CollisionInfo->begin(), endIt = _CollisionInfo->end();
01827 
01828         for (; it != endIt; ++it)
01829         {
01830                 it->reset();
01831         }
01832         CHECK_PS_INTEGRITY
01833 }

void NL3D::CPSLocated::resize uint32  newSize  ) 
 

Resize the located container, in order to accept more instances

Definition at line 1117 of file ps_located.cpp.

References _CollisionInfo, _InvMass, _LocatedBoundCont, _ParametricMotion, _PInfo, _TimeIncrement, CHECK_PS_INTEGRITY, deleteElement(), nlassert, notifyMaxNumFacesChanged(), NL3D::CPSAttrib< CParametricInfo >::resize(), NL3D::CPSAttrib< T >::resize(), NL3D::CPSAttrib< float >::resize(), and uint32.

Referenced by NL3D::CParticleSystem::matchArraySize(), and newElement().

01118 {
01119         CHECK_PS_INTEGRITY      
01120         nlassert(newSize < (1 << 16));
01121         if (newSize < _Size)
01122         {
01123                 for (uint32 k = _Size - 1; k >= newSize; --k)
01124                 {
01125                         deleteElement(k);
01126                         
01127                         if (k == 0) break; // we're dealing with unsigned quantities
01128                 }
01129                 _Size = newSize;
01130         }
01131 
01132 
01133         _MaxSize = newSize;
01134         _InvMass.resize(newSize);
01135         _Pos.resize(newSize);
01136         _Speed.resize(newSize);
01137         _Time.resize(newSize);
01138         _TimeIncrement.resize(newSize);
01139 
01140         if (_ParametricMotion)
01141         {
01142                 _PInfo.resize(newSize);
01143         }       
01144 
01145         if (_CollisionInfo)
01146         {
01147                 _CollisionInfo->resize(newSize);
01148         }
01149 
01150         
01151 
01152         // resize attributes for all bound objects
01153         for (TLocatedBoundCont::iterator it = _LocatedBoundCont.begin(); it != _LocatedBoundCont.end(); ++it)
01154         {
01155                 (*it)->resize(newSize);
01156         }
01157 
01158 
01160         notifyMaxNumFacesChanged();
01161         CHECK_PS_INTEGRITY
01162 }

void NL3D::CPSLocated::serial NLMISC::IStream f  )  throw (NLMISC::EStream) [virtual]
 

***************************************************************************************

Reimplemented from NL3D::CParticleSystemProcess.

Definition at line 1165 of file ps_located.cpp.

References CHECK_PS_INTEGRITY, len, nlassert, sint, sint32, size, t, TNewElementRequestStack, uint, and uint32.

01166 {
01167         CHECK_PS_INTEGRITY      
01168 
01169         // version 4 to version 5 : bugfix with reading of collisions
01170         sint ver = f.serialVersion(6);
01171         CParticleSystemProcess::serial(f);
01172         
01173         if (f.isReading() && !CParticleSystem::getSerializeIdentifierFlag())
01174         {
01175                 // just skip the name
01176                 sint32 len;
01177                 f.serial(len);
01178                 f.seek(len, NLMISC::IStream::current);
01179         }
01180         else
01181         {       
01182                 f.serial(_Name);
01183         }
01184 
01185         f.serial(_InvMass);
01186         f.serial(_Pos);
01187         f.serial(_Speed);
01188         f.serial(_Time);
01189         f.serial(_TimeIncrement);
01190 
01191         f.serial(_Size); 
01192         f.serial(_MaxSize);
01193 
01194         f.serial(_LastForever);
01195 
01196         f.serialPtr(_CollisionInfo);
01197         f.serial(_CollisionInfoNbRef);
01198 
01199         if (_CollisionInfo)
01200         {         
01201                 if (ver <= 5) // should be corrected with version 5
01202                 {               
01203                         if (f.isReading())
01204                         {
01205                                 // apparently, with a previous version, collision haven't been saved properly in a few case, so reset them when they are loaded
01206                                 _CollisionInfo->resize(_Pos.getMaxSize());
01207                                 _CollisionInfo->clear();
01208                                 CPSCollisionInfo nullCollision;
01209                                 uint numInstances = _Pos.getSize();
01210                                 for(uint k = 0; k < numInstances; ++k)
01211                                 {
01212                                         _CollisionInfo->insert(nullCollision);
01213                                 }
01214                         }
01215                 }
01216         }
01217 
01218         //CHECK_PS_INTEGRITY    
01219 
01220         
01221         if (f.isReading())
01222         {
01223                 delete _LifeScheme;
01224                 delete _MassScheme;
01225 
01226                 bool useScheme;
01227                 f.serial(useScheme);
01228                 if (useScheme)
01229                 {
01230                         f.serialPolyPtr(_LifeScheme);
01231                 }
01232                 else
01233                 {
01234                         f.serial(_InitialLife);
01235                         _LifeScheme = NULL;
01236                 }
01237 
01238                 f.serial(useScheme);
01239                 if (useScheme)
01240                 {
01241                         f.serialPolyPtr(_MassScheme);
01242                 }
01243                 else
01244                 {
01245                         f.serial(_InitialMass);
01246                         nlassert(_InitialMass > 0);
01247                         _MassScheme = NULL;
01248                 }
01249         }
01250         else
01251         {
01252                 bool bFalse = false, bTrue = true;
01253                 if (_LifeScheme)
01254                 {
01255                         f.serial(bTrue);
01256                         f.serialPolyPtr(_LifeScheme);
01257                 }
01258                 else
01259                 {
01260                         f.serial(bFalse);
01261                         f.serial(_InitialLife);
01262                 }
01263                 if (_MassScheme)
01264                 {
01265                         f.serial(bTrue);
01266                         f.serialPolyPtr(_MassScheme);
01267                 }
01268                 else
01269                 {
01270                         f.serial(bFalse);
01271                         nlassert(_InitialMass > 0);
01272                         f.serial(_InitialMass);                 
01273                 }
01274         }
01275 
01276 
01277         f.serial(_NbFramesToSkip);
01278 
01279         f.serialContPolyPtr(_DtorObserversVect);
01280 
01281         if (f.isReading())
01282         {
01283                 while(!_RequestStack.empty())
01284                 {
01285                         _RequestStack.pop();
01286                 }
01287                 uint32 size;
01288                 f.serial(size);
01289                 for (uint32 k = 0; k < size; ++k)
01290                 {
01291                         TNewElementRequestStack::value_type t;
01292                         f.serial(t);
01293                         _RequestStack.push(t);
01294                 }
01295         }
01296         else
01297         {
01298                 // when writing the stack, we must make a copy because we can't access elements by their index
01299                 // so the stack must be destroyed
01300                 TNewElementRequestStack r2;
01301                 uint32 size = (uint32) _RequestStack.size();
01302                 f.serial(size);
01303 
01304                 while(!_RequestStack.empty())
01305                 {
01306                         r2.push(_RequestStack.top());
01307                         _RequestStack.pop();
01308                 }
01309                 // now rebuild the stack while serializing it;
01310                 while (!r2.empty())
01311                 {                       
01312                         f.serial(r2.top());
01313                         _RequestStack.push(r2.top());
01314                         r2.pop();
01315                 }
01316 
01317         }
01318 
01319         
01320 
01321 
01322         f.serial(_UpdateLock);  
01323 
01324         f.serialContPolyPtr(_LocatedBoundCont);
01325         
01326         if (ver > 1)
01327         {
01328                 f.serial(_LODDegradation);
01329         }
01330 
01331         if (ver > 2)
01332         {
01333                 f.serial(_ParametricMotion);
01334         }
01335 
01336         if (f.isReading())
01337         {
01338                 // evaluate our max number of faces
01339                 notifyMaxNumFacesChanged();
01340 
01341                 if (_ParametricMotion)
01342                 {
01343                         allocateParametricInfos();                      
01344                 }
01345         }
01346 
01347         if (ver > 3)
01348         {
01349                 f.serial(_TriggerOnDeath, _TriggerID);
01350         }
01351         CHECK_PS_INTEGRITY
01352 }

void NL3D::CPSLocated::setFrameRate uint32  nbFramesToSkip = 0  )  [inline]
 

set the Refresh Rate of this located. Default is motion every frame (frameToSkip = 0) The drawing process will still occur every frame anyway... It's a speed / quality tradeof

Definition at line 379 of file ps_located.h.

References _NbFramesToSkip, and uint32.

00379 { _NbFramesToSkip = nbFramesToSkip; }

void NL3D::CPSLocated::setInitialLife TAnimationTime  lifeTime  ) 
 

***************************************************************************************

Set the duration of locateds. Any previous call to setLastForever() is discarded Any previous scheme for lifetime is dicarded

Reset all particles current date to 0. This is needed because we do not check if particle life is over when the date of the system has not gone beyond the life duration of particles

Definition at line 507 of file ps_located.cpp.

References _InitialLife, _LastForever, _LifeScheme, CHECK_PS_INTEGRITY, NL3D::CParticleSystem::systemDurationChanged(), NL3D::TAnimationTime, and uint.

00508 {
00509         CHECK_PS_INTEGRITY
00510         _LastForever = false;
00511         _InitialLife = lifeTime;
00512         delete _LifeScheme;
00513         _LifeScheme = NULL;     
00514 
00518         for (uint k = 0; k < _Size; ++k)
00519         {
00520                 _Time[k] = 0.f;
00521         }
00522         //
00523         if (_Owner)
00524         {
00525                 _Owner->systemDurationChanged();
00526         }
00527         CHECK_PS_INTEGRITY
00528 }

void NL3D::CPSLocated::setInitialMass float  mass  ) 
 

***************************************************************************************

Set the mass of locateds. Any previous scheme for Mass is dicarded

Definition at line 548 of file ps_located.cpp.

References _InitialMass, _MassScheme, and CHECK_PS_INTEGRITY.

00549 {
00550         CHECK_PS_INTEGRITY
00551         _InitialMass = mass;
00552         delete _MassScheme;
00553         _MassScheme = NULL;     
00554         CHECK_PS_INTEGRITY
00555 }

bool NL3D::CPSLocated::setLastForever  ) 
 

***************************************************************************************

set immortality for located

See also:
setInitialLife
Returns:
true if the operation could be performed. It can fail when this cause the system the system to last forever, which is incompatible with the 'BypassMaxNumIntegrationSteps' in CParticleSystem

Definition at line 153 of file ps_located.cpp.

References _LastForever, NL3D::CParticleSystem::canFinish(), CHECK_PS_INTEGRITY, NL3D::CParticleSystem::getBypassMaxNumIntegrationSteps(), and nlwarning.

00154 {
00155         CHECK_PS_INTEGRITY
00156         _LastForever = true;
00157         if (_Owner && _Owner->getBypassMaxNumIntegrationSteps())
00158         {
00159                 // Should test that the system is still valid.
00160                 if (!_Owner->canFinish())
00161                 {
00162                         _LastForever = false;
00163                         nlwarning("<CPSLocated::setLastForever> Can't set flag : this causes the system to last forever, and it has been flagged with 'BypassMaxNumIntegrationSteps'. Flag is not set");
00164                         return false;
00165                 }
00166         }
00167         CHECK_PS_INTEGRITY
00168         return true;
00169 }

void NL3D::CPSLocated::setLifeScheme CPSAttribMaker< float > *  scheme  ) 
 

***************************************************************************************

Set a scheme (allocated by new, released by that object) that generate the duration of locateds. Such a scheme can't own its memory. Any previous call to setLastForever() is discarded Any previous scheme for lifetime is discarded

Definition at line 531 of file ps_located.cpp.

References _LastForever, _LifeScheme, CHECK_PS_INTEGRITY, NL3D::CPSAttribMaker< T >::hasMemory(), nlassert, and NL3D::CParticleSystem::systemDurationChanged().

00532 {
00533         CHECK_PS_INTEGRITY
00534         nlassert(scheme);
00535         nlassert(!scheme->hasMemory()); // scheme with memory is invalid there !!
00536         _LastForever = false;
00537         delete _LifeScheme;
00538         _LifeScheme = scheme;
00539         //
00540         if (_Owner)
00541         {
00542                 _Owner->systemDurationChanged();
00543         }
00544         CHECK_PS_INTEGRITY
00545 }

void NL3D::CPSLocated::setMassScheme CPSAttribMaker< float > *  scheme  ) 
 

***************************************************************************************

Set a scheme (allocated by new, released by that object) that generate the mass of locateds. Such a scheme can't own its memory. Any previous scheme for Mass is discarded

Definition at line 558 of file ps_located.cpp.

References _MassScheme, CHECK_PS_INTEGRITY, NL3D::CPSAttribMaker< T >::hasMemory(), and nlassert.

00559 {
00560         CHECK_PS_INTEGRITY
00561         nlassert(scheme);
00562         nlassert(!scheme->hasMemory()); // scheme with memory is invalid there !!
00563         delete _MassScheme;
00564         _MassScheme = scheme;   
00565         CHECK_PS_INTEGRITY
00566 }

void NL3D::CPSLocated::setMatrixMode TPSMatrixMode  matrixMode  )  [virtual]
 

***************************************************************************************

Reimplemented from NL3D::CParticleSystemProcess.

Definition at line 401 of file ps_located.cpp.

References _IntegrableForces, _LocatedBoundCont, CHECK_PS_INTEGRITY, NL3D::CParticleSystemProcess::getMatrixMode(), and integrableForceBasisChanged().

00402 {
00403         CHECK_PS_INTEGRITY
00404         if (matrixMode != getMatrixMode())
00405         {               
00406                 for (TLocatedBoundCont::const_iterator it = _LocatedBoundCont.begin(); it != _LocatedBoundCont.end(); ++it)
00407                 {
00408                         (*it)->basisChanged(matrixMode);
00409                 }
00410 
00411                 CParticleSystemProcess::setMatrixMode(matrixMode);
00412 
00413                 for (TForceVect::iterator fIt = _IntegrableForces.begin(); fIt != _IntegrableForces.end(); ++fIt)
00414                 {                       
00415                         integrableForceBasisChanged( (*fIt)->getOwner()->getMatrixMode() );
00416                 }                               
00417         }
00418         CHECK_PS_INTEGRITY
00419 }

void NL3D::CPSLocated::setName const std::string &  name  )  [inline]
 

set the located bindable name (edition purpose)

Definition at line 492 of file ps_located.h.

00492 { _Name = name; }

void NL3D::CParticleSystemProcess::setOwner CParticleSystem ps  )  [inherited]
 

Set the process owner. Called by the particle system during attachment.

Definition at line 38 of file particle_system_process.cpp.

References NL3D::CParticleSystem::addRefForUserSysCoordInfo(), NL3D::CParticleSystemProcess::getUserMatrixUsageCount(), NL3D::CParticleSystemProcess::releaseAllRef(), and NL3D::CParticleSystem::releaseRefForUserSysCoordInfo().

Referenced by NL3D::CParticleSystem::attach(), NL3D::CParticleSystem::detach(), and NL3D::CParticleSystem::remove().

00039 {
00040         if (ps == _Owner) return;
00041         if (ps == NULL)
00042         {
00043                 releaseAllRef();                
00044         }       
00045         _Owner->releaseRefForUserSysCoordInfo(getUserMatrixUsageCount());               
00046         _Owner = ps; 
00047         if (_Owner) _Owner->addRefForUserSysCoordInfo(getUserMatrixUsageCount());
00048 }

void NL3D::CPSLocated::setTriggerEmitterID uint32  id  )  [inline]
 

Set an ID for the emitter to be triggered on death.

Definition at line 558 of file ps_located.h.

References _TriggerID, _TriggerOnDeath, nlassert, and uint32.

00559         { 
00560                 nlassert(_TriggerOnDeath);
00561                 _TriggerID = id; 
00562         }

void NL3D::CPSLocated::setupDriverModelMatrix void   ) 
 

Setup the driver model matrix. It is set accrodingly to the basis of the located.

Setup the driver model matrix. It is set accordingly to the basis used for rendering

Definition at line 1775 of file ps_located.cpp.

References CHECK_PS_INTEGRITY, getDriver(), getLocalToWorldMatrix(), and NL3D::IDriver::setupModelMatrix().

Referenced by NL3D::CPSLocatedBindable::setupDriverModelMatrix().

01776 {
01777         CHECK_PS_INTEGRITY      
01778         getDriver()->setupModelMatrix(getLocalToWorldMatrix());                 
01779         CHECK_PS_INTEGRITY
01780 }

void NL3D::CPSLocated::setZBias float  value  )  [virtual]
 

***************************************************************************************

Implements NL3D::CParticleSystemProcess.

Definition at line 2304 of file ps_located.cpp.

References _LocatedBoundCont, and value.

02305 {
02306         for(TLocatedBoundCont::const_iterator it = _LocatedBoundCont.begin(); it != _LocatedBoundCont.end(); ++it)
02307         {
02308                 (*it)->setZBias(value);
02309         }
02310 }

void NL3D::CPSLocated::step TPSProcessPass  pass,
TAnimationTime  ellapsedTime,
TAnimationTime  realEt
[virtual]
 

***************************************************************************************

process the system

Implements NL3D::CParticleSystemProcess.

Definition at line 1466 of file ps_located.cpp.

References _CollisionInfo, _LocatedBoundCont, _LODDegradation, _NbFramesToSkip, NL3D::CPSAttrib< T >::begin(), CHECK_PS_INTEGRITY, deleteElement(), NL3D::CParticleSystem::getDate(), NL3D::CParticleSystem::getLOD(), NL3D::CParticleSystem::getOneMinusCurrentLODRatio(), NL3D::IntegrateSpeed(), MINI_TIMER, nlassert, NL3D::PSLod1n2, NL3D::PSMotion, NL3D::PSMotion1, NL3D::PSMotion2, NL3D::PSMotion3, NL3D::PSMotion4, NL3D::TAnimationTime, uint, uint32, updateNewElementRequestStack(), and x.

01467 {       
01468         CHECK_PS_INTEGRITY
01469         if (!_Size) return;     
01470 
01471 
01472         if (pass == PSMotion)
01473         {               
01474 
01475                 {                                               
01476                         MINI_TIMER(PSMotion1)
01477                         // check wether we must perform LOD degradation
01478                         if (_LODDegradation)
01479                         {
01480                                 if (ellapsedTime > 0)
01481                                 {
01482                                         nlassert(_Owner);
01483                                         // compute the number of particles to show
01484                                         const uint maxToHave = (uint) (_MaxSize * _Owner->getOneMinusCurrentLODRatio());
01485                                         if (_Size > maxToHave) // too much instances ?
01486                                         {
01487                                                 // choose a random element to start at, and a random step
01488                                                 // this will avoid a pulse effect when the system is far away
01489                                                 
01490                                                 uint pos = maxToHave ? rand() % maxToHave : 0;
01491                                                 uint step  = maxToHave ? rand() % maxToHave : 0;
01492 
01493                                                 do
01494                                                 {
01495                                                         deleteElement(pos);
01496                                                         pos += step;
01497                                                         if (pos >= maxToHave) pos -= maxToHave;
01498                                                 }
01499                                                 while (_Size !=maxToHave);                              
01500                                         }
01501                                 }
01502                         }
01503                 }
01504 
01505                                 
01506                 // check if we must skip frames
01507                 if (!_NbFramesToSkip || !( (uint32) _Owner->getDate() % (_NbFramesToSkip + 1)))
01508                 {
01509                         
01510                         {                                               
01511                                 MINI_TIMER(PSMotion2)
01512                                 // update the located creation requests that may have been posted
01513                                 updateNewElementRequestStack();
01514                         }
01515 
01516                         // there are 2 integration steps : with and without collisions
01517 
01518                         if (!_CollisionInfo) // no collisionner are used
01519                         {
01520                                 {                                               
01521                                         MINI_TIMER(PSMotion3)
01522                                         if (_Size != 0) // avoid referencing _Pos[0] if there's no size, causes STL vectors to assert...
01523                                                 IntegrateSpeed(_Size * 3, &_Pos[0].x, &_Speed[0].x, ellapsedTime);
01524                                 }
01525                         }
01526                         else
01527                         {
01528                                 {                                               
01529                                         MINI_TIMER(PSMotion4)
01530                                         // integration with collisions
01531                                         nlassert(_CollisionInfo);
01532                                         TPSAttribCollisionInfo::iterator itc = _CollisionInfo->begin();
01533                                         TPSAttribVector::iterator itSpeed = _Speed.begin();             
01534                                         TPSAttribVector::iterator itPos = _Pos.begin();         
01535 
01536                                         for (uint k = 0; k < _Size;)
01537                                         {
01538                                                 if (itc->dist != -1)
01539                                                 {
01540                                                         (*itPos) = itc->newPos;
01541                                                         (*itSpeed) = itc->newSpeed;
01542                                                         // notify each located bindable that a bounce occured ...
01543                                                         for (TLocatedBoundCont::iterator it = _LocatedBoundCont.begin(); it != _LocatedBoundCont.end(); ++it)
01544                                                         {       
01545                                                                 (*it)->bounceOccured(k);
01546                                                         }
01547                                                         switch(itc->collisionZone->getCollisionBehaviour())
01548                                                         {
01549                                                                 case CPSZone::bounce:
01550                                                                         itc->reset();
01551                                                                         ++k, ++itPos, ++itSpeed, ++itc;
01552                                                                 break;
01553                                                                 case CPSZone::destroy:
01554                                                                         deleteElement(k);
01555                                                                 break;
01556                                                         }
01557                                                 }
01558                                                 else
01559                                                 {
01560                                                         (*itPos) += ellapsedTime * (*itSpeed) * itc->TimeSliceRatio;
01561                                                         itc->reset();
01562                                                         ++k, ++itPos, ++itSpeed, ++itc;
01563                                                 }
01564                                         }
01565 
01566                                         
01567                                         // reset collision info for the next time => done during the traversal
01569                                 }                               
01570                         }               
01571                 }
01572                 else
01573                 {
01574                         return; // we skip the frame...
01575                 }
01576         }
01577 
01578         if (pass != PSMotion)
01579         {
01580                 {                       
01581                         /*
01582                         uint64 *target;
01583                         switch(pass)
01584                         {
01585                                 case PSEmit: target = &PSStatEmit; break;
01586                                 case PSCollision: target = &PSStatCollision; break;
01587                                 default:
01588                                         target = &PSStatRender;
01589                                 break;
01590                         }
01591                         MINI_TIMER(*target)
01592                         */
01593                         // apply the pass to all bound objects
01594                         for (TLocatedBoundCont::iterator it = _LocatedBoundCont.begin(); it != _LocatedBoundCont.end(); ++it)
01595                         {
01596                                 if ((*it)->isActive())
01597                                 {                       
01598                                         if ((*it)->getLOD() == PSLod1n2 || _Owner->getLOD() == (*it)->getLOD()) // has this object the right LOD ?
01599                                         {
01600                                                 (*it)->step(pass, ellapsedTime, realEt);
01601                                         }
01602                                 }
01603                         }
01604                 }
01605         }
01606         else
01607         {
01608                 for (TLocatedBoundCont::iterator it = _LocatedBoundCont.begin(); it != _LocatedBoundCont.end(); ++it)
01609                 {       
01610                         if ((*it)->isActive())
01611                         {                       
01612                                 (*it)->step(pass, ellapsedTime, realEt);
01613                         }
01614                 }
01615 
01616         }
01617         CHECK_PS_INTEGRITY
01618 }

bool NL3D::CPSLocated::supportParametricMotion void   )  const
 

Test wether this located support parametric motion.

Definition at line 376 of file ps_located.cpp.

References _NonIntegrableForceNbRefs, and _NumIntegrableForceWithDifferentBasis.

Referenced by allocateParametricInfos(), enableParametricMotion(), integrateSingle(), and performParametricMotion().

00377 {
00378         return _NonIntegrableForceNbRefs == 0 && _NumIntegrableForceWithDifferentBasis == 0;
00379 }

void NL3D::CPSLocated::systemDateChanged  )  [virtual]
 

***************************************************************************************

Reimplemented from NL3D::CParticleSystemProcess.

Definition at line 173 of file ps_located.cpp.

References _LocatedBoundCont, and CHECK_PS_INTEGRITY.

00174 {
00175         CHECK_PS_INTEGRITY
00176         for(TLocatedBoundCont::iterator it = _LocatedBoundCont.begin(); it != _LocatedBoundCont.end(); ++it)
00177         {
00178                 (*it)->systemDateChanged();
00179         }
00180         CHECK_PS_INTEGRITY
00181 }

CPSLocatedBindable * NL3D::CPSLocated::unbind uint  index  ) 
 

***************************************************************************************

Detach a bindable object from this located. Ownership is transferred to the caller Any reference the object may have in the system is lost (targets..) After that is may be inserted an other system.

Definition at line 1902 of file ps_located.cpp.

References _LocatedBoundCont, CHECK_PS_INTEGRITY, index, nlassert, NL3D::CPSLocatedBindable::setOwner(), and uint.

Referenced by bind().

01903 {       
01904         CHECK_PS_INTEGRITY
01905         nlassert(index < _LocatedBoundCont.size());
01906         CPSLocatedBindable *lb = _LocatedBoundCont[index];              
01907         lb->setOwner(NULL);     
01908         _LocatedBoundCont.erase(_LocatedBoundCont.begin() + index);
01909         return lb;
01910         CHECK_PS_INTEGRITY
01911 }

void NL3D::CPSLocated::unregisterDtorObserver CPSLocatedBindable anObserver  ) 
 

***************************************************************************************

remove a dtor observer (not present -> nlassert) see register dtor observer

Definition at line 834 of file ps_located.cpp.

References _DtorObserversVect, CHECK_PS_INTEGRITY, and nlassert.

Referenced by NL3D::CPSLocatedBindable::notifyTargetRemoved(), NL3D::CPSEmitter::setEmittedType(), and NL3D::CPSEmitter::~CPSEmitter().

00835 {
00836         CHECK_PS_INTEGRITY
00837         // check that it was registered
00838         TDtorObserversVect::iterator it = std::find(_DtorObserversVect.begin(), _DtorObserversVect.end(), anObserver);
00839         nlassert(it != _DtorObserversVect.end());
00840         _DtorObserversVect.erase(it);
00841         CHECK_PS_INTEGRITY
00842 }

void NL3D::CPSLocated::unregisterIntegrableForce CPSForce f  ) 
 

***************************************************************************************

Definition at line 1851 of file ps_located.cpp.

References _IntegrableForces, _NumIntegrableForceWithDifferentBasis, CHECK_PS_INTEGRITY, NL3D::CParticleSystemProcess::getMatrixMode(), NL3D::CPSLocatedBindable::getOwner(), and nlassert.

Referenced by NL3D::CPSForce::releaseTargetRsc().

01852 {
01853         CHECK_PS_INTEGRITY
01854         nlassert(f->getOwner()); // f must be attached to a located
01855         CPSVector<CPSForce *>::V::iterator it = std::find(_IntegrableForces.begin(), _IntegrableForces.end(), f);
01856         nlassert(it != _IntegrableForces.end() );       
01857         _IntegrableForces.erase(it);
01858         if (getMatrixMode() != f->getOwner()->getMatrixMode())
01859         {
01860                 --_NumIntegrableForceWithDifferentBasis;
01861         }
01862         CHECK_PS_INTEGRITY
01863 }

void NL3D::CPSLocated::updateLife TAnimationTime  ellapsedTime  )  [virtual]
 

***************************************************************************************

all particles have the same lifetime

Implements NL3D::CParticleSystemProcess.

Definition at line 1621 of file ps_located.cpp.

References _InitialLife, _LastForever, _LifeScheme, _TimeIncrement, NL3D::CPSAttrib< T >::begin(), CHECK_PS_INTEGRITY, deleteElement(), NL3D::CPSAttrib< T >::end(), NL3D::CParticleSystem::getSystemDate(), nlassert, size, NL3D::TAnimationTime, uint, and uint32.

01622 {
01623         CHECK_PS_INTEGRITY
01624         if (!_Size) return;
01625         if (! _LastForever)
01626         {
01627                 if (_LifeScheme != NULL)
01628                 {                       
01629                         TPSAttribTime::iterator itTime = _Time.begin(), itTimeInc = _TimeIncrement.begin();                     
01630                         for (uint32 k = 0; k < _Size;)
01631                         {
01632                                 *itTime += ellapsedTime * *itTimeInc;
01633                                 if (*itTime >= 1.0f)
01634                                 {
01635                                         deleteElement(k);
01636                                 }
01637                                 else
01638                                 {
01639                                         ++k;
01640                                         ++itTime;
01641                                         ++itTimeInc;
01642                                 }
01643                         }
01644                 }
01645                 else 
01646                 {
01647                         if (_InitialLife != 0)
01648                         {
01649                                 nlassert(_Owner);
01650                                 float timeInc = ellapsedTime * 1.f / _InitialLife;
01651                                 if (_Owner->getSystemDate() >= (_InitialLife - ellapsedTime))
01652                                 {
01653                                         TPSAttribTime::iterator itTime = _Time.begin();
01654                                         for (uint32 k = 0; k < _Size;)
01655                                         {
01656                                                 *itTime += timeInc;
01657                                                 if (*itTime >= 1.0f)
01658                                                 {
01659                                                         deleteElement(k);
01660                                                 }
01661                                                 else
01662                                                 {
01663                                                         ++k;
01664                                                         ++itTime;                                       
01665                                                 }
01666                                         }
01667                                 }
01668                                 else
01669                                 {
01670                                         TPSAttribTime::iterator itTime = _Time.begin(), itEndTime = _Time.end();
01671                                         do
01672                                         {
01673                                                 *itTime += timeInc;
01674                                                 ++itTime;
01675                                         }
01676                                         while (itTime != itEndTime);
01677                                 }
01678                         }
01679                         else
01680                         {
01681                                 uint size = _Size;
01682                                 do
01683                                 {
01684                                         deleteElement(0);
01685                                 }
01686                                 while (--size);                         
01687                         }
01688                 }
01689         }
01690         else
01691         {
01692                 // the time attribute gives the life in seconds
01693                 TPSAttribTime::iterator itTime = _Time.begin(), endItTime = _Time.end();
01694                 for (; itTime != endItTime; ++itTime)
01695                 {
01696                         *itTime += ellapsedTime;
01697                 }
01698         }
01699         CHECK_PS_INTEGRITY
01700 }

void NL3D::CPSLocated::updateNewElementRequestStack void   )  [protected]
 

***************************************************************************************

Definition at line 1703 of file ps_located.cpp.

References _RequestStack, CHECK_PS_INTEGRITY, newElement(), and NL3D::PSFXWorldMatrix.

Referenced by step().

01704 {
01705         // TODO : update / remove this
01706         CHECK_PS_INTEGRITY
01707         while (!_RequestStack.empty())
01708         {
01709                 newElement(_RequestStack.top()._Pos, _RequestStack.top()._Speed, NULL, 0, PSFXWorldMatrix, 0.f);
01710                 _RequestStack.pop();
01711         }
01712         CHECK_PS_INTEGRITY
01713 }


Friends And Related Function Documentation

friend class CPSForce [friend]
 

Definition at line 588 of file ps_located.h.


Field Documentation

TPSAttribCollisionInfo* NL3D::CPSLocated::_CollisionInfo [protected]
 

Used to solve collision detection it is not always instanciated

Definition at line 657 of file ps_located.h.

Referenced by checkIntegrity(), collisionUpdate(), deleteElement(), getCollisionInfo(), hasCollisionInfos(), newElement(), queryCollisionInfo(), releaseAllRef(), releaseCollisionInfo(), resetCollisionInfo(), resize(), step(), and ~CPSLocated().

uint32 NL3D::CPSLocated::_CollisionInfoNbRef [protected]
 

Definition at line 662 of file ps_located.h.

Referenced by queryCollisionInfo(), releaseAllRef(), releaseCollisionInfo(), and ~CPSLocated().

TDtorObserversVect NL3D::CPSLocated::_DtorObserversVect [protected]
 

Definition at line 723 of file ps_located.h.

Referenced by registerDtorObserver(), releaseAllRef(), releaseRefTo(), unregisterDtorObserver(), and ~CPSLocated().

float NL3D::CPSLocated::_InitialLife [protected]
 

Definition at line 667 of file ps_located.h.

Referenced by evalMaxDuration(), getInitialLife(), newElement(), setInitialLife(), and updateLife().

float NL3D::CPSLocated::_InitialMass [protected]
 

Definition at line 672 of file ps_located.h.

Referenced by getInitialMass(), newElement(), and setInitialMass().

TForceVect NL3D::CPSLocated::_IntegrableForces [protected]
 

Definition at line 736 of file ps_located.h.

Referenced by integrateSingle(), performParametricMotion(), registerIntegrableForce(), releaseAllRef(), setMatrixMode(), unregisterIntegrableForce(), and ~CPSLocated().

TPSAttribFloat NL3D::CPSLocated::_InvMass [protected]
 

Definition at line 620 of file ps_located.h.

Referenced by checkIntegrity(), deleteElement(), getInvMass(), newElement(), and resize().

bool NL3D::CPSLocated::_LastForever [protected]
 

Definition at line 615 of file ps_located.h.

Referenced by evalMaxDuration(), getLastForever(), setInitialLife(), setLastForever(), setLifeScheme(), and updateLife().

CPSAttribMaker<float>* NL3D::CPSLocated::_LifeScheme [protected]
 

Definition at line 668 of file ps_located.h.

Referenced by evalMaxDuration(), getLifeScheme(), newElement(), setInitialLife(), setLifeScheme(), updateLife(), and ~CPSLocated().

TLocatedBoundCont NL3D::CPSLocated::_LocatedBoundCont [protected]
 

Definition at line 604 of file ps_located.h.

Referenced by bind(), computeBBox(), deleteElement(), enumTexs(), getBoundObject(), getIndexOf(), getNbBoundObjects(), getUserMatrixUsageCount(), hasEmitters(), hasParticles(), isBound(), newElement(), notifyMaxNumFacesChanged(), notifyMotionTypeChanged(), releaseAllRef(), releaseRefTo(), remove(), resize(), setMatrixMode(), setZBias(), step(), systemDateChanged(), unbind(), and ~CPSLocated().

bool NL3D::CPSLocated::_LODDegradation [protected]
 

true when LOD degradation apply to this located

Definition at line 726 of file ps_located.h.

Referenced by forceLODDegradation(), hasLODDegradation(), and step().

CPSAttribMaker<float>* NL3D::CPSLocated::_MassScheme [protected]
 

Definition at line 673 of file ps_located.h.

Referenced by getMassScheme(), newElement(), setInitialMass(), setMassScheme(), and ~CPSLocated().

TPSMatrixMode NL3D::CParticleSystemProcess::_MatrixMode [protected, inherited]
 

Definition at line 193 of file particle_system_process.h.

Referenced by NL3D::CParticleSystemProcess::CParticleSystemProcess(), NL3D::CParticleSystemProcess::getMatrixMode(), NL3D::CParticleSystemProcess::getUserMatrixUsageCount(), and NL3D::CParticleSystemProcess::setMatrixMode().

uint32 NL3D::CPSLocated::_MaxNumFaces [protected]
 

cache the max number of faces this located may want

Definition at line 592 of file ps_located.h.

Referenced by notifyMaxNumFacesChanged(), and querryMaxWantedNumFaces().

uint32 NL3D::CPSLocated::_MaxSize [protected]
 

Definition at line 607 of file ps_located.h.

std::string NL3D::CPSLocated::_Name [protected]
 

Definition at line 594 of file ps_located.h.

uint32 NL3D::CPSLocated::_NbFramesToSkip [protected]
 

Definition at line 597 of file ps_located.h.

Referenced by getFrameRate(), setFrameRate(), and step().

uint16 NL3D::CPSLocated::_NonIntegrableForceNbRefs [protected]
 

number of force, and zones etc. that are not integrable over time. If this is not 0, then the trajectory cannot be computed at any time. A force that is integrable must be in the same basis than the located.

Definition at line 731 of file ps_located.h.

Referenced by addNonIntegrableForceRef(), releaseAllRef(), releaseNonIntegrableForceRef(), supportParametricMotion(), and ~CPSLocated().

uint16 NL3D::CPSLocated::_NumIntegrableForceWithDifferentBasis [protected]
 

number of forces that apply on that located that have the same basis that this one (required for parametric animation)

Definition at line 733 of file ps_located.h.

Referenced by integrableForceBasisChanged(), registerIntegrableForce(), supportParametricMotion(), and unregisterIntegrableForce().

CParticleSystem* NL3D::CParticleSystemProcess::_Owner [protected, inherited]
 

Definition at line 190 of file particle_system_process.h.

Referenced by getConversionMatrix().

bool NL3D::CPSLocated::_ParametricMotion [protected]
 

When set to true, this tells the system to use parametric motion. Only parametric forces must have been applied.

Definition at line 741 of file ps_located.h.

Referenced by allocateParametricInfos(), bind(), deleteElement(), integrateSingle(), isParametricMotionEnabled(), newElement(), notifyMotionTypeChanged(), performParametricMotion(), releaseParametricInfos(), and resize().

CPSAttrib<CParametricInfo> NL3D::CPSLocated::_PInfo
 

WARNING : private use by forces only. this vector is only used if parametric motion is achievable and enabled, because of the extra storage space

Definition at line 650 of file ps_located.h.

Referenced by allocateParametricInfos(), deleteElement(), getParametricInfos(), integrateSingle(), newElement(), performParametricMotion(), releaseParametricInfos(), and resize().

TPSAttribVector NL3D::CPSLocated::_Pos [protected]
 

Definition at line 621 of file ps_located.h.

TNewElementRequestStack NL3D::CPSLocated::_RequestStack [protected]
 

this stack is used after each update to generate located

Definition at line 693 of file ps_located.h.

Referenced by postNewElement(), and updateNewElementRequestStack().

uint32 NL3D::CPSLocated::_Size [protected]
 

Definition at line 611 of file ps_located.h.

TPSAttribVector NL3D::CPSLocated::_Speed [protected]
 

Definition at line 622 of file ps_located.h.

TPSAttribTime NL3D::CPSLocated::_Time [protected]
 

Definition at line 623 of file ps_located.h.

TPSAttribTime NL3D::CPSLocated::_TimeIncrement [protected]
 

Definition at line 624 of file ps_located.h.

Referenced by checkIntegrity(), deleteElement(), getTimeIncrement(), newElement(), resize(), and updateLife().

uint32 NL3D::CPSLocated::_TriggerID [protected]
 

Definition at line 738 of file ps_located.h.

Referenced by deleteElement(), getTriggerEmitterID(), and setTriggerEmitterID().

bool NL3D::CPSLocated::_TriggerOnDeath [protected]
 

Definition at line 737 of file ps_located.h.

Referenced by deleteElement(), enableTriggerOnDeath(), getTriggerEmitterID(), isTriggerOnDeathEnabled(), and setTriggerEmitterID().

bool NL3D::CPSLocated::_UpdateLock [protected]
 

this is used to tell wether a newElement or a deleteElement if being performed During these method, creation should use postNewElement to generate new elements Because of the data structures (each located bindable are updated one after each other) inconsistency can happen, when a located generated another located of the same type when he's deleted.

Definition at line 707 of file ps_located.h.

Referenced by deleteElement(), and newElement().


The documentation for this class was generated from the following files:
Generated on Tue Mar 16 07:17:07 2004 for NeL by doxygen 1.3.6