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/a03230.html | 6685 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 6685 insertions(+) create mode 100644 docs/doxygen/nel/a03230.html (limited to 'docs/doxygen/nel/a03230.html') diff --git a/docs/doxygen/nel/a03230.html b/docs/doxygen/nel/a03230.html new file mode 100644 index 00000000..60351fa1 --- /dev/null +++ b/docs/doxygen/nel/a03230.html @@ -0,0 +1,6685 @@ + + +NeL: NL3D::CPSRibbonLookAt class Reference + + + +
+

NL3D::CPSRibbonLookAt Class Reference

#include <ps_ribbon_look_at.h> +

+

Inheritance diagram for NL3D::CPSRibbonLookAt: +

+ +NL3D::CPSRibbonBase +NL3D::CPSSizedParticle +NL3D::CPSColoredParticle +NL3D::CPSMaterial +NL3D::CPSTexturedParticleNoAnim +NL3D::CPSParticle +NL3D::CPSTailParticle +NL3D::CPSLocatedBindable +NLMISC::IStreamable +NLMISC::IClassable + +

Detailed Description

+A ribbon look at particle. It is like a ribbon, but textured (with no animation), and it always faces the user +

+ +

+Definition at line 41 of file ps_ribbon_look_at.h. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Vertex buffers & their corresponding index buffers. We keep a map of pretextured vertex buffer (with or without colors).

Vb for ribbons that have the same size are shared.

typedef std::hash_map< uint,
+ CVBnPB
TVBMap
uint getNumRibbonsInVB () const
 get the number of ribbons contained in a vb for a given length. (e.g the number of ribbons that can be batched)

CVBnPBgetVBnPB ()
 get a vertex buffer and a primitive suited for the current ribbon

TVBMap _ColoredVBMap
TVBMap _VBMap

Public Types

enum  TBlendingMode { add, +modulate, +alphaBlend, +alphaTest + }
 this enum summarize the useful modes for blending to the framebuffer More...

enum  TInterpolationMode { Linear = 0, +Hermitte, +InterpModeLast + }
enum  TRibbonMode { VariableSize = 0, +FixedSize, +RibbonModeLast + }

Public Member Functions

virtual void basisChanged (TPSMatrixMode systemBasis)
virtual bool completeBBox (NLMISC::CAABBox &box) const
NLMISC::CVector computeI (void) const
NLMISC::CVector computeJ (void) const
NLMISC::CVector computeK (void) const
void disableAutoLOD (bool disable=true)
 Force the Auto-LOD to be disbaled. When set to false, the default behaviour set in the system is used.

virtual bool doesProduceBBox (void) const
virtual void draw (bool opaque)
 derivers draw the particles here

void enableGlobalColorLighting (bool enabled)
void enableZTest (bool enabled)
 ===================================================================================

virtual void enumTexs (std::vector< NLMISC::CSmartPtr< ITexture > > &dest, IDriver &drv)
void forceModulateConstantColor (bool force, const NLMISC::CRGBA &col=NLMISC::CRGBA::White)
 ===================================================================================

void forceTexturedMaterialStages (uint numStages)
 ===================================================================================

CPSMaterial::TBlendingMode getBlendingMode (void) const
 ===================================================================================

virtual std::string getClassName ()=0
NLMISC::CRGBA getColor (void) const
 Get the color.

const CPSAttribMaker< CRGBA > * getColorScheme (void) const
 get the color scheme (NULL if none) const version

CPSAttribMaker< CRGBA > * getColorScheme (void)
 get the color scheme (NULL if none)

IDrivergetDriver () const
 shortcut to get an instance of the driver

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

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

CFontGeneratorgetFontGenerator (void)
 Shortcut to get the font generator if one was set.

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

CFontManagergetFontManager (void)
 ***************************************************************************************

const NLMISC::CMatrixgetInvertedSysMat (void) const
 shortcut to get the inverted matrix of the system

const NLMISC::CMatrixgetInvertedViewMat (void) const
 shortcut to get the inverted view matrix

const NLMISC::CMatrixgetLocalToWorldMatrix () const
 Shortcut to get the local to world matrix.

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

float getLODDegradation () const
virtual uint32 getMaxNumFaces (void) const
 return the max number of faces needed for display. This is needed for LOD balancing

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

const CPSLocatedgetOwner (void) const
 get the located that owns this bindable (const version)

CPSLocatedgetOwner (void)
 get the located that owns this bindable

virtual uint32 getPriority (void) const
 return priority

float getSize (void) const
 get the constant size

const CPSAttribMaker< float > * getSizeScheme (void) const
 get the size scheme (NULL if none) const version

CPSAttribMaker< float > * getSizeScheme (void)
 get the size scheme (NULL if none)

const NLMISC::CMatrixgetSysMat (void) const
 ***************************************************************************************

uint32 getType (void) const
 return this bindable type

virtual bool getUserMatrixUsageCount () const
const NLMISC::CMatrixgetViewMat (void) const
 shortcut to get the view matrix

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

virtual bool hasLightableFaces ()
 from CPSParticle : return true if there are lightable faces in the object

virtual bool hasOpaqueFaces (void)
 return true if there are Opaque faces in the object

virtual bool hasParticles (void) const
 return true if this located bindable derived class holds alive particles

virtual bool hasTransparentFaces (void)
 return true if there are transparent faces in the object

bool isActive () const
bool isAutoLODDisabled () const
 Test wether Auto-LOD is disabled.

bool isZTestEnabled () const
 ===================================================================================

virtual void notifyTargetRemoved (CPSLocated *ptr)
 ***************************************************************************************

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

virtual void releaseRefTo (const CParticleSystemProcess *other)
void serialColorScheme (NLMISC::IStream &f) throw (NLMISC::EStream)
 serialization.

void serialMaterial (NLMISC::IStream &f) throw (NLMISC::EStream)
 ===================================================================================

void serialSizeScheme (NLMISC::IStream &f) throw (NLMISC::EStream)
 serialization. We choose a different name because of multiple-inheritance

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

void setBlendingMode (CPSMaterial::TBlendingMode mode)
 ===================================================================================

void setColor (NLMISC::CRGBA col)
 Set a constant color for the particles. remove any previous scheme.

void setColorScheme (CPSAttribMaker< CRGBA > *col)
void setExternID (uint32 id)
 ***************************************************************************************

void setLOD (TPSLod lod)
void setLODDegradation (float percent)
void setName (const std::string &name)
 set the located bindable name (edition purpose)

void setSize (float size)
 Set a constant size for the particles.

void setSizeScheme (CPSAttribMaker< float > *size)
void setupDriverModelMatrix (void)
 shortcut to setup the model matrix (system basis or world basis)

virtual void setZBias (float value)
virtual void showTool ()
 draw the particles for edition mode. The default behaviour just draw a wireframe model

virtual void step (TPSProcessPass pass, TAnimationTime ellapsedTime, TAnimationTime realEt)
 inherited from CPSParticle

virtual bool supportGlobalColorLighting () const
bool usesGlobalColorLighting ()
Object
 CPSRibbonLookAt ()
 ctor

 NLMISC_DECLARE_CLASS (CPSRibbonLookAt)
 ctor

virtual void serial (NLMISC::IStream &f) throw (NLMISC::EStream)
 serialisation. Derivers must override this, and call their parent version

 ~CPSRibbonLookAt ()
 dtor

Behaviour
virtual bool getColorFading (void) const
virtual bool isInSystemBasis (void) const
 return true if the tails are in the system basis

virtual void setColorFading (bool onOff=true)
virtual void setSystemBasis (bool yes)
Texture
const ITexturegetTexture (void) const
ITexturegetTexture (void)
 get the texture used for this particle

void setTexture (CSmartPtr< ITexture > tex)
 set the texture for this particle


Protected Types

typedef CPSVector< float >::V TFloatVect
typedef CPSVector< NLMISC::CVector
+>::V 
TPosVect

Protected Member Functions

virtual void bounceOccured (uint32 index)
void computeRibbon (uint index, NLMISC::CVector *dest, uint stride=sizeof(NLMISC::CVector))
void computeSrcStep (uint32 &step, uint &numToProcess)
void deleteColorElement (uint32 index)
virtual void deleteElement (uint32 index)
 inherited from CPSLocatedBindable

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

virtual CPSLocatedgetColorOwner (void)
 deriver must return their owner there

uint32 getRibbonIndex () const
const TFloatVectgetSamplingDate () const
virtual CPSLocatedgetSizeOwner (void)
 deriver must return their owner there

void initDateVect ()
virtual void motionTypeChanged (bool parametric)
 called when the motion type has changed, this allow us to draw smoother ribbons when parametric anim is used

void newColorElement (CPSLocated *emitterLocated, uint32 emitterIndex)
virtual void newElement (CPSLocated *emitterLocated, uint32 emitterIndex)
 inherited from CPSLocatedBindable

void newSizeElement (CPSLocated *emitterLocated, uint32 emitterIndex)
void notifyOwnerMaxNumFacesChanged (void) const
void resetFromOwner ()
virtual void resize (uint32 size)
 inherited from CPSLocatedBindable

void resizeColor (uint32 size)
void resizeSize (uint32 size)
virtual void setOwner (CPSLocated *psl)
 ***************************************************************************************

void updateGlobals (float realET)
 Called each time the time of the system change in order to update the ribbons positions.

void updateLOD ()
 must be called for the lod to apply (updates UsedNbSegs)


Protected Attributes

bool _Active
CRGBA _Color
CPSAttribMaker< CRGBA > * _ColorScheme
uint32 _ExternID
TPSLod _LOD
 tells when this object must be dealt with

CMaterial _Mat
std::string _Name
uint32 _NbSegs
CPSLocated_Owner
bool _Parametric
float _ParticleSize
TAnimationTime _SegDuration
CPSAttribMaker< float > * _SizeScheme
CSmartPtr< ITexture_Tex
uint32 _UsedNbSegs
 value to use after lod computation

TAnimationTime _UsedSegDuration
float _UsedSegLength

Private Member Functions

void displayRibbons (uint32 nbRibbons, uint32 srcStep)
 display a set of ribbons

virtual void updateMatAndVbForColor (void)
 update the material and the vb so that they match the color scheme. Inherited from CPSColoredParticle


Friends

class CPSLocated
+


Member Typedef Documentation

+

+ + + + +
+ + +
typedef CPSVector<float>::V NL3D::CPSRibbonBase::TFloatVect [protected, inherited] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 99 of file ps_ribbon_base.h. +

+Referenced by NL3D::CPSRibbonBase::getSamplingDate().

+

+ + + + +
+ + +
typedef CPSVector<NLMISC::CVector>::V NL3D::CPSRibbonBase::TPosVect [protected, inherited] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 98 of file ps_ribbon_base.h.

+

+ + + + +
+ + +
typedef std::hash_map<uint, CVBnPB> NL3D::CPSRibbonLookAt::TVBMap [private] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 155 of file ps_ribbon_look_at.h.

+


Member Enumeration Documentation

+

+ + + + +
+ + +
enum NL3D::CPSMaterial::TBlendingMode [inherited] +
+
+ + + + + +
+   + + +

+this enum summarize the useful modes for blending to the framebuffer +

+

Enumeration values:
+ + + + + +
add  +
modulate  +
alphaBlend  +
alphaTest  +
+
+ +

+Definition at line 809 of file ps_particle_basic.h. +

+

+

+ + + + +
+ + +
enum NL3D::CPSRibbonBase::TInterpolationMode [inherited] +
+
+ + + + + +
+   + + +

+

Enumeration values:
+ + + + +
Linear  +
Hermitte  +
InterpModeLast  +
+
+ +

+Definition at line 49 of file ps_ribbon_base.h. +

+Referenced by NL3D::CPSRibbonBase::getInterpolationMode(). +

+

00049 { Linear = 0, Hermitte, InterpModeLast };
+
+

+ + + + +
+ + +
enum NL3D::CPSRibbonBase::TRibbonMode [inherited] +
+
+ + + + + +
+   + + +

+

Enumeration values:
+ + + + +
VariableSize  +
FixedSize  +
RibbonModeLast  +
+
+ +

+Definition at line 48 of file ps_ribbon_base.h. +

+Referenced by NL3D::CPSRibbonBase::getRibbonMode(). +

+

+


Constructor & Destructor Documentation

+

+ + + + +
+ + + + + + + + + +
NL3D::CPSRibbonLookAt::CPSRibbonLookAt  ) 
+
+ + + + + +
+   + + +

+ctor +

+ +

+Definition at line 55 of file ps_ribbon_look_at.cpp. +

+

00056 {
+00057 }
+
+

+ + + + +
+ + + + + + + + + +
NL3D::CPSRibbonLookAt::~CPSRibbonLookAt  ) 
+
+ + + + + +
+   + + +

+dtor +

+ +

+Definition at line 60 of file ps_ribbon_look_at.cpp. +

+

00061 {
+00062 //      delete _DyingRibbons;
+00063 }
+
+


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 {}
+
+

+ + + + +
+ + + + + + + + + + +
virtual void NL3D::CPSLocatedBindable::bounceOccured uint32  index  )  [inline, protected, virtual, inherited]
+
+ + + + + +
+   + + +

+a bounce occured, so some action could be done. The default behaviour does nothing

Parameters:
+ + +
index the index of the element that bounced
+
+ +

+Reimplemented in NL3D::CPSEmitter. +

+Definition at line 1011 of file ps_located.h. +

+References index, and uint32. +

+

01011 {}
+
+

+ + + + +
+ + + + + + + + + + +
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::CPSRibbonBase::computeRibbon uint  index,
NLMISC::CVector dest,
uint  stride = sizeof(NLMISC::CVector)
[protected, inherited]
+
+ + + + + +
+   + + +

+Get position of the i-th ribbon and store them in a table of vector. It uses the interpolation setting of this object. The dest tab must have at least nbSegs + 1 entries. +

+Definition at line 455 of file ps_ribbon_base.cpp. +

+References NL3D::CPSRibbonBase::_InterpolationMode, NL3D::CPSRibbonBase::_RibbonMode, NL3D::CPSRibbonBase::computeHermitteCstSizeRibbon(), NL3D::CPSRibbonBase::computeHermitteRibbon(), NL3D::CPSRibbonBase::computeLinearCstSizeRibbon(), NL3D::CPSRibbonBase::computeLinearRibbon(), NL3D::CPSRibbonBase::Hermitte, index, NL3D::CPSRibbonBase::Linear, nlassert, stride, uint, and NL3D::CPSRibbonBase::VariableSize. +

+Referenced by NL3D::CPSTailDot::displayRibbons(), displayRibbons(), and NL3D::CPSRibbon::displayRibbons(). +

+

00456 {
+00457         switch (_InterpolationMode)
+00458         {
+00459                 case Linear:
+00460                         if (_RibbonMode == VariableSize)
+00461                         {
+00462                                 computeLinearRibbon(index, dest, stride);                               
+00463                         }
+00464                         else
+00465                         {
+00466                                 computeLinearCstSizeRibbon(index, dest, stride);                                
+00467                         }
+00468                 break;
+00469                 case Hermitte:
+00470                         if (_RibbonMode == VariableSize)
+00471                         {
+00472                                 computeHermitteRibbon(index, dest, stride);                                     
+00473                                 
+00474                         }
+00475                         else
+00476                         {
+00477                                 computeHermitteCstSizeRibbon(index, dest, stride);                                      
+00478                         }
+00479                 break;
+00480                 default:
+00481                         nlassert(0);
+00482                 break;
+00483         }
+00484         
+00485 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
void NL3D::CPSParticle::computeSrcStep uint32 step,
uint numToProcess
[protected, inherited]
+
+ + + + + +
+   + + +

+System may have hand-tuned LOD, or auto LOD. This compute the number of particles that must really be displayed, and the src step that allow to go through the whole collection. The step in the source is in a fixed point 16:16 format +

+Definition at line 82 of file ps_particle_basic.cpp. +

+References NL3D::CPSParticle::_DisableAutoLOD, NLMISC::clamp(), NL3D::CParticleSystem::getAutoLODDegradationExponent(), NL3D::CParticleSystem::getAutoLODMode(), NL3D::CParticleSystem::getAutoLODStartDistPercent(), NL3D::CParticleSystem::getOneMinusCurrentLODRatio(), NL3D::CParticleSystemProcess::getOwner(), NL3D::CPSLocated::getSize(), NL3D::CParticleSystem::isAutoLODEnabled(), NL3D::CParticleSystem::isSharingEnabled(), nlassert, r, uint, and uint32. +

+Referenced by NL3D::CPSShockWave::draw(), NL3D::CPSConstraintMesh::draw(), NL3D::CPSFanLight::draw(), NL3D::CPSFaceLookAt::draw(), NL3D::CPSDot::draw(), NL3D::CPSTailDot::step(), step(), NL3D::CPSRibbon::step(), and NL3D::CPSFace::step(). +

+

00083 {               
+00084         nlassert(_Owner && _Owner->getOwner());
+00085         const CParticleSystem &ps = *(_Owner->getOwner());
+00086         if (_DisableAutoLOD || !ps.isAutoLODEnabled() || !ps.isSharingEnabled() || _Owner->getSize() == 0) // Should Auto-LOD be used ?
+00087         {
+00088                 step = (1 << 16);
+00089                 numToProcess = _Owner->getSize();
+00090         }
+00091         else
+00092         {
+00093                 float oneMinusLODRatio = ps.getOneMinusCurrentLODRatio();
+00094                 float LODRatio = 1.f - oneMinusLODRatio;  
+00095                 if (LODRatio > ps.getAutoLODStartDistPercent())
+00096                 {
+00097                         float factor = (LODRatio - 1.f) / (ps.getAutoLODStartDistPercent() - 1.f);
+00098                         NLMISC::clamp(factor, 0.f, 1.f);
+00099                         float r = factor;
+00100                         for (uint k = 1; k < ps.getAutoLODDegradationExponent(); ++k)
+00101                         {
+00102                                 r *= factor;
+00103                         }
+00104                         numToProcess = (uint) (_Owner->getSize() * r);
+00105                         if (numToProcess < 1) { numToProcess = 1; }
+00106 
+00107                         step =   ps.getAutoLODMode() ?                             // skip or limit number, depending on the mode
+00108                                 (_Owner->getSize() << 16) / numToProcess : // skip particles
+00109                                 (1 << 16);                                                         // just display less particles
+00110                 }
+00111                 else
+00112                 {
+00113                         step = (1 << 16);
+00114                         numToProcess = _Owner->getSize();
+00115                 }
+00116         }
+00117 
+00118 }
+
+

+ + + + +
+ + + + + + + + + + +
void NL3D::CPSColoredParticle::deleteColorElement uint32  index  )  [inline, protected, inherited]
+
+ + + + + +
+   + + +

+ +

+Definition at line 237 of file ps_particle_basic.h. +

+References NL3D::CPSAttribMaker< CRGBA >::deleteElement(), NL3D::CPSAttribMaker< CRGBA >::hasMemory(), index, and uint32. +

+Referenced by NL3D::CPSTailDot::deleteElement(), NL3D::CPSShockWave::deleteElement(), deleteElement(), NL3D::CPSRibbon::deleteElement(), NL3D::CPSQuad::deleteElement(), NL3D::CPSConstraintMesh::deleteElement(), NL3D::CPSFanLight::deleteElement(), and NL3D::CPSDot::deleteElement(). +

+

00238                 {
+00239                         if (_ColorScheme && _ColorScheme->hasMemory()) _ColorScheme->deleteElement(index);
+00240                 }
+
+

+ + + + +
+ + + + + + + + + + +
void NL3D::CPSRibbonLookAt::deleteElement uint32  index  )  [protected, virtual]
+
+ + + + + +
+   + + +

+inherited from CPSLocatedBindable +

+ +

+Reimplemented from NL3D::CPSRibbonBase. +

+Definition at line 172 of file ps_ribbon_look_at.cpp. +

+References NL3D::CPSColoredParticle::deleteColorElement(), NL3D::CPSSizedParticle::deleteSizeElement(), index, and uint32. +

+

00173 {
+00174         CPSRibbonBase::deleteElement(index);
+00175         deleteColorElement(index);
+00176         deleteSizeElement(index);       
+00177 }
+
+

+ + + + +
+ + + + + + + + + + +
void NL3D::CPSSizedParticle::deleteSizeElement uint32  index  )  [inline, protected, inherited]
+
+ + + + + +
+   + + +

+ +

+Definition at line 295 of file ps_particle_basic.h. +

+References NL3D::CPSSizedParticle::_SizeScheme, NL3D::CPSAttribMaker< float >::deleteElement(), NL3D::CPSAttribMaker< float >::hasMemory(), index, and uint32. +

+Referenced by NL3D::CPSShockWave::deleteElement(), deleteElement(), NL3D::CPSRibbon::deleteElement(), NL3D::CPSQuad::deleteElement(), NL3D::CPSConstraintMesh::deleteElement(), NL3D::CPSMesh::deleteElement(), and NL3D::CPSFanLight::deleteElement(). +

+

00296                 {
+00297                         if (_SizeScheme && _SizeScheme->hasMemory()) _SizeScheme->deleteElement(index);
+00298                 }
+
+

+ + + + +
+ + + + + + + + + + +
void NL3D::CPSParticle::disableAutoLOD bool  disable = true  )  [inline, inherited]
+
+ + + + + +
+   + + +

+Force the Auto-LOD to be disbaled. When set to false, the default behaviour set in the system is used. +

+ +

+Definition at line 137 of file ps_particle_basic.h. +

+References NL3D::CPSParticle::_DisableAutoLOD. +

+

00137 { _DisableAutoLOD = disable; }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
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 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
void NL3D::CPSRibbonLookAt::displayRibbons uint32  nbRibbons,
uint32  srcStep
[private]
+
+ + + + + +
+   + + +

+display a set of ribbons +

+update material color

+setup sizes

+setup colors

+build the ribbon in vb +

+Definition at line 319 of file ps_ribbon_look_at.cpp. +

+References NL3D::IDriver::activeVertexBuffer(), NL3D::BuildSlice(), NL3D::CPSLocated::computeI(), NL3D::CPSLocated::computeK(), NL3D::CPSRibbonBase::computeRibbon(), NL3D::CPSMaterial::forceModulateConstantColor(), NL3D::CParticleSystem::getColorAttenuationScheme(), NL3D::CVertexBuffer::getColorOff(), NL3D::CPSLocatedBindable::getDriver(), NL3D::CParticleSystem::getForceGlobalColorLightingFlag(), NL3D::CParticleSystem::getGlobalColor(), NL3D::CParticleSystem::getGlobalColorLighted(), NL3D::CPSLocatedBindable::getLocalToWorldMatrix(), getNumRibbonsInVB(), NL3D::CParticleSystemProcess::getOwner(), NL3D::CParticleSystem::getSystemDate(), getVBnPB(), NL3D::CVertexBuffer::getVertexCoordPointer(), NL3D::CVertexBuffer::getVertexSize(), NL3D::CPSLocatedBindable::getViewMat(), NL3D::CPSLocated::incrementNbDrawnParticles(), NL3D::CPSLocated::integrateSingle(), NL3D::CParticleSystem::isUserColorUsed(), NL3D::CPSAttribMaker< CRGBA >::make(), NL3D::CPSAttribMaker< float >::make(), NL3D::MakeProj(), min, nlassert, NL3D::CPSRibbonLookAt::CVBnPB::PB, NL3D::IDriver::render(), NL3D::CMaterial::setColor(), NL3D::CPrimitiveBlock::setNumTri(), NL3D::CPSLocatedBindable::setupDriverModelMatrix(), NL3D::TRibbonVect, uint, uint32, uint8, NL3D::CPSParticle::usesGlobalColorLighting(), and NL3D::CPSRibbonLookAt::CVBnPB::VB. +

+Referenced by step(). +

+

00320 {       
+00321         if (!nbRibbons) return;
+00322         nlassert(_Owner);       
+00323         CPSRibbonBase::updateLOD();
+00324         if (_UsedNbSegs < 2) return;
+00325 
+00326         const float date = _Owner->getOwner()->getSystemDate();
+00327         uint8                                           *currVert;
+00328 
+00329         CVBnPB                                          &VBnPB = getVBnPB(); // get the appropriate vb (build it if needed)
+00330         CVertexBuffer                           &VB = VBnPB.VB;
+00331         CPrimitiveBlock                         &PB = VBnPB.PB;
+00332 
+00333         const uint32                            vertexSize  = VB.getVertexSize();
+00334         uint                                            colorOffset=0;
+00335         const uint32                            vertexSizeX2  = vertexSize << 1;
+00336         const NLMISC::CVector       I = _Owner->computeI();
+00337         const NLMISC::CVector       K = _Owner->computeK();
+00338 
+00339         
+00340         const NLMISC::CMatrix &mat =  getViewMat() * getLocalToWorldMatrix();
+00341                                                                                 
+00342         IDriver *drv = this->getDriver();
+00343         setupDriverModelMatrix();
+00344         drv->activeVertexBuffer(VB);
+00345         _Owner->incrementNbDrawnParticles(nbRibbons); // for benchmark purpose  
+00346 
+00347         
+00348         
+00349         const uint numRibbonBatch = getNumRibbonsInVB(); // number of ribons to process at once
+00350         
+00351 
+00352         static TRibbonVect                                 currRibbon;
+00353         static std::vector<float>                  sizes;
+00354         static std::vector<NLMISC::CRGBA>  colors;
+00355 
+00356 
+00357         
+00358         
+00359 
+00360         if (_UsedNbSegs == 0) return;
+00361 
+00362         currRibbon.resize(_UsedNbSegs + 1);
+00363         sizes.resize(numRibbonBatch);
+00364 
+00365 
+00367         CParticleSystem &ps = *(_Owner->getOwner());
+00368         if (ps.getForceGlobalColorLightingFlag() || usesGlobalColorLighting())
+00369         {
+00370                 CPSMaterial::forceModulateConstantColor(true, ps.getGlobalColorLighted());
+00371         }
+00372         else
+00373         if (ps.getColorAttenuationScheme() != NULL || ps.isUserColorUsed())
+00374         {               
+00375                 CPSMaterial::forceModulateConstantColor(true, ps.getGlobalColor());             
+00376         }
+00377         else
+00378         {       
+00379                 forceModulateConstantColor(false);
+00380                 _Mat.setColor(ps.getGlobalColor());
+00381         }
+00382 
+00383         if (_ColorScheme)
+00384         {
+00385                 colorOffset = VB.getColorOff();
+00386                 colors.resize(numRibbonBatch);          
+00387         }
+00388         
+00389         
+00390         
+00391         uint toProcess;
+00392         uint ribbonIndex = 0; // index of the first ribbon in the batch being processed
+00393         
+00394         uint32 fpRibbonIndex = 0;
+00395 
+00396         do
+00397         {
+00398                 toProcess = std::min((uint) (nbRibbons - ribbonIndex) /* = left to do */, numRibbonBatch);
+00399         
+00400 
+00402                 const float     *ptCurrSize;
+00403                 uint32  ptCurrSizeIncrement;
+00404                 if (_SizeScheme)
+00405                 {                       
+00406                         ptCurrSize = (float *) _SizeScheme->make(this->_Owner, ribbonIndex, &sizes[0], sizeof(float), toProcess, true, srcStep);                        
+00407                         ptCurrSizeIncrement = 1;
+00408                 }
+00409                 else
+00410                 {
+00411                         ptCurrSize = &_ParticleSize;
+00412                         ptCurrSizeIncrement = 0;
+00413                 }
+00414                 
+00415 
+00417                 NLMISC::CRGBA   *ptCurrColor=0;
+00418                 if (_ColorScheme)
+00419                 {
+00420                         colors.resize(nbRibbons);
+00421                         ptCurrColor = (NLMISC::CRGBA *) _ColorScheme->make(this->_Owner, ribbonIndex, &colors[0], sizeof(NLMISC::CRGBA), toProcess, true, srcStep);                     
+00422                 }       
+00423                 
+00424                 
+00425                 currVert = (uint8 *) VB.getVertexCoordPointer();
+00426                 for (uint k = ribbonIndex; k < ribbonIndex + toProcess; ++k)
+00427                 {                       
+00428                         
+00429                         TRibbonVect::iterator rIt = currRibbon.begin(), rItEnd = currRibbon.end(), rItEndMinusOne = rItEnd - 1;
+00430 
+00432                         // interpolate and project points //
+00434                 
+00435                                 if (!_Parametric)
+00436                                 {
+00437 
+00439                                         // INCREMENTAL CASE //
+00441 
+00442                                         // the parent class has a method to get the ribbons positions
+00443                                         computeRibbon((uint) (fpRibbonIndex >> 16), &rIt->Interp, sizeof(CVectInfo));                           
+00444                                         do
+00445                                         {                                       
+00446                                                 MakeProj(rIt->Proj, mat * rIt->Interp);
+00447                                                 ++rIt;                          
+00448                                         }
+00449                                         while (rIt != rItEnd);                                                          
+00450                                 }
+00451                                 else
+00452                                 {
+00454                                         // PARAMETRIC  CASE //
+00456                                         // we compute each pos thanks to the parametric curve                           
+00457                                         _Owner->integrateSingle(date - _UsedSegDuration * (_UsedNbSegs + 1), _UsedSegDuration, _UsedNbSegs + 1, (uint) (fpRibbonIndex >> 16),
+00458                                                                                          &rIt->Interp, sizeof(CVectInfo) );                             
+00459                                         // project each position now
+00460                                         do
+00461                                         {                                       
+00462                                                 MakeProj(rIt->Proj, mat * rIt->Interp); 
+00463                                                 ++rIt;                          
+00464                                         }
+00465                                         while (rIt != rItEnd);                  
+00466                                 }
+00467 
+00468                                 rIt = currRibbon.begin();
+00469 
+00470                 
+00471                                 // setup colors
+00472                                 if (_ColorScheme)
+00473                                 {
+00474                                         uint8 *currColVertex = currVert + colorOffset;
+00475                                         uint colCount = (_UsedNbSegs + 1) << 1;
+00476                                         do
+00477                                         {
+00478                                                 * (CRGBA *) currColVertex = *ptCurrColor;
+00479                                                 currColVertex += vertexSize;
+00480                                         }
+00481                                         while (--colCount);
+00482 
+00483                                         ++ptCurrColor;                  
+00484                                 }
+00485 
+00487                                 // deals with first point                               
+00488                                 BuildSlice(mat, VB, currVert, vertexSize, I, K, rIt, rIt, rIt + 1, *ptCurrSize);                                
+00489                                 currVert += vertexSizeX2;               
+00490                                 ++rIt;
+00491 
+00492                                 
+00493                                 // deals with other points                              
+00494                                 for (;;) // we assume at least 2 segments, so we must have a middle point               
+00495                                 {                                               
+00496                                         // build 2 vertices with the right tangent. /* to project 2 */ is old projected point
+00497                                         BuildSlice(mat, VB, currVert, vertexSize, I, K, rIt, rIt - 1, rIt + 1, *ptCurrSize); 
+00498                                         // next position                
+00499                                         ++rIt;
+00500                                         if (rIt == rItEndMinusOne) break;                                       
+00501                                         // next vertex                  
+00502                                         currVert += vertexSizeX2;               
+00503                                 }
+00504                                 currVert += vertexSizeX2;
+00505                                 // last point.
+00506                                 BuildSlice(mat, VB, currVert, vertexSize, I, K, rIt , rIt - 1, rIt, *ptCurrSize);                                                                               
+00507                                 ptCurrSize += ptCurrSizeIncrement;
+00508                                 currVert += vertexSizeX2;
+00509 
+00510                                 fpRibbonIndex += srcStep;
+00511                                 
+00512                 }
+00513                 
+00514 
+00515                 PB.setNumTri((_UsedNbSegs << 1) * toProcess);
+00516                 // display the result
+00517                 drv->render(PB, _Mat);
+00518                 ribbonIndex += toProcess;               
+00519         }
+00520         while (ribbonIndex != nbRibbons);
+00521 }       
+
+

+ + + + +
+ + + + + + + + + + +
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; }
+
+

+ + + + +
+ + + + + + + + + + +
virtual void NL3D::CPSParticle::draw bool  opaque  )  [inline, virtual, inherited]
+
+ + + + + +
+   + + +

+derivers draw the particles here +

+ +

+Reimplemented in NL3D::CPSDot, NL3D::CPSFaceLookAt, NL3D::CPSFanLight, and NL3D::CPSShockWave. +

+Definition at line 110 of file ps_particle_basic.h. +

+Referenced by NL3D::CPSParticle::step(). +

+

00110 {}
+
+

+ + + + +
+ + + + + + + + + + +
void NL3D::CPSParticle::enableGlobalColorLighting bool  enabled  )  [inline, inherited]
+
+ + + + + +
+   + + +

+ +

+Definition at line 105 of file ps_particle_basic.h. +

+References NL3D::CPSParticle::_UsesGlobalColorLighting. +

+

00105 { _UsesGlobalColorLighting = enabled; }         
+
+

+ + + + +
+ + + + + + + + + + +
void NL3D::CPSMaterial::enableZTest bool  enabled  )  [inherited]
+
+ + + + + +
+   + + +

+=================================================================================== +

+ +

+Definition at line 508 of file ps_particle_basic.cpp. +

+References NL3D::CMaterial::setZFunc(). +

+

00509 {
+00510         _Mat.setZFunc(enabled ? CMaterial::less : CMaterial::always);
+00511 }
+
+

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

+ +

+Reimplemented from NL3D::CPSLocatedBindable. +

+Definition at line 600 of file ps_ribbon_look_at.cpp. +

+

00601 {
+00602         if (_Tex) 
+00603         {
+00604                 dest.push_back(_Tex);
+00605                 _Tex->getShareName();
+00606         }
+00607 }
+
+

+ + + + +
+ + + + + + + + + + +
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 }       
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
void NL3D::CPSMaterial::forceModulateConstantColor bool  force,
const NLMISC::CRGBA col = NLMISC::CRGBA::White
[inherited]
+
+ + + + + +
+   + + +

+=================================================================================== +

+Force the material to have one texture that is modulated by diffuse, and a constant color and its diffuse color. This is not compatible with multitextureing, however.

Parameters:
+ + +
force true to force constant color modulation
+
+ +

+Definition at line 573 of file ps_particle_basic.cpp. +

+References NL3D::CPSMaterial::forceTexturedMaterialStages(), NL3D::CMaterial::getTexture(), NL3D::CMaterial::setTexture(), NL3D::CMaterial::texConstantColor(), NL3D::CMaterial::texEnvArg0Alpha(), NL3D::CMaterial::texEnvArg0RGB(), NL3D::CMaterial::texEnvArg1Alpha(), NL3D::CMaterial::texEnvArg1RGB(), NL3D::CMaterial::texEnvOpAlpha(), and NL3D::CMaterial::texEnvOpRGB(). +

+Referenced by displayRibbons(), NL3D::CPSShockWave::draw(), and NL3D::CPSQuad::updateMatBeforeRendering(). +

+

00574 {
+00575         if (force)
+00576         {
+00578                 _Mat.texConstantColor(1, col);
+00579                 _Mat.texEnvOpRGB(1, CMaterial::Modulate);
+00580                 _Mat.texEnvOpAlpha(1, CMaterial::Modulate);
+00581                 _Mat.texEnvArg0RGB(1, CMaterial::Previous, CMaterial::SrcColor);
+00582                 _Mat.texEnvArg1RGB(1, CMaterial::Constant, CMaterial::SrcColor);
+00583                 _Mat.texEnvArg0Alpha(1, CMaterial::Previous, CMaterial::SrcAlpha);
+00584                 _Mat.texEnvArg1Alpha(1, CMaterial::Constant, CMaterial::SrcAlpha);
+00585                 forceTexturedMaterialStages(2);
+00586         }
+00587         else
+00588         {               
+00589                 if (_Mat.getTexture(1) != NULL)
+00590                 {
+00591                         _Mat.setTexture(1, NULL);
+00592                 }
+00593         }
+00594 }
+
+

+ + + + +
+ + + + + + + + + + +
void NL3D::CPSMaterial::forceTexturedMaterialStages uint  numStages  )  [inherited]
+
+ + + + + +
+   + + +

+=================================================================================== +

+This setup n stage of a material with at least texture.

    +
  • If a texture was present for a given stage it still is
  • If a texture wasn't present, it create a dummy white texture there
  • Above numStages, textures are disabled. It can be used to do extra math with stages that have no textures (required by the driver)
+ +

+Definition at line 598 of file ps_particle_basic.cpp. +

+References NL3D::CMaterial::getTexture(), NL3D::IDRV_MAT_MAXTEXTURES, NL3D::CMaterial::setTexture(), and uint. +

+Referenced by NL3D::CPSDot::draw(), NL3D::CPSMaterial::forceModulateConstantColor(), and NL3D::CPSFanLight::setupMaterial(). +

+

00599 {
+00600         ITexture *blankTex = NULL;
+00601         uint k;
+00602         for (k = 0; k < numStages; ++k)
+00603         {
+00604                 if (_Mat.getTexture(k) == NULL)
+00605                 {
+00606                         if (!blankTex)
+00607                         {
+00608                                 blankTex = CTextureMem::Create1x1WhiteTex();
+00609                         }
+00610                         _Mat.setTexture(k, blankTex);
+00611                 }
+00612         }
+00613         for (; k < IDRV_MAT_MAXTEXTURES; ++k)
+00614         {
+00615                 if (_Mat.getTexture(k) != NULL)
+00616                 {
+00617                         _Mat.setTexture(k, NULL);
+00618                 }               
+00619         }
+00620 }
+
+

+ + + + +
+ + + + + + + + + + +
CPSMaterial::TBlendingMode NL3D::CPSMaterial::getBlendingMode void   )  const [inherited]
+
+ + + + + +
+   + + +

+=================================================================================== +

+ +

+Definition at line 551 of file ps_particle_basic.cpp. +

+References NL3D::CPSMaterial::alphaBlend, NL3D::CPSMaterial::alphaTest, NL3D::CMaterial::getBlend(), NL3D::CMaterial::getDstBlend(), NL3D::CMaterial::getSrcBlend(), and nlassert. +

+Referenced by NL3D::CPSTailDot::hasTransparentFaces(), NL3D::CPSShockWave::hasTransparentFaces(), hasTransparentFaces(), NL3D::CPSRibbon::hasTransparentFaces(), NL3D::CPSQuad::hasTransparentFaces(), NL3D::CPSFanLight::hasTransparentFaces(), and NL3D::CPSDot::hasTransparentFaces(). +

+

00552 {
+00553         if (_Mat.getBlend())
+00554         {
+00555                 CMaterial::TBlend srcBlend = _Mat.getSrcBlend();        
+00556                 CMaterial::TBlend destBlend = _Mat.getDstBlend();
+00557 
+00558                 if (srcBlend == CMaterial::one && destBlend == CMaterial::one) return add;
+00559                 if (srcBlend == CMaterial::zero && destBlend == CMaterial::srccolor) return modulate;
+00560                 if (srcBlend == CMaterial::srcalpha && destBlend == CMaterial::invsrcalpha) return alphaBlend;
+00561 
+00562                 // unrecognized mode
+00563                 nlassert(0);
+00564                 return alphaTest; // to avoid a warning only ...
+00565         }
+00566         else
+00567         {
+00568                 return alphaTest;
+00569         }
+00570 }
+
+

+ + + + +
+ + + + + + + + + +
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::CRGBA NL3D::CPSColoredParticle::getColor void   )  const [inline, inherited]
+
+ + + + + +
+   + + +

+Get the color. +

+ +

+Definition at line 211 of file ps_particle_basic.h. +

+

00211 { return _Color; }
+
+

+ + + + +
+ + + + + + + + + + +
virtual bool NL3D::CPSRibbonLookAt::getColorFading void   )  const [inline, virtual]
+
+ + + + + +
+   + + +

+Test wether color fading is activated. NOT SUPPORTED FOR NOW +

+Implements NL3D::CPSTailParticle. +

+Definition at line 77 of file ps_ribbon_look_at.h. +

+

00077 { return false; }
+
+

+ + + + +
+ + + + + + + + + + +
virtual CPSLocated* NL3D::CPSRibbonLookAt::getColorOwner void   )  [inline, protected, virtual]
+
+ + + + + +
+   + + +

+deriver must return their owner there +

+ +

+Implements NL3D::CPSColoredParticle. +

+Definition at line 132 of file ps_ribbon_look_at.h. +

+

00132 { return _Owner; }      
+
+

+ + + + +
+ + + + + + + + + + +
const CPSAttribMaker<CRGBA>* NL3D::CPSColoredParticle::getColorScheme void   )  const [inline, inherited]
+
+ + + + + +
+   + + +

+get the color scheme (NULL if none) const version +

+ +

+Definition at line 205 of file ps_particle_basic.h. +

+

00205 { return _ColorScheme; }
+
+

+ + + + +
+ + + + + + + + + + +
CPSAttribMaker<CRGBA>* NL3D::CPSColoredParticle::getColorScheme void   )  [inline, inherited]
+
+ + + + + +
+   + + +

+get the color scheme (NULL if none) +

+ +

+Definition at line 202 of file ps_particle_basic.h. +

+

00202 { return _ColorScheme; }
+
+

+ + + + +
+ + + + + + + + + + +
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(), 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          }              
+
+

+ + + + +
+ + + + + + + + + + +
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 }
+
+

+ + + + +
+ + + + + + + + + +
TInterpolationMode NL3D::CPSRibbonBase::getInterpolationMode  )  const [inline, inherited]
+
+ + + + + +
+   + + +

+ +

+Definition at line 64 of file ps_ribbon_base.h. +

+References NL3D::CPSRibbonBase::_InterpolationMode, and NL3D::CPSRibbonBase::TInterpolationMode. +

+

00064 { return _InterpolationMode; }
+
+

+ + + + +
+ + + + + + + + + + +
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 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; }
+
+

+ + + + +
+ + + + + + + + + +
float NL3D::CPSRibbonBase::getLODDegradation  )  const [inline, inherited]
+
+ + + + + +
+   + + +

+ +

+Definition at line 95 of file ps_ribbon_base.h. +

+

00095 { return _LODDegradation; }
+
+

+ + + + +
+ + + + + + + + + + +
uint32 NL3D::CPSRibbonLookAt::getMaxNumFaces void   )  const [virtual]
+
+ + + + + +
+   + + +

+return the max number of faces needed for display. This is needed for LOD balancing +

+ +

+Implements NL3D::CPSParticle. +

+Definition at line 537 of file ps_ribbon_look_at.cpp. +

+References NL3D::CPSLocated::getMaxSize(), nlassert, and uint32. +

+

00538 {
+00539         nlassert(_Owner);
+00540         return _Owner->getMaxSize() * _NbSegs * 2;      
+00541 }
+
+

+ + + + +
+ + + + + + + + + + +
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; }       
+
+

+ + + + +
+ + + + + + + + + +
uint NL3D::CPSRibbonLookAt::getNumRibbonsInVB  )  const [private]
+
+ + + + + +
+   + + +

+get the number of ribbons contained in a vb for a given length. (e.g the number of ribbons that can be batched) +

+approximation of the max number of vertices we want in a vb +

+Definition at line 592 of file ps_ribbon_look_at.cpp. +

+References uint. +

+Referenced by displayRibbons(), and getVBnPB(). +

+

00593 {
+00595         const uint vertexInVB = 256;    
+00596         return std::max(1u, (uint) (vertexInVB / (_UsedNbSegs + 1)));
+00597 }
+
+

+ + + + +
+ + + + + + + + + + +
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; }
+
+

+ + + + +
+ + + + + + + + + + +
virtual uint32 NL3D::CPSParticle::getPriority void   )  const [inline, virtual, inherited]
+
+ + + + + +
+   + + +

+return priority +

+ +

+Implements NL3D::CPSLocatedBindable. +

+Definition at line 66 of file ps_particle_basic.h. +

+References uint32. +

+

00066 { return 1000; }
+
+

+ + + + +
+ + + + + + + + + +
uint32 NL3D::CPSRibbonBase::getRibbonIndex  )  const [inline, protected, inherited]
+
+ + + + + +
+   + + +

+ +

+Definition at line 131 of file ps_ribbon_base.h. +

+References NL3D::CPSRibbonBase::_RibbonIndex, and uint32. +

+

00131 { return _RibbonIndex; }
+
+

+ + + + +
+ + + + + + + + + +
float NL3D::CPSRibbonBase::getRibbonLength  )  const [inline, inherited]
+
+ + + + + +
+   + + +

+ +

+Definition at line 84 of file ps_ribbon_base.h. +

+References NL3D::CPSRibbonBase::_RibbonLength. +

+

00084 { return _RibbonLength; }
+
+

+ + + + +
+ + + + + + + + + +
TRibbonMode NL3D::CPSRibbonBase::getRibbonMode  )  const [inline, inherited]
+
+ + + + + +
+   + + +

+ +

+Definition at line 62 of file ps_ribbon_base.h. +

+References NL3D::CPSRibbonBase::_RibbonMode, and NL3D::CPSRibbonBase::TRibbonMode. +

+

00062 { return _RibbonMode; }
+
+

+ + + + +
+ + + + + + + + + +
const TFloatVect& NL3D::CPSRibbonBase::getSamplingDate  )  const [inline, protected, inherited]
+
+ + + + + +
+   + + +

+ +

+Definition at line 133 of file ps_ribbon_base.h. +

+References NL3D::CPSRibbonBase::_SamplingDate, and NL3D::CPSRibbonBase::TFloatVect. +

+

00133 { return _SamplingDate; }       
+
+

+ + + + +
+ + + + + + + + + + +
TAnimationTime NL3D::CPSRibbonBase::getSegDuration void   )  const [inline, inherited]
+
+ + + + + +
+   + + +

+ +

+Definition at line 77 of file ps_ribbon_base.h. +

+References NL3D::CPSRibbonBase::_SegDuration, and NL3D::TAnimationTime. +

+

00077 { return _SegDuration; }
+
+

+ + + + +
+ + + + + + + + + + +
float NL3D::CPSSizedParticle::getSize void   )  const [inline, inherited]
+
+ + + + + +
+   + + +

+get the constant size +

+ +

+Definition at line 274 of file ps_particle_basic.h. +

+References NL3D::CPSSizedParticle::_ParticleSize. +

+Referenced by NL3D::CPSFaceLookAtHelper::drawLookAt(), NL3D::CPSFaceLookAtHelper::drawLookAtAlignOnMotion(), NL3D::CPSSizedParticle::resizeSize(), and NL3D::CPSSizedParticle::setSizeScheme(). +

+

00274 { return _ParticleSize; }
+
+

+ + + + +
+ + + + + + + + + + +
virtual CPSLocated* NL3D::CPSRibbonLookAt::getSizeOwner void   )  [inline, protected, virtual]
+
+ + + + + +
+   + + +

+deriver must return their owner there +

+ +

+Implements NL3D::CPSSizedParticle. +

+Definition at line 131 of file ps_ribbon_look_at.h. +

+

00131 { return _Owner; }
+
+

+ + + + +
+ + + + + + + + + + +
const CPSAttribMaker<float>* NL3D::CPSSizedParticle::getSizeScheme void   )  const [inline, inherited]
+
+ + + + + +
+   + + +

+get the size scheme (NULL if none) const version +

+ +

+Definition at line 268 of file ps_particle_basic.h. +

+References NL3D::CPSSizedParticle::_SizeScheme. +

+

00268 { return _SizeScheme; }
+
+

+ + + + +
+ + + + + + + + + + +
CPSAttribMaker<float>* NL3D::CPSSizedParticle::getSizeScheme void   )  [inline, inherited]
+
+ + + + + +
+   + + +

+get the size scheme (NULL if none) +

+ +

+Definition at line 265 of file ps_particle_basic.h. +

+References NL3D::CPSSizedParticle::_SizeScheme. +

+Referenced by NL3D::CPSFaceLookAtHelper::drawLookAt(), and NL3D::CPSFaceLookAtHelper::drawLookAtAlignOnMotion(). +

+

00265 { return _SizeScheme; }
+
+

+ + + + +
+ + + + + + + + + + +
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::CPSRibbonBase::getTailNbSeg void   )  const [inline, virtual, inherited]
+
+ + + + + +
+   + + +

+get the number of segments used with this particle +

+ +

+Implements NL3D::CPSTailParticle. +

+Definition at line 72 of file ps_ribbon_base.h. +

+References NL3D::CPSRibbonBase::_NbSegs, and uint32. +

+

00072 { return _NbSegs; }
+
+

+ + + + +
+ + + + + + + + + + +
const ITexture* NL3D::CPSRibbonLookAt::getTexture void   )  const [inline, virtual]
+
+ + + + + +
+   + + +

+ +

+Implements NL3D::CPSTexturedParticleNoAnim. +

+Definition at line 63 of file ps_ribbon_look_at.h. +

+

00063 { return _Tex;}
+
+

+ + + + +
+ + + + + + + + + + +
ITexture* NL3D::CPSRibbonLookAt::getTexture void   )  [inline, virtual]
+
+ + + + + +
+   + + +

+get the texture used for this particle +

+ +

+Implements NL3D::CPSTexturedParticleNoAnim. +

+Definition at line 62 of file ps_ribbon_look_at.h. +

+

00062 { return _Tex;}
+
+

+ + + + +
+ + + + + + + + + + +
uint32 NL3D::CPSParticle::getType void   )  const [inline, virtual, inherited]
+
+ + + + + +
+   + + +

+return this bindable type +

+ +

+Implements NL3D::CPSLocatedBindable. +

+Definition at line 63 of file ps_particle_basic.h. +

+References NL3D::PSParticle, and uint32. +

+

00063 { return PSParticle; }
+
+

+ + + + +
+ + + + + + + + + +
virtual bool NL3D::CPSLocatedBindable::getUserMatrixUsageCount  )  const [inline, virtual, inherited]
+
+ + + + + +
+   + + +

+ +

+Reimplemented in NL3D::CPSEmitter. +

+Definition at line 974 of file ps_located.h. +

+Referenced by NL3D::CPSLocatedBindable::finalize(), and NL3D::CPSLocatedBindable::setOwner(). +

+

00974 { return 0; }
+
+

+ + + + +
+ + + + + + + + + +
CPSRibbonLookAt::CVBnPB & NL3D::CPSRibbonLookAt::getVBnPB  )  [private]
+
+ + + + + +
+   + + +

+get a vertex buffer and a primitive suited for the current ribbon +

+set the vb format & size

+Setup the pb and vb parts. Not very fast but executed only once

+top vertex

+bottom vertex

+add 2 tri in the primitive block +

+Definition at line 546 of file ps_ribbon_look_at.cpp. +

+References getNumRibbonsInVB(), NL3D::CPSRibbonLookAt::CVBnPB::PB, NL3D::CPrimitiveBlock::setNumTri(), NL3D::CVertexBuffer::setNumVertices(), NL3D::CVertexBuffer::setTexCoord(), NL3D::CPrimitiveBlock::setTri(), NL3D::CVertexBuffer::setVertexFormat(), uint, and NL3D::CPSRibbonLookAt::CVBnPB::VB. +

+Referenced by displayRibbons(). +

+

00547 {
+00548         TVBMap &map = _ColorScheme ? _VBMap : _ColoredVBMap;    
+00549         TVBMap::iterator it = map.find(_UsedNbSegs + 1);
+00550         if (it != map.end())
+00551         {
+00552                 return it->second;
+00553         }
+00554         else    // must create this vb
+00555         {
+00556                 const uint numRibbonInVB = getNumRibbonsInVB();
+00557                 CVBnPB &VBnPB = map[_UsedNbSegs + 1]; // make an entry
+00558 
+00560                 CVertexBuffer &vb = VBnPB.VB;
+00561                 vb.setVertexFormat(CVertexBuffer::PositionFlag |
+00562                                                    CVertexBuffer::TexCoord0Flag | 
+00563                                                    (_ColorScheme ? CVertexBuffer::PrimaryColorFlag : 0));
+00564                 vb.setNumVertices(2 * (_UsedNbSegs + 1) * numRibbonInVB );
+00565 
+00566                 // set the primitive block size
+00567                 CPrimitiveBlock &pb = VBnPB.PB;
+00568                 pb.setNumTri((_UsedNbSegs << 1) * numRibbonInVB);
+00570                 uint vbIndex = 0;
+00571                 uint pbIndex = 0; 
+00572                 for (uint i = 0; i < numRibbonInVB; ++i)
+00573                 {
+00574                         for (uint k = 0; k < (_UsedNbSegs + 1); ++k)
+00575                         {                               
+00576                                 vb.setTexCoord(vbIndex, 0, CUV((1.f - k / (float) _UsedNbSegs), 0)); 
+00577                                 vb.setTexCoord(vbIndex + 1, 0, CUV((1.f - k / (float) _UsedNbSegs), 1)); 
+00578                                 if (k != _UsedNbSegs)
+00579                                 {
+00581                                         pb.setTri(pbIndex ++, vbIndex + 1, vbIndex + 2, vbIndex);
+00582                                         pb.setTri(pbIndex ++, vbIndex + 1, vbIndex + 3, vbIndex + 2);
+00583                                 }
+00584                                 vbIndex += 2;
+00585                         }
+00586                 }
+00587                 return VBnPB;
+00588         }
+00589 }
+
+

+ + + + +
+ + + + + + + + + + +
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 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::CPSRibbonLookAt::hasLightableFaces  )  [inline, virtual]
+
+ + + + + +
+   + + +

+from CPSParticle : return true if there are lightable faces in the object +

+ +

+Implements NL3D::CPSParticle. +

+Definition at line 109 of file ps_ribbon_look_at.h. +

+

00109 {       return false; }
+
+

+ + + + +
+ + + + + + + + + + +
bool NL3D::CPSRibbonLookAt::hasOpaqueFaces void   )  [virtual]
+
+ + + + + +
+   + + +

+return true if there are Opaque faces in the object +

+ +

+Implements NL3D::CPSParticle. +

+Definition at line 531 of file ps_ribbon_look_at.cpp. +

+References hasTransparentFaces(). +

+Referenced by step(). +

+

00532 {
+00533         return !hasTransparentFaces();
+00534 }
+
+

+ + + + +
+ + + + + + + + + + +
virtual bool NL3D::CPSParticle::hasParticles void   )  const [inline, virtual, inherited]
+
+ + + + + +
+   + + +

+return true if this located bindable derived class holds alive particles +

+ +

+Reimplemented from NL3D::CPSLocatedBindable. +

+Definition at line 69 of file ps_particle_basic.h. +

+References NL3D::CPSLocated::getSize(), and nlassert. +

+

00069 { nlassert(_Owner); return _Owner->getSize() != 0; }
+
+

+ + + + +
+ + + + + + + + + + +
bool NL3D::CPSRibbonLookAt::hasTransparentFaces void   )  [virtual]
+
+ + + + + +
+   + + +

+return true if there are transparent faces in the object +

+ +

+Implements NL3D::CPSParticle. +

+Definition at line 524 of file ps_ribbon_look_at.cpp. +

+References NL3D::CPSMaterial::getBlendingMode(). +

+Referenced by hasOpaqueFaces(), and step(). +

+

00525 {
+00526         return getBlendingMode() != CPSMaterial::alphaTest ;
+00527 }
+
+

+ + + + +
+ + + + + + + + + +
void NL3D::CPSRibbonBase::initDateVect  )  [protected, inherited]
+
+ + + + + +
+   + + +

+ +

+Definition at line 568 of file ps_ribbon_base.cpp. +

+References NL3D::CPSRibbonBase::_NbSegs, NL3D::CPSRibbonBase::_SamplingDate, and NL3D::EndRibbonStorage. +

+Referenced by NL3D::CPSRibbonBase::CPSRibbonBase(), NL3D::CPSRibbonBase::motionTypeChanged(), and NL3D::CPSRibbonBase::setTailNbSeg(). +

+

00569 {
+00570         _SamplingDate.resize( _NbSegs + 1 + EndRibbonStorage);
+00571         std::fill(_SamplingDate.begin(), _SamplingDate.begin() + (_NbSegs + 1 + EndRibbonStorage), 0.f);
+00572 }
+
+

+ + + + +
+ + + + + + + + + +
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::CPSParticle::isAutoLODDisabled  )  const [inline, inherited]
+
+ + + + + +
+   + + +

+Test wether Auto-LOD is disabled. +

+ +

+Definition at line 140 of file ps_particle_basic.h. +

+References NL3D::CPSParticle::_DisableAutoLOD. +

+

00140 { return _DisableAutoLOD; }     
+
+

+ + + + +
+ + + + + + + + + + +
virtual bool NL3D::CPSRibbonLookAt::isInSystemBasis void   )  const [inline, virtual]
+
+ + + + + +
+   + + +

+return true if the tails are in the system basis +

+ +

+Implements NL3D::CPSTailParticle. +

+Definition at line 86 of file ps_ribbon_look_at.h. +

+

00086 { return true; }
+
+

+ + + + +
+ + + + + + + + + +
bool NL3D::CPSMaterial::isZTestEnabled  )  const [inherited]
+
+ + + + + +
+   + + +

+=================================================================================== +

+ +

+Definition at line 514 of file ps_particle_basic.cpp. +

+References NL3D::CMaterial::getZFunc(). +

+

00515 {
+00516         return _Mat.getZFunc() != CMaterial::always;
+00517 }
+
+

+ + + + +
+ + + + + + + + + + +
void NL3D::CPSRibbonBase::motionTypeChanged bool  parametric  )  [protected, virtual, inherited]
+
+ + + + + +
+   + + +

+called when the motion type has changed, this allow us to draw smoother ribbons when parametric anim is used +

+ +

+Reimplemented from NL3D::CPSLocatedBindable. +

+Definition at line 550 of file ps_ribbon_base.cpp. +

+References NL3D::CPSRibbonBase::_Parametric, NL3D::CPSRibbonBase::_Ribbons, NLMISC::contReset(), NL3D::CPSLocated::getMaxSize(), NL3D::CPSRibbonBase::initDateVect(), nlassert, NL3D::CPSRibbonBase::resetFromOwner(), and NL3D::CPSRibbonBase::resize(). +

+

00551 {
+00552         _Parametric = parametric;
+00553         if (parametric)
+00554         {
+00555                 NLMISC::contReset(_Ribbons); // kill the vector         
+00556         }
+00557         else
+00558         {
+00559                 nlassert(_Owner);
+00560                 resize(_Owner->getMaxSize());
+00561                 initDateVect();         
+00562                 resetFromOwner();               
+00563         }       
+00564 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
void NL3D::CPSColoredParticle::newColorElement CPSLocated emitterLocated,
uint32  emitterIndex
[inline, protected, inherited]
+
+ + + + + +
+   + + +

+ +

+Definition at line 233 of file ps_particle_basic.h. +

+References NL3D::CPSAttribMaker< CRGBA >::hasMemory(), NL3D::CPSAttribMaker< CRGBA >::newElement(), and uint32. +

+Referenced by NL3D::CPSTailDot::newElement(), NL3D::CPSShockWave::newElement(), newElement(), NL3D::CPSRibbon::newElement(), NL3D::CPSQuad::newElement(), NL3D::CPSConstraintMesh::newElement(), NL3D::CPSFanLight::newElement(), and NL3D::CPSDot::newElement(). +

+

00234                 {
+00235                         if (_ColorScheme && _ColorScheme->hasMemory()) _ColorScheme->newElement(emitterLocated, emitterIndex);
+00236                 }       
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
void NL3D::CPSRibbonLookAt::newElement CPSLocated emitterLocated,
uint32  emitterIndex
[protected, virtual]
+
+ + + + + +
+   + + +

+inherited from CPSLocatedBindable +

+ +

+Reimplemented from NL3D::CPSRibbonBase. +

+Definition at line 163 of file ps_ribbon_look_at.cpp. +

+References NL3D::CPSColoredParticle::newColorElement(), NL3D::CPSSizedParticle::newSizeElement(), and uint32. +

+

00164 {
+00165         CPSRibbonBase::newElement(emitterLocated, emitterIndex);
+00166         newColorElement(emitterLocated, emitterIndex);
+00167         newSizeElement(emitterLocated, emitterIndex);   
+00168 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
void NL3D::CPSSizedParticle::newSizeElement CPSLocated emitterLocated,
uint32  emitterIndex
[inline, protected, inherited]
+
+ + + + + +
+   + + +

+ +

+Definition at line 291 of file ps_particle_basic.h. +

+References NL3D::CPSSizedParticle::_SizeScheme, NL3D::CPSAttribMaker< float >::hasMemory(), NL3D::CPSAttribMaker< float >::newElement(), and uint32. +

+Referenced by NL3D::CPSShockWave::newElement(), newElement(), NL3D::CPSRibbon::newElement(), NL3D::CPSQuad::newElement(), NL3D::CPSConstraintMesh::newElement(), NL3D::CPSMesh::newElement(), and NL3D::CPSFanLight::newElement(). +

+

00292                 {
+00293                         if (_SizeScheme && _SizeScheme->hasMemory()) _SizeScheme->newElement(emitterLocated, emitterIndex);
+00294                 }       
+
+

+ + + + +
+ + + + + + + + + + +
NL3D::CPSRibbonLookAt::NLMISC_DECLARE_CLASS CPSRibbonLookAt   ) 
+
+ + + + + +
+   + + +

+ctor +

+

+

+ + + + +
+ + + + + + + + + + +
void NL3D::CPSParticle::notifyOwnerMaxNumFacesChanged void   )  const [inline, protected, inherited]
+
+ + + + + +
+   + + +

+Shortcut to notify that the max number of faces has changed This must be called when a geometric property of the particle has been modified This needn't to be called during CPSParticle::resize overrides +

+Definition at line 151 of file ps_particle_basic.h. +

+References NL3D::CPSLocated::notifyMaxNumFacesChanged(). +

+Referenced by NL3D::CPSFanLight::setNbFans(), NL3D::CPSShockWave::setNbSegs(), and NL3D::CPSConstraintMesh::update(). +

+

00152         {
+00153                 if (_Owner)
+00154                 {
+00155                         _Owner->notifyMaxNumFacesChanged();
+00156                 }
+00157         }
+
+

+ + + + +
+ + + + + + + + + + +
void NL3D::CPSLocatedBindable::notifyTargetRemoved CPSLocated ptr  )  [virtual, inherited]
+
+ + + + + +
+   + + +

+*************************************************************************************** +

+Can be used by located bindable that have located as targets (emitter, collision zone, forces) to be notified that one of their target has been removed. To do this : The object that focus the target must call registerDTorObserver on the target, with himself as a parameter When the target is removed, this target will call this method for all registered CPSLocated The default behaviour remove this object as an observer

+

See also:
CPSLocated::registerDTorObserver()
+ +

+Reimplemented in NL3D::CPSEmitter, and NL3D::CPSTargetLocatedBindable. +

+Definition at line 1996 of file ps_located.cpp. +

+References NL3D::CPSLocated::unregisterDtorObserver(). +

+Referenced by NL3D::CPSLocated::releaseRefTo(). +

+

01997 {
+01998         ptr->unregisterDtorObserver(this);
+01999 }
+
+

+ + + + +
+ + + + + + + + + +
void NL3D::CPSLocatedBindable::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 in NL3D::CPSEmitter, NL3D::CPSLight, NL3D::CPSTargetLocatedBindable, and NL3D::CPSMesh. +

+Definition at line 2170 of file ps_located.cpp. +

+Referenced by NL3D::CPSLocatedBindable::setOwner(). +

+

02171 {
+02172 }
+
+

+ + + + +
+ + + + + + + + + + +
virtual void NL3D::CPSLocatedBindable::releaseRefTo const CParticleSystemProcess other  )  [inline, 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 in NL3D::CPSEmitter, and NL3D::CPSTargetLocatedBindable. +

+Definition at line 871 of file ps_located.h. +

+

00871 {}
+
+

+ + + + +
+ + + + + + + + + +
void NL3D::CPSRibbonBase::resetFromOwner  )  [protected, inherited]
+
+ + + + + +
+   + + +

+ +

+Definition at line 538 of file ps_ribbon_base.cpp. +

+References NL3D::CPSRibbonBase::_Parametric, NL3D::CPSAttrib< T >::begin(), NL3D::CPSAttrib< T >::end(), NL3D::CPSLocated::getPos(), nlassert, NL3D::CPSRibbonBase::resetSingleRibbon(), and uint. +

+Referenced by NL3D::CPSRibbonBase::motionTypeChanged(), and NL3D::CPSRibbonBase::resize(). +

+

00539 {
+00540         nlassert(!_Parametric);
+00541         TPSAttribVector::iterator posIt = _Owner->getPos().begin();
+00542         TPSAttribVector::iterator endPosIt = _Owner->getPos().end();
+00543         for (uint k = 0; posIt != endPosIt; ++posIt, ++k)
+00544         {
+00545                 resetSingleRibbon(k, *posIt);
+00546         }
+00547 }
+
+

+ + + + +
+ + + + + + + + + + +
void NL3D::CPSRibbonLookAt::resize uint32  size  )  [protected, virtual]
+
+ + + + + +
+   + + +

+inherited from CPSLocatedBindable +

+ +

+Reimplemented from NL3D::CPSRibbonBase. +

+Definition at line 181 of file ps_ribbon_look_at.cpp. +

+References nlassert, NL3D::CPSColoredParticle::resizeColor(), NL3D::CPSSizedParticle::resizeSize(), size, and uint32. +

+

00182 {
+00183         nlassert(size < (1 << 16));
+00184         CPSRibbonBase::resize(size);    
+00185         resizeColor(size);
+00186         resizeSize(size);                       
+00187 }
+
+

+ + + + +
+ + + + + + + + + + +
void NL3D::CPSColoredParticle::resizeColor uint32  size  )  [inline, protected, inherited]
+
+ + + + + +
+   + + +

+ +

+Definition at line 241 of file ps_particle_basic.h. +

+References NL3D::CPSColoredParticle::getColorOwner(), NL3D::CPSAttribMaker< CRGBA >::hasMemory(), nlassert, NL3D::CPSAttribMaker< CRGBA >::resize(), size, and uint32. +

+Referenced by NL3D::CPSTailDot::resize(), NL3D::CPSShockWave::resize(), resize(), NL3D::CPSRibbon::resize(), NL3D::CPSQuad::resize(), NL3D::CPSConstraintMesh::resize(), NL3D::CPSFanLight::resize(), and NL3D::CPSDot::resize(). +

+

00242                 {
+00243                         nlassert(size < (1 << 16));
+00244                         if (_ColorScheme && _ColorScheme->hasMemory()) _ColorScheme->resize(size, getColorOwner()->getSize());
+00245                 }
+
+

+ + + + +
+ + + + + + + + + + +
void NL3D::CPSSizedParticle::resizeSize uint32  size  )  [inline, protected, inherited]
+
+ + + + + +
+   + + +

+ +

+Definition at line 299 of file ps_particle_basic.h. +

+References NL3D::CPSSizedParticle::_SizeScheme, NL3D::CPSSizedParticle::getSize(), NL3D::CPSSizedParticle::getSizeOwner(), NL3D::CPSAttribMaker< float >::hasMemory(), nlassert, NL3D::CPSAttribMaker< float >::resize(), size, and uint32. +

+Referenced by NL3D::CPSShockWave::resize(), resize(), NL3D::CPSRibbon::resize(), NL3D::CPSQuad::resize(), NL3D::CPSConstraintMesh::resize(), NL3D::CPSMesh::resize(), and NL3D::CPSFanLight::resize(). +

+

00300                 {
+00301                         nlassert(size < (1 << 16));
+00302                         if (_SizeScheme && _SizeScheme->hasMemory()) _SizeScheme->resize(size, getSizeOwner()->getSize());
+00303                 }
+
+

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

+serialisation. Derivers must override this, and call their parent version +

+ +

+Version 4 : added CPSRibbonBase has a base class instead of CPSParticle +

+Reimplemented from NL3D::CPSRibbonBase. +

+Definition at line 66 of file ps_ribbon_look_at.cpp. +

+References sint, and uint32. +

+

00067 {
+00071         sint ver = f.serialVersion(4);
+00072         if (ver > 3)
+00073         {
+00074                 CPSRibbonBase::serial(f);
+00075         }
+00076         else
+00077         {
+00078                 CPSParticle::serial(f);
+00079         }
+00080         CPSColoredParticle::serialColorScheme(f);       
+00081         CPSSizedParticle::serialSizeScheme(f);          
+00082         serialMaterial(f);
+00083         uint32 dummy = 0; /* _NbDyingRibbons */
+00084         if (ver <= 3)
+00085         {
+00086                 f.serial(_SegDuration, _NbSegs, dummy /*_NbDyingRibbons*/);
+00087         }
+00088         ITexture *tex = NULL;
+00089 
+00090         if (ver > 2)
+00091         {
+00092                 f.serial(_Parametric);
+00093         }
+00094 
+00095 
+00096         if (!f.isReading())
+00097         {               
+00098                 tex = _Tex;
+00099                 f.serialPolyPtr(tex);   
+00100         }
+00101         else
+00102         {               
+00103                 f.serialPolyPtr(tex);
+00104                 setTexture(tex);
+00105                 setTailNbSeg(_NbSegs); // force to build the vb
+00106         }       
+00107 }
+
+

+ + + + +
+ + + + + + + + + + +
void NL3D::CPSColoredParticle::serialColorScheme NLMISC::IStream f  )  throw (NLMISC::EStream) [inherited]
+
+ + + + + +
+   + + +

+serialization. +

+ +

+Definition at line 155 of file ps_particle_basic.cpp. +

+

00156 {       
+00157         f.serialVersion(1);     
+00158         if (f.isReading())
+00159         {
+00160                 if (_ColorScheme)
+00161                 {
+00162                         delete _ColorScheme;
+00163                         _ColorScheme = NULL;
+00164                 }
+00165         }
+00166         bool useColorScheme = _ColorScheme != NULL;
+00167         f.serial(useColorScheme);
+00168         if (useColorScheme)
+00169         {
+00170                 f.serialPolyPtr(_ColorScheme);
+00171         }
+00172         else
+00173         {
+00174                 f.serial(_Color);
+00175         }
+00176 }
+
+

+ + + + +
+ + + + + + + + + + +
void NL3D::CPSMaterial::serialMaterial NLMISC::IStream f  )  throw (NLMISC::EStream) [inherited]
+
+ + + + + +
+   + + +

+=================================================================================== +

+ +

+Definition at line 493 of file ps_particle_basic.cpp. +

+References sint. +

+

00494 {
+00495         sint ver = f.serialVersion(2);  
+00496         TBlendingMode m = getBlendingMode();
+00497         f.serialEnum(m);
+00498         setBlendingMode(m);     
+00499         if (ver >= 2)
+00500         {       
+00501                 bool zTest = isZTestEnabled();
+00502                 f.serial(zTest);
+00503                 enableZTest(zTest);
+00504         }
+00505 }
+
+

+ + + + +
+ + + + + + + + + + +
void NL3D::CPSSizedParticle::serialSizeScheme NLMISC::IStream f  )  throw (NLMISC::EStream) [inherited]
+
+ + + + + +
+   + + +

+serialization. We choose a different name because of multiple-inheritance +

+ +

+Definition at line 211 of file ps_particle_basic.cpp. +

+

00212 {
+00213         f.serialVersion(1);     
+00214         if (f.isReading())
+00215         {
+00216                 if (_SizeScheme)
+00217                 {
+00218                         delete _SizeScheme;
+00219                         _SizeScheme = NULL;
+00220                 }
+00221         }
+00222         bool useSizeScheme = _SizeScheme != NULL;
+00223         f.serial(useSizeScheme);
+00224         if (useSizeScheme)
+00225         {               
+00226                 f.serialPolyPtr(_SizeScheme);
+00227         }
+00228         else
+00229         {
+00230                 f.serial(_ParticleSize);
+00231         }       
+00232 };
+
+

+ + + + +
+ + + + + + + + + + +
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::CPSMaterial::setBlendingMode CPSMaterial::TBlendingMode  mode  )  [inherited]
+
+ + + + + +
+   + + +

+=================================================================================== +

+ +

+Definition at line 520 of file ps_particle_basic.cpp. +

+References NL3D::CPSMaterial::alphaBlend, NL3D::CPSMaterial::alphaTest, NL3D::CMaterial::setAlphaTest(), NL3D::CMaterial::setBlend(), NL3D::CMaterial::setBlendFunc(), and NL3D::CMaterial::setZWrite(). +

+

00521 {
+00522         switch (mode)
+00523         {               
+00524                 case add:
+00525                         _Mat.setBlend(true);
+00526                         _Mat.setBlendFunc(CMaterial::one, CMaterial::one);
+00527                         _Mat.setZWrite(false);
+00528                         _Mat.setAlphaTest(false);
+00529                 break;
+00530                 case modulate:
+00531                         _Mat.setBlend(true);
+00532                         _Mat.setBlendFunc(CMaterial::zero, CMaterial::srccolor);
+00533                         _Mat.setZWrite(false);
+00534                         _Mat.setAlphaTest(false);
+00535                 break;
+00536                 case alphaBlend:
+00537                         _Mat.setBlend(true);
+00538                         _Mat.setBlendFunc(CMaterial::srcalpha, CMaterial::invsrcalpha);
+00539                         _Mat.setZWrite(false);
+00540                         _Mat.setAlphaTest(false);
+00541                 break;
+00542                 case alphaTest:
+00543                         _Mat.setBlend(false);
+00544                         _Mat.setZWrite(true);
+00545                         _Mat.setAlphaTest(true);
+00546                 break;
+00547         }
+00548 }
+
+

+ + + + +
+ + + + + + + + + + +
void NL3D::CPSColoredParticle::setColor NLMISC::CRGBA  col  )  [inherited]
+
+ + + + + +
+   + + +

+Set a constant color for the particles. remove any previous scheme. +

+ +

+Definition at line 135 of file ps_particle_basic.cpp. +

+References NL3D::CPSColoredParticle::updateMatAndVbForColor(). +

+

00136 {       
+00137         delete _ColorScheme;
+00138         _ColorScheme = NULL;
+00139         _Color = col;
+00140         updateMatAndVbForColor();
+00141 }
+
+

+ + + + +
+ + + + + + + + + + +
virtual void NL3D::CPSRibbonLookAt::setColorFading bool  onOff = true  )  [inline, virtual]
+
+ + + + + +
+   + + +

+(de)activate color fading when its done, colors fades to black along the tail. NOT SUPPORTED FOR NOW +

+Implements NL3D::CPSTailParticle. +

+Definition at line 72 of file ps_ribbon_look_at.h. +

+

00072 {}
+
+

+ + + + +
+ + + + + + + + + + +
void NL3D::CPSColoredParticle::setColorScheme CPSAttribMaker< CRGBA > *  col  )  [inherited]
+
+ + + + + +
+   + + +

+Set an attribute maker that produce a color It must have been allocated by new It will be deleted by this object +

+Definition at line 125 of file ps_particle_basic.cpp. +

+References NL3D::CPSColoredParticle::getColorOwner(), nlassert, NL3D::CPSAttribMaker< T >::resize(), and NL3D::CPSColoredParticle::updateMatAndVbForColor(). +

+

00126 {       
+00127         nlassert(col);
+00128         delete _ColorScheme;            
+00129         _ColorScheme = col;
+00130         if (getColorOwner() && col->hasMemory()) col->resize(getColorOwner()->getMaxSize(), getColorOwner()->getSize());
+00131         updateMatAndVbForColor();
+00132 }
+
+

+ + + + +
+ + + + + + + + + + +
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::CPSRibbonBase::setInterpolationMode TInterpolationMode  mode  )  [inherited]
+
+ + + + + +
+   + + +

+ +

+Definition at line 111 of file ps_ribbon_base.cpp. +

+References NL3D::CPSRibbonBase::_InterpolationMode, NL3D::CPSRibbonBase::InterpModeLast, and nlassert. +

+Referenced by NL3D::CPSRibbon::CPSRibbon(), and NL3D::CPSTailDot::CPSTailDot(). +

+

00112 {
+00113         nlassert(mode < InterpModeLast);
+00114         _InterpolationMode = mode;
+00115 }
+
+

+ + + + +
+ + + + + + + + + + +
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; }
+
+

+ + + + +
+ + + + + + + + + + +
void NL3D::CPSRibbonBase::setLODDegradation float  percent  )  [inline, inherited]
+
+ + + + + +
+   + + +

+Allow degradation of ribbons with distance of the system (may not be suited when theit paths have wicked angles)

Parameters:
+ + +
percent 1 mean no degradation, 0 mean nothing will be draw when the system is at its max dist. 1 is the default
+
+ +

+Definition at line 90 of file ps_ribbon_base.h. +

+References nlassert. +

+

00091         { 
+00092                 nlassert(percent >= 0 && percent <= 1);
+00093                 _LODDegradation = percent;
+00094         }
+
+

+ + + + +
+ + + + + + + + + + +
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::CPSLocatedBindable::setOwner CPSLocated psl  )  [protected, virtual, inherited]
+
+ + + + + +
+   + + +

+*************************************************************************************** +

+ +

+Reimplemented in NL3D::CPSEmitter. +

+Definition at line 1948 of file ps_located.cpp. +

+References NL3D::CParticleSystem::addRefForUserSysCoordInfo(), NL3D::CPSLocatedBindable::deleteElement(), NL3D::CParticleSystemProcess::getOwner(), NL3D::CPSLocated::getSize(), NL3D::CPSLocatedBindable::getUserMatrixUsageCount(), NL3D::CPSLocatedBindable::releaseAllRef(), NL3D::CParticleSystem::releaseRefForUserSysCoordInfo(), and uint. +

+Referenced by NL3D::CPSLocated::bind(), and NL3D::CPSLocated::unbind(). +

+

01949 { 
+01950         if (psl == _Owner) return;
+01951         if (psl == NULL)
+01952         {
+01953                 releaseAllRef();
+01954                 if (_Owner)
+01955                 {
+01956                         // empty this located bindable. Need to be empty if it must be rebound to another located.
+01957                         for (uint k = 0; k < _Owner->getSize(); ++k)
+01958                         {
+01959                                 deleteElement(0);
+01960                         }
+01961                 }                               
+01962         }       
+01963         if (_Owner && _Owner->getOwner())
+01964         {
+01965                 _Owner->getOwner()->releaseRefForUserSysCoordInfo(getUserMatrixUsageCount());
+01966         }
+01967         _Owner = psl;
+01968         if (_Owner && _Owner->getOwner())
+01969         {
+01970                 _Owner->getOwner()->addRefForUserSysCoordInfo(getUserMatrixUsageCount());
+01971         } 
+01972 }
+
+

+ + + + +
+ + + + + + + + + + +
void NL3D::CPSRibbonBase::setRibbonLength float  length  )  [inherited]
+
+ + + + + +
+   + + +

+The the length in meter of the ribbon. This is used only if the ribbon mode is set to FixedSize. These kind of ribbon are usually slower than variable size ribbons. The default is one metter. +

+Definition at line 95 of file ps_ribbon_base.cpp. +

+References NL3D::CPSRibbonBase::_NbSegs, NL3D::CPSRibbonBase::_RibbonLength, NL3D::CPSRibbonBase::_SegLength, and nlassert. +

+

00096 { 
+00097         nlassert(length > 0.f);
+00098         _RibbonLength = length;
+00099         _SegLength = length / _NbSegs;
+00100 }
+
+

+ + + + +
+ + + + + + + + + + +
void NL3D::CPSRibbonBase::setRibbonMode TRibbonMode  mode  )  [inherited]
+
+ + + + + +
+   + + +

+NB : a fixed size isn't applied with parametric motion. +

+ +

+Definition at line 103 of file ps_ribbon_base.cpp. +

+References NL3D::CPSRibbonBase::_RibbonMode, nlassert, and NL3D::CPSRibbonBase::RibbonModeLast. +

+

00104 {
+00105         nlassert(mode < RibbonModeLast);
+00106         _RibbonMode = mode;
+00107 }
+
+

+ + + + +
+ + + + + + + + + + +
void NL3D::CPSRibbonBase::setSegDuration TAnimationTime  ellapsedTime  )  [inherited]
+
+ + + + + +
+   + + +

+Set how many seconds need a seg to be traversed. Long times will create longer ribbons. Default is 0.02. It gives the sampling rate for each type of ribbon +

+Definition at line 132 of file ps_ribbon_base.cpp. +

+References NL3D::CPSRibbonBase::_SegDuration, and NL3D::TAnimationTime. +

+Referenced by NL3D::CPSRibbon::CPSRibbon(), and NL3D::CPSTailDot::CPSTailDot(). +

+

00133 {
+00134         _SegDuration = ellapsedTime;
+00135 
+00136 }
+
+

+ + + + +
+ + + + + + + + + + +
void NL3D::CPSSizedParticle::setSize float  size  )  [inherited]
+
+ + + + + +
+   + + +

+Set a constant size for the particles. +

+ +

+Definition at line 192 of file ps_particle_basic.cpp. +

+References NL3D::CPSSizedParticle::_ParticleSize, NL3D::CPSSizedParticle::_SizeScheme, and size. +

+

00193 {       
+00194         delete _SizeScheme;
+00195         _SizeScheme = NULL;     
+00196         _ParticleSize = size;
+00197 }
+
+

+ + + + +
+ + + + + + + + + + +
void NL3D::CPSSizedParticle::setSizeScheme CPSAttribMaker< float > *  size  )  [inherited]
+
+ + + + + +
+   + + +

+Set an attribute maker that produce a size It must have been allocated by new It will be deleted by this object +

+Definition at line 183 of file ps_particle_basic.cpp. +

+References NL3D::CPSSizedParticle::_SizeScheme, NL3D::CPSSizedParticle::getSize(), NL3D::CPSSizedParticle::getSizeOwner(), nlassert, and size. +

+

00184 {       
+00185         nlassert(size != NULL);
+00186         delete _SizeScheme;     
+00187         _SizeScheme = size;
+00188         if (getSizeOwner() && size->hasMemory()) size->resize(getSizeOwner()->getMaxSize(), getSizeOwner()->getSize());
+00189 }
+
+

+ + + + +
+ + + + + + + + + + +
virtual void NL3D::CPSRibbonLookAt::setSystemBasis bool  yes  )  [inline, virtual]
+
+ + + + + +
+   + + +

+tells in which basis is the tail It requires one transform per particle if it is not the same as the located that hold that particle The default is false. With that you can control if a rotation of the system will rotate the tail +

+Implements NL3D::CPSTailParticle. +

+Definition at line 83 of file ps_ribbon_look_at.h. +

+

00083 {}
+
+

+ + + + +
+ + + + + + + + + + +
void NL3D::CPSRibbonBase::setTailNbSeg uint32  nbSegs  )  [virtual, inherited]
+
+ + + + + +
+   + + +

+set the number of segments used with this particle. In this case, it can't be lower than 2 +

+ +

+Implements NL3D::CPSTailParticle. +

+Definition at line 118 of file ps_ribbon_base.cpp. +

+References NL3D::CPSRibbonBase::_NbSegs, NL3D::CPSRibbonBase::_RibbonIndex, NL3D::CPSLocated::getMaxSize(), NL3D::CPSRibbonBase::initDateVect(), nlassert, NL3D::CPSRibbonBase::resize(), and uint32. +

+

00119 {
+00120         nlassert(nbSegs >= 1);  
+00121         _NbSegs = nbSegs;       
+00122         _RibbonIndex = 0;
+00123         if (_Owner)
+00124         {       
+00125                 resize(_Owner->getMaxSize());
+00126         }
+00127         initDateVect();
+00128 }
+
+

+ + + + +
+ + + + + + + + + + +
void NL3D::CPSRibbonLookAt::setTexture CSmartPtr< ITexture tex  )  [virtual]
+
+ + + + + +
+   + + +

+set the texture for this particle +

+ +

+Implements NL3D::CPSTexturedParticleNoAnim. +

+Definition at line 111 of file ps_ribbon_look_at.cpp. +

+References updateMatAndVbForColor(). +

+

00112 {
+00113         _Tex = tex;
+00114         updateMatAndVbForColor();
+00115 }
+
+

+ + + + +
+ + + + + + + + + + +
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(), 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 }
+
+

+ + + + +
+ + + + + + + + + + +
virtual void NL3D::CPSRibbonLookAt::setZBias float  value  )  [inline, virtual]
+
+ + + + + +
+   + + +

+ +

+Reimplemented from NL3D::CPSMaterial. +

+Definition at line 116 of file ps_ribbon_look_at.h. +

+References value. +

+

00116 { CPSMaterial::setZBias(value); }       
+
+

+ + + + +
+ + + + + + + + + +
void NL3D::CPSParticle::showTool  )  [virtual, inherited]
+
+ + + + + +
+   + + +

+draw the particles for edition mode. The default behaviour just draw a wireframe model +

+ +

+Definition at line 55 of file ps_particle_basic.cpp. +

+References NL3D::CPSLocatedBindable::displayIcon2d(), PARTICLES_CHECK_MEM, and uint. +

+Referenced by NL3D::CPSParticle::step(), NL3D::CPSConstraintMesh::step(), NL3D::CPSMesh::step(), and NL3D::CPSFace::step(). +

+

00056 {
+00057         PARTICLES_CHECK_MEM;
+00058 
+00059         CVector I = CVector::I;
+00060         CVector J = CVector::J;
+00061 
+00062         const CVector tab[] = { 2 * J, I + J
+00063                                                         , I + J, 2 * I + J
+00064                                                         , 2 * I + J, I
+00065                                                         , I,  2 * I - J
+00066                                                         , 2 * I - J, - .5f * J
+00067                                                         , - .5f * J, -2 * I - J
+00068                                                         , -2 * I - J, - I
+00069                                                         , - I, -2 * I + J
+00070                                                         , -2 * I + J, - I + J
+00071                                                         , - I + J, 2 * J
+00072                                                 };
+00073         const uint tabSize = sizeof(tab) / (2 * sizeof(CVector));
+00074 
+00075         const float sSize = 0.1f;
+00076         displayIcon2d(tab, tabSize, sSize);
+00077 
+00078         PARTICLES_CHECK_MEM;
+00079 }
+
+

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

+inherited from CPSParticle +

+return true if the ribbon light persist after death

See also:
_PersistAfterDeath()
+ +

+We support Auto-LOD for ribbons, although there is a built-in LOD (that change the geometry rather than the number of ribbons) that gives better result (both can be used simultaneously) +

+Reimplemented from NL3D::CPSParticle. +

+Definition at line 119 of file ps_ribbon_look_at.cpp. +

+References NL3D::CPSParticle::computeSrcStep(), displayRibbons(), NL3D::CParticleSystem::getForceGlobalColorLightingFlag(), NL3D::CParticleSystem::getGlobalColor(), NL3D::CParticleSystem::getGlobalColorLighted(), NL3D::CParticleSystemProcess::getOwner(), hasOpaqueFaces(), hasTransparentFaces(), NL3D::PSBlendRender, NL3D::PSMotion, NL3D::PSSolidRender, NL3D::PSToolRender, NL3D::CMaterial::setColor(), NL3D::TAnimationTime, uint, uint32, NL3D::CPSRibbonBase::updateGlobals(), and NL3D::CPSParticle::usesGlobalColorLighting(). +

+

00120 {       
+00121         if (pass == PSMotion)
+00122         {               
+00123                 if (!_Parametric)
+00124                 {
+00125                         updateGlobals(realET);                  
+00126                 }
+00127         }
+00128         else
+00129         if (
+00130                 (pass == PSBlendRender && hasTransparentFaces())
+00131                 || (pass == PSSolidRender && hasOpaqueFaces())
+00132                 )
+00133         {
+00134                 uint32 step;
+00135                 uint   numToProcess;
+00136                 computeSrcStep(step, numToProcess);     
+00137                 if (!numToProcess) return;
+00138                 
+00140                 CParticleSystem &ps = *(_Owner->getOwner());    
+00141                 if (ps.getForceGlobalColorLightingFlag() || usesGlobalColorLighting())
+00142                 {
+00143                         _Mat.setColor(ps.getGlobalColorLighted());
+00144                 }
+00145                 else
+00146                 {               
+00147                         _Mat.setColor(ps.getGlobalColor());
+00148                 }
+00152                 displayRibbons(numToProcess, step);
+00153         }
+00154         else 
+00155         if (pass == PSToolRender) // edition mode only
+00156         {                       
+00157                 //showTool();
+00158         }       
+00159 }
+
+

+ + + + +
+ + + + + + + + + +
virtual bool NL3D::CPSRibbonLookAt::supportGlobalColorLighting  )  const [inline, virtual]
+
+ + + + + +
+   + + +

+ +

+Implements NL3D::CPSParticle. +

+Definition at line 111 of file ps_ribbon_look_at.h. +

+

00111 { return true; }        
+
+

+ + + + +
+ + + + + + + + + + +
void NL3D::CPSRibbonBase::updateGlobals float  realET  )  [protected, inherited]
+
+ + + + + +
+   + + +

+Called each time the time of the system change in order to update the ribbons positions. +

+decal date

+save current date

+updating ribbons positions +

+Definition at line 139 of file ps_ribbon_base.cpp. +

+References NL3D::CPSRibbonBase::_NbSegs, NL3D::CPSRibbonBase::_Parametric, NL3D::CPSRibbonBase::_RibbonIndex, NL3D::CPSRibbonBase::_Ribbons, NL3D::CPSRibbonBase::_SamplingDate, NL3D::CPSRibbonBase::_SegDuration, NL3D::CPSAttrib< T >::begin(), NL3D::EndRibbonStorage, NL3D::CParticleSystemProcess::getOwner(), NL3D::CPSLocated::getPos(), NL3D::CPSLocated::getSize(), NL3D::CParticleSystem::getSystemDate(), nlassert, size, NL3D::TAnimationTime, and uint. +

+Referenced by NL3D::CPSTailDot::step(), step(), and NL3D::CPSRibbon::step(). +

+

00140 {
+00141         nlassert(!_Parametric);
+00142         nlassert(_Owner);
+00143         const uint size = _Owner->getSize();
+00144         if (!size) return;
+00145         const TAnimationTime currDate = _Owner->getOwner()->getSystemDate() + realET;
+00146         if (currDate  - _LastUpdateDate >= _SegDuration)
+00147         {
+00148                 if (_RibbonIndex == 0) _RibbonIndex = _NbSegs + EndRibbonStorage;
+00149                 else --_RibbonIndex;
+00150                 
+00152                 ::memmove(&_SamplingDate[1], &_SamplingDate[0], sizeof(float) * (_NbSegs + EndRibbonStorage));
+00153                 _LastUpdateDate = currDate;
+00154         }
+00155         
+00157         _SamplingDate[0] = currDate;
+00158 
+00160         TPSAttribVector::iterator posIt = _Owner->getPos().begin();
+00161         NLMISC::CVector *currIt = &_Ribbons[_RibbonIndex];
+00162         uint k = size;
+00163         for (;;)
+00164         {
+00165                 *currIt = *posIt;
+00166                 --k;
+00167                 if (!k) break;
+00168                 ++posIt;
+00169                 currIt += (_NbSegs + 1 + EndRibbonStorage);
+00170         }
+00171 }
+
+

+ + + + +
+ + + + + + + + + +
void NL3D::CPSRibbonBase::updateLOD  )  [protected, inherited]
+
+ + + + + +
+   + + +

+must be called for the lod to apply (updates UsedNbSegs) +

+ +

+Definition at line 610 of file ps_ribbon_base.cpp. +

+References NL3D::CPSRibbonBase::_NbSegs, NL3D::CPSRibbonBase::_SegDuration, NL3D::CPSRibbonBase::_SegLength, NL3D::CPSRibbonBase::_UsedNbSegs, NL3D::CPSRibbonBase::_UsedSegDuration, NL3D::CPSRibbonBase::_UsedSegLength, NLMISC::clamp(), NL3D::CParticleSystem::getOneMinusCurrentLODRatio(), NL3D::CParticleSystemProcess::getOwner(), nlassert, and uint. +

+

00611 {
+00612         nlassert(_Owner);
+00613         float ratio = _Owner->getOwner()->getOneMinusCurrentLODRatio(); 
+00614         float squaredRatio = ratio * ratio;
+00615         float lodRatio = _LODDegradation + (1.f - _LODDegradation ) * squaredRatio * squaredRatio * squaredRatio;
+00616         
+00617         _UsedNbSegs = (uint) (_NbSegs * lodRatio);
+00618         NLMISC::clamp(_UsedNbSegs, 0u, _NbSegs);
+00619         const float epsilon = 10E-4f;   
+00620         _UsedSegDuration =  _SegDuration / std::max(epsilon, lodRatio);
+00621         _UsedSegLength   =  _SegLength / std::max(epsilon, lodRatio);
+00622 
+00623 }
+
+

+ + + + +
+ + + + + + + + + + +
void NL3D::CPSRibbonLookAt::updateMatAndVbForColor void   )  [private, virtual]
+
+ + + + + +
+   + + +

+update the material and the vb so that they match the color scheme. Inherited from CPSColoredParticle +

+ +

+Implements NL3D::CPSColoredParticle. +

+Definition at line 190 of file ps_ribbon_look_at.cpp. +

+References NL3D::CMaterial::setTexture(). +

+Referenced by setTexture(). +

+

00191 {
+00192         _Mat.setTexture(0, _Tex);
+00193 }
+
+

+ + + + +
+ + + + + + + + + +
bool NL3D::CPSParticle::usesGlobalColorLighting  )  [inline, inherited]
+
+ + + + + +
+   + + +

+Returns true if the object can use global lighting color. (example : 'lookat' particle do not have normals, so they use global lighting color instead +

+Definition at line 103 of file ps_particle_basic.h. +

+References NL3D::CPSParticle::_UsesGlobalColorLighting. +

+Referenced by NL3D::CPSTailDot::displayRibbons(), displayRibbons(), NL3D::CPSRibbon::displayRibbons(), NL3D::CPSShockWave::draw(), NL3D::CPSDot::draw(), NL3D::CPSTailDot::setupGlobalColor(), NL3D::CPSFanLight::setupMaterial(), NL3D::CPSRibbon::setupTexturedGlobalColor(), NL3D::CPSRibbon::setupUntexturedGlobalColor(), NL3D::CPSTailDot::step(), step(), NL3D::CPSRibbon::step(), NL3D::CPSQuad::updateMatBeforeRendering(), NL3D::CPSTailDot::updateMaterial(), NL3D::CPSRibbon::updateTexturedMaterial(), and NL3D::CPSRibbon::updateUntexturedMaterial(). +

+

00103 { return _UsesGlobalColorLighting; }
+
+


Friends And Related Function Documentation

+

+ + + + +
+ + +
friend class CPSLocated [friend, inherited] +
+
+ + + + + +
+   + + +

+ +

+Reimplemented in NL3D::CPSForce. +

+Definition at line 986 of file ps_located.h.

+


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().

+

+ + + + +
+ + +
CRGBA NL3D::CPSColoredParticle::_Color [protected, inherited] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 226 of file ps_particle_basic.h.

+

+ + + + +
+ + +
CPSRibbonLookAt::TVBMap NL3D::CPSRibbonLookAt::_ColoredVBMap [static, private] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 52 of file ps_ribbon_look_at.cpp.

+

+ + + + +
+ + +
CPSAttribMaker<CRGBA>* NL3D::CPSColoredParticle::_ColorScheme [protected, inherited] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 228 of file ps_particle_basic.h. +

+Referenced by NL3D::CPSFanLightHelper::drawFanLight(), NL3D::CPSConstraintMeshHelper::drawMeshs(), and NL3D::CPSConstraintMeshHelper::drawPrerotatedMeshs().

+

+ + + + +
+ + +
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().

+

+ + + + +
+ + +
CMaterial NL3D::CPSMaterial::_Mat [protected, inherited] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 844 of file ps_particle_basic.h. +

+Referenced by NL3D::CPSFaceHelper::drawFaces(), NL3D::CPSFanLightHelper::drawFanLight(), NL3D::CPSFaceLookAtHelper::drawLookAt(), and NL3D::CPSFaceLookAtHelper::drawLookAtAlignOnMotion().

+

+ + + + +
+ + +
std::string NL3D::CPSLocatedBindable::_Name [protected, inherited] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 1031 of file ps_located.h.

+

+ + + + +
+ + +
uint32 NL3D::CPSRibbonBase::_NbSegs [protected, inherited] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 101 of file ps_ribbon_base.h. +

+Referenced by NL3D::CPSRibbonBase::computeHermitteCstSizeRibbon(), NL3D::CPSRibbonBase::computeHermitteRibbon(), NL3D::CPSRibbonBase::computeLinearCstSizeRibbon(), NL3D::CPSRibbonBase::computeLinearRibbon(), NL3D::CPSRibbonBase::dupRibbon(), NL3D::CPSRibbonBase::getTailNbSeg(), NL3D::CPSRibbonBase::initDateVect(), NL3D::CPSRibbonBase::resetSingleRibbon(), NL3D::CPSRibbonBase::resize(), NL3D::CPSRibbonBase::setRibbonLength(), NL3D::CPSRibbonBase::setTailNbSeg(), NL3D::CPSRibbonBase::updateGlobals(), and NL3D::CPSRibbonBase::updateLOD().

+

+ + + + +
+ + +
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().

+

+ + + + +
+ + +
bool NL3D::CPSRibbonBase::_Parametric [protected, inherited] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 103 of file ps_ribbon_base.h. +

+Referenced by NL3D::CPSRibbonBase::computeHermitteCstSizeRibbon(), NL3D::CPSRibbonBase::computeHermitteRibbon(), NL3D::CPSRibbonBase::computeLinearCstSizeRibbon(), NL3D::CPSRibbonBase::computeLinearRibbon(), NL3D::CPSRibbonBase::deleteElement(), NL3D::CPSRibbonBase::dupRibbon(), NL3D::CPSRibbonBase::motionTypeChanged(), NL3D::CPSRibbonBase::newElement(), NL3D::CPSRibbonBase::resetFromOwner(), NL3D::CPSRibbonBase::resetSingleRibbon(), NL3D::CPSRibbonBase::resize(), and NL3D::CPSRibbonBase::updateGlobals().

+

+ + + + +
+ + +
float NL3D::CPSSizedParticle::_ParticleSize [protected, inherited] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 289 of file ps_particle_basic.h. +

+Referenced by NL3D::CPSFaceHelper::drawFaces(), NL3D::CPSFanLightHelper::drawFanLight(), NL3D::CPSFaceLookAtHelper::drawLookAt(), NL3D::CPSFaceLookAtHelper::drawLookAtAlignOnMotion(), NL3D::CPSConstraintMeshHelper::drawMeshs(), NL3D::CPSConstraintMeshHelper::drawPrerotatedMeshs(), NL3D::CPSSizedParticle::getSize(), and NL3D::CPSSizedParticle::setSize().

+

+ + + + +
+ + +
TAnimationTime NL3D::CPSRibbonBase::_SegDuration [protected, inherited] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 102 of file ps_ribbon_base.h. +

+Referenced by NL3D::CPSRibbonBase::getSegDuration(), NL3D::CPSRibbonBase::setSegDuration(), NL3D::CPSRibbonBase::updateGlobals(), and NL3D::CPSRibbonBase::updateLOD().

+

+ + + + +
+ + +
CPSAttribMaker<float>* NL3D::CPSSizedParticle::_SizeScheme [protected, inherited] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 290 of file ps_particle_basic.h. +

+Referenced by NL3D::CPSSizedParticle::deleteSizeElement(), NL3D::CPSFaceHelper::drawFaces(), NL3D::CPSFanLightHelper::drawFanLight(), NL3D::CPSFaceLookAtHelper::drawLookAt(), NL3D::CPSFaceLookAtHelper::drawLookAtAlignOnMotion(), NL3D::CPSConstraintMeshHelper::drawMeshs(), NL3D::CPSConstraintMeshHelper::drawPrerotatedMeshs(), NL3D::CPSSizedParticle::getSizeScheme(), NL3D::CPSSizedParticle::newSizeElement(), NL3D::CPSSizedParticle::resizeSize(), NL3D::CPSSizedParticle::setSize(), NL3D::CPSSizedParticle::setSizeScheme(), and NL3D::CPSSizedParticle::~CPSSizedParticle().

+

+ + + + +
+ + +
CSmartPtr<ITexture> NL3D::CPSRibbonLookAt::_Tex [protected] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 119 of file ps_ribbon_look_at.h.

+

+ + + + +
+ + +
uint32 NL3D::CPSRibbonBase::_UsedNbSegs [protected, inherited] +
+
+ + + + + +
+   + + +

+value to use after lod computation +

+ +

+Definition at line 136 of file ps_ribbon_base.h. +

+Referenced by NL3D::CPSRibbonBase::computeHermitteCstSizeRibbon(), NL3D::CPSRibbonBase::computeHermitteRibbon(), NL3D::CPSRibbonBase::computeLinearCstSizeRibbon(), NL3D::CPSRibbonBase::computeLinearRibbon(), and NL3D::CPSRibbonBase::updateLOD().

+

+ + + + +
+ + +
TAnimationTime NL3D::CPSRibbonBase::_UsedSegDuration [protected, inherited] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 137 of file ps_ribbon_base.h. +

+Referenced by NL3D::CPSRibbonBase::computeHermitteRibbon(), NL3D::CPSRibbonBase::computeLinearRibbon(), and NL3D::CPSRibbonBase::updateLOD().

+

+ + + + +
+ + +
float NL3D::CPSRibbonBase::_UsedSegLength [protected, inherited] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 138 of file ps_ribbon_base.h. +

+Referenced by NL3D::CPSRibbonBase::computeHermitteCstSizeRibbon(), NL3D::CPSRibbonBase::computeLinearCstSizeRibbon(), and NL3D::CPSRibbonBase::updateLOD().

+

+ + + + +
+ + +
CPSRibbonLookAt::TVBMap NL3D::CPSRibbonLookAt::_VBMap [static, private] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 51 of file ps_ribbon_look_at.cpp.

+


The documentation for this class was generated from the following files: +
Generated on Tue Mar 16 07:24:09 2004 for NeL by + +doxygen +1.3.6
+ + -- cgit v1.2.1