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 #ifndef NL_PS_EMITTER_H
+00027 #define NL_PS_EMITTER_H
+00028 
+00029 #include "nel/misc/types_nl.h"
+00030 #include "3d/ps_located.h"
+00031 #include "3d/ps_attrib_maker.h"
+00032 #include "3d/ps_edit.h"
+00033 #include "3d/ps_plane_basis.h"
+00034 #include "3d/ps_direction.h"
+00035 
+00036 
+00037 namespace NL3D {
+00038 
+00039 
+00049 class CPSEmitter : public CPSLocatedBindable
+00050 {
+00051 public:
+00052 
+00054 
+00055 
+00056                 CPSEmitter();
+00057 
+00058                 // dtor
+00059                 virtual ~CPSEmitter();
+00061 
+00063         uint32                                                  getType(void) const { return PSEmitter; }
+00064 
+00065 
+00067         virtual uint32                                  getPriority(void) const { return 500; }
+00068 
+00070         virtual bool                                    hasEmitters(void) { nlassert(_Owner); return _Owner->getSize() != 0; }
+00071                 
+00078         virtual void                                    step(TPSProcessPass pass, TAnimationTime ellapsedTime, TAnimationTime realEllapsedTime);
+00079         
+00080 
+00082         virtual void                                    showTool(void);
+00083 
+00085         void                                                    setEmittedType(CPSLocated *et);
+00086 
+00090         virtual void                                    notifyTargetRemoved(CPSLocated *ptr);
+00091 
+00093         CPSLocated                                              *getEmittedType(void) { return _EmittedType; }
+00095         const CPSLocated                                *getEmittedType(void) const { return _EmittedType; }
+00096 
+00097 
+00106         enum TEmissionType { regular = 0, onDeath = 1,  once = 2, onBounce = 3, externEmit = 4 };
+00107 
+00110         void                                                    setEmissionType(TEmissionType freqType);
+00111 
+00113         TEmissionType                                   getEmissionType(void) const { return _EmissionType; }
+00114 
+00118         void                                                    setPeriod(float period);
+00119 
+00121         float                                                   getPeriod(void) const { return _Period; }
+00122 
+00124         bool                                                    usePeriodScheme(void) { return _PeriodScheme != NULL; }
+00125 
+00127         void                                                    setPeriodScheme(CPSAttribMaker<float> *scheme);
+00128 
+00129         // Retrieve the period scheme, or null, if there'isnt
+00130         CPSAttribMaker<float>                   *getPeriodScheme(void) { return _PeriodScheme; }
+00131 
+00132         // Retrieve the period scheme, or null, if there'isnt (const version)
+00133         const CPSAttribMaker<float>             *getPeriodScheme(void) const  { return _PeriodScheme; }
+00134 
+00136         void                                                    setEmitDelay(float delay) { _EmitDelay = delay; }
+00137 
+00139         float                                                   getEmitDelay() const { return _EmitDelay; }
+00140 
+00142         void                                                    setMaxEmissionCount(uint8 count);
+00143 
+00145         uint8                                                   getMaxEmissionCount() const { return _MaxEmissionCount; }
+00146 
+00150         void                                                    setGenNb(uint32 GenNb);
+00151 
+00153         uint                                                    getGenNb(void) const { return _GenNb; }
+00154 
+00156         bool                                                    useGenNbScheme(void) { return _GenNbScheme != NULL; }
+00157 
+00159         void                                                    setGenNbScheme(CPSAttribMaker<uint32> *scheme);
+00160 
+00162         CPSAttribMaker<uint32>                  *getGenNbScheme(void) { return _GenNbScheme; }
+00163 
+00165         const CPSAttribMaker<uint32>    *getGenNbScheme(void) const  { return _GenNbScheme; }
+00166 
+00168         void serial(NLMISC::IStream &f) throw(NLMISC::EStream);
+00169 
+00171 
+00172 
+00175                 void                                                    setSpeedInheritanceFactor(float fact)
+00176                 {
+00177                         _SpeedInheritanceFactor = fact;
+00178                 }
+00179 
+00181                 float                                                   getSpeedInheritanceFactor(void) const
+00182                 {
+00183                         return _SpeedInheritanceFactor;
+00184                 }
+00185 
+00187                 void                                                    enableSpeedBasisEmission(bool enabled = true)
+00188                 {
+00189                         _SpeedBasisEmission  = enabled;
+00190                 }
+00191 
+00195                 bool                                                    isSpeedBasisEmissionEnabled(void) const { return _SpeedBasisEmission; }
+00196 
+00197 
+00204                 void                                                    setSpeedVectorInEmitterBasis(bool enable) { _EmitDirBasis = enable;}
+00205 
+00207                 bool                                                    isSpeedVectorInEmitterBasis(void) const   { return _EmitDirBasis;}
+00209         
+00211         void                                                    singleEmit(uint32 index, uint quantity);
+00212 
+00221         void                                                    enableConsistenEmission(bool enable) { _ConsistentEmission = enable; }
+00222 
+00223         bool                                                isConsistentEmissionEnabled() const { return _ConsistentEmission; }
+00224 
+00228         virtual void                     releaseRefTo(const CParticleSystemProcess *other);
+00229          
+00233         virtual void                     releaseAllRef();
+00234 
+00235 protected:      
+00236 
+00238         void                                            processEmit(uint32 index, sint nbToGenerate);
+00239 
+00241         void                                            processEmitConsistent(const NLMISC::CVector &emitterPos,
+00242                                                                                                           uint32 emitterIndex,
+00243                                                                                                           sint nbToGenerate,
+00244                                                                                                           TAnimationTime deltaT,
+00245                                                                                                           TAnimationTime ellapsedTime,
+00246                                                                                                           float realEllapsedTimeRatio
+00247                                                                                                          );
+00248 
+00250         void                                                    processRegularEmission(TAnimationTime ellapsedTime);
+00251 
+00254         void                                                    processRegularEmissionConsistent(TAnimationTime ellapsedTime, float realEllapsedTimeRatio);
+00255 
+00256 
+00257 
+00258 
+00266         virtual void                                    emit(const NLMISC::CVector &srcPos, uint32 index, NLMISC::CVector &pos, NLMISC::CVector &speed) = 0;
+00267 
+00270         virtual void                                    newElement(CPSLocated *emitterLocated, uint32 emitterIndex);
+00271         
+00276         virtual void                                    deleteElement(uint32 index);
+00277 
+00281         virtual void                                    resize(uint32 size);
+00282         virtual void                                    bounceOccured(uint32 index);    
+00283         void                                                    updateMaxCountVect();
+00284 
+00285 
+00286 
+00288         CPSLocated                                              *_EmittedType;
+00289 
+00292         TPSAttribFloat                                  _Phase;
+00293         TPSAttribUInt8                                  _NumEmission; // used only if MaxEmissionCount is != 0
+00294 
+00295         float                                                   _SpeedInheritanceFactor;        
+00296         TEmissionType                                   _EmissionType;
+00297         float _Period;
+00298         CPSAttribMaker<float>                   *_PeriodScheme;                 
+00299         uint32 _GenNb;
+00300         CPSAttribMaker<uint32>                  *_GenNbScheme;
+00301         float                                                   _EmitDelay;
+00302         uint8                                                   _MaxEmissionCount;
+00303         bool                                                    _SpeedBasisEmission;
+00304         bool                                                    _EmitDirBasis; // true when emission direction is in the emitter basis
+00305         bool                                                    _ConsistentEmission; 
+00306 };
+00307 
+00310 
+00315 class CPSModulatedEmitter
+00316 {
+00317         public:
+00318 
+00320                 CPSModulatedEmitter() : _EmitteeSpeed(1.f), _EmitteeSpeedScheme(NULL)
+00321                 {
+00322                 }
+00323 
+00325                 virtual ~CPSModulatedEmitter()
+00326                 {
+00327                         delete _EmitteeSpeedScheme;
+00328                 }
+00329 
+00333                 void setEmitteeSpeedScheme(CPSAttribMaker<float> *scheme)
+00334                 {
+00335                         delete _EmitteeSpeedScheme;
+00336                         _EmitteeSpeedScheme = scheme;
+00337                         if (getModulatedEmitterOwner() && scheme->hasMemory()) 
+00338                                 scheme->resize(getModulatedEmitterOwner()->getMaxSize(), getModulatedEmitterOwner()->getSize());
+00339                 }
+00340 
+00342                 void setEmitteeSpeed(float speed)
+00343                 {
+00344                         delete _EmitteeSpeedScheme;
+00345                         _EmitteeSpeedScheme = NULL;
+00346                         _EmitteeSpeed = speed;
+00347                 
+00348                 }
+00349 
+00351                 float getEmitteeSpeed(void) const { return _EmitteeSpeed; }
+00352 
+00354                 CPSAttribMaker<float> *getEmitteeSpeedScheme(void) { return _EmitteeSpeedScheme; }
+00355 
+00357                 const CPSAttribMaker<float> *getEmitteeSpeedScheme(void) const { return _EmitteeSpeedScheme; }
+00358 
+00360                 bool useEmitteeSpeedScheme(void) const { return _EmitteeSpeedScheme != NULL; }
+00361 
+00363                 void serialEmitteeSpeedScheme(NLMISC::IStream &f) throw(NLMISC::EStream);
+00364                 
+00365         protected:
+00366 
+00367                 // emitter must define this in order to allow this class to access the located owner
+00368                 virtual CPSLocated *getModulatedEmitterOwner(void) = 0;
+00369 
+00370                 void newEmitteeSpeedElement(CPSLocated *emitter, uint32 emitterIndex)
+00371                 {
+00372                         if (_EmitteeSpeedScheme && _EmitteeSpeedScheme->hasMemory()) _EmitteeSpeedScheme->newElement(emitter, emitterIndex);
+00373                 }
+00374 
+00375                 void deleteEmitteeSpeedElement(uint32 index)
+00376                 {
+00377                         if (_EmitteeSpeedScheme && _EmitteeSpeedScheme->hasMemory()) _EmitteeSpeedScheme->deleteElement(index);
+00378                 }
+00379 
+00380                 void resizeEmitteeSpeed(uint32 capacity)
+00381                 {
+00382                         if (_EmitteeSpeedScheme && _EmitteeSpeedScheme->hasMemory()) _EmitteeSpeedScheme->resize(capacity, getModulatedEmitterOwner()->getSize());
+00383                 }
+00384         
+00385 
+00386                 float _EmitteeSpeed;
+00387                 CPSAttribMaker<float> *_EmitteeSpeedScheme;
+00388 }; 
+00389 
+00390 
+00391 
+00394 
+00396 class CPSEmitterDirectionnal : public CPSEmitter, public CPSModulatedEmitter
+00397                                                            ,public CPSDirection
+00398 {
+00399         
+00400 public:
+00401 
+00402 
+00403         CPSEmitterDirectionnal() : _Dir(NLMISC::CVector::K)
+00404         { _Name = std::string("DirectionnalEmitter"); }
+00405 
+00407         virtual void serial(NLMISC::IStream &f) throw(NLMISC::EStream);
+00408 
+00409         
+00410         NLMISC_DECLARE_CLASS(CPSEmitterDirectionnal);
+00411         
+00412         virtual void emit(const NLMISC::CVector &srcPos, uint32 index, NLMISC::CVector &pos, NLMISC::CVector &speed);
+00413 
+00414         void setDir(const NLMISC::CVector &v) { _Dir = v; }
+00415 
+00416         NLMISC::CVector getDir(void) const { return _Dir; }
+00417 
+00418 
+00419 protected:
+00420 
+00421         NLMISC::CVector _Dir;
+00422 
+00423         virtual CPSLocated *getModulatedEmitterOwner(void) { return _Owner; }
+00424         virtual void newElement(CPSLocated *emitter, uint32 emitterIndex);
+00425         virtual void deleteElement(uint32 index);
+00426         virtual void resize(uint32 capacity);
+00427 }; 
+00428 
+00431 
+00433 class CPSRadialEmitter : public CPSEmitterDirectionnal
+00434 {
+00435         public:
+00436         CPSRadialEmitter()
+00437         { _Name = std::string("RadialEmitter"); }
+00439         virtual void serial(NLMISC::IStream &f) throw(NLMISC::EStream); 
+00440         NLMISC_DECLARE_CLASS(CPSRadialEmitter);
+00441         virtual void emit(const NLMISC::CVector &srcPos, uint32 index, NLMISC::CVector &pos, NLMISC::CVector &speed);
+00442 };
+00443 
+00444 
+00447 
+00449 class CPSEmitterOmni : public CPSEmitter, public CPSModulatedEmitter
+00450 {
+00451         
+00452 public:
+00453 
+00454         CPSEmitterOmni()
+00455         {
+00456                 _Name = std::string("EmitterOmni");
+00457         }
+00458 
+00460         virtual void serial(NLMISC::IStream &f) throw(NLMISC::EStream);
+00461         
+00462         NLMISC_DECLARE_CLASS(CPSEmitterOmni);
+00463 
+00464 
+00466         virtual void emit(const NLMISC::CVector &srcPos, uint32 index, NLMISC::CVector &pos, NLMISC::CVector &speed);
+00467 protected:
+00468         virtual CPSLocated *getModulatedEmitterOwner(void) { return _Owner; }
+00469         virtual void newElement(CPSLocated *emitter, uint32 emitterIndex);
+00470         virtual void deleteElement(uint32 index);
+00471         virtual void resize(uint32 capacity);
+00472 
+00473 
+00474 }; 
+00475 
+00478 
+00480 class CPSEmitterRectangle : public CPSEmitter, public CPSModulatedEmitter, public IPSMover
+00481                                                         , public CPSDirection
+00482 {
+00483         public:
+00484 
+00485                 // Ctor
+00486 
+00487                 CPSEmitterRectangle() : _Dir(-NLMISC::CVector::K)
+00488                 {
+00489                         _Name = std::string("EmitterRectangle");
+00490                 }
+00491 
+00493                 virtual void serial(NLMISC::IStream &f) throw(NLMISC::EStream);
+00494         
+00495                 NLMISC_DECLARE_CLASS(CPSEmitterRectangle);
+00496 
+00497 
+00499 
+00500                 virtual void emit(const NLMISC::CVector &srcPos, uint32 index, NLMISC::CVector &pos, NLMISC::CVector &speed);
+00501 
+00502                 virtual void setDir(const NLMISC::CVector &v) { _Dir = v; }
+00503 
+00504                 NLMISC::CVector getDir(void) const { return _Dir; }
+00505 
+00506         
+00507                 void showTool(void);
+00508 
+00509         
+00510 
+00511                 // Inherited from IPSMover
+00512                 virtual bool supportUniformScaling(void) const { return true; }
+00513                 virtual bool supportNonUniformScaling(void) const { return true; }                      
+00514                 virtual void setMatrix(uint32 index, const NLMISC::CMatrix &m); 
+00515                 virtual NLMISC::CMatrix getMatrix(uint32 index) const;                  
+00516                 virtual void setScale(uint32 index, float scale);       
+00517                 virtual void setScale(uint32 index, const NLMISC::CVector &s);
+00518                 NLMISC::CVector getScale(uint32 index) const;
+00519 
+00520         protected:
+00521 
+00522                 virtual CPSLocated *getModulatedEmitterOwner(void) { return _Owner; }
+00523                 
+00524                 CPSAttrib<CPlaneBasis> _Basis;                          
+00525 
+00526                 //  Width
+00527                 TPSAttribFloat _Width;
+00528 
+00529                 //  Height
+00530                 TPSAttribFloat _Height;
+00531 
+00532                 // Direction of emission (in each plane basis)
+00533                 NLMISC::CVector _Dir;
+00534 
+00537                 virtual void newElement(CPSLocated *emitterLocated, uint32 emitterIndex);
+00538         
+00543                 virtual void deleteElement(uint32 index);
+00544 
+00548                 virtual void resize(uint32 size);
+00549 }; 
+00550 
+00551 
+00554 
+00556 class CPSEmitterConic : public CPSEmitterDirectionnal                                   
+00557 {       
+00558 public:
+00559 
+00560         CPSEmitterConic() : _Radius(1.f)
+00561         {
+00562                 _Name = std::string("EmitterConic");
+00563         }
+00564 
+00566         virtual void serial(NLMISC::IStream &f) throw(NLMISC::EStream);
+00567         
+00568         NLMISC_DECLARE_CLASS(CPSEmitterConic);
+00569 
+00570 
+00572         virtual void emit(const NLMISC::CVector &srcPos, uint32 index, NLMISC::CVector &pos, NLMISC::CVector &speed);
+00573 
+00575         void setRadius(float r) { _Radius = r; }
+00576 
+00578         float getRadius(void) const { return _Radius; }
+00579 
+00581         virtual void setDir(const NLMISC::CVector &v);
+00582 
+00583 protected:      
+00584 
+00585         // The radius for emission
+00586         float _Radius;
+00587  
+00588 };
+00589 
+00592 
+00593 // A spherical emitter
+00594 class CPSSphericalEmitter : public CPSEmitter, public CPSModulatedEmitter, public IPSMover
+00595 {
+00596 public:
+00597         // Ctor
+00598 
+00599         CPSSphericalEmitter()
+00600         {
+00601                 _Name = std::string("spherical emitter");
+00602         }
+00603 
+00605         virtual void serial(NLMISC::IStream &f) throw(NLMISC::EStream);
+00606 
+00607         NLMISC_DECLARE_CLASS(CPSSphericalEmitter);
+00608 
+00609 
+00611 
+00612         virtual void emit(const NLMISC::CVector &srcPos, uint32 index, NLMISC::CVector &pos, NLMISC::CVector &speed);
+00613 
+00614         
+00615 
+00616         void showTool(void);
+00617 
+00618 
+00619 
+00620         // Inherited from IPSMover
+00621         virtual bool supportUniformScaling(void) const { return true; }
+00622         virtual bool supportNonUniformScaling(void) const { return false; }                     
+00623         virtual void setMatrix(uint32 index, const NLMISC::CMatrix &m); 
+00624         virtual NLMISC::CMatrix getMatrix(uint32 index) const;                  
+00625         virtual void setScale(uint32 index, float scale) { _Radius[index] = scale; }            
+00626         NLMISC::CVector getScale(uint32 index) const { return NLMISC::CVector(_Radius[index], _Radius[index], _Radius[index]); }
+00627 
+00628 protected:
+00629         virtual CPSLocated *getModulatedEmitterOwner(void) { return _Owner; }   
+00630         TPSAttribFloat _Radius; 
+00631         virtual void newElement(CPSLocated *emitterLocated, uint32 emitterIndex);       
+00632         virtual void deleteElement(uint32 index);
+00633         virtual void resize(uint32 size);
+00634 };
+00635 
+00636 
+00637 } // NL3D
+00638 
+00639 
+00640 #endif // NL_PS_EMITTER_H
+00641 
+00642 /* End of ps_emitter.h */
+