From 0ea5fc66924303d1bf73ba283a383e2aadee02f2 Mon Sep 17 00:00:00 2001 From: neodarz Date: Sat, 11 Aug 2018 20:21:34 +0200 Subject: Initial commit --- docs/doxygen/nel/a03181.html | 7517 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 7517 insertions(+) create mode 100644 docs/doxygen/nel/a03181.html (limited to 'docs/doxygen/nel/a03181.html') diff --git a/docs/doxygen/nel/a03181.html b/docs/doxygen/nel/a03181.html new file mode 100644 index 00000000..2e14b1aa --- /dev/null +++ b/docs/doxygen/nel/a03181.html @@ -0,0 +1,7517 @@ + + +NeL: NL3D::CPSEmitterDirectionnal class Reference + + + +

NL3D::CPSEmitterDirectionnal Class Reference

#include <ps_emitter.h> +

Inheritance diagram for NL3D::CPSEmitterDirectionnal: +

+ + + + + + + + + + +

Detailed Description

+Emit in one direction. This can be the 0, 0, 0 vector. +

+ +

+Definition at line 450 of file ps_emitter.h. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Public Types
enum TEmissionType {
+ regular = 0, +onDeath = 1, +once = 2, +onBounce = 3, +
+ externEmit = 4, +numEmissionType +
+ }

Public Member Functions
virtual void basisChanged (TPSMatrixMode systemBasis)
bool checkLoop () const
==========================================================================

virtual bool completeBBox (NLMISC::CAABBox &box) const
NLMISC::CVector computeI (void) const
NLMISC::CVector computeJ (void) const
NLMISC::CVector computeK (void) const
CPSEmitterDirectionnal ()
virtual bool doesProduceBBox (void) const
virtual void emit (const NLMISC::CVector &srcPos, uint32 index, NLMISC::CVector &pos, NLMISC::CVector &speed)
==========================================================================

void enableConsistenEmission (bool enable)
virtual void enableGlobalVectorValue (const std::string &name)
virtual void enumTexs (std::vector< NLMISC::CSmartPtr< ITexture > > &dest, IDriver &drv)
bool getBypassAutoLOD () const
virtual std::string getClassName ()=0
NLMISC::CVector getDir (void) const
IDriver * getDriver () const
shortcut to get an instance of the driver

TEmissionType getEmissionType (void) const
Get the frequency type.

float getEmitDelay () const
Get the delay in seconds before the first emission (regular emitter only).

const CPSLocated * getEmittedType (void) const
Get const ptr on emitted type.

CPSLocated * getEmittedType (void)
Get emitted type.

float getEmitteeSpeed (void) const
get the modulation speed (valid only if no scheme is used)

const CPSAttribMaker< float > * getEmitteeSpeedScheme (void) const
get the speed modulation shceme, or NULL if no one is set (const version)

CPSAttribMaker< float > * getEmitteeSpeedScheme (void)
get the speed modulation shceme, or NULL if no one is set

uint32 getExternID (void) const
get the extern ID of this located bindable

const CFontGenerator * getFontGenerator (void) const
Shortcut to get the font generator if one was set (const version).

CFontGenerator * getFontGenerator (void)
Shortcut to get the font generator if one was set.

const CFontManager * getFontManager (void) const
Shortcut to get the font manager if one was set (const version).

CFontManager * getFontManager (void)
***************************************************************************************

uint getGenNb (void) const
Retrieve the GenNb for emission, valid only if a GenNb scheme is used.

const CPSAttribMaker< uint32 > * getGenNbScheme (void) const
Retrieve the GenNb scheme, or null, if there'isnt (const version).

CPSAttribMaker< uint32 > * getGenNbScheme (void)
Retrieve the GenNb scheme, or null, if there'isnt.

virtual std::string getGlobalVectorValueName () const
const NLMISC::CMatrix & getInvertedSysMat (void) const
shortcut to get the inverted matrix of the system

const NLMISC::CMatrix & getInvertedViewMat (void) const
shortcut to get the inverted view matrix

const NLMISC::CMatrix & getLocalToWorldMatrix () const
Shortcut to get the local to world matrix.

TPSLod getLOD (void) const
get the valid lods for that object

uint8 getMaxEmissionCount () const
Get the max. number of particle emission (0 means no limit and is the default). Applies with regular emitter only.

std::string getName (void) const
get the located bindable name (edition purpose)

const CPSLocated * getOwner (void) const
get the located that owns this bindable (const version)

CPSLocated * getOwner (void)
get the located that owns this bindable

float getPeriod (void) const
Retrieve the period for emission, valid only if a period scheme is used.

const CPSAttribMaker< float > * getPeriodScheme (void) const
CPSAttribMaker< float > * getPeriodScheme (void)
virtual uint32 getPriority (void) const
Return priority for emitters.

const NLMISC::CMatrix & getSysMat (void) const
***************************************************************************************

uint32 getType (void) const
Return this bindable type.

virtual bool getUserMatrixUsageCount () const
==========================================================================

const NLMISC::CMatrix & getViewMat (void) const
shortcut to get the view matrix

virtual bool hasEmitters (void) const
tells wether there are alive emitters

virtual bool hasEmitters (void)
Return true if this located bindable derived class holds alive emitters.

virtual bool hasParticles (void) const
tells wether there are alive entities / particles

bool isActive () const
bool isConsistentEmissionEnabled () const
virtual void motionTypeChanged (bool parametric)
called when a located has switch between incrmental / parametric motion. The default does nothing

NLMISC_DECLARE_CLASS (CPSEmitterDirectionnal)
virtual void notifyTargetRemoved (CPSLocated *ptr)
==========================================================================

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

virtual void serial (NLMISC::IStream &f) throw (NLMISC::EStream)
==========================================================================

void serialEmitteeSpeedScheme (NLMISC::IStream &f) throw (NLMISC::EStream)
serialization

void setActive (bool active)
Activate / Deactivate this object. When not active, the owning system won't try to call the 'step' method.

void setBypassAutoLOD (bool bypass)
void setDir (const NLMISC::CVector &v)
bool setEmissionType (TEmissionType freqType)
==========================================================================

void setEmitDelay (float delay)
==========================================================================

bool setEmittedType (CPSLocated *et)
==========================================================================

void setEmitteeSpeed (float speed)
set a constant speed modulation for emittee

void setEmitteeSpeedScheme (CPSAttribMaker< float > *scheme)
void setExternID (uint32 id)
***************************************************************************************

void setGenNb (uint32 GenNb)
==========================================================================

void setGenNbScheme (CPSAttribMaker< uint32 > *scheme)
==========================================================================

void setLOD (TPSLod lod)
bool setMaxEmissionCount (uint8 count)
==========================================================================

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

virtual void setOwner (CPSLocated *psl)
==========================================================================

void setPeriod (float period)
==========================================================================

void setPeriodScheme (CPSAttribMaker< float > *scheme)
==========================================================================

void setupDriverModelMatrix (void)
shortcut to setup the model matrix (system basis or world basis)

virtual void setZBias (float value)
virtual void showTool (void)
==========================================================================

void singleEmit (uint32 index, uint quantity)
==========================================================================

virtual void step (TPSProcessPass pass, TAnimationTime ellapsedTime, TAnimationTime realEllapsedTime)
==========================================================================

virtual bool supportGlobalVectorValue () const
virtual void systemDateChanged ()
bool testEmitForever () const
==========================================================================

bool useEmitteeSpeedScheme (void) const
check wether a speed modulation scheme is being used

bool useGenNbScheme (void)
Indicate whether a GenNb scheme is used or not.

bool usePeriodScheme (void)
Indicate whether a period scheme is used or not.

Static Public Member Functions
void setBypassEmitOnDeath (bool bypass)

Protected Member Functions
virtual void bounceOccured (uint32 index)
==========================================================================

virtual void deleteElement (uint32 index)
==========================================================================

void deleteEmitteeSpeedElement (uint32 index)
void displayIcon2d (const NLMISC::CVector tab[], uint nbSegs, float scale)
***************************************************************************************

virtual CPSLocated * getModulatedEmitterOwner (void)
bool isUserMatrixUsed () const
==========================================================================

virtual void newElement (CPSLocated *emitter, uint32 emitterIndex)
==========================================================================

void newEmitteeSpeedElement (CPSLocated *emitter, uint32 emitterIndex)
void processEmit (uint32 index, sint nbToGenerate)
==========================================================================

void processEmitConsistent (const NLMISC::CVector &emitterPos, uint32 emitterIndex, sint nbToGenerate, TAnimationTime deltaT, TAnimationTime ellapsedTime, float realEllapsedTimeRatio)
==========================================================================

void processRegularEmission (TAnimationTime ellapsedTime, float emitLOD)
==========================================================================

void processRegularEmissionConsistent (TAnimationTime ellapsedTime, float realEllapsedTimeRatio, float emitLOD, float inverseEmitLOD)
==========================================================================

void processRegularEmissionConsistentWithNoLOD (TAnimationTime ellapsedTime, float realEllapsedTimeRatio)
==========================================================================

void processRegularEmissionWithNoLOD (TAnimationTime ellapsedTime)
==========================================================================

virtual void resize (uint32 capacity)
==========================================================================

void resizeEmitteeSpeed (uint32 capacity)
void updateMaxCountVect ()
==========================================================================

void updatePSRefCountForUserMatrixUsage (bool matrixIsNeededNow, bool matrixWasNeededBefore)
==========================================================================

Protected Attributes
bool _Active
bool _BypassAutoLOD: 1
bool _ConsistentEmission: 1
NLMISC::CVector _Dir
TEmissionType _EmissionType
float _EmitDelay
CPSLocated * _EmittedType
A pointer on the type to be emitted.

float _EmitteeSpeed
CPSAttribMaker< float > * _EmitteeSpeedScheme
uint32 _ExternID
uint32 _GenNb
CPSAttribMaker< uint32 > * _GenNbScheme
TPSLod _LOD
tells when this object must be dealt with

uint8 _MaxEmissionCount
std::string _Name
TPSAttribUInt8 _NumEmission
CPSLocated * _Owner
float _Period
CPSAttribMaker< float > * _PeriodScheme
TPSAttribFloat _Phase
bool _SpeedBasisEmission: 1
float _SpeedInheritanceFactor
TPSMatrixMode _UserDirectionMatrixMode
bool _UserMatrixModeForEmissionDirection: 1

Static Protected Attributes
bool _BypassEmitOnDeath = false

Friends
class CPSLocated
+

Member Enumeration Documentation

+ + + + +
+ + +
enum NL3D::CPSEmitter::TEmissionType [inherited] +
+
+ + + + + +
+ + + +
+The type of emission. regular : means use Period, and generation number (the number of particle to generate when an emission occurs) onDeath : emit when the emitter is destroyed once : emit when the emitter is created onBounce : emit when the emitter bounce externEmit : emitted explicitly by the system user. A 4 letter id must be used to identify this kind of emitters the default ID is NONE
Enumeration values:
+ + + + + + + +
regular +
onDeath +
once +
onBounce +
externEmit +
numEmissionType +
+
+ +
+Definition at line 109 of file ps_emitter.h. +
+Referenced by NL3D::CPSEmitter::getEmissionType(), and NL3D::CPSEmitter::setEmissionType(). +
+
00109 { regular = 0, onDeath = 1, once = 2, onBounce = 3, externEmit = 4, numEmissionType }; +

+

Constructor & Destructor Documentation

+ + + + +
+ + + + + + + + + +
NL3D::CPSEmitterDirectionnal::CPSEmitterDirectionnal ( ) [inline]
+
+ + + + + +
+ + + +
+ +
+Definition at line 457 of file ps_emitter.h. +
+References _Dir. +
+
00457 : _Dir(NLMISC::CVector::K) +00458 { +00459 if (CParticleSystem::getSerializeIdentifierFlag()) _Name = std::string("DirectionnalEmitter"); +00460 } +

+

Member Function Documentation

+ + + + +
+ + + + + + + + + + +
virtual void NL3D::CPSLocatedBindable::basisChanged ( TPSMatrixMode systemBasis ) [inline, virtual, inherited]
+
+ + + + + +
+ + + +
+Called when the basis of the owner changed. the default behaviour does nothing
Parameters:
+ + +
newBasis : True if in the system basis, false for the world basis.
+
+ +
+Reimplemented in NL3D::CPSForce. +
+Definition at line 968 of file ps_located.h. +
+
00968 {} +

+

+ + + + +
+ + + + + + + + + + +
void NL3D::CPSEmitter::bounceOccured ( uint32 index ) [protected, virtual, inherited]
+
+ + + + + +
+ + + +
+========================================================================== +
+ +
+Reimplemented from NL3D::CPSLocatedBindable. +
+Definition at line 1908 of file ps_emitter.cpp. +
+References NL3D::CPSEmitter::_EmissionType, NL3D::CPSEmitter::_EmittedType, NL3D::CPSEmitter::_GenNb, NL3D::CPSEmitter::_GenNbScheme, NL3D::CPSAttribMaker< uint32 >::get(), index, NL3D::CPSEmitter::processEmit(), and uint32. +
+
01909 { +01910 // TODO : avoid duplication with deleteElement +01911 if (_EmittedType && _EmissionType == CPSEmitter::onBounce) +01912 { +01913 const uint32 nbToGenerate = _GenNbScheme ? _GenNbScheme->get(_Owner, index) : _GenNb; +01914 processEmit(index, nbToGenerate); +01915 } +01916 } +

+

+ + + + +
+ + + + + + + + + +
bool NL3D::CPSEmitter::checkLoop ( ) const [inherited]
+
+ + + + + +
+ + + +
+========================================================================== +
+check if there's a loop with that e=mitter eg A emit B emit A NB : the emitter should be inserted in a system, otherwise -> assert +
+Definition at line 2117 of file ps_emitter.cpp. +
+References NL3D::CPSEmitter::_EmittedType, NL3D::CPSLocated::getBoundObject(), NL3D::CPSLocated::getNbBoundObjects(), NL3D::CParticleSystemProcess::getOwner(), nlassert, and uint32. +
+Referenced by NL3D::CParticleSystem::hasLoop(). +
+
02118 { +02119 nlassert(_Owner); +02120 nlassert(_Owner->getOwner()); +02121 if (!_EmittedType) return false; +02122 std::set<const CPSLocated *> seenLocated; // the located we've already seen +02123 std::vector<const CPSLocated *> leftLoc(1); // the located that are left to see +02124 leftLoc[0] = _EmittedType; +02125 do +02126 { +02127 const CPSLocated *curr = leftLoc.back(); +02128 if (curr == this->_Owner) return true; +02129 leftLoc.pop_back(); +02130 seenLocated.insert(curr); +02131 for(uint32 k = 0; k < curr->getNbBoundObjects(); ++k) +02132 { +02133 const CPSEmitter *emitter = dynamic_cast<const CPSEmitter *>(curr->getBoundObject(k)); +02134 if (emitter && emitter->_EmittedType) +02135 { +02136 if (seenLocated.find(emitter->_EmittedType) == seenLocated.end()) // not already seen this one ? +02137 { +02138 leftLoc.push_back(emitter->_EmittedType); +02139 } +02140 } +02141 } +02142 } +02143 while (!leftLoc.empty()); +02144 return false; +02145 } +

+

+ + + + +
+ + + + + + + + + + +
virtual bool NL3D::CPSLocatedBindable::completeBBox ( NLMISC::CAABBox & box ) const [inline, virtual, inherited]
+
+ + + + + +
+ + + +
+ +
+Reimplemented in NL3D::CPSFanLight, NL3D::CPSQuad, and NL3D::CPSShockWave. +
+Definition at line 884 of file ps_located.h. +
+
00884 { return false ;} +

+

+ + + + +
+ + + + + + + + + + +
NLMISC::CVector NL3D::CPSLocatedBindable::computeI ( void ) const [inline, inherited]
+
+ + + + + +
+ + + +
+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 931 of file ps_located.h. +
+References NL3D::CPSLocated::computeI(). +
+Referenced by NL3D::CPSLocatedBindable::displayIcon2d(), NL3D::CPSFanLightHelper::drawFanLight(), NL3D::CPSFaceLookAtHelper::drawLookAt(), NL3D::CPSFaceLookAtHelper::drawLookAtAlignOnMotion(), NL3D::CPSGravity::show(), and NL3D::CPSEmitter::showTool(). +
+
00931 { return _Owner->computeI(); } +

+

+ + + + +
+ + + + + + + + + + +
NLMISC::CVector NL3D::CPSLocatedBindable::computeJ ( void ) const [inline, inherited]
+
+ + + + + +
+ + + +
+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 936 of file ps_located.h. +
+References NL3D::CPSLocated::computeJ(). +
+Referenced by NL3D::CPSFaceLookAtHelper::drawLookAt(). +
+
00936 { return _Owner->computeJ(); } +

+

+ + + + +
+ + + + + + + + + + +
NLMISC::CVector NL3D::CPSLocatedBindable::computeK ( void ) const [inline, inherited]
+
+ + + + + +
+ + + +
+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 940 of file ps_located.h. +
+References NL3D::CPSLocated::computeK(). +
+Referenced by NL3D::CPSLocatedBindable::displayIcon2d(), NL3D::CPSFanLightHelper::drawFanLight(), NL3D::CPSFaceLookAtHelper::drawLookAt(), NL3D::CPSFaceLookAtHelper::drawLookAtAlignOnMotion(), and NL3D::CPSEmitter::showTool(). +
+
00940 { return _Owner->computeK(); } +

+

+ + + + +
+ + + + + + + + + + +
void NL3D::CPSEmitterDirectionnal::deleteElement ( uint32 index ) [protected, virtual]
+
+ + + + + +
+ + + +
+========================================================================== +
+ +
+Reimplemented from NL3D::CPSEmitter. +
+Definition at line 2270 of file ps_emitter.cpp. +
+References NL3D::CPSModulatedEmitter::deleteEmitteeSpeedElement(), index, and uint32. +
+
02271 { +02272 CPSEmitter::deleteElement(index); +02273 deleteEmitteeSpeedElement(index); +02274 } +

+

+ + + + +
+ + + + + + + + + + +
void NL3D::CPSModulatedEmitter::deleteEmitteeSpeedElement ( uint32 index ) [inline, protected, inherited]
+
+ + + + + +
+ + + +
+ +
+Definition at line 429 of file ps_emitter.h. +
+References NL3D::CPSModulatedEmitter::_EmitteeSpeedScheme, NL3D::CPSAttribMaker< float >::deleteElement(), NL3D::CPSAttribMaker< float >::hasMemory(), index, and uint32. +
+Referenced by NL3D::CPSSphericalEmitter::deleteElement(), NL3D::CPSEmitterRectangle::deleteElement(), deleteElement(), and NL3D::CPSEmitterOmni::deleteElement(). +
+
00430 { +00431 if (_EmitteeSpeedScheme && _EmitteeSpeedScheme->hasMemory()) _EmitteeSpeedScheme->deleteElement(index); +00432 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
void NL3D::CPSLocatedBindable::displayIcon2d ( const NLMISC::CVector tab[],
uint nbSegs,
float scale
) [protected, inherited]
+
+ + + + + +
+ + + +
+*************************************************************************************** +
+show an drawing to represent the object, and in red if it is selected
Parameters:
+ + + + +
tab : a table of 2 * nbSeg vector. only the x and y coordinates are used
nbSeg : the number of segment
scale : the scale to use for drawing
+
+ +
+Definition at line 2038 of file ps_located.cpp. +
+References NL3D::CPSLocatedBindable::computeI(), NL3D::CPSLocatedBindable::computeK(), NL3D::CParticleSystem::getCurrentEditedElement(), NL3D::CPSLocatedBindable::getDriver(), NL3D::CParticleSystemProcess::getOwner(), NL3D::CPSLocated::getPos(), NL3D::CPSLocated::getSize(), index, NL3D::CMaterial::setBlend(), NL3D::CMaterial::setBlendFunc(), NL3D::CMaterial::setColor(), NL3D::CMaterial::setLighting(), NL3D::CPSLocatedBindable::setupDriverModelMatrix(), NL3D::CMaterial::setZFunc(), NL3D::CMaterial::setZWrite(), size, uint, uint32, NLMISC::CLine::V0, NLMISC::CLine::V1, NLMISC::CVector::x, and NLMISC::CVector::y. +
+Referenced by NL3D::CPSSpring::show(), NL3D::CPSCentralGravity::show(), and NL3D::CPSParticle::showTool(). +
+
02039 { +02040 uint32 size = _Owner->getSize(); +02041 if (!size) return; +02042 setupDriverModelMatrix(); +02043 +02044 const CVector I = computeI(); +02045 const CVector K = computeK(); +02046 +02047 static std::vector<NLMISC::CLine> lines; +02048 +02049 lines.clear(); +02050 +02051 // ugly slow code, but not for runtime +02052 for (uint k = 0; k < size; ++k) +02053 { +02054 // center of the current particle +02055 const CVector p = _Owner->getPos()[k]; +02056 +02057 +02058 +02059 for (uint l = 0; l < nbSegs; ++l) +02060 { +02061 NLMISC::CLine li; +02062 li.V0 = p + scale * (tab[l << 1].x * I + tab[l << 1].y * K); +02063 li.V1 = p + scale * (tab[(l << 1) + 1].x * I + tab[(l << 1) + 1].y * K); +02064 lines.push_back(li); +02065 } +02066 +02067 CMaterial mat; +02068 +02069 mat.setBlendFunc(CMaterial::one, CMaterial::one); +02070 mat.setZWrite(false); +02071 mat.setLighting(false); +02072 mat.setBlend(true); +02073 mat.setZFunc(CMaterial::less); +02074 +02075 +02076 +02077 CPSLocated *loc; +02078 uint32 index; +02079 CPSLocatedBindable *lb; +02080 _Owner->getOwner()->getCurrentEditedElement(loc, index, lb); +02081 +02082 mat.setColor((lb == NULL || this == lb) && loc == _Owner && index == k ? CRGBA::Red : CRGBA(127, 127, 127)); +02083 +02084 +02085 CDRU::drawLinesUnlit(lines, mat, *getDriver() ); +02086 } +02087 +02088 } +

+

+ + + + +
+ + + + + + + + + + +
virtual bool NL3D::CPSLocatedBindable::doesProduceBBox ( void ) const [inline, virtual, inherited]
+
+ + + + + +
+ + + +
+ +
+Reimplemented in NL3D::CPSForce. +
+Definition at line 888 of file ps_located.h. +
+
00888 { return true; } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
void NL3D::CPSEmitterDirectionnal::emit ( const NLMISC::CVector & srcPos,
uint32 index,
NLMISC::CVector & pos,
NLMISC::CVector & speed
) [virtual]
+
+ + + + + +
+ + + +
+========================================================================== +
+ +
+Implements NL3D::CPSEmitter. +
+Reimplemented in NL3D::CPSRadialEmitter, and NL3D::CPSEmitterConic. +
+Definition at line 2252 of file ps_emitter.cpp. +
+References _Dir, NL3D::CPSAttribMaker< float >::get(), index, nlassert, and uint32. +
+
02253 { +02254 // TODO : verifier que ca marche si une particule s'emet elle-mem +02255 nlassert(_EmittedType); +02256 +02257 +02258 speed = (_EmitteeSpeedScheme ? _EmitteeSpeedScheme->get(_Owner, index) : _EmitteeSpeed) * _Dir; +02259 pos = srcPos; +02260 } +

+

+ + + + +
+ + + + + + + + + + +
void NL3D::CPSEmitter::enableConsistenEmission ( bool enable ) [inline, inherited]
+
+ + + + + +
+ + + +
+Enable consistent emission. The default is false. This try to keep the number of emitted particle constant, by allowing more than one emission cycle per iteration. This is useful to deal with poor frmerate. This has several drawbacks though :
+
collisions are not properly supported in this case (may be resolved later).
The motion is in straight lines.
It assumes that emitter has no motion (for now). In fact, this should be used when there can't be collisions with the emitted particles, and with main emitters only. NB : this has no effect if the emission period is 0 (which mean emit at each frame)
+ +
+Definition at line 236 of file ps_emitter.h. +
+References NL3D::CPSEmitter::_ConsistentEmission. +
+
00236 { _ConsistentEmission = enable; } +

+

+ + + + +
+ + + + + + + + + + +
virtual void NL3D::CPSDirection::enableGlobalVectorValue ( const std::string & name ) [inline, virtual, inherited]
+
+ + + + + +
+ + + +
+The direction is taken from a global vector defined in the particle system NULL or an empty string as a name disable the use of a global value +
+Reimplemented in NL3D::CPSDirectionnalForce. +
+Definition at line 49 of file ps_direction.h. +
+
00049 {} +

+

+ + + + +
+ + + + + + + + + + +
void NL3D::CPSEmitter::enableSpeedBasisEmission ( bool enabled = true ) [inherited]
+
+ + + + + +
+ + + +
+=============================================================================== +
+Align the direction of emission on the emitter speed. NB This also implies that the coord. system in which the speed vector is expressed if the same than the one of the emitter so the calls to enableUserMatrixModeForEmissionDirection() & setUserMatrixModeForEmissionDirection() have no effects (but their value is retained) +
+Definition at line 2593 of file ps_emitter.cpp. +
+References NL3D::CPSEmitter::_SpeedBasisEmission, NL3D::CPSEmitter::isUserMatrixUsed(), and NL3D::CPSEmitter::updatePSRefCountForUserMatrixUsage(). +
+
02594 { +02595 bool wasUserMatNeeded = isUserMatrixUsed(); +02596 _SpeedBasisEmission = enabled; +02597 updatePSRefCountForUserMatrixUsage(isUserMatrixUsed(), wasUserMatNeeded); +02598 } +

+

+ + + + +
+ + + + + + + + + + +
void NL3D::CPSEmitter::enableUserMatrixModeForEmissionDirection ( bool enable = true ) [inherited]
+
+ + + + + +
+ + + +
+=============================================================================== +
+By default, the direction of emission is supposed to be expressed in the same coordinate system than the one of the emitter. Enabling a user matrix mode for the direction of emission allows to change that behaviour. example of use : A fire p.s is linked to a torch, but the torch doesn't point to the top. So particles are emitted in the axis aligned to the torch If matrix mode for direction emission is set to PSIdentityMatrix, then the direction is interpreted to be in world, and is thus independant from the torch orientation : particles are always spawned in the +K direction.
+NB : if isSpeedBasisEmissionEnabled() == true then this flag is meaningless +
+Definition at line 2601 of file ps_emitter.cpp. +
+References NL3D::CPSEmitter::_UserMatrixModeForEmissionDirection, NL3D::CPSEmitter::isUserMatrixUsed(), and NL3D::CPSEmitter::updatePSRefCountForUserMatrixUsage(). +
+
02602 { +02603 bool wasUserMatNeeded = isUserMatrixUsed(); +02604 _UserMatrixModeForEmissionDirection = enable; +02605 updatePSRefCountForUserMatrixUsage(isUserMatrixUsed(), wasUserMatNeeded); +02606 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
virtual void NL3D::CPSLocatedBindable::enumTexs ( std::vector< NLMISC::CSmartPtr< ITexture > > & dest,
IDriver & drv
) [inline, virtual, inherited]
+
+ + + + + +
+ + + +
+ +
+Reimplemented in NL3D::CPSFanLight, NL3D::CPSQuad, NL3D::CPSRibbon, NL3D::CPSRibbonLookAt, and NL3D::CPSShockWave. +
+Definition at line 977 of file ps_located.h. +
+
00977 {} +

+

+ + + + +
+ + + + + + + + + + +
void NL3D::CPSLocatedBindable::finalize ( void ) [virtual, inherited]
+
+ + + + + +
+ + + +
+*************************************************************************************** +
+this should be called before to delete any bindable inserted in a system, but this is done by the system, so you should never need calling it. This has been introduced because calls in dtor are not polymorphic to derived class (which are already destroyed anyway), and some infos are needed in some dtor. The default behaviour does nothing +
+Reimplemented in NL3D::CPSTargetLocatedBindable. +
+Definition at line 1975 of file ps_located.cpp. +
+References NL3D::CParticleSystemProcess::getOwner(), NL3D::CPSLocatedBindable::getUserMatrixUsageCount(), and NL3D::CParticleSystem::releaseRefForUserSysCoordInfo(). +
+
01976 { +01977 if (_Owner && _Owner->getOwner()) +01978 { +01979 _Owner->getOwner()->releaseRefForUserSysCoordInfo(getUserMatrixUsageCount()); +01980 } +01981 } +

+

+ + + + +
+ + + + + + + + + +
bool NL3D::CPSEmitter::getBypassAutoLOD ( ) const [inline, inherited]
+
+ + + + + +
+ + + +
+ +
+Definition at line 252 of file ps_emitter.h. +
+References NL3D::CPSEmitter::_BypassAutoLOD. +
+
00252 { return _BypassAutoLOD; } +

+

+ + + + +
+ + + + + + + + + +
virtual std::string NLMISC::IClassable::getClassName ( ) [pure virtual, inherited]
+
+ + + + + +
+ + + +
+ +
+Implemented in NLAIAGENT::CNumericIndex, NLAIC::IPointerGestion, NLAIC::CIdentType, and CAutomataDesc. +
+Referenced by NLMISC::CClassRegistry::checkObject(), and NL3D::GetTextureSize().
+

+ + + + +
+ + + + + + + + + + +
NLMISC::CVector NL3D::CPSEmitterDirectionnal::getDir ( void ) const [inline, virtual]
+
+ + + + + +
+ + + +
+ +
+Implements NL3D::CPSDirection. +
+Definition at line 472 of file ps_emitter.h. +
+References _Dir. +
+
00472 { return _Dir; } +

+

+ + + + +
+ + + + + + + + + + +
IDriver* NL3D::CPSLocatedBindable::getDriver ( void ) const [inline, inherited]
+
+ + + + + +
+ + + +
+shortcut to get an instance of the driver +
+ +
+Definition at line 890 of file ps_located.h. +
+References NL3D::CPSLocated::getDriver(), and nlassert. +
+Referenced by NL3D::CPSLocatedBindable::displayIcon2d(), NL3D::CPSTailDot::displayRibbons(), NL3D::CPSRibbonLookAt::displayRibbons(), NL3D::CPSRibbon::displayRibbons(), NL3D::CPSDot::draw(), NL3D::CPSFaceHelper::drawFaces(), NL3D::CPSFanLightHelper::drawFanLight(), NL3D::CPSFaceLookAtHelper::drawLookAt(), NL3D::CPSFaceLookAtHelper::drawLookAtAlignOnMotion(), NL3D::CPSConstraintMeshHelper::drawMeshs(), NL3D::CPSConstraintMeshHelper::drawPrerotatedMeshs(), NL3D::CPSZoneRectangle::show(), NL3D::CPSZoneCylinder::show(), NL3D::CPSZoneDisc::show(), NL3D::CPSZoneSphere::show(), NL3D::CPSZonePlane::show(), NL3D::CPSLight::show(), NL3D::CPSCylindricVortex::show(), NL3D::CPSGravity::show(), NL3D::CPSDirectionnalForce::show(), NL3D::CPSSphericalEmitter::showTool(), NL3D::CPSEmitterRectangle::showTool(), and NL3D::CPSEmitter::showTool(). +
+
00891 { +00892 nlassert(_Owner); +00893 nlassert(_Owner->getDriver()); +00894 return _Owner->getDriver(); +00895 } +

+

+ + + + +
+ + + + + + + + + + +
TEmissionType NL3D::CPSEmitter::getEmissionType ( void ) const [inline, inherited]
+
+ + + + + +
+ + + +
+Get the frequency type. +
+ +
+Definition at line 118 of file ps_emitter.h. +
+References NL3D::CPSEmitter::_EmissionType, and NL3D::CPSEmitter::TEmissionType. +
+Referenced by NL3D::CParticleSystem::evalDuration(), and NL3D::CPSEmitter::testEmitForever(). +
+
00118 { return _EmissionType; } +

+

+ + + + +
+ + + + + + + + + +
float NL3D::CPSEmitter::getEmitDelay ( ) const [inline, inherited]
+
+ + + + + +
+ + + +
+Get the delay in seconds before the first emission (regular emitter only). +
+ +
+Definition at line 144 of file ps_emitter.h. +
+References NL3D::CPSEmitter::_EmitDelay. +
+Referenced by NL3D::CParticleSystem::evalDuration(). +
+
00144 { return _EmitDelay; } +

+

+ + + + +
+ + + + + + + + + + +
const CPSLocated* NL3D::CPSEmitter::getEmittedType ( void ) const [inline, inherited]
+
+ + + + + +
+ + + +
+Get const ptr on emitted type. +
+ +
+Definition at line 98 of file ps_emitter.h. +
+References NL3D::CPSEmitter::_EmittedType. +
+
00098 { return _EmittedType; } +

+

+ + + + +
+ + + + + + + + + + +
CPSLocated* NL3D::CPSEmitter::getEmittedType ( void ) [inline, inherited]
+
+ + + + + +
+ + + +
+Get emitted type. +
+ +
+Definition at line 96 of file ps_emitter.h. +
+References NL3D::CPSEmitter::_EmittedType. +
+Referenced by NL3D::CParticleSystem::evalDuration(). +
+
00096 { return _EmittedType; } +

+

+ + + + +
+ + + + + + + + + + +
float NL3D::CPSModulatedEmitter::getEmitteeSpeed ( void ) const [inline, inherited]
+
+ + + + + +
+ + + +
+get the modulation speed (valid only if no scheme is used) +
+ +
+Definition at line 405 of file ps_emitter.h. +
+References NL3D::CPSModulatedEmitter::_EmitteeSpeed. +
+
00405 { return _EmitteeSpeed; } +

+

+ + + + +
+ + + + + + + + + + +
const CPSAttribMaker<float>* NL3D::CPSModulatedEmitter::getEmitteeSpeedScheme ( void ) const [inline, inherited]
+
+ + + + + +
+ + + +
+get the speed modulation shceme, or NULL if no one is set (const version) +
+ +
+Definition at line 411 of file ps_emitter.h. +
+References NL3D::CPSModulatedEmitter::_EmitteeSpeedScheme. +
+
00411 { return _EmitteeSpeedScheme; } +

+

+ + + + +
+ + + + + + + + + + +
CPSAttribMaker<float>* NL3D::CPSModulatedEmitter::getEmitteeSpeedScheme ( void ) [inline, inherited]
+
+ + + + + +
+ + + +
+get the speed modulation shceme, or NULL if no one is set +
+ +
+Definition at line 408 of file ps_emitter.h. +
+References NL3D::CPSModulatedEmitter::_EmitteeSpeedScheme. +
+
00408 { return _EmitteeSpeedScheme; } +

+

+ + + + +
+ + + + + + + + + + +
uint32 NL3D::CPSLocatedBindable::getExternID ( void ) const [inline, inherited]
+
+ + + + + +
+ + + +
+get the extern ID of this located bindable +
+ +
+Definition at line 964 of file ps_located.h. +
+References NL3D::CPSLocatedBindable::_ExternID, and uint32. +
+Referenced by NL3D::CPSLocated::bind(), and NL3D::CParticleSystem::unregisterLocatedBindableExternID(). +
+
00964 { return _ExternID; } +

+

+ + + + +
+ + + + + + + + + + +
const CFontGenerator* NL3D::CPSLocatedBindable::getFontGenerator ( void ) const [inline, inherited]
+
+ + + + + +
+ + + +
+Shortcut to get the font generator if one was set (const version). +
+ +
+Definition at line 904 of file ps_located.h. +
+References NL3D::CParticleSystemProcess::getFontGenerator(), and nlassert. +
+
00905 { +00906 nlassert(_Owner); +00907 return _Owner->getFontGenerator(); +00908 } +

+

+ + + + +
+ + + + + + + + + + +
CFontGenerator* NL3D::CPSLocatedBindable::getFontGenerator ( void ) [inline, inherited]
+
+ + + + + +
+ + + +
+Shortcut to get the font generator if one was set. +
+ +
+Definition at line 897 of file ps_located.h. +
+References NL3D::CParticleSystemProcess::getFontGenerator(), and nlassert. +
+Referenced by NL3D::CPSZoneRectangle::show(), NL3D::CPSZoneCylinder::show(), NL3D::CPSZoneDisc::show(), NL3D::CPSZonePlane::show(), NL3D::CPSCylindricVortex::show(), NL3D::CPSGravity::show(), and NL3D::CPSEmitterRectangle::showTool(). +
+
00898 { +00899 nlassert(_Owner); +00900 return _Owner->getFontGenerator(); +00901 } +

+

+ + + + +
+ + + + + + + + + + +
const CFontManager * NL3D::CPSLocatedBindable::getFontManager ( void ) const [inherited]
+
+ + + + + +
+ + + +
+Shortcut to get the font manager if one was set (const version). +
+ +
+Definition at line 2099 of file ps_located.cpp. +
+References NL3D::CParticleSystemProcess::getFontManager(), and nlassert. +
+
02100 { +02101 nlassert(_Owner); +02102 return _Owner->getFontManager(); +02103 } +

+

+ + + + +
+ + + + + + + + + + +
CFontManager * NL3D::CPSLocatedBindable::getFontManager ( void ) [inherited]
+
+ + + + + +
+ + + +
+*************************************************************************************** +
+ +
+Definition at line 2091 of file ps_located.cpp. +
+References NL3D::CParticleSystemProcess::getFontManager(), and nlassert. +
+Referenced by NL3D::CPSZoneRectangle::show(), NL3D::CPSZoneCylinder::show(), NL3D::CPSZoneDisc::show(), NL3D::CPSZonePlane::show(), NL3D::CPSCylindricVortex::show(), NL3D::CPSGravity::show(), and NL3D::CPSEmitterRectangle::showTool(). +
+
02092 { +02093 nlassert(_Owner); +02094 return _Owner->getFontManager(); +02095 } +

+

+ + + + +
+ + + + + + + + + + +
uint NL3D::CPSEmitter::getGenNb ( void ) const [inline, inherited]
+
+ + + + + +
+ + + +
+Retrieve the GenNb for emission, valid only if a GenNb scheme is used. +
+ +
+Definition at line 162 of file ps_emitter.h. +
+References NL3D::CPSEmitter::_GenNb, and uint. +
+
00162 { return _GenNb; } +

+

+ + + + +
+ + + + + + + + + + +
const CPSAttribMaker<uint32>* NL3D::CPSEmitter::getGenNbScheme ( void ) const [inline, inherited]
+
+ + + + + +
+ + + +
+Retrieve the GenNb scheme, or null, if there'isnt (const version). +
+ +
+Definition at line 174 of file ps_emitter.h. +
+References NL3D::CPSEmitter::_GenNbScheme. +
+
00174 { return _GenNbScheme; } +

+

+ + + + +
+ + + + + + + + + + +
CPSAttribMaker<uint32>* NL3D::CPSEmitter::getGenNbScheme ( void ) [inline, inherited]
+
+ + + + + +
+ + + +
+Retrieve the GenNb scheme, or null, if there'isnt. +
+ +
+Definition at line 171 of file ps_emitter.h. +
+References NL3D::CPSEmitter::_GenNbScheme. +
+
00171 { return _GenNbScheme; } +

+

+ + + + +
+ + + + + + + + + +
virtual std::string NL3D::CPSDirection::getGlobalVectorValueName ( ) const [inline, virtual, inherited]
+
+ + + + + +
+ + + +
+ +
+Reimplemented in NL3D::CPSDirectionnalForce. +
+Definition at line 50 of file ps_direction.h. +
+
00050 { return ""; } +

+

+ + + + +
+ + + + + + + + + + +
const NLMISC::CMatrix & NL3D::CPSLocatedBindable::getInvertedSysMat ( void ) const [inherited]
+
+ + + + + +
+ + + +
+shortcut to get the inverted matrix of the system +
+ +
+Definition at line 2116 of file ps_located.cpp. +
+References NL3D::CParticleSystem::getInvertedSysMat(), NL3D::CParticleSystemProcess::getOwner(), and nlassert. +
+
02117 { +02118 nlassert(_Owner); +02119 return _Owner->getOwner()->getInvertedSysMat(); +02120 +02121 } +

+

+ + + + +
+ + + + + + + + + + +
const NLMISC::CMatrix & NL3D::CPSLocatedBindable::getInvertedViewMat ( void ) const [inherited]
+
+ + + + + +
+ + + +
+shortcut to get the inverted view matrix +
+ +
+Definition at line 2134 of file ps_located.cpp. +
+References NL3D::CParticleSystem::getInvertedViewMat(), NL3D::CParticleSystemProcess::getOwner(), and nlassert. +
+
02135 { +02136 nlassert(_Owner); +02137 return _Owner->getOwner()->getInvertedViewMat(); +02138 } +

+

+ + + + +
+ + + + + + + + + +
const NLMISC::CMatrix & NL3D::CPSLocatedBindable::getLocalToWorldMatrix ( ) const [inline, inherited]
+
+ + + + + +
+ + + +
+Shortcut to get the local to world matrix. +
+ +
+Definition at line 1144 of file ps_located.h. +
+References NL3D::CPSLocated::getLocalToWorldMatrix(), and nlassert. +
+Referenced by NL3D::CPSRibbonLookAt::displayRibbons(), NL3D::CPSSound::newElement(), NL3D::CPSZoneRectangle::show(), NL3D::CPSZoneCylinder::show(), NL3D::CPSZoneDisc::show(), NL3D::CPSZonePlane::show(), NL3D::CPSLight::show(), NL3D::CPSGravity::show(), NL3D::CPSEmitterRectangle::showTool(), NL3D::CPSLight::step(), and NL3D::CPSMesh::updatePos(). +
+
01145 { +01146 nlassert(_Owner); +01147 return _Owner->getLocalToWorldMatrix(); +01148 } +

+

+ + + + +
+ + + + + + + + + + +
TPSLod NL3D::CPSLocatedBindable::getLOD ( void ) const [inline, inherited]
+
+ + + + + +
+ + + +
+get the valid lods for that object +
+ +
+Definition at line 954 of file ps_located.h. +
+References NL3D::CPSLocatedBindable::_LOD, and NL3D::TPSLod. +
+
00954 { return _LOD; } +

+

+ + + + +
+ + + + + + + + + +
uint8 NL3D::CPSEmitter::getMaxEmissionCount ( ) const [inline, inherited]
+
+ + + + + +
+ + + +
+Get the max. number of particle emission (0 means no limit and is the default). Applies with regular emitter only. +
+ +
+Definition at line 154 of file ps_emitter.h. +
+References NL3D::CPSEmitter::_MaxEmissionCount, and uint8. +
+Referenced by NL3D::CParticleSystem::evalDuration(), and NL3D::CPSEmitter::testEmitForever(). +
+
00154 { return _MaxEmissionCount; } +

+

+ + + + +
+ + + + + + + + + + +
virtual CPSLocated* NL3D::CPSEmitterDirectionnal::getModulatedEmitterOwner ( void ) [inline, protected, virtual]
+
+ + + + + +
+ + + +
+ +
+Implements NL3D::CPSModulatedEmitter. +
+Definition at line 479 of file ps_emitter.h. +
+
00479 { return _Owner; } +

+

+ + + + +
+ + + + + + + + + + +
std::string NL3D::CPSLocatedBindable::getName ( void ) const [inline, inherited]
+
+ + + + + +
+ + + +
+get the located bindable name (edition purpose) +
+ +
+Definition at line 948 of file ps_located.h. +
+
00948 { return _Name; } +

+

+ + + + +
+ + + + + + + + + + +
const CPSLocated* NL3D::CPSLocatedBindable::getOwner ( void ) const [inline, inherited]
+
+ + + + + +
+ + + +
+get the located that owns this bindable (const version) +
+ +
+Definition at line 944 of file ps_located.h. +
+
00944 { return _Owner; } +

+

+ + + + +
+ + + + + + + + + + +
CPSLocated* NL3D::CPSLocatedBindable::getOwner ( void ) [inline, inherited]
+
+ + + + + +
+ + + +
+get the located that owns this bindable +
+ +
+Definition at line 942 of file ps_located.h. +
+Referenced by NL3D::CPSLocated::deleteElement(), NL3D::CParticleSystemInstanceUser::emit(), NL3D::CPSFaceLookAt::CSecondSize::getSizeOwner(), NL3D::CPSSound::newElement(), NL3D::CPSLocated::registerIntegrableForce(), NL3D::CParticleSystem::registerLocatedBindableExternID(), NL3D::CParticleSystemInstanceUser::removeByID(), NL3D::CPSSound::resize(), NL3D::CPSLight::resize(), NL3D::CPSSound::step(), NL3D::CPSLocated::unregisterIntegrableForce(), and NL3D::CParticleSystem::unregisterLocatedBindableExternID(). +
+
00942 { return _Owner; } +

+

+ + + + +
+ + + + + + + + + + +
float NL3D::CPSEmitter::getPeriod ( void ) const [inline, inherited]
+
+ + + + + +
+ + + +
+Retrieve the period for emission, valid only if a period scheme is used. +
+ +
+Definition at line 126 of file ps_emitter.h. +
+References NL3D::CPSEmitter::_Period. +
+Referenced by NL3D::CParticleSystem::evalDuration(). +
+
00126 { return _Period; } +

+

+ + + + +
+ + + + + + + + + + +
const CPSAttribMaker<float>* NL3D::CPSEmitter::getPeriodScheme ( void ) const [inline, inherited]
+
+ + + + + +
+ + + +
+ +
+Definition at line 138 of file ps_emitter.h. +
+References NL3D::CPSEmitter::_PeriodScheme. +
+
00138 { return _PeriodScheme; } +

+

+ + + + +
+ + + + + + + + + + +
CPSAttribMaker<float>* NL3D::CPSEmitter::getPeriodScheme ( void ) [inline, inherited]
+
+ + + + + +
+ + + +
+ +
+Definition at line 135 of file ps_emitter.h. +
+References NL3D::CPSEmitter::_PeriodScheme. +
+Referenced by NL3D::CParticleSystem::evalDuration(). +
+
00135 { return _PeriodScheme; } +

+

+ + + + +
+ + + + + + + + + + +
virtual uint32 NL3D::CPSEmitter::getPriority ( void ) const [inline, virtual, inherited]
+
+ + + + + +
+ + + +
+Return priority for emitters. +
+ +
+Implements NL3D::CPSLocatedBindable. +
+Definition at line 67 of file ps_emitter.h. +
+References uint32. +
+
00067 { return 500; } +

+

+ + + + +
+ + + + + + + + + + +
float NL3D::CPSEmitter::getSpeedInheritanceFactor ( void ) const [inline, inherited]
+
+ + + + + +
+ + + +
+Get the speed Inheritance factor. +
+ +
+Definition at line 190 of file ps_emitter.h. +
+References NL3D::CPSEmitter::_SpeedInheritanceFactor. +
+
00191 { +00192 return _SpeedInheritanceFactor; +00193 } +

+

+ + + + +
+ + + + + + + + + + +
const NLMISC::CMatrix & NL3D::CPSLocatedBindable::getSysMat ( void ) const [inherited]
+
+ + + + + +
+ + + +
+*************************************************************************************** +
+ +
+Definition at line 2108 of file ps_located.cpp. +
+References NL3D::CParticleSystemProcess::getOwner(), NL3D::CParticleSystem::getSysMat(), and nlassert. +
+
02109 { +02110 nlassert(_Owner); +02111 return _Owner->getOwner()->getSysMat(); +02112 } +

+

+ + + + +
+ + + + + + + + + + +
uint32 NL3D::CPSEmitter::getType ( void ) const [inline, virtual, inherited]
+
+ + + + + +
+ + + +
+Return this bindable type. +
+ +
+Implements NL3D::CPSLocatedBindable. +
+Definition at line 63 of file ps_emitter.h. +
+References NL3D::PSEmitter, and uint32. +
+
00063 { return PSEmitter; } +

+

+ + + + +
+ + + + + + + + + +
TPSMatrixMode NL3D::CPSEmitter::getUserMatrixModeForEmissionDirection ( ) const [inline, inherited]
+
+ + + + + +
+ + + +
+=============================================================================== +
+Align the direction of emission on the emitter speed. NB This also implies that the coord. system in which the speed vector is expressed if the same than the one of the emitter so the calls to enableUserMatrixModeForEmissionDirection() & setUserMatrixModeForEmissionDirection() have no effects (but their value is retained) +
+Definition at line 222 of file ps_emitter.h. +
+References NL3D::CPSEmitter::_UserDirectionMatrixMode, and NL3D::TPSMatrixMode. +
+
00222 { return _UserDirectionMatrixMode; } +

+

+ + + + +
+ + + + + + + + + +
bool NL3D::CPSEmitter::getUserMatrixUsageCount ( ) const [virtual, inherited]
+
+ + + + + +
+ + + +
+========================================================================== +
+ +
+Reimplemented from NL3D::CPSLocatedBindable. +
+Definition at line 2640 of file ps_emitter.cpp. +
+References NL3D::CPSEmitter::isUserMatrixUsed(). +
+
02641 { +02642 return isUserMatrixUsed() ? 1 : 0; +02643 } +

+

+ + + + +
+ + + + + + + + + + +
const NLMISC::CMatrix & NL3D::CPSLocatedBindable::getViewMat ( void ) const [inherited]
+
+ + + + + +
+ + + +
+shortcut to get the view matrix +
+ +
+Definition at line 2125 of file ps_located.cpp. +
+References NL3D::CParticleSystemProcess::getOwner(), NL3D::CParticleSystem::getViewMat(), and nlassert. +
+Referenced by NL3D::CPSRibbonLookAt::displayRibbons(), and NL3D::CPSFaceLookAtHelper::drawLookAt(). +
+
02126 { +02127 nlassert(_Owner); +02128 return _Owner->getOwner()->getViewMat(); +02129 } +

+

+ + + + +
+ + + + + + + + + + +
virtual bool NL3D::CPSLocatedBindable::hasEmitters ( void ) const [inline, virtual, inherited]
+
+ + + + + +
+ + + +
+tells wether there are alive emitters +
+ +
+Definition at line 958 of file ps_located.h. +
+
00958 { return false; } +

+

+ + + + +
+ + + + + + + + + + +
virtual bool NL3D::CPSEmitter::hasEmitters ( void ) [inline, virtual, inherited]
+
+ + + + + +
+ + + +
+Return true if this located bindable derived class holds alive emitters. +
+ +
+Definition at line 70 of file ps_emitter.h. +
+References NL3D::CPSLocated::getSize(), and nlassert. +
+
00070 { nlassert(_Owner); return _Owner->getSize() != 0; } +

+

+ + + + +
+ + + + + + + + + + +
virtual bool NL3D::CPSLocatedBindable::hasParticles ( void ) const [inline, virtual, inherited]
+
+ + + + + +
+ + + +
+tells wether there are alive entities / particles +
+ +
+Reimplemented in NL3D::CPSParticle. +
+Definition at line 956 of file ps_located.h. +
+
00956 { return false; } +

+

+ + + + +
+ + + + + + + + + +
bool NL3D::CPSLocatedBindable::isActive ( ) const [inline, inherited]
+
+ + + + + +
+ + + +
+ +
+Definition at line 844 of file ps_located.h. +
+References NL3D::CPSLocatedBindable::_Active. +
+Referenced by NL3D::CParticleSystem::hasActiveEmitters(). +
+
00844 { return _Active; } +

+

+ + + + +
+ + + + + + + + + +
bool NL3D::CPSEmitter::isConsistentEmissionEnabled ( ) const [inline, inherited]
+
+ + + + + +
+ + + +
+ +
+Definition at line 238 of file ps_emitter.h. +
+References NL3D::CPSEmitter::_ConsistentEmission. +
+
00238 { return _ConsistentEmission; } +

+

+ + + + +
+ + + + + + + + + + +
bool NL3D::CPSEmitter::isSpeedBasisEmissionEnabled ( void ) const [inline, inherited]
+
+ + + + + +
+ + + +
+Check if the direction of emission is aligned on the emitter speed.
See also:
enableSpeedBasisEmission()
+ +
+Definition at line 204 of file ps_emitter.h. +
+References NL3D::CPSEmitter::_SpeedBasisEmission. +
+
00204 { return _SpeedBasisEmission; } +

+

+ + + + +
+ + + + + + + + + +
bool NL3D::CPSEmitter::isUserMatrixModeForEmissionDirectionEnabled ( ) const [inline, inherited]
+
+ + + + + +
+ + + +
+=============================================================================== +
+Align the direction of emission on the emitter speed. NB This also implies that the coord. system in which the speed vector is expressed if the same than the one of the emitter so the calls to enableUserMatrixModeForEmissionDirection() & setUserMatrixModeForEmissionDirection() have no effects (but their value is retained) +
+Definition at line 216 of file ps_emitter.h. +
+References NL3D::CPSEmitter::_UserMatrixModeForEmissionDirection. +
+
00216 { return _UserMatrixModeForEmissionDirection; } +

+

+ + + + +
+ + + + + + + + + +
bool NL3D::CPSEmitter::isUserMatrixUsed ( ) const [protected, inherited]
+
+ + + + + +
+ + + +
+========================================================================== +
+ +
+Definition at line 2634 of file ps_emitter.cpp. +
+References NL3D::CPSEmitter::_SpeedBasisEmission, NL3D::CPSEmitter::_UserDirectionMatrixMode, NL3D::CPSEmitter::_UserMatrixModeForEmissionDirection, and NL3D::PSUserMatrix. +
+Referenced by NL3D::CPSEmitter::enableSpeedBasisEmission(), NL3D::CPSEmitter::enableUserMatrixModeForEmissionDirection(), NL3D::CPSEmitter::getUserMatrixUsageCount(), and NL3D::CPSEmitter::setUserMatrixModeForEmissionDirection(). +
+
02635 { +02636 return !_SpeedBasisEmission && _UserMatrixModeForEmissionDirection && _UserDirectionMatrixMode == PSUserMatrix; +02637 } +

+

+ + + + +
+ + + + + + + + + + +
virtual void NL3D::CPSLocatedBindable::motionTypeChanged ( bool parametric ) [inline, virtual, inherited]
+
+ + + + + +
+ + + +
+called when a located has switch between incrmental / parametric motion. The default does nothing +
+ +
+Reimplemented in NL3D::CPSRibbonBase. +
+Definition at line 971 of file ps_located.h. +
+Referenced by NL3D::CPSLocated::bind(). +
+
00971 {} +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
void NL3D::CPSEmitterDirectionnal::newElement ( CPSLocated * emitter,
uint32 emitterIndex
) [protected, virtual]
+
+ + + + + +
+ + + +
+========================================================================== +
+ +
+Reimplemented from NL3D::CPSEmitter. +
+Definition at line 2263 of file ps_emitter.cpp. +
+References NL3D::CPSModulatedEmitter::newEmitteeSpeedElement(), and uint32. +
+
02264 { +02265 CPSEmitter::newElement(emitter, emitterIndex); +02266 newEmitteeSpeedElement(emitter, emitterIndex); +02267 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
void NL3D::CPSModulatedEmitter::newEmitteeSpeedElement ( CPSLocated * emitter,
uint32 emitterIndex
) [inline, protected, inherited]
+
+ + + + + +
+ + + +
+ +
+Definition at line 424 of file ps_emitter.h. +
+References NL3D::CPSModulatedEmitter::_EmitteeSpeedScheme, NL3D::CPSAttribMaker< float >::hasMemory(), NL3D::CPSAttribMaker< float >::newElement(), and uint32. +
+Referenced by NL3D::CPSSphericalEmitter::newElement(), NL3D::CPSEmitterRectangle::newElement(), newElement(), and NL3D::CPSEmitterOmni::newElement(). +
+
00425 { +00426 if (_EmitteeSpeedScheme && _EmitteeSpeedScheme->hasMemory()) _EmitteeSpeedScheme->newElement(emitter, emitterIndex); +00427 } +

+

+ + + + +
+ + + + + + + + + + +
NL3D::CPSEmitterDirectionnal::NLMISC_DECLARE_CLASS ( CPSEmitterDirectionnal )
+
+ + + + + +
+ + + +
+
+

+ + + + +
+ + + + + + + + + + +
void NL3D::CPSEmitter::notifyTargetRemoved ( CPSLocated * ptr ) [virtual, inherited]
+
+ + + + + +
+ + + +
+========================================================================== +
+Inherited from CPSLocatedBindable We register to the emitted type, so, this, this will be called when it is destroyed +
+Reimplemented from NL3D::CPSLocatedBindable. +
+Definition at line 394 of file ps_emitter.cpp. +
+References NL3D::CPSEmitter::_EmittedType, nlassert, and NL3D::CPSEmitter::setEmittedType(). +
+
00395 { +00396 nlassert(ptr == _EmittedType && _EmittedType); +00397 setEmittedType(NULL); +00398 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
void NL3D::CPSEmitter::processEmit ( uint32 index,
sint nbToGenerate
) [inline, protected, inherited]
+
+ + + + + +
+ + + +
+========================================================================== +
+ +
+Definition at line 119 of file ps_emitter.cpp. +
+References NL3D::CPSEmitter::_EmittedType, NL3D::CPSEmitter::_SpeedBasisEmission, NL3D::CPSEmitter::_SpeedInheritanceFactor, NL3D::CPSEmitter::_UserDirectionMatrixMode, NL3D::CPSEmitter::_UserMatrixModeForEmissionDirection, NL3D::CPSEmitter::emit(), NL3D::CParticleSystemProcess::getMatrixMode(), NL3D::CPSLocated::getPos(), NL3D::CPSLocated::getSpeed(), index, NL3D::CPSLocated::newElement(), nlassert, sint, and uint32. +
+Referenced by NL3D::CPSEmitter::bounceOccured(), NL3D::CPSEmitter::deleteElement(), NL3D::CPSEmitter::processRegularEmission(), NL3D::CPSEmitter::processRegularEmissionConsistent(), NL3D::CPSEmitter::processRegularEmissionConsistentWithNoLOD(), NL3D::CPSEmitter::processRegularEmissionWithNoLOD(), NL3D::CPSEmitter::singleEmit(), and NL3D::CPSEmitter::step(). +
+
00120 { +00121 static NLMISC::CVector speed, pos; +00122 nlassert(_Owner); +00123 if (!_SpeedBasisEmission) +00124 { +00125 if (_SpeedInheritanceFactor == 0.f) +00126 { +00127 if (!_UserMatrixModeForEmissionDirection) +00128 { +00129 while (nbToGenerate > 0) +00130 { +00131 nbToGenerate --; +00132 emit(_Owner->getPos()[index], index, pos, speed); +00133 _EmittedType->newElement(pos, speed, this->_Owner, index, _Owner->getMatrixMode(), 0.f); +00134 } +00135 } +00136 else +00137 { +00138 while (nbToGenerate > 0) +00139 { +00140 nbToGenerate --; +00141 emit(_Owner->getPos()[index], index, pos, speed); +00142 _EmittedType->newElement(pos, speed, this->_Owner, index, _UserDirectionMatrixMode, 0.f); +00143 } +00144 } +00145 } +00146 else +00147 { +00148 while (nbToGenerate --) +00149 { +00150 emit(_Owner->getPos()[index], index, pos, speed); +00151 _EmittedType->newElement(pos, speed + _SpeedInheritanceFactor * _Owner->getSpeed()[index], this->_Owner, 0, _Owner->getMatrixMode(), 0.f); +00152 } +00153 } +00154 } +00155 else +00156 { +00157 NLMISC::CMatrix m; +00158 CPSUtil::buildSchmidtBasis(_Owner->getSpeed()[index], m); +00159 if (_SpeedInheritanceFactor == 0.f) +00160 { +00161 while (nbToGenerate > 0) +00162 { +00163 nbToGenerate --; +00164 emit(_Owner->getPos()[index], index, pos, speed); +00165 _EmittedType->newElement(pos, m * speed, this->_Owner, index, _Owner->getMatrixMode(), 0.f); +00166 } +00167 } +00168 else +00169 { +00170 while (nbToGenerate --) +00171 { +00172 emit(_Owner->getPos()[index], index, pos, speed); +00173 _EmittedType->newElement(pos, m * speed + _SpeedInheritanceFactor * _Owner->getSpeed()[index], this->_Owner, index, _Owner->getMatrixMode(), 0.f); +00174 } +00175 } +00176 } +00177 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
void NL3D::CPSEmitter::processEmitConsistent ( const NLMISC::CVector & emitterPos,
uint32 index,
sint nbToGenerate,
TAnimationTime deltaT,
TAnimationTime ellapsedTime,
float realEllapsedTimeRatio
) [inline, protected, inherited]
+
+ + + + + +
+ + + +
+========================================================================== +
+speed and pos of emittee +
+Definition at line 247 of file ps_emitter.cpp. +
+References NL3D::CPSEmitter::_EmittedType, NL3D::CPSEmitter::_SpeedBasisEmission, NL3D::CPSEmitter::_SpeedInheritanceFactor, NL3D::CPSEmitter::_UserDirectionMatrixMode, NL3D::CPSEmitter::_UserMatrixModeForEmissionDirection, NL3D::CompensateEmission(), NL3D::CPSEmitter::emit(), NL3D::CParticleSystemProcess::getMatrixMode(), NL3D::CPSLocated::getSpeed(), index, NL3D::CPSLocated::newElement(), nlassert, sint, NL3D::TAnimationTime, and uint32. +
+Referenced by NL3D::CPSEmitter::processRegularEmissionConsistent(), and NL3D::CPSEmitter::processRegularEmissionConsistentWithNoLOD(). +
+
00254 { +00255 static NLMISC::CVector speed, pos; +00256 nlassert(_Owner); +00257 sint emittedIndex; +00258 if (!_SpeedBasisEmission) +00259 { +00260 if (_SpeedInheritanceFactor == 0.f) +00261 { +00262 if (!_UserMatrixModeForEmissionDirection) +00263 { +00264 while (nbToGenerate > 0) +00265 { +00266 nbToGenerate --; +00267 emit(emitterPos, index, pos, speed); +00268 emittedIndex = _EmittedType->newElement(pos, speed, this->_Owner, index, _Owner->getMatrixMode(), deltaT); +00269 if (emittedIndex != - 1) CompensateEmission(_EmittedType, emittedIndex, deltaT, ellapsedTime, realEllapsedTimeRatio); +00270 else break; +00271 } +00272 } +00273 else +00274 { +00275 while (nbToGenerate > 0) +00276 { +00277 nbToGenerate --; +00278 emit(emitterPos, index, pos, speed); +00279 emittedIndex = _EmittedType->newElement(pos, speed, this->_Owner, index, _UserDirectionMatrixMode, deltaT); +00280 if (emittedIndex != - 1) CompensateEmission(_EmittedType, emittedIndex, deltaT, ellapsedTime, realEllapsedTimeRatio); +00281 else break; +00282 } +00283 } +00284 } +00285 else +00286 { +00287 while (nbToGenerate --) +00288 { +00289 emit(emitterPos, index, pos, speed); +00290 emittedIndex = _EmittedType->newElement(pos, speed + _SpeedInheritanceFactor * _Owner->getSpeed()[index], this->_Owner, index, _Owner->getMatrixMode(), deltaT); +00291 if (emittedIndex != - 1) CompensateEmission(_EmittedType, emittedIndex, deltaT, ellapsedTime, realEllapsedTimeRatio); +00292 else break; +00293 } +00294 } +00295 } +00296 else +00297 { +00298 NLMISC::CMatrix m; +00299 CPSUtil::buildSchmidtBasis(_Owner->getSpeed()[index], m); +00300 if (_SpeedInheritanceFactor == 0.f) +00301 { +00302 while (nbToGenerate > 0) +00303 { +00304 nbToGenerate --; +00305 emit(emitterPos, index, pos, speed); +00306 emittedIndex = _EmittedType->newElement(pos, m * speed, this->_Owner, index, _Owner->getMatrixMode(), deltaT); +00307 if (emittedIndex != - 1) CompensateEmission(_EmittedType, emittedIndex, deltaT, ellapsedTime, realEllapsedTimeRatio); +00308 else break; +00309 } +00310 } +00311 else +00312 { +00313 while (nbToGenerate --) +00314 { +00315 emit(emitterPos, index, pos, speed); +00316 emittedIndex = _EmittedType->newElement(pos, m * speed + _SpeedInheritanceFactor * _Owner->getSpeed()[index], this->_Owner, index, _Owner->getMatrixMode(), deltaT); +00317 if (emittedIndex != - 1) CompensateEmission(_EmittedType, emittedIndex, deltaT, ellapsedTime, realEllapsedTimeRatio); +00318 else break; +00319 } +00320 } +00321 } +00322 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
void NL3D::CPSEmitter::processRegularEmission ( TAnimationTime ellapsedTime,
float emitLOD
) [protected, inherited]
+
+ + + + + +
+ + + +
+========================================================================== +
+is there an emission delay ?
+is there an emission delay ? +
+Test if 'make' filled our buffer. If this is not the case, we assume that values where precomputed, and that all null period have already been replaced by the threshold +
+Definition at line 665 of file ps_emitter.cpp. +
+References NL3D::CPSEmitter::_EmitDelay, NL3D::CPSEmitter::_GenNb, NL3D::CPSEmitter::_GenNbScheme, NL3D::CPSEmitter::_MaxEmissionCount, NL3D::CPSEmitter::_NumEmission, NL3D::CPSEmitter::_Period, NL3D::CPSEmitter::_PeriodScheme, NL3D::CPSEmitter::_Phase, NL3D::CPSAttrib< T >::begin(), NL3D::CPSAttrib< float >::begin(), NL3D::EMIT_PERIOD_THRESHOLD, NL3D::EMITTER_BUFF_SIZE, NL3D::CPSAttribMaker< uint32 >::get(), NL3D::CPSAttribMaker< float >::getMaxValue(), NL3D::CPSAttribMaker< float >::getMinValue(), NL3D::CParticleSystemProcess::getOwner(), NL3D::CPSLocated::getSize(), NL3D::CParticleSystem::isEmitThresholdEnabled(), NL3D::CPSAttribMaker< float >::make(), nlassert, NL3D::CPSEmitter::processEmit(), NL3D::replaceNullPeriodsByThreshold(), sint32, size, NL3D::TAnimationTime, uint, uint32, and uint8. +
+Referenced by NL3D::CPSEmitter::step(). +
+
00666 { +00667 nlassert(_Owner); +00668 nlassert(_Owner->getOwner()); +00669 // +00670 const bool emitThreshold = _Owner->getOwner()->isEmitThresholdEnabled(); +00671 // +00672 const uint size = _Owner->getSize(); +00673 uint leftToDo = size, toProcess; +00674 float emitPeriod[EMITTER_BUFF_SIZE]; +00675 const float *currEmitPeriod; +00676 uint currEmitPeriodPtrInc = _PeriodScheme ? 1 : 0; +00677 sint32 nbToGenerate; +00678 +00679 TPSAttribTime::iterator phaseIt = _Phase.begin(), endPhaseIt; +00680 TPSAttribUInt8::iterator numEmitIt = _NumEmission.begin(); +00681 +00682 float ellapsedTimeLOD = emitLOD * ellapsedTime; +00683 uint maxEmissionCountLOD = (uint8) (_MaxEmissionCount * emitLOD); +00684 maxEmissionCountLOD = std::max(1u, maxEmissionCountLOD); +00685 +00686 // we don't use an iterator here +00687 // because it could be invalidated if size change (a located could generate itself) +00688 do +00689 { +00690 toProcess = leftToDo < EMITTER_BUFF_SIZE ? leftToDo : EMITTER_BUFF_SIZE; +00691 +00692 +00693 if (_PeriodScheme) +00694 { +00695 currEmitPeriod = (float *) (_PeriodScheme->make(_Owner, size - leftToDo, emitPeriod, sizeof(float), toProcess, true)); +00696 if (emitThreshold) +00697 { +00698 +00702 if (currEmitPeriod == emitPeriod) +00703 { +00704 // if there possibility to have 0 in the scheme ? +00705 if (_PeriodScheme->getMinValue() <= 0.f && _PeriodScheme->getMaxValue() >= 0.f) +00706 { +00707 replaceNullPeriodsByThreshold(emitPeriod, toProcess); +00708 } +00709 } +00710 } +00711 } +00712 else +00713 { +00714 if (_Period != 0.f || !emitThreshold) +00715 { +00716 currEmitPeriod = &_Period; +00717 } +00718 else +00719 { +00720 currEmitPeriod = &EMIT_PERIOD_THRESHOLD; +00721 } +00722 } +00723 +00724 endPhaseIt = phaseIt + toProcess; +00725 +00726 if (_MaxEmissionCount == 0) // no emission count limit +00727 { +00729 if (_EmitDelay == 0.f) // no emission delay +00730 { +00731 do +00732 { +00733 *phaseIt += ellapsedTimeLOD; +00734 if ( *phaseIt >= *currEmitPeriod) // phase is greater than period -> must emit +00735 { +00736 if (*currEmitPeriod != 0) +00737 { +00738 *phaseIt -= ::floorf(*phaseIt / *currEmitPeriod) * *currEmitPeriod; +00739 } +00740 const uint32 k = phaseIt - (_Phase.begin()); +00741 nbToGenerate = _GenNbScheme ? _GenNbScheme->get(_Owner, k) : _GenNb; +00742 if (nbToGenerate) +00743 { +00744 nbToGenerate = (sint32) (emitLOD * nbToGenerate); +00745 if (!nbToGenerate) nbToGenerate = 1; +00746 processEmit(k, nbToGenerate); +00747 } +00748 } +00749 +00750 ++phaseIt; +00751 currEmitPeriod += currEmitPeriodPtrInc; +00752 } +00753 while (phaseIt != endPhaseIt); +00754 } +00755 else // there's an emission delay +00756 { +00757 do +00758 { +00759 if (*phaseIt < _EmitDelay) +00760 { +00761 *phaseIt += ellapsedTime; +00762 if (*phaseIt < _EmitDelay) +00763 { +00764 ++phaseIt; +00765 currEmitPeriod += currEmitPeriodPtrInc; +00766 continue; +00767 } +00768 else +00769 { +00770 *phaseIt = (*phaseIt - _EmitDelay) * emitLOD + _EmitDelay; +00771 } +00772 } +00773 else +00774 { +00775 *phaseIt += ellapsedTimeLOD; +00776 } +00777 +00778 if ( *phaseIt >= *currEmitPeriod + _EmitDelay) // phase is greater than period -> must emit +00779 { +00780 if (*currEmitPeriod != 0) +00781 { +00782 *phaseIt -= ::floorf((*phaseIt - _EmitDelay) / *currEmitPeriod) * *currEmitPeriod; +00783 } +00784 const uint32 k = phaseIt - (_Phase.begin()); +00785 nbToGenerate = _GenNbScheme ? _GenNbScheme->get(_Owner, k) : _GenNb; +00786 if (nbToGenerate) +00787 { +00788 nbToGenerate = (sint32) (emitLOD * nbToGenerate); +00789 if (!nbToGenerate) nbToGenerate = 1; +00790 processEmit(k, nbToGenerate); +00791 } +00792 } +00793 +00794 ++phaseIt; +00795 currEmitPeriod += currEmitPeriodPtrInc; +00796 } +00797 while (phaseIt != endPhaseIt); +00798 } +00799 } +00800 else // there's an emission count limit +00801 { +00803 if (_EmitDelay == 0.f) // no emission delay +00804 { +00805 do +00806 { +00807 if (*numEmitIt < maxEmissionCountLOD) +00808 { +00809 *phaseIt += ellapsedTimeLOD; +00810 if ( *phaseIt >= *currEmitPeriod) // phase is greater than period -> must emit +00811 { +00812 if (*currEmitPeriod != 0) +00813 { +00814 *phaseIt -= ::floorf(*phaseIt / *currEmitPeriod) * *currEmitPeriod; +00815 } +00816 const uint32 k = phaseIt - (_Phase.begin()); +00817 nbToGenerate = _GenNbScheme ? _GenNbScheme->get(_Owner, k) : _GenNb; +00818 if (nbToGenerate) +00819 { +00820 nbToGenerate = (sint32) (emitLOD * nbToGenerate); +00821 if (!nbToGenerate) nbToGenerate = 1; +00822 processEmit(k, nbToGenerate); +00823 } +00824 ++*numEmitIt; +00825 } +00826 } +00827 else +00828 { +00829 *numEmitIt = _MaxEmissionCount; +00830 } +00831 ++phaseIt; +00832 currEmitPeriod += currEmitPeriodPtrInc; +00833 ++ numEmitIt; +00834 } +00835 while (phaseIt != endPhaseIt); +00836 } +00837 else // there's an emission delay +00838 { +00839 do +00840 { +00841 if (*numEmitIt < maxEmissionCountLOD) +00842 { +00843 if (*phaseIt < _EmitDelay) +00844 { +00845 *phaseIt += ellapsedTime; +00846 if (*phaseIt < _EmitDelay) +00847 { +00848 ++phaseIt; +00849 currEmitPeriod += currEmitPeriodPtrInc; +00850 ++numEmitIt; +00851 currEmitPeriod += currEmitPeriodPtrInc; +00852 continue; +00853 } +00854 else +00855 { +00856 *phaseIt = (*phaseIt - _EmitDelay) * emitLOD + _EmitDelay; +00857 } +00858 } +00859 else +00860 { +00861 *phaseIt += ellapsedTimeLOD; +00862 } +00863 +00864 if ( *phaseIt >= *currEmitPeriod + _EmitDelay) // phase is greater than period -> must emit +00865 { +00866 if (*currEmitPeriod != 0) +00867 { +00868 *phaseIt -= ::floorf((*phaseIt - _EmitDelay) / *currEmitPeriod) * *currEmitPeriod; +00869 } +00870 const uint32 k = phaseIt - (_Phase.begin()); +00871 nbToGenerate = _GenNbScheme ? _GenNbScheme->get(_Owner, k) : _GenNb; +00872 if (nbToGenerate) +00873 { +00874 nbToGenerate = (sint32) (nbToGenerate * emitLOD); +00875 if (!nbToGenerate) nbToGenerate = 1; +00876 processEmit(k, nbToGenerate); +00877 } +00878 ++*numEmitIt; +00879 } +00880 } +00881 else +00882 { +00883 *numEmitIt = _MaxEmissionCount; +00884 } +00885 ++phaseIt; +00886 currEmitPeriod += currEmitPeriodPtrInc; +00887 ++numEmitIt; +00888 } +00889 while (phaseIt != endPhaseIt); +00890 } +00891 } +00892 +00893 leftToDo -= toProcess; +00894 } +00895 while (leftToDo); +00896 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
void NL3D::CPSEmitter::processRegularEmissionConsistent ( TAnimationTime ellapsedTime,
float realEllapsedTimeRatio,
float emitLOD,
float inverseEmitLOD
) [protected, inherited]
+
+ + + + + +
+ + + +
+========================================================================== +
+Regular emission processing, with low-framrate compensation +
+Test if 'make' filled our buffer. If this is not the case, we assume that values where precomputed, and that all null period have already been replaced by the threshold
+Must ensure phase is valid if period decrease over time
+Must ensure phase is valid if period decrease over time
+Must ensure phase is valid if period decrease over time
+Must ensure phase is valid if period decrease over time +
+Definition at line 1000 of file ps_emitter.cpp. +
+References NL3D::CPSEmitter::_EmitDelay, NL3D::CPSEmitter::_EmittedType, NL3D::CPSEmitter::_GenNb, NL3D::CPSEmitter::_GenNbScheme, NL3D::CPSEmitter::_MaxEmissionCount, NL3D::CPSEmitter::_NumEmission, NL3D::CPSEmitter::_Period, NL3D::CPSEmitter::_PeriodScheme, NL3D::CPSEmitter::_Phase, NL3D::CPSAttrib< T >::begin(), NL3D::CPSAttrib< float >::begin(), NL3D::EMIT_PERIOD_THRESHOLD, NL3D::EMITTER_BUFF_SIZE, NL3D::GenEmitterPositionsWithLOD(), NL3D::CPSAttribMaker< uint32 >::get(), NL3D::CPSAttribMaker< float >::getMaxValue(), NL3D::CPSAttribMaker< float >::getMinValue(), NL3D::CParticleSystemProcess::getOwner(), NL3D::CPSLocated::getSize(), NL3D::CParticleSystem::isEmitThresholdEnabled(), NL3D::CPSAttribMaker< float >::make(), min, nlassert, NL3D::CPSEmitter::processEmit(), NL3D::CPSEmitter::processEmitConsistent(), NL3D::replaceNullPeriodsByThreshold(), sint32, size, NL3D::TAnimationTime, uint, uint32, and uint8. +
+Referenced by NL3D::CPSEmitter::step(). +
+
01001 { +01003 +01004 nlassert(_Owner); +01005 nlassert(_Owner->getOwner()); +01006 // +01007 const bool emitThreshold = _Owner->getOwner()->isEmitThresholdEnabled(); +01008 // +01009 +01010 +01011 static std::vector<NLMISC::CVector> emitterPositions; +01012 // Positions for the emitter. They are computed by using a parametric trajectory or by using integration +01013 +01014 const uint size = _Owner->getSize(); +01015 uint leftToDo = size, toProcess; +01016 float emitPeriod[EMITTER_BUFF_SIZE]; +01017 const float *currEmitPeriod; +01018 uint currEmitPeriodPtrInc = _PeriodScheme ? 1 : 0; +01019 sint32 nbToGenerate; +01020 +01021 +01022 TPSAttribTime::iterator phaseIt = _Phase.begin(), endPhaseIt; +01023 TPSAttribUInt8::iterator numEmitIt = _NumEmission.begin(); +01024 +01025 float ellapsedTimeLOD = ellapsedTime * emitLOD; +01026 uint maxEmissionCountLOD = (uint8) (_MaxEmissionCount * emitLOD); +01027 maxEmissionCountLOD = std::max(1u, maxEmissionCountLOD); +01028 +01029 // we don't use an iterator here +01030 // because it could be invalidated if size change (a located could generate itself) +01031 do +01032 { +01033 toProcess = leftToDo < EMITTER_BUFF_SIZE ? leftToDo : EMITTER_BUFF_SIZE; +01034 +01035 +01036 if (_PeriodScheme) +01037 { +01038 currEmitPeriod = (float *) (_PeriodScheme->make(_Owner, size - leftToDo, emitPeriod, sizeof(float), toProcess, true)); +01039 if (emitThreshold) +01040 { +01041 +01045 if (currEmitPeriod == emitPeriod) +01046 { +01047 // if there possibility to have 0 in the scheme ? +01048 if (_PeriodScheme->getMinValue() <= 0.f && _PeriodScheme->getMaxValue() >= 0.f) +01049 { +01050 replaceNullPeriodsByThreshold(emitPeriod, toProcess); +01051 } +01052 } +01053 } +01054 } +01055 else +01056 { +01057 if (_Period != 0.f || !emitThreshold) +01058 { +01059 currEmitPeriod = &_Period; +01060 } +01061 else +01062 { +01063 currEmitPeriod = &EMIT_PERIOD_THRESHOLD; +01064 } +01065 } +01066 +01067 endPhaseIt = phaseIt + toProcess; +01068 +01069 if (_MaxEmissionCount == 0) // no emission count limit +01070 { +01072 if (_EmitDelay == 0.f) // no emission delay +01073 { +01074 do +01075 { +01076 *phaseIt += ellapsedTimeLOD; +01077 if ( *phaseIt >= *currEmitPeriod) // phase is greater than period -> must emit +01078 { +01079 if (*currEmitPeriod != 0) +01080 { +01083 *phaseIt = std::min(*phaseIt, *currEmitPeriod + ellapsedTimeLOD); +01084 // +01086 uint numEmissions = (uint) ::floorf(*phaseIt / *currEmitPeriod); +01087 *phaseIt -= *currEmitPeriod * numEmissions; +01088 +01089 uint emitterIndex = phaseIt - _Phase.begin(); +01090 nbToGenerate = _GenNbScheme ? _GenNbScheme->get(_Owner, emitterIndex) : _GenNb; +01091 if (nbToGenerate) +01092 { +01093 float deltaT = std::max(0.f, *phaseIt); +01094 +01096 numEmissions = GenEmitterPositionsWithLOD(_Owner, +01097 _EmittedType, +01098 emitterIndex, +01099 numEmissions, +01100 deltaT, +01101 *currEmitPeriod, +01102 inverseEmitLOD, +01103 emitterPositions +01104 ); +01105 +01107 nbToGenerate = (sint32) (emitLOD * nbToGenerate); +01108 if (!nbToGenerate) nbToGenerate = 1; +01109 uint k = numEmissions; +01110 float deltaTInc = *currEmitPeriod * inverseEmitLOD; +01111 do +01112 { +01113 --k; +01114 processEmitConsistent(emitterPositions[k], +01115 emitterIndex, +01116 nbToGenerate, +01117 deltaT, +01118 ellapsedTime, +01119 realEllapsedTimeRatio); +01120 deltaT += deltaTInc; +01121 } +01122 while (k); +01123 } +01124 } +01125 else +01126 { +01127 const uint32 emitterIndex = phaseIt - (_Phase.begin()); +01128 nbToGenerate = _GenNbScheme ? _GenNbScheme->get(_Owner, emitterIndex) : _GenNb; +01129 if (nbToGenerate) +01130 { +01131 nbToGenerate = (sint32) (emitLOD * nbToGenerate); +01132 if (!nbToGenerate) nbToGenerate = 1; +01133 processEmit(emitterIndex, nbToGenerate); +01134 } +01135 } +01136 } +01137 +01138 ++phaseIt; +01139 currEmitPeriod += currEmitPeriodPtrInc; +01140 } +01141 while (phaseIt != endPhaseIt); +01142 } +01143 else // thhere's an emission delay +01144 { +01145 do +01146 { +01147 if (*phaseIt < _EmitDelay) +01148 { +01149 *phaseIt += ellapsedTime; +01150 if (*phaseIt < _EmitDelay) +01151 { +01152 ++phaseIt; +01153 currEmitPeriod += currEmitPeriodPtrInc; +01154 continue; +01155 } +01156 else +01157 { +01158 *phaseIt = (*phaseIt - _EmitDelay) * emitLOD + _EmitDelay; +01159 } +01160 } +01161 else +01162 { +01163 *phaseIt += ellapsedTimeLOD; +01164 } +01165 +01166 if ( *phaseIt >= *currEmitPeriod + _EmitDelay) // phase is greater than period -> must emit +01167 { +01168 if (*currEmitPeriod != 0) +01169 { +01172 *phaseIt = std::min(*phaseIt, *currEmitPeriod + ellapsedTimeLOD + _EmitDelay); +01173 // +01174 uint numEmissions = (uint) ::floorf((*phaseIt - _EmitDelay) / *currEmitPeriod); +01175 *phaseIt -= *currEmitPeriod * numEmissions; +01176 float deltaT = std::max(*phaseIt - _EmitDelay, 0.f); +01177 //nlassert(deltaT >= 0.f); +01179 uint emitterIndex = phaseIt - _Phase.begin(); +01180 nbToGenerate = _GenNbScheme ? _GenNbScheme->get(_Owner, emitterIndex) : _GenNb; +01181 if (nbToGenerate) +01182 { +01183 +01185 numEmissions = GenEmitterPositionsWithLOD( _Owner, +01186 _EmittedType, +01187 emitterIndex, +01188 numEmissions, +01189 deltaT, +01190 *currEmitPeriod, +01191 inverseEmitLOD, +01192 emitterPositions +01193 ); +01194 +01195 nbToGenerate = (sint32) (emitLOD * nbToGenerate); +01196 if (!nbToGenerate) nbToGenerate = 1; +01197 uint k = numEmissions; +01198 float deltaTInc = *currEmitPeriod * inverseEmitLOD; +01199 do +01200 { +01201 --k; +01202 processEmitConsistent(emitterPositions[k], +01203 emitterIndex, +01204 nbToGenerate, +01205 deltaT, +01206 ellapsedTime, +01207 realEllapsedTimeRatio); +01208 deltaT += deltaTInc; +01209 } +01210 while (k); +01211 } +01212 } +01213 else +01214 { +01215 const uint32 emitterIndex = phaseIt - (_Phase.begin()); +01216 nbToGenerate = _GenNbScheme ? _GenNbScheme->get(_Owner, emitterIndex) : _GenNb; +01217 if (nbToGenerate) +01218 { +01219 nbToGenerate = (sint32) (emitLOD * nbToGenerate); +01220 if (!nbToGenerate) nbToGenerate = 1; +01221 processEmit(emitterIndex, nbToGenerate); +01222 } +01223 } +01224 } +01225 +01226 ++phaseIt; +01227 currEmitPeriod += currEmitPeriodPtrInc; +01228 } +01229 while (phaseIt != endPhaseIt); +01230 } +01231 } +01232 else // there's an emission count limit +01233 { +01235 if (_EmitDelay == 0.f) // no emission delay +01236 { +01237 do +01238 { +01239 if (*numEmitIt < maxEmissionCountLOD) +01240 { +01241 *phaseIt += ellapsedTimeLOD; +01242 if ( *phaseIt >= *currEmitPeriod) // phase is greater than period -> must emit +01243 { +01244 if (*currEmitPeriod != 0) +01245 { +01248 *phaseIt = std::min(*phaseIt, *currEmitPeriod + ellapsedTimeLOD); +01249 // +01250 uint numEmissions = (uint) ::floorf(*phaseIt / *currEmitPeriod); +01251 *numEmitIt += numEmissions; +01252 *phaseIt -= *currEmitPeriod * numEmissions; +01253 float deltaT = std::max(*phaseIt, 0.f); +01254 //nlassert(deltaT >= 0.f); +01255 uint emitterIndex = phaseIt - _Phase.begin(); +01256 if (*numEmitIt > _MaxEmissionCount) // make sure we don't go over the emission limit +01257 { +01258 numEmissions -= *numEmitIt - _MaxEmissionCount; +01259 *numEmitIt = _MaxEmissionCount; +01260 } +01261 nbToGenerate = _GenNbScheme ? _GenNbScheme->get(_Owner, emitterIndex) : _GenNb; +01262 if (nbToGenerate) +01263 { +01265 numEmissions = GenEmitterPositionsWithLOD(_Owner, +01266 _EmittedType, +01267 emitterIndex, +01268 numEmissions, +01269 deltaT, +01270 *currEmitPeriod, +01271 inverseEmitLOD, +01272 emitterPositions +01273 ); +01274 uint k = numEmissions; +01276 nbToGenerate = (sint32) (emitLOD * nbToGenerate); +01277 if (!nbToGenerate) nbToGenerate = 1; +01278 float deltaTInc = *currEmitPeriod * inverseEmitLOD; +01279 do +01280 { +01281 --k; +01282 processEmitConsistent(emitterPositions[k], +01283 emitterIndex, +01284 nbToGenerate, +01285 deltaT, +01286 ellapsedTime, +01287 realEllapsedTimeRatio); +01288 deltaT += deltaTInc; +01289 } +01290 while (k); +01291 } +01292 } +01293 else +01294 { +01295 const uint32 emitterIndex = phaseIt - _Phase.begin(); +01296 nbToGenerate = _GenNbScheme ? _GenNbScheme->get(_Owner, emitterIndex) : _GenNb; +01297 if (nbToGenerate) +01298 { +01299 nbToGenerate = (sint32) (emitLOD * nbToGenerate); +01300 if (!nbToGenerate) nbToGenerate = 1; +01301 processEmit(emitterIndex, nbToGenerate); +01302 ++*numEmitIt; +01303 } +01304 } +01305 } +01306 } +01307 else +01308 { +01309 *numEmitIt = _MaxEmissionCount; // if the lod change, must ensure that the +01310 } +01311 ++phaseIt; +01312 currEmitPeriod += currEmitPeriodPtrInc; +01313 ++ numEmitIt; +01314 } +01315 while (phaseIt != endPhaseIt); +01316 } +01317 else // there's an emission delay +01318 { +01319 do +01320 { +01321 if (*numEmitIt < maxEmissionCountLOD) +01322 { +01323 if (*phaseIt < _EmitDelay) +01324 { +01325 *phaseIt += ellapsedTime; +01326 if (*phaseIt < _EmitDelay) +01327 { +01328 ++phaseIt; +01329 currEmitPeriod += currEmitPeriodPtrInc; +01330 ++numEmitIt; +01331 continue; +01332 } +01333 else +01334 { +01335 *phaseIt = (*phaseIt - _EmitDelay) * emitLOD + _EmitDelay; +01336 } +01337 } +01338 else +01339 { +01340 *phaseIt += ellapsedTimeLOD; +01341 } +01342 // +01343 if ( *phaseIt >= *currEmitPeriod + _EmitDelay) // phase is greater than period -> must emit +01344 { +01345 if (*currEmitPeriod != 0) +01346 { +01349 *phaseIt = std::min(*phaseIt, *currEmitPeriod + ellapsedTimeLOD + _EmitDelay); +01350 // +01351 uint numEmissions = (uint) ::floorf((*phaseIt - _EmitDelay) / *currEmitPeriod); +01352 *numEmitIt += numEmissions; +01353 *phaseIt -= *currEmitPeriod * numEmissions; +01354 float deltaT = std::max(*phaseIt - _EmitDelay, 0.f); +01355 //nlassert(deltaT >= 0.f); +01356 uint emitterIndex = phaseIt - _Phase.begin(); +01357 if (*numEmitIt > _MaxEmissionCount) // make sure we don't go over the emission limit +01358 { +01359 numEmissions -= *numEmitIt - _MaxEmissionCount; +01360 *numEmitIt = _MaxEmissionCount; +01361 } +01362 nbToGenerate = _GenNbScheme ? _GenNbScheme->get(_Owner, emitterIndex) : _GenNb; +01363 if (nbToGenerate) +01364 { +01366 numEmissions = GenEmitterPositionsWithLOD( _Owner, +01367 _EmittedType, +01368 emitterIndex, +01369 numEmissions, +01370 deltaT, +01371 *currEmitPeriod, +01372 inverseEmitLOD, +01373 emitterPositions +01374 ); +01375 uint k = numEmissions; +01377 nbToGenerate = (sint32) (emitLOD * nbToGenerate); +01378 if (!nbToGenerate) nbToGenerate = 1; +01379 float deltaTInc = *currEmitPeriod * inverseEmitLOD; +01380 do +01381 { +01382 --k; +01383 processEmitConsistent(emitterPositions[k], +01384 emitterIndex, +01385 nbToGenerate, +01386 deltaT, +01387 ellapsedTime, +01388 realEllapsedTimeRatio); +01389 deltaT += deltaTInc; +01390 } +01391 while (k); +01392 } +01393 } +01394 else +01395 { +01396 const uint32 emitterIndex = phaseIt - (_Phase.begin()); +01397 nbToGenerate = _GenNbScheme ? _GenNbScheme->get(_Owner, emitterIndex) : _GenNb; +01398 if (nbToGenerate) +01399 { +01400 nbToGenerate = (sint32) (emitLOD * nbToGenerate); +01401 if (!nbToGenerate) nbToGenerate = 1; +01402 processEmit(emitterIndex, nbToGenerate); +01403 ++*numEmitIt; +01404 } +01405 } +01406 } +01407 } +01408 else +01409 { +01410 *numEmitIt = _MaxEmissionCount; // if the lod change, must ensure that the +01411 } +01412 ++phaseIt; +01413 currEmitPeriod += currEmitPeriodPtrInc; +01414 ++numEmitIt; +01415 } +01416 while (phaseIt != endPhaseIt); +01417 } +01418 } +01419 +01420 leftToDo -= toProcess; +01421 } +01422 while (leftToDo); +01423 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
void NL3D::CPSEmitter::processRegularEmissionConsistentWithNoLOD ( TAnimationTime ellapsedTime,
float realEllapsedTimeRatio
) [protected, inherited]
+
+ + + + + +
+ + + +
+========================================================================== +
+hmm some code factorisation would do no harm, but we want to keep tests outside the loops as much as possible...
+is there an emission delay ?
+compute the number of emissions
+compute the position of the emitter for the needed dates
+process each emission at the right pos at the right date
+compute the position of the emitter for the needed date
+process each emission at the right pos at the right date
+is there an emission delay ?
+compute the position of the emitter for the needed date
+process each emission at the right pos at the right date
+compute the position of the emitter for the needed date
+process each emission at the right pos at the right date +
+Test if 'make' filled our buffer. If this is not the case, we assume that values where precomputed, and that all null period have already been replaced by the threshold
+Must ensure phase is valid if period decrease over time
+Must ensure phase is valid if period decrease over time
+Must ensure phase is valid if period decrease over time
+Must ensure phase is valid if period decrease over time +
+Definition at line 1426 of file ps_emitter.cpp. +
+References NL3D::CPSEmitter::_EmitDelay, NL3D::CPSEmitter::_EmittedType, NL3D::CPSEmitter::_GenNb, NL3D::CPSEmitter::_GenNbScheme, NL3D::CPSEmitter::_MaxEmissionCount, NL3D::CPSEmitter::_NumEmission, NL3D::CPSEmitter::_Period, NL3D::CPSEmitter::_PeriodScheme, NL3D::CPSEmitter::_Phase, NL3D::CPSAttrib< T >::begin(), NL3D::CPSAttrib< float >::begin(), NL3D::EMIT_PERIOD_THRESHOLD, NL3D::EMITTER_BUFF_SIZE, NL3D::GenEmitterPositions(), NL3D::CPSAttribMaker< uint32 >::get(), NL3D::CPSAttribMaker< float >::getMaxValue(), NL3D::CPSAttribMaker< float >::getMinValue(), NL3D::CParticleSystemProcess::getOwner(), NL3D::CPSLocated::getSize(), NL3D::CParticleSystem::isEmitThresholdEnabled(), NL3D::CPSAttribMaker< float >::make(), min, nlassert, NL3D::CPSEmitter::processEmit(), NL3D::CPSEmitter::processEmitConsistent(), NL3D::replaceNullPeriodsByThreshold(), sint32, size, NL3D::TAnimationTime, uint, and uint32. +
+Referenced by NL3D::CPSEmitter::step(). +
+
01427 { +01429 +01430 nlassert(_Owner); +01431 nlassert(_Owner->getOwner()); +01432 // +01433 const bool emitThreshold = _Owner->getOwner()->isEmitThresholdEnabled(); +01434 // +01435 +01436 +01437 static std::vector<NLMISC::CVector> emitterPositions; +01438 // Positions for the emitter. They are computed by using a parametric trajectory or by using integration +01439 +01440 const uint size = _Owner->getSize(); +01441 uint leftToDo = size, toProcess; +01442 float emitPeriod[EMITTER_BUFF_SIZE]; +01443 const float *currEmitPeriod; +01444 uint currEmitPeriodPtrInc = _PeriodScheme ? 1 : 0; +01445 sint32 nbToGenerate; +01446 +01447 +01448 TPSAttribTime::iterator phaseIt = _Phase.begin(), endPhaseIt; +01449 TPSAttribUInt8::iterator numEmitIt = _NumEmission.begin(); +01450 +01451 // we don't use an iterator here +01452 // because it could be invalidated if size change (a located could generate itself) +01453 do +01454 { +01455 toProcess = leftToDo < EMITTER_BUFF_SIZE ? leftToDo : EMITTER_BUFF_SIZE; +01456 +01457 +01458 if (_PeriodScheme) +01459 { +01460 currEmitPeriod = (float *) (_PeriodScheme->make(_Owner, size - leftToDo, emitPeriod, sizeof(float), toProcess, true)); +01461 if (emitThreshold) +01462 { +01463 +01467 if (currEmitPeriod == emitPeriod) +01468 { +01469 // if there possibility to have 0 in the scheme ? +01470 if (_PeriodScheme->getMinValue() <= 0.f && _PeriodScheme->getMaxValue() >= 0.f) +01471 { +01472 replaceNullPeriodsByThreshold(emitPeriod, toProcess); +01473 } +01474 } +01475 } +01476 } +01477 else +01478 { +01479 if (_Period != 0.f || !emitThreshold) +01480 { +01481 currEmitPeriod = &_Period; +01482 } +01483 else +01484 { +01485 currEmitPeriod = &EMIT_PERIOD_THRESHOLD; +01486 } +01487 } +01488 +01489 endPhaseIt = phaseIt + toProcess; +01490 +01491 if (_MaxEmissionCount == 0) // no emission count limit +01492 { +01494 if (_EmitDelay == 0.f) // no emission delay +01495 { +01496 do +01497 { +01498 *phaseIt += ellapsedTime; +01499 if ( *phaseIt >= *currEmitPeriod) // phase is greater than period -> must emit +01500 { +01501 if (*currEmitPeriod != 0) +01502 { +01505 *phaseIt = std::min(*phaseIt, *currEmitPeriod + ellapsedTime); +01506 // +01508 uint numEmissions = (uint) ::floorf(*phaseIt / *currEmitPeriod); +01509 *phaseIt -= *currEmitPeriod * numEmissions; +01510 float deltaT = std::max(0.f, *phaseIt); +01511 //nlassert(deltaT >= 0.f); +01512 uint emitterIndex = phaseIt - _Phase.begin(); +01513 +01515 numEmissions = GenEmitterPositions(_Owner, +01516 _EmittedType, +01517 emitterIndex, +01518 numEmissions, +01519 deltaT, +01520 *currEmitPeriod, +01521 emitterPositions +01522 ); +01523 +01525 nbToGenerate = _GenNbScheme ? _GenNbScheme->get(_Owner, emitterIndex) : _GenNb; +01526 uint k = numEmissions; +01527 do +01528 { +01529 --k; +01530 processEmitConsistent(emitterPositions[k], +01531 emitterIndex, +01532 nbToGenerate, +01533 deltaT, +01534 ellapsedTime, +01535 realEllapsedTimeRatio); +01536 deltaT += *currEmitPeriod; +01537 } +01538 while (k); +01539 } +01540 else +01541 { +01542 const uint32 emitterIndex = phaseIt - (_Phase.begin()); +01543 nbToGenerate = _GenNbScheme ? _GenNbScheme->get(_Owner, emitterIndex) : _GenNb; +01544 processEmit(emitterIndex, nbToGenerate); +01545 } +01546 } +01547 +01548 ++phaseIt; +01549 currEmitPeriod += currEmitPeriodPtrInc; +01550 } +01551 while (phaseIt != endPhaseIt); +01552 } +01553 else // thhere's an emission delay +01554 { +01555 do +01556 { +01557 *phaseIt += ellapsedTime; +01558 if ( *phaseIt >= *currEmitPeriod + _EmitDelay) // phase is greater than period -> must emit +01559 { +01560 if (*currEmitPeriod != 0) +01561 { +01564 *phaseIt = std::min(*phaseIt, *currEmitPeriod + ellapsedTime + _EmitDelay); +01565 // +01566 uint numEmissions = (uint) ::floorf((*phaseIt - _EmitDelay) / *currEmitPeriod); +01567 *phaseIt -= *currEmitPeriod * numEmissions; +01568 float deltaT = std::max(*phaseIt - _EmitDelay, 0.f); +01569 //nlassert(deltaT >= 0.f); +01570 +01571 uint emitterIndex = phaseIt - _Phase.begin(); +01573 numEmissions = GenEmitterPositions(_Owner, +01574 _EmittedType, +01575 emitterIndex, +01576 numEmissions, +01577 deltaT, +01578 *currEmitPeriod, +01579 emitterPositions +01580 ); +01582 nbToGenerate = _GenNbScheme ? _GenNbScheme->get(_Owner, emitterIndex) : _GenNb; +01583 uint k = numEmissions; +01584 do +01585 { +01586 --k; +01587 processEmitConsistent(emitterPositions[k], +01588 emitterIndex, +01589 nbToGenerate, +01590 deltaT, +01591 ellapsedTime, +01592 realEllapsedTimeRatio); +01593 deltaT += *currEmitPeriod; +01594 } +01595 while (k); +01596 } +01597 else +01598 { +01599 const uint32 emitterIndex = phaseIt - (_Phase.begin()); +01600 nbToGenerate = _GenNbScheme ? _GenNbScheme->get(_Owner, emitterIndex) : _GenNb; +01601 processEmit(emitterIndex, nbToGenerate); +01602 } +01603 } +01604 +01605 ++phaseIt; +01606 currEmitPeriod += currEmitPeriodPtrInc; +01607 } +01608 while (phaseIt != endPhaseIt); +01609 } +01610 } +01611 else // there's an emission count limit +01612 { +01614 if (_EmitDelay == 0.f) // no emission delay +01615 { +01616 do +01617 { +01618 if (*numEmitIt < _MaxEmissionCount) +01619 { +01620 *phaseIt += ellapsedTime; +01621 if ( *phaseIt >= *currEmitPeriod) // phase is greater than period -> must emit +01622 { +01623 if (*currEmitPeriod != 0) +01624 { +01627 *phaseIt = std::min(*phaseIt, *currEmitPeriod + ellapsedTime); +01628 // +01629 uint numEmissions = (uint) ::floorf(*phaseIt / *currEmitPeriod); +01630 *numEmitIt += numEmissions; +01631 *phaseIt -= *currEmitPeriod * numEmissions; +01632 float deltaT = std::max(*phaseIt, 0.f); +01633 //nlassert(deltaT >= 0.f); +01634 uint emitterIndex = phaseIt - _Phase.begin(); +01635 if (*numEmitIt > _MaxEmissionCount) // make sure we don't go over the emission limit +01636 { +01637 numEmissions -= *numEmitIt - _MaxEmissionCount; +01638 *numEmitIt = _MaxEmissionCount; +01639 } +01641 numEmissions = GenEmitterPositions(_Owner, +01642 _EmittedType, +01643 emitterIndex, +01644 numEmissions, +01645 deltaT, +01646 *currEmitPeriod, +01647 emitterPositions +01648 ); +01649 uint k = numEmissions; +01651 nbToGenerate = _GenNbScheme ? _GenNbScheme->get(_Owner, emitterIndex) : _GenNb; +01652 do +01653 { +01654 --k; +01655 processEmitConsistent(emitterPositions[k], +01656 emitterIndex, +01657 nbToGenerate, +01658 deltaT, +01659 ellapsedTime, +01660 realEllapsedTimeRatio); +01661 deltaT += *currEmitPeriod; +01662 } +01663 while (k); +01664 } +01665 else +01666 { +01667 const uint32 emitterIndex = phaseIt - _Phase.begin(); +01668 nbToGenerate = _GenNbScheme ? _GenNbScheme->get(_Owner, emitterIndex) : _GenNb; +01669 processEmit(emitterIndex, nbToGenerate); +01670 ++*numEmitIt; +01671 } +01672 } +01673 } +01674 ++phaseIt; +01675 currEmitPeriod += currEmitPeriodPtrInc; +01676 ++ numEmitIt; +01677 } +01678 while (phaseIt != endPhaseIt); +01679 } +01680 else // there's an emission delay +01681 { +01682 do +01683 { +01684 if (*numEmitIt < _MaxEmissionCount) +01685 { +01686 *phaseIt += ellapsedTime; +01687 if ( *phaseIt >= *currEmitPeriod + _EmitDelay) // phase is greater than period -> must emit +01688 { +01689 if (*currEmitPeriod != 0) +01690 { +01693 *phaseIt = std::min(*phaseIt, *currEmitPeriod + ellapsedTime + _EmitDelay); +01694 // +01695 uint numEmissions = (uint) ::floorf((*phaseIt - _EmitDelay) / *currEmitPeriod); +01696 *numEmitIt += numEmissions; +01697 *phaseIt -= *currEmitPeriod * numEmissions; +01698 float deltaT = std::max(*phaseIt - _EmitDelay, 0.f); +01699 //nlassert(deltaT >= 0.f); +01700 uint emitterIndex = phaseIt - _Phase.begin(); +01701 if (*numEmitIt > _MaxEmissionCount) // make sure we don't go over the emission limit +01702 { +01703 numEmissions -= *numEmitIt - _MaxEmissionCount; +01704 *numEmitIt = _MaxEmissionCount; +01705 } +01707 numEmissions = GenEmitterPositions(_Owner, +01708 _EmittedType, +01709 emitterIndex, +01710 numEmissions, +01711 deltaT, +01712 *currEmitPeriod, +01713 emitterPositions +01714 ); +01715 uint k = numEmissions; +01717 nbToGenerate = _GenNbScheme ? _GenNbScheme->get(_Owner, emitterIndex) : _GenNb; +01718 do +01719 { +01720 --k; +01721 processEmitConsistent(emitterPositions[k], +01722 emitterIndex, +01723 nbToGenerate, +01724 deltaT, +01725 ellapsedTime, +01726 realEllapsedTimeRatio); +01727 deltaT += *currEmitPeriod; +01728 } +01729 while (k); +01730 } +01731 else +01732 { +01733 const uint32 emitterIndex = phaseIt - (_Phase.begin()); +01734 nbToGenerate = _GenNbScheme ? _GenNbScheme->get(_Owner, emitterIndex) : _GenNb; +01735 processEmit(emitterIndex, nbToGenerate); +01736 ++*numEmitIt; +01737 } +01738 } +01739 } +01740 ++phaseIt; +01741 currEmitPeriod += currEmitPeriodPtrInc; +01742 ++numEmitIt; +01743 } +01744 while (phaseIt != endPhaseIt); +01745 } +01746 } +01747 +01748 leftToDo -= toProcess; +01749 } +01750 while (leftToDo); +01751 } +

+

+ + + + +
+ + + + + + + + + + +
void NL3D::CPSEmitter::processRegularEmissionWithNoLOD ( TAnimationTime ellapsedTime ) [protected, inherited]
+
+ + + + + +
+ + + +
+========================================================================== +
+is there an emission delay ?
+is there an emission delay ? +
+Test if 'make' filled our buffer. If this is not the case, we assume that values where precomputed, and that all null period have already been replaced by the threshold +
+Definition at line 500 of file ps_emitter.cpp. +
+References NL3D::CPSEmitter::_EmitDelay, NL3D::CPSEmitter::_GenNb, NL3D::CPSEmitter::_GenNbScheme, NL3D::CPSEmitter::_MaxEmissionCount, NL3D::CPSEmitter::_NumEmission, NL3D::CPSEmitter::_Period, NL3D::CPSEmitter::_PeriodScheme, NL3D::CPSEmitter::_Phase, NL3D::CPSAttrib< T >::begin(), NL3D::CPSAttrib< float >::begin(), NL3D::EMIT_PERIOD_THRESHOLD, NL3D::EMITTER_BUFF_SIZE, NL3D::CPSAttribMaker< uint32 >::get(), NL3D::CPSAttribMaker< float >::getMaxValue(), NL3D::CPSAttribMaker< float >::getMinValue(), NL3D::CParticleSystemProcess::getOwner(), NL3D::CPSLocated::getSize(), NL3D::CParticleSystem::isEmitThresholdEnabled(), NL3D::CPSAttribMaker< float >::make(), nlassert, NL3D::CPSEmitter::processEmit(), NL3D::replaceNullPeriodsByThreshold(), sint32, size, NL3D::TAnimationTime, uint, and uint32. +
+Referenced by NL3D::CPSEmitter::step(). +
+
00501 { +00502 nlassert(_Owner); +00503 nlassert(_Owner->getOwner()); +00504 // +00505 const bool emitThreshold = _Owner->getOwner()->isEmitThresholdEnabled(); +00506 // +00507 const uint size = _Owner->getSize(); +00508 uint leftToDo = size, toProcess; +00509 float emitPeriod[EMITTER_BUFF_SIZE]; +00510 const float *currEmitPeriod; +00511 uint currEmitPeriodPtrInc = _PeriodScheme ? 1 : 0; +00512 sint32 nbToGenerate; +00513 +00514 TPSAttribTime::iterator phaseIt = _Phase.begin(), endPhaseIt; +00515 TPSAttribUInt8::iterator numEmitIt = _NumEmission.begin(); +00516 +00517 // we don't use an iterator here +00518 // because it could be invalidated if size change (a located could generate itself) +00519 do +00520 { +00521 toProcess = leftToDo < EMITTER_BUFF_SIZE ? leftToDo : EMITTER_BUFF_SIZE; +00522 +00523 +00524 if (_PeriodScheme) +00525 { +00526 currEmitPeriod = (float *) (_PeriodScheme->make(_Owner, size - leftToDo, emitPeriod, sizeof(float), toProcess, true)); +00527 if (emitThreshold) +00528 { +00529 +00533 if (currEmitPeriod == emitPeriod) +00534 { +00535 // if there possibility to have 0 in the scheme ? +00536 if (_PeriodScheme->getMinValue() <= 0.f && _PeriodScheme->getMaxValue() >= 0.f) +00537 { +00538 replaceNullPeriodsByThreshold(emitPeriod, toProcess); +00539 } +00540 } +00541 } +00542 } +00543 else +00544 { +00545 if (_Period != 0.f || !emitThreshold) +00546 { +00547 currEmitPeriod = &_Period; +00548 } +00549 else +00550 { +00551 currEmitPeriod = &EMIT_PERIOD_THRESHOLD; +00552 } +00553 } +00554 +00555 endPhaseIt = phaseIt + toProcess; +00556 +00557 if (_MaxEmissionCount == 0) // no emission count limit +00558 { +00560 if (_EmitDelay == 0.f) // no emission delay +00561 { +00562 do +00563 { +00564 *phaseIt += ellapsedTime; +00565 if ( *phaseIt >= *currEmitPeriod) // phase is greater than period -> must emit +00566 { +00567 if (*currEmitPeriod != 0) +00568 { +00569 *phaseIt -= ::floorf(*phaseIt / *currEmitPeriod) * *currEmitPeriod; +00570 } +00571 const uint32 k = phaseIt - (_Phase.begin()); +00572 nbToGenerate = _GenNbScheme ? _GenNbScheme->get(_Owner, k) : _GenNb; +00573 processEmit(k, nbToGenerate); +00574 } +00575 +00576 ++phaseIt; +00577 currEmitPeriod += currEmitPeriodPtrInc; +00578 } +00579 while (phaseIt != endPhaseIt); +00580 } +00581 else // there's an emission delay +00582 { +00583 do +00584 { +00585 *phaseIt += ellapsedTime; +00586 if ( *phaseIt >= *currEmitPeriod + _EmitDelay) // phase is greater than period -> must emit +00587 { +00588 if (*currEmitPeriod != 0) +00589 { +00590 *phaseIt -= ::floorf((*phaseIt - _EmitDelay) / *currEmitPeriod) * *currEmitPeriod; +00591 } +00592 const uint32 k = phaseIt - (_Phase.begin()); +00593 nbToGenerate = _GenNbScheme ? _GenNbScheme->get(_Owner, k) : _GenNb; +00594 processEmit(k, nbToGenerate); +00595 } +00596 +00597 ++phaseIt; +00598 currEmitPeriod += currEmitPeriodPtrInc; +00599 } +00600 while (phaseIt != endPhaseIt); +00601 } +00602 } +00603 else // there's an emission count limit +00604 { +00606 if (_EmitDelay == 0.f) // no emission delay +00607 { +00608 do +00609 { +00610 if (*numEmitIt < _MaxEmissionCount) +00611 { +00612 *phaseIt += ellapsedTime; +00613 if ( *phaseIt >= *currEmitPeriod) // phase is greater than period -> must emit +00614 { +00615 if (*currEmitPeriod != 0) +00616 { +00617 *phaseIt -= ::floorf(*phaseIt / *currEmitPeriod) * *currEmitPeriod; +00618 } +00619 const uint32 k = phaseIt - (_Phase.begin()); +00620 nbToGenerate = _GenNbScheme ? _GenNbScheme->get(_Owner, k) : _GenNb; +00621 processEmit(k, nbToGenerate); +00622 ++*numEmitIt; +00623 } +00624 } +00625 ++phaseIt; +00626 currEmitPeriod += currEmitPeriodPtrInc; +00627 ++ numEmitIt; +00628 } +00629 while (phaseIt != endPhaseIt); +00630 } +00631 else // there's an emission delay +00632 { +00633 do +00634 { +00635 if (*numEmitIt < _MaxEmissionCount) +00636 { +00637 *phaseIt += ellapsedTime; +00638 if ( *phaseIt >= *currEmitPeriod + _EmitDelay) // phase is greater than period -> must emit +00639 { +00640 if (*currEmitPeriod != 0) +00641 { +00642 *phaseIt -= ::floorf((*phaseIt - _EmitDelay) / *currEmitPeriod) * *currEmitPeriod; +00643 } +00644 const uint32 k = phaseIt - (_Phase.begin()); +00645 nbToGenerate = _GenNbScheme ? _GenNbScheme->get(_Owner, k) : _GenNb; +00646 processEmit(k, nbToGenerate); +00647 ++*numEmitIt; +00648 } +00649 } +00650 ++phaseIt; +00651 currEmitPeriod += currEmitPeriodPtrInc; +00652 ++numEmitIt; +00653 } +00654 while (phaseIt != endPhaseIt); +00655 } +00656 } +00657 +00658 leftToDo -= toProcess; +00659 } +00660 while (leftToDo); +00661 } +

+

+ + + + +
+ + + + + + + + + +
void NL3D::CPSEmitter::releaseAllRef ( ) [virtual, inherited]
+
+ + + + + +
+ + + +
+Release any reference this obj may have to other process of the system For example, this is used when detaching a located bindable from a system. +
+Reimplemented from NL3D::CPSLocatedBindable. +
+Definition at line 104 of file ps_emitter.cpp. +
+References NL3D::CPSEmitter::setEmittedType(). +
+
00105 { +00106 setEmittedType(NULL); +00107 } +

+

+ + + + +
+ + + + + + + + + + +
void NL3D::CPSEmitter::releaseRefTo ( const CParticleSystemProcess * other ) [virtual, inherited]
+
+ + + + + +
+ + + +
+========================================================================== +
+Release any reference this obj may have on the given process. For example, this is used when detaching a located bindable from a system. +
+Reimplemented from NL3D::CPSLocatedBindable. +
+Definition at line 96 of file ps_emitter.cpp. +
+References NL3D::CPSEmitter::_EmittedType, and NL3D::CPSEmitter::setEmittedType(). +
+
00097 { +00098 if (_EmittedType == other) +00099 { +00100 setEmittedType(NULL); +00101 } +00102 } +

+

+ + + + +
+ + + + + + + + + + +
void NL3D::CPSEmitterDirectionnal::resize ( uint32 capacity ) [protected, virtual]
+
+ + + + + +
+ + + +
+========================================================================== +
+ +
+Reimplemented from NL3D::CPSEmitter. +
+Definition at line 2277 of file ps_emitter.cpp. +
+References nlassert, NL3D::CPSModulatedEmitter::resizeEmitteeSpeed(), and uint32. +
+
02278 { +02279 nlassert(capacity < (1 << 16)); +02280 CPSEmitter::resize(capacity); +02281 resizeEmitteeSpeed(capacity); +02282 } +

+

+ + + + +
+ + + + + + + + + + +
void NL3D::CPSModulatedEmitter::resizeEmitteeSpeed ( uint32 capacity ) [inline, protected, inherited]
+
+ + + + + +
+ + + +
+ +
+Definition at line 434 of file ps_emitter.h. +
+References NL3D::CPSModulatedEmitter::_EmitteeSpeedScheme, NL3D::CPSModulatedEmitter::getModulatedEmitterOwner(), NL3D::CPSAttribMaker< float >::hasMemory(), NL3D::CPSAttribMaker< float >::resize(), and uint32. +
+Referenced by NL3D::CPSSphericalEmitter::resize(), NL3D::CPSEmitterRectangle::resize(), resize(), and NL3D::CPSEmitterOmni::resize(). +
+
00435 { +00436 if (_EmitteeSpeedScheme && _EmitteeSpeedScheme->hasMemory()) _EmitteeSpeedScheme->resize(capacity, getModulatedEmitterOwner()->getSize()); +00437 } +

+

+ + + + +
+ + + + + + + + + + +
void NL3D::CPSEmitterDirectionnal::serial ( NLMISC::IStream & f ) throw (NLMISC::EStream) [virtual]
+
+ + + + + +
+ + + +
+========================================================================== +
+ +
+Reimplemented from NL3D::CPSEmitter. +
+Reimplemented in NL3D::CPSRadialEmitter, and NL3D::CPSEmitterConic. +
+Definition at line 2285 of file ps_emitter.cpp. +
+
02286 { +02287 f.serialVersion(1); +02288 CPSEmitter::serial(f); +02289 CPSModulatedEmitter::serialEmitteeSpeedScheme(f); +02290 f.serial(_Dir); +02291 } +

+

+ + + + +
+ + + + + + + + + + +
void NL3D::CPSModulatedEmitter::serialEmitteeSpeedScheme ( NLMISC::IStream & f ) throw (NLMISC::EStream) [inherited]
+
+ + + + + +
+ + + +
+serialization +
+ +
+Definition at line 2180 of file ps_emitter.cpp. +
+
02181 { +02182 bool useScheme; +02183 if (!f.isReading()) +02184 { +02185 useScheme = useEmitteeSpeedScheme(); +02186 } +02187 f.serial(useScheme); +02188 if (useScheme) +02189 { +02190 f.serialPolyPtr(_EmitteeSpeedScheme); +02191 } +02192 else +02193 { +02194 f.serial(_EmitteeSpeed); +02195 } +02196 } +

+

+ + + + +
+ + + + + + + + + + +
void NL3D::CPSLocatedBindable::setActive ( bool active ) [inline, inherited]
+
+ + + + + +
+ + + +
+Activate / Deactivate this object. When not active, the owning system won't try to call the 'step' method. +
+ +
+Definition at line 843 of file ps_located.h. +
+References NL3D::CPSLocatedBindable::_Active. +
+Referenced by NL3D::CParticleSystem::activateEmitters(), and NL3D::CParticleSystemInstanceUser::setActive(). +
+
00843 { _Active = active; } +

+

+ + + + +
+ + + + + + + + + + +
void NL3D::CPSEmitter::setBypassAutoLOD ( bool bypass ) [inline, inherited]
+
+ + + + + +
+ + + +
+ +
+Definition at line 251 of file ps_emitter.h. +
+References NL3D::CPSEmitter::_BypassAutoLOD. +
+
00251 { _BypassAutoLOD = bypass; } +

+

+ + + + +
+ + + + + + + + + + +
void NL3D::CPSEmitter::setBypassEmitOnDeath ( bool bypass ) [inline, static, inherited]
+
+ + + + + +
+ + + +
+For edition only : avoid that a call to CPSLocated::deleteElement() causes emitters flagged with 'emitOnDeath' to emit +
+Definition at line 256 of file ps_emitter.h. +
+References NL3D::CPSEmitter::_BypassEmitOnDeath. +
+
00256 { _BypassEmitOnDeath = bypass; } +

+

+ + + + +
+ + + + + + + + + + +
void NL3D::CPSEmitterDirectionnal::setDir ( const NLMISC::CVector & v ) [inline, virtual]
+
+ + + + + +
+ + + +
+ +
+Implements NL3D::CPSDirection. +
+Reimplemented in NL3D::CPSEmitterConic. +
+Definition at line 470 of file ps_emitter.h. +
+References _Dir, and v. +
+
00470 { _Dir = v; } +

+

+ + + + +
+ + + + + + + + + + +
bool NL3D::CPSEmitter::setEmissionType ( TEmissionType freqType ) [inherited]
+
+ + + + + +
+ + + +
+========================================================================== +
+Set the frequency type. Please note that if the type is externEmit, this located need to have been attached to the system (the system is holding the ID-Located map)
Returns:
true if the operation could be performed. It can fail when this cause the system the system to last forever, which is incompatible with the 'BypassMaxNumIntegrationSteps' in CParticleSystem
+ +
+Definition at line 326 of file ps_emitter.cpp. +
+References NL3D::CPSEmitter::_EmissionType, NL3D::CParticleSystem::getBypassMaxNumIntegrationSteps(), NL3D::CParticleSystemProcess::getOwner(), nlassert, nlwarning, NL3D::CParticleSystem::systemDurationChanged(), NL3D::CPSEmitter::TEmissionType, NL3D::CPSEmitter::testEmitForever(), and NLMISC::toString(). +
+
00327 { +00328 if (_Owner && _Owner->getOwner()) +00329 { +00330 CParticleSystem *ps = _Owner->getOwner(); +00331 if (ps->getBypassMaxNumIntegrationSteps()) +00332 { +00333 if (!_Owner) +00334 { +00335 nlwarning("<CPSEmitter::setEmissionType> The emitter should be inserted in a CPSLocated instance"); +00336 nlassert(0); +00337 } +00338 // check if the new value is valid +00339 TEmissionType oldType = _EmissionType; +00340 _EmissionType = freqType; +00341 if (testEmitForever() == true) +00342 { +00343 _EmissionType = oldType; +00344 std::string mess = "<CPSEmitter::setEmissionType> can't set emission type to '" + +00345 NLMISC::toString(freqType) + +00346 "' with the current configuration : the system has been flagged with \ +00347 'BypassMaxNumIntegrationSteps', and should have a finite duration. \ +00348 The flag is not set"; +00349 nlwarning(mess.c_str()); +00350 return false; +00351 +00352 } +00353 } +00354 ps->systemDurationChanged(); +00355 } +00356 _EmissionType = freqType; +00357 return true; +00358 } +

+

+ + + + +
+ + + + + + + + + + +
void NL3D::CPSEmitter::setEmitDelay ( float delay ) [inherited]
+
+ + + + + +
+ + + +
+========================================================================== +
+ +
+Definition at line 2080 of file ps_emitter.cpp. +
+References NL3D::CPSEmitter::_EmitDelay, NL3D::CParticleSystemProcess::getOwner(), and NL3D::CParticleSystem::systemDurationChanged(). +
+
02081 { +02082 _EmitDelay = delay; +02083 if (_Owner && _Owner->getOwner()) +02084 { +02085 _Owner->getOwner()->systemDurationChanged(); +02086 } +02087 } +

+

+ + + + +
+ + + + + + + + + + +
bool NL3D::CPSEmitter::setEmittedType ( CPSLocated * et ) [inherited]
+
+ + + + + +
+ + + +
+========================================================================== +
+Set the type of located to be emitted. The default is NULL which mean that no emission will occur
Returns:
true if the operation could be performed. It can fail when this cause the system the system to last forever, which is incompatible with the 'BypassMaxNumIntegrationSteps' in CParticleSystem
+ +
+Definition at line 361 of file ps_emitter.cpp. +
+References NL3D::CPSEmitter::_EmittedType, NL3D::CParticleSystem::canFinish(), NL3D::CParticleSystem::getBypassMaxNumIntegrationSteps(), NL3D::CParticleSystemProcess::getOwner(), nlwarning, NL3D::CPSLocated::registerDtorObserver(), NL3D::CParticleSystem::systemDurationChanged(), and NL3D::CPSLocated::unregisterDtorObserver(). +
+Referenced by NL3D::CPSEmitter::notifyTargetRemoved(), NL3D::CPSEmitter::releaseAllRef(), and NL3D::CPSEmitter::releaseRefTo(). +
+
00362 { +00363 if (_EmittedType) +00364 { +00365 _EmittedType->unregisterDtorObserver(this); +00366 } +00367 if (et) +00368 { +00369 et->registerDtorObserver(this); +00370 } +00371 CPSLocated *oldType = _EmittedType; +00372 _EmittedType = et; +00373 if (_Owner && _Owner->getOwner()) +00374 { +00375 CParticleSystem *ps = _Owner->getOwner(); +00376 if (_EmittedType) +00377 { +00378 if (ps->getBypassMaxNumIntegrationSteps()) +00379 { +00380 if (!ps->canFinish()) +00381 { +00382 setEmittedType(oldType); +00383 nlwarning("<CPSLocated::setEmittedType> Can't set new emitted type : this causes the system to last forever, and it has been flagged with 'BypassMaxNumIntegrationSteps'. New emitted type is not set"); +00384 return false; +00385 } +00386 } +00387 } +00388 ps->systemDurationChanged(); +00389 } +00390 return true; +00391 } +

+

+ + + + +
+ + + + + + + + + + +
void NL3D::CPSModulatedEmitter::setEmitteeSpeed ( float speed ) [inline, inherited]
+
+ + + + + +
+ + + +
+set a constant speed modulation for emittee +
+ +
+Definition at line 396 of file ps_emitter.h. +
+References NL3D::CPSModulatedEmitter::_EmitteeSpeed, and NL3D::CPSModulatedEmitter::_EmitteeSpeedScheme. +
+
00397 { +00398 delete _EmitteeSpeedScheme; +00399 _EmitteeSpeedScheme = NULL; +00400 _EmitteeSpeed = speed; +00401 +00402 } +

+

+ + + + +
+ + + + + + + + + + +
void NL3D::CPSModulatedEmitter::setEmitteeSpeedScheme ( CPSAttribMaker< float > * scheme ) [inline, inherited]
+
+ + + + + +
+ + + +
+Set a new scheme for speed modulation. It must have been allocated with new, and will be destriyed by this object +
+Definition at line 387 of file ps_emitter.h. +
+References NL3D::CPSModulatedEmitter::_EmitteeSpeedScheme, NL3D::CPSModulatedEmitter::getModulatedEmitterOwner(), and NL3D::CPSAttribMaker< T >::resize(). +
+
00388 { +00389 delete _EmitteeSpeedScheme; +00390 _EmitteeSpeedScheme = scheme; +00391 if (getModulatedEmitterOwner() && scheme->hasMemory()) +00392 scheme->resize(getModulatedEmitterOwner()->getMaxSize(), getModulatedEmitterOwner()->getSize()); +00393 } +

+

+ + + + +
+ + + + + + + + + + +
void NL3D::CPSLocatedBindable::setExternID ( uint32 id ) [inherited]
+
+ + + + + +
+ + + +
+*************************************************************************************** +
+set the extern ID of this located bindable. 0 means no extern access. The map of ID-locatedBindable. Is in th particle system, so this located bindable must have been attached to a particle system, otherwise an assertion is raised +
+Definition at line 2149 of file ps_located.cpp. +
+References NL3D::CPSLocatedBindable::_ExternID, NL3D::CParticleSystemProcess::getOwner(), NL3D::CParticleSystem::registerLocatedBindableExternID(), uint32, and NL3D::CParticleSystem::unregisterLocatedBindableExternID(). +
+
02150 { +02151 if (id == _ExternID) return; +02152 CParticleSystem *ps = NULL; +02153 if (_Owner && _Owner->getOwner()) +02154 { +02155 ps = _Owner->getOwner(); +02156 } +02157 if (ps) +02158 { +02159 ps->unregisterLocatedBindableExternID(this); +02160 _ExternID = 0; +02161 } +02162 if (id != 0) +02163 { +02164 if (ps) ps->registerLocatedBindableExternID(id, this); +02165 _ExternID = id; +02166 } +02167 } +

+

+ + + + +
+ + + + + + + + + + +
void NL3D::CPSEmitter::setGenNb ( uint32 GenNb ) [inherited]
+
+ + + + + +
+ + + +
+========================================================================== +
+Set a constant number of particle to be generated at once any previous scheme is discarded +
+Definition at line 428 of file ps_emitter.cpp. +
+References NL3D::CPSEmitter::_GenNb, NL3D::CPSEmitter::_GenNbScheme, and uint32. +
+
00429 { +00430 if (_GenNbScheme) +00431 { +00432 delete _GenNbScheme; +00433 _GenNbScheme = NULL; +00434 } +00435 _GenNb = genNb; +00436 } +

+

+ + + + +
+ + + + + + + + + + +
void NL3D::CPSEmitter::setGenNbScheme ( CPSAttribMaker< uint32 > * scheme ) [inherited]
+
+ + + + + +
+ + + +
+========================================================================== +
+ +
+Definition at line 439 of file ps_emitter.cpp. +
+References NL3D::CPSEmitter::_GenNbScheme, NL3D::CPSLocated::getMaxSize(), NL3D::CPSLocated::getSize(), and NL3D::CPSAttribMaker< T >::resize(). +
+
00440 { +00441 delete _GenNbScheme; +00442 _GenNbScheme = scheme; +00443 if (_Owner && scheme->hasMemory()) scheme->resize(_Owner->getMaxSize(), _Owner->getSize()); +00444 } +

+

+ + + + +
+ + + + + + + + + + +
void NL3D::CPSLocatedBindable::setLOD ( TPSLod lod ) [inline, inherited]
+
+ + + + + +
+ + + +
+set the LODs that apply to that object (warning : it is based on the position of the system, and don't act on a per instance basis ...) To have per instance precision, you must use an attribute maker that has LOD as its input +
+Definition at line 952 of file ps_located.h. +
+References NL3D::CPSLocatedBindable::_LOD. +
+
00952 { _LOD = lod; } +

+

+ + + + +
+ + + + + + + + + + +
bool NL3D::CPSEmitter::setMaxEmissionCount ( uint8 count ) [inherited]
+
+ + + + + +
+ + + +
+========================================================================== +
+Set a max. number of particle emission (0 means no limit and is the default). Applies with regular emitter only. NB : the emitter should be inserted in a system for this call to work
Returns:
true if the operation could be performed. It can fail when this cause the system the system to last forever, which is incompatible with the 'BypassMaxNumIntegrationSteps' in CParticleSystem
+ +
+Definition at line 2090 of file ps_emitter.cpp. +
+References NL3D::CPSEmitter::_MaxEmissionCount, count, NL3D::CParticleSystem::getBypassMaxNumIntegrationSteps(), NL3D::CParticleSystemProcess::getOwner(), nlassert, nlwarning, NL3D::CParticleSystem::systemDurationChanged(), NL3D::CPSEmitter::testEmitForever(), uint8, and NL3D::CPSEmitter::updateMaxCountVect(). +
+
02091 { +02092 if (count == _MaxEmissionCount) return true; +02093 nlassert(_Owner && _Owner->getOwner()); +02094 CParticleSystem *ps = _Owner->getOwner(); +02095 if (ps->getBypassMaxNumIntegrationSteps()) +02096 { +02097 uint8 oldEmissiontCount = _MaxEmissionCount; +02098 // should check that the new value is valid +02099 _MaxEmissionCount = count; +02100 if (testEmitForever()) +02101 { +02102 _MaxEmissionCount = oldEmissiontCount; +02103 nlwarning("<CPSEmitter::setMaxEmissionCount> can't set max emission count to %d \ +02104 with the current configuration : the system has been flagged with \ +02105 'BypassMaxNumIntegrationSteps', and should have a finite duration. \ +02106 The new value is not set", (int) count); +02107 return false; +02108 } +02109 } +02110 ps->systemDurationChanged(); +02111 _MaxEmissionCount = count; +02112 updateMaxCountVect(); +02113 return true; +02114 } +

+

+ + + + +
+ + + + + + + + + + +
void NL3D::CPSLocatedBindable::setName ( const std::string & name ) [inline, inherited]
+
+ + + + + +
+ + + +
+set the located bindable name (edition purpose) +
+ +
+Definition at line 946 of file ps_located.h. +
+
00946 { _Name = name; } +

+

+ + + + +
+ + + + + + + + + + +
void NL3D::CPSEmitter::setOwner ( CPSLocated * psl ) [virtual, inherited]
+
+ + + + + +
+ + + +
+========================================================================== +
+ +
+Reimplemented from NL3D::CPSLocatedBindable. +
+Definition at line 111 of file ps_emitter.cpp. +
+References NL3D::CPSEmitter::updateMaxCountVect(). +
+
00112 { +00113 CPSLocatedBindable::setOwner(psl); +00114 updateMaxCountVect(); +00115 } +

+

+ + + + +
+ + + + + + + + + + +
void NL3D::CPSEmitter::setPeriod ( float period ) [inherited]
+
+ + + + + +
+ + + +
+========================================================================== +
+Set a constant period for emission (expressed in second) any previous period scheme is discarded +
+Definition at line 401 of file ps_emitter.cpp. +
+References NL3D::CPSEmitter::_Period, NL3D::CPSEmitter::_PeriodScheme, NL3D::CParticleSystemProcess::getOwner(), and NL3D::CParticleSystem::systemDurationChanged(). +
+
00402 { +00403 if (_PeriodScheme) +00404 { +00405 delete _PeriodScheme; +00406 _PeriodScheme = NULL; +00407 } +00408 _Period = period; +00409 if (_Owner && _Owner->getOwner()) +00410 { +00411 _Owner->getOwner()->systemDurationChanged(); +00412 } +00413 } +

+

+ + + + +
+ + + + + + + + + + +
void NL3D::CPSEmitter::setPeriodScheme ( CPSAttribMaker< float > * scheme ) [inherited]
+
+ + + + + +
+ + + +
+========================================================================== +
+ +
+Definition at line 416 of file ps_emitter.cpp. +
+References NL3D::CPSEmitter::_PeriodScheme, NL3D::CPSLocated::getMaxSize(), NL3D::CParticleSystemProcess::getOwner(), NL3D::CPSLocated::getSize(), NL3D::CPSAttribMaker< T >::resize(), and NL3D::CParticleSystem::systemDurationChanged(). +
+
00417 { +00418 delete _PeriodScheme; +00419 _PeriodScheme = scheme; +00420 if (_Owner && scheme->hasMemory()) scheme->resize(_Owner->getMaxSize(), _Owner->getSize()); +00421 if (_Owner && _Owner->getOwner()) +00422 { +00423 _Owner->getOwner()->systemDurationChanged(); +00424 } +00425 } +

+

+ + + + +
+ + + + + + + + + + +
void NL3D::CPSEmitter::setSpeedInheritanceFactor ( float fact ) [inline, inherited]
+
+ + + + + +
+ + + +
+Set a factor, to add the emitter speed to the emittee creation speed. this can be < 0 The default is 0 +
+Definition at line 184 of file ps_emitter.h. +
+References NL3D::CPSEmitter::_SpeedInheritanceFactor. +
+
00185 { +00186 _SpeedInheritanceFactor = fact; +00187 } +

+

+ + + + +
+ + + + + + + + + + +
void NL3D::CPSLocatedBindable::setupDriverModelMatrix ( void ) [inherited]
+
+ + + + + +
+ + + +
+shortcut to setup the model matrix (system basis or world basis) +
+ +
+Definition at line 2142 of file ps_located.cpp. +
+References nlassert, and NL3D::CPSLocated::setupDriverModelMatrix(). +
+Referenced by NL3D::CPSLocatedBindable::displayIcon2d(), NL3D::CPSTailDot::displayRibbons(), NL3D::CPSRibbonLookAt::displayRibbons(), NL3D::CPSRibbon::displayRibbons(), NL3D::CPSDot::draw(), NL3D::CPSFaceHelper::drawFaces(), NL3D::CPSFanLightHelper::drawFanLight(), NL3D::CPSFaceLookAtHelper::drawLookAt(), NL3D::CPSFaceLookAtHelper::drawLookAtAlignOnMotion(), NL3D::CPSConstraintMeshHelper::drawMeshs(), NL3D::CPSConstraintMeshHelper::drawPrerotatedMeshs(), NL3D::CPSZoneRectangle::show(), NL3D::CPSZoneCylinder::show(), NL3D::CPSZoneDisc::show(), NL3D::CPSZoneSphere::show(), NL3D::CPSZonePlane::show(), NL3D::CPSCylindricVortex::show(), NL3D::CPSDirectionnalForce::show(), NL3D::CPSSphericalEmitter::showTool(), NL3D::CPSEmitterRectangle::showTool(), and NL3D::CPSEmitter::showTool(). +
+
02143 { +02144 nlassert(_Owner); +02145 _Owner->setupDriverModelMatrix(); +02146 } +

+

+ + + + +
+ + + + + + + + + + +
void NL3D::CPSEmitter::setUserMatrixModeForEmissionDirection ( TPSMatrixMode matrixMode ) [inherited]
+
+ + + + + +
+ + + +
+=============================================================================== +
+Set the coord. system in with the direction is expressed. This value is taken in account only if enableUserMatrixModeForEmissionDirection(true) has been called. NB : if isSpeedBasisEmissionEnabled() == true then this value is meaningless +
+Definition at line 2609 of file ps_emitter.cpp. +
+References NL3D::CPSEmitter::_UserDirectionMatrixMode, NL3D::CPSEmitter::isUserMatrixUsed(), and NL3D::CPSEmitter::updatePSRefCountForUserMatrixUsage(). +
+
02610 { +02611 bool wasUserMatNeeded = isUserMatrixUsed(); +02612 _UserDirectionMatrixMode = matrixMode; +02613 updatePSRefCountForUserMatrixUsage(isUserMatrixUsed(), wasUserMatNeeded); +02614 } +

+

+ + + + +
+ + + + + + + + + + +
virtual void NL3D::CPSLocatedBindable::setZBias ( float value ) [inline, virtual, inherited]
+
+ + + + + +
+ + + +
+ +
+Reimplemented in NL3D::CPSDot, NL3D::CPSFanLight, NL3D::CPSMesh, NL3D::CPSConstraintMesh, NL3D::CPSParticle, NL3D::CPSQuad, NL3D::CPSRibbon, NL3D::CPSRibbonLookAt, NL3D::CPSShockWave, and NL3D::CPSTailDot. +
+Definition at line 980 of file ps_located.h. +
+References value. +
+
00980 {} +

+

+ + + + +
+ + + + + + + + + + +
void NL3D::CPSEmitter::showTool ( void ) [virtual, inherited]
+
+ + + + + +
+ + + +
+========================================================================== +
+ +
+Reimplemented in NL3D::CPSEmitterRectangle, and NL3D::CPSSphericalEmitter. +
+Definition at line 447 of file ps_emitter.cpp. +
+References NL3D::CPSLocatedBindable::computeI(), NL3D::CPSLocatedBindable::computeK(), NL3D::CParticleSystem::getCurrentEditedElement(), NL3D::CPSLocatedBindable::getDriver(), NL3D::CParticleSystemProcess::getOwner(), NL3D::CPSLocated::getPos(), NL3D::CPSLocated::getSize(), index, NL3D::CMaterial::setBlend(), NL3D::CMaterial::setBlendFunc(), NL3D::CMaterial::setColor(), NL3D::CMaterial::setLighting(), NL3D::CPSLocatedBindable::setupDriverModelMatrix(), NL3D::CMaterial::setZFunc(), NL3D::CMaterial::setZWrite(), size, uint, and uint32. +
+Referenced by NL3D::CPSEmitter::step(). +
+
00448 { +00449 uint32 size = _Owner->getSize(); +00450 if (!size) return; +00451 setupDriverModelMatrix(); +00452 +00453 const CVector I = computeI(); +00454 const CVector K = computeK(); +00455 +00456 // ugly slow code, but not for runtime +00457 for (uint k = 0; k < size; ++k) +00458 { +00459 // center of the current particle +00460 const CVector p = _Owner->getPos()[k]; +00461 const float sSize =0.1f; +00462 std::vector<NLMISC::CLine> lines; +00463 NLMISC::CLine l; +00464 l.V0 = p - sSize * I; l.V1 = p + sSize * I; lines.push_back(l); +00465 l.V0 = p - sSize * K; l.V1 = p + sSize * K; lines.push_back(l); +00466 l.V0 = p - sSize * (I + K); l.V1 = p + sSize * (I + K); lines.push_back(l); +00467 l.V0 = p - sSize * (I - K); l.V1 = p + sSize * (I - K); lines.push_back(l); +00468 +00469 CMaterial mat; +00470 mat.setBlendFunc(CMaterial::one, CMaterial::one); +00471 mat.setZWrite(false); +00472 mat.setLighting(false); +00473 mat.setBlend(true); +00474 mat.setZFunc(CMaterial::less); +00475 +00476 +00477 CPSLocated *loc; +00478 uint32 index; +00479 CPSLocatedBindable *lb; +00480 _Owner->getOwner()->getCurrentEditedElement(loc, index, lb); +00481 +00482 mat.setColor((lb == NULL || this == lb) && loc == _Owner && index == k ? CRGBA::Red : CRGBA(127, 127, 127)); +00483 +00484 +00485 CDRU::drawLinesUnlit(lines, mat, *getDriver() ); +00486 } +00487 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
void NL3D::CPSEmitter::singleEmit ( uint32 index,
uint quantity
) [inherited]
+
+ + + + + +
+ + + +
+========================================================================== +
+ +
+Definition at line 490 of file ps_emitter.cpp. +
+References NL3D::CPSEmitter::_GenNb, NL3D::CPSEmitter::_GenNbScheme, NL3D::CPSAttribMaker< uint32 >::get(), index, nlassert, NL3D::CPSEmitter::processEmit(), uint, and uint32. +
+Referenced by NL3D::CPSLocated::deleteElement(), and NL3D::CParticleSystemInstanceUser::emit(). +
+
00491 { +00492 nlassert(_Owner); +00493 const uint32 nbToGenerate = _GenNbScheme ? _GenNbScheme->get(_Owner,0) : _GenNb; +00494 processEmit(index, quantity * nbToGenerate); +00495 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
void NL3D::CPSEmitter::step ( TPSProcessPass pass,
TAnimationTime ellapsedTime,
TAnimationTime realEllapsedTime
) [virtual, inherited]
+
+ + + + + +
+ + + +
+========================================================================== +
+Process the emissions. The standard behaviuour will call "emit" each time is needed. So you don't need to redefine this most of the time +
+Implements NL3D::CPSLocatedBindable. +
+Definition at line 1755 of file ps_emitter.cpp. +
+References NL3D::CPSEmitter::_BypassAutoLOD, NL3D::CPSEmitter::_ConsistentEmission, NL3D::CPSEmitter::_EmissionType, NL3D::CPSEmitter::_EmittedType, NL3D::CPSEmitter::_GenNb, NL3D::CPSEmitter::_GenNbScheme, NL3D::CPSEmitter::_Phase, NL3D::CPSAttrib< float >::begin(), NL3D::CPSAttrib< float >::end(), NL3D::CPSAttribMaker< uint32 >::get(), NL3D::CParticleSystem::getAutoLODEmitRatio(), NL3D::CParticleSystemProcess::getOwner(), NL3D::CPSLocated::getSize(), NL3D::CParticleSystem::isAutoLODEnabled(), NL3D::CParticleSystem::isSharingEnabled(), nlassert, NL3D::CPSEmitter::processEmit(), NL3D::CPSEmitter::processRegularEmission(), NL3D::CPSEmitter::processRegularEmissionConsistent(), NL3D::CPSEmitter::processRegularEmissionConsistentWithNoLOD(), NL3D::CPSEmitter::processRegularEmissionWithNoLOD(), NL3D::PSEmit, NL3D::PSToolRender, NL3D::CPSEmitter::showTool(), sint32, size, NL3D::TAnimationTime, and uint32. +
+
01756 { +01757 if (pass == PSToolRender) +01758 { +01759 showTool(); +01760 return; +01761 } +01762 if (pass != PSEmit || !_EmittedType) return; +01763 const uint32 size = _Owner->getSize(); +01764 if (!size) return; +01765 +01766 if (ellapsedTime == 0.f) return; // do nothing when paused +01767 +01768 CParticleSystem *ps = _Owner->getOwner(); +01769 nlassert(ps); +01770 float emitLOD; +01771 if (ps->isAutoLODEnabled() && !ps->isSharingEnabled() && !_BypassAutoLOD) +01772 { +01773 // temp test for auto lod +01774 emitLOD = ps->getAutoLODEmitRatio(); +01775 } +01776 else +01777 { +01778 emitLOD = 1.f; +01779 } +01780 +01781 +01782 // our behaviour depend of the frequency +01783 switch (_EmissionType) +01784 { +01785 case CPSEmitter::once : +01786 { +01787 if (!_GenNbScheme && _GenNb == 0) return; +01788 TPSAttribTime::iterator timeIt = _Phase.begin(), timeEndIt = _Phase.end(); +01789 +01790 if (emitLOD == 1.f) +01791 { +01792 while (timeIt != timeEndIt) +01793 { +01794 if (*timeIt == 0.f) +01795 { +01796 const uint32 nbToGenerate = _GenNbScheme ? _GenNbScheme->get(_Owner, timeIt - _Phase.begin()) : _GenNb; +01797 processEmit(timeIt - _Phase.begin(), nbToGenerate); +01798 *timeIt = 1.f; +01799 } +01800 ++timeIt; +01801 } +01802 } +01803 else +01804 { +01805 while (timeIt != timeEndIt) +01806 { +01807 if (*timeIt == 0.f) +01808 { +01809 uint32 nbToGenerate = _GenNbScheme ? _GenNbScheme->get(_Owner, timeIt - _Phase.begin()) : _GenNb; +01810 if (nbToGenerate > 0) +01811 { +01812 nbToGenerate = (sint32) (emitLOD * nbToGenerate); +01813 if (!nbToGenerate) nbToGenerate = 1; +01814 processEmit(timeIt - _Phase.begin(), nbToGenerate); +01815 } +01816 *timeIt = 1.f; +01817 } +01818 ++timeIt; +01819 } +01820 +01821 } +01822 } +01823 break; +01824 case (CPSEmitter::regular): +01825 { +01826 if (!_ConsistentEmission) +01827 { +01828 if (emitLOD != 1.f) +01829 { +01830 processRegularEmission(ellapsedTime, emitLOD); +01831 } +01832 else +01833 { +01834 processRegularEmissionWithNoLOD(ellapsedTime); +01835 } +01836 } +01837 else +01838 { +01839 if (emitLOD != 1.f) +01840 { +01841 if (emitLOD != 0.f) +01842 { +01843 processRegularEmissionConsistent(ellapsedTime, realEllapsedTime / ellapsedTime, emitLOD, 1.f / emitLOD); +01844 } +01845 } +01846 else +01847 { +01848 processRegularEmissionConsistentWithNoLOD(ellapsedTime, realEllapsedTime / ellapsedTime); +01849 } +01850 } +01851 } +01852 break; +01853 default: break; +01854 } +01855 } +

+

+ + + + +
+ + + + + + + + + +
virtual bool NL3D::CPSDirection::supportGlobalVectorValue ( ) const [inline, virtual, inherited]
+
+ + + + + +
+ + + +
+ +
+Reimplemented in NL3D::CPSDirectionnalForce. +
+Definition at line 45 of file ps_direction.h. +
+
00045 { return false; } +

+

+ + + + +
+ + + + + + + + + +
virtual void NL3D::CPSLocatedBindable::systemDateChanged ( ) [inline, virtual, inherited]
+
+ + + + + +
+ + + +
+PRIVATE USE : called by the system when its date has been manually changed. This his usually for object that expect time to be always increasing, so that they can reset their datas +
+Reimplemented in NL3D::CPSRibbonBase. +
+Definition at line 1038 of file ps_located.h. +
+
01038 {} +

+

+ + + + +
+ + + + + + + + + +
bool NL3D::CPSEmitter::testEmitForever ( ) const [inherited]
+
+ + + + + +
+ + + +
+========================================================================== +
+Test is the emitter will emit an infinite amount of particles (e.g it doesn't stop after a while) NB : If the emitter isn't inserted in a CPSLocated instance, an assertion will be reaised +
+Definition at line 2148 of file ps_emitter.cpp. +
+References NL3D::CPSEmitter::getEmissionType(), NL3D::CPSLocated::getLastForever(), NL3D::CPSEmitter::getMaxEmissionCount(), nlassert, and nlwarning. +
+Referenced by NL3D::CParticleSystem::canFinish(), NL3D::CPSEmitter::setEmissionType(), and NL3D::CPSEmitter::setMaxEmissionCount(). +
+
02149 { +02150 if (!_Owner) +02151 { +02152 nlwarning("<CPSEmitter::testEmitForever> The emitter should be inserted in a CPSLocated instance for this call to work."); +02153 nlassert(0); +02154 return true; +02155 } +02156 if (!_Owner->getLastForever()) return false; +02157 switch(getEmissionType()) +02158 { +02159 case CPSEmitter::onBounce: +02160 case CPSEmitter::externEmit: +02161 case CPSEmitter::regular: +02162 // it is ok only if a limited number of located is emitted +02163 if (getMaxEmissionCount() == 0) return true; +02164 break; +02165 case CPSEmitter::onDeath: return true; // the emitter never dies, so .. +02166 case CPSEmitter::once: return false; +02167 break; +02168 default: +02169 nlassert(0); // not a known type +02170 break; +02171 } +02172 return false; +02173 } +

+

+ + + + +
+ + + + + + + + + +
void NL3D::CPSEmitter::updateMaxCountVect ( ) [protected, inherited]
+
+ + + + + +
+ + + +
+========================================================================== +
+ +
+Definition at line 2059 of file ps_emitter.cpp. +
+References NL3D::CPSEmitter::_MaxEmissionCount, NL3D::CPSEmitter::_NumEmission, NL3D::CPSLocated::getMaxSize(), NL3D::CPSLocated::getSize(), NL3D::CPSAttrib< T >::getSize(), NL3D::CPSAttrib< T >::insert(), NL3D::CPSAttrib< T >::remove(), and NL3D::CPSAttrib< T >::resize(). +
+Referenced by NL3D::CPSEmitter::setMaxEmissionCount(), and NL3D::CPSEmitter::setOwner(). +
+
02060 { +02061 if (!_MaxEmissionCount || !_Owner) +02062 { +02063 _NumEmission.resize(0); +02064 } +02065 else +02066 { +02067 _NumEmission.resize(_Owner->getMaxSize()); +02068 while (_NumEmission.getSize() != 0) +02069 { +02070 _NumEmission.remove(0); +02071 } +02072 while (_NumEmission.getSize() != _Owner->getSize()) +02073 { +02074 _NumEmission.insert(0); +02075 } +02076 } +02077 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
void NL3D::CPSEmitter::updatePSRefCountForUserMatrixUsage ( bool matrixIsNeededNow,
bool matrixWasNeededBefore
) [protected, inherited]
+
+ + + + + +
+ + + +
+========================================================================== +
+The particle system maintains a ref counter to see how many object requires the user matrix for their computation (if it isn't required, a significant amount of memory used for maintenance can be saved) This tool function helps increasing / decreasing that count by seeing if the matrix is still required or not +
+Definition at line 2618 of file ps_emitter.cpp. +
+References NL3D::CParticleSystem::addRefForUserSysCoordInfo(), NL3D::CParticleSystemProcess::getOwner(), and NL3D::CParticleSystem::releaseRefForUserSysCoordInfo(). +
+Referenced by NL3D::CPSEmitter::enableSpeedBasisEmission(), NL3D::CPSEmitter::enableUserMatrixModeForEmissionDirection(), and NL3D::CPSEmitter::setUserMatrixModeForEmissionDirection(). +
+
02619 { +02620 if (_Owner && _Owner->getOwner()) +02621 { +02622 if (matrixIsNeededNow && !matrixWasNeededBefore) +02623 { +02624 _Owner->getOwner()->addRefForUserSysCoordInfo(); +02625 } +02626 else if (!matrixIsNeededNow && matrixWasNeededBefore) +02627 { +02628 _Owner->getOwner()->releaseRefForUserSysCoordInfo(); +02629 } +02630 } +02631 } +

+

+ + + + +
+ + + + + + + + + + +
bool NL3D::CPSModulatedEmitter::useEmitteeSpeedScheme ( void ) const [inline, inherited]
+
+ + + + + +
+ + + +
+check wether a speed modulation scheme is being used +
+ +
+Definition at line 414 of file ps_emitter.h. +
+References NL3D::CPSModulatedEmitter::_EmitteeSpeedScheme. +
+
00414 { return _EmitteeSpeedScheme != NULL; } +

+

+ + + + +
+ + + + + + + + + + +
bool NL3D::CPSEmitter::useGenNbScheme ( void ) [inline, inherited]
+
+ + + + + +
+ + + +
+Indicate whether a GenNb scheme is used or not. +
+ +
+Definition at line 165 of file ps_emitter.h. +
+References NL3D::CPSEmitter::_GenNbScheme. +
+
00165 { return _GenNbScheme != NULL; } +

+

+ + + + +
+ + + + + + + + + + +
bool NL3D::CPSEmitter::usePeriodScheme ( void ) [inline, inherited]
+
+ + + + + +
+ + + +
+Indicate whether a period scheme is used or not. +
+ +
+Definition at line 129 of file ps_emitter.h. +
+References NL3D::CPSEmitter::_PeriodScheme. +
+
00129 { return _PeriodScheme != NULL; } +

+

Field Documentation

+ + + + +
+ + +
bool NL3D::CPSLocatedBindable::_Active [protected, inherited] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 1033 of file ps_located.h. +
+Referenced by NL3D::CPSLocatedBindable::isActive(), and NL3D::CPSLocatedBindable::setActive().
+

+ + + + +
+ + +
bool NL3D::CPSEmitter::_BypassAutoLOD [protected, inherited] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 356 of file ps_emitter.h. +
+Referenced by NL3D::CPSEmitter::getBypassAutoLOD(), NL3D::CPSEmitter::setBypassAutoLOD(), and NL3D::CPSEmitter::step().
+

+ + + + +
+ + +
bool NL3D::CPSEmitter::_BypassEmitOnDeath = false [static, protected, inherited] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 42 of file ps_emitter.cpp. +
+Referenced by NL3D::CPSEmitter::deleteElement(), and NL3D::CPSEmitter::setBypassEmitOnDeath().
+

+ + + + +
+ + +
bool NL3D::CPSEmitter::_ConsistentEmission [protected, inherited] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 355 of file ps_emitter.h. +
+Referenced by NL3D::CPSEmitter::enableConsistenEmission(), NL3D::CPSEmitter::isConsistentEmissionEnabled(), and NL3D::CPSEmitter::step().
+

+ + + + +
+ + +
NLMISC::CVector NL3D::CPSEmitterDirectionnal::_Dir [protected] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 477 of file ps_emitter.h. +
+Referenced by CPSEmitterDirectionnal(), emit(), getDir(), and setDir().
+

+ + + + +
+ + +
TEmissionType NL3D::CPSEmitter::_EmissionType [protected, inherited] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 347 of file ps_emitter.h. +
+Referenced by NL3D::CPSEmitter::bounceOccured(), NL3D::CPSEmitter::deleteElement(), NL3D::CPSEmitter::getEmissionType(), NL3D::CPSEmitter::setEmissionType(), and NL3D::CPSEmitter::step().
+

+ + + + +
+ + +
float NL3D::CPSEmitter::_EmitDelay [protected, inherited] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 352 of file ps_emitter.h. +
+Referenced by NL3D::CPSEmitter::getEmitDelay(), NL3D::CPSEmitter::processRegularEmission(), NL3D::CPSEmitter::processRegularEmissionConsistent(), NL3D::CPSEmitter::processRegularEmissionConsistentWithNoLOD(), NL3D::CPSEmitter::processRegularEmissionWithNoLOD(), and NL3D::CPSEmitter::setEmitDelay().
+

+ + + + +
+ + +
float NL3D::CPSModulatedEmitter::_EmitteeSpeed [protected, inherited] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 440 of file ps_emitter.h. +
+Referenced by NL3D::CPSModulatedEmitter::CPSModulatedEmitter(), NL3D::CPSModulatedEmitter::getEmitteeSpeed(), and NL3D::CPSModulatedEmitter::setEmitteeSpeed().
+

+ + + + +
+ + +
CPSAttribMaker<float>* NL3D::CPSModulatedEmitter::_EmitteeSpeedScheme [protected, inherited] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 441 of file ps_emitter.h. +
+Referenced by NL3D::CPSModulatedEmitter::CPSModulatedEmitter(), NL3D::CPSModulatedEmitter::deleteEmitteeSpeedElement(), NL3D::CPSModulatedEmitter::getEmitteeSpeedScheme(), NL3D::CPSModulatedEmitter::newEmitteeSpeedElement(), NL3D::CPSModulatedEmitter::resizeEmitteeSpeed(), NL3D::CPSModulatedEmitter::setEmitteeSpeed(), NL3D::CPSModulatedEmitter::setEmitteeSpeedScheme(), NL3D::CPSModulatedEmitter::useEmitteeSpeedScheme(), and NL3D::CPSModulatedEmitter::~CPSModulatedEmitter().
+

+ + + + +
+ + +
uint32 NL3D::CPSLocatedBindable::_ExternID [protected, inherited] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 1027 of file ps_located.h. +
+Referenced by NL3D::CPSLocatedBindable::getExternID(), NL3D::CPSLocatedBindable::setExternID(), and NL3D::CPSLocatedBindable::~CPSLocatedBindable().
+

+ + + + +
+ + +
TPSLod NL3D::CPSLocatedBindable::_LOD [protected, inherited] +
+
+ + + + + +
+ + + +
+tells when this object must be dealt with +
+ +
+Definition at line 1029 of file ps_located.h. +
+Referenced by NL3D::CPSLocatedBindable::getLOD(), and NL3D::CPSLocatedBindable::setLOD().
+

+ + + + +
+ + +
std::string NL3D::CPSLocatedBindable::_Name [protected, inherited] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 1031 of file ps_located.h.
+

+ + + + +
+ + +
TPSAttribUInt8 NL3D::CPSEmitter::_NumEmission [protected, inherited] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 344 of file ps_emitter.h. +
+Referenced by NL3D::CPSEmitter::deleteElement(), NL3D::CPSEmitter::newElement(), NL3D::CPSEmitter::processRegularEmission(), NL3D::CPSEmitter::processRegularEmissionConsistent(), NL3D::CPSEmitter::processRegularEmissionConsistentWithNoLOD(), NL3D::CPSEmitter::processRegularEmissionWithNoLOD(), NL3D::CPSEmitter::resize(), and NL3D::CPSEmitter::updateMaxCountVect().
+

+ + + + +
+ + +
CPSLocated* NL3D::CPSLocatedBindable::_Owner [protected, inherited] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 1026 of file ps_located.h. +
+Referenced by NL3D::CPSFaceHelper::drawFaces(), NL3D::CPSFanLightHelper::drawFanLight(), NL3D::CPSFaceLookAtHelper::drawLookAt(), NL3D::CPSFaceLookAtHelper::drawLookAtAlignOnMotion(), NL3D::CPSConstraintMeshHelper::drawMeshs(), and NL3D::CPSConstraintMeshHelper::drawPrerotatedMeshs().
+

+ + + + +
+ + +
float NL3D::CPSEmitter::_Period [protected, inherited] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 348 of file ps_emitter.h. +
+Referenced by NL3D::CPSEmitter::getPeriod(), NL3D::CPSEmitter::processRegularEmission(), NL3D::CPSEmitter::processRegularEmissionConsistent(), NL3D::CPSEmitter::processRegularEmissionConsistentWithNoLOD(), NL3D::CPSEmitter::processRegularEmissionWithNoLOD(), and NL3D::CPSEmitter::setPeriod().
+

+ + + + +
+ + +
TPSAttribFloat NL3D::CPSEmitter::_Phase [protected, inherited] +
+
+ + + + + +
+ + + +
+The phase ( 0 < phase < period of emission). This is the time ellapsed since the last emission +
+Definition at line 343 of file ps_emitter.h. +
+Referenced by NL3D::CPSEmitter::deleteElement(), NL3D::CPSEmitter::newElement(), NL3D::CPSEmitter::processRegularEmission(), NL3D::CPSEmitter::processRegularEmissionConsistent(), NL3D::CPSEmitter::processRegularEmissionConsistentWithNoLOD(), NL3D::CPSEmitter::processRegularEmissionWithNoLOD(), NL3D::CPSEmitter::resize(), and NL3D::CPSEmitter::step().
+

+ + + + +
+ + +
bool NL3D::CPSEmitter::_SpeedBasisEmission [protected, inherited] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 354 of file ps_emitter.h. +
+Referenced by NL3D::CPSEmitter::enableSpeedBasisEmission(), NL3D::CPSEmitter::isSpeedBasisEmissionEnabled(), NL3D::CPSEmitter::isUserMatrixUsed(), NL3D::CPSEmitter::processEmit(), and NL3D::CPSEmitter::processEmitConsistent().
+

+ + + + +
+ + +
float NL3D::CPSEmitter::_SpeedInheritanceFactor [protected, inherited] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 346 of file ps_emitter.h. +
+Referenced by NL3D::CPSEmitter::getSpeedInheritanceFactor(), NL3D::CPSEmitter::processEmit(), NL3D::CPSEmitter::processEmitConsistent(), and NL3D::CPSEmitter::setSpeedInheritanceFactor().
+

+ + + + +
+ + +
TPSMatrixMode NL3D::CPSEmitter::_UserDirectionMatrixMode [protected, inherited] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 358 of file ps_emitter.h. +
+Referenced by NL3D::CPSEmitter::getUserMatrixModeForEmissionDirection(), NL3D::CPSEmitter::isUserMatrixUsed(), NL3D::CPSEmitter::processEmit(), NL3D::CPSEmitter::processEmitConsistent(), and NL3D::CPSEmitter::setUserMatrixModeForEmissionDirection().
+

+ + + + +
+ + +
bool NL3D::CPSEmitter::_UserMatrixModeForEmissionDirection [protected, inherited] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 357 of file ps_emitter.h. +
+Referenced by NL3D::CPSEmitter::enableUserMatrixModeForEmissionDirection(), NL3D::CPSEmitter::isUserMatrixModeForEmissionDirectionEnabled(), NL3D::CPSEmitter::isUserMatrixUsed(), NL3D::CPSEmitter::processEmit(), and NL3D::CPSEmitter::processEmitConsistent().
+

The documentation for this class was generated from the following files:

Generated on Tue Mar 16 07:09:12 2004 for NeL by + +

+1.3.6

+ + -- cgit v1.2.1


Public Types
enum	TEmissionType { + regular = 0, +onDeath = 1, +once = 2, +onBounce = 3, + + externEmit = 4, +numEmissionType + + }
Public Member Functions
virtual void	basisChanged (TPSMatrixMode systemBasis)
bool	checkLoop () const
	==========================================================================
virtual bool	completeBBox (NLMISC::CAABBox &box) const
NLMISC::CVector	computeI (void) const
NLMISC::CVector	computeJ (void) const
NLMISC::CVector	computeK (void) const
	CPSEmitterDirectionnal ()
virtual bool	doesProduceBBox (void) const
virtual void	emit (const NLMISC::CVector &srcPos, uint32 index, NLMISC::CVector &pos, NLMISC::CVector &speed)
	==========================================================================
void	enableConsistenEmission (bool enable)
virtual void	enableGlobalVectorValue (const std::string &name)
virtual void	enumTexs (std::vector< NLMISC::CSmartPtr< ITexture > > &dest, IDriver &drv)
bool	getBypassAutoLOD () const
virtual std::string	getClassName ()=0
NLMISC::CVector	getDir (void) const
IDriver *	getDriver () const
	shortcut to get an instance of the driver
TEmissionType	getEmissionType (void) const
	Get the frequency type.
float	getEmitDelay () const
	Get the delay in seconds before the first emission (regular emitter only).
const CPSLocated *	getEmittedType (void) const
	Get const ptr on emitted type.
CPSLocated *	getEmittedType (void)
	Get emitted type.
float	getEmitteeSpeed (void) const
	get the modulation speed (valid only if no scheme is used)
const CPSAttribMaker< float > *	getEmitteeSpeedScheme (void) const
	get the speed modulation shceme, or NULL if no one is set (const version)
CPSAttribMaker< float > *	getEmitteeSpeedScheme (void)
	get the speed modulation shceme, or NULL if no one is set
uint32	getExternID (void) const
	get the extern ID of this located bindable
const CFontGenerator *	getFontGenerator (void) const
	Shortcut to get the font generator if one was set (const version).
CFontGenerator *	getFontGenerator (void)
	Shortcut to get the font generator if one was set.
const CFontManager *	getFontManager (void) const
	Shortcut to get the font manager if one was set (const version).
CFontManager *	getFontManager (void)
	***************************************************************************************
uint	getGenNb (void) const
	Retrieve the GenNb for emission, valid only if a GenNb scheme is used.
const CPSAttribMaker< uint32 > *	getGenNbScheme (void) const
	Retrieve the GenNb scheme, or null, if there'isnt (const version).
CPSAttribMaker< uint32 > *	getGenNbScheme (void)
	Retrieve the GenNb scheme, or null, if there'isnt.
virtual std::string	getGlobalVectorValueName () const
const NLMISC::CMatrix &	getInvertedSysMat (void) const
	shortcut to get the inverted matrix of the system
const NLMISC::CMatrix &	getInvertedViewMat (void) const
	shortcut to get the inverted view matrix
const NLMISC::CMatrix &	getLocalToWorldMatrix () const
	Shortcut to get the local to world matrix.
TPSLod	getLOD (void) const
	get the valid lods for that object
uint8	getMaxEmissionCount () const
	Get the max. number of particle emission (0 means no limit and is the default). Applies with regular emitter only.
std::string	getName (void) const
	get the located bindable name (edition purpose)
const CPSLocated *	getOwner (void) const
	get the located that owns this bindable (const version)
CPSLocated *	getOwner (void)
	get the located that owns this bindable
float	getPeriod (void) const
	Retrieve the period for emission, valid only if a period scheme is used.
const CPSAttribMaker< float > *	getPeriodScheme (void) const
CPSAttribMaker< float > *	getPeriodScheme (void)
virtual uint32	getPriority (void) const
	Return priority for emitters.
const NLMISC::CMatrix &	getSysMat (void) const
	***************************************************************************************
uint32	getType (void) const
	Return this bindable type.
virtual bool	getUserMatrixUsageCount () const
	==========================================================================
const NLMISC::CMatrix &	getViewMat (void) const
	shortcut to get the view matrix
virtual bool	hasEmitters (void) const
	tells wether there are alive emitters
virtual bool	hasEmitters (void)
	Return true if this located bindable derived class holds alive emitters.
virtual bool	hasParticles (void) const
	tells wether there are alive entities / particles
bool	isActive () const
bool	isConsistentEmissionEnabled () const
virtual void	motionTypeChanged (bool parametric)
	called when a located has switch between incrmental / parametric motion. The default does nothing
	NLMISC_DECLARE_CLASS (CPSEmitterDirectionnal)
virtual void	notifyTargetRemoved (CPSLocated *ptr)
	==========================================================================
virtual void	releaseAllRef ()
virtual void	releaseRefTo (const CParticleSystemProcess *other)
	==========================================================================
virtual void	serial (NLMISC::IStream &f) throw (NLMISC::EStream)
	==========================================================================
void	serialEmitteeSpeedScheme (NLMISC::IStream &f) throw (NLMISC::EStream)
	serialization
void	setActive (bool active)
	Activate / Deactivate this object. When not active, the owning system won't try to call the 'step' method.
void	setBypassAutoLOD (bool bypass)
void	setDir (const NLMISC::CVector &v)
bool	setEmissionType (TEmissionType freqType)
	==========================================================================
void	setEmitDelay (float delay)
	==========================================================================
bool	setEmittedType (CPSLocated *et)
	==========================================================================
void	setEmitteeSpeed (float speed)
	set a constant speed modulation for emittee
void	setEmitteeSpeedScheme (CPSAttribMaker< float > *scheme)
void	setExternID (uint32 id)
	***************************************************************************************
void	setGenNb (uint32 GenNb)
	==========================================================================
void	setGenNbScheme (CPSAttribMaker< uint32 > *scheme)
	==========================================================================
void	setLOD (TPSLod lod)
bool	setMaxEmissionCount (uint8 count)
	==========================================================================
void	setName (const std::string &name)
	set the located bindable name (edition purpose)
virtual void	setOwner (CPSLocated *psl)
	==========================================================================
void	setPeriod (float period)
	==========================================================================
void	setPeriodScheme (CPSAttribMaker< float > *scheme)
	==========================================================================
void	setupDriverModelMatrix (void)
	shortcut to setup the model matrix (system basis or world basis)
virtual void	setZBias (float value)
virtual void	showTool (void)
	==========================================================================
void	singleEmit (uint32 index, uint quantity)
	==========================================================================
virtual void	step (TPSProcessPass pass, TAnimationTime ellapsedTime, TAnimationTime realEllapsedTime)
	==========================================================================
virtual bool	supportGlobalVectorValue () const
virtual void	systemDateChanged ()
bool	testEmitForever () const
	==========================================================================
bool	useEmitteeSpeedScheme (void) const
	check wether a speed modulation scheme is being used
bool	useGenNbScheme (void)
	Indicate whether a GenNb scheme is used or not.
bool	usePeriodScheme (void)
	Indicate whether a period scheme is used or not.
Static Public Member Functions
void	setBypassEmitOnDeath (bool bypass)
Protected Member Functions
virtual void	bounceOccured (uint32 index)
	==========================================================================
virtual void	deleteElement (uint32 index)
	==========================================================================
void	deleteEmitteeSpeedElement (uint32 index)
void	displayIcon2d (const NLMISC::CVector tab[], uint nbSegs, float scale)
	***************************************************************************************
virtual CPSLocated *	getModulatedEmitterOwner (void)
bool	isUserMatrixUsed () const
	==========================================================================
virtual void	newElement (CPSLocated *emitter, uint32 emitterIndex)
	==========================================================================
void	newEmitteeSpeedElement (CPSLocated *emitter, uint32 emitterIndex)
void	processEmit (uint32 index, sint nbToGenerate)
	==========================================================================
void	processEmitConsistent (const NLMISC::CVector &emitterPos, uint32 emitterIndex, sint nbToGenerate, TAnimationTime deltaT, TAnimationTime ellapsedTime, float realEllapsedTimeRatio)
	==========================================================================
void	processRegularEmission (TAnimationTime ellapsedTime, float emitLOD)
	==========================================================================
void	processRegularEmissionConsistent (TAnimationTime ellapsedTime, float realEllapsedTimeRatio, float emitLOD, float inverseEmitLOD)
	==========================================================================
void	processRegularEmissionConsistentWithNoLOD (TAnimationTime ellapsedTime, float realEllapsedTimeRatio)
	==========================================================================
void	processRegularEmissionWithNoLOD (TAnimationTime ellapsedTime)
	==========================================================================
virtual void	resize (uint32 capacity)
	==========================================================================
void	resizeEmitteeSpeed (uint32 capacity)
void	updateMaxCountVect ()
	==========================================================================
void	updatePSRefCountForUserMatrixUsage (bool matrixIsNeededNow, bool matrixWasNeededBefore)
	==========================================================================
Protected Attributes
bool	_Active
bool	_BypassAutoLOD: 1
bool	_ConsistentEmission: 1
NLMISC::CVector	_Dir
TEmissionType	_EmissionType
float	_EmitDelay
CPSLocated *	_EmittedType
	A pointer on the type to be emitted.
float	_EmitteeSpeed
CPSAttribMaker< float > *	_EmitteeSpeedScheme
uint32	_ExternID
uint32	_GenNb
CPSAttribMaker< uint32 > *	_GenNbScheme
TPSLod	_LOD
	tells when this object must be dealt with
uint8	_MaxEmissionCount
std::string	_Name
TPSAttribUInt8	_NumEmission
CPSLocated *	_Owner
float	_Period
CPSAttribMaker< float > *	_PeriodScheme
TPSAttribFloat	_Phase
bool	_SpeedBasisEmission: 1
float	_SpeedInheritanceFactor
TPSMatrixMode	_UserDirectionMatrixMode
bool	_UserMatrixModeForEmissionDirection: 1
Static Protected Attributes
bool	_BypassEmitOnDeath = false
Friends
class	CPSLocated

NL3D::CPSEmitterDirectionnal Class Reference

Detailed Description

Public Types

Public Member Functions

Static Public Member Functions

Protected Member Functions

Protected Attributes

Static Protected Attributes

Friends

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation

Field Documentation