outdated: 18.Quadrics
quadratic可以做许多有趣的事，在声明全局变量时，GLUquadricObj为quadratic(二次曲面)的指针。在InitGL()函数中，glLightfv()函数已经见过好多次了，镜面反射，光线追踪都需要用到。gluNewQuadric()函数创建一个quadratic。gluQuadricNormals()函数选择一个none/smooth/flat标准。gluQuadricTexture()函数为quadratic设置贴图纹理。
这次绘制了六种quadratic，Cube、Cylinder、Disk、Sphere、Cone和PartialDisk。都有对应的函数，gluCylinder()、gluSphere()、gluCylinder()、gluDisk()、gluPartialDisk()。
gluDeleteQuadric()函数在KillGLWindow()函数时删除quadratic。
代码如下，同样修改部分位于双行星号内。
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 /******************************************************************************************************************************************/ 30 /******************************************************************************************************************************************/ 31 bool light; 32 bool lp; 33 bool fp; 34 bool sp; // Spacebar pressed 35 36 int part1; // Start of disc 37 int part2; // End of disc 38 int p1 = 0; // Increase 1 39 int p2 = 1; // Increase 2 40 41 GLfloat xrot; 42 GLfloat yrot; 43 GLfloat xspeed; 44 GLfloat yspeed; 45 46 GLfloat z = -5.0f; 47 48 GLUquadricObj * quadratic; // Storage for our quadratic objects 49 50 GLfloat LightAmbient[] = { 0.5f, 0.5f, 0.5f, 1.0f }; 51 GLfloat LightDiffuse[] = { 1.0f, 1.0f, 1.0f, 1.0f }; 52 GLfloat LightPosition[] = { 0.0f, 0.0f, 2.0f, 1.0f }; 53 54 GLuint filter; 55 GLuint texture[3]; 56 GLuint object = 0; 57 /******************************************************************************************************************************************/ 58 /******************************************************************************************************************************************/ 59 LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM); // Declaration for WndProc 60 61 AUX_RGBImageRec* LoadBMP(char* Filename) 62 { 63 FILE* File = NULL; 64 65 if (!Filename) { 66 return NULL; 67 } 68 69 File = fopen(Filename, "r"); 70 if (File) { 71 fclose(File); 72 return auxDIBImageLoad(Filename); 73 } 74 75 return NULL; 76 } 77 78 int LoadGLTextures() 79 { 80 int Status = FALSE; 81 82 /******************************************************************************************************************************************/ 83 /******************************************************************************************************************************************/ 84 AUX_RGBImageRec* TextureImage[2]; 85 86 memset(TextureImage, 0, sizeof(void*) * 2); 87 88 if (TextureImage[0] = LoadBMP("1.bmp")) { 89 Status = TRUE; 90 glGenTextures(3, &texture[0]); 91 92 glBindTexture(GL_TEXTURE_2D, texture[0]); 93 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); 94 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); 95 glTexImage2D(GL_TEXTURE_2D, 0, 3, TextureImage[0]->sizeX, TextureImage[0]->sizeY, 96 0, GL_RGB, GL_UNSIGNED_BYTE, TextureImage[0]->data); 97 98 glBindTexture(GL_TEXTURE_2D, texture[1]); 99 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); 100 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); 101 glTexImage2D(GL_TEXTURE_2D, 0, 3, TextureImage[0]->sizeX, TextureImage[0]->sizeY, 102 0, GL_RGB, GL_UNSIGNED_BYTE, TextureImage[0]->data); 103 104 glBindTexture(GL_TEXTURE_2D, texture[2]); 105 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); 106 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_NEAREST); 107 gluBuild2DMipmaps(GL_TEXTURE_2D, 3, TextureImage[0]->sizeX, TextureImage[0]->sizeY, 108 GL_RGB, GL_UNSIGNED_BYTE, TextureImage[0]->data); 109 } 110 111 if (TextureImage[0]) { 112 if (TextureImage[0]->data) { 113 free(TextureImage[0]->data); 114 } 115 free(TextureImage[0]); 116 } 117 return Status; 118 } 119 /******************************************************************************************************************************************/ 120 /******************************************************************************************************************************************/ 121 GLvoid ReSizeGLScene(GLsizei width, GLsizei height) // Resize and initialize the GL window 122 { 123 if (height == 0) { // Prevent a divide by zero by 124 height = 1; // Making height equal one 125 } 126 127 glViewport(0, 0, width, height); // Reset the current viewport 128 129 /* 130 * The following lines set the screen up for a perspective view. 131 * Meaning things in the distance get smaller. This creates a realistic looking scene. 132 * The perspective is calculated with a 45 degree viewing angle based on 133 * the windows width and height. The 0.1f, 100.0f is the starting point and 134 * ending point for how deep we can draw into the screen. 135 * 136 * The projection matrix is responsible for adding perspective to our scene. 137 * glLoadIdentity() restores the selected matrix to it's original state. 138 * The modelview matrix is where our object information is stored. 139 * Lastly we reset the modelview matrix. 140 */ 141 142 glMatrixMode(GL_PROJECTION); // Select the projection matrix 143 glLoadIdentity(); // Reset the projection matrix 144 145 // Calculate the aspect ratio of the window 146 gluPerspective(45.0f, (GLfloat)width / (GLfloat)height, 0.1f, 100.0f); 147 148 glMatrixMode(GL_MODELVIEW); // Seclet the modelview matrix 149 glLoadIdentity(); // Reset the modelview matrix 150 } 151 /******************************************************************************************************************************************/ 152 /******************************************************************************************************************************************/ 153 int InitGL(GLvoid) // All setup for OpenGL goes here 154 { 155 /* 156 * Smooth shading blends colors nicely across a polygon, and smoothes out lighting. 157 */ 158 159 if (!LoadGLTextures()) { 160 return FALSE; 161 } 162 163 glEnable(GL_TEXTURE_2D); 164 glShadeModel(GL_SMOOTH); // Enables smooth shading 165 glClearColor(0.0f, 0.0f, 0.0f, 0.0f); // Black background 166 167 glClearDepth(1.0f); // Depth buffer setup 168 169 glDepthFunc(GL_LEQUAL); 170 glEnable(GL_DEPTH_TEST); 171 172 glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); 173 174 glLightfv(GL_LIGHT1, GL_AMBIENT, LightAmbient); 175 glLightfv(GL_LIGHT1, GL_DIFFUSE, LightDiffuse); 176 glLightfv(GL_LIGHT1, GL_POSITION, LightPosition); 177 178 glEnable(GL_LIGHT1); 179 180 quadratic = gluNewQuadric(); // Create a pointer to the quadratic object 181 gluQuadricNormals(quadratic, GLU_SMOOTH); // Create smooth normals 182 gluQuadricTexture(quadratic, GL_TRUE); // Create texture coords 183 184 return TRUE; 185 } 186 187 GLvoid glDrawCube() 188 { 189 glBegin(GL_QUADS); 190 // Front face 191 glNormal3f(0.0f, 0.0f, 0.0f); 192 glTexCoord2f(0.0f, 0.0f); glVertex3f(-1.0f, -1.0f, 1.0f); // Bottom Left Of The Texture and Quad 193 glTexCoord2f(1.0f, 0.0f); glVertex3f(1.0f, -1.0f, 1.0f); // Bottom Right Of The Texture and Quad 194 glTexCoord2f(1.0f, 1.0f); glVertex3f(1.0f, 1.0f, 1.0f); // Top Right Of The Texture and Quad 195 glTexCoord2f(0.0f, 1.0f); glVertex3f(-1.0f, 1.0f, 1.0f); // Top Left Of The Texture and Quad 196 // Back Face 197 glNormal3f(0.0f, 0.0f, -1.0f); 198 glTexCoord2f(1.0f, 0.0f); glVertex3f(-1.0f, -1.0f, -1.0f); // Bottom Right Of The Texture and Quad 199 glTexCoord2f(1.0f, 1.0f); glVertex3f(-1.0f, 1.0f, -1.0f); // Top Right Of The Texture and Quad 200 glTexCoord2f(0.0f, 1.0f); glVertex3f(1.0f, 1.0f, -1.0f); // Top Left Of The Texture and Quad 201 glTexCoord2f(0.0f, 0.0f); glVertex3f(1.0f, -1.0f, -1.0f); // Bottom Left Of The Texture and Quad 202 // Top Face 203 glNormal3f(0.0f, 1.0f, 0.0f); 204 glTexCoord2f(0.0f, 1.0f); glVertex3f(-1.0f, 1.0f, -1.0f); // Top Left Of The Texture and Quad 205 glTexCoord2f(0.0f, 0.0f); glVertex3f(-1.0f, 1.0f, 1.0f); // Bottom Left Of The Texture and Quad 206 glTexCoord2f(1.0f, 0.0f); glVertex3f(1.0f, 1.0f, 1.0f); // Bottom Right Of The Texture and Quad 207 glTexCoord2f(1.0f, 1.0f); glVertex3f(1.0f, 1.0f, -1.0f); // Top Right Of The Texture and Quad 208 // Bottom Face 209 glNormal3f(0.0f, -1.0f, 0.0f); 210 glTexCoord2f(1.0f, 1.0f); glVertex3f(-1.0f, -1.0f, -1.0f); // Top Right Of The Texture and Quad 211 glTexCoord2f(0.0f, 1.0f); glVertex3f(1.0f, -1.0f, -1.0f); // Top Left Of The Texture and Quad 212 glTexCoord2f(0.0f, 0.0f); glVertex3f(1.0f, -1.0f, 1.0f); // Bottom Left Of The Texture and Quad 213 glTexCoord2f(1.0f, 0.0f); glVertex3f(-1.0f, -1.0f, 1.0f); // Bottom Right Of The Texture and Quad 214 // Right face 215 glNormal3f(1.0f, 0.0f, 0.0f); 216 glTexCoord2f(1.0f, 0.0f); glVertex3f(1.0f, -1.0f, -1.0f); // Bottom Right Of The Texture and Quad 217 glTexCoord2f(1.0f, 1.0f); glVertex3f(1.0f, 1.0f, -1.0f); // Top Right Of The Texture and Quad 218 glTexCoord2f(0.0f, 1.0f); glVertex3f(1.0f, 1.0f, 1.0f); // Top Left Of The Texture and Quad 219 glTexCoord2f(0.0f, 0.0f); glVertex3f(1.0f, -1.0f, 1.0f); // Bottom Left Of The Texture and Quad 220 // Left Face 221 glNormal3f(-1.0f, 0.0f, 0.0f); 222 glTexCoord2f(0.0f, 0.0f); glVertex3f(-1.0f, -1.0f, -1.0f); // Bottom Left Of The Texture and Quad 223 glTexCoord2f(1.0f, 0.0f); glVertex3f(-1.0f, -1.0f, 1.0f); // Bottom Right Of The Texture and Quad 224 glTexCoord2f(1.0f, 1.0f); glVertex3f(-1.0f, 1.0f, 1.0f); // Top Right Of The Texture and Quad 225 glTexCoord2f(0.0f, 1.0f); glVertex3f(-1.0f, 1.0f, -1.0f); // Top Left Of The Texture and Quad 226 glEnd(); 227 } 228 229 /* 230 * For now all we will do is clear the screen to the color we previously decided on, 231 * clear the depth buffer and reset the scene. We wont draw anything yet. 232 */ 233 int DrawGLScene(GLvoid) // Here's where we do all the drawing 234 { 235 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // Clear the screen and the depth buffer 236 glLoadIdentity(); 237 238 glTranslatef(0.0f, 0.0f, z-10.0f); 239 240 glBindTexture(GL_TEXTURE_2D, texture[filter]); 241 242 glRotatef(xrot+95.0f, 1.0f, 0.0f, 0.0f); 243 glRotatef(yrot, 0.0f, 1.0f, 0.0f); 244 245 switch(object) { 246 case 0: 247 glDrawCube(); break; // Cube 248 case 1: 249 glTranslatef(0.0f, 0.0f, -1.5f); 250 gluCylinder(quadratic, 1.0f, 1.0f, 3.0f, 32, 32); break; // Cylinder 251 case 2: 252 gluDisk(quadratic, 3.0f, 3.5f, 32, 32); break; // Disk 253 case 3: 254 gluSphere(quadratic, 1.3f, 32, 32); break; // Sphere 255 case 4: 256 glTranslatef(0.0f, 0.0f, -1.5f); 257 gluCylinder(quadratic, 1.0f, 0.0f, 3.0, 32, 32); break; // Cone 258 case 5: 259 part1 += p1; 260 part2 += p2; 261 262 if (part1 > 359) { 263 p1 = 0; 264 part1 = 0; 265 p2 = 1; 266 part2 = 0; 267 } 268 if (part2 > 359) { 269 p1 = 1; 270 p2 = 0; 271 } 272 gluPartialDisk(quadratic, 0.5f, 1.5f, 32, 32, part1, part2 - part1); break; 273 } 274 275 xrot += xspeed; 276 yrot += yspeed; 277 278 return TRUE; // everthing went OK 279 } 280 /******************************************************************************************************************************************/ 281 /******************************************************************************************************************************************/ 282 /* 283 * The job of KillGLWindow() is to release the Rendering Context, 284 * the Device Context and finally the Window Handle. 285 */ 286 287 GLvoid KillGLWindow(GLvoid) // Properly kill the window 288 { 289 if (fullscreen) { // Are we in fullscreen mode 290 291 /* 292 * We use ChangeDisplaySettings(NULL,0) to return us to our original desktop. 293 * After we've switched back to the desktop we make the cursor visible again. 294 */ 295 296 ChangeDisplaySettings(NULL, 0); // if so switch back to the desktop 297 ShowCursor(TRUE); // Show mouse pointer 298 } 299 300 if (hRC) { // Do we have a rendering context 301 if (!wglMakeCurrent(NULL, NULL)) { // Are we able to release the DC and RC contexts 302 MessageBox(NULL, "Release of DC and RC failed.", "SHUTDOWN ERROR", MB_OK | MB_ICONINFORMATION); 303 } 304 305 if (!wglDeleteContext(hRC)) { // Are we able to delete the RC 306 MessageBox(NULL, "Release rendering context failed.", "SHUTDOWN ERROR", MB_OK | MB_ICONINFORMATION); 307 hRC = NULL; // Set RC to NULL 308 } 309 310 if (hDC && !ReleaseDC(hWnd, hDC)) { // Are we able to release the DC 311 MessageBox(NULL, "Release device context failed.", "SHUTDOWN ERROR", MB_OK | MB_ICONINFORMATION); 312 hDC = NULL; // Set DC to NULL 313 } 314 if (hWnd && !DestroyWindow(hWnd)) { // Are we able to destroy the window 315 MessageBox(NULL, "Could not release hWnd.", "SHUTDOWN ERROR", MB_OK | MB_ICONINFORMATION); 316 hWnd = NULL; // Set hWnd to NULL 317 } 318 319 if (!UnregisterClass("OpenGL", hInstance)) { // Are we able to unregister class 320 MessageBox(NULL, "Could not register class.", "SHUTDOWN ERROR", MB_OK | MB_ICONINFORMATION); 321 hInstance = NULL; // Set hInstance to NULL 322 } 323 } 324 /******************************************************************************************************************************************/ 325 /******************************************************************************************************************************************/ 326 gluDeleteQuadric(quadratic); 327 /******************************************************************************************************************************************/ 328 /******************************************************************************************************************************************/ 329 } 330 331 /* 332 * The next section of code creates our OpenGL Window. 333 */ 334 335 BOOL CreateGLWindow(char* title, int width, int height, int bits, bool fullscreenflag) 336 { 337 /* 338 * Find a pixel format that matches the one we want 339 */ 340 GLuint PixelFormat; // Holds the result after serching for a match 341 342 /* 343 * Before you create a window, you MUST register a Class for the window 344 */ 345 WNDCLASS wc; // Windows class structure 346 347 /* 348 * dwExStyle and dwStyle will store the Extended and normal Window Style Information. 349 */ 350 DWORD dwExStyle; // Window extend style 351 DWORD dwStyle; // Window style 352 353 RECT WindowRect; // Grabs rectangle upper left/lower right values 354 WindowRect.left = (long)0; // Set left value to 0 355 WindowRect.right = (long)width; // Set right value to requested width 356 WindowRect.top = (long)0; // Set top value to 0 357 WindowRect.bottom = (long)height; // Set bottom value to requested height 358 359 fullscreen = fullscreenflag; // Set the global fullscreen flag 360 361 /* 362 * The style CS_HREDRAW and CS_VREDRAW force the Window to redraw whenever it is resized. 363 * CS_OWNDC creates a private DC for the Window. Meaning the DC is not shared across applications. 364 * WndProc is the procedure that watches for messages in our program. 365 * No extra Window data is used so we zero the two fields. Then we set the instance. 366 * Next we set hIcon to NULL meaning we don't want an ICON in the Window, 367 * and for a mouse pointer we use the standard arrow. The background color doesn't matter 368 * (we set that in GL). We don't want a menu in this Window so we set it to NULL, 369 * and the class name can be any name you want. I'll use "OpenGL" for simplicity. 370 */ 371 hInstance = GetModuleHandle(NULL); // Grab an instance for our window 372 wc.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC; // Redraw on move, and own DC for window 373 wc.lpfnWndProc = (WNDPROC)WndProc; // WndProc handles message 374 wc.cbClsExtra = 0; // No extra window date 375 wc.cbWndExtra = 0; // No extra window date 376 wc.hInstance = hInstance; // set the instance 377 wc.hIcon = LoadIcon(NULL, IDI_WINLOGO); // Load the default icon 378 wc.hCursor = LoadCursor(NULL, IDC_ARROW); // Load the arrow pointer 379 wc.hbrBackground = NULL; // No background requried for GL 380 wc.lpszMenuName = NULL; // We don't want a menu 381 wc.lpszClassName = "OpenGL"; // set the class name 382 383 if (!RegisterClass(&wc)) { // Attempt to register the window class 384 MessageBox(NULL, "Failed to register the window class.", "ERROR", MB_OK | MB_ICONEXCLAMATION); 385 return FALSE; // Exit and return false 386 } 387 388 if (fullscreen) { // attempt fullsreen model 389 390 /* 391 T* here are a few very important things you should keep in mind when switching to full screen mode. 392 * Make sure the width and height that you use in fullscreen mode is the same as 393 * the width and height you plan to use for your window, and most importantly, 394 * set fullscreen mode BEFORE you create your window. 395 */ 396 DEVMODE dmScreenSettings; // Device mode 397 memset(&dmScreenSettings, 0, sizeof(dmScreenSettings)); // Make sure memory's cleared 398 dmScreenSettings.dmSize = sizeof(dmScreenSettings); // Size of devmode structure 399 dmScreenSettings.dmPelsWidth = width; // Select window width 400 dmScreenSettings.dmPelsHeight = height; // Select window height 401 dmScreenSettings.dmBitsPerPel = bits; // Select bits per pixel 402 dmScreenSettings.dmFields = DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT; 403 404 /* 405 * In the line below ChangeDisplaySettings tries to switch to a mode that matches 406 * what we stored in dmScreenSettings. I use the parameter CDS_FULLSCREEN when switching modes, 407 * because it's supposed to remove the start bar at the bottom of the screen, 408 * plus it doesn't move or resize the windows on your desktop when you switch to 409 * fullscreen mode and back. 410 */ 411 //Try to set selected mode and get results. Note: CDS_FULLSCREEN gets rid of start bar 412 if (ChangeDisplaySettings(&dmScreenSettings, CDS_FULLSCREEN) != DISP_CHANGE_SUCCESSFUL) { 413 //If the mode fails, offer two options. Quit or run in a window 414 if (MessageBox(NULL, "The requested fullscreen mode is not supported by\n your video card. Use" 415 "windowed mode instead?", "GL", MB_YESNO | MB_ICONEXCLAMATION) == IDYES) 416 { 417 fullscreen = FALSE; // Select windowed mode (fullscreen=FLASE) 418 } 419 else { 420 // Pop up a message box letting user know the programe is closing. 421 MessageBox(NULL, "Program will now close.", "ERROR", MB_OK | MB_ICONSTOP); 422 return FALSE; // Exit and return FALSE 423 } 424 } 425 } 426 427 if (fullscreen) { // Are we still in fullscreen mode 428 429 /* 430 * If we are still in fullscreen mode we'll set the extended style to WS_EX_APPWINDOW, 431 * which force a top level window down to the taskbar once our window is visible. 432 * For the window style we'll create a WS_POPUP window. 433 * This type of window has no border around it, making it perfect for fullscreen mode. 434 435 * Finally, we disable the mouse pointer. If your program is not interactive, 436 * it's usually nice to disable the mouse pointer when in fullscreen mode. It's up to you though. 437 */ 438 dwExStyle = WS_EX_APPWINDOW; // Window extended style 439 dwStyle = WS_POPUP; // Window style 440 ShowCursor(FALSE); // Hide mosue pointer 441 } 442 else { 443 444 /* 445 * If we're using a window instead of fullscreen mode, 446 * we'll add WS_EX_WINDOWEDGE to the extended style. This gives the window a more 3D look. 447 * For style we'll use WS_OVERLAPPEDWINDOW instead of WS_POPUP. 448 * WS_OVERLAPPEDWINDOW creates a window with a title bar, sizing border, 449 * window menu, and minimize / maximize buttons. 450 */ 451 dwExStyle = WS_EX_APPWINDOW | WS_EX_WINDOWEDGE; // Window extended style 452 dwStyle = WS_OVERLAPPEDWINDOW; // Window style 453 } 454 455 /* 456 * By using the AdjustWindowRectEx command none of our OpenGL scene will be covered up by the borders, 457 * instead, the window will be made larger to account for the pixels needed to draw the window border. 458 * In fullscreen mode, this command has no effect. 459 */ 460 AdjustWindowRectEx(&WindowRect, dwStyle, FALSE, dwExStyle); // Adjust window to true resqusted 461 462 /* 463 * WS_CLIPSIBLINGS and WS_CLIPCHILDREN are both REQUIRED for OpenGL to work properly. 464 * These styles prevent other windows from drawing over or into our OpenGL Window. 465 */ 466 if (!(hWnd = CreateWindowEx(dwExStyle, // Extended style for the window 467 "OpenGL", // Class name 468 title, // Window title 469 WS_CLIPSIBLINGS | // Requried window style 470 WS_CLIPCHILDREN | // Requried window style 471 dwStyle, // Select window style 472 0, 0, // Window position 473 WindowRect.right - WindowRect.left, // Calculate adjusted window width 474 WindowRect.bottom - WindowRect.top, // Calculate adjusted window height 475 NULL, // No parent window 476 NULL, // No menu 477 hInstance, // Instance 478 NULL))) // Don't pass anything to WM_CREATE 479 { 480 KillGLWindow(); //Reset the display 481 MessageBox(NULL, "Window creation error.", "ERROR", MB_OK | MB_ICONEXCLAMATION); 482 return FALSE; // Retrurn FALSE; 483 } 484 485 /* 486 * aside from the stencil buffer and the (slow) accumulation buffer 487 */ 488 static PIXELFORMATDESCRIPTOR pfd = // pfd tells windows how we want things to be 489 { 490 sizeof(PIXELFORMATDESCRIPTOR), // Size of this pixel format descriptor 491 1, // Version number 492 PFD_DRAW_TO_WINDOW | // Format must support window 493 PFD_SUPPORT_OPENGL | // Format must support OpenGL 494 PFD_DOUBLEBUFFER, // Must support double buffer 495 PFD_TYPE_RGBA, // Request an RGBA format 496 bits, // Select our color depth 497 0, 0, 0, 0, 0, 0, // Color bits ignored 498 0, // No alpha buffer 499 0, // shift bit ignored 500 0, // No accumulation buffer 501 0, 0, 0, 0, // Accumulation bits ignored 502 16, // 16Bits Z_Buffer (depth buffer) 503 0, // No stencil buffer 504 0, // No auxiliary buffer 505 PFD_MAIN_PLANE, // Main drawing layer 506 0, // Reserved 507 0, 0, 0 // Layer makes ignored 508 }; 509 510 if (!(hDC = GetDC(hWnd))) { // Did we get a device context 511 KillGLWindow(); // Reset the display 512 MessageBox(NULL, "Can't create a GL device context.", "ERROR", MB_OK | MB_ICONEXCLAMATION); 513 return FALSE; // Return FALSE 514 } 515 516 if (!(PixelFormat = ChoosePixelFormat(hDC, &pfd))) { // Did window find a matching pixel format 517 KillGLWindow(); // Reset the display 518 MessageBox(NULL, "Can't find a suitable pixelformat.", "ERROR", MB_OK | MB_ICONEXCLAMATION); 519 return FALSE; // Return FALSE; 520 } 521 522 if (!SetPixelFormat(hDC, PixelFormat, &pfd)) { // Are we able to set the pixel format 523 KillGLWindow(); // Reset the display 524 MessageBox(NULL, "Can't set the pixelformat.", "ERROR", MB_OK | MB_ICONEXCLAMATION); 525 return FALSE; // Return FALSE; 526 } 527 528 if (!(hRC = wglCreateContext(hDC))) { // Are we able to rendering context 529 KillGLWindow(); // Reset the display 530 MessageBox(NULL, "Can't create a GL rendering context.", "ERROR", MB_OK | MB_ICONEXCLAMATION); 531 return FALSE; // Return FASLE; 532 } 533 534 if (!wglMakeCurrent(hDC, hRC)) { // Try to activate the rendering context 535 KillGLWindow(); // Reset the display 536 MessageBox(NULL, "Can't activate the GL rendering context.", "ERROR", MB_OK | MB_ICONEXCLAMATION); 537 return FALSE; // Return FALSE 538 } 539 540 /* 541 * ReSizeGLScene passing the screen width and height to set up our perspective OpenGL screen. 542 */ 543 ShowWindow(hWnd, SW_SHOW); // Show the window 544 SetForegroundWindow(hWnd); // slightly higher priority 545 SetFocus(hWnd); // Sets keyboard focus to the window 546 ReSizeGLScene(width, height); // Set up our perspective GL screen 547 548 /* 549 * we can set up lighting, textures, and anything else that needs to be setup in InitGL(). 550 */ 551 if (!InitGL()) { // Initialize our newly created GL window 552 KillGLWindow(); // Reset the display 553 MessageBox(NULL, "Initialize Failed.", "ERROR", MB_OK | MB_ICONEXCLAMATION); 554 return FALSE; // Return FALSE 555 } 556 return TRUE; 557 } 558 559 LRESULT CALLBACK WndProc(HWND hWnd, // Handle for this window 560 UINT uMsg, // Message for this window 561 WPARAM wParam, // Additional message information 562 LPARAM lParam) // Additional message information 563 { 564 switch (uMsg) { // Check for window message 565 case WM_ACTIVATE: { // Check minimization state 566 if (!HIWORD(wParam)) { 567 active = TRUE; // Program is active 568 } 569 else { 570 active = FALSE; // Program is no longer active 571 } 572 return 0; // Return to the message loop 573 } 574 case WM_SYSCOMMAND: { // Intercept system commands 575 switch (wParam) { // Check system calls 576 case SC_SCREENSAVE: // Screensaver trying to start 577 case SC_MONITORPOWER: // Monitor trying to enter powersave 578 return 0; // Prevent form happening 579 } 580 break; // Exit 581 } 582 case WM_CLOSE: { // Did we receive a close message 583 PostQuitMessage(0); // Send a quit message 584 return 0; 585 } 586 case WM_KEYDOWN: { // Is a key being held down 587 keys[wParam] = TRUE; // if so, mark it as TRUE 588 return 0; // Jump back 589 } 590 case WM_KEYUP: { // Has a key been released 591 keys[wParam] = FALSE; // if so, mark it as FALSE 592 return 0; // Jump back 593 } 594 case WM_SIZE: { // Resize the OpenGL window 595 ReSizeGLScene(LOWORD(lParam), HIWORD(lParam)); // LoWord = width HiWord = height 596 return 0; // Jump back 597 } 598 } 599 return DefWindowProc(hWnd, uMsg, wParam, lParam); // Pass all unhandled message to DefWindwProc 600 } 601 602 int WINAPI WinMain(HINSTANCE hInstance, // Instance 603 HINSTANCE hPrevInstance, // Previous instance 604 LPSTR lpCmdLine, // Command line parameters 605 int nCmdShow) // Window show state 606 { 607 MSG msg; // Window message structure 608 BOOL done = FALSE; // Bool variable to exit loop 609 // Ask the user which screen mode they prefer 610 if (MessageBox(NULL, "Would you like to run in fullscreen mode?", 611 "Start fullscreen?", MB_YESNO | MB_ICONQUESTION) == IDNO) 612 { 613 fullscreen = FALSE; // Window mode 614 } 615 // Create our OpenGL window 616 if (!CreateGLWindow("3D Shapes", 640, 480, 16, fullscreen)) { // (Modified) 617 return 0; // Quit if window was not create 618 } 619 620 while (!done) { // Loop that runs until donw = TRUE 621 if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) { // Is there a message wating 622 if (msg.message == WM_QUIT) { // Havw we received a quit message 623 done = TRUE; // if so done = TRUE 624 } 625 else { // If not, deal with window message 626 TranslateMessage(&msg); // Translate message 627 DispatchMessage(&msg); // Dispatch message 628 } 629 } 630 else { 631 // Draw the scene. Watch for ESC key and quit message from DrawGLScene() 632 if (active) { // Program active 633 if (keys[VK_ESCAPE]) { // Was ESC pressed 634 done = TRUE; // ESC signalled a quit 635 } 636 else { // Not time to quit, update screen 637 DrawGLScene(); // Draw scene 638 SwapBuffers(hDC); // Swap buffers (double buffering) 639 } 640 } 641 /******************************************************************************************************************************************/ 642 /******************************************************************************************************************************************/ 643 if (keys[' '] && !sp) { 644 sp = TRUE; 645 object++; 646 if (object > 5) { 647 object = 0; 648 } 649 } 650 if (!keys[' ']) { 651 sp = FALSE; 652 } 653 654 if (keys['L'] && !lp) { // L key being pressed not held 655 lp = TRUE; // lp become TRUE 656 light = !light; // Toggle light TRUE/FALSE 657 658 if (!light) { 659 glDisable(GL_LIGHTING); // Disable light 660 } 661 else { 662 glEnable(GL_LIGHTING); // Enable light 663 } 664 } 665 666 if (!keys['L']) { 667 lp = FALSE; 668 } 669 if (keys['F'] && !fp) { 670 fp = TRUE; 671 filter += 1; 672 if (filter > 2) { 673 filter = 0; 674 } 675 } 676 if (!keys['F']) { 677 fp = FALSE; 678 } 679 if (keys[VK_SUBTRACT]) { //VK_PRIOR 680 z -= 0.005f; 681 } 682 if (keys[VK_ADD]) { // VK_NEXT 683 z += 0.005f; 684 } 685 if (keys[VK_UP]) { 686 xspeed -= 0.0005f; 687 } 688 if (keys[VK_DOWN]) { 689 xspeed += 0.0005f; 690 } 691 if (keys[VK_RIGHT]) { 692 yspeed += 0.0005f; 693 } 694 if (keys[VK_LEFT]) { 695 yspeed -= 0.0005f; 696 } 697 /******************************************************************************************************************************************/ 698 /******************************************************************************************************************************************/ 699 /* 700 * It allows us to press the F1 key to switch from fullscreen mode to 701 * windowed mode or windowed mode to fullscreen mode. 702 */ 703 if (keys[VK_F1]) { // Is F1 being pressed 704 keys[VK_F1] = FALSE; // If so make key FASLE 705 KillGLWindow(); // Kill our current window 706 fullscreen = !fullscreen; // Toggle fullscreen / window mode 707 //Recreate our OpenGL window(modified) 708 if (!CreateGLWindow("3D Shapes", 640, 480, 16, fullscreen)) { 709 return 0; // Quit if window was not create 710 } 711 } 712 } 713 } 714 // Shutdown 715 KillGLWindow(); // Kill the window 716 return (msg.wParam); // Exit the program 717 }
Thanks for Nehe's tutorials, this is his home.
