water.cpp

Go to the documentation of this file.

#include <GL/gl.h>
#include <assert.h>
#include <math.h>
#include <string.h>
#include <stdio.h>
#include <complex>

#include "config.h"
#include "water.h"
//#include "envmap.h"

using namespace std;



// Water surface data
typedef float normal[3];
static float *g_hf = NULL;
static normal *g_hf_normals = NULL;
static float *g_hf_fc_re = NULL;
static float *g_hf_fc_im = NULL;
static int g_W = 0;
static int g_H = 0;
// Eye position
static float g_xe, g_ye, g_ze;


static inline float gethf( int x, int y ) {
  while (x<0) x += g_W;
  while (y<0) y += g_H;
  return g_hf[ (x%g_W) + (y%g_H)*g_W ];
}

static inline const normal& getnormal( int x, int y )
{
  while (x<0) x += g_W;
  while (y<0) y += g_H;
  return g_hf_normals[ (x%g_W) + (y%g_H)*g_W ];
}



static inline void computeNormal( int x, int y, float &nx, float &ny, float &nz )
{
  assert( x>=0 && x<g_W );
  assert( y>=0 && y<g_H );

  // Compute normal using forward/backward differences
  nx = 0.5f * (gethf( x+1,y ) - gethf( x-1,y )) / g_cellsize;
  ny = -1;
  nz = 0.5f * (gethf( x,y+1 ) - gethf( x,y-1 )) / g_cellsize;
  // Normalize
  float len = (float)sqrt( nx*nx + ny*ny + nz*nz );
  assert( len != 0 );
  nx /= len; ny /= len; nz /= len;
}
 



double gauss_rand()
{
  int nSum = 0;
  for (unsigned i=0; i<100; i++) {
    nSum += (rand()%2);
  }
  return double(nSum-50) / 25.0;
}


// Wave field fourier coefficient
complex<float> fourier( float x, float y )
{
  const float windx = 1.0;
  const float windy = 0.8;
  const float gravity = 9.81;
  float wind_speed2 = windx*windx + windy*windy;

  float k2 = x*x + y*y;;
  float f1 = exp( -0.5*gravity*gravity / (k2 * wind_speed2 * wind_speed2)  );
  float f2 = abs(x*windx + y*windy) / k2;
  float phillips = f1*f2;

  return float(1.0 / sqrt(2.0)) * complex<float>( gauss_rand(), gauss_rand() ) * phillips;
}



void initWater( int W, int H )
{
  // Validate params
  assert( W>0 && W*H > 0 );
  // Clear old data
  delete[] g_hf;
  delete[] g_hf_normals;
  delete[] g_hf_fc_re;
  delete[] g_hf_fc_im;

  // Init new data
  g_W = W;
  g_H = H;
  g_hf = new float[W*H];
  g_hf_normals = new normal[W*H];
  g_hf_fc_re = new float[W*H];
  g_hf_fc_im = new float[W*H];

  for (int x=0; x<g_W; x++) {
    for (int y=0; y<g_H; y++) {
      complex<float> fc = fourier( x,y );
      g_hf_fc_re[x+y*g_W] = real(fc);
      g_hf_fc_im[x+y*g_W] = imag(fc);
    }
  }
  g_hf_fc_re[0] = 0;
  g_hf_fc_im[0] = 0;

  computeWater( 0.0f );
}

float computeHeight( int x, int y, float t )
{
  float tOff = t*0.1f;
  float re = 0.0f;

  const int N = 8;
  for (int xc=1; xc<N; xc++) {
    for (int yc=1; yc<N; yc++) {
      float xp = x/float(g_W);
      float yp = y/float(g_H);
      float p = 2*M_PI* (xc*(xp+tOff) + yc*(yp+tOff));
      int i = xc + yc*g_W;
      re += g_hf_fc_re[i]*cos(p) - g_hf_fc_im[i]*sin(p);
    }
  }
  return g_fWaterScale * re / N*N;
}


void computeWater( float fTime )
{
  // Compute eye position
  g_xe = g_CameraX; // cos( g_fCameraX*M_PI/180.0f ) * g_fViewDistance;
  g_ze = g_CameraZ; //sin( g_fCameraX*M_PI/180.0f ) * g_fViewDistance;
  g_ye = g_CameraY;//cos( g_fCameraY*M_PI/180.0f ) * g_fViewDistance;

  // Init height field
  float *p = g_hf;
  for (int y=0; y<g_H; y++) {
    for (int x=0; x<g_W; x++) {
      *p = computeHeight( x,y, fTime );
      p++;
    }
  }

  // Init normals
  normal *pN = g_hf_normals;
  for (int y=0; y<g_H; y++) {
    for (int x=0; x<g_W; x++) {
      computeNormal( x,y, (*pN)[0], (*pN)[1], (*pN)[2] );
      pN++;
    }
  }
}


// Compute the fresnel term from the angle between eye direction and the normal
inline float fresnelTerm( float a )
{
  // Compute angle between normal and incoming ray
  float b = 1.0f / (1.0f+a);
  return b*b;
}

// Stream a vertex to the GL
inline void streamVertex( int x, int y, float xp, float yp, float zoff )
{
  // Get normal
  const normal& n = getnormal( x,y );
  // Compute color and fresnel term
  float col[4];
/*  if (g_bSkymap) {
    col[0] = 0.6;//colorSky[0]; 
    col[1] = 0.6;//colorSky[1]; 
    col[2] = 0.8;//colorSky[2];
  }
  else {*/
if (day)
    {
    col[0] = colorSky[0];//White[0]; 
    col[1] = colorSky[1]; 
    col[2] = colorSky[2]; 
    }
else
    {
    col[0] = colorWaterGreen[0];//White[0]; 
    col[1] = colorWaterGreen[1]; 
    col[2] = colorWaterGreen[2]; 
    }

  float zp = zoff + gethf(x,y);

  float ex = g_xe-xp; float ez = g_ye-yp; float ey = g_ze-zp;
  float l = sqrt( ex*ex + ey*ey + ez*ez );
  ex /= l; ey /= l; ez /= l;
  float a = ex*n[0] + ey*n[1] + ez*n[2];
  if (g_bFresnel) {
    col[3] = fresnelTerm( a );
  }
  else {
    col[3] = 0.5f;
  }

  // Compute the reflected ray and use as texture coord for
  // the sky map.
    float rx = -ex + 2*a*n[0];
    float ry = -ey + 2*a*n[1];
    float rz = -ez + 2*a*n[2];
    glTexCoord3f( rx,ry,rz );

  glColor4fv( col );
  glNormal3fv( n );
  glVertex3f( xp, zp, yp );
}


// Draw a quad with multiple textures (via multipass rendering)
void drawWaterQuad( int x, int y, float xp, float yp )
{
  // Compute water surface base z coord
  float zOff = g_waterlevel * g_fHeightScale;
  streamVertex( x  ,y+1, xp           , yp+g_cellsize,zOff );
  streamVertex( x+1,y+1, xp+g_cellsize, yp+g_cellsize,zOff );
  streamVertex( x+1,y  , xp+g_cellsize, yp           ,zOff );
  streamVertex( x  ,y  , xp           , yp           ,zOff );
}


void drawWaterQuads( const vector<_S_WaterQuad> &water )
{
  /*if (g_bSkymap) {
    // Setup sky map as reflection texture
    glBindTexture( GL_TEXTURE_CUBE_MAP, cubeMap() );
    glEnable( GL_TEXTURE_CUBE_MAP );
    
    // Texture environment: MODULATE RGB, REPLACE ALPHA
    // Set up texture function for RGB and alpha channel
    glTexEnvi( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE );
    glTexEnvi( GL_TEXTURE_ENV, GL_COMBINE_RGB_EXT, GL_MODULATE );
    glTexEnvi( GL_TEXTURE_ENV, GL_COMBINE_ALPHA_EXT, GL_REPLACE );
    // Multiply the RGB components of the texture and the primary color
    glTexEnvi( GL_TEXTURE_ENV, GL_SOURCE0_RGB_EXT, GL_PREVIOUS_EXT );
    glTexEnvi( GL_TEXTURE_ENV, GL_OPERAND0_RGB_EXT, GL_SRC_COLOR );
    glTexEnvi( GL_TEXTURE_ENV, GL_SOURCE1_RGB_EXT, GL_TEXTURE );
    glTexEnvi( GL_TEXTURE_ENV, GL_OPERAND1_RGB_EXT, GL_SRC_COLOR );
    // Replace the alpha component
    glTexEnvi( GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_EXT, GL_PREVIOUS_EXT );
    glTexEnvi( GL_TEXTURE_ENV, GL_OPERAND0_ALPHA_EXT, GL_SRC_ALPHA );
  }
*/
  // Enable blending
  glEnable( GL_BLEND );

  // Render surface
  vector<_S_WaterQuad>::const_iterator it = water.begin();
  glBegin( GL_QUADS );
  while ( it != water.end() ) {
    drawWaterQuad( (*it).x, (*it).y, (*it).xp, (*it).yp );
    it++;
  }
  glEnd();

  // Reset old GL State
  glDisable( GL_BLEND );
  glDisable( GL_TEXTURE_CUBE_MAP );
}

---