heightfield.cpp

Go to the documentation of this file.

#include <assert.h>
#include <string.h>
#include <stdio.h>
#include <math.h>
#include <algorithm>
#include <map>
#include <vector>

#include "config.h"
#include "heightfield.h"
#include "texture.h"
#include "water.h"


using namespace std;

// Texture coord array (from config.cpp)
extern float g_texcoord[];
// Normalization constant for light vector
float g_fLightVectorNorm = 1.0f;

// Data for a single height field vertex
struct _S_VertexData
{
  // Position
  float x,y,z;
  // Normal
  float nx, ny, nz;
  // Texture coord
  float tx,ty;
  // Texture ID
  TEXTURE nTex;
  // Shadow coordinates
  float sx, sy;
  // Flag if inside shadow map
  bool bShadow;
  // Flag if below water level
  bool bWater;
};



// Height field data
static float *g_hf = NULL;
static _S_VertexData *g_hfData = NULL;
static int g_W = 0;
static int g_H = 0;



float gethf( int x, int y ) {
  // Not exactly as in the previous assignment, but looks 
  // better than modulo.
     x = abs(x); y=abs(y);
//    while (x<0) x += g_hfW;
//    while (y<0) y += g_hfH;
    
  // Tile HF over full plane
  return g_hf[ (x%g_W) + (y%g_H)*g_W ];
}


inline _S_VertexData gethfData( int x, int y ) {
  // Not exactly as in the previous assignment, but looks 
  // better than modulo.
  x = abs(x); y=abs(y);
  // Tile HF over full plane
  return g_hfData[ (x%g_W) + (y%g_H)*g_W ];
}


inline float diffuseLighting( const float &nx, const float &ny, const float &nz )
{
  if (g_bLighting) {
    float l = nx * g_lightPos[0] + ny * g_lightPos[1] + nz * g_lightPos[2];
    l = 0.5 - 0.5*l*g_fLightVectorNorm;
    return colorDarkGrey[0] + l * (colorWhite[0] - colorDarkGrey[0]);
  }
  return 1.0f;
}



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;
}
 

// Get average height of a cell
float averageHeight( int x, int y )
{
  float v = gethf( x,y ) + gethf( x+1, y ) + gethf( x,y+1 ) + gethf( x+1,y+1 );
  return v/4.0f;
}

// Get correct texture for a certain height
TEXTURE hftexture( float h )
{
  h /= g_fHeightScale;
  if (h > 0.8) return TEX_SNOW;
  if (h > 0.5) return TEX_ROCK;
  if (h > 0.2) return TEX_GRASS;
  return TEX_SAND;
}



void initHeightField( int W, int H, const char *filename )
{
  // Validate params
  assert( W>0 && W*H > 0 );
  // Clear old data
  if (g_hf != NULL) {
    delete[] g_hf;
  }
  if (g_hfData != NULL) {
    delete[] g_hfData;
  }

  // Init new data
  g_W = W;
  g_H = H;
  g_hf = new float[W*H];
  g_hfData = new _S_VertexData[W*H];

  // Read data from file
  if (filename != NULL) {
    int L = strlen( filename ) + strlen( g_strResourceDir );
    char fn[L+1];
    strcpy( fn, g_strResourceDir );
    strcat( fn, filename );

    FILE *file = fopen( fn, "rb" );
    assert( file != NULL );
    int n;
    if ( (n=fread( g_hf, sizeof(float), W*H, file )) != W*H) {
      printf( "Error loading height field, only %i floats read.", n ); 
    }
    else {
      printf( "read %i floats ... ", n );
    }
  }

  // Init texture coords
  for ( int i=0; i<=g_tpt; i++) {
    g_texcoord[i] = float(i) / float(g_tpt);
  }
  for ( int i=0; i<g_tpt; i++) {
    g_texcoord[i + g_tpt] = 1.0f - float(i) / float(g_tpt);
  }

  // Init height field
  for (int x=0; x<g_W; x++) {
    for (int y=0; y<g_H; y++) {
      g_hf[ x+y*g_W ] *= g_fHeightScale;
    }
  }

  // Init per vertex height field data
  for (int x=0; x<g_W; x++) {
    for (int y=0; y<g_H; y++) {

        _S_VertexData &V = g_hfData[ x+y*g_W ];
        V.x = x * g_cellsize;
        V.y = gethf( x,y );
        V.z = y * g_cellsize;
        computeNormal( x,y, V.nx, V.ny, V.nz );
        V.tx = g_texcoord[ abs(x) % (2*g_tpt) ];
        V.ty = g_texcoord[ abs(y) % (2*g_tpt) ];
        V.nTex = hftexture( V.y );

    }
  }
}






// Helper structure : Data for a single texture quad in multipass rendering
struct _S_TexData {
    _S_TexData() {
        _bv1 = _bv2 = _bv3 = _bv4 = 0;
    };
    // Flags are set if the vertex has this texture as primary texture
    int _bv1, _bv2, _bv3, _bv4;
};


// Compute average vertex data
_S_VertexData averageVertex( const _S_VertexData &v1, const _S_VertexData &v2,
                    const _S_VertexData &v3, const _S_VertexData &v4 )
{
    _S_VertexData V(v1);
    V.x += v2.x; V.x += v3.x; V.x += v4.x;
    V.y += v2.y; V.y += v3.y; V.y += v4.y;
    V.z += v2.z; V.z += v3.z; V.z += v4.z;

    V.nx += v2.nx; V.nx += v3.nx; V.nx += v4.nx;
    V.ny += v2.ny; V.ny += v3.ny; V.ny += v4.ny;
    V.nz += v2.nz; V.nz += v3.nz; V.nz += v4.nz;

    V.tx += v2.tx; V.tx += v3.tx; V.tx += v4.tx;
    V.ty += v2.ty; V.ty += v3.ty; V.ty += v4.ty;

    V.x /= 4.0f; V.y /= 4.0f; V.z /= 4.0f;
    V.nx /= 4.0f; V.ny /= 4.0f; V.nz /= 4.0f;
    V.tx /= 4.0f; V.ty /= 4.0f;

    return V;
}



// Stream a single vertex (texcoord, normal, pos) to the GL
inline void streamVertex( const _S_VertexData &V, float alpha = 1.0f )
{
    float l = diffuseLighting( V.nx, V.ny, V.nz );
    glColor4f( l,l,l, alpha );

  glTexCoord2fv( &V.tx );
  glNormal3fv( &V.nx );
  glVertex3fv( &V.x );
}


// Draw a quad with multiple textures (via multipass rendering)
void drawMultipassQuad( const _S_VertexData &v1, const _S_VertexData &v2,
                        const _S_VertexData &v3, const _S_VertexData &v4 )
{
    // Init textures which are used for the quad
    // This function is not called too frequently, so it is
    // not heavily optimized. The map yields very
    // elegant code, but it's a bit slow.
    map<TEXTURE, _S_TexData> textures;
    textures[v1.nTex]._bv1 = 1;
    textures[v2.nTex]._bv2 = 1;
    textures[v3.nTex]._bv3 = 1;
    textures[v4.nTex]._bv4 = 1;

    // Draw all textures used by vertices in the quad
    // Should be more than 1
    if ( textures.size() <= 1 ) {
        printf( "Wrong number of textures: %u\n", textures.size() );
        assert( false );
    }

    map<TEXTURE, _S_TexData>::const_iterator it = textures.begin();
    while( it != textures.end() ) {
        glBindTexture( GL_TEXTURE_2D, texture((*it).first) );

        if (g_bSmoothing) {
          // Draw some extra geometry to improve the
          // boundaries between the blended textures
          // You can see it directly when you turn polygon fill off
          _S_VertexData V = averageVertex( v1,v2,v3,v4 );
          float c = (*it).second._bv1 + (*it).second._bv2 +
            (*it).second._bv3 + (*it).second._bv4;
          if (c<=1.0f) c=0.0f;
          else if (c==2.0f) c=0.5f;
          else c=1.0f;

          glBegin( GL_TRIANGLE_FAN );
          streamVertex( V, c );
          streamVertex( v1, (*it).second._bv1 );
          streamVertex( v2, (*it).second._bv2 );
          streamVertex( v3, (*it).second._bv3 );
          streamVertex( v4, (*it).second._bv4 );
          streamVertex( v1, (*it).second._bv1 );
          glEnd();
        }
        else {
          // Standard quad version
          glBegin( GL_QUADS );
          streamVertex( v1, (*it).second._bv1 );
          streamVertex( v2, (*it).second._bv2 );
          streamVertex( v3, (*it).second._bv3 );
          streamVertex( v4, (*it).second._bv4 );
          glEnd();
        }

        // Blend from the second texture on
        glEnable( GL_BLEND );
        it++;
    }
    glDisable( GL_BLEND );
}





// Get vertex data for a certain (x,y) position of the plane
inline void gethfVertexData( float x, float y, int xc, int yc, _S_VertexData &V )
{
  V = gethfData( xc,yc );
  V.x = (xc-x)*g_cellsize;
  V.z = (yc-y)*g_cellsize;
  
  V.bWater = (gethf(xc,yc) < g_waterlevel * g_fHeightScale);
}



void initGLState()
{
  // Compute light vector normalization
  float L = g_lightPos[0]*g_lightPos[0];
  L += g_lightPos[1]*g_lightPos[1];
  L += g_lightPos[2]*g_lightPos[2];
  g_fLightVectorNorm = 1.0f / sqrt(L);
  // Use texture?
//  if (g_bTexturing) {
    glEnable( GL_TEXTURE_2D );
//  }
  // Own lighting computation
  glDisable( GL_LIGHTING );
  // Setup blending function
  glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );

    // MULTI-PASS RENDERING

    // 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 );
    glTexEnvi( GL_TEXTURE_ENV, GL_SOURCE1_ALPHA_EXT, GL_TEXTURE );
    glTexEnvi( GL_TEXTURE_ENV, GL_OPERAND1_ALPHA_EXT, GL_SRC_ALPHA );
    // Allow triangle overdrawing
    glDepthFunc( GL_LEQUAL );
}




void drawHeightField( float x, float y, int w, int h )
{
  // List of the water quads (rendered after field)
  vector<_S_WaterQuad> water;

  initGLState();
  int xi = int(x);
  int yi = int(y);   
  for (int xc=xi-w; xc <= xi+w; xc++ ) {
    TEXTURE nCurrentTexture = TEX_N;
    _S_VertexData v1, v2;
    gethfVertexData( x,y, xc+1, yi-h, v1 );
    gethfVertexData( x,y, xc,   yi-h, v2 );
    for ( int yc=yi-h; yc <= yi+h; yc++ ) {
      _S_VertexData v3, v4;
      gethfVertexData( x,y, xc,   yc+1, v3 );
      gethfVertexData( x,y, xc+1, yc+1, v4 );
      
      // Get correct textures for all four vertices of the next quad
      TEXTURE t1 = v1.nTex;
      TEXTURE t2 = v2.nTex;
      TEXTURE t3 = v3.nTex;
      TEXTURE t4 = v4.nTex;
      // Check if all are equal
      bool bAllEqual = false;
      if (t1==t2 && t2==t3 && t3==t4) {
        bAllEqual = true;
      }
      // Check if shadow quad
      bool bShadow = false;
      if (v1.bShadow || v2.bShadow || v3.bShadow || v4.bShadow) {
        bShadow = true;
      }

      bool bWater = false;
      if (v1.bWater || v2.bWater || v3.bWater || v4.bWater) {
        bWater = true;
      }
      
      if (bAllEqual && t1==nCurrentTexture && !bShadow && !bWater) {
        // Continue current triangle strip
        assert( t1 != TEX_N );
        streamVertex( v1 );
        streamVertex( v2 );
      }
      else {
        // The current texture changes. Stop the triangle strip,
        // if one is currently active.
        if ( nCurrentTexture != TEX_N ) {
          streamVertex( v1 );
          streamVertex( v2 );
          nCurrentTexture = TEX_N;
          glEnd();
        }

        if (bAllEqual && !bShadow && !bWater) {
          // Only one pass is required. Start a new active
          // triangle strip.
          glBindTexture( GL_TEXTURE_2D, texture(t1) );
          glBegin( GL_TRIANGLE_STRIP );
          nCurrentTexture = t1;
          streamVertex( v1 );
          streamVertex( v2 );
        }
        else {
          if ( g_bBlending && !bAllEqual ) {
            // Draw the current quad using multiple passes.
            // Get coordinates for next vertices in the strip
              drawMultipassQuad( v1,v2,v3,v4 );
          }
          else {
            // Just use the texture for the average height
            TEXTURE tex = hftexture( averageHeight( xc,yc ));
            glBindTexture( GL_TEXTURE_2D, texture(tex) );
            glBegin( GL_QUADS );
            streamVertex( v1 );
            streamVertex( v2 );
            streamVertex( v3 );
            streamVertex( v4 );
            glEnd();
          }

          if (bWater) {
            _S_WaterQuad W;
            W.x = xc; W.y = yc;
            W.xp = v2.x; W.yp = v2.z;
            water.push_back( W );
          }
        }
      }
      v1 = v4; v2 = v3;
    }
    
    glEnd();
  }
  glDisable( GL_TEXTURE_2D );

  drawWaterQuads( water );
  glEnable( GL_LIGHTING );
}

---