Cocos2d-x 2.0 按键加速处理深入分析

大家好，我们经常会玩赛车游戏，当我们按下一个按键时，如果只能匀速运动是令人烦燥的。在游戏中用到加速度，利用加速度对于物体进行更真实的控制是必不可少的技能。今天我们来学习一下Cocos2d-x中如何利用按键来处理速度的累加。

 

    我们知道在WIN32编程中，一个键按下时所对应的窗口会收到WM_KEYDOWN消息，如果按下的键输入的是字符，窗口接着会收到WM_CHAR消息，而当按键抬起时对应的窗口会收到WM_KEYUP消息。在HelloWorld深入分析一节中，我们知道在CCEGLView类中有窗口消息的处理函数WindowProc，所以要进行按键的处理，就需要在接受按键消息时调用相应的函数。我们来看一下它在接受到WM_KEYDOWN,WM_CHAR和WM_KEYUP时做了什么。

[cpp]  view plain copy

1. LRESULT CCEGLView::WindowProc(UINT message, WPARAM wParam, LPARAM lParam)  
2. {  
3.     …  
4. case WM_KEYDOWN:  
5.         if (wParam == VK_F1 || wParam == VK_F2)  
6.         {  
7.             CCDirector* pDirector = CCDirector::sharedDirector();  
8.             //当SHIFT键被按下时，根据是否按下的是F1来决定软键盘收到的消息是响应回退还是主菜单。  
9.             if (GetKeyState(VK_LSHIFT) < 0 ||  GetKeyState(VK_RSHIFT) < 0 || GetKeyState(VK_SHIFT) < 0)  
10.                 pDirector->getKeypadDispatcher()->dispatchKeypadMSG(wParam == VK_F1 ? kTypeBackClicked : kTypeMenuClicked);  
11.         }  
12.         //如果按键消息响应函数有效则调用函数指针m_lpfnAccelerometerKeyHook所指的函数。   
13.         if ( m_lpfnAccelerometerKeyHook!=NULL )  
14.         {  
15.             (*m_lpfnAccelerometerKeyHook)( message,wParam,lParam );  
16.         }  
17.         break;  
18.     case WM_KEYUP:  
19.         //如果按键消息响应函数有效则调用函数指针m_lpfnAccelerometerKeyHook所指的函数。  
20.         if ( m_lpfnAccelerometerKeyHook!=NULL )  
21.         {  
22.             (*m_lpfnAccelerometerKeyHook)( message,wParam,lParam );  
23.         }  
24.         break;  
25.     case WM_CHAR:  
26.         {  
27.             //如果输入的字符是控制符则进行相关处理。  
28.             if (wParam < 0x20)  
29.             {  
30.                 if (VK_BACK == wParam)  
31.                 {  
32.                     CCIMEDispatcher::sharedDispatcher()->dispatchDeleteBackward();  
33.                 }  
34.                 else if (VK_RETURN == wParam)  
35.                 {  
36.                     CCIMEDispatcher::sharedDispatcher()->dispatchInsertText("\n", 1);  
37.                 }  
38.                 else if (VK_TAB == wParam)  
39.                 {  
40.                     // tab input  
41.                 }  
42.                 else if (VK_ESCAPE == wParam)  
43.                 {  
44.                     // ESC input  
45.                     CCDirector::sharedDirector()->end();  
46.                 }  
47.             }  
48.             else if (wParam < 128)  
49.             {  
50.                 //如果是ASCII码，则响应文字输入。  
51.                 CCIMEDispatcher::sharedDispatcher()->dispatchInsertText((const char *)&wParam, 1);  
52.             }  
53.             else  
54.             {   //大于128的使用宽字符，所以这里将其转化为多字节字符串来输入文本。  
55.                 char szUtf8[8] = {0};  
56.                 int nLen = WideCharToMultiByte(CP_UTF8, 0, (LPCWSTR)&wParam, 1, szUtf8, sizeof(szUtf8), NULL, NULL);  
57.                 CCIMEDispatcher::sharedDispatcher()->dispatchInsertText(szUtf8, nLen);  
58.             }  
59.             //如果按键消息响应函数有效则调用函数指针m_lpfnAccelerometerKeyHook所指的函数。  
60.             if ( m_lpfnAccelerometerKeyHook!=NULL )  
61.             {  
62.                (*m_lpfnAccelerometerKeyHook)( message,wParam,lParam );  
63.             }  
64.         }  
65.         break;  
66. …  
67. }  

 

    可以看到，CCEGLView类中有一个成员函数指针m_lpfnAccelerometerKeyHook，它将具体的实际的按键处理交给了外部函数。

 

那么，是谁？在哪里去设置函数指针指向的函数呢？我们保留疑问，继续学习。

        我们打开CCLayer.h，我们来看一下CCLayer的声明：

class   CC_DLL CCLayer :public CCNode, public CCTouchDelegate,public   CCAccelerometerDelegate,publicCCKeypadDelegate

         在这一行里，我们可以清楚的知道CCLayer的本质是什么，它是具有输入功能的节点。

CCAccelerometerDelegate是加速键消息处理接口类，可以接收到加速键产生的速度信息并进行处理，我们打开源码

CCAccelerometerDelegate.h来看一下：

[cpp]  view plain copy

1. //这个结构用于记录当前时刻的X,Y,Z三个方向的速度信息。  
2. typedef struct   
3. {  
4.     double x;  
5.     double y;  
6.     double z;  
7.     double timestamp;  
8. }   
9. CCAcceleration;  
10.   
11. //类CCAccelerometerDelegate  
12. class CC_DLL CCAccelerometerDelegate  
13. {  
14. public:  
15.     //接受CCAcceleration消息处理的虚函数。  
16.     virtual void didAccelerate(CCAcceleration* pAccelerationValue) {CC_UNUSED_PARAM(pAccelerationValue);}  
17. };  

再回到CCLayer.h：

[cpp]  view plain copy

1. class CC_DLL CCLayer : public CCNode, public CCTouchDelegate, public CCAccelerometerDelegate, public CCKeypadDelegate  
2. ｛  
3.     …  
4.     //重载CCAccelerometerDelegate中相应函数，具体实现相应功能。  
5.     virtual void didAccelerate(CCAcceleration* pAccelerationValue)   
6. {CC_UNUSED_PARAM(pAccelerationValue);}  
7.     …  
8.     //取得是否开启响应按键处理。  
9. bool isAccelerometerEnabled();  
10. //设置是否开启响应按键处理。  
11. void setAccelerometerEnabled(bool value);  
12. …  
13. protected:     
14.  bool m_bIsAccelerometerEnabled;  
15.  …  
16. }  

打开CPP:

[cpp]  view plain copy

1. //取得是否开启响应按键处理。  
2. bool CCLayer::isAccelerometerEnabled()  
3. {  
4.     return m_bIsAccelerometerEnabled;  
5. }  
6. //设置是否开启响应按键处理。  
7. void CCLayer::setAccelerometerEnabled(bool enabled)  
8. {  
9.     if (enabled != m_bIsAccelerometerEnabled)  
10.     {  
11.         m_bIsAccelerometerEnabled = enabled;  
12.         //如果正在运行中。  
13.         if (m_bIsRunning)  
14.         {  
15.             //取得当前设备  
16.             CCDirector* pDirector = CCDirector::sharedDirector();  
17.             if (enabled)  
18.             {  
19.                 //取得设备的加速键管理器，设置其内部的按键消息响应处理接口类对象指针指向当前层。  
20.                 pDirector->getAccelerometer()->setDelegate(this);  
21.             }  
22.             else  
23.             {   //取得设备的加速键管理器，设置其内部的按键消息响应处理接口类对象指针为空。  
24.                 pDirector->getAccelerometer()->setDelegate(NULL);  
25.             }  
26.         }  
27.     }  
28. }  

    设备也不甘寂寞啊。里面有一个getAccelerometer函数为取得加速键管理器。

打开CCDirector.h:

 

CC_PROPERTY(CCAccelerometer*,m_pAccelerometer, Accelerometer);

 

CCAccelerometer类的定义在CCAccelerometer.h中：

[cpp]  view plain copy

1. class CC_DLL CCAccelerometer  
2. {  
3. public:  
4.     //构造与析构  
5.     CCAccelerometer();  
6.     ~CCAccelerometer();  
7.     //设置加速键消息响应处理接口类实例指针。  
8.     void setDelegate(CCAccelerometerDelegate* pDelegate);  
9.     //更新当前时刻的速度处理。  
10.     void update( double x,double y,double z,double timestamp );  
11. private:  
12.     //当前时刻的速度信息。  
13.     CCAcceleration m_obAccelerationValue;  
14.     //加速键消息响应处理接口类实例指针。  
15.     CCAccelerometerDelegate* m_pAccelDelegate;  
16. };  

其对应CPP为：

[cpp]  view plain copy

1. namespace  
2. {  
3.     //定义一些命名空间中的全局变量。  
4.     //X,Y,Z方向的速度  
5.     double            g_accelX=0.0;  
6.     double            g_accelY=0.0;  
7.     double            g_accelZ=0.0;  
8.     //X,Y,Z方向的加速度  
9.     const double    g_accelerationStep=0.2f;  
10.     const double    g_minAcceleration=-1.0f;  
11.     const double    g_maxAcceleration=1.0f;  
12.     //命名空间内的模版函数，用于取得val的有效值（即限定了最小和最大范围）  
13.     template <class T>  
14.     T CLAMP( const T val,const T minVal,const T maxVal )  
15.     {  
16.         CC_ASSERT( minVal<=maxVal );  
17.         T    result=val;  
18.         if ( result<minVal )  
19.             result=minVal;  
20.         else if ( result>maxVal )  
21.             result=maxVal;  
22.   
23.         CC_ASSERT( minVal<=result && result<=maxVal );  
24.         return result;  
25.     }  
26.     //命名空间内的函数，用于响应按下键后的处理。  
27.     bool handleKeyDown( WPARAM wParam )  
28.     {//定义变量值设置是否有速度更新。  
29.         bool    sendUpdate=false  
30.         //通过接键来处理X,Y,Z方向的速度变化。  
31.         switch( wParam )  
32.         {  
33.         case VK_LEFT:  
34.             sendUpdate=true;     
35. //X方向速度减小 g_accelX=CLAMP( g_accelX-g_accelerationStep,g_minAcceleration,g_maxAcceleration );  
36.             break;  
37.         case VK_RIGHT:  
38.             sendUpdate=true;  
39. //X方向速度增大  
40. g_accelX=CLAMP( g_accelX+g_accelerationStep,g_minAcceleration,g_maxAcceleration );  
41.             break;  
42.         case VK_UP:  
43.             sendUpdate=true;  
44. //Y方向速度增大  
45. g_accelY=CLAMP( g_accelY+g_accelerationStep,g_minAcceleration,g_maxAcceleration );  
46.             break;  
47.         case VK_DOWN:  
48.             sendUpdate=true;  
49. //Y方向速度减小  
50. g_accelY=CLAMP( g_accelY-g_accelerationStep,g_minAcceleration,g_maxAcceleration );  
51.             break;  
52.         case VK_OEM_COMMA:  
53.             sendUpdate=true;  
54. //Z方向速度增大  
55. g_accelZ=CLAMP( g_accelZ+g_accelerationStep,g_minAcceleration,g_maxAcceleration );  
56.             break;  
57.         case VK_OEM_PERIOD:  
58.             sendUpdate=true;  
59. //Z方向速度减小  
60. g_accelZ=CLAMP( g_accelZ-g_accelerationStep,g_minAcceleration,g_maxAcceleration );  
61.             break;  
62.         }  
63.         //返回是否有速度更新。  
64.         return sendUpdate;  
65.     }  
66.     //命名空间内的函数，用于响应键松开时的处理。  
67.     bool handleKeyUp( WPARAM wParam )  
68.     {//定义变量值设置是否有速度更新。  
69.         bool    sendUpdate=false;  
70.         switch( wParam )  
71.         {  
72.         case VK_LEFT:  
73.         case VK_RIGHT:  
74.             sendUpdate=true;  
75.             //将速度重置为零  
76.             g_accelX=0.0;  
77.             break;  
78.         case VK_UP:  
79.         case VK_DOWN:  
80.             sendUpdate=true;  
81.                 //将速度重置为零  
82.             g_accelY=0.0;  
83.             break;  
84.         case VK_OEM_COMMA:  
85.         case VK_OEM_PERIOD:  
86.             sendUpdate=true;  
87.                 //将速度重置为零  
88.             g_accelZ=0.0;  
89.             break;  
90.         }  
91.         //返回是否有速度更新。  
92.         return sendUpdate;  
93.     }  
94.     //命名空间内的函数，用于加速键响应处理函数。  
95.     void myAccelerometerKeyHook( UINT message,WPARAM wParam,LPARAM lParam )  
96.     {  
97.         //取得加速键管理器指针  
98.         cocos2d::CCAccelerometer    *pAccelerometer = cocos2d::CCDirector::sharedDirector()->getAccelerometer();  
99.         bool                        sendUpdate=false;  
100.         switch( message )  
101.         {  
102.         case WM_KEYDOWN:  
103.             //调用按下加速键的处理。  
104.             sendUpdate=handleKeyDown( wParam );  
105.             break;  
106.         case WM_KEYUP:  
107.             //调用松开加速键的处理。  
108.             sendUpdate=handleKeyUp( wParam );  
109.             break;  
110.         case WM_CHAR:  
111.             break;  
112.         default:  
113.             // Not expected to get here!!  
114.             CC_ASSERT( false );  
115.             break;  
116.         }  
117.         //如果有速度更新。  
118.         if ( sendUpdate )  
119.         {  
120.             //计算当前时间。  
121.             const time_t    theTime=time(NULL);  
122.             const double    timestamp=(double)theTime / 100.0;  
123. //调用加速键管理器的更新函数更新当前速度         pAccelerometer->update( g_accelX,g_accelY,g_accelZ,timestamp );  
124.         }  
125.     }  
126.     //重置速度  
127.     void resetAccelerometer()  
128.     {  
129.         g_accelX=0.0;  
130.         g_accelY=0.0;  
131.         g_accelZ=0.0;  
132.     }  
133.   
134. }  
135.   
136. NS_CC_BEGIN  
137. //构造函数。  
138. CCAccelerometer::CCAccelerometer() :   
139.     m_pAccelDelegate(NULL)  
140. {  
141.     memset(&m_obAccelerationValue, 0, sizeof(m_obAccelerationValue));  
142. }  
143.   
144. //析构  
145. CCAccelerometer::~CCAccelerometer()   
146. {  
147.   
148. }  
149. //设置加速键所用的加速键消息处理接口类实例。  
150. void CCAccelerometer::setDelegate(CCAccelerometerDelegate* pDelegate)   
151. {  
152.     //保存加速键消息处理接口类实例  
153.     m_pAccelDelegate = pDelegate;  
154.     if (pDelegate)  
155.     {  
156.         //这里就解答了之前的疑问，也就是说，如果你对CCLayer设置开启响应按键处理，则会设置CCEGLView类实例使用的按键消息处理回调函数为命名空间内的函数myAccelerometerKeyHook。  
157. CCEGLView::sharedOpenGLView()->setAccelerometerKeyHook( &myAccelerometerKeyHook );  
158.     }  
159.     else  
160.     {  
161.         //如果参数为空，这里就注销设置CCEGLView类实例使用的按键消息处理回调函数。同时重置速度值。  
162. CCEGLView::sharedOpenGLView()->setAccelerometerKeyHook( NULL );  
163.         resetAccelerometer();  
164.     }  
165. }  
166. //加速键的更新函数，用于更新当前速度  
167. void CCAccelerometer::update( double x,double y,double z,double timestamp )   
168. {  
169.     //保存相应的值到结构变量中。  
170.     if (m_pAccelDelegate)  
171.     {  
172.         m_obAccelerationValue.x            = x;  
173.         m_obAccelerationValue.y            = y;  
174.         m_obAccelerationValue.z            = z;  
175.         m_obAccelerationValue.timestamp = timestamp;  
176.   
177.         //调用虚函数进行处理，实际处理方式就由m_pAccelDelegate的派生类实例(如CCLayer及其派生类实例)来具体实现了。  
178.         m_pAccelDelegate->didAccelerate(&m_obAccelerationValue);  
179.     }      
180. }  

有点迷糊吧，现在我来解释一下这个圈子是怎么一回事。

见图：

原理说明：

      有一个函数myAccelerometerKeyHook，它会取得当前设备中的加速键管理器(CCAccelerometer)实例对象，并将接受到的按键消息做为参数调用其update函数，其update函数将按键消息生成的速度信息结构转发给相应的速度信息处理接口类(CCAccelerometerDelegate)实例指针，然后由此指针所指向的实例对象调用虚函数didAccelerate来进行实现相应的加速效果。

      当我们对一个速度信息处理接口类(CCAccelerometerDelegate)的派生类，如CCLayer及其派生类设置开启响应加速键消息处理时，系统会将其设置为设备的加速键管理器(CCAccelerometer)实例对象的速度信息处理接口类(CCAccelerometerDelegate)实例指针，并将函数myAccelerometerKeyHook设置为CCEGLView类实例使用的按键消息处理回调函数。

    原理解释清楚了，现在我们来看一下TestCpp中的AccelerometerTest。

打开头文件：

[cpp]  view plain copy

1. //演示层AccelerometerTest。  
2. class AccelerometerTest: public CCLayer  
3. {  
4. protected:  
5.     //用于演示加速变化的精灵。  
6. CCSprite* m_pBall;  
7. //上一帧的时间。  
8.     double    m_fLastTime;  
9.   
10. public:  
11.     //构造与析构  
12.     AccelerometerTest(void);  
13.     ~AccelerometerTest(void);  
14.     //关键之处了，具体实现按键后的速度变化。参数为按键后收到的速度信息。  
15.     virtual void didAccelerate(CCAcceleration* pAccelerationValue);  
16.     //取得标题。  
17. virtual std::string title();  
18. //当前层加载时的处理。  
19.     virtual void onEnter();  
20. };  
21.   
22. //用于演示的场景。  
23. class AccelerometerTestScene : public TestScene  
24. {  
25. public:  
26.     //加载场景时的处理。  
27.     virtual void runThisTest();  
28. };  

打开CPP：

[cpp]  view plain copy

1. //定义宏，限定_pos的有效范围值。  
2. #define FIX_POS(_pos, _min, _max) \  
3.     if (_pos < _min)        \  
4.     _pos = _min;        \  
5. else if (_pos > _max)   \  
6.     _pos = _max;        \  
7.   
8. //构造  
9. AccelerometerTest::AccelerometerTest(void)  
10. : m_fLastTime(0.0)  
11. {  
12. }  
13. //析构  
14. AccelerometerTest::~AccelerometerTest(void)  
15. {  
16.     //对占用的小球引用计数减一。因为在onEnter中进行了加一操作。  
17.     m_pBall->release();  
18. }  
19. //取得标题。  
20. std::string AccelerometerTest::title()  
21. {  
22.     return "AccelerometerTest";  
23. }  
24. //加载当前层时的处理。  
25. void AccelerometerTest::onEnter()  
26. {  
27.     //调用基类的相应函数。  
28.     CCLayer::onEnter();  
29.     //设置开启响应加速键  
30.     setAccelerometerEnabled(true);  
31.     //取得窗口大小   
32.     CCSize s = CCDirector::sharedDirector()->getWinSize();  
33.     //创建一个文字标签。  
34. CCLabelTTF* label = CCLabelTTF::create(title().c_str(), "Arial", 32);  
35. //将文字标签加入到当前层中。  
36.     addChild(label, 1);  
37.     //设置文字标签的位置。  
38.     label->setPosition( CCPointMake(s.width/2, s.height-50) );  
39.     //由一个小球的图片创建一个精灵。  
40.     m_pBall = CCSprite::create("Images/ball.png");  
41.     //设置小球的位置居于屏幕中央。  
42.     m_pBall->setPosition(ccp(s.width / 2, s.height / 2));  
43.     //将小球放到当前层中。  
44.     addChild(m_pBall);  
45.     //占用小球，让小球的引用计数器加一。这里加一，在析构时就必须减一才能使引用计数器保证不乱。不过个人认为这里引用计数加一没什么必要。因为addChild已经对小球精灵做了引用计数加一操作了，代表了占用，再加一略显繁琐。  
46.     m_pBall->retain();  
47. }  
48. //具体实现按键后的速度变化。参数为按键后收到的速度信息。  
49. void AccelerometerTest::didAccelerate(CCAcceleration* pAccelerationValue)  
50. {  
51.     //取得设备及窗口大小。  
52.     CCDirector* pDir = CCDirector::sharedDirector();  
53.     CCSize winSize   = pDir->getWinSize();  
54.   
55.     //判断小球精灵是否有效。  
56.     if ( m_pBall == NULL ) {  
57.         return;  
58.     }  
59.     //取得小球的图像区域大小。  
60.     CCSize ballSize  = m_pBall->getContentSize();  
61.     //取得小球的当前位置。  
62.     CCPoint ptNow  = m_pBall->getPosition();  
63.     //将当前位置转换成界面坐标系的位置。  
64.     CCPoint ptTemp = pDir->convertToUI(ptNow);  
65.     //由收到的速度乘以一个系数后来影响位置。  
66.     ptTemp.x += pAccelerationValue->x * 9.81f;  
67.     ptTemp.y -= pAccelerationValue->y * 9.81f;  
68.     //再转换为OPENGL坐标系的位置。貌似有点麻烦，其实直接在上面X,Y的加减上做上正确的方向即可。  
69.     CCPoint ptNext = pDir->convertToGL(ptTemp);  
70.     //限定位置的X,Y的有效范围，等于小球边缘始终在窗口内。  
71.     FIX_POS(ptNext.x, (ballSize.width / 2.0), (winSize.width - ballSize.width / 2.0));  
72.     FIX_POS(ptNext.y, (ballSize.height / 2.0), (winSize.height - ballSize.height / 2.0));  
73.     //将位置传给小球。  
74.     m_pBall->setPosition(ptNext);  
75. }  
76.   
77. //运行场景  
78. void AccelerometerTestScene::runThisTest()  
79. {  
80.     //创建一个新的AccelerometerTest的实例并加入当前场景之中。  
81.     CCLayer* pLayer = new AccelerometerTest();  
82. addChild(pLayer);  
83. //new时实例的计数器会加一，所以这里release后会减1保持对应。另注意：addChild(pLayer)后也会因占用实例而对其计数器加一。  
84.     pLayer->release();  
85.     //运行当前场景。  
86.     CCDirector::sharedDirector()->replaceScene(this);  
87. }  

    运行结果如图：

    当我们按下键：上，下，右，左，<,>时，小球分别产生X,Y,Z的正负方向的加速度。WINDOWS在通过WM_KEYDOWN消息来即时处理按键响应时有延迟间隔的，所以按键响应不流畅，改成GetKeyState后就流畅多了，比如在CCEGLView的swapBuffer中加入相应的处理使每一帧都能进行按键的实时判断。

[cpp]  view plain copy

1. void CCEGLView::swapBuffers()  
2. {  
3.     if (m_hDC != NULL)  
4.     {  
5.         ::SwapBuffers(m_hDC);  
6.     }     
7.     //如果按下左键  
8.     if(GetKeyState(VK_LEFT) < 0)  
9.     {  
10.            if ( m_lpfnAccelerometerKeyHook!=NULL )  
11.             {  
12.                 (*m_lpfnAccelerometerKeyHook)( WM_KEYDOWN,VK_LEFT,0 );  
13.             }  
14.     }  
15.     ….按上面写的如法炮制即可。  
16. }