Win32 OpenGL标准例子

　　在VS2008的MSDN中有一个标准的OpenGL例子，记录如下：

 /*
  * Example of a Win32 OpenGL program.
  * The OpenGL code is the same as that used in
  * the X Window System sample
  */
 #include <windows.h>
 #include <GL/gl.h>
 #include <GL/glu.h>

 /* Windows globals, defines, and prototypes */
 CHAR szAppName[]="Win OpenGL";
 HWND  ghWnd;
 HDC   ghDC;
 HGLRC ghRC;

 #define SWAPBUFFERS SwapBuffers(ghDC)
 #define BLACK_INDEX     0
 #define RED_INDEX       13
 #define GREEN_INDEX     14
 #define BLUE_INDEX      16
 #define WIDTH           640
 #define HEIGHT          480

 LONG WINAPI MainWndProc (HWND, UINT, WPARAM, LPARAM);
 BOOL bSetupPixelFormat(HDC);

 /* OpenGL globals, defines, and prototypes */
 GLfloat latitude, longitude, latinc, longinc;
 GLdouble radius;

 #define GLOBE    1
 #define CYLINDER 2
 #define CONE     3

 GLvoid resize(GLsizei, GLsizei);
 GLvoid initializeGL(GLsizei, GLsizei);
 GLvoid drawScene(GLvoid);
 void polarView( GLdouble, GLdouble, GLdouble, GLdouble);

 int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
 {
     MSG        msg;
     WNDCLASS   wndclass;

     /* Register the frame class */
     wndclass.style         = ;
     wndclass.lpfnWndProc   = (WNDPROC)MainWndProc;
     wndclass.cbClsExtra    = ;
     wndclass.cbWndExtra    = ;
     wndclass.hInstance     = hInstance;
     wndclass.hIcon         = LoadIcon (hInstance, szAppName);
     wndclass.hCursor       = LoadCursor (NULL,IDC_ARROW);
     wndclass.hbrBackground = (HBRUSH)(COLOR_WINDOW+);
     wndclass.lpszMenuName  = szAppName;
     wndclass.lpszClassName = szAppName;

     if (!RegisterClass (&wndclass) )
         return FALSE;

     /* Create the frame */
     ghWnd = CreateWindow (szAppName,
                           "Generic OpenGL Sample",
                           WS_OVERLAPPEDWINDOW | WS_CLIPSIBLINGS | WS_CLIPCHILDREN,
                           CW_USEDEFAULT,
                           CW_USEDEFAULT,
                           WIDTH,
                           HEIGHT,
                           NULL,
                           NULL,
                           hInstance,
                           NULL);

     /* make sure window was created */
     if (!ghWnd)
         return FALSE;

     /* show and update main window */
     ShowWindow (ghWnd, nCmdShow);

     UpdateWindow (ghWnd);

     /* animation loop */
     while ()
     {
         /*
          *  Process all pending messages
          */

         while (PeekMessage(&msg, NULL, , , PM_NOREMOVE) == TRUE)
         {
             if (GetMessage(&msg, NULL, , ) )
             {
                 TranslateMessage(&msg);
                 DispatchMessage(&msg);
             }
             else
             {
                 return TRUE;
             }
         }
         drawScene();
         Sleep();
     }
 }

 /* main window procedure */
 LONG WINAPI MainWndProc (
     HWND    hWnd,
     UINT    uMsg,
     WPARAM  wParam,
     LPARAM  lParam)
 {
     LONG    lRet = ;
     PAINTSTRUCT    ps;
     RECT rect;

     switch (uMsg)
     {

     case WM_CREATE:
         ghDC = GetDC(hWnd);
         if (!bSetupPixelFormat(ghDC))
             PostQuitMessage ();

         ghRC = wglCreateContext(ghDC);
         wglMakeCurrent(ghDC, ghRC);
         GetClientRect(hWnd, &rect);
         initializeGL(rect.right, rect.bottom);
         break;

     case WM_PAINT:
         BeginPaint(hWnd, &ps);
         EndPaint(hWnd, &ps);
         break;

     case WM_SIZE:
         GetClientRect(hWnd, &rect);
         resize(rect.right, rect.bottom);
         break;

     case WM_CLOSE:
         if (ghRC)
             wglDeleteContext(ghRC);
         if (ghDC)
             ReleaseDC(hWnd, ghDC);
         ghRC = ;
         ghDC = ;

         DestroyWindow (hWnd);
         break;

     case WM_DESTROY:
         if (ghRC)
             wglDeleteContext(ghRC);
         if (ghDC)
             ReleaseDC(hWnd, ghDC);

         PostQuitMessage ();
         break;

     case WM_KEYDOWN:
         switch (wParam)
         {
         case VK_LEFT:
             longinc += 0.5F;
             break;
         case VK_RIGHT:
             longinc -= 0.5F;
             break;
         case VK_UP:
             latinc += 0.5F;
             break;
         case VK_DOWN:
             latinc -= 0.5F;
             break;
         }

     default:
         lRet = DefWindowProc (hWnd, uMsg, wParam, lParam);
         break;
     }

     return lRet;
 }

 BOOL bSetupPixelFormat(HDC hdc)
 {
     PIXELFORMATDESCRIPTOR pfd, *ppfd;
     int pixelformat;

     ppfd = &pfd;

     ppfd->nSize = sizeof(PIXELFORMATDESCRIPTOR);
     ppfd->nVersion = ;
     ppfd->dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL |
                     PFD_DOUBLEBUFFER;
     ppfd->dwLayerMask = PFD_MAIN_PLANE;
     ppfd->iPixelType = PFD_TYPE_COLORINDEX;
     ppfd->cColorBits = ;
     ppfd->cDepthBits = ;
     ppfd->cAccumBits = ;
     ppfd->cStencilBits = ;

     pixelformat = ChoosePixelFormat(hdc, ppfd);

     if ( (pixelformat = ChoosePixelFormat(hdc, ppfd)) ==  )
     {
         MessageBox(NULL, "ChoosePixelFormat failed", "Error", MB_OK);
         return FALSE;
     }

     if (SetPixelFormat(hdc, pixelformat, ppfd) == FALSE)
     {
         MessageBox(NULL, "SetPixelFormat failed", "Error", MB_OK);
         return FALSE;
     }

     return TRUE;
 }

 /* OpenGL code */

 GLvoid resize( GLsizei width, GLsizei height )
 {
     GLfloat aspect;

     glViewport( , , width, height );

     aspect = (GLfloat) width / height;

     glMatrixMode( GL_PROJECTION );
     glLoadIdentity();
     gluPerspective( 45.0, aspect, 3.0, 7.0 );
     glMatrixMode( GL_MODELVIEW );
 }

 GLvoid createObjects()
 {
     GLUquadricObj *quadObj;

     glNewList(GLOBE, GL_COMPILE);
     quadObj = gluNewQuadric ();
     gluQuadricDrawStyle (quadObj, GLU_LINE);
     gluSphere (quadObj, 1.5, , );
     glEndList();

     glNewList(CONE, GL_COMPILE);
     quadObj = gluNewQuadric ();
     gluQuadricDrawStyle (quadObj, GLU_FILL);
     gluQuadricNormals (quadObj, GLU_SMOOTH);
     gluCylinder(quadObj, 0.3, 0.0, 0.6, , );
     glEndList();

     glNewList(CYLINDER, GL_COMPILE);
     glPushMatrix ();
     glRotatef ((GLfloat)90.0, (GLfloat)1.0, (GLfloat)0.0, (GLfloat)0.0);
     glTranslatef ((GLfloat)0.0, (GLfloat)0.0, (GLfloat)-1.0);
     quadObj = gluNewQuadric ();
     gluQuadricDrawStyle (quadObj, GLU_FILL);
     gluQuadricNormals (quadObj, GLU_SMOOTH);
     gluCylinder (quadObj, 0.3, 0.3, 0.6, , );
     glPopMatrix ();
     glEndList();
 }

 GLvoid initializeGL(GLsizei width, GLsizei height)
 {
     GLfloat     maxObjectSize, aspect;
     GLdouble    near_plane, far_plane;

     glClearIndex( (GLfloat)BLACK_INDEX);
     glClearDepth( 1.0 );

     glEnable(GL_DEPTH_TEST);

     glMatrixMode( GL_PROJECTION );
     aspect = (GLfloat) width / height;
     gluPerspective( 45.0, aspect, 3.0, 7.0 );
     glMatrixMode( GL_MODELVIEW );

     near_plane = 3.0;
     far_plane = 7.0;
     maxObjectSize = 3.0F;
     radius = near_plane + maxObjectSize/2.0;

     latitude = 0.0F;
     longitude = 0.0F;
     latinc = 6.0F;
     longinc = 2.5F;

     createObjects();
 }

 void polarView(GLdouble radius, GLdouble twist, GLdouble latitude,
                GLdouble longitude)
 {
     glTranslated(0.0, 0.0, -radius);
     glRotated(-twist, 0.0, 0.0, 1.0);
     glRotated(-latitude, 1.0, 0.0, 0.0);
     glRotated(longitude, 0.0, 0.0, 1.0);

 }

 GLvoid drawScene(GLvoid)
 {
     glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );

     glPushMatrix();

     latitude += latinc;
     longitude += longinc;

     polarView( radius, , latitude, longitude );

     // glIndexi(RED_INDEX);
     glColor3f(,,);
     glCallList(CONE);

     // glIndexi(BLUE_INDEX);
     glColor3f(,,);
     glCallList(GLOBE);

     // glIndexi(GREEN_INDEX);
     glColor3f(,,);
     glPushMatrix();
     glTranslatef(0.8F, -0.65F, 0.0F);
     glRotatef(30.0F, 1.0F, 0.5F, 1.0F);
     glCallList(CYLINDER);
     glPopMatrix();

     glPopMatrix();

     SWAPBUFFERS;
 }