Jeff Molofee - NeHe's OpenGL Tutorials

Last of all we close up the file and return success.

while (currentpixel < pixelcount); // More Pixels To Read? … Start Loop Over

fclose(fTGA); // Close File

return true; // Return Success

}

Now you have some image data ready for glGenTextures and glBindTexture. I suggest you check out NeHe's tutorial #6 and #24 for info on these commands. That concludes my first ever tutorial. I do not guarantee my code is error free, though i made an effort to see that it was. Special thanks to Jeff "NeHe" Molofee for his great tutorials and to Trent "ShiningKnight" Polack for helping me revise this tutorial. If you find errors, have suggestions, or comments please feel free to email me (terminate@gdnmail.net), or ICQ me at UIN# 38601160. Enjoy!

* DOWNLOAD Visual C++Code For This Lesson.

Welcome to another exciting tutorial! The code for this tutorial was written by Ben Humphrey, and is based on the GL framework from lesson 1. By now you should be a GL expert {grin}, and moving the code into your own base code should be a snap!

This tutorial will teach you how to create cool looking terrain from a height map. For those of you that have no idea what a height map is, I will attempt a crude explanation. A height map is simply… displacement from a surface. For those of you that are still scratching your heads asking yourself "what the heck is this guy talking about!?!"… In english, our heightmap represents low and height points for our landscape. It's completely up to you to decide which shades represent low points and which shades represent high points. It's also important to note that height maps do not have to be images… you can create a height map from just about any type of data. For instance, you could use an audio stream to create a visual height map representation. If you're still confused… keep reading… it will all start to make sense as you go through the tutorial :)

#include // Header File For Windows

#include // Header file For Standard Input/Output ( NEW )

#include // Header File For The OpenGL32 Library

#include // Header File For The GLu32 Library

#include // Header File For The Glaux Library

#pragma comment(lib, "opengl32.lib") // Link OpenGL32.lib

#pragma comment(lib, "glu32.lib") // Link Glu32.lib

We start off by defining a few important variables. MAP_SIZE is the dimension of our map. In this tutorial, the map is 1024x1024. The STEP_SIZE is the size of each quad we use to draw the landscape. By reducing the step size, the landscape becomes smoother. It's important to note that the smaller the step size, the more of a performance hit your program will take, especially when using large height maps. The HEIGHT_RATIO is used to scale the landscape on the y-axis. A low HEIGHT_RATIO produces flatter mountains. A high HEIGHT_RATIO produces taller / more defined mountains.

Further down in the code you will notice bRender. If bRender is set to true (which it is by default), we will drawn solid polygons. If bRender is set to false, we will draw the landscape in wire frame.

#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 )

HDC hDC=NULL; // Private GDI Device Context

HGLRC hRC=NULL; // Permanent Rendering Context

HWND hWnd=NULL; // Holds Our Window Handle

HINSTANCE hInstance; // Holds The Instance Of The Application

bool keys[256]; // Array Used For The Keyboard Routine

bool active=TRUE; // Window Active Flag Set To TRUE By Default

bool fullscreen=TRUE; // Fullscreen Flag Set To TRUE By Default

bool bRender = TRUE; // Polygon Flag Set To TRUE By Default ( NEW )

Here we make an array (g_HeightMap[ ]) of bytes to hold our height map data. Since we are reading in a .RAW file that just stores values from 0 to 255, we can use the values as height values, with 255 being the highest point, and 0 being the lowest point. We also create a variable called scaleValue for scaling the entire scene. This gives the user the ability to zoom in and out.

BYTE g_HeightMap[MAP_SIZE*MAP_SIZE]; // Holds The Height Map Data ( NEW )

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

LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM); // Declaration For WndProc

The ReSizeGLScene() code is the same as lesson 1 except the farthest distance has been changed from 100.0f to 500.0f.

GLvoid ReSizeGLScene(GLsizei width, GLsizei height) // Resize And Initialize The GL Window {

… CUT …

}

The following code loads in the .RAW file. Not too complex! We open the file in Read/Binary mode. We then check to make sure the file was found and that it could be opened. If there was a problem opening the file for whatever reason, an error message will be displayed.

// Loads The .RAW File And Stores It In pHeightMap

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

FILE *pFile = NULL;

// 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 Error Message And Stop The Function

MessageBox(NULL, "Can't Find The Height Map!", "Error", MB_OK);

return;

}

If we've gotten this far, then it's safe to assume there were no problems opening the file. With the file open, we can now read in the data. We do this with fread(). pHeightMap is the storage location for the data (pointer to our g_Heightmap array). 1 is the number of items to load (1 byte at a time), nSize is the maximum number of items to read (the image size in bytes — width of image × height of image). Finally, pFile is a pointer to our file structure!

After reading in the data, we check to see if there were any errors. We store the results in result and then check result. If an error did occur, we pop up an error message.

The last thing we do is close the file with fclose(pFile).

// Here We Load The .RAW File Into Our pHeightMap Data Array

// We Are Only Reading In '1', And The Size Is (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, "Failed To Get Data!", "Error", MB_OK);

}

// Close The File

fclose(pFile);

}

The init code is pretty basic. We set the background clear color to black, set up depth testing, polygon smoothing, etc. After doing all that, we load in our .RAW file. To do this, we pass the filename ("Data/Terrain.raw"), the dimensions of the .RAW file (MAP_SIZE * MAP_SIZE) and finally our HeightMap array (g_HeightMap) to LoadRawFile(). This will jump to the .RAW loading code above. The .RAW file will be loaded, and the data will be stored in our Heightmap array (g_HeightMap).

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

{