void ReadInRawFile(char* fileName, int size, BYTE* file_pt)
{
	FILE*	file;

	file = fopen(fileName, "rb");
	if (!file)
	{
		return;
	}
	fread(file_pt, 1, size, file);

	fclose(file);
}

int LoadTerrain()
{
	BYTE*	image_data = new BYTE[MAP_SIZE*MAP_SIZE];
	float*	heightMap = new float[VERTICES_PER_ROW*VERTICES_PER_ROW];
	int		index=0, h_index=0;
	int		x, y;

	// read in terrain image

	ReadInRawFile("data/Terrain.raw", MAP_SIZE*MAP_SIZE, image_data);

	// get the correct number of heights in the correct order

	for (y=0; y < MAP_SIZE; y += STEP_SIZE)
	{
		for (x=0; x < MAP_SIZE; x+= STEP_SIZE)
		{
			heightMap[index] = (float) image_data[x + (y * MAP_SIZE)];

			index++;
		}
	}

	// calculate the position of each vertex

	for (y=0; y < VERTICES_PER_ROW*8; y+=8)
	{
		for (x=0; x < VERTICES_PER_ROW*8; x+=8)
		{
			index = x + (y * VERTICES_PER_ROW);

			// Texture Coordinates

			terrain_data[index  ] = (float) x / (float) (VERTICES_PER_ROW*8);
			terrain_data[index+1] = (float) y / (float) (VERTICES_PER_ROW*8);

			// Normal Coordinates

			terrain_data[index+2] = 0;
			terrain_data[index+3] = 1.0f;
			terrain_data[index+4] = 0;

			// Vertex Coordinates

			terrain_data[index+5] = (float) x * (float) (STEP_SIZE/8);
			terrain_data[index+6] = heightMap[h_index];
			terrain_data[index+7] = (float) y * (float) (STEP_SIZE/8);

			h_index++;
		}
	}

	index = 0;

	// calculate the order by which to draw them

	// we're going to be using a triangle strip

	// so it should be done (x0, y0), (x1, y0),

	// (x0, y1), (x1, y1), (x0, y2) ...


	for (x=0; x < VERTICES_PER_ROW; x++)
	{
		for (y=0; y < VERTICES_PER_ROW; y++)
		{
			t_indices[index] = (x+1) + (y * VERTICES_PER_ROW);
			index++;
			t_indices[index] = x + (y * VERTICES_PER_ROW);
			index++;
		}

		x++;

		if (x >= VERTICES_PER_ROW)
			break;

		for (y=VERTICES_PER_ROW-1; y >= 0; y--)
		{
			t_indices[index] = x + (y * VERTICES_PER_ROW);
			index++;
			t_indices[index] = (x+1) + (y * VERTICES_PER_ROW);
			index++;
		}
	}

	// Free resources


	if (image_data)
		free(image_data);

	if (heightMap)
		free(heightMap);

	return true;
}

void initObjects()
{
	heading = 0.0f;

	walk_speed = 15.0f;

	camera.pos.x = MAP_SIZE * X_SCALE / 2;
	camera.pos.y = 400.0f;
	camera.pos.z = MAP_SIZE * Z_SCALE / 2;
}

int InitGL(GLvoid)										// All Setup For OpenGL Goes Here

{
	if (!LoadTerrain())
	{
		return false;
	}

	glInterleavedArrays(GL_T2F_N3F_V3F, 0, terrain_data);

	if (!LoadTexture("data/grass.bmp", texture[0]))
	{
		return false;
	}

	glShadeModel(GL_SMOOTH);							// Enable Smooth Shading

	glEnable(GL_TEXTURE_2D);
	glClearDepth(1.0f);									// Depth Buffer Setup

	glEnable(GL_DEPTH_TEST);							// Enables Depth Testing

	glDepthFunc(GL_LEQUAL);								// The Type Of Depth Testing To Do

	glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);	// Really Nice Perspective Calculations


	if (FOG_ENABLED)
	{
		// Turn on fog

		glEnable(GL_FOG);						

		// Pick a grey color for our fog with a full alpha

		float fogColor[4] = {0.5f, 0.5f, 0.5f, 1.0f};

		glFogi(GL_FOG_MODE, GL_EXP);
		glFogfv(GL_FOG_COLOR, fogColor);
		glFogf(GL_FOG_DENSITY, 0.0007f);
		glHint(GL_FOG_HINT, GL_DONT_CARE);
		glFogf(GL_FOG_START, 0.0f);
		glFogf(GL_FOG_END, 7000.0f);
		glClearColor(0.5f, 0.5f, 0.5f, 1.0f);
	}
	else
	{
		glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
	}

	initObjects();

	return TRUE;
}

int DrawGLScene(GLvoid)
{
	// Clear The Screen And The Depth Buffer

	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);	

	glLoadIdentity();

	glRotatef(pitch, 1.0f, 0, 0);
	glRotatef(heading, 0, 1.0f, 0);
	glRotatef(roll, 0, 0, 1.0f);

	glTranslatef(-camera.pos.x, -camera.pos.y, -camera.pos.z);

	glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);

	glScalef(X_SCALE, Y_SCALE, Z_SCALE);

	// For a triangle strip, the number of indices is double 

	// the amount of vertices, minus the number of vertices 

	// in the first and last rows.

	glDrawElements(GL_TRIANGLE_STRIP, 2*VERTICES_PER_ROW*VERTICES_PER_ROW-2*VERTICES_PER_ROW, GL_UNSIGNED_INT, t_indices);

	return TRUE;	// Keep Going

}