SmokeVol.h

Go to the documentation of this file.

//##################################################
//# $Id: SmokeVol.h 359 2005-12-26 17:22:09Z herout $
//##################################################

#ifndef _SmokeVol_h_
#define _SmokeVol_h_

#define _rev_SmokeVol_h_ "$Id: SmokeVol.h 359 2005-12-26 17:22:09Z herout $" 


#include "Transparency.h"
#include "Effect.h"
#include "Color.h"
#include "TexNoise.h"
#include "Environment.h"

#define TEXTURE_SIZE                    128                     
#define NUM_TEXTURES                    16                      


class TNoiseTexture
{
  private:
    float   textArr[NUM_TEXTURES][TEXTURE_SIZE][TEXTURE_SIZE];          
  public:
    TNoiseTexture( float density, int octaves ); 
    void createTextures( float density, int octaves ); 
    float getTexturePoint( int x, int y, int n );
};


class TSmokeVol : public TEffect 
{
public:
  class TParticle : TTransparent 
  {
    friend class TSmokeVol;
  private:
    TVector   position;                         
    TVector   direction;                        
    float     time2LiveInit;            
    float     time2Live;                        
    float     size;                                     
        float     sizeStart;                    
        float     sizeEnd;                              
    float     dsize;                            
    TColor    color;                            
    TColor    colorEnd;                         
        TColor    colorStart;                   
    TColor    dcolor;                           
    bool      free;                                     
    unsigned  texId;                            
    int       method;                           
        bool      wind;                                 
        bool      gravity;                              
        float     mass;                                 

  public:
    TParticle();
    ~TParticle();
    void UpdateTexture( const double &time, char * str, int texture );
        virtual void Render( TCamera *Camera );
    virtual void Schedule( TCamera *Camera );

        bool IsAlive() const { return ( ( time2Live > 0) && ( !free ) ); }                      
    void Move( const double &delta );
//    void SetColor( const TColor &colorStart, const TColor &colorEnd, int method );
        void FireAt( const TVector &position, const TVector &direction, float time2Live,
                 float sizeStart, float sizeEnd, const TColor &colorStart,
                 const TColor &colorEnd,int method, int &lastText, bool wind,
                                 bool gravity, float mass );
  };

  class TInterpolation
  {
  public:
    enum eInterpolationMethod { Linear, Exponential };

  private:
    static eInterpolationMethod si_method;                              

  public:
    static void Init();
    static eInterpolationMethod getMethod();
    static void changeMethod( eInterpolationMethod method );
  };


  class TRendering
  {
  public:
    enum eRenderingMethod { ParticlesOnly, Billboards, TexturedBillboards };

  private:
    static eRenderingMethod sr_method;                                                                                  

  public:
    static void Init();
    static eRenderingMethod getMethod();
    static void changeMethod( eRenderingMethod method );
  };
  
protected:
  bool        existent;                 
  TVector     position;                 
  TVector     dposition;                
  TVector     direction;                
  float       size;                             
  float       dispersion;               
  float       speed;                    
  int         maxCount;                 
  int         actCount;                 
  float       PPS;                              
  float       actPPS;                   
  float       partSizeStart;    
  float       partSizeEnd;              
  float       partTTL;                  
  float       duration;                 
  float       durationOld;              
  TParticle*  particles;                
  float       last_delta;               
  TColor      colorStart;               
  TColor      colorEnd;                 
  int         method;                   
  bool        wind;                             
  bool        gravity;                  
  int             lastTex;                      
  float       mass;                             

public: 
  static TInterpolation Interpolation;          
  static TRendering             Rendering;                      

  TSmokeVol( float size, int maxCount, float duration, float PPS, float partSizeStart, float partSizeEnd, bool wind, bool gravity );
  virtual ~TSmokeVol();
  virtual void TimeTick( const double &time, const double &delta ); 
  virtual void Render( TCamera *Camera );
  virtual bool IsExistent() { return existent; }
  virtual void Move( const double &delta );
  virtual void GenerateParticles();  
  virtual void FireAt( const TVector &position, const TVector &dposition, float power, const TVector &direction, float partTTL, float disp, float mass );
  virtual void SetColor( const TColor &colorStart, const TColor &colorEnd, int method );
};

float GetRandomFloat(float mid, float delta);
float interpolateNoise(int x, int y, float arr[TEXTURE_SIZE][TEXTURE_SIZE], int del );
void updateField( float arrx[TEXTURE_SIZE][TEXTURE_SIZE], float arr[TEXTURE_SIZE][TEXTURE_SIZE], int del );

#endif

---