#include <ps_located.h>
Inheritance diagram for NL3D::CPSLocated:
Definition at line 130 of file ps_located.h.
Public Types | |
| typedef CPSAttrib< CParametricInfo > | TPSAttribParametricInfo |
| 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) |
| CPSLocatedBindable * | getBoundObject (uint32 index) |
| const CPSLocatedBindable * | getBoundObject (uint32 index) const |
| virtual std::string | getClassName ()=0 |
| const TPSAttribCollisionInfo & | getCollisionInfo (void) const |
| get a const ref to the collision infos | |
| TPSAttribCollisionInfo & | getCollisionInfo (void) |
| get a ref to the collision infos | |
| IDriver * | getDriver () 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 TPSAttribFloat & | getInvMass (void) const |
| get mass inverse attrib const ref | |
| TPSAttribFloat & | getInvMass (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::CMatrix & | getLocalToWorldMatrix () 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 CParticleSystem * | getOwner (void) const |
| retrieve the particle system that owns this process (const version) | |
| CParticleSystem * | getOwner (void) |
| Retrieve the particle system that owns this process. | |
| TPSAttribParametricInfo & | getParametricInfos () |
| PRIVATE USE : access to parametric infos. | |
| const TPSAttribVector & | getPos (void) const |
| get Pos attrib const ref | |
| TPSAttribVector & | getPos (void) |
| get Pos attrib ref | |
| CScene * | getScene (void) |
| *************************************************************************************** | |
| uint32 | getSize (void) const |
| get the current number of instance in this located container | |
| const TPSAttribVector & | getSpeed (void) const |
| get Speed attrib const ref | |
| TPSAttribVector & | getSpeed (void) |
| get Speed attrib ref | |
| const TPSAttribTime & | getTime (void) const |
| get Time attrib const ref | |
| TPSAttribTime & | getTime (void) |
| get Time attrib ref | |
| const TPSAttribTime & | getTimeIncrement (void) const |
| get TotalTime attrib const ref | |
| TPSAttribTime & | getTimeIncrement (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::CMatrix & | getWorldToLocalMatrix () 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 () |
| *************************************************************************************** | |
| CPSLocatedBindable * | unbind (uint index) |
| *************************************************************************************** | |
| void | unregisterDtorObserver (CPSLocatedBindable *anObserver) |
| *************************************************************************************** | |
| void | unregisterIntegrableForce (CPSForce *f) |
| *************************************************************************************** | |
| virtual void | updateLife (TAnimationTime ellapsedTime) |
| *************************************************************************************** | |
| virtual | ~CPSLocated () |
| dtor | |
Useful methods for edition | |
| const CFontGenerator * | getFontGenerator (void) const |
| Shortcut to get a font generator if one was set, const version (edition mode). | |
| CFontGenerator * | getFontGenerator (void) |
| Shortcut to get a font generator if one was set (edition mode). | |
| const CFontManager * | getFontManager (void) const |
| Shortcut to get a font Manager if one was set, const version (edition mode). | |
| CFontManager * | getFontManager (void) |
| Shortcut to get a font Manager if one was set (edition mode). | |
Useful methods for edition | |
| const CFontGenerator * | getFontGenerator (void) const |
| Shortcut to get a font generator if one was set, const version (edition mode). | |
| CFontGenerator * | getFontGenerator (void) |
| Shortcut to get a font generator if one was set (edition mode). | |
| const CFontManager * | getFontManager (void) const |
| Shortcut to get a font Manager if one was set, const version (edition mode). | |
| CFontManager * | getFontManager (void) |
| Shortcut to get a font Manager if one was set (edition mode). | |
Static Public Member Functions | |
| const NLMISC::CMatrix & | getConversionMatrix (const CPSLocated *A, const CPSLocated *B) |
| const NLMISC::CMatrix & | getConversionMatrix (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< CPostNewElementRequestInfo > | TNewElementRequestStack |
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 |
|
|
Definition at line 722 of file ps_located.h. Referenced by releaseAllRef(), and ~CPSLocated(). |
|
|
a vector of integrable forces that apply on this located
Definition at line 735 of file ps_located.h. |
|
|
Definition at line 600 of file ps_located.h. |
|
|
Definition at line 690 of file ps_located.h. Referenced by serial(). |
|
|
WARNING : private use by forces only.
Definition at line 645 of file ps_located.h. Referenced by getParametricInfos(). |
|
|
*************************************************************************************** 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 } |
|
|
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 }
|
|
|
***************************************************************************************
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().
01867 {
01868 CHECK_PS_INTEGRITY
01869 ++_NonIntegrableForceNbRefs;
01870 releaseParametricInfos();
01871 CHECK_PS_INTEGRITY
01872 }
|
|
|
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 }
|
|
|
*************************************************************************************** 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.
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 }
|
|
|
***************************************************************************************
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 }
|
|
||||||||||||
|
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.
|
|
|
*************************************************************************************** Compute the aabbox of this located, (expressed in world basis
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 }
|
|
|
*************************************************************************************** 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 }
|
|
|
*************************************************************************************** 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 }
|
|
|
*************************************************************************************** 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 }
|
|
|
*************************************************************************************** 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 }
|
|
|
*************************************************************************************** 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 }
|
|
|
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; }
|
|
||||||||||||
|
***************************************************************************************
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 }
|
|
|
*************************************************************************************** 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 }
|
|
|
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; }
|
|
|
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 }
|
|
|
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 }
|
|
|
Implemented in NLAIAGENT::CNumericIndex, NLAIC::IPointerGestion, NLAIC::CIdentType, and CAutomataDesc. Referenced by NLMISC::CClassRegistry::checkObject(), and NL3D::GetTextureSize(). |
|
|
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 }
|
|
|
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 }
|
|
||||||||||||
|
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 }
|
|
||||||||||||||||
|
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 }
|
|
|
***************************************************************************************
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 }
|
|
|
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.
|
|
|
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().
|
|
|
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.
|
|
|
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().
|
|
|
Definition at line 382 of file ps_located.h. References _NbFramesToSkip, and uint32.
00382 { return _NbFramesToSkip; }
|
|
|
*************************************************************************************** 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 }
|
|
|
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; }
|
|
|
get the mass of created particle
Definition at line 311 of file ps_located.h. References _InitialMass.
00311 { return _InitialMass; }
|
|
|
get mass inverse attrib const ref
Definition at line 331 of file ps_located.h. References _InvMass, and NL3D::TPSAttribFloat.
00331 { return _InvMass; }
|
|
|
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; }
|
|
|
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; }
|
|
|
Definition at line 296 of file ps_located.h. References _LifeScheme.
00296 { return _LifeScheme; }
|
|
|
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; }
|
|
|
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 }
|
|
||||||||||||||||
|
***************************************************************************************
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 }
|
|
|
Definition at line 315 of file ps_located.h. References _MassScheme.
00315 { return _MassScheme; }
|
|
|
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; }
|
|
|
|
|
get the located bindable name (edition purpose)
Definition at line 495 of file ps_located.h.
00495 { return _Name; }
|
|
|
|
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; }
|
|
|
retrieve the particle system that owns this process (const version)
Definition at line 114 of file particle_system_process.h.
00114 { return _Owner ; }
|
|
|
|
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; }
|
|
|
get Pos attrib const ref
Definition at line 336 of file ps_located.h. References NL3D::TPSAttribVector.
00336 { return _Pos; }
|
|
|
|
***************************************************************************************
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 }
|
|
|
|
get Speed attrib const ref
Definition at line 341 of file ps_located.h. References NL3D::TPSAttribVector.
00341 { return _Speed; }
|
|
|
|
get Time attrib const ref
Definition at line 346 of file ps_located.h. References NL3D::TPSAttribTime.
00346 { return _Time; }
|
|
|
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; }
|
|
|
get TotalTime attrib const ref
Definition at line 351 of file ps_located.h. References _TimeIncrement, and NL3D::TPSAttribTime.
00351 { return _TimeIncrement; }
|
|
|
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; }
|
|
|
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 }
|
|
|
***************************************************************************************
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 }
|
|
|
***************************************************************************************
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 }
|
|
|
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 }
|
|
|
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; }
|
|
|
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 }
|
|
|
Test whether LOD degradation was activated
Definition at line 514 of file ps_located.h. References _LODDegradation.
00514 { return _LODDegradation; }
|
|
|
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 }
|
|
|
*************************************************************************************** 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 }
|
|
|
***************************************************************************************
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 }
|
|
||||||||||||||||||||||||||||
|
*************************************************************************************** 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 }
|
|
|
***************************************************************************************
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 }
|
|
|
Reimplemented from NL3D::CParticleSystemProcess. Definition at line 148 of file ps_located.h.
00148 { return true; }
|
|
|
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;}
|
|
|
Test wether a trigger on death has been enabled.
Definition at line 555 of file ps_located.h. References _TriggerOnDeath.
00555 { return _TriggerOnDeath; }
|
|
||||||||||||||||||||||||||||
|
*************************************************************************************** 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
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 }
|
|
|
|
|
|
*************************************************************************************** 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 }
|
|
|
***************************************************************************************
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 }
|
|
||||||||||||||||
|
***************************************************************************************
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 }
|
|
||||||||||||
|
*************************************************************************************** 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 }
|
|
|
***************************************************************************************
Implements NL3D::CParticleSystemProcess. Definition at line 442 of file ps_located.cpp. References _MaxNumFaces, and uint.
00443 {
00444 return _MaxNumFaces;
00445 }
|
|
|
*************************************************************************************** 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 }
|
|
|
*************************************************************************************** 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 }
|
|
|
***************************************************************************************
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 }
|
|
|
*************************************************************************************** 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 }
|
|
|
***************************************************************************************
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 }
|
|
|
***************************************************************************************
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 }
|
|
|
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 }
|
|
|
*************************************************************************************** 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 }
|
|
|
*************************************************************************************** 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 }
|
|
|
***************************************************************************************
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 }
|
|
|
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 }
|
|
|
***************************************************************************************
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 }
|
|
|
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; }
|
|
|
*************************************************************************************** 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 }
|
|
|
*************************************************************************************** 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 }
|
|
|
*************************************************************************************** set immortality for located
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 }
|
|
|
*************************************************************************************** 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 }
|
|
|
*************************************************************************************** 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 }
|
|
|
***************************************************************************************
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 }
|
|
|
set the located bindable name (edition purpose)
Definition at line 492 of file ps_located.h.
00492 { _Name = name; }
|
|
|
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 }
|
|
|
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 }
|
|
|
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 }
|
|
|
***************************************************************************************
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 }
|
|
||||||||||||||||
|
*************************************************************************************** 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 }
|
|
|
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 }
|
|
|
***************************************************************************************
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 }
|
|
|
*************************************************************************************** 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 }
|
|
|
*************************************************************************************** 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 }
|
|
|
***************************************************************************************
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 }
|
|
|
*************************************************************************************** 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 }
|
|
|
***************************************************************************************
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 }
|
|
|
Definition at line 588 of file ps_located.h. |
|
|
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(). |
|
|
Definition at line 662 of file ps_located.h. Referenced by queryCollisionInfo(), releaseAllRef(), releaseCollisionInfo(), and ~CPSLocated(). |
|
|
Definition at line 723 of file ps_located.h. Referenced by registerDtorObserver(), releaseAllRef(), releaseRefTo(), unregisterDtorObserver(), and ~CPSLocated(). |
|
|
Definition at line 667 of file ps_located.h. Referenced by evalMaxDuration(), getInitialLife(), newElement(), setInitialLife(), and updateLife(). |
|
|
Definition at line 672 of file ps_located.h. Referenced by getInitialMass(), newElement(), and setInitialMass(). |
|
|
Definition at line 736 of file ps_located.h. Referenced by integrateSingle(), performParametricMotion(), registerIntegrableForce(), releaseAllRef(), setMatrixMode(), unregisterIntegrableForce(), and ~CPSLocated(). |
|
|
Definition at line 620 of file ps_located.h. Referenced by checkIntegrity(), deleteElement(), getInvMass(), newElement(), and resize(). |
|
|
Definition at line 615 of file ps_located.h. Referenced by evalMaxDuration(), getLastForever(), setInitialLife(), setLastForever(), setLifeScheme(), and updateLife(). |
|
|
Definition at line 668 of file ps_located.h. Referenced by evalMaxDuration(), getLifeScheme(), newElement(), setInitialLife(), setLifeScheme(), updateLife(), and ~CPSLocated(). |
|
|
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(). |
|
|
true when LOD degradation apply to this located
Definition at line 726 of file ps_located.h. Referenced by forceLODDegradation(), hasLODDegradation(), and step(). |
|
|
Definition at line 673 of file ps_located.h. Referenced by getMassScheme(), newElement(), setInitialMass(), setMassScheme(), and ~CPSLocated(). |
|
|
|
cache the max number of faces this located may want
Definition at line 592 of file ps_located.h. Referenced by notifyMaxNumFacesChanged(), and querryMaxWantedNumFaces(). |
|
|
Definition at line 607 of file ps_located.h. |
|
|
Definition at line 594 of file ps_located.h. |
|
|
Definition at line 597 of file ps_located.h. Referenced by getFrameRate(), setFrameRate(), and step(). |
|
|
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(). |
|
|
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(). |
|
|
Definition at line 190 of file particle_system_process.h. Referenced by getConversionMatrix(). |
|
|
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(). |
|
|
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(). |
|
|
Definition at line 621 of file ps_located.h. |
|
|
this stack is used after each update to generate located
Definition at line 693 of file ps_located.h. Referenced by postNewElement(), and updateNewElementRequestStack(). |
|
|
Definition at line 611 of file ps_located.h. |
|
|
Definition at line 622 of file ps_located.h. |
|
|
Definition at line 623 of file ps_located.h. |
|
|
Definition at line 624 of file ps_located.h. Referenced by checkIntegrity(), deleteElement(), getTimeIncrement(), newElement(), resize(), and updateLife(). |
|
|
Definition at line 738 of file ps_located.h. Referenced by deleteElement(), getTriggerEmitterID(), and setTriggerEmitterID(). |
|
|
Definition at line 737 of file ps_located.h. Referenced by deleteElement(), enableTriggerOnDeath(), getTriggerEmitterID(), isTriggerOnDeathEnabled(), and setTriggerEmitterID(). |
|
|
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(). |
1.3.6