source: orxonox.OLD/orxonox/branches/nico/src/importer/heightMapTerrain.cc @ 3542

/*
 *  ldrawparser.cpp
 *  legotown3d
 *
 *  Created by Nico Bernold on 08.01.05.
 *  Copyright 2005 __MyCompanyName__. All rights reserved.
 *
 */

#include "heightMapTerrain.h"
#include "vector.h"
#ifdef HAVE_SDL_SDL_IMAGE_H
#include <SDL/SDL_image.h>
#endif /* HAVE_SDL_SDL_IMAGE_H */

HeightMapTerrain::HeightMapTerrain()
{       
}

HeightMapTerrain::~HeightMapTerrain()
{
}

bool HeightMapTerrain::loadBitmap(char* fileName)
{
#ifdef HAVE_SDL_SDL_IMAGE_H
  cout << "Using SDL-image for reading in the File " << fileName <<endl;
  return this->bitmap = IMG_Load(fileName);
#else
  return this->bitmap = SDL_LoadBMP(fileName);  
#endif /* HAVE_SDL_SDL_IMAGE_H */
}

bool HeightMapTerrain::createDisplayLists(int width, int height, int levelOfDetail)
{
        if (bitmap == NULL) return false;
        
        cout << "bitmap-dimensions:             " << bitmap->w << " x " << bitmap->h << endl;
        cout << "bitmap-pitch:                  " << bitmap->pitch << endl;
        cout << "bitmap->format->BytesPerPixel: " << (int)bitmap->format->BytesPerPixel << endl;
        cout << "bitmap->format->BitsPerPixel:  " << (int)bitmap->format->BitsPerPixel << endl;
         
        if (bitmap->w % width != 0) return false;
        if (bitmap->h % height != 0) return false;
        
        if (levelOfDetail < 1 || levelOfDetail > 10) return false;
        
        int howManyListsWide = bitmap->w / width;
        int howManyListsHigh = bitmap->h / height;
        
        // calculate how many displayLists we'll create
        displayListCount = howManyListsWide * howManyListsHigh; 

        cout << "lists-information: " << howManyListsWide << " * " << howManyListsHigh << " = " << displayListCount << " display lists." << endl;
        
        displayListStart = glGenLists(displayListCount);
        if (displayListStart == 0)
        {
                cout << "could not generate " << displayListCount << " display lists. exiting. " << endl;
                return false;
        }
        
        cout << displayListCount << " display lists generated. starting at: " << displayListStart << endl;


        int i,j;
        
        for (i=0; i<howManyListsHigh; i++)
        {
                for (j=0; j<howManyListsWide; j++)
                {
                        if (readIntoList(j*width,i*height,width,height,levelOfDetail,i*howManyListsHigh + j) == false)
                        {
                                cout << "error while generating display lists. exiting. " << endl;
                                return false;
                        }

                }
        }
        
        return true;
}

bool HeightMapTerrain::readIntoList(int left, int top, int width, int height, int levelOfDetail, GLuint displayListNr)
{
        cout << "creating list Nr " << displayListNr << endl;
        cout << "left, top, width, height: " << left << ", " << top << ", " << width << ", " << height << endl; 
        
        // y is the height value in OpenGL convention
        int x,y,z;
        GLfloat col;

        // used for normal calculations
        Vector O; // origin: the vertex where i'm standing
        Vector N,E,S,W,NE,SE,SW,NW; // vectors pointing to north, east, ...

        bool eightTriangles = false;
        
        
        // contains a normal vector for every vertex
        normals = new Vector[width*height];

        // precalculate all vertex normals for later use in display list generation
        // many superflous calculations i know...
        for (z=top; z<top+height; z++)
        {
                for (x=left; x<left+width; x++)
                {
                        O = Vector(x,getHeightValue(x,z),z);

                        N = Vector(x,getHeightValue(x,z-1),z-1) - O;
                        E = Vector(x+1,getHeightValue(x+1,z),z) - O;
                        S = Vector(x,getHeightValue(x,z+1),z+1) - O;
                        W = Vector(x-1,getHeightValue(x-1,z),z) - O;

                        if (eightTriangles == false)
                                // calculate the average normal vector by adding up all 4 adjacent triangle normal vectors
                                normals[(z-top) * height + (x-left)] = N.cross(W) + W.cross(S) + S.cross(E);

                        else
                        {
                                NE = Vector(x+1,getHeightValue(x+1,z-1),z-1) - O;
                                SE = Vector(x+1,getHeightValue(x+1,z+1),z+1) - O;
                                SW = Vector(x-1,getHeightValue(x-1,z+1),z+1) - O;
                                NW = Vector(x-1,getHeightValue(x-1,z-1),z-1) - O;
                                // calculate the average normal vector by adding up all 8 adjacent triangle normal vectors
                                normals[(z-top) * height + (x-left)] = N.cross(NW) + NW.cross(W) + W.cross(SW) + SW.cross(S) + S.cross(SE) + SE.cross(E) + E.cross(NE) + NE.cross(N);
                        }

                        // every second vertex is the edge of eightTriangles (the others have only four triangles)
                        eightTriangles = !eightTriangles;
                }
        }
        
        cout << "normals precalculated for list " << displayListNr << endl;
        
        glNewList(displayListStart + displayListNr,GL_COMPILE);
        {
                glBegin(GL_TRIANGLES);
                {
                        // don't go through last col and row, because they are already done by second last col&row
                        for (z = top; z < (top + height) - 1; z++)
                        {
                                for (x = left; x < (left + width) - 1; x++)
                                {
                                        // draw 2 triangles per (x,z) pair
                                        
                                        if (eightTriangles)
                                        {
                                                call_glNormal_and_glVertex(x,z,top,left,height);
                                                call_glNormal_and_glVertex(x,z+1,top,left,height);
                                                call_glNormal_and_glVertex(x+1,z,top,left,height);
                                        
                                                call_glNormal_and_glVertex(x+1,z,top,left,height);
                                                call_glNormal_and_glVertex(x,z+1,top,left,height);
                                                call_glNormal_and_glVertex(x+1,z+1,top,left,height);
                                        }
                                        
                                        else
                                        {
                                                call_glNormal_and_glVertex(x,z,top,left,height);
                                                call_glNormal_and_glVertex(x,z+1,top,left,height);
                                                call_glNormal_and_glVertex(x+1,z+1,top,left,height);
                                                
                                                call_glNormal_and_glVertex(x+1,z,top,left,height);
                                                call_glNormal_and_glVertex(x,z,top,left,height);
                                                call_glNormal_and_glVertex(x+1,z+1,top,left,height);
                                        }
                                        
                                        
                                        // use the same trick to change the triangles everytime. once |/| and once |\|
                                        eightTriangles = !eightTriangles;

                                }
                        }
                }
                glEnd();

        }
        glEndList();

        
        delete[] normals;
        
        return true;
}


void HeightMapTerrain::call_glNormal_and_glVertex(int x,int z,int top,int left,int height)
{
/*
        GLfloat color[4];           // color parameter for glMaterial
        
        int heightVal = getHeightValue(x,z);

        color[0] = 1.0 / 256.0 * heightVal;
        color[1] = 1.0 / 256.0 * heightVal;
        color[2] = 1.0 / 256.0 * heightVal;
        color[3] = 1;  // alpha channel (1 = solid)

        glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, color);
*/
        glNormal3f(normals[(z-top) * height + (x-left)].x,normals[(z-top) * height + (x-left)].y,normals[(z-top) * height + (x-left)].z);
        glVertex3i(x,getHeightValue(x,z),z);
}


GLint HeightMapTerrain::getHeightValue(int x, int z)
{
        if (bitmap == NULL) return 0;

        // catch out of image access
        int X = x % bitmap->w;
        int Z = z % bitmap->h;
        
        /*
        if (X != x) cout << "x lies outside of image (" << x << "," << z << ")" << endl;
        if (Z != z) cout << "z lies outside of image (" << x << "," << z << ")" << endl;
        */
        
        // if x or z exeed the image size, return 0 as height value
        if (X != x || Z != z) return 0;
        
        
        Uint8 index;
        SDL_Color color;
        
        SDL_LockSurface(bitmap);

        index = *((Uint8*)bitmap->pixels + Z * bitmap->pitch + X * bitmap->format->BytesPerPixel);
        color = bitmap->format->palette->colors[index];

        SDL_UnlockSurface(bitmap);
        
        // return the red component, because in a grayscale pic, r,g and b are all the same value
        return (GLint)color.r;
}