Jeff Molofee - NeHe's OpenGL Tutorials

The variable performance_timer can be either TRUE of FALSE. If the program detects a performance counter, the variable performance_timer variable is set to TRUE, and all timing is done using the performance counter (alot more accurate than the multimedia timer). If a performance counter is not found, performance_timer is set to FALSE and the multimedia timer is used for timing.

The last 2 variables are 64 bit integer variables that hold the start time of the performance counter and the amount of time that has elapsed since the performance counter was started.

The name of this structure is "timer" as you can see at the bottom of the structure. If we want to know the timer frequency we can now check timer.frequency. Nice!

struct // Create A Structure For The Timer Information

{

__int64 frequency; // Timer Frequency

float resolution; // Timer Resolution

unsigned long mm_timer_start; // Multimedia Timer Start Value

unsigned long mm_timer_elapsed; // Multimedia Timer Elapsed Time

bool performance_timer; // Using The Performance Timer?

__int64 performance_timer_start; // Performance Timer Start Value

__int64 performance_timer_elapsed; // Performance Timer Elapsed Time

} timer; // Structure Is Named timer

The next line of code is our speed table. The objects in the game will move at a different rate depending on the value of adjust. If adjust is 0 the objects will move one pixel at a time. If the value of adjust is 5, the objects will move 20 pixels at a time. So by increasing the value of adjust the speed of the objects will increase, making the game run faster on slow computers. The higher adjust is however, the choppier the game will play.

Basically steps[ ] is just a look-up table. If adjust was 3, we would look at the number stored at location 3 in steps[ ]. Location 0 holds the value 1, location 1 holds the value 2, location 2 holds the value 4, and location 3 hold the value 5. If adjust was 3, our objects would move 5 pixels at a time. Make sense?

int steps[6]={ 1, 2, 4, 5, 10, 20 }; // Stepping Values For Slow Video Adjustment

Next we make room for two textures. We'll load a background scene, and a bitmap font texture. Then we set up a base variable so we can keep track of our font display list just like we did in the other font tutorials. Finally we declare WndProc().

GLuint texture[2]; // Font Texture Storage Space

GLuint base; // Base Display List For The Font

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

Now for the fun stuff :) The next section of code initializes our timer. It will check the computer to see if a performance counter is available (very accurate counter). If we don't have a performance counter the computer will use the multimedia timer. This code should be portable from what I'm told.

We start off by clearing all the timer variables to zero. This will set all the variables in our timer structure to zero. After that, we check to see if there is NOT a performance counter. The ! means NOT. If there is, the frequency will be stored in timer.frequency.

If there was no performance counter, the code in between the { }'s is run. The first line sets the variable timer.performance_timer to FALSE. This tells our program that there is no performance counter. The second line gets our starting multimedia timer value from timeGetTime(). We set the timer.resolution to 0.001f, and the timer.frequency to 1000. Because no time has elapsed yet, we make the elapsed time equal the start time.

void TimerInit(void) // Initialize Our Timer (Get It Ready)

{

memset(&timer, 0, sizeof(timer)); // Clear Our Timer Structure

// Check To See If A Performance Counter Is Available

// If One Is Available The Timer Frequency Will Be Updated

if (!QueryPerformanceFrequency((LARGE_INTEGER *) &timer.frequency)) {

// No Performace Counter Available

timer.performance_timer = FALSE; // Set Performance Timer To FALSE

timer.mm_timer_start = timeGetTime(); // Use timeGetTime() To Get Current Time

timer.resolution = 1.0f/1000.0f; // Set Our Timer Resolution To .001f

timer.frequency = 1000; // Set Our Timer Frequency To 1000

timer.mm_timer_elapsed = timer.mm_timer_start; // Set The Elapsed Time To The Current Time

}

If there is a performance counter, the following code is run instead. The first line grabs the current starting value of the performance counter, and stores it in timer.performance_timer_start. Then we set timer.performance_timer to TRUE so that our program knows there is a performance counter available. After that we calculate the timer resolution by using the frequency that we got when we checked for a performance counter in the code above. We divide 1 by the frequency to get the resolution. The last thing we do is make the elapsed time the same as the starting time.

Notice instead of sharing variables for the performance and multimedia timer start and elapsed variables, I've decided to make seperate variables. Either way it will work fine.

else {

// Performance Counter Is Available, Use It Instead Of The Multimedia Timer

// Get The Current Time And Store It In performance_timer_start

QueryPerformanceCounter((LARGE_INTEGER *) &timer.performance_timer_start);

timer.performance_timer = TRUE; // Set Performance Timer To TRUE

// Calculate The Timer Resolution Using The Timer Frequency

timer.resolution = (float) (((double)1.0f)/((double)timer.frequency));

// Set The Elapsed Time To The Current Time

timer.performance_timer_elapsed = timer.performance_timer_start;

}

}

The section of code above sets up the timer. The code below reads the timer and returns the amount of time that has passed in milliseconds.

The first thing we do is set up a 64 bit variable called time. We will use this variable to grab the current counter value. The next line checks to see if we have a performance counter. If we do, timer.performance_timer will be TRUE and the code right after will run.

The first line of code inside the { }'s grabs the counter value and stores it in the variable we created called time. The second line takes the time we just grabbed (time and subtracts the start time that we got when we initialized the timer. This way our timer should start out pretty close to zero. We then multiply the results by the resolution to find out how many seconds have passed. The last thing we do is multiply the result by 1000 to figure out how many milliseconds have passed. After the calculation is done, our results are sent back to the section of code that called this procedure. The results will be in floating point format for greater accuracy.

If we are not using the peformance counter, the code after the else statement will be run. It does pretty much the same thing. We grab the current time with timeGetTime() and subtract our starting counter value. We multiply it by our resolution and then multiply the result by 1000 to convert from seconds into milliseconds.

float TimerGetTime() // Get Time In Milliseconds

{

__int64 time; // time Will Hold A 64 Bit Integer

if (timer.performance_timer) // Are We Using The Performance Timer?

{

QueryPerformanceCounter((LARGE_INTEGER *) &time); // Grab The Current Performance Time