一个面向对象的OPENGL程序框架

最近在看徐明亮的<<opengl游戏编程>>,发觉这本书在国人的著作中尚属不错,在此先要感谢作者。

这个框摘自<<opengl游戏编程>>,我修改了部分代码,使之能在VS2005中顺利运行。

代码清单:

1. //========================================================
2. /**
3. *  @file  GLWindows.h
4. *
5. *  项目描述： OpenGL程序框架演示
6. *  文件描述:  程序窗口类  
7. *  适用平台： Windows98/2000/NT/XP
8. *  
9. *
10. */     
11. //========================================================
12. #ifndef __GLWINDOW_H__
13. #define __GLWINDOW_H__
15. #include <windows.h>                                             /**< 包含windows.h头文件 */
17. #pragma warning(disable: 4311)                                  /**< 禁止编译器出现类型转换的警告 */
18. #pragma warning(disable: 4312)
19. #pragma warning(disable: 4244)
21. /** windows窗口类 */
22. class GLWindow                                                          
23. {
24. public:
25. /** 重要的窗口函数  */
26.     
27.     /** 构造函数 */
28.     GLWindow();
29.     /** 创建windows窗口 */
30.     bool    Create(const char * window_title, const char * class_name, bool fullscreen,HINSTANCE h_instance, LPVOID lpParam);
31.     /** 删除OpenGL窗口 */
32.     void    Destroy();
33.     /** 改变窗口的显示设置 */
34.     bool    ChangeScreenSetting();
35.     /** 当窗口大小改变时，通知OpenGL调整大小 */
36.     void    ReshapeGL();
37.     /** Swap Buffers (Double Buffering) */
38.     void    SwapBuffers() { ::SwapBuffers(m_hDC); }
40. /** 下面函数为设置/返回窗口类的属性 */
41.     
42.     /** 设置窗口左上角的位置 */
43.     void    SetPosX(int x);
44.     void    SetPosX(unsigned short x) { SetPosX((signed short)x); }     
45.     void    SetPosY(int y);
46.     void    SetPosY(unsigned short y) { SetPosY((signed short)y); }     
47.     /** 返回窗口的大小 */
48.     int     GetWidth();
49.     int     GetHeight();
50.     /** 设置窗口的大小 */
51.     void    SetWidth(int width);
52.     void    SetHeight(int height);
53.     /** 返回窗口左上角的位置 */
54.     int     GetPosX();
55.     int     GetPosY();
56.     /** 设置窗口的颜色位深 */
57.     void    SetHiColor()    { m_BitsPerPixel = 16; }
58.     void    SetTrueColor()  { m_BitsPerPixel = 32; }
59.     //void  SetFullScreen(bool mode)    { m_IsFullScreen = mode; }
60.     //bool  GetFullScreen() { return m_IsFullScreen; }
61.     /** 重载运算符，可以让GL_Window m_Window声明后的m_Window作为窗口句柄使用 */
62.     operator HWND() { return m_hWnd; }
64. private:
65.     HWND    m_hWnd;                                                     /**< 窗口句柄 */
66.     HDC     m_hDC;                                                      /**< 设备描述表 */
67.     HGLRC   m_hRC;                                                      /**< OpenGL渲染描述表 */
69.     int     m_WindowPosX;                                               /**< 窗口的左上角的X位置 */
70.     int     m_WindowPosY;                                               /**< 窗口的左上角的Y位置 */
71.     int     m_WindowWidth;                                              /**< 窗口的宽度 */
72.     int     m_WindowHeight;                                             /**< 窗口的高度 */
73.     int     m_ScreenWidth;                                              /**< 全屏的宽度 */
74.     int     m_ScreenHeight;                                             /**< 全屏的高度 */
75.     int     m_BitsPerPixel;                                             /**< 颜色位深 */
76.     bool    m_IsFullScreen;                                             /**< 是否全屏 */
77. };
79. #endif  // __GLWINDOW_H__

1. //========================================================
2. /**
3. *  @file  GLWindows.h
4. *
5. *  项目描述： OpenGL程序框架演示
6. *  文件描述:  程序窗口类 
7. *  适用平台： Windows98/2000/NT/XP
8. *  
9. *
10. */     
11. //========================================================
12. #include "GLWindow.h"                                                   /**< 包含GLwindows.h头文件 */
14. #include <gl/gl.h>                                                      /**< 包含OpenGL头文件 */
15. #include <gl/glu.h>                                                     
18. /** 构造函数 */
19. GLWindow::GLWindow()                                                    
20. {
21.     m_WindowPosX    = 0;                                                /**< 窗口的左上角的X位置 */
22.     m_WindowPosY    = 0;                                                /**< 窗口的左上角的Y位置 */
23.     m_WindowWidth   = 640;                                              /**< 窗口的宽度 */
24.     m_WindowHeight  = 480;                                              /**< 窗口的高度 */
25.     m_ScreenWidth   = 1024;                                             /**< 全屏的宽度 */
26.     m_ScreenHeight  = 768;                                              /**< 全屏的高度 */
27.     m_BitsPerPixel  = 16;                                               /**< 颜色位深 */
28.     m_IsFullScreen  = false;                                            /**< 不使用全屏 */
30.     m_hWnd = 0;
31.     m_hDC = 0;
32.     m_hRC = 0;
33. }
35. /** 返回窗口的大小 */
36. int GLWindow::GetWidth()
37. {
38.     if (m_IsFullScreen == true)
39.     {
40.         return m_ScreenWidth;
41.     }
42.     else
43.     {
44.         return m_WindowWidth;
45.     }
46. }
47. int GLWindow::GetHeight()
48. {
49.     if (m_IsFullScreen == true)
50.     {
51.         return m_ScreenHeight;
52.     }
53.     else
54.     {
55.         return m_WindowHeight;
56.     }
57. }
59. /** 设置窗口的大小 */
60. void GLWindow::SetWidth(int width)
61. {
62.     if (m_IsFullScreen == true)
63.     {
64.         m_ScreenWidth = width;
65.     }
66.     else
67.     {
68.         m_WindowWidth = width;
69.     }
70. }
71. void GLWindow::SetHeight(int height)
72. {
73.     if (m_IsFullScreen == true)
74.     {
75.         m_ScreenHeight = height;
76.     }
77.     else
78.     {
79.         m_WindowHeight = height;
80.     }
81. }
83. /** 返回窗口左上角的位置 */
84. int GLWindow::GetPosX()
85. {
86.     if (m_IsFullScreen == false)
87.     {
88.         return m_WindowPosX;
89.     }
90.     return 0;
91. }
92. int GLWindow::GetPosY()
93. {
94.     if (m_IsFullScreen == false)
95.     {
96.         return m_WindowPosY;
97.     }
98.     return 0;
99. }
101. /** 设置窗口左上角的位置 */
102. void GLWindow::SetPosX(int x)
103. {
104.     if (m_IsFullScreen == false)
105.     {
106.         m_WindowPosX = x;
107.     }
108. }
109. void GLWindow::SetPosY(int y)
110. {
111.     if (m_IsFullScreen == false)
112.     {
113.         m_WindowPosY = y;
114.     }
115. }
117. /** 当窗口大小改变时，通知OpenGL调整大小 */
118. void GLWindow::ReshapeGL()
119. {
120.     GLsizei width = GetWidth();
121.     GLsizei height = GetHeight();
122.     glViewport(0, 0, width, height);                                    /**< 重新设置视口 */
123.     glMatrixMode(GL_PROJECTION);                                    
124.     glLoadIdentity();                                                   
125.     gluPerspective(45.0f, (GLfloat)width / (GLfloat)height, 1.0f, 100.0f);  
126.     glMatrixMode(GL_MODELVIEW);                                         
127.     glLoadIdentity();                                                   
128. }
130. /** 改变窗口的显示设置 */
131. bool GLWindow::ChangeScreenSetting()
132. {
133.     DEVMODE dmScreenSettings;                                           /**< 设备模式 */
134.     ZeroMemory(&dmScreenSettings, sizeof(DEVMODE));                     /**< 清零结构 */
135.     dmScreenSettings.dmSize         = sizeof(DEVMODE);                  /**< 结构大小 */
136.     dmScreenSettings.dmPelsWidth    = GetWidth();                       /**< 设置宽度 */
137.     dmScreenSettings.dmPelsHeight   = GetHeight();                      /**< 设置高度 */
138.     dmScreenSettings.dmBitsPerPel   = m_BitsPerPixel;                   /**< 设置位深度 */
139.     //dmScreenSettings.dmDisplayFrequency = 75;                           /**< 设置屏幕刷新率 */
140.     dmScreenSettings.dmFields       = DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT ;//| DM_DISPLAYFREQUENCY;
142.     /// 改变显示模式
143.     if (ChangeDisplaySettings(&dmScreenSettings, 0) != DISP_CHANGE_SUCCESSFUL)
144.     {
145.         return false;                                                   /**< 如果失败，返回false */
146.     }
148.     return true;                                                        /**< 成功返回 */
149. }
151. /** 创建windows窗口 */
152. bool GLWindow::Create(const char * window_title,const char * class_name,bool fullscreen, HINSTANCE h_instance, LPVOID lpParam)
153. {
154.     m_IsFullScreen = fullscreen;
155.     int nX=0;
156.     int nY=0;
157.     PIXELFORMATDESCRIPTOR pfd =                                         /**< 设置像素描述结构 */
158.     {
159.         sizeof(PIXELFORMATDESCRIPTOR),                                  /**< 像素描述结构的大小 */ 
160.         1,                                                              /**< 版本号 */
161.         PFD_DRAW_TO_WINDOW  |                                           /**< 缓存区的输出显示在一个窗口中 */
162.         PFD_SUPPORT_OPENGL  |                                           /**< 缓存区支持OpenGL绘图 */
163.         PFD_STEREO          |                                           /**< 颜色缓存区是立体缓存 */
164.         PFD_DOUBLEBUFFER,                                               /**< 颜色缓存区是双缓存 */
165.         PFD_TYPE_RGBA,                                                  /**< 使用RGBA颜色格式 */
166.         m_BitsPerPixel,                                                 /**< 颜色缓存区中颜色值所占的位深 */
167.         0, 0, 0, 0, 0, 0,                                               /**< 使用默认的颜色设置 */
168.         0,                                                              /**< 无Alpha缓存 */
169.         0,                                                              /**< 颜色缓存区中alpha成分的移位计数 */
170.         0,                                                              /**< 无累计缓存区 */
171.         0, 0, 0, 0,                                                     /**< 累计缓存区无移位 */
172.         32,                                                             /**< 32位深度缓存 */
173.         0,                                                              /**< 无蒙版缓存 */
174.         0,                                                              /**< 无辅助缓存区 */
175.         PFD_MAIN_PLANE,                                                 /**< 必须为PFD_MAIN_PLANE，设置为主绘图层 */
176.         0,                                                              /**< 表示OpenGL实现所支持的上层或下层平面的数量 */
177.         0, 0, 0                                                         /**< 过时，已不再使用 */
178.     };
180.     DWORD windowStyle = WS_OVERLAPPEDWINDOW & ~WS_SIZEBOX & ~WS_MAXIMIZEBOX;    /**< 定义我们窗口类型，使用常规设定，去掉最大化按钮，并不能改变窗体大小 */
181.     DWORD windowExtendedStyle = WS_EX_APPWINDOW;                        
183.     if (m_IsFullScreen == true)                                         /**< 如果为全屏模式，尝试转化为全屏模式 */
184.     {
185.         if (ChangeScreenSetting() == false)
186.         {                                                               /**< 全屏模式转换失败，弹出对话框提示，并尝试窗口模式 */
187.             MessageBoxA(HWND_DESKTOP, "模式转换失败./n在窗口模式下运行.", "Error", MB_OK | MB_ICONEXCLAMATION);
188.             m_IsFullScreen = false;                                     /**< 设置为窗口模式 */
189.         }
190.         else                                                            /**< 如果为窗口模式 */
191.         {
192.             ShowCursor(false);                                          /**< 隐藏鼠标 */
193.             windowStyle = WS_POPUP;                                     /**< 设置窗口模式为顶层窗口 */
194.             windowExtendedStyle |= WS_EX_TOPMOST;                       
195.         }                                                               
196.     }
198.     /// 调整我们窗口的大小，使其客户区的大小为我们设置的大小
199.     RECT windowRect = {GetPosX(), GetPosY(), GetPosX() + GetWidth(), GetPosY() + GetHeight()};
200.     if (m_IsFullScreen == false)                                        /**< 在窗口模式下使用 */
201.     {   
202.         windowExtendedStyle = WS_EX_APPWINDOW | WS_EX_WINDOWEDGE;   /**< 使窗口具有3D外观 */
203.         int wid = GetSystemMetrics(SM_CXSCREEN);        /**< 获取当前屏幕宽 */
204.         int hei = GetSystemMetrics(SM_CYSCREEN);        /**< 获取当前屏幕高 */
205.         nX = (wid - GetWidth()) / 2;                    /**< 计算窗口居中用 */
206.         nY = (hei - GetHeight()) / 2;           
207.         /// 调整我们窗口的大小，使其客户区的大小为我们设置的大小
208.         AdjustWindowRectEx(&windowRect, windowStyle, 0, windowExtendedStyle);
209.         /// 判断窗口的左上角是否隐藏在桌面外
210.         if (windowRect.left < 0)                                        /**< 如果窗口X坐标为负，移动坐标到0处，并调整窗口的位置 */
211.         {
212.             windowRect.right -= windowRect.left;                        
213.             windowRect.left = 0;                                        
214.         }
215.         if (windowRect.top < 0)                                         /**< 如果窗口Y坐标为负，移动坐标到0处，并调整窗口的位置 */
216.         {
217.             windowRect.bottom -= windowRect.top;                        
218.             windowRect.top = 0;                                         
219.         }
220.     }
222.     /// 创建窗口
223.     m_hWnd = CreateWindowExA(windowExtendedStyle,                       /**< 窗口的扩展风格 */
224.                             class_name,                                 /**< 窗口的类名 */
225.                             window_title,                               /**< 窗口标题 */
226.                             windowStyle,                                /**< 窗口的风格 */
227.                             nX,nY,                                      /**< 窗口的左上角位置 */
228.                             windowRect.right - windowRect.left,         /**< 窗口的宽度 */
229.                             windowRect.bottom - windowRect.top,         /**< 窗口的高度 */
230.                             HWND_DESKTOP,                               /**< 窗口的父窗口为桌面 */
231.                             0,                                          /**< 无菜单 */
232.                             h_instance,                                 /**< 传入窗口的实例句柄 */
233.                             lpParam);                                   /**< 传入程序类参数 */
235.     while (m_hWnd != 0)                                                 /**< 窗口是否创建成功 */
236.     {
237.         m_hDC = GetDC(m_hWnd);                                          /**< 返回窗口的设备描述表 */
238.         if (m_hDC == 0)                                                 /**< 如果为空 */
239.         {                                                               /**< 失败 */
240.             break;                                                      
241.         }
243.         GLuint PixelFormat = ChoosePixelFormat(m_hDC, &pfd);            /**< 查找一个兼容的像素格式 */
244.         if (PixelFormat == 0)                                           /**< 如果没找到 */
245.         {                                                               /**< 失败 */
246.             break;                                                      
247.         }
248.         if (SetPixelFormat(m_hDC, PixelFormat, &pfd) == false)          /**< 设置像素格式 */
249.         {                                                               /**< 失败 */
250.             break;                                                      
251.         }
252.         m_hRC = wglCreateContext(m_hDC);                                /**< 创建OpenGL的渲染描述表 */
253.         if (m_hRC == 0)                                                 /**< 如果为空 */
254.         {                                                               /**< 失败 */
255.             break;                                                      
256.         }
257.         if (wglMakeCurrent(m_hDC, m_hRC) == false)                      /**< 设置当前的OpenGL的渲染对象为当前的窗口 */
258.         {                                                               /**< 失败 */
259.             break;                                                      
260.         }
261.         
262.         ShowWindow(m_hWnd, SW_NORMAL);                                  /**< 显示窗口 */
263.         ReshapeGL();                                                    /**< 告诉OpenGL调整窗口大小 */
264.         return true;                                                    /**< 成功返回 */
265.     }                                                                   
267.     Destroy();                                                          /**< 释放资源 */
268.     return false;                                                       /**< 返回失败 */
269. }
271. /** 删除OpenGL窗口 */
272. void GLWindow::Destroy()                                    
273. {
274.     if (m_hWnd != 0)                                        /**< 窗口句柄是否存在 */
275.     {
276.         if (m_hDC != 0)                                     /**< 窗口设备描述表是否存在 */
277.         {
278.             wglMakeCurrent(m_hDC, 0);                       /**< 设置当前的OpenGL的渲染对象为空NULL */
279.             if (m_hRC != 0)                                 /**< OpenGL的渲染描述表是否存在 */
280.             {
281.                 wglDeleteContext(m_hRC);                    /**< 释放OpenGL的渲染描述表 */
282.                 m_hRC = 0;                                  /**< 设置OpenGL的渲染描述表为0 */
283.             }
284.             ReleaseDC(m_hWnd, m_hDC);                       /**< 释放窗口的设备描述表 */
285.             m_hDC = 0;                                      /**< 设置窗口的设备描述表为0 */
286.         }
287.         DestroyWindow(m_hWnd);                              /**< 删除窗口 */
288.         m_hWnd = 0;                                         /**< 设置窗口句柄为0 */
289.     }
291.     if (m_IsFullScreen)                                     /**< 如果为全屏模式，在程序结束后，变换到窗口模式，并显示鼠标 */
292.     {
293.         ChangeDisplaySettings(NULL, 0);                     /**< 变换到窗口模式 */
294.         ShowCursor(true);                                   /**< 显示鼠标 */
295.     }
296. }

1. //======================================================================
2. /**
3. *  @file  Framework.h
4. *
5. *  项目描述： OpenGL程序框架演示
6. *  文件描述:  键盘类和程序框架类 
7. *  适用平台： Windows98/2000/NT/XP
8. *   
9. *  你必须在你的继承类中完成以下函数的实现
10. *                                                                           
11. *  GLApplication * GLApplication::Create(const char * class_name)       
12. *       创建你的子类的一个实例     
13. *                                                                           
14. *  bool Init();                                                     
15. *       执行所有的初始化工作，如果成功函数返回true                         
16. *                                                                           
17. *  void Uninit();                                                   
18. *       执行所有的卸载工作                                       
19. *                                                                           
20. *  void Update(DWORD milliseconds);                                     
21. *       执行所有的更新操作，传入的参数为两次操作经过的时间，以毫秒为单位
22. *                                                                           
23. *  void Draw();                                                         
24. *       执行所有的绘制操作
25. */                                                                          
26. //======================================================================
27. #ifndef __GLFRAME_H__
28. #define __GLFRAME_H__
31. #include "GLWindow.h"                                           /**< 包含GLWindow.h头文件 */
33. /** 定义键盘类 */
34. class Keys                                                       
35. {
36. public:
37.     /** 构造函数 */
38.     Keys() { Clear(); }
39.     /** 清空所有的按键信息 */
40.     void Clear() { ZeroMemory(&m_KeyDown, sizeof(m_KeyDown)); }
41.     /** 判断某个键是否按下 */
42.     bool IsPressed(unsigned int key)    { return (key < MAX_KEYS) ? (m_KeyDown[key] == true) : false; }
43.     /** 设置某个键被按下 */
44.     void SetPressed(unsigned int key)   { if (key < MAX_KEYS) m_KeyDown[key] = true; }
45.     /** 设置某个键被释放 */
46.     void SetReleased(unsigned int key)  { if (key < MAX_KEYS) m_KeyDown[key] = false; }
48. private:
49.     static const unsigned int MAX_KEYS = 256;
50.     bool m_KeyDown[MAX_KEYS];                                   /**< 保存256个按键的状态 */
51. };
54. /** 基本的程序类，继承它用来创建OpenGL程序 */
55. class GLApplication                                         
56. {
57. public:
58.     /** 创建一个全局的Create函数，这个函数必须被继承类实现 */
59.     static GLApplication * Create(const char * class_name); /**< 创建你自己的子类 */
61.     /** 虚析构函数 */
62.     virtual ~GLApplication() {};
64. protected:
65.     /** 下面的函数必须被继承类实现，完成基本的OpenGL渲染过程 */
66.     virtual bool    Init() = 0;                         /**< OpenGL的初始化 */ 
67.     virtual void    Uninit() = 0;                           /**< OpenGL的卸载 */
68.     virtual void    Update(DWORD milliseconds) = 0;             /**< 执行OpenGL程序的更新 */
69.     virtual void    Draw() = 0;                                 /**< 绘制OpenGL场景 */
71.     /** 通用的函数 */
72.     void    ToggleFullscreen();                                 /**< 切换 全屏/窗口模式 */
73.     void    TerminateApplication();                             /**< 结束程序 */
74.     void    ResizeDraw(bool enable) { m_ResizeDraw = enable; }  /**< 设置在窗口改变大小的时候，可以绘制 */
76.     Keys    m_Keys;                                             /**< 按键类 */
77.     /** 构造函数 */
78.     GLApplication(const char * class_name); 
79.     
80. private:
81.     /** 程序的主循环 */
82.     friend int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow);
83.     int     Main(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow);
85.     /** 消息处理回调函数 */
86.     friend LRESULT CALLBACK WindowProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
87.     LRESULT Message(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
89.     static const UINT WM_TOGGLEFULLSCREEN = (WM_USER + 1);      /**< 自定义消息，在切换窗口模式的时候发送 */
91.     GLWindow    m_Window;                                       /**< Window类 */
92.     const char* m_ClassName;                                    /**< 程序名 */
93.     bool        m_IsProgramLooping;                             /**< 程序循环标记，如果为false，则退出程序 */
94.     bool        m_CreateFullScreen;                             /**< 若为true，则创建全屏模式 */
95.     bool        m_IsVisible;                                    /**< 窗口是否可见 */
96.     bool        m_ResizeDraw;                                   /**< 是否在改变大小时，调用绘制函数 */
97.     DWORD       m_LastTickCount;                                /**< 上一次计时器的值 */
98. };
100. #endif  // __GLFRAMEWORK_H__

1. //======================================================================
2. /**
3. *  @file  Framework.cpp
4. *
5. *  项目描述： OpenGL程序框架演示
6. *  文件描述:  键盘类和程序框架类 
7. *  适用平台： Windows98/2000/NT/XP
8. *  
9. *   
10. *  你必须在你的继承类中完成以下函数的实现
11. *                                                                           
12. *  GLApplication * GLApplication::Create(const char * class_name)       
13. *       创建你的子类的一个实例     
14. *                                                                           
15. *  bool Init();                                                     
16. *       执行所有的初始化工作，如果成功函数返回true                         
17. *                                                                           
18. *  void Uninit();                                                   
19. *       执行所有的卸载工作                                       
20. *                                                                           
21. *  void Update(DWORD milliseconds);                                     
22. *       执行所有的更新操作，传入的参数为两次操作经过的时间，以毫秒为单位
23. *                                                                           
24. *  void Draw();                                                         
25. *       执行所有的绘制操作
26. */                                                                          
27. //======================================================================
29. #include "GLFrame.h"                                                    /**< 包含Framework.h头文件 */
30. //#include "ScreenDlg.h"                                                  /**< 包含ScreenDlg.h头文件 */
32. #include <gl/gl.h>                                                      /**< 包含OpenGL头文件 */
33. #include <gl/glu.h>                                                     
36. /** 主程序入口 */
37. int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
38. {
39.     int ret = -1;
40.     GLApplication * appl = GLApplication::Create("OpenGL");         /**< 创建程序类 */
41.     if (appl != 0)
42.     {
43.         ret = appl->Main(hInstance, hPrevInstance, lpCmdLine, nCmdShow);/**< 执行程序主循环 */
44.         delete appl;                                                    /**< 删除程序类（在继承类中，使用GL_Example * example = new GL_Example(class_name);分配了一块内存）*/
45.     }
46.     else
47.     {                                                                   /**< 创建程序出错 */
48.         MessageBoxA(HWND_DESKTOP, "创建程序出错", "Error", MB_OK | MB_ICONEXCLAMATION);
49.     }
50.     return ret;
51. }                                                                       
53. /** 处理窗口消息 */
54. LRESULT CALLBACK WindowProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
55. {
56.     LONG user_data = GetWindowLong(hWnd, GWL_USERDATA);                 /**< 返回用户自定义的32位的程序附加值 */
57.     if (user_data == 0)
58.     {   
59.         /// 如果程序第一次运行
60.         if (uMsg == WM_CREATE)                                          /**< 处理窗口创建消息 */
61.         {                                                               
62.             /// 返回窗口结构的指针，它保存刚创建的程序实例的类
63.             CREATESTRUCT * creation = reinterpret_cast<CREATESTRUCT *>(lParam);
64.             /// 获得程序实例的指针
65.             GLApplication * appl = reinterpret_cast<GLApplication *>(creation->lpCreateParams);
66.             /// 保存程序实例的指针为用户自定义的程序附加值
67.             SetWindowLong(hWnd, GWL_USERDATA, reinterpret_cast<LONG>(appl));
68.             appl->m_IsVisible = true;                                   /**< 设置程序可见 */
69.             return 0;                                                   /**< 返回 */
70.         }
71.     }
72.     else
73.     {   /// 如果不是第一次窗口，返回程序实例的指针
74.         GLApplication * appl = reinterpret_cast<GLApplication *>(user_data);
75.         return appl->Message(hWnd, uMsg, wParam, lParam);               /**< 调用程序实例自己的消息处理函数 */
76.     }
78.     return DefWindowProc(hWnd, uMsg, wParam, lParam);                   /**< 调用默认的窗口消息处理函数 */
79. }
82. /** 构造函数 */
83. GLApplication::GLApplication(const char * class_name)                   
84. {
85.     m_ClassName = class_name;                                           /**< 保存类名 */
86.     m_IsProgramLooping = true;                                          /**< 设置程序循环为true */
87.     m_CreateFullScreen = true;                                          /**< 使用全屏模式 */
88.     m_IsVisible = false;                                                /**< 不可见 */
89.     m_ResizeDraw = false;                                               /**< 在窗口改变大小的时候，不可绘制 */
90.     m_LastTickCount = 0;
91. }
93. void GLApplication::ToggleFullscreen()                                  /**< 切换 全屏/窗口模式 */
94. {
95.     PostMessage(m_Window, WM_TOGGLEFULLSCREEN, 0, 0);                   /**< 发送自定的切换消息 */
96. }
98. void GLApplication::TerminateApplication()                              /**< 结束程序 */
99. {
100.     PostMessage(m_Window, WM_QUIT, 0, 0);                               /**< 发送退出消息 */
101.     m_IsProgramLooping = false;                                         /**< 停止程序循环 */
102. }
104. /** 消息循环 */
105. LRESULT GLApplication::Message(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
106. {
107.     switch (uMsg)                                                       /**< 处理不同的Windows消息 */
108.     {
109.         case WM_SYSCOMMAND:                                             /**< 截获系统命令 */
110.             switch (wParam)                                             
111.             {
112.                 case SC_SCREENSAVE:                                     /**< 截获屏幕保护启动命令 */
113.                 case SC_MONITORPOWER:                                   /**< 截获显示其省电模式启动命令 */
114.                     return 0;                                           /**< 不启用这两个命令 */
115.                 break;
116.             }
117.         break;                                                          /**< 退出 */
119.         case WM_CLOSE:                                                  /**< 关闭窗口 */
120.             TerminateApplication();                                     /**< 调用TerminateApplication函数 */
121.             return 0;                                                   
122.         break;
124.         case WM_EXITMENULOOP:
125.         case WM_EXITSIZEMOVE:
126.             m_LastTickCount = GetTickCount();                           /**< 更新计数器的值 */
127.             return 0;
128.         break;
130.         case WM_MOVE:
131.             m_Window.SetPosX(LOWORD(lParam));                           /**< 更新鼠标的坐标 */
132.             m_Window.SetPosY(HIWORD(lParam));                           
133.             return 0;
134.         break;
136.         case WM_PAINT:
137.             if (m_ResizeDraw == true)                                   /**< 如果需要重绘 */
138.             {
139.                 m_Window.ReshapeGL();                                   /**< 重新设置窗口的大小 */
140.                 Draw();                                                 /**< 重新绘制 */
141.                 m_Window.SwapBuffers();                                 /**< 交换前后帧缓存 */
142.             }
143.         break;
145.         case WM_SIZING:                                                 /**< 窗口正在改变大小 */
146.         {
147.             RECT * rect = (RECT *)lParam;
148.             m_Window.SetWidth(rect->right - rect->left);                /**< 设置窗口宽度 */
149.             m_Window.SetHeight(rect->bottom - rect->top);               /**< 设置窗口高度 */
150.             return TRUE;
151.         }
152.         break;
154.         case WM_SIZE:                                                   /**< 窗口改变大小后 */
155.             switch (wParam)                                             /**< 处理不同的窗口状态 */
156.             {
157.                 case SIZE_MINIMIZED:                                    /**< 是否最小化? */
158.                     m_IsVisible = false;                                /**< 如果是，则设置不可见 */
159.                     return 0;                                           
160.                 break;
162.                 case SIZE_MAXIMIZED:                                    /**< 窗口是否最大化? */
163.                 case SIZE_RESTORED:                                     /**< 窗口被还原? */
164.                     m_IsVisible = true;                                 /**< 设置为可见 */
165.                     m_Window.SetWidth(LOWORD(lParam));                  /**< 设置窗口宽度 */
166.                     m_Window.SetHeight(HIWORD(lParam));                 /**< 设置窗口高度 */
167.                     m_Window.ReshapeGL();                               /**< 改变窗口大小 */
168.                     m_LastTickCount = GetTickCount();                   /**< 更新计数器的值 */
169.                     return 0;                                           
170.                 break;
171.             }
172.         break;                                                          
174.         case WM_KEYDOWN:                                                /**< 更新按键信息 */
175.             m_Keys.SetPressed(wParam);                                  
176.             return 0;                                                   
177.         break;
179.         case WM_KEYUP:                                                  /**< 更新释放键信息 */
180.             m_Keys.SetReleased(wParam);                                 
181.             return 0;                                                   
182.         break;
184.         case WM_TOGGLEFULLSCREEN:                                       /**< 切换 全屏/窗口模式 */
185.           /*  m_Window.SetFullScreen(!m_Window.GetFullScreen());
186.             if(!m_Window.GetFullScreen())
187.                 ShowCursor(true);
188.             else
189.                 ShowCursor(false);*/
191.             m_CreateFullScreen = !m_CreateFullScreen;
192.             PostMessage(hWnd, WM_QUIT, 0, 0);
193.         break;                                                          
194.     }
196.     return DefWindowProc(hWnd, uMsg, wParam, lParam);                   /**< 调用默认的窗口消息处理函数 */
197. }
199. /** 程序的主循环 */
200. int GLApplication::Main(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
201. {
202.     /// 注册一个窗口
203.     WNDCLASSEX windowClass;                                             /**< 窗口类 */
204.     ZeroMemory(&windowClass, sizeof(WNDCLASSEX));                       /**< 清空结构为0 */
205.     windowClass.cbSize          = sizeof(WNDCLASSEX);                   /**< 窗口结构的大小 */
206.     windowClass.style           = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;   /**< 设置窗口类型为，移动时重画，并为窗口取得DC */
207.     windowClass.lpfnWndProc     = (WNDPROC)(WindowProc);                /**< WndProc处理消息 */
208.     windowClass.hInstance       = hInstance;                            /**< 设置实例 */
209.     windowClass.hbrBackground   = (HBRUSH)(COLOR_APPWORKSPACE);         /**< 设置背景 */
210.     windowClass.hCursor         = LoadCursor(NULL, IDC_ARROW);          /**< 载入光标 */
211.     windowClass.lpszClassName   = m_ClassName;                          /**< 设置类名 */
212.     if (RegisterClassEx(&windowClass) == 0)                             /**< 尝试注册窗口类 */
213.     {                                                                   /**< NOTE: Failure, Should Never Happen */
214.         MessageBoxA(HWND_DESKTOP, "注册窗口失败!", "Error", MB_OK | MB_ICONEXCLAMATION);
215.         return -1;                                                      /**< 退出并返回FALSE */
216.     }
218.     // 询问是否在全屏状态下运行?
219.     if (MessageBoxA(HWND_DESKTOP, "你想在全屏状态下运行么 ?", "是否全屏运行?", MB_YESNO | MB_ICONQUESTION) == IDNO)
220.     {
221.         m_CreateFullScreen = false;                                     /**< m_CreateFullScreen记录当前的显示模式为窗口 */
222.     }
223.     //ScreenDlg sd;
224.     //sd.SetupWindow(&m_Window);
225.     //m_CreateFullScreen = m_Window.GetFullScreen();
226.     while (m_IsProgramLooping)                                          /**< 循环直道WM_QUIT退出程序 */
227.     {                                                                   
228.         /// 创建一个窗口
229.         if (m_Window.Create("OpenGL 3D游戏编程——框架", m_ClassName,m_CreateFullScreen, hInstance, this) == true)
230.         {   
231.             
232.             /// 如果初始化失败，则退出
233.             if (Init() == false)                                    /**< 调用自定义的初始化函数 */
234.             {                                                           /**< 失败 */
235.                 TerminateApplication();                                 /**< 关闭窗口退出程序 */
236.             }
237.             else                                                        /**< 成功开始消息循环 */
238.             {                                                            
239.                 MSG msg;                                                /**< Window消息结构 */ 
240.                 bool isMessagePumpActive = true;                        /**< 当消息不为空时，处理消息循环 */
241.                 m_LastTickCount = GetTickCount();                       /**< 返回当前的计时器的值 */
242.                 m_Keys.Clear();                                         /**< 清空所有的按键信息 */
243.                 while (isMessagePumpActive == true)                     /**< 当消息不为空时，处理消息循环 */
244.                 {                                                       /**< 成功创建窗口，检测窗口消息 */
245.                     if (PeekMessage(&msg, m_Window, 0, 0, PM_REMOVE) != 0)
246.                     {                                                   
247.                         /// 检测是否为WM_QUIT消息
248.                         if (msg.message != WM_QUIT)                     
249.                         {
250.                             DispatchMessage(&msg);                      /**< 如果不是发送消息到消息回调函数中处理 */
251.                         }
252.                         else                                            
253.                         {
254.                             isMessagePumpActive = false;                /**< 如果是，则退出 */
255.                         }
256.                     }
257.                     /// 如果没有消息
258.                     else                                                
259.                     {
260.                         if (m_IsVisible == false)                       /**< 如果窗口不可见 */
261.                         {
262.                             WaitMessage();                              /**< 暂停程序，等待消息 */
263.                         }
264.                         else                                            /**< 如果窗口可见 */
265.                         {                                               /**< 执行消息循环 */
266.                             DWORD tickCount = GetTickCount();           /**< 返回计时器的当前值 */
267.                             Update(tickCount - m_LastTickCount);        /**< 调用用户自定义的更新函数 */
268.                             m_LastTickCount = tickCount;                /**< 重新设置上一次，计数器的值 */
269.                             Draw();                                     /**< 调用用户自定义的绘制函数 */
270.                             m_Window.SwapBuffers();                     /**< 交换前后帧缓存 */
271.                         }
272.                     }
273.                 }                                                       /**< 如果isMessagePumpActive == true，则循环 */
274.             }                                                           
275.                                                                         /**< 程序结束 */
276.             Uninit();                                               /**< 用户自定义的卸载函数 */
277.             m_Window.Destroy();                                         /**< 删除窗口 */
278.         }
279.         else                                                            /**< 如果创建窗口失败 */
280.         {                                                               
281.             MessageBoxA(HWND_DESKTOP, "创建OpenGL窗口错误", "Error", MB_OK | MB_ICONEXCLAMATION);
282.             m_IsProgramLooping = false;                                 /**< 停止程序循环 */
283.         }
284.     }                                                                   
286.     UnregisterClassA(m_ClassName, hInstance);                           /**< 取消注册的窗口 */
287.     return 0;
288. }

附上实例程序:

1. //=========================================================================
2. /**
3. *  @file  Example.h
4. *
5. *  项目描述： OpenGL程序框架演示
6. *  文件描述:  具体实例类 
7. *  适用平台： Windows98/2000/NT/XP
8. *  
9. *
10. *  在这个类中您必须重载如下几个虚函数
11. *                                                                                               
12. *   virtual bool Init();                                                        
13. *       执行所有的初始化工作，如果成功函数返回true                         
14. *                                                                           
15. *   virtual void Uninit();                                                  
16. *       执行所有的卸载工作                                       
17. *                                                                           
18. *   virtual void Update(DWORD milliseconds);                                        
19. *       执行所有的更新操作，传入的参数为两次操作经过的时间，以毫秒为单位
20. *                                                                           
21. *   virtual void Draw();                                                            
22. *       执行所有的绘制操作
23. */
24. //=========================================================================
26. #ifndef __EXAMPLE_H__
27. #define __EXAMPLE_H__
30. #include "GLFrame.h"                                                /**< 包含基本的框架类 */
32. /** 从GL_Application派生出一个子类 */
33. class Example : GLApplication                               
34. {
35. public:
36.     bool    Init();                                     /**< 执行所有的初始化工作，如果成功函数返回true */
37.     void    Uninit();                                       /**< 执行所有的卸载工作 */
38.     void    Update(DWORD milliseconds);                         /**< 执行所有的更新操作，传入的参数为两次操作经过的时间，以毫秒为单位 */
39.     void    Draw();                                             /**< 执行所有的绘制操作 */
41. private:
42.     friend class GLApplication;                             /**< 父类为它的一个友元类，可以用来创建程序的实例，见函数GL_Application * GL_Application::Create(const char * class_name) */
43.     Example(const char * class_name);                       /**< 构造函数 */
44. /** 用户自定义的程序变量 */
45.     float   m_Angle;                                            /**< 使用它来旋转三角形 */
46. };
49. #endif  // __EXAMPLE_H__

1. //=========================================================================
2. /**
3. *  @file  Example.cpp
4. *
5. *  项目描述： OpenGL程序框架演示
6. *  文件描述:  具体实例类 
7. *  适用平台： Windows98/2000/NT/XP
8. *  
9. *
10. *  在这个类中您必须重载如下几个虚函数
11. *                                                                                               
12. *   virtual bool Init();                                                        
13. *       执行所有的初始化工作，如果成功函数返回true                         
14. *                                                                           
15. *   virtual void Uninit();                                                  
16. *       执行所有的卸载工作                                       
17. *                                                                           
18. *   virtual void Update(DWORD milliseconds);                                        
19. *       执行所有的更新操作，传入的参数为两次操作经过的时间，以毫秒为单位
20. *                                                                           
21. *   virtual void Draw();                                                            
22. *       执行所有的绘制操作
23. */
24. //=========================================================================
26. #include "Example.h"                                            /**< 包含头文件 */
28. #include <gl/gl.h>                                              /**< 包含OpenGL头文件 */
29. #include <gl/glu.h>                                             
30. #include <gl/glaux.h>                                           
33. #pragma comment(lib, "opengl32.lib")                            /**< 包含OpenGL链接库文件 */
34. #pragma comment(lib, "glu32.lib")                           
35. #pragma comment(lib, "glaux.lib")                           
38. /** 创建一个程序的实例 */
39. GLApplication * GLApplication::Create(const char * class_name)
40. {
41.     Example * example = new Example(class_name);
42.     return reinterpret_cast<GLApplication *>(example);
43. }
46. /** 构造函数 */
47. Example::Example(const char * class_name) : GLApplication(class_name)
48. {
49.   /// 初始化用户自定义的程序变量
50.     m_Angle = 0.0f;                                             /**< 设置初始角度为0 */
51. }
53. /** 初始化OpenGL */
54. bool Example::Init()                                    
55. {
56. /** 用户自定义的初始化过程 */
57.     glClearColor(0.0f, 0.0f, 0.0f, 0.5f);                       
58.     glClearDepth(1.0f);                                         
59.     glDepthFunc(GL_LEQUAL);                                     
60.     glEnable(GL_DEPTH_TEST);                                    
61.     glShadeModel(GL_SMOOTH);                                    
62.     glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);          
63.     ResizeDraw(true);                                           /**< 改变OpenGL窗口大小，直接调用子类的函数 */
65.     return true;                                                /**< 成功返回 */
66. }
68. /** 用户自定义的卸载函数 */
69. void Example::Uninit()                                  
70. {
71. /** 用户自定义的卸载过程 */
72. ///......
73. ///......
74. }
76. /** 程序更新函数 */
77. void Example::Update(DWORD milliseconds)                        
78. {
79.     if (m_Keys.IsPressed(VK_ESCAPE) == true)                    /**< 按ESC退出 */
80.     {
81.         TerminateApplication();                                 
82.     }
84.     if (m_Keys.IsPressed(VK_F1) == true)                        /**< 按F1切换窗口/全屏模式 */
85.     {
86.         ToggleFullscreen();                                     
87.     }
88. /** 用户自定义的更新过程 */
89.     m_Angle += (float)(milliseconds) / 15.0f;                   /**< 更新旋转的角度 */
90.      
91. }
93. /** 绘制函数 */
94. void Example::Draw()                                            
95. {
96. /** 用户自定义的绘制过程 */
97.     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);         
98.     glLoadIdentity();                                           
99.     glTranslatef(0.0f, 0.0f, -6.0f);                            
100.     glRotatef(m_Angle, 0.0f, 1.0f, 0.0f);                       
101.     glRotatef(m_Angle * 0.7f, -1.0f, 0.0f, 0.0f);               
103.     for (int rot1 = 0; rot1 < 2; rot1++)                        /**< 绘制四个交错的三角形（想的很巧妙啊）*/
104.     {
105.         glRotatef(90.0f, 0.0f, 1.0f, 0.0f);                     
106.         glRotatef(180.0f, 1.0f, 0.0f, 0.0f);                    
107.         for (int rot2 = 0; rot2 < 2; rot2++)                    
108.         {
109.             glRotatef(180.0f, 0.0f, 1.0f, 0.0f);                
110.             glBegin(GL_TRIANGLES);                              
111.                 glColor3f(1.f, 0.f, 0.f);   glVertex3f( 0.0f,  1.0f, 0.0f);
112.                 glColor3f(0.f, 1.f, 0.f);   glVertex3f(-1.0f, -1.0f, 1.0f);
113.                 glColor3f(0.f, 0.f, 1.f);   glVertex3f( 1.0f, -1.0f, 1.0f);
114.             glEnd();                                            
115.         }
116.     }
117.     glFlush();                                                  /**< 强制执行所有的OpenGL命令 */
118. }

注意的几点是:

1.在VS2005中建立项目时,须先建立控制台应用程序,再点选空项目,否则调试时会跑到 crt0.c 程序中。

2.需要将相应库文件放在源文件同一目录下。

3.配置属性->常规->字符集 中点选使用多字节字符集,否则若使用Unicode字符集,一些windows函数调用会出错。

4.配置属性->调试->生成调试信息 点选(是/Debug).

5.配置属性->清单工具->常规->使用FAT32解决办法 点选是。