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_PARTICLE_BASIC_H
+00027 #define NL_PS_PARTICLE_BASIC_H
+00028 
+00029 #include "nel/misc/types_nl.h"
+00030 #include "nel/misc/vector_2f.h"
+00031 #include "3d/ps_located.h"
+00032 #include "3d/ps_plane_basis.h"
+00033 #include "3d/material.h"
+00034 #include "3d/ps_attrib_maker.h"
+00035 
+00036 namespace NL3D 
+00037 {
+00038 
+00039 
+00041 // class forward declarations //
+00043 
+00044 class CTextureGrouped;
+00045 
+00054 class CPSParticle : public CPSLocatedBindable
+00055 {
+00056 public:
+00057 
+00059         CPSParticle();
+00060 
+00062         uint32 getType(void) const { return PSParticle; }
+00063 
+00065         virtual uint32 getPriority(void) const { return 1000; }
+00066 
+00068         virtual bool hasParticles(void) const { nlassert(_Owner); return _Owner->getSize() != 0; }
+00069         
+00073         virtual void step(TPSProcessPass pass, TAnimationTime ellapsedTime, TAnimationTime realEt)
+00074         {
+00075                 if (
+00076                         (pass == PSBlendRender && hasTransparentFaces())
+00077                         || (pass == PSSolidRender && hasOpaqueFaces())
+00078                         )
+00079                 {
+00080                         draw(pass == PSSolidRender);
+00081                 }
+00082                 else 
+00083                 if (pass == PSToolRender) // edition mode only
+00084                 {                       
+00085                         showTool();
+00086                 }
+00087         }
+00088 
+00090         virtual bool hasTransparentFaces(void)  = 0;
+00091 
+00093         virtual bool hasOpaqueFaces(void)  = 0;
+00094 
+00096         virtual void draw(bool opaque) {}
+00097 
+00099         virtual void showTool();
+00100 
+00102         virtual uint32 getMaxNumFaces(void) const = 0;
+00103         
+00105         virtual void serial(NLMISC::IStream &f) throw(NLMISC::EStream)
+00106         {               
+00108                 sint ver = f.serialVersion(2);
+00109                 CPSLocatedBindable::serial(f);
+00110                 if (ver >= 2)
+00111                 {
+00112                         f.serial(_DisableAutoLOD);
+00113                 }               
+00114         }
+00115 
+00116 
+00118         void    disableAutoLOD(bool disable = true) { _DisableAutoLOD = disable; }
+00119 
+00121         bool    isAutoLODDisabled() const { return _DisableAutoLOD; }   
+00122 
+00123 protected:
+00124 
+00129         void notifyOwnerMaxNumFacesChanged(void) const
+00130         {
+00131                 if (_Owner)
+00132                 {
+00133                         _Owner->notifyMaxNumFacesChanged();
+00134                 }
+00135         }
+00136 
+00139         virtual void newElement(CPSLocated *emitterLocated, uint32 emitterIndex) = 0;
+00140         
+00145         virtual void deleteElement(uint32 index) = 0;
+00146 
+00150         virtual void resize(uint32 size) = 0;
+00151 
+00152 
+00157          void computeSrcStep(uint32 &step, uint &numToProcess);
+00158 
+00159 private:
+00161          bool   _DisableAutoLOD;
+00162 };
+00163 
+00166 
+00168 class CPSColoredParticle
+00169 {
+00170         public:
+00171 
+00176                 void setColorScheme(CPSAttribMaker<CRGBA> *col);
+00177 
+00179                 CPSAttribMaker<CRGBA> *getColorScheme(void) { return _ColorScheme; }
+00180 
+00182                 const CPSAttribMaker<CRGBA> *getColorScheme(void) const { return _ColorScheme; }
+00183 
+00185                 void setColor(NLMISC::CRGBA col);
+00186 
+00188                 NLMISC::CRGBA getColor(void) const { return _Color; }
+00189 
+00191                 CPSColoredParticle();
+00192 
+00194                 virtual ~CPSColoredParticle();
+00195 
+00197                 void serialColorScheme(NLMISC::IStream &f) throw(NLMISC::EStream);              
+00198 
+00199         protected:              
+00200 
+00202                 virtual CPSLocated *getColorOwner(void) = 0;            
+00203                 CRGBA _Color;
+00204                 
+00205                 CPSAttribMaker<CRGBA> *_ColorScheme;                                            
+00206 
+00208                 virtual void updateMatAndVbForColor(void) = 0;
+00209 
+00210                 void newColorElement(CPSLocated *emitterLocated, uint32 emitterIndex)
+00211                 {
+00212                         if (_ColorScheme && _ColorScheme->hasMemory()) _ColorScheme->newElement(emitterLocated, emitterIndex);
+00213                 }       
+00214                 void deleteColorElement(uint32 index)
+00215                 {
+00216                         if (_ColorScheme && _ColorScheme->hasMemory()) _ColorScheme->deleteElement(index);
+00217                 }
+00218                 void resizeColor(uint32 size)
+00219                 {
+00220                         nlassert(size < (1 << 16));
+00221                         if (_ColorScheme && _ColorScheme->hasMemory()) _ColorScheme->resize(size, getColorOwner()->getSize());
+00222                 }
+00223 };
+00224 
+00227 
+00229 class CPSSizedParticle
+00230 {
+00231         public:
+00232 
+00237                 void setSizeScheme(CPSAttribMaker<float> *size);
+00238 
+00239 
+00240 
+00242                 CPSAttribMaker<float> *getSizeScheme(void) { return _SizeScheme; }
+00243 
+00245                 const CPSAttribMaker<float> *getSizeScheme(void) const { return _SizeScheme; }
+00246 
+00248                 void setSize(float size);
+00249 
+00251                 float getSize(void) const { return _ParticleSize; }
+00252 
+00254                 CPSSizedParticle();
+00255 
+00257                 virtual ~CPSSizedParticle();
+00258 
+00260                 void serialSizeScheme(NLMISC::IStream &f) throw(NLMISC::EStream);
+00261 
+00262         protected:      
+00263                 
+00265                 virtual CPSLocated *getSizeOwner(void) = 0;             
+00266                 float _ParticleSize;
+00267                 CPSAttribMaker<float> *_SizeScheme;
+00268                 void newSizeElement(CPSLocated *emitterLocated, uint32 emitterIndex)
+00269                 {
+00270                         if (_SizeScheme && _SizeScheme->hasMemory()) _SizeScheme->newElement(emitterLocated, emitterIndex);
+00271                 }       
+00272                 void deleteSizeElement(uint32 index)
+00273                 {
+00274                         if (_SizeScheme && _SizeScheme->hasMemory()) _SizeScheme->deleteElement(index);
+00275                 }
+00276                 void resizeSize(uint32 size)
+00277                 {
+00278                         nlassert(size < (1 << 16));
+00279                         if (_SizeScheme && _SizeScheme->hasMemory()) _SizeScheme->resize(size, getSizeOwner()->getSize());
+00280                 }
+00281 };
+00282 
+00283 
+00286 
+00288 class CPSRotated2DParticle
+00289 {
+00290         public:
+00291 
+00297                 void setAngle2DScheme(CPSAttribMaker<float> *scheme);
+00298 
+00300                 CPSAttribMaker<float> *getAngle2DScheme(void) { return _Angle2DScheme; }
+00301 
+00303                 const CPSAttribMaker<float> *getAngle2DScheme(void) const { return _Angle2DScheme; }
+00304 
+00305 
+00310                 void setAngle2D(float angle);
+00311 
+00313                 float getAngle2D(void) const { return _Angle2D; }
+00314 
+00316                 CPSRotated2DParticle();
+00317 
+00319                 virtual ~CPSRotated2DParticle();
+00320 
+00322                 void serialAngle2DScheme(NLMISC::IStream &f) throw(NLMISC::EStream);
+00323 
+00324 
+00325 
+00331                 static inline const float *getRotTable(void)
+00332                 {
+00333                         nlassert(_InitializedRotTab); // must have called initRotTable at the start of the apply
+00334                         return _RotTable;
+00335                 }
+00336 
+00338                 static void initRotTable(void);
+00339 
+00340         protected:      
+00342                 virtual CPSLocated *getAngle2DOwner(void) = 0;
+00343                                 
+00344                 float _Angle2D;
+00345                 CPSAttribMaker<float> *_Angle2DScheme;
+00346                 static float _RotTable[4 * 256];
+00347 
+00348                 //#ifdef NL_DEBUG
+00350                         static bool _InitializedRotTab;
+00351                 //#endif
+00352 
+00353                 void newAngle2DElement(CPSLocated *emitterLocated, uint32 emitterIndex)
+00354                 {
+00355                         if (_Angle2DScheme && _Angle2DScheme->hasMemory()) _Angle2DScheme->newElement(emitterLocated, emitterIndex);
+00356                 }       
+00357                 void deleteAngle2DElement(uint32 index)
+00358                 {
+00359                         if (_Angle2DScheme && _Angle2DScheme->hasMemory()) _Angle2DScheme->deleteElement(index);
+00360                 }
+00361                 void resizeAngle2D(uint32 size)
+00362                 {
+00363                         nlassert(size < (1 << 16));
+00364                         if (_Angle2DScheme && _Angle2DScheme->hasMemory()) _Angle2DScheme->resize(size, getAngle2DOwner()->getSize());
+00365                 }
+00366 };
+00367 
+00368 
+00371 
+00373 struct CPSTexturedParticleNoAnim
+00374 {
+00376                 virtual void                                            setTexture(CSmartPtr<ITexture> tex) = 0;
+00378                 virtual ITexture                                        *getTexture(void) = 0;
+00379                 virtual const ITexture                          *getTexture(void) const = 0;
+00380 };
+00381 
+00384 
+00388 class CPSTexturedParticle
+00389 {
+00390         public:
+00391 
+00398                 void setTextureIndexScheme(CPSAttribMaker<sint32> *animOrder);
+00399 
+00401                 CPSAttribMaker<sint32> *getTextureIndexScheme(void) { return _TextureIndexScheme; }
+00402 
+00404                 const CPSAttribMaker<sint32> *getTextureIndexScheme(void) const { return _TextureIndexScheme; }
+00405 
+00407                 void setTextureIndex(sint32 index);
+00408 
+00410                 sint32 getTextureIndex(void) const { return _TextureIndex; }            
+00411 
+00413                 void setTextureGroup(NLMISC::CSmartPtr<CTextureGrouped> texGroup);
+00414 
+00416                 CTextureGrouped *getTextureGroup(void) {  return _TexGroup; }
+00417 
+00419                 const CTextureGrouped *getTextureGroup(void) const { return _TexGroup; }
+00420 
+00425                 void setTexture(CSmartPtr<ITexture> tex);
+00426 
+00428                 ITexture *getTexture(void) { return _Tex; }
+00429                 // get the texture (const version)
+00430                 const ITexture *getTexture(void) const { return _Tex; }
+00431 
+00433                 CPSTexturedParticle();
+00434 
+00436                 virtual ~CPSTexturedParticle();
+00437 
+00439                 void serialTextureScheme(NLMISC::IStream &f) throw(NLMISC::EStream);            
+00440                 
+00441         protected:                      
+00443                 virtual CPSLocated *getTextureIndexOwner(void) = 0;
+00444                 
+00445                 // a single texture
+00446                 CSmartPtr<ITexture> _Tex;
+00447 
+00448                 // a grouped texture
+00449                 CSmartPtr<CTextureGrouped> _TexGroup;           
+00450                 
+00451                 CPSAttribMaker<sint32> *_TextureIndexScheme;
+00452 
+00453                 // a texture index. Most of the time, a scheme of index will be used instead of that
+00454                 sint32 _TextureIndex;
+00455 
+00457                 virtual void updateMatAndVbForTexture(void) = 0;
+00458 
+00459                 void newTextureIndexElement(CPSLocated *emitterLocated, uint32 emitterIndex)
+00460                 {
+00461                         if (_TextureIndexScheme && _TextureIndexScheme->hasMemory()) _TextureIndexScheme->newElement(emitterLocated, emitterIndex);
+00462                 }       
+00463                 void deleteTextureIndexElement(uint32 index)
+00464                 {
+00465                         if (_TextureIndexScheme && _TextureIndexScheme->hasMemory()) _TextureIndexScheme->deleteElement(index);
+00466                 }
+00467                 void resizeTextureIndex(uint32 size)
+00468                 {
+00469                         nlassert(size < (1 << 16));
+00470                         if (_TextureIndexScheme && _TextureIndexScheme->hasMemory()) _TextureIndexScheme->resize(size, getTextureIndexOwner()->getSize() );
+00471                 }
+00472 };
+00473 
+00476 
+00482 class CPSMultiTexturedParticle
+00483 {
+00484 public:
+00486         CPSMultiTexturedParticle();
+00487 
+00489         enum TOperator { Add = 0, Modulate, Decal, EnvBumpMap, Last = 0xff };
+00490 
+00492         void                                            enableMultiTexture(bool enabled = true);
+00493         bool                                            isMultiTextureEnabled() const   { return (_MultiTexState & (uint8) MultiTextureEnabled) != 0; }
+00494 
+00496         void                                            setTexture2(ITexture *tex);     
+00497 
+00499         const ITexture                          *getTexture2() const { return _Texture2; }
+00500         ITexture                                        *getTexture2() { return _Texture2; }
+00501 
+00505         void                                            setMainTexOp(TOperator op);     
+00506 
+00507         TOperator                                       getMainTexOp() const       { return _MainOp; }
+00508 
+00509         // Enable the use of an alternate texture for multitexturing. When disabled, this discard the textures that may have been set.
+00510         void                                            enableAlternateTex(bool enabled = true);
+00511         bool                                            isAlternateTexEnabled() const { return (_MultiTexState & (uint8) AlternateTextureEnabled) != 0; }
+00512         
+00514         // Convert the texture to / from a bumpmap if needed. (so you just provide its heightmap)
+00515         void                                            setTexture2Alternate(ITexture *tex);
+00516 
+00518         const ITexture                          *getTexture2Alternate() const { return _AlternateTexture2; }
+00519         ITexture                                        *getTexture2Alternate() { return _AlternateTexture2; }
+00520 
+00522         void                                            setAlternateTexOp(TOperator op); 
+00523         
+00524         TOperator                                       getAlternateTexOp() const           
+00525         {               
+00526                 return _AlternateOp; 
+00527         }
+00528 
+00532         void                                            setScrollSpeed(uint stage, const NLMISC::CVector2f &sp) 
+00533         {
+00534                 nlassert(stage < 2);
+00535                 _TexScroll[stage] = sp;         
+00536         }
+00537         const NLMISC::CVector2f         &getScrollSpeed(uint stage) const
+00538         {
+00539                 nlassert(stage < 2);
+00540                 return _TexScroll[stage];
+00541         }
+00542 
+00546         void                                            setAlternateScrollSpeed(uint stage, const NLMISC::CVector2f &sp) 
+00547         {
+00548                 nlassert(stage < 2);
+00549                 _TexScrollAlternate[stage] = sp;
+00550         }
+00551         const NLMISC::CVector2f         &getAlternateScrollSpeed(uint stage) const
+00552         {
+00553                 nlassert(stage < 2);
+00554                 return _TexScrollAlternate[stage];
+00555         }
+00556 
+00558         void serialMultiTex(NLMISC::IStream &f) throw(NLMISC::EStream); 
+00559 
+00564         void setupMaterial(ITexture *primary, IDriver *drv, CMaterial &mat);
+00565 
+00569         static void forceBasicCaps(bool force = true) { _ForceBasicCaps =  force; }
+00570 
+00572         static  bool areBasicCapsForced() { return _ForceBasicCaps; }
+00573 
+00575         void    setUseLocalDate(bool use);
+00576         bool    getUseLocalDate() { return (_MultiTexState & ScrollUseLocalDate) != 0; }
+00577 
+00579         void    setUseLocalDateAlt(bool use);
+00580         bool    getUseLocalDateAlt() { return (_MultiTexState & ScrollUseLocalDateAlternate) != 0; }
+00581 
+00583         void    setBumpFactor(float bumpFactor) { _BumpFactor = bumpFactor; touch(); }
+00584         float   getBumpFactor() const { return _BumpFactor; }
+00585 
+00586 protected:      
+00587         void                                            setupMultiTexEnv(TOperator op, ITexture *tex1, ITexture *tex2, CMaterial &mat); 
+00588         TOperator                                       _MainOp, _AlternateOp;
+00589         NLMISC::CSmartPtr<ITexture> _Texture2;
+00590         NLMISC::CSmartPtr<ITexture> _AlternateTexture2; 
+00591 
+00593         NLMISC::CVector2f _TexScroll[2];
+00595         NLMISC::CVector2f _TexScrollAlternate[2];
+00596         
+00597         enum TMultiTexState {  TouchFlag = 0x01, MultiTextureEnabled = 0x02, AlternateTextureEnabled = 0x04, AlternateTextureUsed = 0x08, EnvBumpMapUsed = 0x10, BasicCapsForced = 0x20,
+00598                                                         ScrollUseLocalDate = 0x40, ScrollUseLocalDateAlternate = 0x80
+00599                                                 };
+00600         uint8   _MultiTexState;
+00601 
+00603         bool    isAlternateTextureUsed() const { return (_MultiTexState & AlternateTextureUsed) != 0; }
+00604         bool    isEnvBumpMapUsed() const { return (_MultiTexState & EnvBumpMapUsed) != 0; }
+00605 
+00606         void touch()            { _MultiTexState |= (uint8) TouchFlag; }
+00607         void unTouch()          { _MultiTexState &= ~ (uint8) TouchFlag; }
+00608         bool isTouched()        { return (_MultiTexState & TouchFlag) != 0; }   
+00609         bool areBasicCapsForcedLocal() const { return (_MultiTexState & BasicCapsForced) != 0; }
+00610         void forceBasicCapsLocal(bool force) 
+00611         { 
+00612                 if (force) _MultiTexState |= BasicCapsForced;
+00613                 else _MultiTexState &= ~BasicCapsForced;
+00614         }
+00615         float           _BumpFactor;
+00616         static bool _ForceBasicCaps;    
+00617 };
+00618  
+00619 
+00622 
+00626 class CPSRotated3DPlaneParticle
+00627 {
+00628         public:
+00629 
+00634                 void setPlaneBasisScheme(CPSAttribMaker<CPlaneBasis> *basisMaker);
+00635 
+00640 
+00641                 CPSAttribMaker<CPlaneBasis> *getPlaneBasisScheme(void) { return _PlaneBasisScheme; }
+00642 
+00644                 const CPSAttribMaker<CPlaneBasis> *getPlaneBasisScheme(void) const { return _PlaneBasisScheme; }
+00645 
+00646                 void setPlaneBasis(const CPlaneBasis &basis);
+00647 
+00649                 CPlaneBasis getPlaneBasis(void) const { return _PlaneBasis; }
+00650 
+00652                 CPSRotated3DPlaneParticle();
+00653 
+00655                 virtual ~CPSRotated3DPlaneParticle();
+00656 
+00658                 void serialPlaneBasisScheme(NLMISC::IStream &f) throw(NLMISC::EStream);
+00659 
+00660         protected:              
+00662 
+00664                 virtual CPSLocated *getPlaneBasisOwner(void) = 0;               
+00665                 
+00666                 CPSAttribMaker<CPlaneBasis> *_PlaneBasisScheme;
+00667                 
+00668                 CPlaneBasis _PlaneBasis; // constant basis..
+00669 
+00670                 void newPlaneBasisElement(CPSLocated *emitterLocated, uint32 emitterIndex)
+00671                 {
+00672                         if (_PlaneBasisScheme && _PlaneBasisScheme->hasMemory()) _PlaneBasisScheme->newElement(emitterLocated, emitterIndex);
+00673                 }       
+00674                 void deletePlaneBasisElement(uint32 index)
+00675                 {
+00676                         if (_PlaneBasisScheme && _PlaneBasisScheme->hasMemory()) _PlaneBasisScheme->deleteElement(index);
+00677                 }
+00678                 void resizePlaneBasis(uint32 size)
+00679                 {
+00680                         nlassert(size < (1 << 16));
+00681                         if (_PlaneBasisScheme && _PlaneBasisScheme->hasMemory()) _PlaneBasisScheme->resize(size, getPlaneBasisOwner()->getSize());
+00682                 }
+00683 };
+00684 
+00687 
+00692 struct CPSHintParticleRotateTheSame
+00693 {
+00703         virtual void hintRotateTheSame(uint32 nbConfiguration
+00704                                                         , float minAngularVelocity = NLMISC::Pi
+00705                                                         , float maxAngularVelocity = NLMISC::Pi
+00706                                                   ) = 0;
+00707 
+00712         virtual void disableHintRotateTheSame(void) = 0;
+00713         
+00714 
+00719         virtual uint32 checkHintRotateTheSame(float &minAngularVelocity, float &maxAngularVelocity) const = 0;
+00720 };
+00721 
+00724 
+00726 struct CPSTailParticle
+00727 {
+00731         virtual void setColorFading(bool onOff = true) = 0;
+00732 
+00734         virtual bool getColorFading(void) const = 0;
+00735                 
+00736                 
+00738         virtual void setTailNbSeg(uint32 nbSeg) = 0;
+00739 
+00740         // get the number of segments in the tail
+00741         virtual uint32 getTailNbSeg(void) const = 0;
+00742 
+00743         
+00748         virtual void setSystemBasis(bool yes) = 0;
+00749                 
+00751         virtual bool isInSystemBasis(void) const = 0;
+00752 };
+00753 
+00756 
+00758 struct CPSShapeParticle
+00759 {
+00761         virtual void setShape(const std::string &shape) = 0;
+00762 
+00764         virtual std::string getShape(void) const = 0;
+00765 };
+00766 
+00769 
+00773 class CPSMaterial
+00774 {
+00775 public:
+00777         CPSMaterial();
+00778 
+00780         enum TBlendingMode { add, modulate, alphaBlend, alphaTest };    
+00781 
+00783         void serialMaterial(NLMISC::IStream &f) throw(NLMISC::EStream); 
+00784 
+00786         void setBlendingMode(CPSMaterial::TBlendingMode mode);
+00787 
+00789         CPSMaterial::TBlendingMode getBlendingMode(void) const; 
+00790 
+00791 
+00796         void forceModulateConstantColor(bool force, const NLMISC::CRGBA &col = NLMISC::CRGBA::White);
+00797 
+00804         void forceTexturedMaterialStages(uint numStages);
+00805 
+00806         
+00807 protected:
+00808         CMaterial _Mat;         
+00809 };
+00810 
+00811 
+00812 //==========================================================================    
+00814 inline void SetupModulatedStage(CMaterial &m, uint stage, CMaterial::TTexSource src1, CMaterial::TTexSource src2)
+00815 {
+00816         m.texEnvOpRGB(stage, CMaterial::Modulate);
+00817         m.texEnvOpAlpha(stage, CMaterial::Modulate);
+00818         m.texEnvArg0RGB(stage, src1, CMaterial::SrcColor);
+00819         m.texEnvArg1RGB(stage, src2, CMaterial::SrcColor);
+00820         m.texEnvArg0Alpha(stage, src1, CMaterial::SrcAlpha);
+00821         m.texEnvArg1Alpha(stage, src2, CMaterial::SrcAlpha);
+00822 }
+00823 
+00824 
+00825 
+00826 
+00827 } // NL3D
+00828 
+00829 
+00830 #endif // NL_PS_PARTICLE_BASIC_H
+00831 
+00832 /* End of ps_particle_basic.h */
+