OpenGL入门笔记（二）

第一篇笔记中的OpenGL框架其实很简单，大致有如下几个步骤：

1，取得窗口的实例，然后定义窗口类

2，注册窗口类

3,创建窗口

4,描述像素格式

5，获取设备描述表

6，找到与此前我们选定的象素格式相对应的象素格式

7，设置象素格式

8，取得绘制描述表

9，激活绘制描述表

10,显示窗口

11,将屏幕的宽度和高度设置给透视OpenGL屏幕(设置视口，进行投影，模型透视）

 

   其他就是对窗口事件的处理了，尤其是重画事件(WM_PAINT等)，但只是画了一个空窗口，现在加一些代码来画简单的基本图元。：

OpenGL框架完整代码
#include <windows.h>
#include <GL\gl.h>
#include <GL\glu.h>
#include <GL\glaux.h>

HINSTANCE hInstance;//当前程序实例
HDC hDC = NULL;//设备环境
HGLRC hRC = NULL;//绘制环境
HWND  hWnd = NULL;//窗口句柄

bool keys[256];
bool active = TRUE;

LRESULT CALLBACK WndProc(HWND,UINT,WPARAM,LPARAM);


GLvoid ReSizeGLScene(GLsizei width, GLsizei height)        // Resize And Initialize The GL Window
{
    if (height==0)                                        // Prevent A Divide By Zero By
    {
        height=1;                                        // Making Height Equal One
    }

    glViewport(0,0,width,height);                        // Reset The Current Viewport

    glMatrixMode(GL_PROJECTION);                        // Select The Projection Matrix
    glLoadIdentity();                                    // Reset The Projection Matrix

    // Calculate The Aspect Ratio Of The Window
    gluPerspective(45.0f,(GLfloat)width/(GLfloat)height,0.1f,100.0f);

    glMatrixMode(GL_MODELVIEW);                            // Select The Modelview Matrix
    glLoadIdentity();                                    // Reset The Modelview Matrix
}


int InitGL(GLvoid)                                        // All Setup For OpenGL Goes Here
{
    glShadeModel(GL_SMOOTH);                            // Enable Smooth Shading
    glClearColor(0.3f,0.0f, 0.5f, 0.5f);                // Black Background
    glClearDepth(1.0f);                                    // Depth Buffer Setup
    glEnable(GL_DEPTH_TEST);                            // Enables Depth Testing
    glDepthFunc(GL_LEQUAL);                                // The Type Of Depth Testing To Do
    glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);    // Really Nice Perspective Calculations
    return TRUE;                                        // Initialization Went OK
}

int DrawGLScene(GLvoid)                                    // Here's Where We Do All The Drawing
{
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);    // Clear Screen And Depth Buffer
    glLoadIdentity();
    
    glTranslatef(-1.5f,0.0f,-6.0f);                        // Move Left 1.5 Units And Into The Screen 6.0
    glBegin(GL_TRIANGLES);                                // Drawing Using Triangles
        glVertex3f( 0.0f, 1.0f, 0.0f);                    // Top
        glVertex3f(-1.0f,-1.0f, 0.0f);                    // Bottom Left
        glVertex3f( 1.0f,-1.0f, 0.0f);                    // Bottom Right

    glEnd();                                            // Finished Drawing The Triangle
    glTranslatef(3.0f,0.0f,0.0f);                        // Move Right 3 Units
    glBegin(GL_QUADS);                                    // Draw A Quad
        glVertex3f(-1.0f, 1.0f, 0.0f);                    // Top Left
        glVertex3f( 1.0f, 1.0f, 0.0f);                    // Top Right
        glVertex3f( 1.0f,-1.0f, 0.0f);                    // Bottom Right
        glVertex3f(-1.0f,-1.0f, 0.0f);                    // Bottom Left
    glEnd();                                            // Done Drawing The Quad// Reset The Current Modelview Matrix
    return TRUE;                                        // Everything Went OK
}


GLvoid KillGLWindow(GLvoid)                                // Properly Kill The Window
{
    if (hRC)                                            // Do We Have A Rendering Context?
    {
        if (!wglMakeCurrent(NULL,NULL))                    // Are We Able To Release The DC And RC Contexts?
        {
            MessageBox(NULL,"Release Of DC And RC Failed.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION);
        }

        if (!wglDeleteContext(hRC))                        // Are We Able To Delete The RC?
        {
            MessageBox(NULL,"Release Rendering Context Failed.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION);
        }
        hRC=NULL;                                        // Set RC To NULL
    }

    if (hDC && !ReleaseDC(hWnd,hDC))                    // Are We Able To Release The DC
    {
        MessageBox(NULL,"Release Device Context Failed.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION);
        hDC=NULL;                                        // Set DC To NULL
    }

    if (hWnd && !DestroyWindow(hWnd))                    // Are We Able To Destroy The Window?
    {
        MessageBox(NULL,"Could Not Release hWnd.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION);
        hWnd=NULL;                                        // Set hWnd To NULL
    }

    if (!UnregisterClass("OpenGL",hInstance))            // Are We Able To Unregister Class
    {
        MessageBox(NULL,"Could Not Unregister Class.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION);
        hInstance=NULL;                                    // Set hInstance To NULL
    }
}

BOOL CreateGLWindow(char* title,int width,int height,int bits)
{/**//* title:窗口标题; width:窗口宽度; height:窗口高度; bits:每象素所选的色彩深度*/
    GLuint PixelFormat;
    WNDCLASS wc;
    DWORD dwExStyle;
    DWORD dwStyle;
    RECT WindowRect;
    WindowRect.left = (long)0;
    WindowRect.right = (long)width;
    WindowRect.top = (long)0;
    WindowRect.bottom = (long)height;

    hInstance = GetModuleHandle(NULL);
    wc.style = CS_HREDRAW|CS_VREDRAW|CS_OWNDC;
    wc.lpfnWndProc = (WNDPROC)WndProc;
    wc.cbClsExtra = 0;
    wc.cbWndExtra = 0;
    wc.hInstance = hInstance;
    wc.hIcon = LoadIcon(NULL,IDI_WINLOGO);
    wc.hCursor = LoadCursor(NULL,IDC_ARROW);
    wc.hbrBackground = NULL;
    wc.lpszMenuName = NULL;
    wc.lpszClassName = "OpenGL";
    
    if(!RegisterClass(&wc))
    {
        MessageBox(NULL,"无法注册窗口类!!!","ERROR",MB_OK|MB_ICONEXCLAMATION);
        return FALSE;
    }
    
    dwExStyle = WS_EX_APPWINDOW | WS_EX_WINDOWEDGE;
    dwStyle = WS_OVERLAPPEDWINDOW;

    AdjustWindowRectEx(&WindowRect,dwExStyle,FALSE,dwStyle);
    
    if(!(hWnd = CreateWindowEx(dwExStyle,                            // Extended Style For The Window
                                "OpenGL",                            // Class Name
                                title,                                // Window Title
                                dwStyle |                            // Defined Window Style
                                WS_CLIPSIBLINGS |                    // Required Window Style
                                WS_CLIPCHILDREN,                    // Required Window Style
                                0, 0,                                // Window Position
                                WindowRect.right-WindowRect.left,    // Calculate Window Width
                                WindowRect.bottom-WindowRect.top,    // Calculate Window Height
                                NULL,                                // No Parent Window
                                NULL,                                // No Menu
                                hInstance,                            // Instance
                                NULL)))                                // Dont Pass Anything To WM_CREATE
    {
        MessageBox(NULL,"创建窗口失败","ERROR",MB_OK|MB_ICONEXCLAMATION);
        return FALSE;
    }
    

        static    PIXELFORMATDESCRIPTOR pfd=                // pfd Tells Windows How We Want Things To Be
    {
        sizeof(PIXELFORMATDESCRIPTOR),                // Size Of This Pixel Format Descriptor
        1,                                            // Version Number
        PFD_DRAW_TO_WINDOW |                        // Format Must Support Window
        PFD_SUPPORT_OPENGL |                        // Format Must Support OpenGL
        PFD_DOUBLEBUFFER,                            // Must Support Double Buffering
        PFD_TYPE_RGBA,                                // Request An RGBA Format
        bits,                                        // Select Our Color Depth
        0, 0, 0, 0, 0, 0,                            // Color Bits Ignored
        0,                                            // No Alpha Buffer
        0,                                            // Shift Bit Ignored
        0,                                            // No Accumulation Buffer
        0, 0, 0, 0,                                    // Accumulation Bits Ignored
        16,                                            // 16Bit Z-Buffer (Depth Buffer)  
        0,                                            // No Stencil Buffer
        0,                                            // No Auxiliary Buffer
        PFD_MAIN_PLANE,                                // Main Drawing Layer
        0,                                            // Reserved
        0, 0, 0                                        // Layer Masks Ignored
    };
    
    if(!(hDC = GetDC(hWnd)))
    {
        KillGLWindow();        
        MessageBox(NULL,"无法创建GL设备环境.","ERROR",MB_OK|MB_ICONEXCLAMATION);
        return FALSE;    
    }

    if (!(PixelFormat=ChoosePixelFormat(hDC,&pfd)))    // Did Windows Find A Matching Pixel Format?
    {
        KillGLWindow();                                // Reset The Display
        MessageBox(NULL,"无法找到合适的像素格式.","ERROR",MB_OK|MB_ICONEXCLAMATION);
        return FALSE;                                // Return FALSE
    }


    if(!SetPixelFormat(hDC,PixelFormat,&pfd))        // Are We Able To Set The Pixel Format?
    {
        KillGLWindow();                                // Reset The Display
        MessageBox(NULL,"像素格式无法设置.","ERROR",MB_OK|MB_ICONEXCLAMATION);
        return FALSE;                                // Return FALSE
    }

    if (!(hRC=wglCreateContext(hDC)))                // Are We Able To Get A Rendering Context?
    {
        KillGLWindow();                                // Reset The Display
        MessageBox(NULL,"无法创建一个绘制环境.","ERROR",MB_OK|MB_ICONEXCLAMATION);
        return FALSE;                                // Return FALSE
    }

    if(!wglMakeCurrent(hDC,hRC))                    // Try To Activate The Rendering Context
    {
        KillGLWindow();                                // Reset The Display
        MessageBox(NULL,"无法激活绘制环境.","ERROR",MB_OK|MB_ICONEXCLAMATION);
        return FALSE;                                // Return FALSE
    }

    ShowWindow(hWnd,SW_SHOW);
    SetForegroundWindow(hWnd);
    SetFocus(hWnd);

    
    ReSizeGLScene(width, height);
    if(!InitGL())//初始化新建的GL窗口
    {
        KillGLWindow();//重置显示区
        MessageBox(NULL,"Initialization Failed.","ERROR",MB_OK|MB_ICONEXCLAMATION);
        return FALSE;//返回 FALSE
    }

    return TRUE;


}

LRESULT CALLBACK WndProc(    HWND    hWnd,            // Handle For This Window
                            UINT    uMsg,            // Message For This Window
                            WPARAM    wParam,            // Additional Message Information
                            LPARAM    lParam)            // Additional Message Information
{
    switch (uMsg)                                    // Check For Windows Messages
    {
        case WM_ACTIVATE:                            // Watch For Window Activate Message
        {
            if (!HIWORD(wParam))                    // Check Minimization State
            {
                active=TRUE;                        // Program Is Active
            }
            else
            {
                active=FALSE;                        // Program Is No Longer Active
            }

            return 0;                                // Return To The Message Loop
        }

        case WM_SYSCOMMAND:                            // Intercept System Commands
        {
            switch (wParam)                            // Check System Calls
            {
                case SC_SCREENSAVE:                    // Screensaver Trying To Start?
                case SC_MONITORPOWER:                // Monitor Trying To Enter Powersave?
                return 0;                            // Prevent From Happening
            }
            break;                                    // Exit
        }

        case WM_CLOSE:                                // Did We Receive A Close Message?
        {
            PostQuitMessage(0);                        // Send A Quit Message
            return 0;                                // Jump Back
        }

        case WM_KEYDOWN:                            // Is A Key Being Held Down?
        {
            keys[wParam] = TRUE;                    // If So, Mark It As TRUE
            return 0;                                // Jump Back
        }

        case WM_KEYUP:                                // Has A Key Been Released?
        {
            keys[wParam] = FALSE;                    // If So, Mark It As FALSE
            return 0;                                // Jump Back
        }

        case WM_SIZE:                                // Resize The OpenGL Window
        {
            ReSizeGLScene(LOWORD(lParam),HIWORD(lParam));  // LoWord=Width, HiWord=Height
            return 0;                                // Jump Back
        }
    }

    // Pass All Unhandled Messages To DefWindowProc
    return DefWindowProc(hWnd,uMsg,wParam,lParam);
}

int WINAPI WinMain(HINSTANCE hInstance,HINSTANCE hPrevInstance,LPSTR lpCmdLine,int nShowCmd)
{
    MSG        msg;                                    // Windows Message Structure
    BOOL    done=FALSE;                                // Bool Variable To Exit Loop


    // Create Our OpenGL Window
    if (!CreateGLWindow("NeHe's OpenGL Framework",640,480,16))
    {
        return 0;                                    // Quit If Window Was Not Created
    }

    while(!done)                                    // Loop That Runs While done=FALSE
    {
        if (PeekMessage(&msg,NULL,0,0,PM_REMOVE))    // Is There A Message Waiting?
        {
            if (msg.message==WM_QUIT)                // Have We Received A Quit Message?
            {
                done=TRUE;                            // If So done=TRUE
            }
            else                                    // If Not, Deal With Window Messages
            {
                TranslateMessage(&msg);                // Translate The Message
                DispatchMessage(&msg);                // Dispatch The Message
            }
        }
        else                                        // If There Are No Messages
        {
            // Draw The Scene.  Watch For ESC Key And Quit Messages From DrawGLScene()
            if (active)                                // Program Active?
            {
                if (keys[VK_ESCAPE])                // Was ESC Pressed?
                {
                    done=TRUE;                        // ESC Signalled A Quit
                }
                else                                // Not Time To Quit, Update Screen
                {
                    DrawGLScene();                    // Draw The Scene
                    SwapBuffers(hDC);                // Swap Buffers (Double Buffering)
                }
            }
        }
    }

    // Shutdown
    KillGLWindow();                                    // Kill The Window
    return (msg.wParam);                            // Exit The Program

    
}

其中最核心的代码是：

int DrawGLScene(GLvoid)                                    // Here's Where We Do All The Drawing
{
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);    // Clear Screen And Depth Buffer
    glLoadIdentity();
    
    glTranslatef(-1.5f,0.0f,-6.0f);                        // Move Left 1.5 Units And Into The Screen 6.0
    glBegin(GL_TRIANGLES);                                // Drawing Using Triangles
        glVertex3f( 0.0f, 1.0f, 0.0f);                    // Top
        glVertex3f(-1.0f,-1.0f, 0.0f);                    // Bottom Left
        glVertex3f( 1.0f,-1.0f, 0.0f);                    // Bottom Right

    glEnd();                                            // Finished Drawing The Triangle
    glTranslatef(3.0f,0.0f,0.0f);                        // Move Right 3 Units
    glBegin(GL_QUADS);                                    // Draw A Quad
        glVertex3f(-1.0f, 1.0f, 0.0f);                    // Top Left
        glVertex3f( 1.0f, 1.0f, 0.0f);                    // Top Right
        glVertex3f( 1.0f,-1.0f, 0.0f);                    // Bottom Right
        glVertex3f(-1.0f,-1.0f, 0.0f);                    // Bottom Left
    glEnd();                                            // Done Drawing The Quad// Reset The Current Modelview Matrix
    return TRUE;                                        // Everything Went OK
}

按照我的个人理解，，就好比照相机拍照一样，被拍的物体移动和照相机反方向移动可以得到相同的效果(使得成像的大小变化)，这里的glTranslatef是用来进行造型变换的（类似移动物体却不移动照相机）。通过改变平移值的大小可以明显看出平移的效果。

 

这里要注意的是存在两种不同的坐标变换方式，glTranslatef(x,y,z)中的x，y，z是相对与当前所在点的位移，但glVertex(x,y,z)是相对于glTranslatef(x,y,z)移动后的新原点的位移。因而这里可以认为glTranslate移动的是坐标原点，glVertex中的点是相对最新的坐标原点的坐标值。

 

当调用glLoadIdentity()之后，实际上将当前点移到了屏幕中心，X坐标轴从左至右，Y坐标轴从下至上，Z坐标轴从里至外。OpenGL屏幕中心的坐标值是X和Y轴上的0.0f点。中心左面的坐标值是负值，右面是正值。移向屏幕顶端是正值，移向屏幕底端是负值。移入屏幕深处是负值，移出屏幕则是正值。

　　 glTranslatef(x, y, z)沿着X，Y和Z轴移动。根据前面的次序，下面的代码沿着X轴左移1.5个单位，Y轴不动(0.0f)，最后移入屏幕6.0f个单位。注意在glTranslatef(x, y, z)中当移动的时候，并不是相对屏幕中心移动，而是相对与当前所在的屏幕位置。

　　　　　　 glTranslatef(-1.5f,0.0f,-6.0f); // 左移1.5单位，并移入屏幕6.0

　　 现在我们已经移到了屏幕的左半部分，并且将视图推入屏幕背后足够的距离以便我们可以看见全部的场景－创建三角形。

 

在屏幕的左半部分画完三角形后，我们要移到右半部分来画正方形。为此要再次使用glTranslate。这次右移，所以X坐标值为正值。因为前面左移了1.5个单位，这次要先向右移回屏幕中心（1.5个单位），再向右移动1.5个单位。总共要向右移3.0个单位。

　　　　　　 glTranslatef(3.0f,0.0f,0.0f);　　　　　　　　　　　// 右移3单位

   还有一点值得特别注意：我们使用顺时针次序来画正方形－左上－右上－右下－左下。采用顺时针绘制的是对象的后表面。这就是说我们所看见的是正方形的背面。逆时针画出来的正方形才是正面朝着我们的。