main.cpp

一本关于OPenGL的很好的电子书

// Render
// desc: handles drawing of scene
void Render()
{
     static float zpos = 0.0f;     // the position along the z-axis
     static bool zDir = false;     // false = negative, true = positive

     // move text forward and backward
     if (zDir)
          zpos += 0.08f;
     else
          zpos -= 0.08f;

     if (zpos > 30.0f)
          zDir = false;
     if (zpos < -30.0f)
          zDir = true;

     // clear screen and depth buffer
     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);         
     glLoadIdentity();

     glPushMatrix();
          glColor3f(0.5f, 0.5f, 0.5f);
          glTranslatef(0.0f, 3.0f, -10.0f);
          PrintString(listBase, "Hear me click?");
     glPopMatrix();

     // move the text along the z-axis
     glTranslatef(0.0f, 0.0f, zpos);

     // update sound source position to reflect text
     Set3DSoundPos(ds3DBuffer, 0.0, 0.0, zpos);

     // set color to blue-ish color
     glColor3f(0.3f, 0.4f, 0.8f);

     // display the text
     glPushMatrix();
          glTranslatef(0.0f, -1.0f, 0.0f);
          if (zDir)
               PrintString(listBase, "Coming at you!");
          else
               PrintString(listBase, "Moving away from you!");
     glPopMatrix();

     // yellow-green color
     glColor3f(0.6f, 0.8f, 0.5f);

     // display text
     glPushMatrix();
          glTranslatef(0.0f, -3.0f, 0.0f);
          PrintString(listBase, "ESC - Quit");
     glPopMatrix();

     SwapBuffers(g_HDC);           // bring backbuffer to foreground
}

// function to set the pixel format for the device context
void SetupPixelFormat(HDC hDC)
{
     int nPixelFormat;                       // our pixel format index

     static PIXELFORMATDESCRIPTOR pfd = {
          sizeof(PIXELFORMATDESCRIPTOR),     // size of structure
          1,                                 // default version
          PFD_DRAW_TO_WINDOW |               // window drawing support
          PFD_SUPPORT_OPENGL |               // OpenGL support
          PFD_DOUBLEBUFFER,                  // double buffering support
          PFD_TYPE_RGBA,                     // RGBA color mode
          32,                                // 32 bit color mode
          0, 0, 0, 0, 0, 0,                  // ignore color bits, non-palettized mode
          0,                                 // no alpha buffer
          0,                                 // ignore shift bit
          0,                                 // no accumulation buffer
          0, 0, 0, 0,                        // ignore accumulation bits
          16,                                // 16 bit z-buffer size
          0,                                 // no stencil buffer
          0,                                 // no auxiliary buffer
          PFD_MAIN_PLANE,                    // main drawing plane
          0,                                 // reserved
          0, 0, 0 };                         // layer masks ignored

     nPixelFormat = ChoosePixelFormat(hDC, &pfd); // choose best matching pixel format

     SetPixelFormat(hDC, nPixelFormat, &pfd);     // set pixel format to device context
}

// the Windows Procedure event handler
LRESULT CALLBACK WndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
     static HGLRC hRC;                       // rendering context
     static HDC hDC;                         // device context
     int width, height;                      // window width and height

     switch(message)
     {
          case WM_CREATE:                    // window is being created

               hDC = GetDC(hwnd);            // get current window's device context
               g_HDC = hDC;
               SetupPixelFormat(hDC);        // call our pixel format setup function

               // create rendering context and make it current
               hRC = wglCreateContext(hDC);
               wglMakeCurrent(hDC, hRC);

               return 0;
               break;

          case WM_CLOSE:                     // windows is closing

               // deselect rendering context and delete it
               wglMakeCurrent(hDC, NULL);
               wglDeleteContext(hRC);

               // send WM_QUIT to message queue
               PostQuitMessage(0);

               return 0;
               break;

          case WM_SIZE:
               height = HIWORD(lParam);      // retrieve width and height
               width = LOWORD(lParam);

               if (height==0)                // don't want a divide by zero
               {
                    height=1;                     
               }

               glViewport(0, 0, width, height);   // reset the viewport to new dimensions
               glMatrixMode(GL_PROJECTION);       // set projection matrix current matrix
               glLoadIdentity();                  // reset projection matrix

               // calculate aspect ratio of window
               gluPerspective(54.0f,(GLfloat)width/(GLfloat)height,1.0f,1000.0f);

               glMatrixMode(GL_MODELVIEW);        // set modelview matrix
               glLoadIdentity();                  // reset modelview matrix

               return 0;
               break;

          case WM_KEYDOWN:                        // is a key pressed?
               keyPressed[wParam] = true;
               return 0;
               break;

          case WM_KEYUP:
               keyPressed[wParam] = false;
               return 0;
               break;

          default:
               break;
     }

     return (DefWindowProc(hwnd, message, wParam, lParam));
}

// the main windows entry point
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nShowCmd)
{
     WNDCLASSEX windowClass;  // window class
     HWND    hwnd;            // window handle
     MSG          msg;        // message
     bool    done;            // flag saying when our app is complete
     DWORD        dwExStyle;  // Window Extended Style
     DWORD        dwStyle;    // Window Style
     RECT    windowRect;

     // screen resolution
     int width = 800;
     int height = 600;
     int bits = 16;

     //fullScreen = TRUE;

     windowRect.left=(long)0;                          // Set Left Value To 0
     windowRect.right=(long)width;                     // Set Right Value To Requested Width
     windowRect.top=(long)0;                           // Set Top Value To 0
     windowRect.bottom=(long)height;                   // Set Bottom Value To Requested Height

     // fill out the window class structure
     windowClass.cbSize            = sizeof(WNDCLASSEX);
     windowClass.style             = CS_HREDRAW | CS_VREDRAW;
     windowClass.lpfnWndProc       = WndProc;
     windowClass.cbClsExtra        = 0;
     windowClass.cbWndExtra        = 0;
     windowClass.hInstance         = hInstance;
     windowClass.hIcon             = LoadIcon(NULL, IDI_APPLICATION); // default icon
     windowClass.hCursor           = LoadCursor(NULL, IDC_ARROW);     // default arrow
     windowClass.hbrBackground     = NULL;                            // don't need background
     windowClass.lpszMenuName = NULL;                                 // no menu
     windowClass.lpszClassName     = "MyClass";
     windowClass.hIconSm           = LoadIcon(NULL, IDI_WINLOGO);     // windows logo small icon

     // register the windows class
     if (!RegisterClassEx(&windowClass))
          return 0;

     if (fullScreen)                                        // fullscreen?
     {
          DEVMODE dmScreenSettings;                         // device mode
          memset(&dmScreenSettings,0,sizeof(dmScreenSettings));
          dmScreenSettings.dmSize = sizeof(dmScreenSettings);    
          dmScreenSettings.dmPelsWidth = width;        // screen width
          dmScreenSettings.dmPelsHeight = height;      // screen height
          dmScreenSettings.dmBitsPerPel = bits;        // bits per pixel
          dmScreenSettings.dmFields=DM_BITSPERPEL|DM_PELSWIDTH|DM_PELSHEIGHT;

          // 
          if (ChangeDisplaySettings(&dmScreenSettings, CDS_FULLSCREEN) != DISP_CHANGE_SUCCESSFUL)
          {
               // setting display mode failed, switch to windowed
               MessageBox(NULL, "Display mode failed", NULL, MB_OK);
               fullScreen=FALSE;   
          }
     }

     if (fullScreen)                                   // Are We Still In Fullscreen Mode?
     {
          dwExStyle=WS_EX_APPWINDOW;                   // Window Extended Style
          dwStyle=WS_POPUP;                            // Windows Style
          ShowCursor(FALSE);                           // Hide Mouse Pointer
     }
     else
     {
          dwExStyle=WS_EX_APPWINDOW | WS_EX_WINDOWEDGE;     // Window Extended Style
          dwStyle=WS_OVERLAPPEDWINDOW;                      // Windows Style
     }

     AdjustWindowRectEx(&windowRect, dwStyle, FALSE, dwExStyle);      // Adjust Window To True Requested Size

     // class registered, so now create our window
     hwnd = CreateWindowEx(NULL,                                           // extended style
                                "MyClass",                                 // class name
                                "DirectX Audio Example 2 - 3D Effects",// app name
                                dwStyle | WS_CLIPCHILDREN |
                                WS_CLIPSIBLINGS,
                                0, 0,                                 // x,y coordinate
                                windowRect.right - windowRect.left,
                                windowRect.bottom - windowRect.top,   // width, height
                                NULL,                                 // handle to parent
                                NULL,                                 // handle to menu
                                hInstance,                            // application instance
                                NULL);                                // no extra params

     // check if window creation failed (hwnd would equal NULL)
     if (!hwnd)
          return 0;

     // initialize COM
     if (FAILED(CoInitialize(NULL)))
          return 0;                     // if unable to initialize COM, exit

     // initialize DirectX Audio
     if (!InitDirectXAudio(hwnd))
          return 0;

     // load the segment
     if (!LoadSegment(hwnd, "start.wav"))
          return 0;

     // set the 3D sound parameters
     Set3DSoundParams(0.0, 0.1f, 1.0f, 100.0f);

     // start the segment (infinitely loops)
     PlaySegment(dmusicPerformance, dmusicSegment);

     ShowWindow(hwnd, SW_SHOW);              // display the window
     UpdateWindow(hwnd);                     // update the window

     done = false;                           // intialize the loop condition variable
     Initialize();                           // initialize OpenGL

     // main message loop
     while (!done)
     {
          PeekMessage(&msg, hwnd, NULL, NULL, PM_REMOVE);

          if (msg.message == WM_QUIT)        // do we receive a WM_QUIT message?
          {
               done = true;                  // if so, time to quit the application
          }
          else
          {
               // exit the app
               if (keyPressed[VK_ESCAPE])
                    done = true;
               else
               {
                    Render();                // render a frame

                    TranslateMessage(&msg);  // translate and dispatch to event queue
                    DispatchMessage(&msg);
               }
          }
     }

     // close down the performance
     CloseDown(dmusicPerformance);

     // clean up application
     CleanUp();

     // close down COM
     CoUninitialize();

     if (fullScreen)
     {
          ChangeDisplaySettings(NULL,0);          // If So Switch Back To The Desktop
          ShowCursor(TRUE);                       // Show Mouse Pointer
     }

     return msg.wParam;
}