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

NL3D::CPSRibbon Class Reference

#include <ps_ribbon.h> +

Inheritance diagram for NL3D::CPSRibbon: +

+ + + + + + + + + + + + +

Detailed Description

+'Ribbon' particle : a shape is extruded while it follows the particle. It replaces the old ribbon version. It has more limitations : no 2d rotations and it has no propagation of size and color. It doesn't take ha much memory, and displays better (the length is not dependent on framerate as it was the case before) +

+ +

+Definition at line 45 of file ps_ribbon.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)

CVBnPB & getVBnPB ()
get a vertex buffer and a primitive suited for the current ribbon

TVBMap _ColoredVBMap
TVBMap _FadedColoredVBMap
TVBMap _FadedVBMap
TVBMap _TexColoredVBMap
TVBMap _TexFadedColoredVBMap
TVBMap _TexFadedVBMap
TVBMap _TexVBMap
textured ribbons

TVBMap _VBMap
untextured ribbons

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)

IDriver * getDriver () const
shortcut to get an instance of the driver

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

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

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

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

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

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

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

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

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

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)

uint32 getNbVerticesInShape (void) const
get the number of vertice in the shape used for ribbons

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

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

virtual uint32 getPriority (void) const
return priority

void getShape (NLMISC::CVector *shape) const
==================================================================================================================

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::CMatrix & getSysMat (void) const
***************************************************************************************

const ITexture * getTexture (void) const
ITexture * getTexture (void)
get the texture used

uint32 getType (void) const
return this bindable type

float getUFactor (void) const
virtual bool getUserMatrixUsageCount () const
float getVFactor (void) const
const NLMISC::CMatrix & getViewMat (void) const
shortcut to get the view matrix

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

virtual bool 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 setShape (const NLMISC::CVector *shape, uint32 nbPointsInShape)
==================================================================================================================

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

void setSizeScheme (CPSAttribMaker< float > *size)
void setTexFactor (float uFactor=1.f, float vFactor=1.f)
Set texture factors.

void setTexture (NLMISC::CSmartPtr< ITexture > tex)
set a texture

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
CPSRibbon ()
NLMISC_DECLARE_CLASS (CPSRibbon)
virtual void serial (NLMISC::IStream &f) throw (NLMISC::EStream)
==================================================================================================================

~CPSRibbon ()
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)

Static Public Attributes
Predefined shapes
const NLMISC::CVector HeightSides []
Predefined shape : height sides.

const NLMISC::CVector Losange []
Predefined shape : a regular losange shape.

const uint NbVerticesInHeightSide = sizeof(CPSRibbon::HeightSides) / sizeof(CVector)
number of vertices in the height side (must be 8 ... :) )

const uint NbVerticesInLosange = sizeof(Losange) / sizeof(CVector)
number of vertices in the losange

const uint NbVerticesInPentagram = sizeof(CPSRibbon::Pentagram) / sizeof(CVector)
Predefined shape : height sides.

const uint NbVerticesInTriangle = sizeof(CPSRibbon::Triangle) / sizeof(CVector)
Predefined shape : height sides.

const NLMISC::CVector Pentagram []
Predifined shape : pentagram.

const NLMISC::CVector Triangle []
Predifined shape : triangle.

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 CPSLocated * getColorOwner (void)
From CPSColoredParticle.

uint32 getRibbonIndex () const
const TFloatVect & getSamplingDate () const
virtual CPSLocated * getSizeOwner (void)
From CPSSizedParticle.

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

uint getNumVerticesInSlice () const
Get the number of vertices in each slices (depends on wether the ribbon is textured or not).

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

void updateMaterial ()
void updateTexturedMaterial ()
void updateUntexturedMaterial ()

Private Attributes
bool _ColorFading: 1
bool _ForceLighted: 1
bool _GlobalColor: 1
bool _Lighted: 1
CPSVector< NLMISC::CVector
+>::V _Shape
CSmartPtr< ITexture > _Tex
bool _Touch: 1
float _UFactor
float _VFactor

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::CPSRibbon::TVBMap [private] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 228 of file ps_ribbon.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. +
+
00809 { add, modulate, alphaBlend, alphaTest }; +

+

+ + + + +
+ + +
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(). +
+
00048 { VariableSize = 0, FixedSize, RibbonModeLast }; +

+

Constructor & Destructor Documentation

+ + + + +
+ + + + + + + + + +
NL3D::CPSRibbon::CPSRibbon ( )
+
+ + + + + +
+ + + +
+ctor.
Parameters:
+ + + + +
nbSegmentInTail the number of segment the ribbon has in its tail
shape pointer to a shape that will be extruded along the ribbon. It must have a unit size and be located in the x-y plane. This will be copied
nbPointsInShape : the number of points in the shape
+
+ +
+Definition at line 233 of file ps_ribbon.cpp. +
+References NbVerticesInTriangle, NL3D::CMaterial::setDoubleSided(), NL3D::CPSRibbonBase::setInterpolationMode(), NL3D::CPSRibbonBase::setSegDuration(), and setShape(). +
+
00233 : _UFactor(1.f), +00234 _VFactor(1.f), +00235 _ColorFading(true), +00236 _GlobalColor(false), +00237 _Touch(true), +00238 _Lighted(false), +00239 _ForceLighted(false) +00240 { +00241 setInterpolationMode(Linear); +00242 setSegDuration(0.06f); +00243 if (CParticleSystem::getSerializeIdentifierFlag()) _Name = std::string("Ribbon"); +00244 setShape(Triangle, NbVerticesInTriangle); +00245 _Mat.setDoubleSided(true); +00246 } +

+

+ + + + +
+ + + + + + + + + +
NL3D::CPSRibbon::~CPSRibbon ( )
+
+ + + + + +
+ + + +
+dtor +
+ +
+Definition at line 250 of file ps_ribbon.cpp. +
+
00251 { +00252 } +

+

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(), NL3D::CPSRibbonLookAt::displayRibbons(), and 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(), NL3D::CPSRibbonLookAt::step(), 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(), NL3D::CPSRibbonLookAt::deleteElement(), 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::CPSRibbon::deleteElement ( uint32 index ) [protected, virtual]
+
+ + + + + +
+ + + +
+inherited from CPSLocatedBindable +
+ +
+Reimplemented from NL3D::CPSRibbonBase. +
+Definition at line 322 of file ps_ribbon.cpp. +
+References NL3D::CPSColoredParticle::deleteColorElement(), NL3D::CPSSizedParticle::deleteSizeElement(), index, and uint32. +
+
00323 { +00324 CPSRibbonBase::deleteElement(index); +00325 deleteColorElement(index); +00326 deleteSizeElement(index); +00327 } +

+

+ + + + +
+ + + + + + + + + + +
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(), NL3D::CPSRibbonLookAt::deleteElement(), 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::CPSRibbon::displayRibbons ( uint32 nbRibbons,
uint32 srcStep
) [private]
+
+ + + + + +
+ + + +
+display a set of ribbons +
+setup sizes
+compute colors +
+Definition at line 471 of file ps_ribbon.cpp. +
+References _ForceLighted, _Lighted, NL3D::IDriver::activeVertexBuffer(), NL3D::CPSRibbonBase::computeRibbon(), NL3D::ComputeTexturedRibbonMesh(), NL3D::ComputeUntexturedRibbonMesh(), NL3D::CParticleSystem::getColorAttenuationScheme(), NL3D::CVertexBuffer::getColorOff(), NL3D::CPSLocatedBindable::getDriver(), NL3D::CParticleSystem::getForceGlobalColorLightingFlag(), getNumRibbonsInVB(), getNumVerticesInSlice(), NL3D::CParticleSystemProcess::getOwner(), NL3D::CParticleSystem::getSystemDate(), getVBnPB(), NL3D::CVertexBuffer::getVertexCoordPointer(), NL3D::CVertexBuffer::getVertexSize(), NL3D::CPSLocated::incrementNbDrawnParticles(), NL3D::CPSLocated::integrateSingle(), NL3D::CParticleSystem::isUserColorUsed(), NL3D::CPSAttribMaker< float >::make(), NL3D::CPSAttribMaker< CRGBA >::makeN(), min, nlassert, NL3D::CPSRibbon::CVBnPB::PB, NL3D::IDriver::render(), NL3D::CPrimitiveBlock::setNumTri(), NL3D::CPSLocatedBindable::setupDriverModelMatrix(), setupGlobalColor(), touch(), uint, uint32, uint8, updateMaterial(), NL3D::CPSParticle::usesGlobalColorLighting(), and NL3D::CPSRibbon::CVBnPB::VB. +
+Referenced by step(). +
+
00472 { +00473 if (!nbRibbons) return; +00474 nlassert(_Owner); +00475 CPSRibbonBase::updateLOD(); +00476 if (_UsedNbSegs < 2) return; +00477 const float date = _Owner->getOwner()->getSystemDate(); +00478 uint8 *currVert; +00479 CVBnPB &VBnPB = getVBnPB(); // get the appropriate vb (built it if needed) +00480 CVertexBuffer &VB = VBnPB.VB; +00481 CPrimitiveBlock &PB = VBnPB.PB; +00482 const uint32 vertexSize = VB.getVertexSize(); +00483 uint colorOffset=0; +00484 +00485 IDriver *drv = this->getDriver(); +00486 setupDriverModelMatrix(); +00487 drv->activeVertexBuffer(VB); +00488 _Owner->incrementNbDrawnParticles(nbRibbons); // for benchmark purpose +00489 const uint numRibbonBatch = getNumRibbonsInVB(); // number of ribons to process at once +00490 if (_UsedNbSegs == 0) return; +00492 // Material setup // +00494 CParticleSystem &ps = *(_Owner->getOwner()); +00495 bool useGlobalColor = ps.getColorAttenuationScheme() != NULL || ps.isUserColorUsed(); +00496 if (useGlobalColor != _GlobalColor) +00497 { +00498 _GlobalColor = useGlobalColor; +00499 touch(); +00500 } +00501 if (usesGlobalColorLighting() != _Lighted) +00502 { +00503 _Lighted = usesGlobalColorLighting(); +00504 touch(); +00505 } +00506 if (ps.getForceGlobalColorLightingFlag() != _ForceLighted) +00507 { +00508 _ForceLighted = ps.getForceGlobalColorLightingFlag(); +00509 touch(); +00510 } +00511 updateMaterial(); +00512 setupGlobalColor(); +00513 // +00514 if (_ColorScheme) +00515 { +00516 colorOffset = VB.getColorOff(); +00517 } +00519 // Compute ribbons // +00521 const uint numVerticesInSlice = getNumVerticesInSlice(); +00522 const uint numVerticesInShape = _Shape.size(); +00523 // +00524 static std::vector<float> sizes; +00525 static std::vector<NLMISC::CVector> ribbonPos; // this is where the position of each ribbon slice center i stored +00526 ribbonPos.resize(_UsedNbSegs + 1); // make sure we have enough room +00527 sizes.resize(numRibbonBatch); +00528 +00529 // +00530 uint toProcess; +00531 uint ribbonIndex = 0; // index of the first ribbon in the batch being processed +00532 uint32 fpRibbonIndex = 0; // fixed point index in source +00533 do +00534 { +00535 toProcess = std::min((uint) (nbRibbons - ribbonIndex) , numRibbonBatch); +00536 currVert = (uint8 *) VB.getVertexCoordPointer(); +00537 +00539 const float *ptCurrSize; +00540 uint32 ptCurrSizeIncrement; +00541 if (_SizeScheme) +00542 { +00543 ptCurrSize = (float *) _SizeScheme->make(this->_Owner, ribbonIndex, &sizes[0], sizeof(float), toProcess, true, srcStep); +00544 ptCurrSizeIncrement = 1; +00545 } +00546 else +00547 { +00548 ptCurrSize = &_ParticleSize; +00549 ptCurrSizeIncrement = 0; +00550 } +00551 +00553 if (_ColorScheme) +00554 { +00555 _ColorScheme->makeN(this->_Owner, ribbonIndex, currVert + colorOffset, vertexSize, toProcess, numVerticesInSlice * (_UsedNbSegs + 1), srcStep); +00556 } +00557 uint k = toProcess; +00559 // interpolate and project points the result is directly setup in the vertex buffer // +00561 if (!_Parametric) +00562 { +00564 // INCREMENTAL CASE // +00566 if (_Tex != NULL) // textured case +00567 { +00568 do +00569 { +00570 const float ribbonSizeIncrement = *ptCurrSize / (float) _UsedNbSegs; +00571 ptCurrSize += ptCurrSizeIncrement; +00572 // the parent class has a method to get the ribbons positions +00573 computeRibbon((uint) (fpRibbonIndex >> 16), &ribbonPos[0], sizeof(NLMISC::CVector)); +00574 currVert = ComputeTexturedRibbonMesh(currVert, +00575 vertexSize, +00576 &ribbonPos[0], +00577 &_Shape[0], +00578 _UsedNbSegs, +00579 numVerticesInShape, +00580 ribbonSizeIncrement, +00581 *ptCurrSize +00582 ); +00583 fpRibbonIndex += srcStep; +00584 } +00585 while (--k); +00586 } +00587 else // untextured case +00588 { +00589 do +00590 { +00591 const float ribbonSizeIncrement = *ptCurrSize / (float) _UsedNbSegs; +00592 ptCurrSize += ptCurrSizeIncrement; +00593 // the parent class has a method to get the ribbons positions +00594 computeRibbon((uint) (fpRibbonIndex >> 16), &ribbonPos[0], sizeof(NLMISC::CVector)); +00595 currVert = ComputeUntexturedRibbonMesh(currVert, +00596 vertexSize, +00597 &ribbonPos[0], +00598 &_Shape[0], +00599 _UsedNbSegs, +00600 numVerticesInShape, +00601 ribbonSizeIncrement, +00602 *ptCurrSize +00603 ); +00604 fpRibbonIndex += srcStep; +00605 } +00606 while (--k); +00607 } +00608 } +00609 else +00610 { +00612 // PARAMETRIC CASE // +00614 if (_Tex != NULL) // textured case +00615 { +00616 do +00617 { +00618 const float ribbonSizeIncrement = *ptCurrSize / (float) _UsedNbSegs; +00619 ptCurrSize += ptCurrSizeIncrement; +00620 _Owner->integrateSingle(date - _UsedSegDuration * (_UsedNbSegs + 1), +00621 _UsedSegDuration, +00622 _UsedNbSegs + 1, +00623 (uint) (fpRibbonIndex >> 16), +00624 &ribbonPos[0]); +00625 +00626 currVert = ComputeTexturedRibbonMesh(currVert, +00627 vertexSize, +00628 &ribbonPos[0], +00629 &_Shape[0], +00630 _UsedNbSegs, +00631 numVerticesInShape, +00632 ribbonSizeIncrement, +00633 *ptCurrSize +00634 ); +00635 fpRibbonIndex += srcStep; +00636 } +00637 while (--k); +00638 } +00639 else // untextured case +00640 { +00641 do +00642 { +00643 const float ribbonSizeIncrement = *ptCurrSize / (float) _UsedNbSegs; +00644 ptCurrSize += ptCurrSizeIncrement; +00645 _Owner->integrateSingle(date - _UsedSegDuration * (_UsedNbSegs + 1), +00646 _UsedSegDuration, +00647 _UsedNbSegs + 1, +00648 (uint) (fpRibbonIndex >> 16), +00649 &ribbonPos[0]); +00650 +00651 currVert = ComputeUntexturedRibbonMesh(currVert, +00652 vertexSize, +00653 &ribbonPos[0], +00654 &_Shape[0], +00655 _UsedNbSegs, +00656 numVerticesInShape, +00657 ribbonSizeIncrement, +00658 *ptCurrSize +00659 ); +00660 fpRibbonIndex += srcStep; +00661 } +00662 while (--k); +00663 } +00664 } +00665 // display the result +00666 PB.setNumTri((numVerticesInShape * _UsedNbSegs * toProcess) << 1); +00667 drv->render(PB, _Mat); +00668 ribbonIndex += toProcess; +00669 } +00670 while (ribbonIndex != nbRibbons); +00671 +00672 } +

+

+ + + + +
+ + + + + + + + + + +
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::CPSRibbon::enumTexs ( std::vector< NLMISC::CSmartPtr< ITexture > > & dest,
IDriver & drv
) [virtual]
+
+ + + + + +
+ + + +
+================================================================================================================== +
+ +
+Reimplemented from NL3D::CPSLocatedBindable. +
+Definition at line 1143 of file ps_ribbon.cpp. +
+
01144 { +01145 if (_Tex) +01146 { +01147 dest.push_back(_Tex); +01148 } +01149 } +

+

+ + + + +
+ + + + + + + + + + +
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 NL3D::CPSRibbonLookAt::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(), NL3D::CPSRibbonLookAt::hasTransparentFaces(), 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::CPSRibbon::getColorFading ( void ) const [inline, virtual]
+
+ + + + + +
+ + + +
+Test wether color fading is activated. +
+Implements NL3D::CPSTailParticle. +
+Definition at line 84 of file ps_ribbon.h. +
+References _ColorFading. +
+
00085 { +00086 return _ColorFading; +00087 } +

+

+ + + + +
+ + + + + + + + + + +
virtual CPSLocated* NL3D::CPSRibbon::getColorOwner ( void ) [inline, protected, virtual]
+
+ + + + + +
+ + + +
+From CPSColoredParticle. +
+ +
+Implements NL3D::CPSColoredParticle. +
+Definition at line 201 of file ps_ribbon.h. +
+
00201 { 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(), NL3D::CPSRibbonLookAt::displayRibbons(), 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 NL3D::CPSRibbonLookAt::displayRibbons(), NL3D::CPSSound::newElement(), NL3D::CPSZoneRectangle::show(), NL3D::CPSZoneCylinder::show(), NL3D::CPSZoneDisc::show(), NL3D::CPSZonePlane::show(), NL3D::CPSLight::show(), NL3D::CPSGravity::show(), NL3D::CPSEmitterRectangle::showTool(), NL3D::CPSLight::step(), and NL3D::CPSMesh::updatePos(). +
+
01145 { +01146 nlassert(_Owner); +01147 return _Owner->getLocalToWorldMatrix(); +01148 } +

+

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

+

+ + + + +
+ + + + + + + + + +
float NL3D::CPSRibbonBase::getLODDegradation ( ) const [inline, inherited]
+
+ + + + + +
+ + + +
+ +
+Definition at line 95 of file ps_ribbon_base.h. +
+
00095 { return _LODDegradation; } +

+

+ + + + +
+ + + + + + + + + + +
uint32 NL3D::CPSRibbon::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 688 of file ps_ribbon.cpp. +
+References NL3D::CPSLocated::getMaxSize(), nlassert, and uint32. +
+
00689 { +00690 nlassert(_Owner); +00691 return _Owner->getMaxSize() * _NbSegs; +00692 } +

+

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

+

+ + + + +
+ + + + + + + + + + +
uint32 NL3D::CPSRibbon::getNbVerticesInShape ( void ) const [inline]
+
+ + + + + +
+ + + +
+get the number of vertice in the shape used for ribbons +
+ +
+Definition at line 146 of file ps_ribbon.h. +
+References uint32. +
+
00146 { return _Shape.size(); } +

+

+ + + + +
+ + + + + + + + + +
uint NL3D::CPSRibbon::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) +
+1 vertex added for textured ribbon (to avoid texture stretching) +
+Definition at line 815 of file ps_ribbon.cpp. +
+References getNumVerticesInSlice(), and uint. +
+Referenced by displayRibbons(), and getVBnPB(). +
+
00816 { +00817 const uint numVerticesInSlice = getNumVerticesInSlice(); +00818 const uint vertexInVB = 512; +00819 return std::max(1u, (uint) (vertexInVB / (numVerticesInSlice * (_UsedNbSegs + 1)))); +00820 } +

+

+ + + + +
+ + + + + + + + + +
uint NL3D::CPSRibbon::getNumVerticesInSlice ( ) const [inline, private]
+
+ + + + + +
+ + + +
+Get the number of vertices in each slices (depends on wether the ribbon is textured or not). +
+ +
+Definition at line 256 of file ps_ribbon.cpp. +
+References uint. +
+Referenced by displayRibbons(), getNumRibbonsInVB(), and getVBnPB(). +
+
00257 { +00258 return _Shape.size() + (_Tex == NULL ? 0 : 1); +00259 } +

+

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

+

+ + + + +
+ + + + + + + + + + +
void NL3D::CPSRibbon::getShape ( NLMISC::CVector * shape ) const
+
+ + + + + +
+ + + +
+================================================================================================================== +
+Get a copy of the shape used for ribbon
Parameters:
+ + +
dest a table of cvector that has the right size, it will be filled with vertices
+
+
See also:
getNbVerticesInShape()
+ +
+Definition at line 1137 of file ps_ribbon.cpp. +
+
01138 { +01139 std::copy(_Shape.begin(), _Shape.end(), shape); +01140 } +

+

+ + + + +
+ + + + + + + + + + +
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::CPSRibbon::getSizeOwner ( void ) [inline, protected, virtual]
+
+ + + + + +
+ + + +
+From CPSSizedParticle. +
+ +
+Implements NL3D::CPSSizedParticle. +
+Definition at line 199 of file ps_ribbon.h. +
+
00199 { 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::CPSRibbon::getTexture ( void ) const [inline, virtual]
+
+ + + + + +
+ + + +
+ +
+Implements NL3D::CPSTexturedParticleNoAnim. +
+Definition at line 134 of file ps_ribbon.h. +
+
00134 { return _Tex; } +

+

+ + + + +
+ + + + + + + + + + +
ITexture* NL3D::CPSRibbon::getTexture ( void ) [inline, virtual]
+
+ + + + + +
+ + + +
+get the texture used +
+ +
+Implements NL3D::CPSTexturedParticleNoAnim. +
+Definition at line 133 of file ps_ribbon.h. +
+
00133 { 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; } +

+

+ + + + +
+ + + + + + + + + + +
float NL3D::CPSRibbon::getUFactor ( void ) const [inline]
+
+ + + + + +
+ + + +
+ +
+Definition at line 129 of file ps_ribbon.h. +
+References _UFactor. +
+
00129 { return _UFactor; } +

+

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

+

+ + + + +
+ + + + + + + + + +
CPSRibbon::CVBnPB & NL3D::CPSRibbon::getVBnPB ( ) [private]
+
+ + + + + +
+ + + +
+get a vertex buffer and a primitive suited for the current ribbon +
+untextured cases
+textured cases
+choose the right vb by building an index for lookup into 'vbMaps' defined above
+1 vertex added for textured ribbon (to avoid texture stretching)
+Setup the pb and vb parts. Not very fast but executed only once
+setup primitive block
+there are alway one more slice than segments in the ribbon...
+deals with each ribbon vertices
+the last 2 index don't loop if there's a texture
+setup vb
+deals with each ribbon vertices
+setup texture (if any)
+setup gradient +
+set the vb format & size In the case of a ribbon with color and fading, we encode the fading in a texture If the ribbon has fading, but only a global color, we encode it in the primary color +
+Definition at line 695 of file ps_ribbon.cpp. +
+References _ColorFading, _FadedColoredVBMap, _FadedVBMap, _TexColoredVBMap, _TexFadedColoredVBMap, _TexFadedVBMap, getNumRibbonsInVB(), NL3D::CVertexBuffer::getNumVertices(), getNumVerticesInSlice(), nlassert, NL3D::CPSRibbon::CVBnPB::PB, NL3D::CVertexBuffer::setColor(), NL3D::CPrimitiveBlock::setNumTri(), NL3D::CVertexBuffer::setNumVertices(), NL3D::CVertexBuffer::setTexCoord(), NL3D::CPrimitiveBlock::setTri(), NL3D::CVertexBuffer::setVertexFormat(), uint, uint8, and NL3D::CPSRibbon::CVBnPB::VB. +
+Referenced by displayRibbons(). +
+
00696 { +00697 static TVBMap * const vbMaps[] = +00698 { +00700 &_VBMap, +00701 &_FadedVBMap, +00702 &_ColoredVBMap, +00703 &_FadedColoredVBMap, +00705 &_TexVBMap, +00706 &_TexFadedVBMap, +00707 &_TexColoredVBMap, +00708 &_TexFadedColoredVBMap +00709 }; +00710 +00712 TVBMap &map = *vbMaps[ (_Tex != NULL ? (1 << 2) : 0) | // set bit 2 if textured +00713 (_ColorScheme != NULL ? (1 << 1) : 0) | // set bit 1 if per ribbon color +00714 (_ColorFading ? 1 : 0) // set bit 0 if color fading +00715 ]; +00716 +00717 const uint numVerticesInSlice = getNumVerticesInSlice(); +00718 const uint numVerticesInShape = _Shape.size(); +00719 +00720 +00721 // The number of slice is encoded in the upper word of the vb index +00722 // The number of vertices per slices is encoded in the lower word +00723 uint VBnPDIndex = ((_UsedNbSegs + 1) << 16) | numVerticesInSlice; +00724 TVBMap::iterator it = map.find(VBnPDIndex); +00725 if (it != map.end()) +00726 { +00727 return it->second; +00728 } +00729 else // must create this vb, with few different size, it is still interseting, though they are only destroyed at exit +00730 { +00731 const uint numRibbonInVB = getNumRibbonsInVB(); +00732 CVBnPB &VBnPB = map[VBnPDIndex]; // make an entry +00733 +00737 CVertexBuffer &vb = VBnPB.VB; +00738 vb.setVertexFormat(CVertexBuffer::PositionFlag | /* alway need position */ +00739 (_ColorScheme || _ColorFading ? CVertexBuffer::PrimaryColorFlag : 0) | /* need a color ? */ +00740 ((_ColorScheme && _ColorFading) || _Tex != NULL ? CVertexBuffer::TexCoord0Flag : 0) | /* need texture coordinates ? */ +00741 (_Tex != NULL && _ColorScheme && _ColorFading ? CVertexBuffer::TexCoord1Flag : 0) /* need 2nd texture coordinates ? */ +00742 ); +00743 vb.setNumVertices((_UsedNbSegs + 1) * numRibbonInVB * numVerticesInSlice); // 1 seg = 1 line + terminal vertices +00744 +00745 // set the primitive block size +00746 CPrimitiveBlock &pb = VBnPB.PB; +00747 pb.setNumTri((_UsedNbSegs * numRibbonInVB * _Shape.size()) << 1); +00749 uint vbIndex = 0; +00750 uint pbIndex = 0; +00751 uint i, k, l; +00752 for (i = 0; i < numRibbonInVB; ++i) +00753 { +00754 for (k = 0; k < (_UsedNbSegs + 1); ++k) +00755 { +00756 +00758 if (k != _UsedNbSegs) +00759 { +00760 uint vIndex = vbIndex; +00761 for (l = 0; l < (numVerticesInShape - 1); ++l) +00762 { +00763 pb.setTri(pbIndex ++, vIndex, vIndex + numVerticesInSlice, vIndex + numVerticesInSlice + 1); +00764 pb.setTri(pbIndex ++, vIndex, vIndex + numVerticesInSlice + 1, vIndex + 1); +00765 ++ vIndex; +00766 } +00767 +00769 uint nextVertexIndex = (numVerticesInShape == numVerticesInSlice) ? vIndex + 1 - numVerticesInShape // no texture -> we loop +00770 : vIndex + 1; // a texture is used : use onemore vertex +00771 pb.setTri(pbIndex ++, vIndex, vIndex + numVerticesInSlice, nextVertexIndex + numVerticesInSlice); +00772 pb.setTri(pbIndex ++, vIndex, nextVertexIndex + numVerticesInSlice, nextVertexIndex); +00773 +00774 } +00775 +00777 for (l = 0; l < numVerticesInSlice; ++l) +00778 { +00779 nlassert(vbIndex < vb.getNumVertices()); +00781 if (_Tex != NULL) +00782 { +00783 vb.setTexCoord(vbIndex, +00784 _ColorScheme && _ColorFading ? 1 : 0, // must we use the second texture coord ? (when 1st one used by the gradient texture : we can't encode it in the diffuse as it encodes each ribbon color) +00785 (float) k / _UsedNbSegs, // u +00786 1.f - (l / (float) numVerticesInShape) // v +00787 ); +00788 } +00789 +00791 if (_ColorFading) +00792 { +00793 // If not per ribbon color, we can encode it in the diffuse +00794 if (_ColorScheme == NULL) +00795 { +00796 uint8 intensity = (uint8) (255 * (1.f - ((float) k / _UsedNbSegs))); +00797 NLMISC::CRGBA col(intensity, intensity, intensity, intensity); +00798 vb.setColor(vbIndex, col); +00799 } +00800 else // encode it in the first texture +00801 { +00802 vb.setTexCoord(vbIndex, 0, 0.5f - 0.5f * ((float) k / _UsedNbSegs), 0); +00803 } +00804 } +00805 ++ vbIndex; +00806 } +00807 +00808 } +00809 } +00810 return VBnPB; +00811 } +00812 } +

+

+ + + + +
+ + + + + + + + + + +
float NL3D::CPSRibbon::getVFactor ( void ) const [inline]
+
+ + + + + +
+ + + +
+ +
+Definition at line 131 of file ps_ribbon.h. +
+References _VFactor. +
+
00131 { return _VFactor; } +

+

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

+

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

+

+ + + + +
+ + + + + + + + + +
virtual bool NL3D::CPSRibbon::hasLightableFaces ( ) [inline, virtual]
+
+ + + + + +
+ + + +
+from CPSParticle : return true if there are lightable faces in the object +
+ +
+Implements NL3D::CPSParticle. +
+Definition at line 173 of file ps_ribbon.h. +
+
00173 { return false; } +

+

+ + + + +
+ + + + + + + + + + +
bool NL3D::CPSRibbon::hasOpaqueFaces ( void ) [virtual]
+
+ + + + + +
+ + + +
+return true if there are Opaque faces in the object +
+ +
+Implements NL3D::CPSParticle. +
+Definition at line 682 of file ps_ribbon.cpp. +
+References hasTransparentFaces(). +
+Referenced by step(). +
+
00683 { +00684 return !hasTransparentFaces(); +00685 } +

+

+ + + + +
+ + + + + + + + + + +
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::CPSRibbon::hasTransparentFaces ( void ) [virtual]
+
+ + + + + +
+ + + +
+return true if there are transparent faces in the object +
+ +
+Implements NL3D::CPSParticle. +
+Definition at line 675 of file ps_ribbon.cpp. +
+References NL3D::CPSMaterial::getBlendingMode(). +
+Referenced by hasOpaqueFaces(), and step(). +
+
00676 { +00677 return getBlendingMode() != CPSMaterial::alphaTest ; +00678 } +

+

+ + + + +
+ + + + + + + + + +
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::CPSRibbon::isInSystemBasis ( void ) const [inline, virtual]
+
+ + + + + +
+ + + +
+return true if the tails are in the system basis +
+ +
+Implements NL3D::CPSTailParticle. +
+Definition at line 96 of file ps_ribbon.h. +
+
00096 { 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(), NL3D::CPSRibbonLookAt::newElement(), 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::CPSRibbon::newElement ( CPSLocated * emitterLocated,
uint32 emitterIndex
) [protected, virtual]
+
+ + + + + +
+ + + +
+inherited from CPSLocatedBindable +
+ +
+Reimplemented from NL3D::CPSRibbonBase. +
+Definition at line 313 of file ps_ribbon.cpp. +
+References NL3D::CPSColoredParticle::newColorElement(), NL3D::CPSSizedParticle::newSizeElement(), and uint32. +
+
00314 { +00315 CPSRibbonBase::newElement(emitterLocated, emitterIndex); +00316 newColorElement(emitterLocated, emitterIndex); +00317 newSizeElement(emitterLocated, emitterIndex); +00318 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
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(), NL3D::CPSRibbonLookAt::newElement(), 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::CPSRibbon::NLMISC_DECLARE_CLASS ( CPSRibbon )
+
+ + + + + +
+ + + +
+ctor.
Parameters:
+ + + + +
nbSegmentInTail the number of segment the ribbon has in its tail
shape pointer to a shape that will be extruded along the ribbon. It must have a unit size and be located in the x-y plane. This will be copied
nbPointsInShape : the number of points in the shape
+
+
+

+ + + + +
+ + + + + + + + + + +
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::CPSRibbon::resize ( uint32 size ) [protected, virtual]
+
+ + + + + +
+ + + +
+inherited from CPSLocatedBindable +
+ +
+Reimplemented from NL3D::CPSRibbonBase. +
+Definition at line 331 of file ps_ribbon.cpp. +
+References nlassert, NL3D::CPSColoredParticle::resizeColor(), NL3D::CPSSizedParticle::resizeSize(), size, and uint32. +
+
00332 { +00333 nlassert(size < (1 << 16)); +00334 CPSRibbonBase::resize(size); +00335 resizeColor(size); +00336 resizeSize(size); +00337 } +

+

+ + + + +
+ + + + + + + + + + +
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(), NL3D::CPSRibbonLookAt::resize(), 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(), NL3D::CPSRibbonLookAt::resize(), 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::CPSRibbon::serial ( NLMISC::IStream & f ) throw (NLMISC::EStream) [virtual]
+
+ + + + + +
+ + + +
+================================================================================================================== +
+ +
+we had CPSParticle::serial(f), but this is not the base class anymore, so we emulate this... version 2 : auto-lod saved +
+Reimplemented from NL3D::CPSRibbonBase. +
+Definition at line 121 of file ps_ribbon.cpp. +
+References nlassert, NL3D::ITexture::serial(), NL3D::CPSRotated2DParticle::serialAngle2DScheme(), sint, and uint32. +
+
00122 { +00123 sint ver = f.serialVersion(2); +00124 if (ver == 1) +00125 { +00126 nlassert(f.isReading()); +00127 +00130 sint ver2 = f.serialVersion(2); +00131 +00132 // here is CPSLocatedBindable::serial(f) +00133 sint ver3 = f.serialVersion(4); +00134 f.serialPtr(_Owner); +00135 if (ver3 > 1) f.serialEnum(_LOD); +00136 if (ver3 > 2) f.serial(_Name); +00137 if (ver3 > 3) +00138 { +00139 if (f.isReading()) +00140 { +00141 uint32 id; +00142 f.serial(id); +00143 setExternID(id); +00144 } +00145 else +00146 { +00147 f.serial(_ExternID); +00148 } +00149 } +00150 +00151 if (ver2 >= 2) +00152 { +00153 bool bDisableAutoLOD; +00154 f.serial(bDisableAutoLOD); +00155 disableAutoLOD(bDisableAutoLOD); +00156 } +00157 +00158 uint32 tailNbSegs; +00159 bool colorFading; +00160 bool systemBasisEnabled; +00161 bool drEnabled; // dying ribbons, not supported in this version +00162 +00163 CPSColoredParticle::serialColorScheme(f); +00164 CPSSizedParticle::serialSizeScheme(f); +00165 +00166 // we dont use the 2d angle anymore...serial a dummy one +00167 { +00168 CDummy2DAngle _Dummy2DAngle; +00169 _Dummy2DAngle.serialAngle2DScheme(f); +00170 } +00171 +00172 f.serial(colorFading, systemBasisEnabled); +00173 serialMaterial(f); +00174 +00175 f.serial(drEnabled); +00176 f.serial(tailNbSegs); +00177 ITexture *tex; +00178 f.serialPolyPtr(tex); +00179 _Tex = tex; +00180 if (_Tex != NULL) +00181 { +00182 f.serial(_UFactor, _VFactor) ; +00183 } +00184 +00185 // shape serialization +00186 f.serialCont(_Shape); +00187 +00188 +00189 _NbSegs = tailNbSegs >> 1; +00190 if (_NbSegs < 1) _NbSegs = 2; +00191 setInterpolationMode(Linear); +00192 +00193 nlassert(_Owner); +00194 resize(_Owner->getMaxSize()); +00195 initDateVect(); +00196 resetFromOwner(); +00197 } +00198 +00199 +00200 if (ver >= 2) +00201 { +00202 CPSRibbonBase::serial(f); +00203 CPSColoredParticle::serialColorScheme(f); +00204 CPSSizedParticle::serialSizeScheme(f); +00205 CPSMaterial::serialMaterial(f); +00206 f.serialCont(_Shape); +00207 bool colorFading = _ColorFading; +00208 f.serial(colorFading); +00209 _ColorFading = colorFading; +00210 uint32 tailNbSegs = _NbSegs; +00211 f.serial(tailNbSegs); +00212 if (f.isReading()) +00213 { +00214 setTailNbSeg(_NbSegs); +00215 touch(); +00216 } +00217 ITexture *tex = _Tex; +00218 f.serialPolyPtr(tex); +00219 _Tex = tex; +00220 if (_Tex != NULL) +00221 { +00222 f.serial(_UFactor, _VFactor) ; +00223 } +00224 } +00225 if (f.isReading()) +00226 { +00227 touch(); +00228 } +00229 } +

+

+ + + + +
+ + + + + + + + + + +
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::CPSRibbon::setColorFading ( bool onOff = true ) [inline, virtual]
+
+ + + + + +
+ + + +
+(de)activate color fading when its done, colors fades to black along the ribbon. +
+Implements NL3D::CPSTailParticle. +
+Definition at line 76 of file ps_ribbon.h. +
+References _ColorFading, and touch(). +
+
00077 { +00078 _ColorFading = onOff; +00079 touch(); +00080 } +

+

+ + + + +
+ + + + + + + + + + +
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 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 CPSRibbon(), and NL3D::CPSTailDot::CPSTailDot(). +
+
00133 { +00134 _SegDuration = ellapsedTime; +00135 +00136 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
void NL3D::CPSRibbon::setShape ( const NLMISC::CVector * shape,
uint32 nbPointsInShape
)
+
+ + + + + +
+ + + +
+================================================================================================================== +
+set a new shape for the ribbon If the number of vertices in the shape has changed, the previous ribbon will be desroyed In fact, their radius will be 0 all along the tail
Parameters:
+ + + +
shape pointer to a shape that will be extruded along the ribbon. It must have a unit size and be located in the x-y plane (z can be used for effects) . This will be copied
nbPointsInShape : the number of points in the shape
+
+ +
+Definition at line 1129 of file ps_ribbon.cpp. +
+References nlassert, and uint32. +
+Referenced by CPSRibbon(). +
+
01130 { +01131 nlassert(nbPointsInShape >= 3); +01132 _Shape.resize(nbPointsInShape); +01133 std::copy(shape, shape + nbPointsInShape, _Shape.begin()); +01134 } +

+

+ + + + +
+ + + + + + + + + + +
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::CPSRibbon::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 93 of file ps_ribbon.h. +
+
00093 {} +

+

+ + + + +
+ + + + + + + + + + +
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::CPSRibbon::setTexFactor ( float uFactor = 1.f,
float vFactor = 1.f
) [inline]
+
+ + + + + +
+ + + +
+Set texture factors. +
+ +
+Definition at line 122 of file ps_ribbon.h. +
+References _UFactor, _VFactor, and touch(). +
+
00123 { +00124 _UFactor = uFactor; +00125 _VFactor = vFactor; +00126 touch(); +00127 } +

+

+ + + + +
+ + + + + + + + + + +
void NL3D::CPSRibbon::setTexture ( NLMISC::CSmartPtr< ITexture > tex ) [inline, virtual]
+
+ + + + + +
+ + + +
+set a texture +
+ +
+Implements NL3D::CPSTexturedParticleNoAnim. +
+Definition at line 120 of file ps_ribbon.h. +
+References touch(). +
+
00120 { _Tex = tex; touch(); } +

+

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

+

+ + + + +
+ + + + + + + + + +
void NL3D::CPSRibbon::setupGlobalColor ( ) [private]
+
+ + + + + +
+ + + +
+ +
+Definition at line 1100 of file ps_ribbon.cpp. +
+References setupTexturedGlobalColor(), and setupUntexturedGlobalColor(). +
+Referenced by displayRibbons(). +
+
01101 { +01102 if (_Tex != NULL) setupTexturedGlobalColor(); +01103 else setupUntexturedGlobalColor(); +01104 } +

+

+ + + + +
+ + + + + + + + + +
void NL3D::CPSRibbon::setupTexturedGlobalColor ( ) [inline, private]
+
+ + + + + +
+ + + +
+setup the global color if it is used +
+Definition at line 1026 of file ps_ribbon.cpp. +
+References _ColorFading, NL3D::CParticleSystem::getColorAttenuationScheme(), NL3D::CParticleSystem::getForceGlobalColorLightingFlag(), NL3D::CParticleSystem::getGlobalColor(), NL3D::CParticleSystem::getGlobalColorLighted(), NL3D::CParticleSystemProcess::getOwner(), NL3D::CParticleSystem::isUserColorUsed(), NLMISC::CRGBA::modulateFromColor(), NL3D::CMaterial::setColor(), NL3D::CMaterial::texConstantColor(), and NL3D::CPSParticle::usesGlobalColorLighting(). +
+Referenced by setupGlobalColor(). +
+
01027 { +01029 CParticleSystem &ps = *(_Owner->getOwner()); +01030 if (_ColorScheme) +01031 { +01032 if (ps.getForceGlobalColorLightingFlag() || usesGlobalColorLighting()) +01033 { +01034 if (_ColorFading) +01035 { +01036 _Mat.texConstantColor(2, ps.getGlobalColorLighted()); +01037 } +01038 else +01039 { +01040 _Mat.texConstantColor(1, ps.getGlobalColorLighted()); +01041 } +01042 } +01043 else +01044 { +01045 if (_ColorFading) +01046 { +01047 _Mat.texConstantColor(2, ps.getGlobalColor()); +01048 } +01049 else +01050 { +01051 _Mat.texConstantColor(1, ps.getGlobalColor()); +01052 } +01053 } +01054 } +01055 else // GLOBAL COLOR with / without fading +01056 { +01057 if (ps.getForceGlobalColorLightingFlag() || usesGlobalColorLighting()) +01058 { +01059 NLMISC::CRGBA col; +01060 col.modulateFromColor(ps.getGlobalColorLighted(), _Color); +01061 if (_ColorFading) +01062 { +01063 _Mat.texConstantColor(1, col); +01064 } +01065 else // color attenuation, no fading : +01066 { +01067 _Mat.setColor(col); +01068 } +01069 } +01070 else +01071 if (ps.getColorAttenuationScheme() || ps.isUserColorUsed()) +01072 { +01073 NLMISC::CRGBA col; +01074 col.modulateFromColor(ps.getGlobalColor(), _Color); +01075 if (_ColorFading) +01076 { +01077 _Mat.texConstantColor(1, col); +01078 } +01079 else // color attenuation, no fading : +01080 { +01081 _Mat.setColor(col); +01082 } +01083 } +01084 else +01085 { +01086 if (_ColorFading) +01087 { +01088 _Mat.texConstantColor(1, _Color); +01089 } +01090 else // constant color +01091 { +01092 _Mat.setColor(_Color); +01093 } +01094 } +01095 } +01096 } +

+

+ + + + +
+ + + + + + + + + +
void NL3D::CPSRibbon::setupTextureMatrix ( ) [private]
+
+ + + + + +
+ + + +
+ +
+Definition at line 1107 of file ps_ribbon.cpp. +
+References _ColorFading, _UFactor, _VFactor, NL3D::CMaterial::enableUserTexMat(), NLMISC::CMatrix::setRot(), NL3D::CMaterial::setUserTexMat(), and uint. +
+Referenced by updateMaterial(). +
+
01108 { +01109 uint stage = (_ColorScheme != NULL && _ColorFading == true) ? 1 : 0; +01110 if (_UFactor != 1.f || _VFactor != 1.f) +01111 { +01112 _Mat.enableUserTexMat(stage); +01113 CMatrix texMat; +01114 texMat.setRot(_UFactor * NLMISC::CVector::I, +01115 _VFactor * NLMISC::CVector::J, +01116 NLMISC::CVector::K +01117 ); +01118 _Mat.setUserTexMat(stage, texMat); +01119 } +01120 else +01121 { +01122 _Mat.enableUserTexMat(stage, false); +01123 } +01124 _Mat.enableUserTexMat(1 - stage, false); +01125 } +

+

+ + + + +
+ + + + + + + + + +
void NL3D::CPSRibbon::setupUntexturedGlobalColor ( ) [inline, private]
+
+ + + + + +
+ + + +
+setup the global color if it is used +
+Definition at line 984 of file ps_ribbon.cpp. +
+References _ColorFading, NL3D::CParticleSystem::getColorAttenuationScheme(), NL3D::CParticleSystem::getForceGlobalColorLightingFlag(), NL3D::CParticleSystem::getGlobalColor(), NL3D::CParticleSystem::getGlobalColorLighted(), NL3D::CParticleSystemProcess::getOwner(), NL3D::CParticleSystem::isUserColorUsed(), NLMISC::CRGBA::modulateFromColor(), NL3D::CMaterial::setColor(), NL3D::CMaterial::texConstantColor(), and NL3D::CPSParticle::usesGlobalColorLighting(). +
+Referenced by setupGlobalColor(). +
+
00985 { +00987 CParticleSystem &ps = *(_Owner->getOwner()); +00988 if (_ColorScheme) +00989 { +00990 if (ps.getForceGlobalColorLightingFlag() || usesGlobalColorLighting()) +00991 { +00992 _Mat.texConstantColor(0, ps.getGlobalColorLighted()); +00993 } +00994 else +00995 { +00996 _Mat.texConstantColor(0, ps.getGlobalColor()); +00997 } +00998 } +00999 else // GLOBAL COLOR with / without fading +01000 { +01001 NLMISC::CRGBA col; +01002 if (ps.getForceGlobalColorLightingFlag() || usesGlobalColorLighting()) +01003 { +01004 col.modulateFromColor(ps.getGlobalColorLighted(), _Color); +01005 } +01006 else if (ps.getColorAttenuationScheme() || ps.isUserColorUsed()) +01007 { +01008 col.modulateFromColor(ps.getGlobalColor(), _Color); +01009 } +01010 else +01011 { +01012 col = _Color; +01013 } +01014 if (_ColorFading) +01015 { +01016 _Mat.texConstantColor(0, col); +01017 } +01018 else // color attenuation, no fading : +01019 { +01020 _Mat.setColor(col); +01021 } +01022 } +01023 } +

+

+ + + + +
+ + + + + + + + + + +
virtual void NL3D::CPSRibbon::setZBias ( float value ) [inline, virtual]
+
+ + + + + +
+ + + +
+ +
+Reimplemented from NL3D::CPSMaterial. +
+Definition at line 182 of file ps_ribbon.h. +
+References value. +
+
00182 { 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::CPSRibbon::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 266 of file ps_ribbon.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(). +
+
00267 { +00268 if (pass == PSMotion) +00269 { +00270 if (!_Parametric) +00271 { +00272 updateGlobals(realET); +00273 } +00274 } +00275 else +00276 if ( +00277 (pass == PSBlendRender && hasTransparentFaces()) +00278 || (pass == PSSolidRender && hasOpaqueFaces()) +00279 ) +00280 { +00281 uint32 step; +00282 uint numToProcess; +00283 computeSrcStep(step, numToProcess); +00284 if (!numToProcess) return; +00285 +00287 CParticleSystem &ps = *(_Owner->getOwner()); +00288 if (ps.getForceGlobalColorLightingFlag() || usesGlobalColorLighting()) +00289 { +00290 _Mat.setColor(ps.getGlobalColorLighted()); +00291 } +00292 else +00293 { +00294 _Mat.setColor(ps.getGlobalColor()); +00295 } +00296 +00301 displayRibbons(numToProcess, step); +00302 +00303 } +00304 else +00305 if (pass == PSToolRender) // edition mode only +00306 { +00307 //showTool(); +00308 } +00309 } +

+

+ + + + +
+ + + + + + + + + +
virtual bool NL3D::CPSRibbon::supportGlobalColorLighting ( ) const [inline, virtual]
+
+ + + + + +
+ + + +
+ +
+Implements NL3D::CPSParticle. +
+Definition at line 176 of file ps_ribbon.h. +
+
00176 { return true; } +

+

+ + + + +
+ + + + + + + + + +
void NL3D::CPSRibbon::touch ( ) [inline, private]
+
+ + + + + +
+ + + +
+ +
+Definition at line 260 of file ps_ribbon.h. +
+References _Touch. +
+Referenced by displayRibbons(), setColorFading(), setTexFactor(), setTexture(), and updateMatAndVbForColor(). +
+
00260 { _Touch = 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(), NL3D::CPSRibbonLookAt::step(), and 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::CPSRibbon::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 340 of file ps_ribbon.cpp. +
+References touch(). +
+
00341 { +00342 touch(); +00343 } +

+

+ + + + +
+ + + + + + + + + +
void NL3D::CPSRibbon::updateMaterial ( ) [private]
+
+ + + + + +
+ + + +
+ +
+Definition at line 967 of file ps_ribbon.cpp. +
+References _Touch, setupTextureMatrix(), updateTexturedMaterial(), and updateUntexturedMaterial(). +
+Referenced by displayRibbons(). +
+
00968 { +00969 if (!_Touch) return; +00970 if (_Tex != NULL) +00971 { +00972 updateTexturedMaterial(); +00973 setupTextureMatrix(); +00974 } +00975 else +00976 { +00977 updateUntexturedMaterial(); +00978 } +00979 } +

+

+ + + + +
+ + + + + + + + + +
void NL3D::CPSRibbon::updateTexturedMaterial ( ) [inline, private]
+
+ + + + + +
+ + + +
+fading is stored in last stage (work only with 3 stages...) +
+Definition at line 890 of file ps_ribbon.cpp. +
+References _ColorFading, _Touch, NL3D::CreateGradientTexture(), NL3D::CParticleSystem::getColorAttenuationScheme(), NL3D::CParticleSystem::getForceGlobalColorLightingFlag(), NL3D::CParticleSystemProcess::getOwner(), NL3D::CParticleSystem::isUserColorUsed(), NL3D::CMaterial::setTexture(), NL3D::SetupModulatedStage(), and NL3D::CPSParticle::usesGlobalColorLighting(). +
+Referenced by updateMaterial(). +
+
00891 { +00893 // TEXTURED RIBBON // +00895 +00896 static NLMISC::CRefPtr<ITexture> ptGradTexture; +00897 CParticleSystem &ps = *(_Owner->getOwner()); +00898 if (_ColorScheme) +00899 { // PER RIBBON COLOR +00900 if (ps.getForceGlobalColorLightingFlag() || usesGlobalColorLighting() || ps.getColorAttenuationScheme() || ps.isUserColorUsed()) +00901 { +00902 if (_ColorFading) // global color + fading + per ribbon color +00903 { +00904 if (ptGradTexture == NULL) // have we got a gradient texture ? +00905 { +00906 ptGradTexture = CreateGradientTexture(); // create it +00907 } +00909 _Mat.setTexture(0, ptGradTexture); +00910 _Mat.setTexture(1, _Tex); +00911 CPSMaterial::forceTexturedMaterialStages(3); // use constant color 0 * diffuse, 1 stage needed +00912 SetupModulatedStage(_Mat, 0, CMaterial::Texture, CMaterial::Diffuse); +00913 SetupModulatedStage(_Mat, 1, CMaterial::Texture, CMaterial::Previous); +00914 SetupModulatedStage(_Mat, 2, CMaterial::Previous, CMaterial::Constant); +00915 } +00916 else // per ribbon color with global color +00917 { +00918 _Mat.setTexture(0, _Tex); +00919 CPSMaterial::forceTexturedMaterialStages(2); // use constant color 0 * diffuse, 1 stage needed +00920 SetupModulatedStage(_Mat, 0, CMaterial::Texture, CMaterial::Diffuse); +00921 SetupModulatedStage(_Mat, 1, CMaterial::Previous, CMaterial::Constant); +00922 } +00923 } +00924 else +00925 { +00926 if (_ColorFading) // per ribbon color, fading : 2 textures needed +00927 { +00928 if (ptGradTexture == NULL) // have we got a gradient texture ? +00929 { +00930 ptGradTexture = CreateGradientTexture(); // create it +00931 } +00932 _Mat.setTexture(0, ptGradTexture); +00933 _Mat.setTexture(1, _Tex); +00934 CPSMaterial::forceTexturedMaterialStages(2); +00935 SetupModulatedStage(_Mat, 0, CMaterial::Texture, CMaterial::Diffuse); // texture * ribbon color +00936 SetupModulatedStage(_Mat, 1, CMaterial::Texture, CMaterial::Previous); // * gradient +00937 } +00938 else // per color ribbon with no fading, and no global color +00939 { +00940 _Mat.setTexture(0, _Tex); +00941 CPSMaterial::forceTexturedMaterialStages(1); // no texture use constant diffuse only +00942 SetupModulatedStage(_Mat, 0, CMaterial::Texture, CMaterial::Diffuse); +00943 } +00944 } +00945 } +00946 else // GLOBAL COLOR +00947 { +00948 +00949 if (_ColorFading) // gradient is encoded in diffuse +00950 { +00951 _Mat.setTexture(0, _Tex); +00952 CPSMaterial::forceTexturedMaterialStages(2); // use constant color 0 * diffuse, 1 stage needed +00953 SetupModulatedStage(_Mat, 0, CMaterial::Texture, CMaterial::Diffuse); +00954 SetupModulatedStage(_Mat, 1, CMaterial::Previous, CMaterial::Constant); +00955 } +00956 else // constant color +00957 { +00958 _Mat.setTexture(0, _Tex); +00959 CPSMaterial::forceTexturedMaterialStages(1); // no texture use constant diffuse only +00960 SetupModulatedStage(_Mat, 0, CMaterial::Texture, CMaterial::Diffuse); +00961 } +00962 } +00963 _Touch = false; +00964 } +

+

+ + + + +
+ + + + + + + + + +
void NL3D::CPSRibbon::updateUntexturedMaterial ( ) [inline, private]
+
+ + + + + +
+ + + +
+ +
+Definition at line 824 of file ps_ribbon.cpp. +
+References _ColorFading, _Touch, NL3D::CreateGradientTexture(), NL3D::CParticleSystem::getColorAttenuationScheme(), NL3D::CParticleSystem::getForceGlobalColorLightingFlag(), NL3D::CParticleSystemProcess::getOwner(), NL3D::CParticleSystem::isUserColorUsed(), NL3D::CMaterial::setTexture(), NL3D::SetupModulatedStage(), and NL3D::CPSParticle::usesGlobalColorLighting(). +
+Referenced by updateMaterial(). +
+
00825 { +00827 // UNTEXTURED RIBBON // +00829 +00830 static NLMISC::CRefPtr<ITexture> ptGradTexture; +00831 +00832 CParticleSystem &ps = *(_Owner->getOwner()); +00833 if (_ColorScheme) +00834 { // PER RIBBON COLOR +00835 if (ps.getForceGlobalColorLightingFlag() || usesGlobalColorLighting() || ps.getColorAttenuationScheme() || ps.isUserColorUsed()) +00836 { +00837 if (_ColorFading) // global color + fading + per ribbon color +00838 { +00839 // the first stage is used to get fading * global color +00840 // the second stage multiply the result by the diffuse colot +00841 if (ptGradTexture == NULL) // have we got a gradient texture ? +00842 { +00843 ptGradTexture = CreateGradientTexture(); +00844 } +00845 _Mat.setTexture(0, ptGradTexture); +00846 CPSMaterial::forceTexturedMaterialStages(2); // use constant color 0 * diffuse, 1 stage needed +00847 SetupModulatedStage(_Mat, 0, CMaterial::Texture, CMaterial::Constant); +00848 SetupModulatedStage(_Mat, 1, CMaterial::Previous, CMaterial::Diffuse); +00849 } +00850 else // per ribbon color with global color +00851 { +00852 CPSMaterial::forceTexturedMaterialStages(1); // use constant color 0 * diffuse, 1 stage needed +00853 SetupModulatedStage(_Mat, 0, CMaterial::Diffuse, CMaterial::Constant); +00854 } +00855 } +00856 else +00857 { +00858 if (_ColorFading) // per ribbon color, no fading +00859 { +00860 if (ptGradTexture == NULL) // have we got a gradient texture ? +00861 { +00862 ptGradTexture = CreateGradientTexture(); +00863 } +00864 _Mat.setTexture(0, ptGradTexture); +00865 CPSMaterial::forceTexturedMaterialStages(1); +00866 SetupModulatedStage(_Mat, 0, CMaterial::Texture, CMaterial::Diffuse); +00867 } +00868 else // per color ribbon with no fading, and no global color +00869 { +00870 CPSMaterial::forceTexturedMaterialStages(0); // no texture use constant diffuse only +00871 } +00872 } +00873 } +00874 else // GLOBAL COLOR +00875 { +00876 if (_ColorFading) +00877 { +00878 CPSMaterial::forceTexturedMaterialStages(1); // use constant color 0 * diffuse, 1 stage needed +00879 SetupModulatedStage(_Mat, 0, CMaterial::Diffuse, CMaterial::Constant); +00880 } +00881 else // color attenuation, no fading : +00882 { +00883 CPSMaterial::forceTexturedMaterialStages(0); // no texture use constant diffuse only +00884 } +00885 } +00886 _Touch = false; +00887 } +

+

+ + + + +
+ + + + + + + + + +
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(), NL3D::CPSRibbonLookAt::displayRibbons(), displayRibbons(), NL3D::CPSShockWave::draw(), NL3D::CPSDot::draw(), NL3D::CPSTailDot::setupGlobalColor(), NL3D::CPSFanLight::setupMaterial(), setupTexturedGlobalColor(), setupUntexturedGlobalColor(), NL3D::CPSTailDot::step(), NL3D::CPSRibbonLookAt::step(), step(), NL3D::CPSQuad::updateMatBeforeRendering(), NL3D::CPSTailDot::updateMaterial(), updateTexturedMaterial(), and updateUntexturedMaterial(). +
+
00103 { return _UsesGlobalColorLighting; } +

+

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

+ + + + +
+ + +
CPSRibbon::TVBMap NL3D::CPSRibbon::_ColoredVBMap [static, private] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 106 of file ps_ribbon.cpp.
+

+ + + + +
+ + +
bool NL3D::CPSRibbon::_ColorFading [private] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 254 of file ps_ribbon.h. +
+Referenced by getColorFading(), getVBnPB(), setColorFading(), setupTexturedGlobalColor(), setupTextureMatrix(), setupUntexturedGlobalColor(), updateTexturedMaterial(), and updateUntexturedMaterial().
+

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

+ + + + +
+ + +
CPSRibbon::TVBMap NL3D::CPSRibbon::_FadedColoredVBMap [static, private] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 107 of file ps_ribbon.cpp. +
+Referenced by getVBnPB().
+

+ + + + +
+ + +
CPSRibbon::TVBMap NL3D::CPSRibbon::_FadedVBMap [static, private] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 105 of file ps_ribbon.cpp. +
+Referenced by getVBnPB().
+

+ + + + +
+ + +
bool NL3D::CPSRibbon::_ForceLighted [private] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 257 of file ps_ribbon.h. +
+Referenced by displayRibbons().
+

+ + + + +
+ + +
bool NL3D::CPSRibbon::_GlobalColor [private] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 255 of file ps_ribbon.h.
+

+ + + + +
+ + +
bool NL3D::CPSRibbon::_Lighted [private] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 256 of file ps_ribbon.h. +
+Referenced by displayRibbons().
+

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

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

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

+ + + + +
+ + +
CPSVector<NLMISC::CVector>::V NL3D::CPSRibbon::_Shape [private] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 250 of file ps_ribbon.h.
+

+ + + + +
+ + +
CSmartPtr<ITexture> NL3D::CPSRibbon::_Tex [private] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 249 of file ps_ribbon.h.
+

+ + + + +
+ + +
CPSRibbon::TVBMap NL3D::CPSRibbon::_TexColoredVBMap [static, private] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 111 of file ps_ribbon.cpp. +
+Referenced by getVBnPB().
+

+ + + + +
+ + +
CPSRibbon::TVBMap NL3D::CPSRibbon::_TexFadedColoredVBMap [static, private] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 112 of file ps_ribbon.cpp. +
+Referenced by getVBnPB().
+

+ + + + +
+ + +
CPSRibbon::TVBMap NL3D::CPSRibbon::_TexFadedVBMap [static, private] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 110 of file ps_ribbon.cpp. +
+Referenced by getVBnPB().
+

+ + + + +
+ + +
CPSRibbon::TVBMap NL3D::CPSRibbon::_TexVBMap [static, private] +
+
+ + + + + +
+ + + +
+textured ribbons +
+ +
+Definition at line 109 of file ps_ribbon.cpp.
+

+ + + + +
+ + +
bool NL3D::CPSRibbon::_Touch [private] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 258 of file ps_ribbon.h. +
+Referenced by touch(), updateMaterial(), updateTexturedMaterial(), and updateUntexturedMaterial().
+

+ + + + +
+ + +
float NL3D::CPSRibbon::_UFactor [private] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 251 of file ps_ribbon.h. +
+Referenced by getUFactor(), setTexFactor(), and setupTextureMatrix().
+

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

+ + + + +
+ + +
CPSRibbon::TVBMap NL3D::CPSRibbon::_VBMap [static, private] +
+
+ + + + + +
+ + + +
+untextured ribbons +
+ +
+Definition at line 104 of file ps_ribbon.cpp.
+

+ + + + +
+ + +
float NL3D::CPSRibbon::_VFactor [private] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 251 of file ps_ribbon.h. +
+Referenced by getVFactor(), setTexFactor(), and setupTextureMatrix().
+

+ + + + +
+ + +
const NLMISC::CVector NL3D::CPSRibbon::HeightSides [static] +
+
+ + + + + +
+ + + +
+Initial value:
+{ + NLMISC::CVector(-0.5f, 1, 0), + NLMISC::CVector(0.5f, 1, 0), + NLMISC::CVector(1, 0.5f, 0), + NLMISC::CVector(1, -0.5f, 0), + NLMISC::CVector(0.5f, -1, 0), + NLMISC::CVector(-0.5f, -1, 0), + NLMISC::CVector(-1, -0.5f, 0), + NLMISC::CVector(-1, 0.5f, 0) +} +
Predefined shape : height sides. +
+ +
+Definition at line 76 of file ps_ribbon.cpp.
+

+ + + + +
+ + +
const NLMISC::CVector NL3D::CPSRibbon::Losange [static] +
+
+ + + + + +
+ + + +
+Initial value:
+{ + NLMISC::CVector(0, 1.f, 0), + NLMISC::CVector(1.f, 0, 0), + NLMISC::CVector(0, -1.f, 0), + NLMISC::CVector(-1.f, 0, 0) +} +
Predefined shape : a regular losange shape. +
+ +
+Definition at line 68 of file ps_ribbon.cpp.
+

+ + + + +
+ + +
const uint NL3D::CPSRibbon::NbVerticesInHeightSide = sizeof(CPSRibbon::HeightSides) / sizeof(CVector) [static] +
+
+ + + + + +
+ + + +
+number of vertices in the height side (must be 8 ... :) ) +
+ +
+Definition at line 100 of file ps_ribbon.cpp.
+

+ + + + +
+ + +
const uint NL3D::CPSRibbon::NbVerticesInLosange = sizeof(Losange) / sizeof(CVector) [static] +
+
+ + + + + +
+ + + +
+number of vertices in the losange +
+ +
+Definition at line 99 of file ps_ribbon.cpp.
+

+ + + + +
+ + +
const uint NL3D::CPSRibbon::NbVerticesInPentagram = sizeof(CPSRibbon::Pentagram) / sizeof(CVector) [static] +
+
+ + + + + +
+ + + +
+Predefined shape : height sides. +
+ +
+Definition at line 101 of file ps_ribbon.cpp.
+

+ + + + +
+ + +
const uint NL3D::CPSRibbon::NbVerticesInTriangle = sizeof(CPSRibbon::Triangle) / sizeof(CVector) [static] +
+
+ + + + + +
+ + + +
+Predefined shape : height sides. +
+ +
+Definition at line 98 of file ps_ribbon.cpp. +
+Referenced by CPSRibbon().
+

+ + + + +
+ + +
const NLMISC::CVector NL3D::CPSRibbon::Pentagram [static] +
+
+ + + + + +
+ + + +
+Initial value:
+{ + NLMISC::CVector(0, 1, 0), + NLMISC::CVector(1, -1, 0), + NLMISC::CVector(-1, 0, 0), + NLMISC::CVector(1, 0, 0), + NLMISC::CVector(-1, -1, 0) +} +
Predifined shape : pentagram. +
+ +
+Definition at line 89 of file ps_ribbon.cpp.
+

+ + + + +
+ + +
const NLMISC::CVector NL3D::CPSRibbon::Triangle [static] +
+
+ + + + + +
+ + + +
+Initial value:
+{ + NLMISC::CVector(0, 1, 0), + NLMISC::CVector(1, -1, 0), + NLMISC::CVector(-1, -1, 0), +} +
Predifined shape : triangle. +
+ +
+Definition at line 61 of file ps_ribbon.cpp.
+

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

Generated on Tue Mar 16 07:22:43 2004 for NeL by + +

+1.3.6

+ + -- cgit v1.2.1


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)
CVBnPB &	getVBnPB ()
	get a vertex buffer and a primitive suited for the current ribbon
TVBMap	_ColoredVBMap
TVBMap	_FadedColoredVBMap
TVBMap	_FadedVBMap
TVBMap	_TexColoredVBMap
TVBMap	_TexFadedColoredVBMap
TVBMap	_TexFadedVBMap
TVBMap	_TexVBMap
	textured ribbons
TVBMap	_VBMap
	untextured ribbons
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)
IDriver *	getDriver () const
	shortcut to get an instance of the driver
uint32	getExternID (void) const
	get the extern ID of this located bindable
const CFontGenerator *	getFontGenerator (void) const
	Shortcut to get the font generator if one was set (const version).
CFontGenerator *	getFontGenerator (void)
	Shortcut to get the font generator if one was set.
const CFontManager *	getFontManager (void) const
	Shortcut to get the font manager if one was set (const version).
CFontManager *	getFontManager (void)
	***************************************************************************************
const NLMISC::CMatrix &	getInvertedSysMat (void) const
	shortcut to get the inverted matrix of the system
const NLMISC::CMatrix &	getInvertedViewMat (void) const
	shortcut to get the inverted view matrix
const NLMISC::CMatrix &	getLocalToWorldMatrix () const
	Shortcut to get the local to world matrix.
TPSLod	getLOD (void) const
	get the valid lods for that object
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)
uint32	getNbVerticesInShape (void) const
	get the number of vertice in the shape used for ribbons
const CPSLocated *	getOwner (void) const
	get the located that owns this bindable (const version)
CPSLocated *	getOwner (void)
	get the located that owns this bindable
virtual uint32	getPriority (void) const
	return priority
void	getShape (NLMISC::CVector *shape) const
	==================================================================================================================
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::CMatrix &	getSysMat (void) const
	***************************************************************************************
const ITexture *	getTexture (void) const
ITexture *	getTexture (void)
	get the texture used
uint32	getType (void) const
	return this bindable type
float	getUFactor (void) const
virtual bool	getUserMatrixUsageCount () const
float	getVFactor (void) const
const NLMISC::CMatrix &	getViewMat (void) const
	shortcut to get the view matrix
virtual bool	hasEmitters (void) const
	tells wether there are alive emitters
virtual bool	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	setShape (const NLMISC::CVector *shape, uint32 nbPointsInShape)
	==================================================================================================================
void	setSize (float size)
	Set a constant size for the particles.
void	setSizeScheme (CPSAttribMaker< float > *size)
void	setTexFactor (float uFactor=1.f, float vFactor=1.f)
	Set texture factors.
void	setTexture (NLMISC::CSmartPtr< ITexture > tex)
	set a texture
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
	CPSRibbon ()
	NLMISC_DECLARE_CLASS (CPSRibbon)
virtual void	serial (NLMISC::IStream &f) throw (NLMISC::EStream)
	==================================================================================================================
	~CPSRibbon ()
	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)
Static Public Attributes
Predefined shapes
const NLMISC::CVector	HeightSides []
	Predefined shape : height sides.
const NLMISC::CVector	Losange []
	Predefined shape : a regular losange shape.
const uint	NbVerticesInHeightSide = sizeof(CPSRibbon::HeightSides) / sizeof(CVector)
	number of vertices in the height side (must be 8 ... :) )
const uint	NbVerticesInLosange = sizeof(Losange) / sizeof(CVector)
	number of vertices in the losange
const uint	NbVerticesInPentagram = sizeof(CPSRibbon::Pentagram) / sizeof(CVector)
	Predefined shape : height sides.
const uint	NbVerticesInTriangle = sizeof(CPSRibbon::Triangle) / sizeof(CVector)
	Predefined shape : height sides.
const NLMISC::CVector	Pentagram []
	Predifined shape : pentagram.
const NLMISC::CVector	Triangle []
	Predifined shape : triangle.
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 CPSLocated *	getColorOwner (void)
	From CPSColoredParticle.
uint32	getRibbonIndex () const
const TFloatVect &	getSamplingDate () const
virtual CPSLocated *	getSizeOwner (void)
	From CPSSizedParticle.
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
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
uint	getNumVerticesInSlice () const
	Get the number of vertices in each slices (depends on wether the ribbon is textured or not).
void	setupGlobalColor ()
void	setupTexturedGlobalColor ()
void	setupTextureMatrix ()
void	setupUntexturedGlobalColor ()
void	touch ()
virtual void	updateMatAndVbForColor (void)
	update the material and the vb so that they match the color scheme. Inherited from CPSColoredParticle
void	updateMaterial ()
void	updateTexturedMaterial ()
void	updateUntexturedMaterial ()
Private Attributes
bool	_ColorFading: 1
bool	_ForceLighted: 1
bool	_GlobalColor: 1
bool	_Lighted: 1
CPSVector< NLMISC::CVector +>::V	_Shape
CSmartPtr< ITexture >	_Tex
bool	_Touch: 1
float	_UFactor
float	_VFactor
Friends
class	CPSLocated

NL3D::CPSRibbon Class Reference

Detailed Description

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

Public Types

Public Member Functions

Static Public Attributes

Protected Types

Protected Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Friends

Member Typedef Documentation

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation

Field Documentation