source: orxonox.OLD/branches/atmospheric_engine/src/lib/graphics/effects/cloud_effect.h @ 8704

/**
* @file cloud_effect.h
*/

#ifndef _CLOUD_EFFECT
#define _CLOUD_EFFECT

#include "weather_effect.h"

#include "sound_buffer.h"
#include "sound_source.h"

#include "world_entity.h"
#include "material.h"
#include "shader.h"

#define MAXB 0x100
#define N 0x1000
#define NP 12   /* 2^N */
#define NM 0xfff

#define s_curve(t) ( t * t * (3. - 2. * t) )
#define lerp(t, a, b) ( a + t * (b - a) )
#define setup(i,b0,b1,r0,r1)\
        t = vec[i] + N;\
        b0 = ((int)t) & BM;\
        b1 = (b0+1) & BM;\
        r0 = t - (int)t;\
        r1 = r0 - 1.;
#define at2(rx,ry) ( rx * q[0] + ry * q[1] )
#define at3(rx,ry,rz) ( rx * q[0] + ry * q[1] + rz * q[2] )


#define DTOR (PI/180.0f)
#define SQR(x) (x*x)

typedef struct {
  float x,y,z;
  unsigned int color;
  float u, v;
} VERTEX;


class CloudEffect : public WeatherEffect
{
public:
  CloudEffect(const TiXmlElement* root = NULL);
  virtual ~CloudEffect();

  virtual void loadParams(const TiXmlElement* root);

  virtual void init();

  virtual void activate();
  virtual void deactivate();

  inline void activateCloud()
  { this->activate(); }
  
  inline void deactivateCloud()
  { this->deactivate(); }
  
  inline void setCloudOption(const std::string& option)
  {
    if (option == "activate")
      this->cloudActivate = true;
  }
  
  inline void setAnimationSpeed(float speed)
  { this->animationSpeed = speed; }
  
  inline void setLightPosition(float x, float y, float z)
  { this->lightPos = Vector(x,y,z); }

  inline void setCloudScale(float scale)
  { this->scale = scale; }
  
  inline void setPlanetRadius(float planetRadius)
  { this->planetRadius = planetRadius; }
  
  inline void setAtmosphericRadius(float atmosphericRadius)
  { this->atmosphericRadius = atmosphericRadius; }
  
  inline void setDivisions(int divs)
  { this->divs = divs; }
  
  virtual void draw() const;
  virtual void tick(float dt);

  void make3DNoiseTexture();
  void initNoise();
  void SetNoiseFrequency(int frequency);
  double noise3(double vec[3]);
  void normalize2(double v[2]);
  void normalize3(double v[3]);

  void generateSkyPlane(int divisions, float planetRadius, float atmosphereRadius,
                        float hTile, float vTile);
private:

  bool             cloudActivate;
  float            animationSpeed;

  // Material                 cloudMaterial;
  
  // SHADER STUFF
  Shader*          shader;
  Shader::Uniform* offset;
  float            offsetZ;
  Vector           lightPos;
  float            scale;
  float            planetRadius;
  float            atmosphericRadius;
  int              divs;

  // NOISE STUFF
  int              noise3DTexSize;
  GLuint           noise3DTexName;
  GLubyte          *noise3DTexPtr;

  int              p[MAXB + MAXB + 2];
  double           g3[MAXB + MAXB + 2][3];
  double           g2[MAXB + MAXB + 2][2];
  double           g1[MAXB + MAXB + 2];

  int              start;
  int              B;
  int              BM;
  
  // SKYPLANE STUFF
  VERTEX *planeVertices;
  int numPlaneVertices;

  int *indices;
  int numIndices;

  float pRadius;
  
  VERTEX *vertices;
  int numVertices;
};

#endif  /* _CLOUD_EFFECT */