Cocos2d-x 的“HelloWorld” 深入分析

本节所用Cocos2d-x版本：cocos2d-1.0.1-x-0.12.0

不能免俗，一切都从“HelloWorld!”开始.打开HelloWorld工程,里面有两个文件目录Classes和win32。

Classes下有HelloWorldScene.h/cpp ,AppDelegate.h/cpp.

win32下有main.h/cpp

首先看一下win32目录下的main.h,其中定义了使用win32平台进行编译的宏和一些Windows编程头文件。

1. [Cocos2d-x相关教程来源于红孩儿的游戏编程之路 CSDN博客地址：http://blog.csdn.net/honghaier]
2. #ifndef __MAIN_H__
3. #define __MAIN_H__
4. //定义使用WIN32平台进行编译的宏
5. #define WIN32_LEAN_AND_MEAN
6. // 所用到的Windows编程所用头文件
7. #include <windows.h>
8. #include <tchar.h>
9. // Cocos的C语言头文件
10. #include "CCStdC.h"
11. #endif// __MAIN_H__

再打开main.cpp.

1. //加入main.h头文件
2. #include "main.h"
3. //加入使用的AppDelegate类头文件
4. #include "../Classes/AppDelegate.h"
5. //WinMain主函数
6. int APIENTRY _tWinMain(HINSTANCE hInstance,
7. HINSTANCE hPrevInstance,
8. LPTSTR    lpCmdLine,
9. int       nCmdShow)
10. {
11. //UNREFERENCED_PARAMETER用于在VC编译器下告知编译器，不必检测改变量是否使用的警告。
12. UNREFERENCED_PARAMETER(hPrevInstance);
13. UNREFERENCED_PARAMETER(lpCmdLine);
14. // 创建一个Cocos2d-x程序实例
15. AppDelegate app;
16. // 运行程序实例
17. return cocos2d::CCApplication::sharedApplication().run();
18. }

代码看着就这么几行，好像非常简单。那是因为Cocos2d-x把很多WINDOWS窗口程序的代码都封装到了内部。这也使得它更加简单易学。但我们也应该明白这里面是怎么一回事。

咱们转到AppDelegate.h，可以看到AppDelegate类是一个私有继承Cocos2d命名空间中的CCApplication类。它的成员函数均是重载了CCApplication类的成员函数。顾名思义，CCApplication代表了程序类。我们打开它的声明文件看一下：

1. #ifndef __CC_APPLICATION_WIN32_H__
2. #define __CC_APPLICATION_WIN32_H__
3. //Windows头文件
4. #include <Windows.h>
5. //Cocos2d-x公共头文件,声明了一些公共函数以及语言类型枚举ccLanguageType
6. #include "CCCommon.h"
7. //使用cocos2d的命名空间来包括后面的代码
8. NS_CC_BEGIN;
9. //声明一下CCRect类，在CCApplication中会用到CCRect类指针
10. class CCRect;
11. class CC_DLL CCApplication
12. {
13. public:
14. //构造
15. CCApplication();
16. //析构
17. virtual ~CCApplication();
18. //初始化
19. virtual bool initInstance() = 0;
20. //程序启动后调用的函数，在这里创建设备与场景
21. virtual bool applicationDidFinishLaunching() = 0;
22. //当程序转入后台，如电话打入时调用
23. virtual void applicationDidEnterBackground() = 0;
24. //当程序转入前台，再次恢复时调用
25. virtual void applicationWillEnterForeground() = 0;
26. //在“设备”设置FPS时调用的函数，设置帧间隔时间
27. void setAnimationInterval(double interval);
28. //声明一个枚举，列出当前设备的摆放方向
29. typedef enum
30. {
31. /// 垂直方向, home 键在下面
32. kOrientationPortrait = 0,
33. /// 垂直方向, home 键在上面
34. kOrientationPortraitUpsideDown = 1,
35. /// 水平方向，home键在右边
36. kOrientationLandscapeLeft = 2,
37. /// 水平方向，home健在左边
38. kOrientationLandscapeRight = 3,
39. } Orientation;
40. //在“设备”改变了摆放方向后调用的函数,设置设备摆放方向
41. Orientation setOrientation(Orientation orientation);
42. //取得窗口的状态栏所在的矩形位置
43. void    statusBarFrame(CCRect * rect);
44. //运行程序
45. int run();
46. //取得当前的程序实例，这种用法可参考C++模式设计中的“单件”模式
47. static CCApplication& sharedApplication();
48. //取得当前的语言类型
49. static ccLanguageType getCurrentLanguage();
50. protected:
51. //程序实例句柄
52. HINSTANCE           m_hInstance;
53. //加速键句柄
54. HACCEL              m_hAccelTable;
55. //声明为帧间隔，实际上是每两帧之间的频率次数
56. LARGE_INTEGER       m_nAnimationInterval;
57. //单件的程序实例指针
58. static CCApplication * sm_pSharedApplication;
59. };
60. NS_CC_END;
61. #endif// __CC_APPLICATION_WIN32_H__

通过对于CCApplication_win32.h的代码分析，我们可以清楚CCApplication的功能是对于程序的控制。

我们转到CCApplication类的cpp文件CCApplication_win32.cpp再来分析一下。

读前小提示:  CCDirector代表显示设备管理器。也是一个单件类。通过其静态函数CCDirector::sharedDirector()来访问唯一的显示设备。

重点关注函数：CCApplication()，run()。

1. #include "CCApplication.h"
2. //设备头文件
3. #include "CCDirector.h"
4. //在注册表中写入对于PVRFrame的显示和隐藏的设置
5. static void PVRFrameEnableControlWindow(bool bEnable);
6. //使用cocos2d的命名空间来包括后面的代码
7. NS_CC_BEGIN;
8. // CCApplication的静态成员指针变量, 单件对象指针
9. CCApplication * CCApplication::sm_pSharedApplication = 0;
10. //构造函数
11. CCApplication::CCApplication()
12. : m_hInstance(NULL)
13. , m_hAccelTable(NULL)
14. {
15. //获取当前程序句柄
16. m_hInstance= GetModuleHandle(NULL);
17. //初始化m_nAnimationInterval
18. m_nAnimationInterval.QuadPart = 0;
19. //断言程序中只有一个sm_pSharedApplication。确保当前类只有一个实例对象
20. CC_ASSERT(! sm_pSharedApplication);
21. //设置单件对象指针指向当前类对象实例
22. sm_pSharedApplication = this;
23. }
24. //析构
25. CCApplication::~CCApplication()
26. {
27. //断言程序只有一个sm_pSharedApplication就是指向当前类的实例对象
28. CC_ASSERT(this == sm_pSharedApplication);
29. sm_pSharedApplication = NULL;
30. }
31. //程序运行
32. int CCApplication::run()
33. {
34. //设置注册表PVRFrame隐藏
35. PVRFrameEnableControlWindow(false);
36. //主消息循环
37. MSG msg;
38. LARGE_INTEGER nFreq;
39. LARGE_INTEGER nLast;
40. LARGE_INTEGER nNow;
41. //WINDOWS高精度定时器的用法，先获取频率
42. QueryPerformanceFrequency(&nFreq);
43. //获取当前的计数值,即频率x当前时间
44. QueryPerformanceCounter(&nLast);
45. //initInstance函数为虚函数，由派生类AppDelegate进行了重载。此段代码在调用AppDelegate重载的initInstance函数之后调用applicationDidFinishLaunching函数完成一些初始化处理。
46. //注:AppDelegate重载initInstance函数做了什么我们暂且只先认为它如平时我们WINDOWS基本框架程序一样创建了一个Windows窗口。【伏笔1后面会有讲解】。
47. if (! initInstance() || ! applicationDidFinishLaunching())
48. {
49. return 0;
50. }
51. //取得当前使用的OPENGL窗口管理实例对象
52. CCEGLView& mainWnd = CCEGLView::sharedOpenGLView();
53. //将窗口居中显示
54. mainWnd.centerWindow();
55. ShowWindow(mainWnd.getHWnd(), SW_SHOW);
56. //非常熟悉!进入WINDOWS消息循环
57. while (1)
58. {
59. //如果没有获取到WINDOWS消息
60. if (! PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
61. {
62. // 取得当前的计数值,即频率x当前时间
63. QueryPerformanceCounter(&nNow);
64. //m_nAnimationInterval.QuadPart的值 为setAnimationInterval函数进行设置的固定值。此处是为了判断时间流逝了多久，是否应该更新显示设备
65. if (nNow.QuadPart - nLast.QuadPart > m_nAnimationInterval.QuadPart)
66. {
67. //如果时间流逝达到了设定的FPS时间差，则更新计数值。
68. nLast.QuadPart = nNow.QuadPart;
69. //这里是设备渲染场景的函数，【伏笔2后面会有讲解】
70. CCDirector::sharedDirector()->mainLoop();
71. }
72. else
73. {
74. //sleep0秒的意义是让CPU做下时间片切换，防止死循环而使系统其它程序得不到响应。
75. Sleep(0);
76. }
77. continue;
78. }
79. //有消息获取到
80. if (WM_QUIT == msg.message)
81. {
82. // 如果获取的消息是退出则退出循环。
83. break;
84. }
85. // 如果没有定义加速键或者处理完加速键信息
86. if (! m_hAccelTable || ! TranslateAccelerator(msg.hwnd, m_hAccelTable, &msg))
87. {
88. //处理Windows消息
89. TranslateMessage(&msg);
90. DispatchMessage(&msg);
91. }
92. }
93. return (int) msg.wParam;
94. }
95. //外部调用的设置帧间隔时间
96. void CCApplication::setAnimationInterval(double interval)
97. {
98. //获取高精度定时器的频率
99. LARGE_INTEGER nFreq;
100. QueryPerformanceFrequency(&nFreq);
101. //计算出频率X帧间隔时差的值存入m_nAnimationInterval用做比较值
102. m_nAnimationInterval.QuadPart = (LONGLONG)(interval * nFreq.QuadPart);
103. }
104. //摆放方向变化时外部自动调用的设置摆放方向
105. CCApplication::Orientation CCApplication::setOrientation(Orientation orientation)
106. {
107. //切换OPENGL视窗的宽高
108. CCEGLView * pView = CCDirector::sharedDirector()->getOpenGLView();
109. if (pView)
110. {
111. return (Orientation)pView->setDeviceOrientation(orientation);
112. }
113. return (Orientation)CCDirector::sharedDirector()->getDeviceOrientation();
114. }
115. //获取状态栏的位置矩形
116. void CCApplication::statusBarFrame(CCRect * rect)
117. {
118. if (rect)
119. {
120. // WINDOWS系统没有状态栏，所以返回的矩形各位置都是0
121. *rect = CCRectMake(0, 0, 0, 0);
122. }
123. }
124. //////////////////////////////////////////////////////////////////////////
125. // 静态成员函数，获取单件指针
126. //////////////////////////////////////////////////////////////////////////
127. CCApplication& CCApplication::sharedApplication()
128. {
129. CC_ASSERT(sm_pSharedApplication);
130. return *sm_pSharedApplication;
131. }
132. //静态成员函数，获取当前系统的语言类型
133. ccLanguageType CCApplication::getCurrentLanguage()
134. {
135. //默认为英语
136. ccLanguageType ret = kLanguageEnglish;
137. //
138. LCID localeID = GetUserDefaultLCID();
139. unsigned short primaryLanguageID = localeID & 0xFF;
140. switch (primaryLanguageID)
141. {
142. case LANG_CHINESE://中文
143. ret = kLanguageChinese;
144. break;
145. case LANG_FRENCH://法文
146. ret = kLanguageFrench;
147. break;
148. case LANG_ITALIAN://意文
149. ret = kLanguageItalian;
150. break;
151. case LANG_GERMAN://德文
152. ret = kLanguageGerman;
153. break;
154. case LANG_SPANISH://西班牙文
155. ret = kLanguageSpanish;
156. break;
157. case LANG_RUSSIAN://俄文
158. ret = kLanguageRussian;
159. break;
160. }
161. return ret;
162. }
163. NS_CC_END;
164. //////////////////////////////////////////////////////////////////////////
165. //在注册表中写入对于PVRFrame的显示和隐藏的设置
166. //////////////////////////////////////////////////////////////////////////
167. static void PVRFrameEnableControlWindow(bool bEnable)
168. {
169. HKEY hKey = 0;
170. // 打开注册表的 PVRFrame 项
171. if(ERROR_SUCCESS != RegCreateKeyExW(HKEY_CURRENT_USER,
172. L"Software\\Imagination Technologies\\PVRVFRame\\STARTUP\\",
173. 0,
174. 0,
175. REG_OPTION_NON_VOLATILE,
176. KEY_ALL_ACCESS,
177. 0,
178. &hKey,
179. NULL))
180. {
181. return;
182. }
183. const wchar_t * wszValue = L"hide_gui";
184. const wchar_t * wszNewData = (bEnable) ? L"NO" : L"YES";
185. wchar_t wszOldData[256] = {0};
186. DWORD   dwSize = sizeof(wszOldData);
187. //读取相应的键值
188. LONGstatus = RegQueryValueExW(hKey, wszValue, 0, NULL, (LPBYTE)wszOldData, &dwSize);
189. //如果键值不存在，或者键值存在但与当前值不同，重设键值
190. if (ERROR_FILE_NOT_FOUND == status
191. || (ERROR_SUCCESS == status
192. && 0 != wcscmp(wszNewData, wszOldData)))
193. {
194. dwSize = sizeof(wchar_t) * (wcslen(wszNewData) + 1);
195. RegSetValueEx(hKey, wszValue, 0, REG_SZ, (const BYTE *)wszNewData, dwSize);
196. }
197. //关闭注册表
198. RegCloseKey(hKey);
199. }

代码看完之后，我们来做一下CCApplication类的总结：

在CCApplication的构造函数中可以看到这里定义了一个静态指针sm_pShareApplication;它在CCApplication实例化时指定为实例化单件对象的指针。在sharedApplication函数中返回实例化的单件对象引用。重点函数是run函数。在run函数开始调用了initInstance函数进行程序的初始化,调用返回为true后再调用applicationDidFinishLaunching函数完成一些逻辑的初始化工作,完成初始化后会进入WINDOWS消息循环，并通过高精度定时器进行FPS判断什么时候调用CCDirector::sharedDirector()->mainLoop()。直待收到窗口关闭的消息退出消息循环并返回。

好了，我们理解了CCApplication之后，我们再来看一下它的派生类AppDelegate，了解一下它都重载了哪些函数。

读前小提示:  CCEGLView代表OpenGL显示窗口。封装了使用OpengGL做为显示底层API的一个基本的WINDOWS窗体的创建与控制。

读前小提示:  CCDirector类中有一个函数enableRetinaDisplay函数。这个函数主要是影响到IOS平台上支持高清显示的设备如iphone4，iphone4s等。如
果设置enableRetinaDisplay(false), 则在iphone4平台上运行的结果是游戏的图片分辨率降低为原来的一半，因为宽高都被
拉伸了一倍。如果设置enableRetinaDisplay(true), 则在iphone4平台上运行的结果是游戏的图片分辨率正常，但是放置的位
置的水平方向和垂直方向都拉伸了两倍。要记住在cocos2d里面设置精灵坐标时，使用的是点，而不是像素，在普通的iphone上，一个点就等于一个像
素，而在高清显示设备中，默认一个点等于二个像素。在IOS SDK 4.0及以后的SDK中支持不同的分辨率。并提供了相应的函数对逻辑点与像素的对应
比例值做设置。

重点关注函数：initInstance()。

1. #ifndef  _APP_DELEGATE_H_
2. #define  _APP_DELEGATE_H_
3. #include "CCApplication.h"
4. class  AppDelegate : private cocos2d::CCApplication
5. {
6. public:
7. //构造函数
8. AppDelegate();
9. //析构函数
10. virtual ~AppDelegate();
11. //重载初始化函数
12. virtual bool initInstance();
13. //重载应用程序启动后调用的处理函数
14. virtual bool applicationDidFinishLaunching();
15. //重载应用程序转入后台时调用的函数
16. virtual void applicationDidEnterBackground();
17. //重载应用程序恢复前台时调用的函数
18. virtual void applicationWillEnterForeground();
19. };
20. #endif // _APP_DELEGATE_H_

再来看cpp文件

1. #include "AppDelegate.h"
2. //加入cocos2d头文件
3. #include "cocos2d.h"
4. #include "HelloWorldScene.h"
5. //加入OpenGL窗口类
6. #include "CCEGLView.h"
7. //使用cocos2d命名空间
8. USING_NS_CC;
9. //构造函数
10. AppDelegate::AppDelegate() {
11. }
12. //析构函数
13. AppDelegate::~AppDelegate() {
14. }
15. //初始化函数,解答伏笔1
16. bool AppDelegate::initInstance()
17. {
18. //定义一个bool返回值用于判断是否正常初始化
19. bool bRet = false;
20. do {
21. //通过对宏定义的匹配来判断当前编译的代码的目标平台是什么，在这里可以知道Cocos2d-x的跨平台都支持哪些平台。我们的教程只针对WIN32平台部分做讲解，其它平台大家可以自行参考WIN32平台部分进行学习。
22. //第一种平台类型，WIN32系统
23. #if (CC_TARGET_PLATFORM == CC_PLATFORM_WIN32)
24. // 创建并初始化OpenGL窗口管理实例对象，注意这里使用的是new来动态实例化的。当程序退出时会通过显示设备的release函数进行对窗口的释放。【伏笔3后面会有讲解】。
25. CCEGLView * pMainWnd = new CCEGLView();
26. //CC_BREAK_IF宏的意思是如果括号中的语句为否则中断循环。配合do_while流程使用。
27. //可以看到这里的意思是，如果pMainWnd实例化失败或者pMainWnd创建窗口失败则中断循环。在这里硬性的设定了窗口的标题和窗口的宽度高度。
28. CC_BREAK_IF(! pMainWnd
29. || ! pMainWnd->Create(TEXT("cocos2d: Hello World"), 480, 320));
30. #endif  // CC_PLATFORM_WIN32
31. //第二种平台类型，IOS类型
32. #if (CC_TARGET_PLATFORM == CC_PLATFORM_IOS)
33. #endif  // CC_PLATFORM_IOS
34. //第三种平台类型，ANDORID类型
35. #if (CC_TARGET_PLATFORM == CC_PLATFORM_ANDROID)
36. #endif  // CC_PLATFORM_ANDROID
37. //第四种平台，WOPHONE平台
38. #if (CC_TARGET_PLATFORM == CC_PLATFORM_WOPHONE)
39. #endif  // CC_PLATFORM_WOPHONE
40. //第五种平台，MARMALADE
41. #if (CC_TARGET_PLATFORM == CC_PLATFORM_MARMALADE)
42. #endif
43. //第六种平台，LINUX
44. #if (CC_TARGET_PLATFORM == CC_PLATFORM_LINUX)
45. #endif  // CC_PLATFORM_LINUX
46. //第七种平台，BADA
47. #if (CC_TARGET_PLATFORM == CC_PLATFORM_BADA)
48. #endif  // CC_PLATFORM_BADA
49. //第八种平台,QNX
50. #if (CC_TARGET_PLATFORM == CC_PLATFORM_QNX)
51. #endif // CC_PLATFORM_QNX
52. //如果没有被中断，则成功完成初始化。
53. bRet = true;
54. //退出循环
55. } while (0);
56. return bRet;
57. }
58. //重载应用程序启动后调用的处理函数
59. bool AppDelegate::applicationDidFinishLaunching() {
60. //通过CCDirector的静态函数sharedDirector来获取单件显示设备管理器指针
61. CCDirector *pDirector = CCDirector::sharedDirector();
62. //通过CCEGLView的静态函数sharedOpenGLView来获取单件管理实例对象并将其地址通过CCDirector的成员函数setOpenGLView传递给显示设备管理器。
63. pDirector->setOpenGLView(&CCEGLView::sharedOpenGLView());
64. //打开使用高清模式，这里给屏蔽了，如未来有需要可以打开。但是在设计程序时需要考虑到打开后对于位置的影响并提前制定相应的设计方案。
65. //pDirector->enableRetinaDisplay(true);
66. // 打开显示FPS
67. pDirector->setDisplayFPS(true);
68. // 设置当前屏幕的摆放方向，这里给屏蔽了。
69. // pDirector->setDeviceOrientation(kCCDeviceOrientationLandscapeLeft);
70. // 设置FPS的帧间隔时间差为60分之一秒，从而期望FPS为60帧。
71. pDirector->setAnimationInterval(1.0 / 60);
72. //通过HelloWorld的静态函数scene()创建返回一个场景实例
73. CCScene *pScene = HelloWorld::scene();
74. //运行这个场景
75. pDirector->runWithScene(pScene);
76. return true;
77. }
78. //重载应用程序转入后台时调用的函数，如电话打进来
79. void AppDelegate::applicationDidEnterBackground() {
80. //暂停显示设备的渲染处理
81. CCDirector::sharedDirector()->pause();
82. // 如果使用了声音引擎，这里进行暂停设置。否则会影响到通话，因为暂时没用到，所以屏蔽
83. // SimpleAudioEngine::sharedEngine()->pauseBackgroundMusic();
84. }
85. //重载应用程序恢复前台时调用的函数
86. void AppDelegate::applicationWillEnterForeground() {
87. //恢复显示设备的渲染处理
88. CCDirector::sharedDirector()->resume();
89. //如果使用了声音引擎，这里进行恢复设置
90. // SimpleAudioEngine::sharedEngine()->resumeBackgroundMusic();
91. }

在InitInstance函数中，我们看到Cocos2d-x将Windows窗口的创建与控制都封装到了CCEGLView类中。它已经暴露出一个Create函数，做为一个求知者，我们应该迫不及待的想要看到它在哪里创建窗口。继续追进去吧！GoGoGo!

我们进入了CCEGLView_win32.h，通过文件名可以知道CCEGLView类应该有多个平台的版本。我们暂不理它。看一下Create函数。

//

1. bool CCEGLView::Create(LPCTSTR pTitle, int w, int h)
2. {
3. //定义一个bool型返回值
4. bool bRet = false;
5. do
6. {
7. //检测窗口句柄是否已经存在。确保只创建一个窗口
8. CC_BREAK_IF(m_hWnd);
9. //进入到这里，我们应该很高兴了。没错，终于找到了创建窗口的代码。
10. HINSTANCE hInstance = GetModuleHandle( NULL );
11. WNDCLASS  wc;// 窗口类
12. // 设置相关参数
13. wc.style          = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;
14. wc.lpfnWndProc    = _WindowProc;// 本窗口使用的WINDOWS消息处理函数
15. wc.cbClsExtra     = 0;
16. wc.cbWndExtra     = 0;
17. wc.hInstance      = hInstance;
18. wc.hIcon          = LoadIcon( NULL, IDI_WINLOGO );
19. wc.hCursor        = LoadCursor( NULL, IDC_ARROW );
20. wc.hbrBackground  = NULL;
21. wc.lpszMenuName   = NULL;
22. wc.lpszClassName  = kWindowClassName;
23. //注册窗口类,如果失败则判断失败原因是否是此类别已存在(错误码1410)，如果是因为此类存在而导致失败，则仍然可以继续。
24. CC_BREAK_IF(! RegisterClass(&wc) && 1410 != GetLastError());
25. // 取得窗口的窗体矩形
26. RECT rcDesktop;
27. GetWindowRect(GetDesktopWindow(), &rcDesktop);
28. // 调用创建口函数
29. m_hWnd = CreateWindowEx(
30. WS_EX_APPWINDOW | WS_EX_WINDOWEDGE,
31. kWindowClassName,// 之前注册的窗口类
32. pTitle,// 窗口标题
33. WS_CAPTION | WS_POPUPWINDOW | WS_MINIMIZEBOX,// 窗体样式
34. 0, 0,              // 窗体位置
35. 0,                                                  // 窗体宽度
36. 0,                                                  // 窗体高度
37. NULL,// 无父窗口
38. NULL,// 无菜单
39. hInstance,// 程序句柄
40. NULL );
41. //判断窗口是否创建成功
42. CC_BREAK_IF(! m_hWnd);
43. //取得显示设备的摆放方向
44. m_eInitOrientation = CCDirector::sharedDirector()->getDeviceOrientation();
45. //通过对摆放方向的判断得出水平还是垂直
46. m_bOrientationInitVertical = (CCDeviceOrientationPortrait == m_eInitOrientation
47. || kCCDeviceOrientationPortraitUpsideDown == m_eInitOrientation) ? true : false;
48. m_tSizeInPoints.cx = w;
49. m_tSizeInPoints.cy = h;
50. //设置窗口大小
51. resize(w, h);
52. // 使用此窗口进行OpenGL的设置
53. m_pEGL = CCEGL::create(this);
54. // 如果OpenGL创建失败,销毁窗体并中断
55. if (! m_pEGL)
56. {
57. DestroyWindow(m_hWnd);
58. m_hWnd = NULL;
59. break;
60. }
61. //将静态指针设置为当前实例对象。
62. s_pMainWindow = this;
63. bRet = true;
64. } while (0);
65. return bRet;
66. }

在注册类时，设定了窗口的消息处理回调函数为_WinDowProc,我们继续追入看一下程序退出时在哪里释放了Opengl窗口实例对象。呵呵，还记得
前面我们埋下的伏笔3，它是用new创建出来的。而new出来的内存必须释放。程序退出会销毁窗体，消息处理函数会先后收到WM_CLOSE和
WM_DESTROY。我们找一下。

1. static LRESULT CALLBACK _WindowProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
2. {
3. //如果OpenGL窗体初始化完成，则由OpenGL窗体进行消息处理，否则由WINDOWS系统进行默认处理
4. if (s_pMainWindow && s_pMainWindow->getHWnd() == hWnd)
5. {
6. return s_pMainWindow->WindowProc(uMsg, wParam, lParam);
7. }
8. else
9. {
10. return DefWindowProc(hWnd, uMsg, wParam, lParam);
11. }
12. }

继续。

1. LRESULT CCEGLView::WindowProc(UINT message, WPARAM wParam, LPARAM lParam)
2. {
3. PAINTSTRUCT ps;
4. switch (message)
5. {…//其它消息暂不理，可自行分析
6. case WM_PAINT:
7. //这里是刷新屏幕，因为使用了OpenGL来进行绘制，所以这里不作任何处理。
8. BeginPaint(m_hWnd, &ps);
9. EndPaint(m_hWnd, &ps);
10. break;
11. case WM_CLOSE:
12. //调用单件显示设备管理器的end函数关闭窗口
13. CCDirector::sharedDirector()->end();
14. break;
15. case WM_DESTROY:
16. //向消息循环发送WM_QUIT消息退出程序
17. PostQuitMessage(0);
18. break;
19. default:
20. return DefWindowProc(m_hWnd, message, wParam, lParam);
21. }
22. return 0;
23. }

进入显示设备管理器CCDirector的end函数。

1. void CCDirector::end()
2. {
3. m_bPurgeDirecotorInNextLoop = true;
4. }

倒!这里只是设置成员变量m_bPurgeDirecotorInNextLoop为true,没有什么delete。怎么回事呢？

1. void CCDisplayLinkDirector::mainLoop(void)
2. {//如果清除显示设备开关为true
3. if (m_bPurgeDirecotorInNextLoop)
4. {
5. //清楚设备
6. purgeDirector();
7. m_bPurgeDirecotorInNextLoop = false;
8. }//否则判断显示设备是否有效
9. else if (! m_bInvalid)
10. {
11. //如果有效，绘制场景
12. drawScene();
13. //调用内存管理器释放其管理的内存
14. CCPoolManager::getInstance()->pop();
15. }
16. }

马上要接晓答案了

1. void CCDirector::purgeDirector()
2. {
3. …//其它暂不理。有兴趣的朋友请自行分析
4. // 调用Opengl窗口管理实例对象的release函数进行释放。
5. m_pobOpenGLView->release();
6. m_pobOpenGLView = NULL;
7. }

进入OpenGL窗口管理类的release函数

1. void CCEGLView::release()
2. {//销毁窗体
3. if (m_hWnd)
4. {
5. DestroyWindow(m_hWnd);
6. m_hWnd = NULL;
7. }
8. s_pMainWindow = NULL;
9. //注销所使用的窗口类
10. UnregisterClass(kWindowClassName, GetModuleHandle(NULL));
11. //释放使用到的指针
12. CC_SAFE_DELETE(m_pSet);
13. CC_SAFE_DELETE(m_pTouch);
14. CC_SAFE_DELETE(m_pDelegate);
15. CC_SAFE_DELETE(m_pEGL);
16. //关键点：在最后释放了自已在AppDelegate::initInstance()中通过new创建对象而占用的内存。
17. delete this;
18. }

现在我们了解了Cocos2d-x是如何将WINDOWS程序基本框架封装在自已的类之中的。运行一下程序，可们可以看到弹出的窗口显示出HelloWorld的画面。而当初复杂的WINDOWS程序基本框架。在这里只化为简单的一句run()。非常简洁！

这个运行中的窗口，没有最大化系统按钮，窗体大小也被固定在480x320。我们希望能够更灵活的设置窗口的标题和大小。那我们必须要做一些改动。即然已经看懂了代码，下面就亲自实习一下吧。

打开AppDelegate的initInstance函数，增加相应的参数。

1. bool AppDelegate::initInstance(LPCTSTR szTitle,UINT wWidth,UINT wHeight)

并改动下面一句

1. CC_BREAK_IF(! pMainWnd
2. //改成由函数参数来创建OpenGL窗体
3. || ! pMainWnd->Create(szTitle, wWidth, wHeight));
4. //|| ! pMainWnd->Create(TEXT("cocos2d: Hello World"), 480, 320));

然后我们打开CCApplication_win32.cpp，找到run函数。做同样的修改。

1. int CCApplication::run(LPCTSTR szTitle,UINT wWidth,UINT wHeight)

并改动下面一句

1. if (! initInstance(szTitle,wWidth,wHeight) || ! applicationDidFinishLaunching())
2. // if (! initInstance() || ! applicationDidFinishLaunching())

之后我们将头文件所需要改动的函数声明也一一改动。保存，重新编译libcocos2d工程。再打开HelloWorld中的main.cpp修改这一句：

//我们可以在这里自已设定窗口标题和窗口大小

1. return cocos2d::CCApplication::sharedApplication().run(TEXT("第一个Cocos2d-x程序"),800,600);
2. //return cocos2d::CCApplication::sharedApplication().run();

编译HelloWorld。运行一下。享受一下成果！

对于这个框架我写的较多，因为整个Cocos2d-x的所有例子都是基于这个框架，我们必须理解清楚它是怎么一回事。之后我们将进入到引擎显示部分模块的讲解。希望大家后面继续努力！下课:）