outdated: 15.Texture Mapped Outline Fonts

  1 #include <windows.h>
  2 #include <stdio.h>
  3 #include <math.h>
  4 #include <gl/glew.h>
  5 #include <gl/glut.h>
  6 #include <GL/GLUAX.H>
  7 #pragma comment(lib, "legacy_stdio_definitions.lib")
  8 /*
  9  *  Every OpenGL program is linked to a Rendering Context.
 10  *  A Rendering Context is what links OpenGL calls to the Device Context.
 11  *  In order for your program to draw to a Window you need to create a Device Context.
 12  *  The DC connects the Window to the GDI (Graphics Device Interface).
 13  */
 14 
 15 HGLRC     hRC = NULL;         // Permanent rendering context
 16 HDC       hDC = NULL;         // Private GDI device context
 17 HWND      hWnd = NULL;        // Holds our window handle
 18 HINSTANCE hInstance;          // Holds the instance of the application
 19 
 20 /*
 21  *  It‘s important to make this global so that each procedure knows if 
 22  *  the program is running in fullscreen mode or not.
 23  */
 24 
 25 bool keys[256];         // Array used for the keyboard routine
 26 bool active = TRUE;     // Window active flag set to TRUE by default
 27 bool fullscreen = TRUE; // Fullscreen flag set to fullscreen mode by default
 28 
 29 GLuint base;                         // Base display list for the font set
 30 GLfloat rot;                         // Used to  rotate the text
 31 /******************************************************************************************************************************************/
 32 /******************************************************************************************************************************************/
 33 GLuint texture[1];
 34 
 35 GLYPHMETRICSFLOAT gmf[256];      // Address buffer  for font storage 
 36 
 37 LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM); // Declaration for WndProc
 38 
 39 GLvoid BuildFont(GLvoid)
 40 {
 41     HFONT font;                      // Windows font ID
 42 
 43     base = glGenLists(256);          // Storage for 256 characters
 44 
 45     // The CreateFont function creates a logical font with the specified characteristics.
 46     // The logical font can subsequently be selected as the font for any device.
 47     font = CreateFont(-12,           // Height of font
 48         0,                           // Width of font 
 49         0,                           // Angle of escapement
 50         0,                           // Orientation angle
 51         FW_BOLD,                     // Font weight
 52         FALSE,                       // Italic
 53         FALSE,                       // Underline
 54         FALSE,                       // Strikeout
 55         SYMBOL_CHARSET,              // Character set identifier
 56         OUT_TT_PRECIS,               // Output precision
 57         CLIP_DEFAULT_PRECIS,         // Clipping precision
 58         ANTIALIASED_QUALITY,         // Output quality
 59         FF_DONTCARE | DEFAULT_PITCH, // Family and pitch
 60         "Wingdings");                // Font name
 61 
 62     // The SelectObject function selects an object into the specified device context (DC). 
 63     // The new object replaces the previous object of the same type.
 64     SelectObject(hDC, font);
 65     
 66     wglUseFontOutlines(hDC,                           // Select the current DC
 67         0,                                            // Starting character
 68         255,                                          // Number of display lists of build
 69         base,                                         // Starting display lists
 70         0.1f,                                         // Deviation from the true outlines
 71         0.2f,                                         // font thickness in the Z direction
 72         WGL_FONT_POLYGONS,                            // Use polygons, not lines
 73         gmf);                                         // Address of buffer to recive data
 74 }
 75 
 76 GLvoid KillFont(GLvoid)
 77 {
 78     glDeleteLists(base, 256);                         // Delete all 96 characters
 79 }
 80 
 81 GLvoid glPrint(const char* fmt, ...)
 82 {
 83     float length = 0;                                 // Used to find the length of the text
 84     char text[256];                                   // Holds ours string
 85     va_list ap;                                       // Pointer to list of arguments
 86 
 87     if (fmt == NULL) {
 88         return;
 89     }
 90     va_start(ap, fmt);                                // Parses the string for variables
 91     vsprintf(text, fmt, ap);                          // And converts symbols to actual numbers
 92     va_end(ap);                                       // Results are stored in text
 93 
 94     for (unsigned int loop = 0; loop < strlen(text); ++loop) {
 95         length += gmf[text[loop]].gmfCellIncX;        // Increase length  by each character width
 96     }
 97     glTranslatef(-length / 2, 0.0f, 0.0f);              // Center our text on the screen
 98 
 99     glPushAttrib(GL_LIST_BIT);                        // Pushes the display list bits
100     glListBase(base - 32);                            // Sets th base charcter to 32
101 
102     glCallLists(strlen(text), GL_UNSIGNED_BYTE, text);// Draws the display list text
103     glPopAttrib();                                    // Pops the display list bits
104 }
105 
106 
107 AUX_RGBImageRec* LoadBMP(char* Filename)
108 {
109     FILE* File = NULL;
110     
111     if (!Filename) {
112         return NULL;
113     }
114 
115     File = fopen(Filename, "r");
116     if (File) {
117         fclose(File);
118         return auxDIBImageLoad(Filename);
119     }
120 
121     return NULL;
122 }
123 
124 int LoadGLTextures()
125 {
126     int Status = FALSE;
127 
128     AUX_RGBImageRec* TextureImage[1];
129     
130     memset(TextureImage, 0, sizeof(void*) * 1);
131 
132     if (TextureImage[0] = LoadBMP("1.bmp")) {
133         Status = TRUE;
134         glGenTextures(1, &texture[0]);
135         glBindTexture(GL_TEXTURE_2D, texture[0]);
136         gluBuild2DMipmaps(GL_TEXTURE_2D, 3, TextureImage[0]->sizeX, TextureImage[0]->sizeY,
137             GL_RGB, GL_UNSIGNED_BYTE, TextureImage[0]->data);
138         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
139         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_NEAREST);
140         // Texturing contour anchored to the object
141         glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
142         // GL_S will cover mapping the texture left to right
143         glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
144         // GL_T will cover mapping the texture up and down
145         glEnable(GL_TEXTURE_GEN_S);                   // Auto texture generation
146         glEnable(GL_TEXTURE_GEN_T);                   // Auto texture generation
147     }
148 
149     if (TextureImage[0]) {
150         if (TextureImage[0]->data) {
151             free(TextureImage[0]->data);
152         }
153         free(TextureImage[0]);
154     }
155     return Status;
156 }
157 /******************************************************************************************************************************************/
158 /******************************************************************************************************************************************/
159 
160 GLvoid ReSizeGLScene(GLsizei width, GLsizei height)   // Resize and initialize the GL window
161 {
162     if (height == 0) {                                // Prevent a divide by zero by
163         height = 1;                                   // Making height equal one
164     }
165     
166     glViewport(0, 0, width, height);                  // Reset the current viewport
167 
168     /*
169      *  The following lines set the screen up for a perspective view. 
170      *  Meaning things in the distance get smaller. This creates a realistic looking scene. 
171      *  The perspective is calculated with a 45 degree viewing angle based on 
172      *  the windows width and height. The 0.1f, 100.0f is the starting point and 
173      *  ending point for how deep we can draw into the screen.
174      *
175      *  The projection matrix is responsible for adding perspective to our scene.
176      *  glLoadIdentity() restores the selected matrix to it‘s original state.
177      *  The modelview matrix is where our object information is stored.
178      *   Lastly we reset the modelview matrix.
179      */
180 
181     glMatrixMode(GL_PROJECTION);                      // Select the projection matrix
182     glLoadIdentity();                                 // Reset the projection matrix
183     
184                                                       // Calculate the aspect ratio of the window
185     gluPerspective(45.0f, (GLfloat)width / (GLfloat)height, 0.1f, 100.0f);
186 
187     glMatrixMode(GL_MODELVIEW);                       // Seclet the modelview matrix
188     glLoadIdentity();                                 // Reset the modelview matrix
189 }
190 /******************************************************************************************************************************************/
191 /******************************************************************************************************************************************/
192 int InitGL(GLvoid)                                    // All setup for OpenGL goes here
193 {
194     /*
195      *  Smooth shading blends colors nicely across a polygon, and smoothes out lighting.
196      */
197     if (!LoadGLTextures()) {
198         return FALSE;
199     }
200     
201     glShadeModel(GL_SMOOTH);                          // Enables smooth shading
202     glClearColor(0.0f, 0.0f, 0.0f, 0.5f);             // Black background
203 
204     glClearDepth(1.0f);                               // Depth buffer setup
205 
206     glDepthFunc(GL_LEQUAL);
207     glEnable(GL_DEPTH_TEST);
208 
209     glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);   // Really nice perspective calculations
210     
211     glEnable(GL_LIGHT0);                              // Enable default light (quick and dirty)
212     glEnable(GL_LIGHTING);                            // Enable lighting
213     glEnable(GL_TEXTURE_2D);
214     glBindTexture(GL_TEXTURE_2D, texture[0]);
215 
216     BuildFont();
217     return TRUE;
218 }
219 /*
220  *  For now all we will do is clear the screen to the color we previously decided on, 
221  *  clear the depth buffer and reset the scene. We wont draw anything yet.
222  */
223 int DrawGLScene(GLvoid)                                  // Here‘s where we do all the drawing
224 {
225     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);  // Clear the screen and the depth buffer
226     glLoadIdentity();
227 
228     glTranslatef(1.1f * float(cos(rot / 116.0f)), 0.8f * float(sin(rot / 120.0f)), -3.0f);
229 
230     glRotatef(rot, 1.0f, 0.0f, 0.0f);
231     glRotatef(rot * 1.2f, 0.0f, 1.0f, 0.0f);
232     glRotatef(rot * 1.4f, 0.0f, 0.0f, 1.0f);
233     glTranslatef(-0.35f, -0.35f, 0.1);
234 
235     glPrint("n");                                        // Draw A skull and crossbones symbol
236     rot += 0.05f;
237     return TRUE;                                         // everthing went OK
238 }
239 /******************************************************************************************************************************************/
240 /******************************************************************************************************************************************/
241 /*
242  *  The job of KillGLWindow() is to release the Rendering Context, 
243  *  the Device Context and finally the Window Handle. 
244  */
245 
246 GLvoid KillGLWindow(GLvoid)                              // Properly kill the window
247 {
248     if (fullscreen) {                                    // Are we in fullscreen mode
249         
250         /*
251          *  We use ChangeDisplaySettings(NULL,0) to return us to our original desktop.
252          *  After we‘ve switched back to the desktop we make the cursor visible again.
253          */
254 
255         ChangeDisplaySettings(NULL, 0);                  // if so switch back to the desktop
256         ShowCursor(TRUE);                                // Show mouse pointer
257     }
258 
259     if (hRC) {                                           // Do we have a rendering context
260         if (!wglMakeCurrent(NULL, NULL)) {                // Are we able to release the DC and RC contexts
261             MessageBox(NULL, "Release of DC and RC failed.", "SHUTDOWN ERROR", MB_OK | MB_ICONINFORMATION);
262         }
263 
264         if (!wglDeleteContext(hRC)) {                     // Are we able to delete the RC
265             MessageBox(NULL, "Release rendering context failed.", "SHUTDOWN ERROR", MB_OK | MB_ICONINFORMATION);
266             hRC = NULL;                                  // Set RC to NULL
267         }
268 
269         if (hDC && !ReleaseDC(hWnd, hDC)) {              // Are we able to release the DC
270             MessageBox(NULL, "Release device context failed.", "SHUTDOWN ERROR", MB_OK | MB_ICONINFORMATION);
271             hDC = NULL;                                  // Set DC to NULL
272         }
273         if (hWnd && !DestroyWindow(hWnd)) {              // Are we able to destroy the window
274             MessageBox(NULL, "Could not release hWnd.", "SHUTDOWN ERROR", MB_OK | MB_ICONINFORMATION);
275             hWnd = NULL;                                 // Set hWnd to NULL
276         }
277 
278         if (!UnregisterClass("OpenGL", hInstance)) {     // Are we able to unregister class
279             MessageBox(NULL, "Could not register class.", "SHUTDOWN ERROR", MB_OK | MB_ICONINFORMATION);
280             hInstance = NULL;                            // Set hInstance to NULL
281         }
282     }
283 /******************************************************************************************************************************************/
284 /******************************************************************************************************************************************/
285     KillFont();
286 /******************************************************************************************************************************************/
287 /******************************************************************************************************************************************/
288 }
289 
290 /*
291  * The next section of code creates our OpenGL Window.
292  */
293 
294 BOOL CreateGLWindow(char* title, int width, int height, int bits, bool fullscreenflag)
295 {
296     /*
297      * Find  a pixel format that matches the one we want
298      */
299     GLuint PixelFormat;                                  // Holds the result after serching for a match
300     
301     /*
302      * Before you create a window, you MUST register a Class for the window
303      */
304     WNDCLASS wc;                                         // Windows class structure
305 
306     /*
307      *  dwExStyle and dwStyle will store the Extended and normal Window Style Information.
308     */
309     DWORD dwExStyle;                                     // Window extend style
310     DWORD dwStyle;                                       // Window style
311 
312     RECT WindowRect;                                     // Grabs rectangle upper left/lower right values
313     WindowRect.left = (long)0;                           // Set left value to 0
314     WindowRect.right = (long)width;                      // Set right value to requested width
315     WindowRect.top = (long)0;                            // Set top value to 0
316     WindowRect.bottom = (long)height;                    // Set bottom value to requested height
317 
318     fullscreen = fullscreenflag;                         // Set the global fullscreen flag
319 
320     /*
321      *  The style CS_HREDRAW and CS_VREDRAW force the Window to redraw whenever it is resized. 
322      *  CS_OWNDC creates a private DC for the Window. Meaning the DC is not shared across applications. 
323      *  WndProc is the procedure that watches for messages in our program. 
324      *  No extra Window data is used so we zero the two fields. Then we set the instance. 
325      *  Next we set hIcon to NULL meaning we don‘t want an ICON in the Window, 
326      *  and for a mouse pointer we use the standard arrow. The background color doesn‘t matter 
327      *  (we set that in GL). We don‘t want a menu in this Window so we set it to NULL, 
328      *  and the class name can be any name you want. I‘ll use "OpenGL" for simplicity.
329      */
330     hInstance = GetModuleHandle(NULL);                   // Grab an instance for our window
331     wc.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;       // Redraw on move, and own DC for window
332     wc.lpfnWndProc = (WNDPROC)WndProc;                   // WndProc handles message
333     wc.cbClsExtra = 0;                                   // No extra window date
334     wc.cbWndExtra = 0;                                   // No extra window date
335     wc.hInstance = hInstance;                            // set the instance
336     wc.hIcon = LoadIcon(NULL, IDI_WINLOGO);              // Load the default icon
337     wc.hCursor = LoadCursor(NULL, IDC_ARROW);            // Load the arrow pointer
338     wc.hbrBackground = NULL;                             // No background requried for GL
339     wc.lpszMenuName = NULL;                              // We don‘t want a menu
340     wc.lpszClassName = "OpenGL";                         // set the class name
341 
342     if (!RegisterClass(&wc)) {                           // Attempt to register the window class
343         MessageBox(NULL, "Failed to register the window class.", "ERROR", MB_OK | MB_ICONEXCLAMATION);
344         return FALSE;                                    // Exit and return false
345     }
346 
347     if (fullscreen) {                                    // attempt fullsreen model
348         
349         /*
350         T*  here are a few very important things you should keep in mind when switching to full screen mode.
351          *  Make sure the width and height that you use in fullscreen mode is the same as 
352          *  the width and height you plan to use for your window, and most importantly,
353          *  set fullscreen mode BEFORE you create your window.
354          */
355         DEVMODE dmScreenSettings;                        // Device mode
356         memset(&dmScreenSettings, 0, sizeof(dmScreenSettings)); // Make sure memory‘s cleared
357         dmScreenSettings.dmSize = sizeof(dmScreenSettings);     // Size of devmode structure
358         dmScreenSettings.dmPelsWidth = width;            // Select window width
359         dmScreenSettings.dmPelsHeight = height;          // Select window height
360         dmScreenSettings.dmBitsPerPel = bits;            // Select bits per pixel
361         dmScreenSettings.dmFields = DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT;
362         
363         /*
364          *  In the line below ChangeDisplaySettings tries to switch to a mode that matches 
365          *  what we stored in dmScreenSettings. I use the parameter CDS_FULLSCREEN when switching modes, 
366          *  because it‘s supposed to remove the start bar at the bottom of the screen, 
367          *  plus it doesn‘t move or resize the windows on your desktop when you switch to 
368          *  fullscreen mode and back.
369          */
370         //Try to set selected mode and get results. Note: CDS_FULLSCREEN gets rid of start bar
371         if (ChangeDisplaySettings(&dmScreenSettings, CDS_FULLSCREEN) != DISP_CHANGE_SUCCESSFUL) {
372             //If the mode fails, offer two options. Quit or run in a window
373             if (MessageBox(NULL, "The requested fullscreen mode is not supported by\n your video card. Use"
374                 "windowed mode instead?", "GL", MB_YESNO | MB_ICONEXCLAMATION) == IDYES)
375             {
376                 fullscreen = FALSE;                       // Select windowed mode (fullscreen=FLASE)
377             }
378             else {
379                 // Pop up a message box letting user know the programe is closing.
380                 MessageBox(NULL, "Program will now close.", "ERROR", MB_OK | MB_ICONSTOP);
381                 return FALSE;                             // Exit and return FALSE
382             }
383         }
384     }
385 
386     if (fullscreen) {                                     // Are we still in fullscreen mode
387         
388         /*
389          *  If we are still in fullscreen mode we‘ll set the extended style to WS_EX_APPWINDOW, 
390          *  which force a top level window down to the taskbar once our window is visible. 
391          *  For the window style we‘ll create a WS_POPUP window. 
392          *  This type of window has no border around it, making it perfect for fullscreen mode.
393 
394          *  Finally, we disable the mouse pointer. If your program is not interactive, 
395          *  it‘s usually nice to disable the mouse pointer when in fullscreen mode. It‘s up to you though.
396          */
397         dwExStyle = WS_EX_APPWINDOW;                      // Window extended style
398         dwStyle = WS_POPUP;                               // Window style
399         ShowCursor(FALSE);                                // Hide mosue pointer 
400     }
401     else {
402 
403         /*
404          *  If we‘re using a window instead of fullscreen mode, 
405          *  we‘ll add WS_EX_WINDOWEDGE to the extended style. This gives the window a more 3D look. 
406          *  For style we‘ll use WS_OVERLAPPEDWINDOW instead of WS_POPUP. 
407          *  WS_OVERLAPPEDWINDOW creates a window with a title bar, sizing border, 
408          *  window menu, and minimize / maximize buttons.
409          */
410         dwExStyle = WS_EX_APPWINDOW | WS_EX_WINDOWEDGE;   // Window extended style
411         dwStyle = WS_OVERLAPPEDWINDOW;                    // Window style
412     }
413 
414     /*
415      *  By using the AdjustWindowRectEx command none of our OpenGL scene will be covered up by the borders, 
416      *  instead, the window will be made larger to account for the pixels needed to draw the window border. 
417      *  In fullscreen mode, this command has no effect.
418      */
419     AdjustWindowRectEx(&WindowRect, dwStyle, FALSE, dwExStyle);  // Adjust window to true resqusted
420     
421     /*
422      *  WS_CLIPSIBLINGS and WS_CLIPCHILDREN are both REQUIRED for OpenGL to work properly. 
423      *  These styles prevent other windows from drawing over or into our OpenGL Window.
424      */
425     if (!(hWnd = CreateWindowEx(dwExStyle,                // Extended style for the window
426         "OpenGL",                                         // Class name
427         title,                                            // Window title
428         WS_CLIPSIBLINGS |                                 // Requried window style
429         WS_CLIPCHILDREN |                                 // Requried window style
430         dwStyle,                                          // Select window style
431         0, 0,                                             // Window position
432         WindowRect.right - WindowRect.left,               // Calculate adjusted window width
433         WindowRect.bottom - WindowRect.top,               // Calculate adjusted window height
434         NULL,                                             // No parent window
435         NULL,                                             // No menu
436         hInstance,                                        // Instance
437         NULL)))                                           // Don‘t pass anything to WM_CREATE
438     {
439         KillGLWindow();                                   //Reset the display
440         MessageBox(NULL, "Window creation error.", "ERROR", MB_OK | MB_ICONEXCLAMATION);
441         return FALSE;                                     // Retrurn FALSE;
442     }
443 
444     /*
445      *  aside from the stencil buffer and the (slow) accumulation buffer
446      */
447     static PIXELFORMATDESCRIPTOR pfd =                    // pfd tells windows how we want things to be 
448     {
449         sizeof(PIXELFORMATDESCRIPTOR),                    // Size of this pixel format descriptor
450         1,                                                // Version number
451         PFD_DRAW_TO_WINDOW |                              // Format must support window
452         PFD_SUPPORT_OPENGL |                              // Format must support OpenGL
453         PFD_DOUBLEBUFFER,                                 // Must support double buffer
454         PFD_TYPE_RGBA,                                    // Request an RGBA format
455         bits,                                             // Select our color depth
456         0, 0, 0, 0, 0, 0,                                 // Color bits ignored
457         0,                                                // No alpha buffer
458         0,                                                // shift bit ignored
459         0,                                                // No accumulation buffer
460         0, 0, 0, 0,                                       // Accumulation bits ignored
461         16,                                               // 16Bits Z_Buffer (depth buffer)
462         0,                                                // No stencil buffer
463         0,                                                // No auxiliary buffer
464         PFD_MAIN_PLANE,                                   // Main drawing layer
465         0,                                                // Reserved
466         0, 0, 0                                           // Layer makes ignored
467     };
468 
469     if (!(hDC = GetDC(hWnd))) {                           // Did we get a device context
470         KillGLWindow();                                   // Reset the display
471         MessageBox(NULL, "Can‘t create a GL device context.", "ERROR", MB_OK | MB_ICONEXCLAMATION);
472         return FALSE;                                     // Return FALSE
473     }
474 
475     if (!(PixelFormat = ChoosePixelFormat(hDC, &pfd))) {  // Did window find a matching pixel format
476         KillGLWindow();                                   // Reset the display
477         MessageBox(NULL, "Can‘t find a suitable pixelformat.", "ERROR", MB_OK | MB_ICONEXCLAMATION);
478         return FALSE;                                     // Return FALSE;
479     }
480 
481     if (!SetPixelFormat(hDC, PixelFormat, &pfd)) {        // Are we able to set the pixel format
482         KillGLWindow();                                   // Reset the display
483         MessageBox(NULL, "Can‘t set the pixelformat.", "ERROR", MB_OK | MB_ICONEXCLAMATION);
484         return FALSE;                                     // Return FALSE;
485     }
486 
487     if (!(hRC = wglCreateContext(hDC))) {                 // Are we able to rendering context
488         KillGLWindow();                                   // Reset the display
489         MessageBox(NULL, "Can‘t create a GL rendering context.", "ERROR", MB_OK | MB_ICONEXCLAMATION);
490         return FALSE;                                     // Return FASLE;
491     }
492 
493     if (!wglMakeCurrent(hDC, hRC)) {                      // Try to activate the rendering context
494         KillGLWindow();                                   // Reset the display
495         MessageBox(NULL, "Can‘t activate the GL rendering context.", "ERROR", MB_OK | MB_ICONEXCLAMATION);
496         return FALSE;                                     // Return FALSE    
497     }
498 
499     /*
500      *  ReSizeGLScene passing the screen width and height to set up our perspective OpenGL screen.
501      */
502     ShowWindow(hWnd, SW_SHOW);                            // Show the window
503     SetForegroundWindow(hWnd);                            // slightly higher priority
504     SetFocus(hWnd);                                       // Sets keyboard focus to the window
505     ReSizeGLScene(width, height);                         // Set up our perspective GL screen
506 
507 /*
508  *  we can set up lighting, textures, and anything else that needs to be setup in InitGL().
509  */
510 if (!InitGL()) {                                      // Initialize our newly created GL window
511     KillGLWindow();                                   // Reset the display
512     MessageBox(NULL, "Initialize Failed.", "ERROR", MB_OK | MB_ICONEXCLAMATION);
513     return FALSE;                                     // Return FALSE
514 }
515 return TRUE;
516 }
517 
518 LRESULT CALLBACK WndProc(HWND hWnd,                       // Handle for this window
519     UINT uMsg,                                            // Message for this window
520     WPARAM wParam,                                        // Additional message information
521     LPARAM lParam)                                        // Additional message information
522 {
523     switch (uMsg) {                                       // Check for window message
524     case WM_ACTIVATE: {                               // Check minimization state
525         if (!HIWORD(wParam)) {
526             active = TRUE;                            // Program is active
527         }
528         else {
529             active = FALSE;                           // Program is no longer active
530         }
531         return 0;                                     // Return to the message loop
532     }
533     case WM_SYSCOMMAND: {                             // Intercept system commands
534         switch (wParam) {                             // Check system calls
535         case SC_SCREENSAVE:                       // Screensaver trying to start
536         case SC_MONITORPOWER:                     // Monitor trying to enter powersave
537             return 0;                                 // Prevent form happening
538         }
539         break;                                        // Exit
540     }
541     case WM_CLOSE: {                                  // Did we receive a close message
542         PostQuitMessage(0);                           // Send a quit message
543         return 0;
544     }
545     case WM_KEYDOWN: {                                // Is a key being held down
546         keys[wParam] = TRUE;                          // if so, mark it as TRUE
547         return 0;                                     // Jump back
548     }
549     case WM_KEYUP: {                                  // Has a key been released
550         keys[wParam] = FALSE;                         // if so, mark it as FALSE
551         return 0;                                     // Jump back
552     }
553     case WM_SIZE: {                                   // Resize the OpenGL window
554         ReSizeGLScene(LOWORD(lParam), HIWORD(lParam));   // LoWord = width HiWord = height
555         return 0;                                     // Jump back
556     }
557     }
558     return DefWindowProc(hWnd, uMsg, wParam, lParam);     // Pass all unhandled message to DefWindwProc
559 }
560 
561 int WINAPI WinMain(HINSTANCE hInstance,                   // Instance
562     HINSTANCE hPrevInstance,                              // Previous instance
563     LPSTR lpCmdLine,                                      // Command line parameters
564     int nCmdShow)                                         // Window show state
565 {
566     MSG msg;                                              // Window message structure
567     BOOL done = FALSE;                                    // Bool variable to exit loop
568                                                           // Ask the user which screen mode they prefer
569     if (MessageBox(NULL, "Would you like to run in fullscreen mode?",
570         "Start fullscreen?", MB_YESNO | MB_ICONQUESTION) == IDNO)
571     {
572         fullscreen = FALSE;                               // Window mode
573     }
574     // Create our OpenGL window
575     if (!CreateGLWindow("3D Shapes", 640, 480, 16, fullscreen)) {  // (Modified)
576         return 0;                                         // Quit if window was not create
577     }
578 
579     while (!done) {                                       // Loop that runs until donw = TRUE
580         if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) {   // Is there a message wating
581             if (msg.message == WM_QUIT) {                 // Havw we received a quit message
582                 done = TRUE;                              // if so done  = TRUE
583             }
584             else {                                        // If not, deal with window message
585                 TranslateMessage(&msg);                   // Translate message
586                 DispatchMessage(&msg);                    // Dispatch message
587             }
588         }
589         else {
590             // Draw the scene. Watch for ESC key and quit message from DrawGLScene()
591             if (active) {                                 // Program active
592                 if (keys[VK_ESCAPE]) {                    // Was ESC pressed
593                     done = TRUE;                          // ESC signalled a quit
594                 }
595                 else {                                    // Not time to quit, update screen
596                     DrawGLScene();                        // Draw scene
597                     SwapBuffers(hDC);                     // Swap buffers (double buffering)
598                 }
599             }
600 
601             /*
602              *  It allows us to press the F1 key to switch from fullscreen mode to
603              *  windowed mode or windowed mode to fullscreen mode.
604              */
605 /******************************************************************************************************************************************/
606 /******************************************************************************************************************************************/
607 /******************************************************************************************************************************************/
608 /******************************************************************************************************************************************/
609             if (keys[VK_F1]) {                            // Is F1 being pressed
610                 keys[VK_F1] = FALSE;                      // If so make key FASLE
611                 KillGLWindow();                           // Kill our current window
612                 fullscreen = !fullscreen;                 // Toggle fullscreen / window mode
613                 //Recreate our OpenGL window(modified)
614                 if (!CreateGLWindow("3D Shapes", 640, 480, 16, fullscreen)) {
615                     return 0;                             // Quit if window was not create
616                 }
617             }
618         }
619     }
620     // Shutdown
621     KillGLWindow();                                       // Kill the window
622     return (msg.wParam);                                  // Exit the program
623 }