nevrax.org : docs

00001 
00007 /* Copyright, 2000 - 2002 Nevrax Ltd.
00008  *
00009  * This file is part of NEVRAX NEL.
00010  * NEVRAX NEL is free software; you can redistribute it and/or modify
00011  * it under the terms of the GNU General Public License as published by
00012  * the Free Software Foundation; either version 2, or (at your option)
00013  * any later version.
00014 
00015  * NEVRAX NEL is distributed in the hope that it will be useful, but
00016  * WITHOUT ANY WARRANTY; without even the implied warranty of
00017  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
00018  * General Public License for more details.
00019 
00020  * You should have received a copy of the GNU General Public License
00021  * along with NEVRAX NEL; see the file COPYING. If not, write to the
00022  * Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
00023  * MA 02111-1307, USA.
00024  */
00025 
00026 #include "std3d.h"
00027 
00028 #include "3d/particle_system_manager.h"
00029 #include "3d/particle_system_model.h"
00030 #include "3d/scene.h"
00031 
00032 namespace NL3D {
00033 
00035 CParticleSystemManager::CParticleSystemManager() : _NumModels(0)
00036 {
00037         _CurrListIterator = _ModelList.end();
00038 }
00039 
00041 void    CParticleSystemManager::refreshModels(const std::vector<NLMISC::CPlane> &worldFrustumPyramid,  const NLMISC::CVector &viewerPos)
00042 {       
00043         #ifdef NL_DEBUG
00044                 nlassert(_NumModels == _ModelList.size());
00045         #endif
00046 
00047         if (_NumModels == 0) return;
00048         const uint toProcess = std::min(_NumModels, (uint) NumProcessToRefresh);        
00049 
00050         for (uint k = 0; k < toProcess; ++k)
00051         {
00052                 if (_CurrListIterator == _ModelList.end())
00053                 {
00054                         _CurrListIterator = _ModelList.begin();
00055                 }
00056                 
00057                 if ((*_CurrListIterator)->refreshRscDeletion(worldFrustumPyramid, viewerPos)) // check if the resources of the model must be released (which also release them)
00058                 {                                               
00059                         _CurrListIterator = _ModelList.erase(_CurrListIterator);                        
00060                         -- _NumModels;
00061                 }
00062                 else
00063                 {
00064                         ++ _CurrListIterator;
00065                 }               
00066         }
00067 
00068         #ifdef NL_DEBUG
00069                 nlassert(_NumModels == _ModelList.size());
00070         #endif
00071 }
00072 
00074 CParticleSystemManager::TModelHandle CParticleSystemManager::addSystemModel(CParticleSystemModel *model)
00075 {
00076         #ifdef NL_DEBUG
00077                 nlassert(std::find(_ModelList.begin(), _ModelList.end(), model) == _ModelList.end()); 
00078         #endif
00079         _ModelList.push_front(model);
00080         ++_NumModels;
00081 
00082         #ifdef NL_DEBUG
00083                 nlassert(_NumModels == _ModelList.size());
00084         #endif
00085 
00086         TModelHandle handle;
00087         handle.Valid = true;
00088         handle.Iter = _ModelList.begin();
00089         return handle;
00090 }
00091 
00092 
00094 void            CParticleSystemManager::removeSystemModel(TModelHandle &handle)
00095 {       
00096         nlassert(handle.Valid);
00097         #ifdef NL_DEBUG
00098                 nlassert(_NumModels == _ModelList.size());
00099         #endif
00100         nlassert(_NumModels != 0);      
00101         if (handle.Iter == _CurrListIterator)
00102         {
00103                 ++_CurrListIterator;            
00104         }
00105 
00106         _ModelList.erase(handle.Iter);
00107         --_NumModels;
00108         #ifdef NL_DEBUG
00109                 nlassert(_NumModels == _ModelList.size());
00110         #endif
00111 }
00112 
00113 
00115 CParticleSystemManager::TModelHandle    CParticleSystemManager::addPermanentlyAnimatedSystem(CParticleSystemModel *ps)
00116 {
00117         #ifdef NL_DEBUG
00118                 nlassert(std::find(_PermanentlyAnimatedModelList.begin(), _PermanentlyAnimatedModelList.end(), ps) == _PermanentlyAnimatedModelList.end());
00119         #endif
00120         _PermanentlyAnimatedModelList.push_front(ps);
00121 
00122 
00123         TModelHandle handle;
00124         handle.Valid = true;
00125         handle.Iter = _PermanentlyAnimatedModelList.begin();
00126         return handle;  
00127 }
00128 
00130 void                    CParticleSystemManager::removePermanentlyAnimatedSystem(CParticleSystemManager::TModelHandle &handle)
00131 {
00132         nlassert(handle.Valid);
00133         _PermanentlyAnimatedModelList.erase(handle.Iter);       
00134 }
00135 
00137 void    CParticleSystemManager::processAnimate(TAnimationTime deltaT)
00138 {
00139         for (TModelList::iterator it = _PermanentlyAnimatedModelList.begin(); it != _PermanentlyAnimatedModelList.end(); ++it)
00140         {
00141                 CParticleSystemModel &psm = *(*it);
00142                 CParticleSystem          *ps  = psm.getPS();
00143                 if (ps)
00144                 {
00145                         if (psm.isAutoGetEllapsedTimeEnabled())
00146                         {
00147                                 psm.setEllapsedTime(ps->getScene()->getEllapsedTime() * psm.getEllapsedTimeRatio());
00148                         }
00149                         TAnimationTime delay = psm.getEllapsedTime();
00150                         // animate particles
00151                         ps->step(CParticleSystem::Anim, delay); 
00152 
00153                         if (!psm.getEditionMode())
00154                         {                       
00155                                 // test deletion condition (no more particle, no more particle and emitters)
00156                                 if (ps->getDestroyCondition() != CParticleSystem::none)
00157                                 {
00158                                         if (ps->getSystemDate() > ps->getDelayBeforeDeathConditionTest())
00159                                         {
00160                                                 switch (ps->getDestroyCondition())
00161                                                 {
00162                                                         case CParticleSystem::noMoreParticles:
00163                                                                 if (!ps->hasParticles())
00164                                                                 {                                                       
00165                                                                         psm.releaseRscAndInvalidate();
00166                                                                         return;
00167                                                                 }
00168                                                         break;
00169                                                         case CParticleSystem::noMoreParticlesAndEmitters:
00170                                                                 if (!ps->hasParticles() && !ps->hasEmitters())
00171                                                                 {
00172                                                                         psm.releaseRscAndInvalidate();
00173                                                                         return;
00174                                                                 }
00175                                                         break;
00176                                                         default: break;
00177                                                 }
00178                                         }
00179                                 }
00180                         }
00181                 }
00182         }
00183 }
00184 
00185 } // NL3D
particle_system_manager.cpp
