cocos2d-x HelloWorld基本原理

转载：http://blog.csdn.net/wenzi6886/article/details/8520210 

我觉得讲一个东西还是要从HelloWorld开始讲。

1.导演类

用VS新建一个Cocos2d-X工程，然后自己帮我们生成一个HelloWorld工程，然后看看AppGelegate.app文件，里面有这个函数：

[cpp]  view plain copy

1. bool  AppDelegate::applicationDidFinishLaunching()  
2.   
3. {  
4.   
5.     // initialize director  
6.   
7.     CCDirector *pDirector =CCDirector::sharedDirector();  
8.   
9.     pDirector->setOpenGLView(CCEGLView::sharedOpenGLView());  
10.   
11.    
12.   
13.     // enable High Resource Mode(2x, such as iphone4) and maintains low resource on other devices.  
14.   
15. //     pDirector->enableRetinaDisplay(true);  
16.   
17.    
18.   
19.     // turn on display FPS  
20.   
21.     pDirector->setDisplayStats(true);  
22.   
23.    
24.   
25.     // set FPS. the default value is 1.0/60 if you don't call this  
26.   
27.     pDirector->setAnimationInterval(1.0 / 60);  
28.   
29.    
30.   
31.     // create a scene. it's an autorelease object  
32.   
33.     CCScene *pScene =HelloWorld::scene();  
34.   
35.    
36.   
37.     // run  
38.   
39.     pDirector->runWithScene(pScene);  
40.   
41.     return  true;  
42.   
43. }  

 

CCDirector类，是导演类，在Cocos2d-X的里，构建一个游戏，就是构建一个世界，这个世界由导演类去指导演绎，于是，在打开游戏的第一步时，导演告诉程序：

pDirector->setDisplayStats(true);     //要显示FPS数值，方便我查看游戏效率

pDirector->setAnimationInterval(1.0 / 60);   //游戏每秒播放多少帧（这里是60帧）

pDirector->runWithScene(pScene);      //进入游戏，首先要显示哪个场景

 

于是代码都很简单，主要是要留意，一个类继承了CCScene就可以作为场景使用，然后用导演类的runWithScene方法运行游戏的第一个场景，但是以后切换场景就要用replaceScene方法了。

 

2. 自定义场景

接下来我们来看看自定义的场景类，先看看HelloWorldScene.h头文件

[cpp]  view plain copy

1. class  HelloWorld : public  cocos2d::CCLayer  
2.   
3. {  
4.   
5. public:  
6.   
7.     virtual  bool init();    
8.   
9.     static  cocos2d::CCScene*  scene();  
10.   
11.    
12.   
13.     void  menuCloseCallback(CCObject*  pSender);  
14.   
15.    
16.   
17.     CREATE_FUNC(HelloWorld);  
18.   
19. };  

menuCloseCallback我觉得它应该是一个回调函数，没了，仅此而已，就是Android的OnClickListener里面的onClick函数一样，但是又有点不一样！

 

scene函数是不可缺的，它是CCLayer的类，HelloWorld里要重写这个函数的。那scene函数在哪个地方会用到？还记得之前那段代码吗？新建一个场景类的时候是这样的：

 

[cpp]  view plain copy

1. // create a scene. it's an autorelease object  
2.   
3.     CCScene *pScene =HelloWorld::scene();  
4.   
5.    
6.   
7.     // run  
8.   
9.     pDirector->runWithScene(pScene);  

 

再来看看CREATE_FUNC(HelloWorld);这个我纠结了很久，CREATE_FUNC是一个宏（应该是的，我C++很差的哈！）：

[cpp]  view plain copy

1. #define  CREATE_FUNC(__TYPE__) \  
2.   
3. static  __TYPE__* create() \  
4.   
5. { \  
6.   
7.     __TYPE__ *pRet =new__TYPE__(); \  
8.   
9.     if (pRet &&pRet->init()) \  
10.   
11.     { \  
12.   
13.         pRet->autorelease(); \  
14.   
15.         return  pRet; \  
16.   
17.     } \  
18.   
19.     else \  
20.   
21.     { \  
22.   
23.         delete  pRet; \  
24.   
25.         pRet =  NULL; \  
26.   
27.         return  NULL; \  
28.   
29.     } \  
30.   
31. }  

CREATE_FUNC实际上就是create函数，准确的说，是重写了CCLayer里的create函数，看看CCLayer的create函数：

 

[cpp]  view plain copy

1. CCLayer *CCLayer::create()  
2.   
3. {  
4.   
5.     CCLayer *pRet =newCCLayer();  
6.   
7.     if (pRet &&pRet->init())  
8.   
9.     {  
10.   
11.         pRet->autorelease();  
12.   
13.         return  pRet;  
14.   
15.     }  
16.   
17.     else  
18.   
19.     {  
20.   
21.         CC_SAFE_DELETE(pRet);  
22.   
23.         return  NULL;  
24.   
25.     }  
26.   
27. }  

 

是的，CREATE_FUNC的作用只不过是把create的返回值改成继承了CCLayer的实际子类

 

HelloWorldScene.cpp里是怎么重写scene函数的：

[cpp]  view plain copy

1. CCScene*  HelloWorld::scene()  
2.   
3. {  
4.   
5.     CCScene *  scene = NULL;  
6.   
7.     do   
8.   
9.     {  
10.   
11.         // 'scene' is an autorelease object  
12.   
13.         scene =  CCScene::create();  
14.   
15.         CC_BREAK_IF(!  scene);  
16.   
17.    
18.   
19.         // 'layer' is an autorelease object  
20.   
21.         HelloWorld *layer =HelloWorld::create();  
22.   
23.         CC_BREAK_IF(!  layer);  
24.   
25.    
26.   
27.         // add layer as a child to scene  
28.   
29.         scene->addChild(layer);  
30.   
31.     } while (0);  
32.   
33.    
34.   
35.     // return the scene  
36.   
37.     return  scene;  
38.   
39. }  

 

于是我们发现了，虽然HelloWorld自称是场景类，但是导演要的并不是它~！导演还是要了一个真正的CCScene类，你看：

            scene = CCScene::create();

这里创建了一个真正的CCScene类。

 一个场景类应该是继承了CCLayer，然后这个场景类有一个scene函数，这个函数会新建一个CCScene对象。

再看：

    HelloWorld *layer =HelloWorld::create();

    scene->addChild(layer);

HelloWorld只是作为一个layer（一个层），它被添加到刚刚创建的那个CCScene类了。好吧，现实很残酷，尽管HelloWorld继承了场景类，可它依旧不是一个真正的场景~！

 

好，紧接着，不要放松，还记得刚刚create函数里有这几句吗？

[cpp]  view plain copy

1. if (pRet &&pRet->init())  
2.   
3.     {  
4.   
5.         pRet->autorelease();  
6.   
7.         return  pRet;  
8.   
9.     }  

也就是说，场景类的init函数是一定会被调用的。

于是，这就表示，继承了CCScene的类，必须要有这三个家伙：

 

[cpp]  view plain copy

1. public:  
2.   
3.     virtual  bool init();    
4.   
5.     static  cocos2d::CCScene*  scene();  
6.   
7.     CREATE_FUNC(HelloWorld);  
8.   
9. };  

 

3.最后的最后，当然是总结

1). HelloWorld工程主要就是教我们创建一个场景类

2). AppDelegate.cpp里会创建第一个显示的场景类，此时用的方法是runWithScene

3).要新建一个场景类，就一定要有以下三个函数：

virtual bool init();                // 初始化，可以在这里创建精灵

 

static cocos2d::CCScene* scene();  // 在这里要自己新建一个CCScene类，然后把我们自定义的场景类作为一个CCLayer添加到这个CCScene类中

   

CREATE_FUNC(HelloWorld);          //相当于重写create函数，让create函数返回子类对象。

4. 然后，就是这样了。

 

好了，以上就是我从HelloWorld工程能够发现的东西了，肯定会有不少错误的思想，但是现在的我还无法修正。所以，仅供参考，嘿嘿~