aleajactaest/khanat-opennel-code
1
0
Fork 0
mirror of https://port.numenaute.org/aleajactaest/khanat-opennel-code.git synced 2024-11-24 16:16:14 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions
khanat-opennel-code/code/nel/src/3d/particle_system.cpp

2332 lines
71 KiB
C++
Raw Blame History

// 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-5f;
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
uint numProcess = (uint)_ProcessVect.size();
if (numProcess > _Spawns.size())
{
uint oldSize = (uint)_Spawns.size();
_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 information
{
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);
ptr->setIndex((uint32)_ProcessVect.size() - 1);
//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)
return (uint)_LBMap.count(id);
}
///=======================================================================================
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)
return (uint)_LBMap.size();
}
///=======================================================================================
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;
}
nlassert(_UserCoordSystemInfo);
_UserCoordSystemInfo->NumRef += numRefs;
}
///=======================================================================================
void CParticleSystem::releaseRefForUserSysCoordInfo(uint numRefs)
{
NL_PS_FUNC_MAIN(CParticleSystem_releaseRefForUserSysCoordInfo)
if (!numRefs) return;
nlassert(_UserCoordSystemInfo);
nlassert(numRefs <= _UserCoordSystemInfo->NumRef);
_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 @%p", loc->getName().c_str(), loc);
for(uint l = 0; l < loc->getNbBoundObjects(); ++l)
{
CPSEmitter *emitter = dynamic_cast<CPSEmitter *>(loc->getBoundObject(l));
if (emitter)
{
nlinfo(" emitter %s : emit %s @%p", emitter->getName().c_str(), emitter->getEmittedType() ? emitter->getEmittedType()->getName().c_str() : "none", 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
Reference in a new issue View git blame Copy permalink