spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

Quellcode

Die Eckpunkte des Quadrates sind A,B,C,D. Von denen ist jeweils die x,y und z position bekannt.
Kamera y
Kamera z 
Kamera x
sind bekannt.

L ist die Kantenlänge:

L = A.x - B.x + A.y - B.y + A.z - B.z  (??)

 interpolationsfaktor in x und y richtung:
a ist die distanz zwischen dem linkenrand und der x position der Kamra!
b ist die distanz zwischen dem oberenrand und der y position der Kamera! (Müsste das nicht z sein?)

fx = a / L; 
fy = b / L; 

jetzt interpolierst du dir 2 Höhenwerte h1 und h2 z.B. in x richtung: 

hv1 ist die höhe (also y?) von dem ersten vertex.
hv2 vom zweiten.
hv3 vom dritten.
hv4 vom vierten.

h1 = hv1 * fx + hv2 * (1 - fx) 
h2 = hv3 * fx + hv4 * (1 - fx) 

Jetzt die höhe der Kamera (h):

h = h1 * fy + h2 * (1 - fy)

C-/C++-Quelltext

L = A.x - B.x;
            a = Cam.mPos.x-A.x;
            b = Cam.mPos.y-A.y;
            fx = a / L; 
            fy = b / L; 
            h1 = A.y * fx + B.y * (1 - fx); 
            h2 = C.y * fx + D.y * (1 - fx);
            hoehe = h1 * fy + h2 * (1 - fy);

C-/C++-Quelltext

#define     MAP_SIZE    1024                // Size Of Our .RAW Height Map ( NEW )

#define     STEP_SIZE   16              // Width And Height Of Each Quad ( NEW )

#define     HEIGHT_RATIO    1.5f                // Ratio That The Y Is Scaled According To The X And Z ( NEW )


                // Holds The Height Map Data ( NEW )


float scaleValue = 0.15f;                   // Scale Value For The Terrain ( NEW )

UINT Gras[1];

typedef struct tVector{
 
GLfloat x;
GLfloat y;
GLfloat z;
        
};

GLfloat hoehe[(MAP_SIZE-STEP_SIZE)*(MAP_SIZE-STEP_SIZE)];


void init_Landschaft(BYTE pHeightMap[]){

LoadRawFile("Terrain.raw", MAP_SIZE * MAP_SIZE, pHeightMap);    // ( NEW )

 BMP_Texture(Gras, "grass.bmp",0);     
}



int Height(BYTE *pHeightMap, int X, int Y)          // This Returns The Height From A Height Map Index

{
    int x = X % MAP_SIZE;                   // Error Check Our x Value

    int y = Y % MAP_SIZE;                   // Error Check Our y Value


    if(!pHeightMap) return 0;               // Make Sure Our Data Is Valid


return pHeightMap[x + (y * MAP_SIZE)];          // Index Into Our Height Array And Return The Height

}



void draw_Landschaft(BYTE pHeightMap[]){

int X = 0, Y = 0;                   // Create Some Variables To Walk The Array With.

int x, y, z=0, i=0;                     // Create Some Variables For Readability


glBindTexture(GL_TEXTURE_2D, Gras[0]);              
glBegin( GL_QUADS );            

for ( X = 0; X < (MAP_SIZE-STEP_SIZE); X += STEP_SIZE )
        for ( Y = 0; Y < (MAP_SIZE-STEP_SIZE); Y += STEP_SIZE )
        {
            tVector A;
            tVector B;
            tVector C;
            tVector D;
            GLfloat L;
            GLfloat a, b;
            GLfloat fx, fy;
            GLfloat h1, h2;
       
            glTexCoord2f(0.0f, 1);
            x = X;                          
            y = Height(pHeightMap, X, Y );  
            z = Y;
                        
            A.x=x;
            A.y=y;
            A.z=z;
            
            
            glVertex3i(x, y, z);        

            glTexCoord2f(0.0f, 0.0f);
            x = X;                                      
            y = Height(pHeightMap, X, Y + STEP_SIZE );  
            z = Y + STEP_SIZE ; 
                                    
            B.x=x;
            B.y=y;
            B.z=z;
            
            glVertex3i(x, y, z);        

            glTexCoord2f(1, 0.0f);
            x = X + STEP_SIZE; 
            y = Height(pHeightMap, X + STEP_SIZE, Y + STEP_SIZE ); 
            z = Y + STEP_SIZE ;
            
            C.x=x;
            C.y=y;
            C.z=z;

                
            glVertex3i(x, y, z);        

           glTexCoord2f(1, 1);
            x = X + STEP_SIZE; 
            y = Height(pHeightMap, X + STEP_SIZE, Y ); 
            z = Y;
            
            C.x=x;
            C.y=y;
            C.z=z;
            
            glVertex3i(x, y, z);    
            
            L = A.x - B.x;
            a = Cam.mPos.x-A.x;
            b = Cam.mPos.z-A.z;
            fx = a / L; 
            fy = b / L; 
            h1 = A.y * fx + B.y * (1 - fx); 
            h2 = C.y * fx + D.y * (1 - fx);
            hoehe[i] = h1 * fy + h2 * (1 - fy);
            
            i++;
        }
    glEnd();


     
}