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

/*
  orxonox - the future of 3D-vertical-scrollers
 
  Copyright (C) 2004 orx
 
  This program is free software; you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation; either version 2, or (at your option)
  any later version.
 
### File Specific:
  main-programmer: hdavid, amaechler
 
  INSPIRED BY http://www.codesampler.com/usersrc/usersrc_6.htm#oglu_sky_dome_shader
*/

#include "cloud_effect.h"

#include "util/loading/load_param.h"
#include "util/loading/factory.h"
#include "util/loading/resource_manager.h"

#include "material.h"
#include "state.h"
#include "p_node.h"
#include "shader.h"
#include "shell_command.h"

#include "parser/tinyxml/tinyxml.h"


using namespace std;

SHELL_COMMAND(activate, CloudEffect, activateCloud);
SHELL_COMMAND(deactivate, CloudEffect, deactivateCloud);

CREATE_FACTORY(CloudEffect, CL_CLOUD_EFFECT);

CloudEffect::CloudEffect(const TiXmlElement* root)
{
  this->setClassID(CL_CLOUD_EFFECT, "CloudEffect");

  this->init();

  if (root != NULL)
    this->loadParams(root);

  if(cloudActivate)
    this->activate();
}

CloudEffect::~CloudEffect()
{
  this->deactivate();
  
  delete shader;
}


void CloudEffect::init()
{
  PRINTF(0)("Initializing CloudEffect\n");
  
  this->offsetZ = 0;
  this->animationSpeed = 2;
  this->lightPos = Vector(0,0,0);
  this->scale = 0.0008f;
  this->atmosphericRadius = 4000;
  this->planetRadius = 1500;
  this->divs = 50;

  noise3DTexSize = 128;
  noise3DTexName = 0;

  this->make3DNoiseTexture();

  glGenTextures(1, &noise3DTexName);
  glBindTexture(GL_TEXTURE_3D, noise3DTexName);

  glTexParameterf(GL_TEXTURE_3D, GL_TEXTURE_WRAP_S, GL_REPEAT);
  glTexParameterf(GL_TEXTURE_3D, GL_TEXTURE_WRAP_T, GL_REPEAT);
  glTexParameterf(GL_TEXTURE_3D, GL_TEXTURE_WRAP_R, GL_REPEAT);
  glTexParameterf(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
  glTexParameterf(GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);

  glTexImage3D(GL_TEXTURE_3D, 0, GL_RGBA,
               noise3DTexSize, noise3DTexSize, noise3DTexSize,
               0, GL_RGBA, GL_UNSIGNED_BYTE, noise3DTexPtr);
  
  shader = new Shader(ResourceManager::getInstance()->getDataDir() + "/shaders/cloud.vert",
                      ResourceManager::getInstance()->getDataDir() + "/shaders/cloud.frag");

  this->shader->activateShader();

  Shader::Uniform(shader, "Noise").set(0);
  Shader::Uniform(shader, "SkyColor").set(0.0f, 0.0f, 0.8f);
  Shader::Uniform(shader, "CloudColor").set(0.8f, 0.8f, 0.8f);
  
  offset = new Shader::Uniform(shader, "Offset");

  this->shader->deactivateShader();
}


void CloudEffect::loadParams(const TiXmlElement* root)
{
  WeatherEffect::loadParams(root);

  LoadParam(root, "speed", this, CloudEffect, setAnimationSpeed);
  LoadParam(root, "lightPos", this, CloudEffect, setLightPosition);
  LoadParam(root, "scale", this, CloudEffect, setCloudScale);
  
  LoadParam(root, "planetRadius", this, CloudEffect, setPlanetRadius);
  LoadParam(root, "atmosphericRadius", this, CloudEffect, setAtmosphericRadius);
  LoadParam(root, "divisions", this, CloudEffect, setDivisions);
  
  LOAD_PARAM_START_CYCLE(root, element);
  {
    LoadParam_CYCLE(element, "option", this, CloudEffect, setCloudOption);
  }
  LOAD_PARAM_END_CYCLE(element);
}


void CloudEffect::activate()
{
  PRINTF(0)( "Activating\n");
  
  // Can only be set after the loadParams call
  this->shader->activateShader();
  Shader::Uniform(shader, "Scale").set(this->scale);
  Shader::Uniform(shader, "LightPos").set(lightPos.x, lightPos.y, lightPos.z);
  this->shader->deactivateShader();
  
  this->generateSkyPlane(this->divs, this->planetRadius, this->atmosphericRadius, 1, 1);

  this->cloudActivate = true;
}

void CloudEffect::deactivate()
{
  PRINTF(0)("Deactivating CloudEffect\n");

  this->cloudActivate = false;
}

void CloudEffect::draw() const
{
  if (!this->cloudActivate)
    return;

  glPushAttrib(GL_ENABLE_BIT);

  glDisable(GL_LIGHTING);
  glDisable(GL_BLEND);

  glEnable(GL_TEXTURE_3D);
  glBindTexture(GL_TEXTURE_3D, noise3DTexName);

  //glPushMatrix();

  this->shader->activateShader();
  offset->set(0.0f, 0.0f, offsetZ);


  /*glColor3f(1.0, 1.0, 1.0);
  glBegin(GL_QUADS);

  glTexCoord2f(1.0f, 1.0f); glVertex3f(0.0f, 0.0f,  0.0f);
  glTexCoord2f(0.0f, 1.0f); glVertex3f( 0.0f, 10.0f,  0.0f);
  glTexCoord2f(0.0f, 0.0f); glVertex3f( 10.0f, 10.0f,  0.0f);
  glTexCoord2f(1.0f, 0.0f); glVertex3f(10.0f, 0.0f,  0.0f);

  glEnd();*/

  glPushMatrix();
  glTranslatef(0.0f,pRadius,0.0f);
  //glRotatef(timeGetTime()/2000.0f,0.0f, 1.0f, 0.0f);
  //glTranslatef(0.0f,0.0f,0.0f);

  glBegin(GL_TRIANGLES);

  for (int i=0; i < numIndices; i++)
  {
    glColor3f(1.0f, 1.0f, 1.0f);

    glTexCoord2f(planeVertices[indices[i]].u, planeVertices[indices[i]].v);
    glVertex3f(planeVertices[indices[i]].x, planeVertices[indices[i]].y, planeVertices[indices[i]].z);
  }

  glEnd();

  glPopMatrix();

  this->shader->deactivateShader();

  //glPopMatrix();
  glPopAttrib();

}

void CloudEffect::tick (float dt)
{
  if (!this->cloudActivate)
    return;
  this->offsetZ += 0.05 * dt * this->animationSpeed;
}

void CloudEffect::generateSkyPlane(int divisions, float planetRadius, float atmosphereRadius, float hTile, float vTile)
{
  // Make sure our vertex array is clear
  if (planeVertices) 
  {
    delete planeVertices;
    planeVertices = NULL;
  }

  // Make sure our index array is clear
  if (indices)
  {
    delete indices;
    indices = NULL;
  }

  // Set the number of divisions into a valid range
  int divs = divisions;
  if (divisions < 1) 
    divs = 1;

  if (divisions > 256) 
    divs = 256; 

  pRadius = planetRadius;

  // Initialize the Vertex and indices arrays
  numPlaneVertices = (divs + 1) * (divs + 1);   // 1 division would give 4 verts
  numIndices  = divs * divs * 2 * 3;       // 1 division would give 6 indices for 2 tris

  planeVertices = new VERTEX[numPlaneVertices];
  memset(planeVertices, 0, sizeof(VERTEX));

  indices = new int[numIndices];
  memset(indices, 0, sizeof(int)*numIndices);

  // Calculate some values we will need
  float plane_size = 2.0f * (float)sqrt((SQR(atmosphereRadius)-SQR(planetRadius)));
  float delta = plane_size/(float)divs;
  float tex_delta = 2.0f/(float)divs;
  
  // Variables we'll use during the dome's generation
  float x_dist   = 0.0f;
  float z_dist   = 0.0f;
  float x_height = 0.0f;
  float z_height = 0.0f;
  float height = 0.0f;

  VERTEX SV; // temporary vertex

  for (int i=0;i <= divs;i++)
  {
    for (int j=0; j <= divs; j++)
    {
      x_dist = (-0.5f * plane_size) + ((float)j*delta);
      z_dist = (-0.5f * plane_size) + ((float)i*delta);

      x_height = (x_dist*x_dist) / atmosphereRadius;
      z_height = (z_dist*z_dist) / atmosphereRadius;
      height = x_height + z_height;

      SV.x = x_dist;
      SV.y = 0.0f - height;
      SV.z = z_dist;

      // Calculate the texture coordinates
      SV.u = hTile*((float)j * tex_delta*0.5f);
      SV.v = vTile*(1.0f - (float)i * tex_delta*0.5f);

      planeVertices[i*(divs+1)+j] = SV;
    }
  }

  // Calculate the indices
  int index = 0;
  for (int i=0; i < divs;i++)
  {
    for (int j=0; j < divs; j++)
    {
      int startvert = (i*(divs+1) + j);

        // tri 1
      indices[index++] = startvert;
      indices[index++] = startvert+1;
      indices[index++] = startvert+divs+1;

      // tri 2
      indices[index++] = startvert+1;
      indices[index++] = startvert+divs+2;
      indices[index++] = startvert+divs+1;
    }
  }  
}

void CloudEffect::make3DNoiseTexture()
{
  int f, i, j, k, inc;
  int startFrequency = 4;
  int numOctaves = 4;
  double ni[3];
  double inci, incj, inck;
  int frequency = startFrequency;
  GLubyte *ptr;
  double amp = 0.5;

  if ((noise3DTexPtr = (GLubyte *) malloc(noise3DTexSize *
                                          noise3DTexSize *
                                          noise3DTexSize * 4)) == NULL)
    PRINTF(0)("ERROR: Could not allocate 3D noise texture\n");

  for (f=0, inc=0; f < numOctaves;
       ++f, frequency *= 2, ++inc, amp *= 0.5)
  {
    SetNoiseFrequency(frequency);
    ptr = noise3DTexPtr;
    ni[0] = ni[1] = ni[2] = 0;

    inci = 1.0 / (noise3DTexSize / frequency);
    for (i=0; i<noise3DTexSize; ++i, ni[0] += inci)
    {
      incj = 1.0 / (noise3DTexSize / frequency);
      for (j=0; j<noise3DTexSize; ++j, ni[1] += incj)
      {
        inck = 1.0 / (noise3DTexSize / frequency);
        for (k=0; k<noise3DTexSize; ++k, ni[2] += inck, ptr+= 4)
        {
          *(ptr+inc) = (GLubyte) (((noise3(ni)+1.0) * amp)*128.0);
        }
      }
    }
  }
}

void CloudEffect::initNoise()
{
  int i, j, k;

  srand(30757);
  for (i = 0 ; i < B ; i++)
  {
    p[i] = i;
    g1[i] = (double)((rand() % (B + B)) - B) / B;

    for (j = 0 ; j < 2 ; j++)
      g2[i][j] = (double)((rand() % (B + B)) - B) / B;
    normalize2(g2[i]);

    for (j = 0 ; j < 3 ; j++)
      g3[i][j] = (double)((rand() % (B + B)) - B) / B;
    normalize3(g3[i]);
  }

  while (--i)
  {
    k = p[i];
    p[i] = p[j = rand() % B];
    p[j] = k;
  }

  for (i = 0 ; i < B + 2 ; i++)
  {
    p[B + i] = p[i];
    g1[B + i] = g1[i];
    for (j = 0 ; j < 2 ; j++)
      g2[B + i][j] = g2[i][j];
    for (j = 0 ; j < 3 ; j++)
      g3[B + i][j] = g3[i][j];
  }
}

void CloudEffect::SetNoiseFrequency( int frequency)
{
  start = 1;
  B = frequency;
  BM = B-1;
}

double CloudEffect::noise3( double vec[3])
{
  int bx0, bx1, by0, by1, bz0, bz1, b00, b10, b01, b11;
  double rx0, rx1, ry0, ry1, rz0, rz1, *q, sy, sz, a, b, c, d, t, u, v;
  int i, j;

  if (start)
  {
    start = 0;
    initNoise();
  }

  setup(0, bx0,bx1, rx0,rx1);
  setup(1, by0,by1, ry0,ry1);
  setup(2, bz0,bz1, rz0,rz1);

  i = p[ bx0 ];
  j = p[ bx1 ];

  b00 = p[ i + by0 ];
  b10 = p[ j + by0 ];
  b01 = p[ i + by1 ];
  b11 = p[ j + by1 ];

  t  = s_curve(rx0);
  sy = s_curve(ry0);
  sz = s_curve(rz0);

  q = g3[ b00 + bz0 ] ; u = at3(rx0,ry0,rz0);
  q = g3[ b10 + bz0 ] ; v = at3(rx1,ry0,rz0);
  a = lerp(t, u, v);

  q = g3[ b01 + bz0 ] ; u = at3(rx0,ry1,rz0);
  q = g3[ b11 + bz0 ] ; v = at3(rx1,ry1,rz0);
  b = lerp(t, u, v);

  c = lerp(sy, a, b);

  q = g3[ b00 + bz1 ] ; u = at3(rx0,ry0,rz1);
  q = g3[ b10 + bz1 ] ; v = at3(rx1,ry0,rz1);
  a = lerp(t, u, v);

  q = g3[ b01 + bz1 ] ; u = at3(rx0,ry1,rz1);
  q = g3[ b11 + bz1 ] ; v = at3(rx1,ry1,rz1);
  b = lerp(t, u, v);

  d = lerp(sy, a, b);

  return lerp(sz, c, d);
}

void CloudEffect::normalize2( double v[2])
{
  double s;

  s = sqrt(v[0] * v[0] + v[1] * v[1]);
  v[0] = v[0] / s;
  v[1] = v[1] / s;
}

void CloudEffect::normalize3( double v[3])
{
  double s;

  s = sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]);
  v[0] = v[0] / s;
  v[1] = v[1] / s;
  v[2] = v[2] / s;
}