Changeset 3390 in orxonox.OLD for orxonox/branches/nico/src/importer/heightMapTerrain.cc

Timestamp:

Feb 2, 2005, 1:04:00 PM (21 years ago)

Author:

bensch

Message:

orxonox/branches/nico: heightmap now compiles on all platforms

File:

• orxonox/branches/nico/src/importer/heightMapTerrain.cc (modified) (3 diffs)

orxonox/branches/nico/src/importer/heightMapTerrain.cc

@@ -27 +27 @@
         if (bitmap == NULL) return false;
         
-        cout << "bitmap-dimensions: " << bitmap->w << "x" << bitmap->h << endl;
-        
+        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;
@@ -48 +51 @@
                 return false;
         }
+        
+        cout << displayListCount << " display lists generated. starting at: " << displayListStart << endl;
+
 
         int i,j;
@@ -69 +75 @@
 bool HeightMapTerrain::readIntoList(int left, int top, int width, int height, int levelOfDetail, GLuint displayListNr)
 {
-        // y is the height value in OpenGL convention
-        GLuint x,y,z;
-        GLfloat col;
-        
         cout << "creating list Nr " << displayListNr << endl;
         cout << "left, top, width, height: " << left << ", " << top << ", " << width << ", " << height << endl; 
         
-        glNewList(displayListNr,GL_COMPILE);
-        {
-                for (z=top; z<top+height; z++)
+        // 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++)
                 {
-                        glBegin(GL_QUAD_STRIP);
+                        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
                         {
-                                for (x=left; x<left+width; x++)
+                                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++)
                                 {
-                                        y = heightValue(x,z+1);
-                                        col = y / 256.0;
-                                        glColor3f(1.0,0.0,0.0);
-                                        glVertex3i(x,y,z+1);
-                                        
-                                        y = heightValue(x,z);
-                                        col = y / 256.0;
-                                        glColor3f(1.0,0.0,0.0);
-                                        glVertex3i(x,y,z);
+                                        // 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();
                 }
-                
+                glEnd();
+
         }
         glEndList();
+
+        
+        delete[] normals;
         
         return true;
 }
 
-GLint HeightMapTerrain::heightValue(Uint8 x, Uint8 z)
-{
-        return 100;
+
+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 (bitmap == NULL) return 0;
+        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 = NULL;
-        
+        SDL_Color color;
         
         SDL_LockSurface(bitmap);
-        
-        index = *((Uint8*)bitmap->pixels[z * bitmap->h + x]);
-        color = &bitmap->format->palette->colors[index];
-        
+
+        index = *((Uint8*)bitmap->pixels + Z * bitmap->pitch + X * bitmap->format->BytesPerPixel);
+        color = bitmap->format->palette->colors[index];
+
         SDL_UnlockSurface(bitmap);
-
-        return color->r;
-         */
-}
+        
+        // return the red component, because in a grayscale pic, r,g and b are all the same value
+        return (GLint)color.r;
+}