nevrax.org : docs

00001 
00007 /* Copyright, 2001 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.h"
00029 #include "3d/particle_system_shape.h"
00030 #include "3d/particle_system_model.h"
00031 #include "3d/scene.h"
00032 #include "3d/driver.h"
00033 #include "nel/misc/file.h"
00034 #include "nel/misc/mem_stream.h"
00035 
00036 
00037 
00038 namespace NL3D {
00039 
00040 using NLMISC::IStream;
00041 using NLMISC::CIFile;
00042 
00043 
00044 
00045 
00046 // private usage : macro to check the memory integrity
00047 #if defined(NL_DEBUG) && defined(NL_OS_WINDOWS)
00048         #include <crtdbg.h>
00049         //#define PARTICLES_CHECK_MEM nlassert(_CrtCheckMemory());
00050         #define PARTICLES_CHECK_MEM 
00051 #else
00052         #define PARTICLES_CHECK_MEM
00053 #endif
00054 
00056 CParticleSystemShape::CParticleSystemShape() : _MaxViewDist(100.f),
00057                                                                                            _DestroyWhenOutOfFrustum(false),
00058                                                                                            _DestroyModelWhenOutOfRange(false),
00059                                                                                            _UsePrecomputedBBox(false),
00060                                                                                            _Sharing(false)
00061 {
00062         for (uint k = 0; k < 4; ++k)
00063         {
00064                 _UserParamDefaultTrack[k].setValue(0);
00065         }
00066         _DefaultPos.setValue(CVector::Null);
00067         _DefaultScale.setValue( CVector(1, 1, 1) );     
00068         _DefaultRotQuat.setValue(CQuat());
00069         _DefaultTriggerTrack.setValue(true); // by default, system start as soon as they are instanciated
00070 
00071 }
00072 
00074 void    CParticleSystemShape::serial(NLMISC::IStream &f) throw(NLMISC::EStream)
00075 {
00076         sint ver = f.serialVersion(6);
00078         NLMISC::CVector8 &buf = _ParticleSystemProto.bufferAsVector();
00079         f.serialCont(buf);
00080         if (ver > 1)
00081         {
00082                 // serial default tracks
00083                 for (uint k = 0; k < 4; ++k)
00084                 {
00085                         f.serial(_UserParamDefaultTrack[k]);
00086                 }
00087         }
00088         if ( ver > 2)
00089         {
00090                 f.serial (_DefaultPos);
00091                 f.serial (_DefaultScale);               
00092                 f.serial (_DefaultRotQuat);
00093         }
00094         if ( ver > 3)
00095         {
00096                 f.serial(_MaxViewDist);
00097                 f.serial(_DestroyWhenOutOfFrustum);             
00098                 f.serial(_DestroyModelWhenOutOfRange);
00099         }
00100         if ( ver > 4)
00101         {
00102                 f.serial(_UsePrecomputedBBox);
00103                 if (_UsePrecomputedBBox)
00104                 {
00105                         f.serial(_PrecomputedBBox);
00106                 }
00107         }
00108         if ( ver > 5)
00109         {
00110                 f.serial(_Sharing);
00111         }
00112 }
00113 
00115 void CParticleSystemShape::buildFromPS(const CParticleSystem &ps)
00116 {
00117         // must be sure that we are writting in the stream
00118         if (_ParticleSystemProto.isReading())
00119         {
00120                 _ParticleSystemProto.invert();
00121         }
00122         
00123         // to have const correctness in the prototype, we must do this...
00124         CParticleSystem *myPs = const_cast<CParticleSystem *>(&ps);
00125         nlassert(myPs);
00126         // build the prototype
00127         _ParticleSystemProto.serialPtr(myPs);
00128 
00129         // mirror some system values
00130         _MaxViewDist = myPs->getMaxViewDist();
00131         _DestroyWhenOutOfFrustum = myPs->doesDestroyWhenOutOfFrustum(); 
00132         _DestroyModelWhenOutOfRange    = myPs->getDestroyModelWhenOutOfRange();
00133         if (!myPs->getAutoComputeBBox())
00134         {
00135                 _UsePrecomputedBBox = true;
00136                 myPs->computeBBox(_PrecomputedBBox);
00137         }
00138         else
00139         {
00140                 _UsePrecomputedBBox = false;
00141         }
00142         _Sharing = myPs->isSharingEnabled();
00143 }
00144 
00146 void    CParticleSystemShape::getAABBox(NLMISC::CAABBox &bbox) const
00147 {
00148         if (!_UsePrecomputedBBox)
00149         {
00150                 bbox.setCenter(NLMISC::CVector::Null);
00151                 bbox.setHalfSize(NLMISC::CVector(1, 1, 1));
00152         }
00153         else
00154         {
00155                 bbox = _PrecomputedBBox;
00156         }
00157 }
00158 
00160 CParticleSystem *CParticleSystemShape::instanciatePS(CScene &scene)
00161 {
00162         if (_Sharing && _SharedSystem != NULL) // is sharing enabled, and is a system already instanciated
00163         {
00164                 return _SharedSystem;
00165         }
00166 
00167         // copy the datas
00168         CParticleSystem *myInstance = NULL;
00169 
00170         // serialize from the memory stream     
00171         if (!_ParticleSystemProto.isReading()) // we must be sure that we are reading the stream
00172         {
00173                 _ParticleSystemProto.invert();
00174         }
00175 
00176         _ParticleSystemProto.resetPtrTable();
00177         _ParticleSystemProto.seek(0, IStream::begin);
00178         _ParticleSystemProto.serialPtr(myInstance); // instanciate the system   
00179 
00180 
00181         myInstance->setScene(&scene);
00182 
00183         if (_Sharing)
00184         {
00185                 _SharedSystem = myInstance; // set this as the first shared instance
00186         }
00187 
00188         return myInstance;
00189 }
00190 
00192 CTransformShape         *CParticleSystemShape::createInstance(CScene &scene)
00193 {
00194         CParticleSystemModel *psm = NLMISC::safe_cast<CParticleSystemModel *>(scene.createModel(NL3D::ParticleSystemModelId) );
00195         psm->Shape = this;
00196         psm->_Scene = &scene; // the model needs the scene to recreate the particle system he holds                     
00197         // by default, we don't instanciate the system. It will be instanciated only if visible and triggered
00198         // psm->_ParticleSystem = instanciatePS(scene); 
00199 
00200         // Setup position with the default value
00201         psm->ITransformable::setPos( ((CAnimatedValueVector&)_DefaultPos.getValue()).Value  );
00202         psm->ITransformable::setRotQuat( ((CAnimatedValueQuat&)_DefaultRotQuat.getValue()).Value  );    
00203         psm->ITransformable::setScale( ((CAnimatedValueVector&)_DefaultScale.getValue()).Value  );
00204 
00205         // LoadBalancing backward compatibility: ParticleSystems are added to the "Global" Load Balancing Group.
00206         psm->setLoadBalancingGroup("Global");
00207 
00208         return psm;
00209 }
00210 
00212 void    CParticleSystemShape::render(IDriver *drv, CTransformShape *trans, bool passOpaque)
00213 {
00214         nlassert(dynamic_cast<CParticleSystemModel *>(trans));
00215         nlassert(drv);
00216         CParticleSystemModel *psm = (CParticleSystemModel *) trans;
00217         if (psm->_Invalidated) return;
00218         CParticleSystem *ps = psm->getPS();
00220         if (!ps) return;
00221         
00222         TAnimationTime delay = psm->getEllapsedTime();
00223         nlassert(ps->getScene());       
00224 
00226         // render particles  //
00228 
00230         if (ps->isSharingEnabled())
00231         {
00232                 ps->setSysMat(trans->getWorldMatrix());
00233         }
00234         
00235         // Setup the matrix.
00237 
00238         ps->setDriver(drv);
00239         // draw particle
00240         PARTICLES_CHECK_MEM;
00241         if (passOpaque)
00242         {
00243                 ps->step(CParticleSystem::SolidRender, delay);
00244         }
00245         else
00246         {
00247                 ps->step(CParticleSystem::BlendRender, delay);
00248         }
00249         PARTICLES_CHECK_MEM;
00250         if (psm->isToolDisplayEnabled())
00251         {
00252                 ps->step(CParticleSystem::ToolRender, delay);
00253                 PARTICLES_CHECK_MEM;
00254         }
00255 }
00256 
00257 } // NL3D
particle_system_shape.cpp
