Height mapping questions

void LoadHeightMap(char *file){
	AUX_RGBImageRec *TextureImage[1];					// Create Storage Space For The Texture


	memset(TextureImage,0,sizeof(void *)*1);				// Set The Pointer To NULL


	// Load The Bitmap, Check For Errors, If Bitmap's Not Found Quit

	if (TextureImage[0]=LoadBMP(file))
	{
		for(unsigned int y=0;y<HEIGHTMAP_Y;y++){
			for(unsigned int x=0;x<HEIGHTMAP_X;x++){
				heightmap[x][y]=TextureImage[0]->data[(y*HEIGHTMAP_X+x)*3];
				g_islava[x][y]=false;
			};
		};
	}

	if (TextureImage[0])							// If Texture Exists

	{
		if (TextureImage[0]->data)					// If Texture Image Exists

		{
			free(TextureImage[0]->data);				// Free The Texture Image Memory

		}

		free(TextureImage[0]);						// Free The Image Structure

	}

}

#include "GLModel.h"
#include <stdio.h>

#define MAP_SIZE		1024				// PREDEFINED MAP SIZE

#define STEP_SIZE		16					// ACCURACY OF OUR HEIGHT MAP

#define HEIGHT_RATIO	1.5f				// AMOUNT Y IS SCALED IN REALTION TO X AND Z




class GLTerrain : public GLModel
{

	
private:

	UINT HeightMapTexture[1];								// This holds the texture info by an ID	


	BYTE g_HeightMap[MAP_SIZE*MAP_SIZE];					// This holds the height map data


	// This returns the height (0 to 255) from a heightmap given an X and Y

	int Height(BYTE *pHeightMap, int X, int Y);

	// This turns heightmap data into primitives and draws them to the screen

	void DrawHeightMap(BYTE *pHeightMap);

	// This loads a .raw file of a certain size from the file

	void LoadRawFile(LPSTR strName, int nSize, BYTE *pHeightMap);

	void SetTextureCoord(float x, float z);

public:
	
	// DEFAULT CONSTRUCTOR

	GLTerrain();

	// RENDER FUNCTION

	void Render();

};



And this is the .cpp file...

   
#include "GLTerrain.h"
#include "GLModel.h"



int GLTerrain::Height(BYTE *pHeightMap, int X, int Y)
{
	// Make sure we don't go past our array size

	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


	// Use the equation: index = (x + (y * arrayWidth) ) to find the current height

	return pHeightMap[x + (y * MAP_SIZE)];	// Index into our height array and return the height

}





/////////////////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////////////////







void GLTerrain::SetTextureCoord(float x, float z)
{
	// Give OpenGL the current texture coordinate for our height map

	glTexCoord2f(   (float)x / (float)MAP_SIZE,	
				  - (float)z / (float)MAP_SIZE	);
}






/////////////////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////////////////







void GLTerrain::DrawHeightMap(BYTE pHeightMap[])
{
	int X = 0, Y = 0;						// Create some variables to walk the array with.

	int x, y, z;							// Create some variables for readability

	bool bSwitchSides = false;

	// Make sure our height data is valid

	if(!pHeightMap) return;		
	
	// Bind the terrain texture to our terrain

	glBindTexture( GL_TEXTURE_2D, HeightMapTexture[0] );

	// We want to render triangle strips

	glBegin( GL_TRIANGLE_STRIP );			

	// Go through all of the rows of the height map

	for ( X = 0; X <= MAP_SIZE; X += STEP_SIZE )
	{
		// Chechk if we need to render the opposite way for this column

		if(bSwitchSides)
		{	
			// Render a column of the terrain, for this current X.

			// We start at MAP_SIZE and render down to 0.

			for ( Y = MAP_SIZE; Y >= 0; Y -= STEP_SIZE )
			{
				// Get the (X, Y, Z) value for the bottom left vertex		

				x = X;							
				y = Height(pHeightMap, X, Y );	
				z = Y;							

				// Set the current texture coordinate and render the vertex

				SetTextureCoord( (float)x, (float)z );
				glVertex3i(x, y, z);		

				// Get the (X, Y, Z) value for the bottom right vertex		

				x = X + STEP_SIZE; 
				y = Height(pHeightMap, X + STEP_SIZE, Y ); 
				z = Y;

				// Set the current texture coordinate and render the vertex

				SetTextureCoord( (float)x, (float)z );
				glVertex3i(x, y, z);			
			}
		}
		else
		{	
			// Render a column of the terrain, for this current X.

			// We start at 0 and render down up to MAP_SIZE.

			for ( Y = 0; Y <= MAP_SIZE; Y += STEP_SIZE )
			{
				// Get the (X, Y, Z) value for the bottom right vertex		

				x = X + STEP_SIZE; 
				y = Height(pHeightMap, X + STEP_SIZE, Y ); 
				z = Y;

				// Set the current texture coordinate and render the vertex

				SetTextureCoord( (float)x, (float)z );
				glVertex3i(x, y, z);

				// Get the (X, Y, Z) value for the bottom left vertex		

				x = X;							
				y = Height(pHeightMap, X, Y );	
				z = Y;							

				// Set the current texture coordinate and render the vertex

				SetTextureCoord( (float)x, (float)z );
				glVertex3i(x, y, z);		
			}
		}

		// Switch the direction the column renders to allow the fluid tri strips

		bSwitchSides = !bSwitchSides;
	}

	// Stop rendering triangle strips

	glEnd();
}





/////////////////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////////////////







void GLTerrain::LoadRawFile(LPSTR strName, int nSize, BYTE *pHeightMap)
{
	FILE *pFile = NULL;

	// Let's open the file in Read/Binary mode.

	pFile = fopen( strName, "rb" );

	// Check to see if we found the file and could open it

	if ( pFile == NULL )	
	{
		// Display our error message and stop the function

		MessageBox(NULL, "Can't find the height map!", "Error", MB_OK);
		return;
	}

	// Here we load the .raw file into our pHeightMap data array.

	// We are only reading in '1', and the size is the (width * height)

	fread( pHeightMap, 1, nSize, pFile );

	// After we read the data, it's a good idea to check if everything read fine.

	int result = ferror( pFile );

	// Check if we received an error.

	if (result)
	{
		MessageBox(NULL, "Can't get data!", "Error", MB_OK);
	}

	// Close the file.

	fclose(pFile);
}





/////////////////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////////////////







GLTerrain::GLTerrain()
{
	LoadRawFile("Data/Terrain.raw", (MAP_SIZE * MAP_SIZE) , g_HeightMap);
	CreateTexture(HeightMapTexture, "Data/Terrain.bmp", 0);

}





/////////////////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////////////////







void GLTerrain::Render()
{
	DrawHeightMap( g_HeightMap );
}