//淡入动画:渐渐显现的动画.

1. //淡入动画:渐渐显现的动画.
   
2. class CC_DLL CCFadeIn : public CCActionInterval
   
3. {
   
4. public:
   
5.         //重载相应函数.
   
6.     virtual void update(float time);
   
7.     virtual CCActionInterval* reverse(void);
   
8.     virtual CCObject* copyWithZone(CCZone* pZone);
   
9. 
   
10. public:
    
11.     //创建一个淡入动画,内部调用create实现.参数为淡入时间.
    
12.     CC_DEPRECATED_ATTRIBUTE static CCFadeIn* actionWithDuration(float d);
    
13.     //创建一个淡入动画
    
14.     static CCFadeIn* create(float d);
    
15. };
    
16. 具体实现：
    
17. //创建一个淡入动画,内部调用create实现.
    
18. CCFadeIn* CCFadeIn::actionWithDuration(float d)
    
19. {
    
20.     return CCFadeIn::create(d);
    
21. }
    
22. //创建一个渐渐显现的淡入动画.
    
23. CCFadeIn* CCFadeIn::create(float d)
    
24. {
    
25.         //利用new创建一个淡入动画.初始化后交由内存管理器进行释放处理.
    
26.     CCFadeIn* pAction = new CCFadeIn();
    
27. 
    
28.     pAction->initWithDuration(d);
    
29.     pAction->autorelease();
    
30.         //返回创建的淡入动画.
    
31.     return pAction;
    
32. }
    
33. //创建一个拷贝.
    
34. CCObject* CCFadeIn::copyWithZone(CCZone *pZone)
    
35. {
    
36.     CCZone* pNewZone = NULL;
    
37.     CCFadeIn* pCopy = NULL;
    
38.     if(pZone && pZone->m_pCopyObject)
    
39.     {
    
40.         //in case of being called at sub class
    
41.         pCopy = (CCFadeIn*)(pZone->m_pCopyObject);
    
42.     }
    
43.     else
    
44.     {
    
45.         pCopy = new CCFadeIn();
    
46.         pZone = pNewZone = new CCZone(pCopy);
    
47.     }
    
48.     
    
49.     CCActionInterval::copyWithZone(pZone);
    
50. 
    
51.     CC_SAFE_DELETE(pNewZone);
    
52. 
    
53.     return pCopy;
    
54. }
    
55. //更新淡入动画.
    
56. void CCFadeIn::update(float time)
    
57. {
    
58.         //将演员由精灵类降为色彩控制基类CCRGBAProtocol .
    
59.         CCRGBAProtocol *pRGBAProtocol = dynamic_cast<CCRGBAProtocol*>(m_pTarget);
    
60.     if (pRGBAProtocol)
    
61.     {        //如果转换成功,按时间进度设置透明度.透明度取值0~255,所以要乘以255.
    
62.         pRGBAProtocol->setOpacity((GLubyte)(255 * time));
    
63.     }
    
64.     /*m_pTarget->setOpacity((GLubyte)(255 * time));*/
    
65. }
    
66. //创建一个反向播放的淡入动画.其实是创建一个相同时间的渐渐消失的淡出动画.
    
67. CCActionInterval* CCFadeIn::reverse(void)
    
68. {
    
69.     return CCFadeOut::create(m_fDuration);
    
70. }

复制代码

CCFadeOut:

1. //淡出动画:渐渐消失的动画.
   
2. class CC_DLL CCFadeOut : public CCActionInterval
   
3. {
   
4. public:
   
5.         //重载相应函数.
   
6.     virtual void update(float time);
   
7.     virtual CCActionInterval* reverse(void);
   
8.     virtual CCObject* copyWithZone(CCZone* pZone);
   
9. 
   
10. public:
    
11.     //创建一个淡出动画,内部调用create实现.参数为淡入时间.
    
12.     CC_DEPRECATED_ATTRIBUTE static CCFadeOut* actionWithDuration(float d);
    
13. 
    
14.     //创建一个淡出动画.
    
15.     static CCFadeOut* create(float d);
    
16. };
    
17. 具体实现：
    
18. //创建一个淡出动画,内部调用create实现.参数为淡入时间.
    
19. CCFadeOut* CCFadeOut::actionWithDuration(float d)
    
20. {
    
21.     return CCFadeOut::create(d);
    
22. }
    
23. //创建一个淡出动画.
    
24. CCFadeOut* CCFadeOut::create(float d)
    
25. {
    
26.         //利用new创建一个淡出动画.初始化后交由内存管理器进行释放处理.
    
27.     CCFadeOut* pAction = new CCFadeOut();
    
28. 
    
29.     pAction->initWithDuration(d);
    
30.     pAction->autorelease();
    
31.         //返回创建的动画实例对象指针.
    
32.     return pAction;
    
33. }
    
34. //创建拷贝.
    
35. CCObject* CCFadeOut::copyWithZone(CCZone *pZone)
    
36. {
    
37.     CCZone* pNewZone = NULL;
    
38.     CCFadeOut* pCopy = NULL;
    
39.     if(pZone && pZone->m_pCopyObject) 
    
40.     {
    
41.         //in case of being called at sub class
    
42.         pCopy = (CCFadeOut*)(pZone->m_pCopyObject);
    
43.     }
    
44.     else
    
45.     {
    
46.         pCopy = new CCFadeOut();
    
47.         pZone = pNewZone = new CCZone(pCopy);
    
48.     }
    
49. 
    
50.     CCActionInterval::copyWithZone(pZone);
    
51. 
    
52.     CC_SAFE_DELETE(pNewZone);
    
53. 
    
54.     return pCopy;
    
55. }
    
56. //更新淡出动画.
    
57. void CCFadeOut::update(float time)
    
58. {
    
59.         //将演员由精灵类降为色彩控制基类CCRGBAProtocol .
    
60.         CCRGBAProtocol *pRGBAProtocol = dynamic_cast<CCRGBAProtocol*>(m_pTarget);
    
61.     if (pRGBAProtocol)
    
62.     {        //如果转换成功,按时间进度设置透明度.透明度取值0~255,所以要乘以255.
    
63.         pRGBAProtocol->setOpacity(GLubyte(255 * (1 - time)));
    
64.     }
    
65.     /*m_pTarget->setOpacity(GLubyte(255 * (1 - time)));*/    
    
66. }
    
67. //创建一个反向播放的淡出动画.其实是创建一个相同时间的渐渐显示的淡入动画.
    
68. CCActionInterval* CCFadeOut::reverse(void)
    
69. {
    
70.     return CCFadeIn::create(m_fDuration);
    
71. }
    
72. 
    
73. //透明度渐变动画:从当前透明度渐渐变化到指定的透明度.
    
74. class CC_DLL CCFadeTo : public CCActionInterval
    
75. {
    
76. public:
    
77.     //初始化，参数一为时间长度，参数二为目标透明度。
    
78.     bool initWithDuration(float duration, GLubyte opacity);
    
79.         //重载基类相应函数。
    
80.     virtual CCObject* copyWithZone(CCZone* pZone);
    
81.     virtual void startWithTarget(CCNode *pTarget);
    
82.     virtual void update(float time);
    
83. 
    
84. public:
    
85.     //创建一个透明度渐变动画，内部调用create实现，参数一为时间长度，参数二为目标透明度。
    
86.     CC_DEPRECATED_ATTRIBUTE static CCFadeTo* actionWithDuration(float duration, GLubyte opacity);
    
87.     //创建一个透明度渐变动画。
    
88.     static CCFadeTo* create(float duration, GLubyte opacity);
    
89. protected:
    
90.         //目标透明度
    
91.         GLubyte m_toOpacity;
    
92.         //当前透明度。
    
93.     GLubyte m_fromOpacity;
    
94. };
    
95. 具体实现：
    
96. //创建一个透明度渐变动画，内部调用create实现，参数一为时间长度，参数二为目标透明度。
    
97. CCFadeTo* CCFadeTo::actionWithDuration(float duration, GLubyte opacity)
    
98. {
    
99.      return CCFadeTo::create(duration, opacity);
    
100. }
     
101. //创建一个透明度渐变动画。
     
102. CCFadeTo* CCFadeTo::create(float duration, GLubyte opacity)
     
103. {
     
104.         //利用new创建一个透明度渐变动画.初始化后交由内存管理器进行释放处理.
     
105.     CCFadeTo *pFadeTo = new CCFadeTo();
     
106.     pFadeTo->initWithDuration(duration, opacity);
     
107.     pFadeTo->autorelease();
     
108.         //返回创建的动画实例对象指针。
     
109.     return pFadeTo;
     
110. }
     
111. //初始化。
     
112. bool CCFadeTo::initWithDuration(float duration, GLubyte opacity)
     
113. {
     
114.         //调用基类的初始化函数。
     
115.     if (CCActionInterval::initWithDuration(duration))
     
116.         {
     
117.         //保存目标透明度值并返回成功。
     
118.         m_toOpacity = opacity;
     
119.         return true;
     
120.     }
     
121.         //否则返回失败。
     
122.     return false;
     
123. }
     
124. //创建拷贝。
     
125. CCObject* CCFadeTo::copyWithZone(CCZone *pZone)
     
126. {
     
127.     CCZone* pNewZone = NULL;
     
128.     CCFadeTo* pCopy = NULL;
     
129.     if(pZone && pZone->m_pCopyObject) 
     
130.     {
     
131.         //in case of being called at sub class
     
132.         pCopy = (CCFadeTo*)(pZone->m_pCopyObject);
     
133.     }
     
134.     else
     
135.     {
     
136.         pCopy = new CCFadeTo();
     
137.         pZone = pNewZone = new CCZone(pCopy);
     
138.     }
     
139. 
     
140.     CCActionInterval::copyWithZone(pZone);
     
141. 
     
142.     pCopy->initWithDuration(m_fDuration, m_toOpacity);
     
143.     
     
144.     CC_SAFE_DELETE(pNewZone);
     
145.     return pCopy;
     
146. }
     
147. //设置演示当前动画的演员。
     
148. void CCFadeTo::startWithTarget(CCNode *pTarget)
     
149. {
     
150.         //调用基类相应函数。
     
151.     CCActionInterval::startWithTarget(pTarget);
     
152.         //将演员由精灵类降为色彩控制基类CCRGBAProtocol .
     
153.     CCRGBAProtocol *pRGBAProtocol = dynamic_cast<CCRGBAProtocol*>(pTarget);
     
154.     if (pRGBAProtocol)
     
155.         {
     
156.         //取得当前演员的透明度做为起始透明度。
     
157.         m_fromOpacity = pRGBAProtocol->getOpacity();
     
158.     }
     
159.     /*m_fromOpacity = pTarget->getOpacity();*/
     
160. }
     
161. //更新动画。
     
162. void CCFadeTo::update(float time)
     
163. {
     
164.         //将演员由精灵类降为色彩控制基类CCRGBAProtocol .
     
165.     CCRGBAProtocol *pRGBAProtocol = dynamic_cast<CCRGBAProtocol*>(m_pTarget);
     
166.     if (pRGBAProtocol)
     
167.         {
     
168.         //通过时间插值计算当前演员的透明度值。
     
169.         pRGBAProtocol->setOpacity((GLubyte)(m_fromOpacity + (m_toOpacity - m_fromOpacity) * time));
     
170.     }
     
171.     /*m_pTarget->setOpacity((GLubyte)(m_fromOpacity + (m_toOpacity - m_fromOpacity) * time));*/
     
172. }

复制代码

CCTintTo:

1. //变色动画：从当前演员的色彩值变化到目标色彩。
   
2. class CC_DLL CCTintTo : public CCActionInterval
   
3. {
   
4. public:
   
5.     //初始化：参一为动画时长，参二，三，四分别代表目标色彩的红色，绿色，蓝色的分量。
   
6.     bool initWithDuration(float duration, GLubyte red, GLubyte green, GLubyte blue);
   
7.         //重载基类函数。
   
8.     virtual CCObject* copyWithZone(CCZone* pZone);
   
9.     virtual void startWithTarget(CCNode *pTarget);
   
10.     virtual void update(float time);
    
11. 
    
12. public:
    
13.     //创建一个变色动画，内部调用create实现。参一为动画时长，参二，三，四分别代表目标色彩的红色，绿色，蓝色的分量。
    
14.     CC_DEPRECATED_ATTRIBUTE static CCTintTo* actionWithDuration(float duration, GLubyte red, GLubyte green, GLubyte blue);
    
15.     //创建一个变色动画。
    
16.     static CCTintTo* create(float duration, GLubyte red, GLubyte green, GLubyte blue);
    
17. protected:
    
18.         //目标的三原色。
    
19.         ccColor3B m_to;
    
20.         //起始的三原色。
    
21.     ccColor3B m_from;
    
22. };
    
23. 具体实现：
    
24. //创建一个变色动画，内部调用create实现。参一为动画时长，参二，三，四分别代表目标色彩的红色，绿色，蓝色的分量。
    
25. CCTintTo* CCTintTo::actionWithDuration(float duration, GLubyte red, GLubyte green, GLubyte blue)
    
26. {
    
27.     return CCTintTo::create(duration, red, green, blue);
    
28. }
    
29. //创建一个变色动画。
    
30. CCTintTo* CCTintTo::create(float duration, GLubyte red, GLubyte green, GLubyte blue)
    
31. {
    
32.         //利用new创建一个变色动画.初始化后交由内存管理器进行释放处理.
    
33.     CCTintTo *pTintTo = new CCTintTo();
    
34.     pTintTo->initWithDuration(duration, red, green, blue);
    
35.     pTintTo->autorelease();
    
36.         //返回创建的动画实例对象指针。
    
37.     return pTintTo;
    
38. }
    
39. //初始化。
    
40. bool CCTintTo::initWithDuration(float duration, GLubyte red, GLubyte green, GLubyte blue)
    
41. {
    
42.         //先调用基类的初始化函数。
    
43.     if (CCActionInterval::initWithDuration(duration))
    
44.         {
    
45.         //保存目标色彩值。
    
46.         m_to = ccc3(red, green, blue);
    
47.         //返回成功。
    
48.         return true;
    
49.     }
    
50.         //如果初始化失败返回false。
    
51.     return false;
    
52. }
    
53. //创建拷贝。
    
54. CCObject* CCTintTo::copyWithZone(CCZone *pZone)
    
55. {
    
56.     CCZone* pNewZone = NULL;
    
57.     CCTintTo* pCopy = NULL;
    
58.     if(pZone && pZone->m_pCopyObject) 
    
59.     {
    
60.         //in case of being called at sub class
    
61.         pCopy = (CCTintTo*)(pZone->m_pCopyObject);
    
62.     }
    
63.     else
    
64.     {
    
65.         pCopy = new CCTintTo();
    
66.         pZone = pNewZone = new CCZone(pCopy);
    
67.     }
    
68. 
    
69.     CCActionInterval::copyWithZone(pZone);
    
70. 
    
71.     pCopy->initWithDuration(m_fDuration, m_to.r, m_to.g, m_to.b);
    
72.     
    
73.     CC_SAFE_DELETE(pNewZone);
    
74.     return pCopy;
    
75. }
    
76. //设置演示变色动画的演员。
    
77. void CCTintTo::startWithTarget(CCNode *pTarget)
    
78. {
    
79.         //调用基类的相应函数。
    
80.         CCActionInterval::startWithTarget(pTarget);
    
81.         //将演员由精灵类降为色彩控制基类CCRGBAProtocol .
    
82.     CCRGBAProtocol *pRGBAProtocol = dynamic_cast<CCRGBAProtocol*>(m_pTarget);
    
83.     if (pRGBAProtocol)
    
84.         {
    
85.         //取得演员的色彩值做为起始色彩值。
    
86.         m_from = pRGBAProtocol->getColor();
    
87.     }
    
88.     /*m_from = pTarget->getColor();*/
    
89. }
    
90. //更新动画的播放。
    
91. void CCTintTo::update(float time)
    
92. {
    
93.         //将演员由精灵类降为色彩控制基类CCRGBAProtocol .
    
94.     CCRGBAProtocol *pRGBAProtocol = dynamic_cast<CCRGBAProtocol*>(m_pTarget);
    
95.     if (pRGBAProtocol)
    
96.         {
    
97.         //利用时间对色彩变化进行插值，计算出演员的当前色彩值。
    
98.         pRGBAProtocol->setColor(ccc3(GLubyte(m_from.r + (m_to.r - m_from.r) * time), 
    
99.             (GLbyte)(m_from.g + (m_to.g - m_from.g) * time),
    
100.             (GLbyte)(m_from.b + (m_to.b - m_from.b) * time)));
     
101.     }    
     
102. }

复制代码

转自http://blog.csdn.net/honghaier/article/details/8214030