class Terrain{
  float[][] heightMap;
  float[][][] normals;
  color[][] vertexColor;
  float xStep,yStep;
  int h, w, res, zScale;
  color[] spectrum;
  boolean gouraud = false;
  boolean textureBlend = true;
  boolean wireframe = false;
  boolean dynamicTexture = false;
  //------------
  Terrain(int res){
    this(width,height,res,200);
    buildVertexColors();
  }
  //------------
  Terrain(Terrain t){
    this(t.w,t.h,t.res,t.zScale);
  }
  //------------
  Terrain( int w, int h, int res, int zScale){
    vertexColor = new color[res][res];
    for(int x=0;x<res;x++)
      for(int y=0;y<res;y++)
        vertexColor[x][y] = color(0,255,0);
    PImage img = loadImage("hill.png");
    spectrum = new color[img.width];
    for( int i=0; i<img.width; i++)
      spectrum[i] = img.get(i,0);

    this.w = w;
    this.h = h;
    this.zScale = zScale;
    xStep = w/(float)res;
    yStep = h/(float)res;
    this.res = res;
    heightMap = new float[res][res];

    float xOff = random(500);
    float yOff = random(500);

    for(int x=0;x<res;x++)
      for(int y=0;y<res;y++)
        heightMap[x][y] = zScale*noise(5*x/(float)res+xOff,5*y/(float)res+yOff,0);
    //heightMap[x][y] = sin(x*PI/res)*sin(y*PI/res)*zScale*noise(5*x/(float)res+xOff,5*y/(float)res+yOff,0);

    normals = new float[res][res][3];
    makeNormals();
  }
  //------------
  void makeNormals(){
    // boundaries
    for(int i=0; i<res; i++){
      normals[i][0][2] = 1;
      normals[i][res-1][2] = 1;
      normals[0][i][2] = 1;
      normals[res-1][i][2] = 1;
    }
    
    for(int x=1; x<res-1; x++)
      for(int y=1; y<res-1; y++){
        float dx = heightMap[x+1][y] - heightMap[x-1][y];
        float dy = heightMap[x][y+1] - heightMap[x][y-1];
        float d = mag(dx,dy,xStep);
        normals[x][y][0] = -dx/d;
        normals[x][y][1] = -dy/d;
        normals[x][y][2] = xStep/d;
      }
  }
  //------------
  float getHeight(int x, int y){
    return heightMap[x][y];
  }
  //------------
  void buildVertexColors(){
    for(int x=1;x<res;x++){
      for(int y=1;y<res;y++){
        int index = (int)( (spectrum.length-1)*heightMap[x][y]/zScale );
        vertexColor[x][y] = spectrum[index];
      }
    }
  }
  //------------
  void visualize(){
    // fix edge cells
    for(int i=0; i<res; i++){
      heightMap[i][0] = heightMap[i][1];
      heightMap[i][res-1] = heightMap[i][res-2];
      heightMap[0][i] = heightMap[1][i];
      heightMap[res-1][i] = heightMap[res-2][i];
    }
    
    if(dynamicTexture) buildVertexColors();
    pushMatrix();
    translate(-w/2,-h/2);
    if(wireframe) stroke(255,64);
    else noStroke();
    for(int x=1;x<res;x++){
      for(int y=1;y<res;y++){
        beginShape(POLYGON);
        fill( vertexColor[x][y] );
        if(gouraud) normal( normals[x][y][0], normals[x][y][1], normals[x][y][2] );
        vertex( x*xStep, y*yStep, getHeight(x,y) );
        if(textureBlend) fill( vertexColor[x-1][y] );
        if(gouraud) normal( normals[x-1][y][0], normals[x-1][y][1], normals[x-1][y][2] );
        vertex( (x-1)*xStep, y*yStep, getHeight(x-1,y) );
        if(textureBlend) fill( vertexColor[x-1][y-1] );
        if(gouraud) normal( normals[x-1][y-1][0], normals[x-1][y-1][1], normals[x-1][y-1][2] );
        vertex( (x-1)*xStep, (y-1)*yStep, getHeight(x-1,y-1) );
        if(textureBlend) fill( vertexColor[x][y-1] );
        if(gouraud) normal( normals[x][y-1][0], normals[x][y-1][1], normals[x][y-1][2] );
        vertex( x*xStep, (y-1)*yStep, getHeight(x,y-1) );
        endShape();
      }
    }
    popMatrix();
  }
}