2010-05-06 00:08:41 +00:00
// NeL - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
// Copyright (C) 2010 Winch Gate Property Limited
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
# include "std3d.h"
# include "nel/3d/particle_system.h"
# include "nel/3d/ps_located.h"
# include "nel/3d/driver.h"
# include "nel/3d/vertex_buffer.h"
# include "nel/3d/material.h"
# include "nel/3d/index_buffer.h"
# include "nel/3d/nelu.h"
# include "nel/3d/ps_util.h"
# include "nel/3d/ps_particle.h"
# include "nel/3d/ps_emitter.h"
# include "nel/3d/ps_sound.h"
# include "nel/3d/particle_system_shape.h"
# include "nel/3d/ps_located.h"
# include "nel/misc/aabbox.h"
# include "nel/misc/file.h"
# include "nel/misc/stream.h"
// tmp
# include "nel/3d/particle_system_model.h"
# ifdef NL_DEBUG
# define CHECK_INTEGRITY checkIntegrity();
# else
# define CHECK_INTEGRITY
# endif
namespace NL3D
{
uint32 CParticleSystem : : NbParticlesDrawn = 0 ;
UPSSoundServer * CParticleSystem : : _SoundServer = NULL ;
CParticleSystem : : TGlobalValuesMap CParticleSystem : : _GlobalValuesMap ;
CParticleSystem : : TGlobalVectorValuesMap CParticleSystem : : _GlobalVectorValuesMap ;
// sim step infos
TAnimationTime CParticleSystem : : EllapsedTime = 0.f ;
TAnimationTime CParticleSystem : : InverseTotalEllapsedTime = 0.f ;
TAnimationTime CParticleSystem : : RealEllapsedTime = 0.f ;
float CParticleSystem : : RealEllapsedTimeRatio = 1.f ;
bool CParticleSystem : : InsideSimLoop = false ;
bool CParticleSystem : : InsideRemoveLoop = false ;
bool CParticleSystem : : InsideNewElementsLoop = false ; ;
std : : vector < NLMISC : : CVector > CParticleSystem : : _SpawnPos ;
//bool FilterPS[10] = { false, false, false, false, false, false, false, false, false, false };
# ifdef NL_DEBUG
uint CParticleSystem : : _NumInstances = 0 ;
# endif
static const float PS_MIN_TIMEOUT = 1.f ; // the test that check if there are no particles left
# if defined(NL_DEBUG) || defined(NL_PS_DEBUG)
bool CParticleSystem : : _SerialIdentifiers = true ;
# else
bool CParticleSystem : : _SerialIdentifiers = false ;
# endif
bool CParticleSystem : : _ForceDisplayBBox = false ;
CParticleSystemModel * CParticleSystem : : OwnerModel = NULL ;
///////////////////////////////////
// CPaticleSystem implementation //
///////////////////////////////////
/// the default max distance of view for particle systems
const float PSDefaultMaxViewDist = 300.f ;
/*
* Constructor
*/
CParticleSystem : : CParticleSystem ( ) : _Driver ( NULL ) ,
_FontGenerator ( NULL ) ,
_FontManager ( NULL ) ,
_UserCoordSystemInfo ( NULL ) ,
_Date ( 0 ) ,
_LastUpdateDate ( - 1 ) ,
_CurrEditedElementLocated ( NULL ) ,
_CurrEditedElementIndex ( 0 ) ,
_Scene ( NULL ) ,
_TimeThreshold ( 0.15f ) ,
_SystemDate ( 0.f ) ,
_MaxNbIntegrations ( 2 ) ,
_LODRatio ( 0.5f ) ,
_OneMinusCurrentLODRatio ( 0 ) ,
_MaxViewDist ( PSDefaultMaxViewDist ) ,
_MaxDistLODBias ( 0.05f ) ,
_InvMaxViewDist ( 1.f / PSDefaultMaxViewDist ) ,
_InvCurrentViewDist ( 1.f / PSDefaultMaxViewDist ) ,
_AutoLODEmitRatio ( 0.f ) ,
_DieCondition ( none ) ,
_DelayBeforeDieTest ( - 1.f ) ,
_NumWantedTris ( 0 ) ,
_AnimType ( AnimInCluster ) ,
_UserParamGlobalValue ( NULL ) ,
_BypassGlobalUserParam ( 0 ) ,
_PresetBehaviour ( UserBehaviour ) ,
_AutoLODStartDistPercent ( 0.1f ) ,
_AutoLODDegradationExponent ( 1 ) ,
_ColorAttenuationScheme ( NULL ) ,
_GlobalColor ( NLMISC : : CRGBA : : White ) ,
_GlobalColorLighted ( NLMISC : : CRGBA : : White ) ,
_LightingColor ( NLMISC : : CRGBA : : White ) ,
_UserColor ( NLMISC : : CRGBA : : White ) ,
_ComputeBBox ( true ) ,
_BBoxTouched ( true ) ,
_AccurateIntegration ( true ) ,
_CanSlowDown ( true ) ,
_DestroyModelWhenOutOfRange ( false ) ,
_DestroyWhenOutOfFrustum ( false ) ,
_Sharing ( false ) ,
_AutoLOD ( false ) ,
_KeepEllapsedTimeForLifeUpdate ( false ) ,
_AutoLODSkipParticles ( false ) ,
_EnableLoadBalancing ( true ) ,
_EmitThreshold ( true ) ,
_BypassIntegrationStepLimit ( false ) ,
_ForceGlobalColorLighting ( false ) ,
_AutoComputeDelayBeforeDeathTest ( true ) ,
_AutoCount ( false ) ,
_HiddenAtCurrentFrame ( true ) ,
_HiddenAtPreviousFrame ( true )
{
NL_PS_FUNC_MAIN ( CParticleSystem_CParticleSystem )
std : : fill ( _UserParam , _UserParam + MaxPSUserParam , 0.0f ) ;
# ifdef NL_DEBUG
+ + _NumInstances ;
# endif
}
std : : vector < NLMISC : : CSmartPtr < CParticleSystem : : CSpawnVect > > CParticleSystem : : _Spawns ; // spawns for the current system being processed
std : : vector < uint > CParticleSystem : : _ParticleToRemove ;
std : : vector < sint > CParticleSystem : : _ParticleRemoveListIndex ;
///=======================================================================================
/// immediatly shut down all the sound in this system
void CParticleSystem : : stopSound ( )
{
NL_PS_FUNC_MAIN ( CParticleSystem_stopSound )
for ( uint k = 0 ; k < this - > getNbProcess ( ) ; + + k )
{
CPSLocated * psl = dynamic_cast < NL3D : : CPSLocated * > ( this - > getProcess ( k ) ) ;
if ( psl )
{
for ( uint l = 0 ; l < psl - > getNbBoundObjects ( ) ; + + l )
{
if ( psl - > getBoundObject ( l ) - > getType ( ) = = PSSound )
{
static_cast < CPSSound * > ( psl - > getBoundObject ( l ) ) - > stopSound ( ) ;
}
}
}
}
}
///=======================================================================================
void CParticleSystem : : reactivateSound ( )
{
NL_PS_FUNC_MAIN ( CParticleSystem_reactivateSound )
for ( uint k = 0 ; k < this - > getNbProcess ( ) ; + + k )
{
CPSLocated * psl = dynamic_cast < NL3D : : CPSLocated * > ( this - > getProcess ( k ) ) ;
if ( psl )
{
for ( uint l = 0 ; l < psl - > getNbBoundObjects ( ) ; + + l )
{
if ( psl - > getBoundObject ( l ) - > getType ( ) = = PSSound )
{
static_cast < CPSSound * > ( psl - > getBoundObject ( l ) ) - > reactivateSound ( ) ;
}
}
}
}
}
///=======================================================================================
void CParticleSystem : : enableLoadBalancing ( bool enabled /*=true*/ )
{
NL_PS_FUNC_MAIN ( CParticleSystem_enableLoadBalancing )
if ( enabled )
{
//notifyMaxNumFacesChanged();
}
_EnableLoadBalancing = enabled ;
}
///=======================================================================================
/*
void CParticleSystem : : notifyMaxNumFacesChanged ( void )
{
if ( ! _EnableLoadBalancing ) return ;
_MaxNumFacesWanted = 0 ;
for ( TProcessVect : : iterator it = _ProcessVect . begin ( ) ; it ! = _ProcessVect . end ( ) ; + + it )
{
_MaxNumFacesWanted + = ( * it ) - > querryMaxWantedNumFaces ( ) ;
}
}
*/
///=======================================================================================
void CParticleSystem : : updateNumWantedTris ( )
{
NL_PS_FUNC_MAIN ( CParticleSystem_updateNumWantedTris )
_NumWantedTris = 0 ;
for ( TProcessVect : : iterator it = _ProcessVect . begin ( ) ; it ! = _ProcessVect . end ( ) ; + + it )
{
_NumWantedTris + = ( * it ) - > getNumWantedTris ( ) ;
}
}
///=======================================================================================
float CParticleSystem : : getWantedNumTris ( float dist )
{
NL_PS_FUNC_MAIN ( CParticleSystem_getWantedNumTris )
if ( ! _EnableLoadBalancing ) return 0 ; // no contribution to the load balancing
if ( dist > _MaxViewDist ) return 0 ;
float retValue = ( ( 1.f - dist * _InvMaxViewDist ) * _NumWantedTris ) ;
///nlassertex(retValue >= 0 && retValue < 10000, ("dist = %f, _MaxViewDist = %f, _MaxNumFacesWanted = %d, retValue = %f", dist, _MaxViewDist, _MaxNumFacesWanted, retValue));
return retValue ;
}
///=======================================================================================
void CParticleSystem : : setNumTris ( uint numFaces )
{
NL_PS_FUNC_MAIN ( CParticleSystem_setNumTris )
if ( _EnableLoadBalancing )
{
float modelDist = ( getSysMat ( ) . getPos ( ) - _InvertedViewMat . getPos ( ) ) . norm ( ) ;
/*uint numFaceWanted = (uint) getWantedNumTris(modelDist);*/
const float epsilon = 10E-5 f ;
uint wantedNumTri = ( uint ) getWantedNumTris ( modelDist ) ;
if ( numFaces > = wantedNumTri | | wantedNumTri = = 0 | | _NumWantedTris = = 0 | | modelDist < epsilon )
{
_InvCurrentViewDist = _InvMaxViewDist ;
}
else
{
_InvCurrentViewDist = ( _NumWantedTris - numFaces ) / ( _NumWantedTris * modelDist ) ;
}
}
else
{
// always take full detail when there's no load balancing
_InvCurrentViewDist = _InvMaxViewDist ;
}
}
///=======================================================================================
/// dtor
CParticleSystem : : ~ CParticleSystem ( )
{
NL_PS_FUNC_MAIN ( CParticleSystem_CParticleSystemDtor )
for ( TProcessVect : : iterator it = _ProcessVect . begin ( ) ; it ! = _ProcessVect . end ( ) ; + + it )
{
delete * it ;
}
if ( _ColorAttenuationScheme )
delete _ColorAttenuationScheme ;
if ( _UserParamGlobalValue )
delete _UserParamGlobalValue ;
delete _UserCoordSystemInfo ;
# ifdef NL_DEBUG
- - _NumInstances ;
# endif
}
///=======================================================================================
void CParticleSystem : : setViewMat ( const NLMISC : : CMatrix & m )
{
NL_PS_FUNC_MAIN ( CParticleSystem_setViewMat )
_ViewMat = m ;
_InvertedViewMat = m . inverted ( ) ;
}
///=======================================================================================
bool CParticleSystem : : hasEmitters ( void ) const
{
NL_PS_FUNC_MAIN ( CParticleSystem_hasEmitters )
for ( TProcessVect : : const_iterator it = _ProcessVect . begin ( ) ; it ! = _ProcessVect . end ( ) ; + + it )
{
if ( ( * it ) - > hasEmitters ( ) ) return true ;
}
return false ;
}
///=======================================================================================
bool CParticleSystem : : hasParticles ( ) const
{
NL_PS_FUNC_MAIN ( CParticleSystem_hasParticles )
for ( TProcessVect : : const_iterator it = _ProcessVect . begin ( ) ; it ! = _ProcessVect . end ( ) ; + + it )
{
if ( ( * it ) - > hasParticles ( ) ) return true ;
}
return false ;
}
///=======================================================================================
bool CParticleSystem : : hasTemporaryParticles ( ) const
{
NL_PS_FUNC_MAIN ( CParticleSystem_hasTemporaryParticles )
for ( TProcessVect : : const_iterator it = _ProcessVect . begin ( ) ; it ! = _ProcessVect . end ( ) ; + + it )
{
if ( ( * it ) - > isLocated ( ) )
{
CPSLocated * loc = static_cast < CPSLocated * > ( * it ) ;
if ( loc - > hasParticles ( ) ) return true ;
}
}
return false ;
}
///=======================================================================================
void CParticleSystem : : stepLocated ( TPSProcessPass pass )
{
NL_PS_FUNC_MAIN ( CParticleSystem_stepLocated )
for ( TProcessVect : : iterator it = _ProcessVect . begin ( ) ; it ! = _ProcessVect . end ( ) ; + + it )
{
( * it ) - > step ( pass ) ;
}
}
///=======================================================================================
# ifndef NL_DEBUG
inline
# endif
float CParticleSystem : : getDistFromViewer ( ) const
{
NL_PS_FUNC_MAIN ( CParticleSystem_getDistFromViewer )
const CVector d = getSysMat ( ) . getPos ( ) - _InvertedViewMat . getPos ( ) ;
return d . norm ( ) ;
}
///=======================================================================================
# ifndef NL_DEBUG
inline
# endif
float CParticleSystem : : updateLODRatio ( )
{
NL_PS_FUNC_MAIN ( CParticleSystem_updateLODRatio )
float dist = getDistFromViewer ( ) ;
_OneMinusCurrentLODRatio = 1.f - ( dist * _InvCurrentViewDist ) ;
NLMISC : : clamp ( _OneMinusCurrentLODRatio , 0.f , 1.f ) ;
return dist ;
}
///=======================================================================================
inline void CParticleSystem : : updateColor ( float distFromViewer )
{
NL_PS_FUNC_MAIN ( CParticleSystem_updateColor )
if ( _ColorAttenuationScheme )
{
float ratio = distFromViewer * _InvMaxViewDist ;
NLMISC : : clamp ( ratio , 0.f , 1.f ) ;
_GlobalColor = _ColorAttenuationScheme - > get ( ratio ) ;
}
else
{
_GlobalColor = NLMISC : : CRGBA : : White ;
}
_GlobalColor . modulateFromColor ( _GlobalColor , _UserColor ) ;
_GlobalColorLighted . modulateFromColor ( _GlobalColor , _LightingColor ) ;
}
/*
static void displaySysPos ( IDriver * drv , const CVector & pos , CRGBA col )
{
if ( ! drv ) return ;
drv - > setupModelMatrix ( CMatrix : : Identity ) ;
CPSUtil : : displayArrow ( drv , pos , CVector : : K , 1.f , CRGBA : : White , col ) ;
}
*/
///=======================================================================================
void CParticleSystem : : step ( TPass pass , TAnimationTime ellapsedTime , CParticleSystemShape & shape , CParticleSystemModel & model )
{
NL_PS_FUNC_MAIN ( CParticleSystem_step )
CHECK_INTEGRITY
OwnerModel = & model ;
nlassert ( _CoordSystemInfo . Matrix ) ; // matrix not set for position of system
if ( _UserCoordSystemInfo )
{
nlassert ( _CoordSystemInfo . Matrix ) ;
}
switch ( pass )
{
case SolidRender :
EllapsedTime = RealEllapsedTime = ellapsedTime ;
RealEllapsedTimeRatio = 1.f ;
/// When shared, the LOD ratio must be computed there
if ( _Sharing )
{
float dist = updateLODRatio ( ) ;
updateColor ( dist ) ;
}
else
{
updateColor ( getDistFromViewer ( ) ) ;
}
// update time
+ + _Date ;
// update global color
stepLocated ( PSSolidRender ) ;
break ;
case BlendRender :
EllapsedTime = RealEllapsedTime = ellapsedTime ;
RealEllapsedTimeRatio = 1.f ;
/// When shared, the LOD ratio must be computed there
/// When shared, the LOD ratio must be computed there
if ( _Sharing )
{
float dist = updateLODRatio ( ) ;
updateColor ( dist ) ;
}
else
{
updateColor ( getDistFromViewer ( ) ) ;
}
// update time
+ + _Date ;
// update global color
stepLocated ( PSBlendRender ) ;
if ( _ForceDisplayBBox )
{
NLMISC : : CAABBox box ;
computeBBox ( box ) ;
getDriver ( ) - > setupModelMatrix ( * _CoordSystemInfo . Matrix ) ;
CPSUtil : : displayBBox ( getDriver ( ) , box ) ;
}
break ;
case ToolRender :
EllapsedTime = RealEllapsedTime = ellapsedTime ;
RealEllapsedTimeRatio = 1.f ;
stepLocated ( PSToolRender ) ;
break ;
case Anim :
{
if ( ellapsedTime < = 0.f ) return ;
// update user param from global value if needed, unless this behaviour is bypassed has indicated by a flag in _BypassGlobalUserParam
if ( _UserParamGlobalValue )
{
nlctassert ( MaxPSUserParam < 8 ) ; // there should be less than 8 parameters because of mask stored in a byte
uint8 bypassMask = 1 ;
for ( uint k = 0 ; k < MaxPSUserParam ; + + k )
{
if ( _UserParamGlobalValue [ k ] & & ! ( _BypassGlobalUserParam & bypassMask ) ) // if there is a global value for this param and if the update is not bypassed
{
_UserParam [ k ] = _UserParamGlobalValue [ k ] - > second ;
}
bypassMask < < = 1 ;
}
}
//
uint nbPass = 1 ;
EllapsedTime = ellapsedTime ;
_BBoxTouched = true ;
if ( _AccurateIntegration )
{
if ( EllapsedTime > _TimeThreshold )
{
nbPass = ( uint32 ) ceilf ( EllapsedTime / _TimeThreshold ) ;
if ( ! _BypassIntegrationStepLimit & & nbPass > _MaxNbIntegrations )
{
nbPass = _MaxNbIntegrations ;
if ( _CanSlowDown )
{
EllapsedTime = _TimeThreshold ;
nlassert ( _TimeThreshold ! = 0 ) ;
InverseTotalEllapsedTime = 1.f / ( _TimeThreshold * nbPass ) ;
}
else
{
EllapsedTime = ellapsedTime / nbPass ;
InverseTotalEllapsedTime = ellapsedTime ! = 0 ? 1.f / ellapsedTime : 0.f ;
}
}
else
{
EllapsedTime = ellapsedTime / nbPass ;
InverseTotalEllapsedTime = ellapsedTime ! = 0 ? 1.f / ellapsedTime : 0.f ;
}
}
else
{
InverseTotalEllapsedTime = ellapsedTime ! = 0 ? 1.f / ellapsedTime : 0.f ;
}
}
else
{
InverseTotalEllapsedTime = ellapsedTime ! = 0 ? 1.f / ellapsedTime : 0.f ;
}
updateLODRatio ( ) ;
{
MINI_TIMER ( PSAnim3 )
if ( _AutoLOD & & ! _Sharing )
{
float currLODRatio = 1.f - _OneMinusCurrentLODRatio ;
if ( currLODRatio < = _AutoLODStartDistPercent )
{
_AutoLODEmitRatio = 1.f ; // no LOD applied
}
else
{
float lodValue = ( currLODRatio - 1.f ) / ( _AutoLODStartDistPercent - 1.f ) ;
NLMISC : : clamp ( lodValue , 0.f , 1.f ) ;
float finalValue = lodValue ;
for ( uint l = 1 ; l < _AutoLODDegradationExponent ; + + l )
{
finalValue * = lodValue ;
}
_AutoLODEmitRatio = ( 1.f - _MaxDistLODBias ) * finalValue + _MaxDistLODBias ;
if ( _AutoLODEmitRatio < 0.f ) _AutoLODEmitRatio = 0.f ;
}
}
}
{
MINI_TIMER ( PSAnim4 )
// set start position. Used by emitters that emit from Local basis to world
if ( ! _HiddenAtPreviousFrame & & ! _HiddenAtCurrentFrame )
{
_CoordSystemInfo . CurrentDeltaPos = _CoordSystemInfo . OldPos - _CoordSystemInfo . Matrix - > getPos ( ) ;
if ( _UserCoordSystemInfo )
{
CCoordSystemInfo & csi = _UserCoordSystemInfo - > CoordSystemInfo ;
csi . CurrentDeltaPos = csi . OldPos - csi . Matrix - > getPos ( ) ;
}
}
else
{
_CoordSystemInfo . CurrentDeltaPos = NLMISC : : CVector : : Null ;
_CoordSystemInfo . OldPos = _CoordSystemInfo . Matrix - > getPos ( ) ;
if ( _UserCoordSystemInfo )
{
CCoordSystemInfo & csi = _UserCoordSystemInfo - > CoordSystemInfo ;
csi . CurrentDeltaPos = NLMISC : : CVector : : Null ;
csi . OldPos = csi . Matrix - > getPos ( ) ;
}
}
//displaySysPos(_Driver, _CurrentDeltaPos + _OldSysMat.getPos(), CRGBA::Red);
// process passes
}
RealEllapsedTime = _KeepEllapsedTimeForLifeUpdate ? ( ellapsedTime / nbPass )
: EllapsedTime ;
RealEllapsedTimeRatio = RealEllapsedTime / EllapsedTime ;
/*PSMaxET = std::max(PSMaxET, ellapsedTime);
PSMaxNBPass = std : : max ( PSMaxNBPass , nbPass ) ; */
// Sort by emission depth. We assume that the ps is a directed acyclic graph (so no loop will be encountered)
if ( shape . _ProcessOrder . empty ( ) )
{
getSortingByEmitterPrecedence ( shape . _ProcessOrder ) ;
}
// nodes sorted by degree
InsideSimLoop = true ;
// make enough room for spawns
2010-05-13 20:14:36 +00:00
uint numProcess = ( uint ) _ProcessVect . size ( ) ;
2010-05-06 00:08:41 +00:00
if ( numProcess > _Spawns . size ( ) )
{
2010-05-13 20:14:36 +00:00
uint oldSize = ( uint ) _Spawns . size ( ) ;
2010-05-06 00:08:41 +00:00
_Spawns . resize ( numProcess ) ;
for ( uint k = oldSize ; k < numProcess ; + + k )
{
_Spawns [ k ] = new CSpawnVect ;
}
}
for ( uint k = 0 ; k < numProcess ; + + k )
{
if ( ! _ProcessVect [ k ] - > isLocated ( ) ) continue ;
CPSLocated * loc = static_cast < CPSLocated * > ( _ProcessVect [ k ] ) ;
if ( loc - > hasLODDegradation ( ) )
{
loc - > doLODDegradation ( ) ;
}
_Spawns [ k ] - > MaxNumSpawns = loc - > getMaxSize ( ) ;
}
do
{
{
MINI_TIMER ( PSAnim5 )
// position of the system at the end of the integration
_CoordSystemInfo . CurrentDeltaPos + = ( _CoordSystemInfo . Matrix - > getPos ( ) - _CoordSystemInfo . OldPos ) * ( EllapsedTime * InverseTotalEllapsedTime ) ;
if ( _UserCoordSystemInfo )
{
CCoordSystemInfo & csi = _UserCoordSystemInfo - > CoordSystemInfo ;
csi . CurrentDeltaPos + = ( csi . Matrix - > getPos ( ) - csi . OldPos ) * ( EllapsedTime * InverseTotalEllapsedTime ) ;
}
}
for ( uint k = 0 ; k < shape . _ProcessOrder . size ( ) ; + + k )
{
if ( ! _ProcessVect [ shape . _ProcessOrder [ k ] ] - > isLocated ( ) ) continue ;
CPSLocated * loc = static_cast < CPSLocated * > ( _ProcessVect [ shape . _ProcessOrder [ k ] ] ) ;
if ( _ParticleRemoveListIndex . size ( ) < loc - > getMaxSize ( ) )
{
_ParticleRemoveListIndex . resize ( loc - > getMaxSize ( ) , - 1 ) ;
}
if ( loc - > getSize ( ) ! = 0 )
{
# ifdef NL_DEBUG
loc - > checkLife ( ) ;
# endif
if ( loc - > hasCollisionInfos ( ) )
{
loc - > resetCollisions ( loc - > getSize ( ) ) ;
}
// compute motion (including collisions)
if ( ! loc - > isParametricMotionEnabled ( ) ) loc - > computeMotion ( ) ;
// Update life and mark particles that must be removed
loc - > updateLife ( ) ;
// Spawn particles. Emitters date is updated only after so we check in CPSLocated::postNewElement
// if the emitter was still alive at this date, otherwise we discard the post
loc - > computeSpawns ( 0 , false ) ;
if ( loc - > hasCollisionInfos ( ) ) loc - > updateCollisions ( ) ;
// Remove too old particles, making room for new ones
if ( ! _ParticleToRemove . empty ( ) )
{
loc - > removeOldParticles ( ) ;
}
# ifdef NL_DEBUG
loc - > checkLife ( ) ;
# endif
}
if ( ! _Spawns [ shape . _ProcessOrder [ k ] ] - > SpawnInfos . empty ( ) )
{
uint insertionIndex = loc - > getSize ( ) ; // index at which new particles will be inserted
// add new particles that where posted by ancestor emitters, and also mark those that must already be deleted
loc - > addNewlySpawnedParticles ( ) ;
if ( insertionIndex ! = loc - > getSize ( ) )
{
// Compute motion for spawned particles. This is useful only if particle can collide because
if ( loc - > hasCollisionInfos ( ) )
{
loc - > resetCollisions ( loc - > getSize ( ) ) ;
loc - > computeNewParticleMotion ( insertionIndex ) ;
}
loc - > computeSpawns ( insertionIndex , true ) ;
if ( loc - > hasCollisionInfos ( ) ) loc - > updateCollisions ( ) ;
// Remove too old particles among the newly created ones.
if ( ! _ParticleToRemove . empty ( ) )
{
loc - > removeOldParticles ( ) ;
}
# ifdef NL_DEBUG
loc - > checkLife ( ) ;
# endif
}
}
if ( ! loc - > isParametricMotionEnabled ( ) ) loc - > computeForces ( ) ;
}
_SystemDate + = RealEllapsedTime ;
for ( TProcessVect : : iterator it = _ProcessVect . begin ( ) ; it ! = _ProcessVect . end ( ) ; + + it )
{
# ifdef NL_DEBUG
if ( ( * it ) - > isLocated ( ) )
{
CPSLocated * loc = static_cast < CPSLocated * > ( * it ) ;
loc - > checkLife ( ) ;
}
# endif
{
MINI_TIMER ( PSAnim2 )
( * it ) - > step ( PSMotion ) ;
}
}
}
while ( - - nbPass ) ;
{
MINI_TIMER ( PSAnim10 )
// perform parametric motion if present
for ( TProcessVect : : iterator it = _ProcessVect . begin ( ) ; it ! = _ProcessVect . end ( ) ; + + it )
{
if ( ( * it ) - > isParametricMotionEnabled ( ) ) ( * it ) - > performParametricMotion ( _SystemDate ) ;
}
}
updateNumWantedTris ( ) ;
InsideSimLoop = false ;
{
MINI_TIMER ( PSAnim11 )
// memorize position of matrix for next frame (becomes old position)
_CoordSystemInfo . OldPos = _CoordSystemInfo . Matrix - > getPos ( ) ;
if ( _UserCoordSystemInfo )
{
CCoordSystemInfo & csi = _UserCoordSystemInfo - > CoordSystemInfo ;
csi . OldPos = csi . Matrix - > getPos ( ) ;
}
_HiddenAtPreviousFrame = _HiddenAtCurrentFrame ;
}
}
}
RealEllapsedTimeRatio = 0.f ;
CHECK_INTEGRITY
}
///=======================================================================================
void CParticleSystem : : serial ( NLMISC : : IStream & f ) throw ( NLMISC : : EStream )
{
CHECK_INTEGRITY
NL_PS_FUNC_MAIN ( CParticleSystem_serial )
sint version = f . serialVersion ( 19 ) ;
// version 19: sysmat no more serialized (useless)
// version 18: _AutoComputeDelayBeforeDeathTest
// version 17: _ForceGlobalColorLighting flag
// version 16: _BypassIntegrationStepLimit flag
// version 14: emit threshold
// version 13: max dist lod bias for auto-LOD
// version 12: global userParams
// version 11: enable load balancing flag
// version 9: Sharing flag added
// Auto-lod parameters
// New integration flag
// Global color attenuation
// version 8: Replaced the attribute '_PerformMotionWhenOutOfFrustum' by a _AnimType field which allow more precise control
//f.serial(_ViewMat);
// patch for old fx : force to recompute duration when fx is saved to avoid prbs
if ( ! f . isReading ( ) )
{
if ( _AutoComputeDelayBeforeDeathTest )
{
_DelayBeforeDieTest = evalDuration ( ) ;
}
}
if ( version < 19 )
{
NLMISC : : CMatrix dummy ;
f . serial ( dummy ) ;
}
f . serial ( _Date ) ;
if ( f . isReading ( ) )
{
delete _ColorAttenuationScheme ;
// delete previous multimap
_LBMap . clear ( ) ;
// delete previously attached process
TProcessVect : : iterator it ;
for ( it = _ProcessVect . begin ( ) ; it ! = _ProcessVect . end ( ) ; + + it )
{
delete ( * it ) ;
}
_ProcessVect . clear ( ) ;
f . serialContPolyPtr ( _ProcessVect ) ;
_FontGenerator = NULL ;
_FontManager = NULL ;
if ( _UserParamGlobalValue )
delete _UserParamGlobalValue ;
_UserParamGlobalValue = NULL ;
_BypassGlobalUserParam = 0 ;
// see if some process need to access the user matrix
delete _UserCoordSystemInfo ;
_UserCoordSystemInfo = NULL ;
for ( TProcessVect : : iterator it = _ProcessVect . begin ( ) ; it ! = _ProcessVect . end ( ) ; + + it )
{
addRefForUserSysCoordInfo ( ( * it ) - > getUserMatrixUsageCount ( ) ) ;
}
}
else
{
f . serialContPolyPtr ( _ProcessVect ) ;
}
if ( version > 1 ) // name of the system
{
if ( f . isReading ( ) & & ! getSerializeIdentifierFlag ( ) )
{
// just skip the name
sint32 len ;
f . serial ( len ) ;
f . seek ( len , NLMISC : : IStream : : current ) ;
}
else
{
f . serial ( _Name ) ;
}
}
if ( version > 2 ) // infos about integration, and LOD
{
bool accurateIntegration = _AccurateIntegration ; // read from bitfield
f . serial ( accurateIntegration ) ;
_AccurateIntegration = accurateIntegration ;
if ( _AccurateIntegration )
{
bool canSlowDown = _CanSlowDown ;
f . serial ( canSlowDown ) ;
_CanSlowDown = canSlowDown ;
f . serial ( _TimeThreshold , _MaxNbIntegrations ) ;
}
f . serial ( _InvMaxViewDist , _LODRatio ) ;
_MaxViewDist = 1.f / _InvMaxViewDist ;
_InvCurrentViewDist = _InvMaxViewDist ;
}
if ( version > 3 ) // tell whether the system must compute his bbox, hold a precomputed bbox
{
bool computeBBox = _ComputeBBox ;
f . serial ( computeBBox ) ;
_ComputeBBox = computeBBox ;
if ( ! computeBBox )
{
f . serial ( _PreComputedBBox ) ;
}
}
if ( version > 4 ) // lifetime informations
{
bool destroyModelWhenOutOfRange = _DestroyModelWhenOutOfRange ; // read from bitfield
f . serial ( destroyModelWhenOutOfRange ) ;
_DestroyModelWhenOutOfRange = destroyModelWhenOutOfRange ;
f . serialEnum ( _DieCondition ) ;
if ( _DieCondition ! = none )
{
f . serial ( _DelayBeforeDieTest ) ;
}
}
if ( version > 5 )
{
bool destroyWhenOutOfFrustum = _DestroyWhenOutOfFrustum ; // read from bitfield
f . serial ( destroyWhenOutOfFrustum ) ;
_DestroyWhenOutOfFrustum = destroyWhenOutOfFrustum ;
}
if ( version > 6 & & version < 8 )
{
bool performMotionWOOF ;
if ( f . isReading ( ) )
{
f . serial ( performMotionWOOF ) ;
performMotionWhenOutOfFrustum ( performMotionWOOF ) ;
}
else
{
performMotionWOOF = doesPerformMotionWhenOutOfFrustum ( ) ;
f . serial ( performMotionWOOF ) ;
}
}
if ( version > 7 )
{
f . serialEnum ( _AnimType ) ;
f . serialEnum ( _PresetBehaviour ) ;
}
if ( version > 8 )
{
bool sharing = _Sharing ; // read from bitfield
f . serial ( sharing ) ;
_Sharing = sharing ;
bool autoLOD = _AutoLOD ; // read from bitfield
f . serial ( autoLOD ) ;
_AutoLOD = autoLOD ;
if ( _AutoLOD )
{
f . serial ( _AutoLODStartDistPercent , _AutoLODDegradationExponent ) ;
bool autoLODSkipParticles = _AutoLODSkipParticles ; // read from bitfield
f . serial ( autoLODSkipParticles ) ;
_AutoLODSkipParticles = autoLODSkipParticles ;
}
bool keepEllapsedTimeForLifeUpdate = _KeepEllapsedTimeForLifeUpdate ;
f . serial ( keepEllapsedTimeForLifeUpdate ) ;
_KeepEllapsedTimeForLifeUpdate = keepEllapsedTimeForLifeUpdate ;
f . serialPolyPtr ( _ColorAttenuationScheme ) ;
}
if ( version > = 11 )
{
bool enableLoadBalancing = _EnableLoadBalancing ; // read from bitfield
f . serial ( enableLoadBalancing ) ;
_EnableLoadBalancing = enableLoadBalancing ;
}
if ( version > = 12 )
{
// serial infos about global user params
nlctassert ( MaxPSUserParam < 8 ) ; // In this version mask of used global user params are stored in a byte..
if ( f . isReading ( ) )
{
uint8 mask ;
f . serial ( mask ) ;
if ( mask )
{
std : : string globalValueName ;
uint8 testMask = 1 ;
for ( uint k = 0 ; k < MaxPSUserParam ; + + k )
{
if ( mask & testMask )
{
f . serial ( globalValueName ) ;
bindGlobalValueToUserParam ( globalValueName . c_str ( ) , k ) ;
}
testMask < < = 1 ;
}
}
}
else
{
uint8 mask = 0 ;
if ( _UserParamGlobalValue )
{
for ( uint k = 0 ; k < MaxPSUserParam ; + + k )
{
if ( _UserParamGlobalValue [ k ] ) mask | = ( 1 < < k ) ;
}
}
f . serial ( mask ) ;
if ( _UserParamGlobalValue )
{
for ( uint k = 0 ; k < MaxPSUserParam ; + + k )
{
if ( _UserParamGlobalValue [ k ] )
{
std : : string valueName = _UserParamGlobalValue [ k ] - > first ;
f . serial ( valueName ) ;
}
}
}
}
}
if ( version > = 13 )
{
if ( _AutoLOD & & ! _Sharing )
{
f . serial ( _MaxDistLODBias ) ;
}
}
if ( version > = 14 )
{
bool emitThreshold = _EmitThreshold ; // read from bitfiled
f . serial ( emitThreshold ) ;
_EmitThreshold = emitThreshold ;
}
if ( version > = 15 )
{
bool bypassIntegrationStepLimit = _BypassIntegrationStepLimit ; // read from bitfield
f . serial ( bypassIntegrationStepLimit ) ;
_BypassIntegrationStepLimit = bypassIntegrationStepLimit ;
}
if ( version > = 17 )
{
bool forceGlobalColorLighting = _ForceGlobalColorLighting ; // read from bitfield
f . serial ( forceGlobalColorLighting ) ;
_ForceGlobalColorLighting = forceGlobalColorLighting ;
}
if ( version > = 18 )
{
bool autoComputeDelayBeforeDeathTest = _AutoComputeDelayBeforeDeathTest ; // read from bitfield
f . serial ( autoComputeDelayBeforeDeathTest ) ;
_AutoComputeDelayBeforeDeathTest = autoComputeDelayBeforeDeathTest ;
}
else
{
nlassert ( f . isReading ( ) ) ;
// for all previously created system, force to eval the system duration in an automatyic way
setDelayBeforeDeathConditionTest ( - 1.f ) ;
_AutoComputeDelayBeforeDeathTest = true ;
}
if ( f . isReading ( ) )
{
//notifyMaxNumFacesChanged();
updateNumWantedTris ( ) ;
activatePresetBehaviour ( _PresetBehaviour ) ; // apply behaviour changes
updateProcessIndices ( ) ;
}
CHECK_INTEGRITY
// tmp
//if (f.isReading())
// {
// dumpHierarchy();
// }
}
///=======================================================================================
bool CParticleSystem : : attach ( CParticleSystemProcess * ptr )
{
NL_PS_FUNC_MAIN ( CParticleSystem_attach )
nlassert ( ptr ) ;
nlassert ( std : : find ( _ProcessVect . begin ( ) , _ProcessVect . end ( ) , ptr ) = = _ProcessVect . end ( ) ) ; // can't attach twice
//nlassert(ptr->getOwner() == NULL);
_ProcessVect . push_back ( ptr ) ;
ptr - > setOwner ( this ) ;
2010-05-13 20:14:36 +00:00
ptr - > setIndex ( ( uint32 ) _ProcessVect . size ( ) - 1 ) ;
2010-05-06 00:08:41 +00:00
//notifyMaxNumFacesChanged();
if ( getBypassMaxNumIntegrationSteps ( ) )
{
if ( ! canFinish ( ) )
{
remove ( ptr ) ;
nlwarning ( " <void CParticleSystem::attach> Can't attach object : this causes the system to last forever, and it has been flagged with 'BypassMaxNumIntegrationSteps'. Object is not attached " ) ;
return false ;
}
}
systemDurationChanged ( ) ;
return true ;
}
///=======================================================================================
void CParticleSystem : : remove ( CParticleSystemProcess * ptr )
{
NL_PS_FUNC_MAIN ( CParticleSystem_remove )
TProcessVect : : iterator it = std : : find ( _ProcessVect . begin ( ) , _ProcessVect . end ( ) , ptr ) ;
nlassert ( it ! = _ProcessVect . end ( ) ) ;
ptr - > setOwner ( NULL ) ;
_ProcessVect . erase ( it ) ;
delete ptr ;
systemDurationChanged ( ) ;
updateProcessIndices ( ) ;
}
///=======================================================================================
void CParticleSystem : : forceComputeBBox ( NLMISC : : CAABBox & aabbox )
{
NL_PS_FUNC_MAIN ( CParticleSystem_forceComputeBBox )
bool foundOne = false ;
NLMISC : : CAABBox tmpBox ;
for ( TProcessVect : : const_iterator it = _ProcessVect . begin ( ) ; it ! = _ProcessVect . end ( ) ; + + it )
{
if ( ( * it ) - > computeBBox ( tmpBox ) )
{
// rotate the aabbox so that it is in the correct basis
const CMatrix & convMat = CPSLocated : : getConversionMatrix ( * this , PSFXWorldMatrix , ( * it ) - > getMatrixMode ( ) ) ;
tmpBox = NLMISC : : CAABBox : : transformAABBox ( convMat , tmpBox ) ;
if ( foundOne )
{
aabbox = NLMISC : : CAABBox : : computeAABBoxUnion ( aabbox , tmpBox ) ;
}
else
{
aabbox = tmpBox ;
foundOne = true ;
}
}
}
if ( ! foundOne )
{
aabbox . setCenter ( NLMISC : : CVector : : Null ) ;
aabbox . setHalfSize ( NLMISC : : CVector : : Null ) ;
}
}
///=======================================================================================
void CParticleSystem : : computeBBox ( NLMISC : : CAABBox & aabbox )
{
NL_PS_FUNC_MAIN ( CParticleSystem_computeBBox )
if ( ! _ComputeBBox | | ! _BBoxTouched )
{
aabbox = _PreComputedBBox ;
return ;
}
forceComputeBBox ( aabbox ) ;
_BBoxTouched = false ;
_PreComputedBBox = aabbox ;
}
///=======================================================================================
void CParticleSystem : : setSysMat ( const CMatrix * m )
{
NL_PS_FUNC_MAIN ( CParticleSystem_setSysMat )
_CoordSystemInfo . Matrix = m ;
if ( _SystemDate = = 0.f )
{
_CoordSystemInfo . OldPos = m ? m - > getPos ( ) : CVector : : Null ;
}
if ( ! m ) return ;
_CoordSystemInfo . InvMatrix = _CoordSystemInfo . Matrix - > inverted ( ) ;
}
///=======================================================================================
void CParticleSystem : : setUserMatrix ( const NLMISC : : CMatrix * m )
{
NL_PS_FUNC_MAIN ( CParticleSystem_setUserMatrix )
if ( ! _UserCoordSystemInfo ) return ; // no process in the system references the user matrix
CCoordSystemInfo & csi = _UserCoordSystemInfo - > CoordSystemInfo ;
csi . Matrix = m ;
if ( _SystemDate = = 0.f )
{
csi . OldPos = m ? m - > getPos ( ) : getSysMat ( ) . getPos ( ) ; // _CoordSystemInfo.Matrix is relevant if at least one call to setSysMat has been performed before
}
if ( ! m ) return ;
csi . InvMatrix = csi . Matrix - > inverted ( ) ;
// build conversion matrix between father user matrix & fx matrix
// TODO : lazy evaluation for this ?
_UserCoordSystemInfo - > UserBasisToFXBasis = _CoordSystemInfo . InvMatrix * * ( csi . Matrix ) ;
_UserCoordSystemInfo - > FXBasisToUserBasis = csi . InvMatrix * getSysMat ( ) ;
}
///=======================================================================================
bool CParticleSystem : : hasOpaqueObjects ( void ) const
{
NL_PS_FUNC_MAIN ( CParticleSystem_hasOpaqueObjects )
/// for each process
for ( TProcessVect : : const_iterator it = _ProcessVect . begin ( ) ; it ! = _ProcessVect . end ( ) ; + + it )
{
if ( ( * it ) - > isLocated ( ) )
{
CPSLocated * loc = static_cast < CPSLocated * > ( * it ) ;
for ( uint k = 0 ; k < loc - > getNbBoundObjects ( ) ; + + k )
{
CPSLocatedBindable * lb = loc - > getBoundObject ( k ) ;
if ( lb - > getType ( ) = = PSParticle )
{
if ( ( ( CPSParticle * ) lb ) - > hasOpaqueFaces ( ) ) return true ;
}
}
}
}
return false ;
}
///=======================================================================================
bool CParticleSystem : : hasTransparentObjects ( void ) const
{
NL_PS_FUNC_MAIN ( CParticleSystem_hasTransparentObjects )
/// for each process
for ( TProcessVect : : const_iterator it = _ProcessVect . begin ( ) ; it ! = _ProcessVect . end ( ) ; + + it )
{
if ( ( * it ) - > isLocated ( ) )
{
CPSLocated * loc = static_cast < CPSLocated * > ( * it ) ;
for ( uint k = 0 ; k < loc - > getNbBoundObjects ( ) ; + + k )
{
CPSLocatedBindable * lb = loc - > getBoundObject ( k ) ;
if ( lb - > getType ( ) = = PSParticle )
{
if ( ( ( CPSParticle * ) lb ) - > hasTransparentFaces ( ) ) return true ;
}
}
}
}
return false ;
}
///=======================================================================================
bool CParticleSystem : : hasLightableObjects ( ) const
{
NL_PS_FUNC_MAIN ( CParticleSystem_hasLightableObjects )
if ( _ForceGlobalColorLighting ) return true ;
/// for each process
for ( TProcessVect : : const_iterator it = _ProcessVect . begin ( ) ; it ! = _ProcessVect . end ( ) ; + + it )
{
if ( ( * it ) - > isLocated ( ) )
{
CPSLocated * loc = static_cast < CPSLocated * > ( * it ) ;
for ( uint k = 0 ; k < loc - > getNbBoundObjects ( ) ; + + k )
{
CPSLocatedBindable * lb = loc - > getBoundObject ( k ) ;
if ( lb - > getType ( ) = = PSParticle )
{
if ( ( ( CPSParticle * ) lb ) - > hasLightableFaces ( ) ) return true ;
if ( ( ( CPSParticle * ) lb ) - > usesGlobalColorLighting ( ) ) return true ;
}
}
}
}
return false ;
}
///=======================================================================================
void CParticleSystem : : getLODVect ( NLMISC : : CVector & v , float & offset , TPSMatrixMode matrixMode )
{
NL_PS_FUNC_MAIN ( CParticleSystem_getLODVect )
switch ( matrixMode )
{
case PSFXWorldMatrix :
{
const CVector tv = getInvertedSysMat ( ) . mulVector ( _InvertedViewMat . getJ ( ) ) ;
const CVector org = getInvertedSysMat ( ) * _InvertedViewMat . getPos ( ) ;
v = _InvCurrentViewDist * tv ;
offset = - org * v ;
}
break ;
case PSIdentityMatrix :
{
v = _InvCurrentViewDist * _InvertedViewMat . getJ ( ) ;
offset = - _InvertedViewMat . getPos ( ) * v ;
}
break ;
case PSUserMatrix :
{
const CVector tv = getInvertedUserMatrix ( ) . mulVector ( _InvertedViewMat . getJ ( ) ) ;
const CVector org = getInvertedUserMatrix ( ) * _InvertedViewMat . getPos ( ) ;
v = _InvCurrentViewDist * tv ;
offset = - org * v ;
}
break ;
default :
nlassert ( 0 ) ;
break ;
}
}
///=======================================================================================
TPSLod CParticleSystem : : getLOD ( void ) const
{
NL_PS_FUNC_MAIN ( CParticleSystem_getLOD )
const float dist = fabsf ( _InvCurrentViewDist * ( getSysMat ( ) . getPos ( ) - _InvertedViewMat . getPos ( ) ) * _InvertedViewMat . getJ ( ) ) ;
return dist > _LODRatio ? PSLod2 : PSLod1 ;
}
///=======================================================================================
void CParticleSystem : : registerLocatedBindableExternID ( uint32 id , CPSLocatedBindable * lb )
{
NL_PS_FUNC_MAIN ( CParticleSystem_registerLocatedBindableExternID )
nlassert ( lb ) ;
nlassert ( lb - > getOwner ( ) & & lb - > getOwner ( ) - > getOwner ( ) = = this ) ; // the located bindable must belong to that system
# ifdef NL_DEBUG
// check that this lb hasn't been inserted yet
TLBMap : : iterator lbd = _LBMap . lower_bound ( id ) , ubd = _LBMap . upper_bound ( id ) ;
nlassert ( std : : find ( lbd , ubd , TLBMap : : value_type ( id , lb ) ) = = ubd ) ;
nlassert ( std : : find ( lbd , ubd , TLBMap : : value_type ( id , lb ) ) = = ubd ) ;
# endif
_LBMap . insert ( TLBMap : : value_type ( id , lb ) ) ;
}
///=======================================================================================
void CParticleSystem : : unregisterLocatedBindableExternID ( CPSLocatedBindable * lb )
{
NL_PS_FUNC_MAIN ( CParticleSystem_unregisterLocatedBindableExternID )
nlassert ( lb ) ;
nlassert ( lb - > getOwner ( ) & & lb - > getOwner ( ) - > getOwner ( ) = = this ) ; // the located bindable must belong to that system
uint32 id = lb - > getExternID ( ) ;
if ( ! id ) return ;
TLBMap : : iterator lbd = _LBMap . lower_bound ( id ) , ubd = _LBMap . upper_bound ( id ) ;
TLBMap : : iterator el = std : : find ( lbd , ubd , TLBMap : : value_type ( id , lb ) ) ;
nlassert ( el ! = ubd ) ;
_LBMap . erase ( el ) ;
}
///=======================================================================================
uint CParticleSystem : : getNumLocatedBindableByExternID ( uint32 id ) const
{
NL_PS_FUNC_MAIN ( CParticleSystem_getNumLocatedBindableByExternID )
2010-05-13 20:14:36 +00:00
return ( uint ) _LBMap . count ( id ) ;
2010-05-06 00:08:41 +00:00
}
///=======================================================================================
CPSLocatedBindable * CParticleSystem : : getLocatedBindableByExternID ( uint32 id , uint index )
{
NL_PS_FUNC_MAIN ( CParticleSystem_getLocatedBindableByExternID )
if ( index > = _LBMap . count ( id ) )
{
return NULL ;
}
TLBMap : : const_iterator el = _LBMap . lower_bound ( id ) ;
uint left = index ;
while ( left - - ) + + el ;
return el - > second ;
}
///=======================================================================================
const CPSLocatedBindable * CParticleSystem : : getLocatedBindableByExternID ( uint32 id , uint index ) const
{
NL_PS_FUNC_MAIN ( CParticleSystem_getLocatedBindableByExternID )
if ( index > = _LBMap . count ( id ) )
{
return NULL ;
}
TLBMap : : const_iterator el = _LBMap . lower_bound ( id ) ;
uint left = index ;
while ( left - - ) + + el ;
return el - > second ;
}
///=======================================================================================
bool CParticleSystem : : merge ( CParticleSystemShape * pss )
{
NL_PS_FUNC_MAIN ( CParticleSystem_merge )
nlassert ( pss ) ;
nlassert ( _Scene ) ;
CParticleSystem * duplicate = pss - > instanciatePS ( * this - > _Scene ) ; // duplicate the p.s. to merge
// now we transfer the located of the duplicated ps to this object...
for ( TProcessVect : : iterator it = duplicate - > _ProcessVect . begin ( ) ; it ! = duplicate - > _ProcessVect . end ( ) ; + + it )
{
if ( ! attach ( * it ) )
{
for ( TProcessVect : : iterator clearIt = duplicate - > _ProcessVect . begin ( ) ; clearIt ! = it ; + + it )
{
detach ( getIndexOf ( * * it ) ) ;
}
nlwarning ( " <CParticleSystem::merge> Can't do the merge : this causes the system to last forever, and it has been flagged with 'BypassMaxNumIntegrationSteps'. Merge is not done. " ) ;
return false ;
}
}
//
if ( getBypassMaxNumIntegrationSteps ( ) )
{
if ( ! canFinish ( ) )
{
for ( TProcessVect : : iterator it = duplicate - > _ProcessVect . begin ( ) ; it ! = duplicate - > _ProcessVect . end ( ) ; + + it )
{
detach ( getIndexOf ( * * it ) ) ;
}
nlwarning ( " <CParticleSystem::merge> Can't do the merge : this causes the system to last forever, and it has been flagged with 'BypassMaxNumIntegrationSteps'. Merge is not done. " ) ;
return false ;
}
}
//
duplicate - > _ProcessVect . clear ( ) ;
delete duplicate ;
systemDurationChanged ( ) ;
CHECK_INTEGRITY
return true ;
}
///=======================================================================================
void CParticleSystem : : activatePresetBehaviour ( TPresetBehaviour behaviour )
{
NL_PS_FUNC_MAIN ( CParticleSystem_activatePresetBehaviour )
switch ( behaviour )
{
case EnvironmentFX :
setDestroyModelWhenOutOfRange ( false ) ;
setDestroyCondition ( none ) ;
destroyWhenOutOfFrustum ( false ) ;
setAnimType ( AnimVisible ) ;
setBypassMaxNumIntegrationSteps ( false ) ;
_KeepEllapsedTimeForLifeUpdate = false ;
break ;
case RunningEnvironmentFX :
setDestroyModelWhenOutOfRange ( false ) ;
setDestroyCondition ( none ) ;
destroyWhenOutOfFrustum ( false ) ;
setAnimType ( AnimInCluster ) ;
setBypassMaxNumIntegrationSteps ( false ) ;
_KeepEllapsedTimeForLifeUpdate = false ;
break ;
case SpellFX :
setDestroyModelWhenOutOfRange ( true ) ;
setDestroyCondition ( noMoreParticles ) ;
destroyWhenOutOfFrustum ( false ) ;
setAnimType ( AnimAlways ) ;
setBypassMaxNumIntegrationSteps ( true ) ;
_KeepEllapsedTimeForLifeUpdate = false ;
break ;
case LoopingSpellFX :
setDestroyModelWhenOutOfRange ( false ) ;
setDestroyCondition ( noMoreParticles ) ;
destroyWhenOutOfFrustum ( false ) ;
// setAnimType(AnimInCluster); // TODO : AnimAlways could be better ?
setAnimType ( AnimVisible ) ;
setBypassMaxNumIntegrationSteps ( false ) ;
_KeepEllapsedTimeForLifeUpdate = false ;
break ;
case MinorFX :
setDestroyModelWhenOutOfRange ( true ) ;
setDestroyCondition ( noMoreParticles ) ;
destroyWhenOutOfFrustum ( true ) ;
setAnimType ( AnimVisible ) ;
setBypassMaxNumIntegrationSteps ( false ) ;
_KeepEllapsedTimeForLifeUpdate = false ;
break ;
case MovingLoopingFX :
setDestroyModelWhenOutOfRange ( false ) ;
setDestroyCondition ( none ) ;
destroyWhenOutOfFrustum ( false ) ;
setAnimType ( AnimVisible ) ;
setBypassMaxNumIntegrationSteps ( false ) ;
_KeepEllapsedTimeForLifeUpdate = true ;
break ;
case SpawnedEnvironmentFX :
setDestroyModelWhenOutOfRange ( true ) ;
setDestroyCondition ( noMoreParticles ) ;
destroyWhenOutOfFrustum ( false ) ;
setAnimType ( AnimAlways ) ;
setBypassMaxNumIntegrationSteps ( false ) ;
_KeepEllapsedTimeForLifeUpdate = false ;
break ;
case GroundFX :
setDestroyModelWhenOutOfRange ( false ) ;
setDestroyCondition ( none ) ;
destroyWhenOutOfFrustum ( false ) ;
setAnimType ( AnimAlways ) ;
setBypassMaxNumIntegrationSteps ( false ) ;
_KeepEllapsedTimeForLifeUpdate = true ;
break ;
case Projectile :
setDestroyModelWhenOutOfRange ( false ) ;
setDestroyCondition ( noMoreParticles ) ;
destroyWhenOutOfFrustum ( false ) ;
setAnimType ( AnimVisible ) ;
setBypassMaxNumIntegrationSteps ( false ) ;
_KeepEllapsedTimeForLifeUpdate = true ;
break ;
default : break ;
}
_PresetBehaviour = behaviour ;
}
///=======================================================================================
CParticleSystemProcess * CParticleSystem : : detach ( uint index )
{
NL_PS_FUNC_MAIN ( CParticleSystem_detach )
nlassert ( index < _ProcessVect . size ( ) ) ;
CParticleSystemProcess * proc = _ProcessVect [ index ] ;
// release references other process may have to this system
for ( TProcessVect : : iterator it = _ProcessVect . begin ( ) ; it ! = _ProcessVect . end ( ) ; + + it )
{
( * it ) - > releaseRefTo ( proc ) ;
}
// erase from the vector
_ProcessVect . erase ( _ProcessVect . begin ( ) + index ) ;
proc - > setOwner ( NULL ) ;
//
systemDurationChanged ( ) ;
// not part of this system any more
return proc ;
}
///=======================================================================================
bool CParticleSystem : : isProcess ( const CParticleSystemProcess * process ) const
{
NL_PS_FUNC_MAIN ( CParticleSystem_isProcess )
for ( TProcessVect : : const_iterator it = _ProcessVect . begin ( ) ; it ! = _ProcessVect . end ( ) ; + + it )
{
if ( * it = = process ) return true ;
}
return false ;
}
///=======================================================================================
uint CParticleSystem : : getIndexOf ( const CParticleSystemProcess & process ) const
{
NL_PS_FUNC_MAIN ( CParticleSystem_getIndexOf )
# ifdef NL_DEBUG
nlassert ( isProcess ( & process ) ) ;
# endif
return process . getIndex ( ) ;
}
///=======================================================================================
uint CParticleSystem : : getNumID ( ) const
{
NL_PS_FUNC_MAIN ( CParticleSystem_getNumID )
2010-05-13 20:14:36 +00:00
return ( uint ) _LBMap . size ( ) ;
2010-05-06 00:08:41 +00:00
}
///=======================================================================================
uint32 CParticleSystem : : getID ( uint index ) const
{
NL_PS_FUNC_MAIN ( CParticleSystem_getID )
TLBMap : : const_iterator it = _LBMap . begin ( ) ;
for ( uint k = 0 ; k < index ; + + k )
{
if ( it = = _LBMap . end ( ) ) return 0 ;
+ + it ;
}
return it - > first ;
}
///=======================================================================================
void CParticleSystem : : getIDs ( std : : vector < uint32 > & dest ) const
{
NL_PS_FUNC_MAIN ( CParticleSystem_getIDs )
dest . resize ( _LBMap . size ( ) ) ;
uint k = 0 ;
for ( TLBMap : : const_iterator it = _LBMap . begin ( ) ; it ! = _LBMap . end ( ) ; + + it )
{
dest [ k ] = it - > first ;
+ + k ;
}
}
///=======================================================================================
void CParticleSystem : : interpolateFXPosDelta ( NLMISC : : CVector & dest , TAnimationTime deltaT )
{
NL_PS_FUNC_MAIN ( CParticleSystem_interpolateFXPosDelta )
nlassert ( _CoordSystemInfo . Matrix ) ;
dest = _CoordSystemInfo . CurrentDeltaPos - ( deltaT * InverseTotalEllapsedTime ) * ( _CoordSystemInfo . Matrix - > getPos ( ) - _CoordSystemInfo . OldPos ) ;
}
///=======================================================================================
void CParticleSystem : : interpolateUserPosDelta ( NLMISC : : CVector & dest , TAnimationTime deltaT )
{
NL_PS_FUNC_MAIN ( CParticleSystem_interpolateUserPosDelta )
if ( ! _UserCoordSystemInfo )
{
interpolateFXPosDelta ( dest , deltaT ) ;
}
else
{
CCoordSystemInfo & csi = _UserCoordSystemInfo - > CoordSystemInfo ;
dest = csi . CurrentDeltaPos - ( deltaT * InverseTotalEllapsedTime ) * ( csi . Matrix - > getPos ( ) - csi . OldPos ) ;
}
}
///=======================================================================================
void CParticleSystem : : bindGlobalValueToUserParam ( const std : : string & globalValueName , uint userParamIndex )
{
NL_PS_FUNC_MAIN ( CParticleSystem_bindGlobalValueToUserParam )
nlassert ( userParamIndex < MaxPSUserParam ) ;
if ( globalValueName . empty ( ) ) // disable a user param global value
{
if ( ! _UserParamGlobalValue ) return ;
_UserParamGlobalValue [ userParamIndex ] = NULL ;
for ( uint k = 0 ; k < MaxPSUserParam ; + + k )
{
if ( _UserParamGlobalValue [ k ] ! = NULL ) return ;
}
// no more entry used
delete _UserParamGlobalValue ;
_UserParamGlobalValue = NULL ;
}
else // enable a user param global value
{
if ( ! _UserParamGlobalValue )
{
// no table has been allocated yet, so create one
_UserParamGlobalValue = new const TGlobalValuesMap : : value_type * [ MaxPSUserParam ] ;
std : : fill ( _UserParamGlobalValue , _UserParamGlobalValue + MaxPSUserParam , ( TGlobalValuesMap : : value_type * ) NULL ) ;
}
// has the global value be created yet ?
TGlobalValuesMap : : const_iterator it = _GlobalValuesMap . find ( globalValueName ) ;
if ( it ! = _GlobalValuesMap . end ( ) )
{
// yes, make a reference on it
_UserParamGlobalValue [ userParamIndex ] = & ( * it ) ;
}
else
{
// create a new entry
std : : pair < TGlobalValuesMap : : iterator , bool > itPair = _GlobalValuesMap . insert ( TGlobalValuesMap : : value_type ( globalValueName , 0.f ) ) ;
_UserParamGlobalValue [ userParamIndex ] = & ( * ( itPair . first ) ) ;
}
}
}
///=======================================================================================
void CParticleSystem : : setGlobalValue ( const std : : string & name , float value )
{
NL_PS_FUNC ( CParticleSystem_setGlobalValue )
nlassert ( ! name . empty ( ) ) ;
NLMISC : : clamp ( value , 0.f , 1.f ) ;
_GlobalValuesMap [ name ] = value ;
}
///=======================================================================================
float CParticleSystem : : getGlobalValue ( const std : : string & name )
{
NL_PS_FUNC ( CParticleSystem_getGlobalValue )
TGlobalValuesMap : : const_iterator it = _GlobalValuesMap . find ( name ) ;
if ( it ! = _GlobalValuesMap . end ( ) ) return it - > second ;
return 0.f ; // not a known value
}
///=======================================================================================
std : : string CParticleSystem : : getGlobalValueName ( uint userParamIndex ) const
{
NL_PS_FUNC_MAIN ( CParticleSystem_getGlobalValueName )
nlassert ( userParamIndex < MaxPSUserParam ) ;
if ( ! _UserParamGlobalValue ) return " " ;
if ( ! _UserParamGlobalValue [ userParamIndex ] ) return " " ;
return _UserParamGlobalValue [ userParamIndex ] - > first ;
}
///=======================================================================================
void CParticleSystem : : setGlobalVectorValue ( const std : : string & name , const NLMISC : : CVector & value )
{
NL_PS_FUNC ( CParticleSystem_setGlobalVectorValue )
nlassert ( ! name . empty ( ) ) ;
_GlobalVectorValuesMap [ name ] = value ;
}
///=======================================================================================
NLMISC : : CVector CParticleSystem : : getGlobalVectorValue ( const std : : string & name )
{
NL_PS_FUNC ( CParticleSystem_getGlobalVectorValue )
nlassert ( ! name . empty ( ) ) ;
TGlobalVectorValuesMap : : const_iterator it = _GlobalVectorValuesMap . find ( name ) ;
if ( it ! = _GlobalVectorValuesMap . end ( ) ) return it - > second ;
return NLMISC : : CVector : : Null ; // not a known value
}
///=======================================================================================
CParticleSystem : : CGlobalVectorValueHandle CParticleSystem : : getGlobalVectorValueHandle ( const std : : string & name )
{
NL_PS_FUNC ( CParticleSystem_getGlobalVectorValueHandle )
nlassert ( ! name . empty ( ) ) ;
TGlobalVectorValuesMap : : iterator it = _GlobalVectorValuesMap . find ( name ) ;
if ( it = = _GlobalVectorValuesMap . end ( ) )
{
it = _GlobalVectorValuesMap . insert ( TGlobalVectorValuesMap : : value_type ( name , NLMISC : : CVector : : Null ) ) . first ;
}
CGlobalVectorValueHandle handle ;
handle . _Value = & it - > second ;
handle . _Name = & it - > first ;
return handle ;
}
///=======================================================================================
void CParticleSystem : : setMaxDistLODBias ( float lodBias )
{
NL_PS_FUNC_MAIN ( CParticleSystem_setMaxDistLODBias )
NLMISC : : clamp ( lodBias , 0.f , 1.f ) ;
_MaxDistLODBias = lodBias ;
}
///=======================================================================================
bool CParticleSystem : : canFinish ( CPSLocatedBindable * * lastingForeverObj /*= NULL*/ ) const
{
NL_PS_FUNC_MAIN ( CParticleSystem_canFinish )
if ( hasLoop ( lastingForeverObj ) ) return false ;
for ( uint k = 0 ; k < _ProcessVect . size ( ) ; + + k )
{
if ( _ProcessVect [ k ] - > isLocated ( ) )
{
CPSLocated * loc = static_cast < CPSLocated * > ( _ProcessVect [ k ] ) ;
if ( loc - > getLastForever ( ) )
{
for ( uint l = 0 ; l < loc - > getNbBoundObjects ( ) ; + + l )
{
CPSEmitter * em = dynamic_cast < CPSEmitter * > ( loc - > getBoundObject ( l ) ) ;
if ( em & & em - > testEmitForever ( ) )
{
if ( lastingForeverObj ) * lastingForeverObj = em ;
return false ;
}
CPSParticle * p = dynamic_cast < CPSParticle * > ( loc - > getBoundObject ( l ) ) ;
if ( p )
{
if ( lastingForeverObj ) * lastingForeverObj = p ;
return false ; // particles shouldn't live forever, too
}
}
}
}
}
return true ;
}
///=======================================================================================
bool CParticleSystem : : hasLoop ( CPSLocatedBindable * * loopingObj /*= NULL*/ ) const
{
NL_PS_FUNC_MAIN ( CParticleSystem_hasLoop )
// we want to check for loop like A emit B emit A
// NB : there's room for a smarter algo here, but should not be useful for now
for ( uint k = 0 ; k < _ProcessVect . size ( ) ; + + k )
{
if ( _ProcessVect [ k ] - > isLocated ( ) )
{
CPSLocated * loc = static_cast < CPSLocated * > ( _ProcessVect [ k ] ) ;
for ( uint l = 0 ; l < loc - > getNbBoundObjects ( ) ; + + l )
{
CPSEmitter * em = dynamic_cast < CPSEmitter * > ( loc - > getBoundObject ( l ) ) ;
if ( em )
{
if ( em - > checkLoop ( ) )
{
if ( loopingObj ) * loopingObj = em ;
return true ;
}
}
}
}
}
return false ;
}
///=======================================================================================
void CParticleSystem : : systemDurationChanged ( )
{
NL_PS_FUNC_MAIN ( CParticleSystem_systemDurationChanged )
if ( getAutoComputeDelayBeforeDeathConditionTest ( ) )
{
setDelayBeforeDeathConditionTest ( - 1.f ) ;
}
}
///=======================================================================================
void CParticleSystem : : setAutoComputeDelayBeforeDeathConditionTest ( bool computeAuto )
{
NL_PS_FUNC_MAIN ( CParticleSystem_setAutoComputeDelayBeforeDeathConditionTest )
if ( computeAuto = = _AutoComputeDelayBeforeDeathTest ) return ;
_AutoComputeDelayBeforeDeathTest = computeAuto ;
if ( computeAuto ) setDelayBeforeDeathConditionTest ( - 1.f ) ;
}
///=======================================================================================
TAnimationTime CParticleSystem : : getDelayBeforeDeathConditionTest ( ) const
{
NL_PS_FUNC_MAIN ( CParticleSystem_getDelayBeforeDeathConditionTest )
if ( _DelayBeforeDieTest < 0.f )
{
_DelayBeforeDieTest = evalDuration ( ) ;
}
return std : : max ( PS_MIN_TIMEOUT , _DelayBeforeDieTest ) ;
}
///=======================================================================================
// struct to eval duration of an emitter chain
struct CToVisitEmitter
{
float Duration ; // cumuled duration of this emitter parent emitters
const CPSLocated * Located ;
} ;
///=======================================================================================
float CParticleSystem : : evalDuration ( ) const
{
NL_PS_FUNC_MAIN ( CParticleSystem_evalDuration )
std : : vector < const CPSLocated * > visitedEmitter ;
std : : vector < CToVisitEmitter > toVisitEmitter ;
float maxDuration = 0.f ;
for ( uint k = 0 ; k < _ProcessVect . size ( ) ; + + k )
{
if ( _ProcessVect [ k ] - > isLocated ( ) )
{
bool emitterFound = false ;
const CPSLocated * loc = static_cast < const CPSLocated * > ( _ProcessVect [ k ] ) ;
for ( uint l = 0 ; l < loc - > getNbBoundObjects ( ) ; + + l )
{
const CPSLocatedBindable * bind = loc - > getBoundObject ( l ) ;
if ( loc - > getSize ( ) > 0 )
{
switch ( bind - > getType ( ) )
{
case PSParticle :
{
if ( loc - > getLastForever ( ) )
{
return - 1 ;
}
else
{
maxDuration = std : : max ( maxDuration , loc - > evalMaxDuration ( ) ) ;
}
}
break ;
case PSEmitter :
{
if ( ! emitterFound )
{
CToVisitEmitter tve ;
tve . Located = loc ;
tve . Duration = 0.f ;
toVisitEmitter . push_back ( tve ) ;
emitterFound = true ;
}
}
break ;
}
}
}
visitedEmitter . clear ( ) ;
while ( ! toVisitEmitter . empty ( ) )
{
const CPSLocated * loc = toVisitEmitter . back ( ) . Located ;
float duration = toVisitEmitter . back ( ) . Duration ;
toVisitEmitter . pop_back ( ) ;
visitedEmitter . push_back ( loc ) ;
bool emitterFound = false ;
for ( uint m = 0 ; m < loc - > getNbBoundObjects ( ) ; + + m )
{
const CPSLocatedBindable * bind = loc - > getBoundObject ( m ) ;
if ( bind - > getType ( ) = = PSEmitter )
{
const CPSEmitter * em = NLMISC : : safe_cast < const CPSEmitter * > ( loc - > getBoundObject ( m ) ) ;
const CPSLocated * emittedType = em - > getEmittedType ( ) ;
// continue if there's no loop
if ( std : : find ( visitedEmitter . begin ( ) , visitedEmitter . end ( ) , emittedType ) = = visitedEmitter . end ( ) )
{
if ( emittedType ! = NULL )
{
emitterFound = true ;
CToVisitEmitter tve ;
tve . Located = emittedType ;
// if emitter has limited lifetime, use it
if ( ! loc - > getLastForever ( ) )
{
tve . Duration = duration + loc - > evalMaxDuration ( ) ;
}
else
{
// try to eval duration depending on type
switch ( em - > getEmissionType ( ) )
{
case CPSEmitter : : regular :
{
if ( em - > getMaxEmissionCount ( ) ! = 0 )
{
float period = em - > getPeriodScheme ( ) ? em - > getPeriodScheme ( ) - > getMaxValue ( ) : em - > getPeriod ( ) ;
tve . Duration = duration + em - > getEmitDelay ( ) + period * em - > getMaxEmissionCount ( ) ;
}
else
{
tve . Duration = duration + em - > getEmitDelay ( ) ;
}
}
break ;
case CPSEmitter : : onDeath :
case CPSEmitter : : once :
case CPSEmitter : : onBounce :
case CPSEmitter : : externEmit :
tve . Duration = duration ; // can't eval duration ..
break ;
default :
break ;
}
}
toVisitEmitter . push_back ( tve ) ;
}
}
}
}
if ( ! emitterFound )
{
if ( ! loc - > getLastForever ( ) )
{
duration + = loc - > evalMaxDuration ( ) ;
}
maxDuration = std : : max ( maxDuration , duration ) ;
}
}
}
}
return maxDuration ;
}
///=======================================================================================
bool CParticleSystem : : isDestroyConditionVerified ( ) const
{
NL_PS_FUNC_MAIN ( CParticleSystem_isDestroyConditionVerified )
if ( getDestroyCondition ( ) ! = CParticleSystem : : none )
{
if ( getSystemDate ( ) > getDelayBeforeDeathConditionTest ( ) )
{
switch ( getDestroyCondition ( ) )
{
case CParticleSystem : : noMoreParticles : return ! hasParticles ( ) ;
case CParticleSystem : : noMoreParticlesAndEmitters : return ! hasParticles ( ) & & ! hasEmitters ( ) ;
default : nlassert ( 0 ) ; return false ;
}
}
}
return false ;
}
///=======================================================================================
void CParticleSystem : : setSystemDate ( float date )
{
NL_PS_FUNC_MAIN ( CParticleSystem_setSystemDate )
if ( date = = _SystemDate ) return ;
_SystemDate = date ;
for ( uint k = 0 ; k < _ProcessVect . size ( ) ; + + k )
{
_ProcessVect [ k ] - > systemDateChanged ( ) ;
}
}
///=======================================================================================
void CParticleSystem : : registerSoundServer ( UPSSoundServer * soundServer )
{
NL_PS_FUNC ( CParticleSystem_registerSoundServer )
if ( soundServer = = _SoundServer ) return ;
if ( _SoundServer )
{
CParticleSystemManager : : stopSoundForAllManagers ( ) ;
}
_SoundServer = soundServer ;
if ( _SoundServer )
{
CParticleSystemManager : : reactivateSoundForAllManagers ( ) ;
}
}
///=======================================================================================
void CParticleSystem : : activateEmitters ( bool active )
{
NL_PS_FUNC_MAIN ( CParticleSystem_activateEmitters )
for ( uint k = 0 ; k < getNbProcess ( ) ; + + k )
{
if ( getProcess ( k ) - > isLocated ( ) )
{
CPSLocated * loc = static_cast < CPSLocated * > ( getProcess ( k ) ) ;
if ( loc )
{
for ( uint l = 0 ; l < loc - > getNbBoundObjects ( ) ; + + l )
{
if ( loc - > getBoundObject ( l ) - > getType ( ) = = PSEmitter )
loc - > getBoundObject ( l ) - > setActive ( active ) ;
}
}
}
}
}
///=======================================================================================
bool CParticleSystem : : hasActiveEmitters ( ) const
{
NL_PS_FUNC_MAIN ( CParticleSystem_hasActiveEmitters )
for ( uint k = 0 ; k < getNbProcess ( ) ; + + k )
{
if ( getProcess ( k ) - > isLocated ( ) )
{
const CPSLocated * loc = static_cast < const CPSLocated * > ( getProcess ( k ) ) ;
if ( loc )
{
for ( uint l = 0 ; l < loc - > getNbBoundObjects ( ) ; + + l )
{
if ( loc - > getBoundObject ( l ) - > getType ( ) = = PSEmitter )
{
if ( loc - > getBoundObject ( l ) - > isActive ( ) ) return true ;
}
}
}
}
}
return false ;
}
///=======================================================================================
bool CParticleSystem : : hasEmittersTemplates ( ) const
{
NL_PS_FUNC_MAIN ( CParticleSystem_hasEmittersTemplates )
for ( uint k = 0 ; k < getNbProcess ( ) ; + + k )
{
if ( getProcess ( k ) - > isLocated ( ) )
{
const CPSLocated * loc = static_cast < const CPSLocated * > ( getProcess ( k ) ) ;
if ( loc )
{
for ( uint l = 0 ; l < loc - > getNbBoundObjects ( ) ; + + l )
{
if ( loc - > getBoundObject ( l ) - > getType ( ) = = PSEmitter )
{
return true ;
}
}
}
}
}
return false ;
}
///=======================================================================================
void CParticleSystem : : matchArraySize ( )
{
NL_PS_FUNC_MAIN ( CParticleSystem_matchArraySize )
for ( uint k = 0 ; k < getNbProcess ( ) ; + + k )
{
if ( getProcess ( k ) - > isLocated ( ) )
{
CPSLocated * loc = static_cast < CPSLocated * > ( getProcess ( k ) ) ;
loc - > resize ( loc - > getSize ( ) ) ; // match the max size with the number of instances
}
}
}
///=======================================================================================
uint CParticleSystem : : getMaxNumParticles ( ) const
{
NL_PS_FUNC_MAIN ( CParticleSystem_getMaxNumParticles )
uint numParts = 0 ;
for ( uint k = 0 ; k < getNbProcess ( ) ; + + k )
{
if ( getProcess ( k ) - > isLocated ( ) )
{
const CPSLocated * loc = static_cast < const CPSLocated * > ( getProcess ( k ) ) ;
if ( loc )
{
for ( uint l = 0 ; l < loc - > getNbBoundObjects ( ) ; + + l )
{
if ( loc - > getBoundObject ( l ) - > getType ( ) = = PSParticle )
{
numParts + = loc - > getMaxSize ( ) ;
}
}
}
}
}
return numParts ;
}
///=======================================================================================
uint CParticleSystem : : getCurrNumParticles ( ) const
{
NL_PS_FUNC_MAIN ( CParticleSystem_getCurrNumParticles )
uint numParts = 0 ;
for ( uint k = 0 ; k < getNbProcess ( ) ; + + k )
{
if ( getProcess ( k ) - > isLocated ( ) )
{
const CPSLocated * loc = static_cast < const CPSLocated * > ( getProcess ( k ) ) ;
if ( loc )
{
for ( uint l = 0 ; l < loc - > getNbBoundObjects ( ) ; + + l )
{
if ( loc - > getBoundObject ( l ) - > getType ( ) = = PSParticle )
{
numParts + = loc - > getSize ( ) ;
}
}
}
}
}
return numParts ;
}
///=======================================================================================
void CParticleSystem : : getTargeters ( const CPSLocated * target , std : : vector < CPSTargetLocatedBindable * > & targeters )
{
NL_PS_FUNC_MAIN ( CParticleSystem_getTargeters )
nlassert ( target ) ;
nlassert ( isProcess ( target ) ) ;
targeters . clear ( ) ;
for ( uint k = 0 ; k < getNbProcess ( ) ; + + k )
{
if ( getProcess ( k ) - > isLocated ( ) )
{
CPSLocated * loc = static_cast < CPSLocated * > ( getProcess ( k ) ) ;
if ( loc )
{
for ( uint l = 0 ; l < loc - > getNbBoundObjects ( ) ; + + l )
{
CPSTargetLocatedBindable * targeter = dynamic_cast < CPSTargetLocatedBindable * > ( loc - > getBoundObject ( l ) ) ;
if ( targeter )
{
for ( uint m = 0 ; m < targeter - > getNbTargets ( ) ; + + m )
{
if ( targeter - > getTarget ( m ) = = target )
{
targeters . push_back ( targeter ) ;
break ;
}
}
}
}
}
}
}
}
///=======================================================================================
void CParticleSystem : : matrixModeChanged ( CParticleSystemProcess * proc , TPSMatrixMode oldMode , TPSMatrixMode newMode )
{
NL_PS_FUNC_MAIN ( CParticleSystem_matrixModeChanged )
nlassert ( proc ) ;
// check that the located belong to that system
nlassert ( isProcess ( proc ) ) ;
if ( oldMode ! = PSUserMatrix & & newMode = = PSUserMatrix )
{
addRefForUserSysCoordInfo ( ) ;
}
else if ( oldMode = = PSUserMatrix & & newMode ! = PSUserMatrix )
{
releaseRefForUserSysCoordInfo ( ) ;
}
}
///=======================================================================================
void CParticleSystem : : addRefForUserSysCoordInfo ( uint numRefs )
{
NL_PS_FUNC_MAIN ( CParticleSystem_addRefForUserSysCoordInfo )
if ( ! numRefs ) return ;
if ( ! _UserCoordSystemInfo )
{
_UserCoordSystemInfo = new CUserCoordSystemInfo ;
}
2010-05-13 17:02:00 +00:00
nlassert ( _UserCoordSystemInfo ) ;
2010-05-06 00:08:41 +00:00
_UserCoordSystemInfo - > NumRef + = numRefs ;
}
///=======================================================================================
void CParticleSystem : : releaseRefForUserSysCoordInfo ( uint numRefs )
{
NL_PS_FUNC_MAIN ( CParticleSystem_releaseRefForUserSysCoordInfo )
if ( ! numRefs ) return ;
nlassert ( _UserCoordSystemInfo ) ;
2010-05-13 17:02:00 +00:00
nlassert ( numRefs < = _UserCoordSystemInfo - > NumRef ) ;
2010-05-06 00:08:41 +00:00
_UserCoordSystemInfo - > NumRef - = numRefs ;
if ( _UserCoordSystemInfo - > NumRef = = 0 )
{
delete _UserCoordSystemInfo ;
_UserCoordSystemInfo = NULL ;
}
}
///=======================================================================================
void CParticleSystem : : checkIntegrity ( )
{
NL_PS_FUNC_MAIN ( CParticleSystem_checkIntegrity )
// do some checks
uint userMatrixUsageCount = 0 ;
for ( TProcessVect : : iterator it = _ProcessVect . begin ( ) ; it ! = _ProcessVect . end ( ) ; + + it )
{
userMatrixUsageCount + = ( * it ) - > getUserMatrixUsageCount ( ) ;
}
if ( userMatrixUsageCount = = 0 )
{
nlassert ( _UserCoordSystemInfo = = NULL ) ;
}
else
{
nlassert ( _UserCoordSystemInfo ! = NULL ) ;
nlassert ( _UserCoordSystemInfo - > NumRef = = userMatrixUsageCount ) ;
}
for ( uint k = 0 ; k < _ProcessVect . size ( ) ; + + k )
{
nlassert ( _ProcessVect [ k ] - > getOwner ( ) = = this ) ;
}
}
///=======================================================================================
void CParticleSystem : : enumTexs ( std : : vector < NLMISC : : CSmartPtr < ITexture > > & dest , IDriver & drv )
{
NL_PS_FUNC_MAIN ( CParticleSystem_enumTexs )
for ( TProcessVect : : iterator it = _ProcessVect . begin ( ) ; it ! = _ProcessVect . end ( ) ; + + it )
{
( * it ) - > enumTexs ( dest , drv ) ;
}
}
///=======================================================================================
void CParticleSystem : : setZBias ( float value )
{
NL_PS_FUNC_MAIN ( CParticleSystem_setZBias )
for ( TProcessVect : : iterator it = _ProcessVect . begin ( ) ; it ! = _ProcessVect . end ( ) ; + + it )
{
( * it ) - > setZBias ( value ) ;
}
}
///=======================================================================================
void CParticleSystem : : getSortingByEmitterPrecedence ( std : : vector < uint > & result ) const
{
NL_PS_FUNC_MAIN ( CParticleSystem_getSortingByEmitterPrecedence )
# ifdef NL_DEBUG
nlassert ( ! hasLoop ( ) ) ; // should be an acyclic graph, otherwise big problem....
# endif
typedef std : : list < CParticleSystemProcess * > TProcessList ;
std : : vector < TProcessList > degreeToNodes ;
std : : vector < TProcessList : : iterator > nodeToIterator ( _ProcessVect . size ( ) ) ;
//
std : : vector < uint > inDegree ( _ProcessVect . size ( ) , 0 ) ; // degree for each node
for ( uint k = 0 ; k < _ProcessVect . size ( ) ; + + k )
{
if ( _ProcessVect [ k ] - > isLocated ( ) )
{
CPSLocated * loc = static_cast < CPSLocated * > ( _ProcessVect [ k ] ) ;
for ( uint l = 0 ; l < loc - > getNbBoundObjects ( ) ; + + l )
{
if ( loc - > getBoundObject ( l ) - > getType ( ) = = PSEmitter )
{
CPSEmitter * pEmit = NLMISC : : safe_cast < CPSEmitter * > ( loc - > getBoundObject ( l ) ) ;
if ( pEmit - > getEmittedType ( ) )
{
+ + inDegree [ getIndexOf ( * pEmit - > getEmittedType ( ) ) ] ;
}
}
}
}
}
// make enough room in degreeToNodes.
for ( uint k = 0 ; k < inDegree . size ( ) ; + + k )
{
if ( degreeToNodes . size ( ) < = inDegree [ k ] )
{
degreeToNodes . resize ( inDegree [ k ] + 1 ) ;
}
}
// sort nodes by degree
for ( uint k = 0 ; k < inDegree . size ( ) ; + + k )
{
// NB : could not do resize there because we keep iterators in the list, so it's done in the previous loop
degreeToNodes [ inDegree [ k ] ] . push_front ( _ProcessVect [ k ] ) ;
nodeToIterator [ k ] = degreeToNodes [ inDegree [ k ] ] . begin ( ) ;
}
//
# ifdef NL_DEBUG
# define DO_SBEP_CHECK \
{ for ( uint k = 0 ; k < degreeToNodes . size ( ) ; + + k ) \
{ \
for ( TProcessList : : const_iterator it = degreeToNodes [ k ] . begin ( ) ; it ! = degreeToNodes [ k ] . end ( ) ; + + it ) \
{ \
nlassert ( inDegree [ ( * it ) - > getIndex ( ) ] = = k ) ; \
} \
} }
# else
# define DO_SBEP_CHECK
# endif
//
DO_SBEP_CHECK
result . reserve ( _ProcessVect . size ( ) ) ;
result . clear ( ) ;
if ( degreeToNodes . empty ( ) ) return ;
// now, do the sort -> add each node with a degree of 0, and removes arc to their son (and insert in new good list according to their degree)
while ( ! degreeToNodes [ 0 ] . empty ( ) )
{
DO_SBEP_CHECK
CParticleSystemProcess * pr = degreeToNodes [ 0 ] . front ( ) ;
degreeToNodes [ 0 ] . pop_front ( ) ;
result . push_back ( getIndexOf ( * pr ) ) ;
if ( pr - > isLocated ( ) )
{
CPSLocated * loc = static_cast < CPSLocated * > ( pr ) ;
for ( uint l = 0 ; l < loc - > getNbBoundObjects ( ) ; + + l )
{
if ( loc - > getBoundObject ( l ) - > getType ( ) = = PSEmitter )
{
CPSEmitter * pEmit = NLMISC : : safe_cast < CPSEmitter * > ( loc - > getBoundObject ( l ) ) ;
// update degree of node
if ( pEmit - > getEmittedType ( ) )
{
uint emittedLocIndex = getIndexOf ( * pEmit - > getEmittedType ( ) ) ;
uint degree = inDegree [ emittedLocIndex ] ;
nlassert ( degree ! = 0 ) ;
degreeToNodes [ degree - 1 ] . splice ( degreeToNodes [ degree - 1 ] . begin ( ) , degreeToNodes [ degree ] , nodeToIterator [ emittedLocIndex ] ) ;
nodeToIterator [ emittedLocIndex ] = degreeToNodes [ degree - 1 ] . begin ( ) ; // update iterator
- - inDegree [ emittedLocIndex ] ;
DO_SBEP_CHECK
}
}
}
}
}
}
///=======================================================================================
void CParticleSystem : : updateProcessIndices ( )
{
NL_PS_FUNC_MAIN ( CParticleSystem_updateProcessIndices )
for ( uint k = 0 ; k < _ProcessVect . size ( ) ; + + k )
{
_ProcessVect [ k ] - > setIndex ( k ) ;
}
}
///=======================================================================================
void CParticleSystem : : dumpHierarchy ( )
{
NL_PS_FUNC_MAIN ( CParticleSystem_dumpHierarchy )
for ( uint k = 0 ; k < _ProcessVect . size ( ) ; + + k )
{
CPSLocated * loc = dynamic_cast < CPSLocated * > ( _ProcessVect [ k ] ) ;
if ( loc )
{
nlinfo ( " Located k : %s @%x " , loc - > getName ( ) . c_str ( ) , ( ptrdiff_t ) loc ) ;
for ( uint l = 0 ; l < loc - > getNbBoundObjects ( ) ; + + l )
{
CPSEmitter * emitter = dynamic_cast < CPSEmitter * > ( loc - > getBoundObject ( l ) ) ;
if ( emitter )
{
nlinfo ( " emitter %s : emit %s @%x " , emitter - > getName ( ) . c_str ( ) , emitter - > getEmittedType ( ) ? emitter - > getEmittedType ( ) - > getName ( ) . c_str ( ) : " none " , ( ptrdiff_t ) emitter - > getEmittedType ( ) ) ;
}
}
}
}
}
///=======================================================================================
void CParticleSystem : : onShow ( bool shown )
{
NL_PS_FUNC_MAIN ( CParticleSystem_onShow )
for ( uint k = 0 ; k < _ProcessVect . size ( ) ; + + k )
{
_ProcessVect [ k ] - > onShow ( shown ) ;
}
}
} // NL3D