*USA/UK--en'---''a new milestone: Cocos2D-X V3.0 released the official version + + + + there are many others ..!. "TW--zht--'新里程碑：在Cocos2D-X V3.0正式版本發布！++++其他的.還有很多的.. *PT(FDZ)Macau'---''''um novo marco: Cocos2D-X V3.0 lançou a versão oficial + + + + existem muitos outros ..!. -한국 언어*South of Koren---'새로운 이정표 :적인 Cocos2D-X V3.0은 많은 사람들이 공식 버전 + + + +를 출시 ..!.-*Internacia Lingvo' ----"'' nova mejloŝtono: Cocos2D-X v3.0 liberigis la oficiala versio + + + + estas multaj aliaj ..!.

**USA/UK--en'---''a new milestone: Cocos2D-X V3.0     
 released the official version + + + + there are many others ..!. 

"TW--zht--'新里程碑：在Cocos2D-X V3.0正式版本發布！++++其他的.還有很多的..
*PT(FDZ)Macau'---''''um novo marco: Cocos2D-X V3.0 lançou a versão oficial + + + + existem muitos outros ..!. 
-한국 언어*South of Koren---'새로운 이정표 :적인 Cocos2D-X V3.0은 많은 사람들이 공식 버전 + + + +를 출시 ..!. 
*Internacia Lingvo' ----"'' nova mejloŝtono: Cocos2D-X v3.0 liberigis la oficiala versio + + + + estas multaj aliaj ..!. *

*#**USA/UK--en"---(1).Note - This is the Cocos2D-X V3.0 office / 
 !!!!!!! *****2). --- T-off state "- 
'' --- **** 3).Indezine News 
****4). Behance "" "----- 
**** 5).Sketchfab ----- 
Send to squeeze into our mailbox'' burst'' 
Because we are too lazy a [not much time deliberately mailboxes, and clean-up, causing the congestion significantly, 
There are many hidden and unknown spam and deleted by us all at once. 
Valuable in - our tribe, the actual content must be'' rich'' excellent'' and the'' good of each person'' before'' big'' we give and share Shu congregation of large software / tools / Information, 
-------------------------------------------------- --------------------------------------------- 
After six months of carefully polished, the official version of Cocos2D-X V3.0 final release! Compared to last September's Cocos2D-X v3.0-alpha version, the official version of the renderer, performance, compatibility, stability, etc. have been a qualitative improvement, and add support for WinPhone8's. 
-------------------------------------------------- --------------- 
(1).!!!!! Cocos2D-X V3.0 office / 
---------------------------------------
 
In addition, the engine team is more separately for C + +, Lua, JavaScript three programming - 
- Have done a lot to enhance the user experience interfaces, 
We look to optimize each language: 
C + + on the basis of the underlying optimization: new renderer, the new API, performance leap 
The new renderer - more elegant, more flexible, easier to use; create the render queue, 
Each node independently released rendering instructions 
Decomposition draw commands to achieve volume rendering; 
All concentrated in OpenGL renderer, making it easier to cross-platform; 
At the same time, by creating a custom rendering commands, 
The callback function used to render logic into a custom reserved for custom OpenGL functions. 

* The new modified API - using C + +11 features replaces Objective-C language features, 
Stability and readability would be enhanced; redo a lot of containers, 
Direct packaged Std, can be automatically saved, 
More convenient to use; slowly remove the object used to inherit into Ref 
; Also made a reference to technology-based memory pool, which automatically frees memory for easy management. 
--- Performance / compatibility / memory allocation optimization - using the automatic tailoring techniques, 
Fluency big game scene was 2-8 fold increase, 
The performance of Auto-Batching automatically simulate merge function has been close to hand-tune; 
sortall Children optimized to accelerate after sorting algorithm 10 times 
After doing the cache to speed up visit three times; 
Enhance compatibility to 90.71 percent, 
Some foreign reach triple engine, 
On Chinese Android platform is very easy to use; CPU average occupancy rate also reduced by 36%. 

!! (Note ---> We do not like mainland China, but we do not have other good people, 
Hope they do not come to the overall total bureaucratic style of selfish and arrogant, 
Money to survive the primary, with the stench of this tribe, "no blending" 
As long as the "Who Cares" Whether nationality., Age characteristics, be eligible rich or poor, high or low status 
, Readers are also welcome friends Oh, just normal for the big 
Share knowledge, live to old to learn, the same taste in the world enthusiasts sharing between large Ende ~ 
Thanks again for giving me such a good variety of shared text. Thanksgiving everybody!) 

* Enhanced Lua language experience: faster development, testing, fast, fast on-line 
The new version for developers to enhance the experience in Lua, 
Improved core main aspects: 
1, using the Lua binding bindngs generator generated 
Greatly reducing the workload of the document prepared by the package; 
2, V3.0 new features for basic do binding, 
For example new Label, EventDispatcher and physics, etc. 
While some of the original c + + functions were binding, such as websocket, xmlHttpRequest, Spine, A 
OpenGL bindings ssetManager and related functions 
3, when binding a modular work automatically, 
Lua modules currently in use are cc, ccs, ccui, sp, gl 
4, registered Lua function using ScriptHandlerMgr unified management and anti-registration 
5, for the table to pass some kind Lua direct use, such as points, rectangles and size
6, an increase of Lua script called directly ObjectC Java code and 

The new product line of cocos2d-JS: HTML5 + JSB efficient integration 
Original Cocos2d-html5 and Cocos2d-JSB is now officially integrated into a new product line - 
** Cocos2d-JS, providing a consistent user experience for developers, 
Feature support, and clear workflow. 

Cocos2d-JS installation package contains a complete HTML5 runtime engine and JSB, 
Command-line tool offers three steps to get Web and 
Native convenient full-function platform deployment. 
---> First, Cocos2d-JS unified development experience using JS development, 
The HTML5 engine and JSB's highly unified API, 
The new file directory structure makes HTML5 development and the development of fully shared JSB game code, 
Full unified platform deployment tools released after the test process development, 
A development of the whole platform runs Cocos2d-JS will become more natural development experience. 
---> Secondly, in Cocos2D-JS release also completed 
HTML5 engine from 2.X to 3.0 nodes and more user-friendly operation of the API. 
---> Tools, in addition to full-platform deployment tools, 
Cocos2d-JS also offers modular configuration capabilities, 
The engine may not need to tick off all the things. 
Follow-up will add interface tools to automate packing compression, 
Currently, after completion of a minimum engine version packaged 120K. 
Meanwhile, visual debugging tools available to the current scene tree, 
Typesetting adjustment, property changes, simplify UI commissioning work. 
In addition, Intel also contributed BENCHMARK tools used in different models, 
Run on the browser points to help put on the market after the project location to which users are able to cover. 

CocoStudio new code IDE: to create a complete tool chain 
Outside the engine, Cocos2d-x team's vision - 
- Is to become a complete tool chain cross-platform game development, 
Contains from rapid prototyping to final completion of a high-performance product, 
Help developers reduce the cost and shorten the cycle, 
Promote developer ecosystem. 
---> The first part of the tool chain is the framework for the use of transfer API SDK, 
Including renderer, scene management; 
The second part is CocoStudio editor; s 
Is a three-part set of tools. 

* Currently CocoStudio version has been updated to v1.3, 
Optimized experience while adding a number of new features, new highlights: 
Animation Editor bulk operations increased animation frames, 
And onion and animation curve function; 
UI Editor supports extended UI plug; 
Scene Editor provides cool trigger functions 
Let developers do not write code to do the game. 
In addition, CocoStudio v2.0 version is also in full swing, 
The cross-platform, with plans to support JS LUA binding, 
Planning released before the end of today. 
This time, CocoStudio also added Eclipse-based cross-platform code IDE, 
Developers ready to Cocos2D-X is designed for Lua and JavaScript. 
By Cocos IDE, the game can easily create projects, 
Writing and debugging code, view real-time code modification effect, 
Eventually publish directly into a rack-mounted package. 
In the majority of developers and contributor support and companionship, 
Cocos2d-x has become a global game developers in the mobile phone and 
Independent developers who share best game engine, 
In the past 30 years, China is no second team on the basis of products and 
Technically the world to get such a high acceptance and market share. 
The official version v3.0 will strive to create a new milestone 
!!! ---- Will soon have organized a variety of developer feedback activities, so stay tuned! 
The Cocos2D-X 3.0 (Download) 
Chinese version of the release notes (click to view) 
Cocos IDE Getting Started Guide (click to view) 
Related Tutorials Recommended:...

The Cocos2D-X 3.0 (Download) 
Chinese version of the release notes (click to view) 
Cocos IDE Getting Started Guide (click to view) 
Related Tutorials Recommended: 
[In the Cocos2D-x3.x Video Tutorial] Detailed coordinates 
[In the Cocos2D-X3.0 video tutorial] three elimination games SushiCrush S01E01 
[In the Cocos2D-X3.0 video tutorial] three elimination games SushiCrush S01E02 

**Great God using google translator, select the language of each country with the family, you can download and read all of the code Oh ^ ^ ~
使用google大神翻譯器,選取各用家的國家語言,便可下載及詳閱所有代碼喔^^~
Grande Deus usando o google tradutor, selecione o idioma de cada país com a família, você pode baixar e ler todo o código Oh ^ ^ ~ 
위대한 하나님 구글 번역기를 사용하여 가족과 함께 각국의 언어를 선택, 다운로드 및 모든 코드를 읽을 수 있습니다 아 ^ ^ ~ 
Granda Dio uzante google tradukisto, elektu la lingvon de ĉiu lando kun la familio, vi povas elŝuti kaj legi la kodon, Ho ^ ^ ~ 
  http://www.010cnc.net/subject/about/Cocos2d-x%202.0%20%E6%A0%BC%E5%AD%90%E5%8B%95%E7%95%AB%E6%B7%B1%E5%85%A5%E5%88%86%E6%9E%90.html    *

          http://www.010cnc.net/subject/about/Cocos2d-x%202.0%20%E6%A0%BC%E5%AD%90%E5%8B%95%E7%95%AB%E6%B7%B1%E5%85%A5%E5%88%86%E6%9E%90.html   

[Tutorial] summarized the essence of the Cocos2D-X Tutorial Summary (Phase I) 
[Tutorial] summarized the essence of Cocos2D-X Tutorial Summary (Phase II) 
CocoaChina is the world's largest Apple Developer Chinese community, the official micro-channel regular daily push a variety of exciting research and development resources and tools tutorial introduces app promotion marketing experience, new business recruitment and outsourcing of information, as well as Cocos2d engine, Cocostudio latest development kit and training information. Concerned about the micro-channel can be the first to learn about the latest products and services to dynamic, micro letter in hand, the world I have! 

Please search Micro Signal "CocoaChina" Follow us!
--------------------------------------

 http://melodytoyssexy.blogspot.com/2014/04/usauk-en-new-milestone-cocos2d-x-v30.html

新里程碑：在的Cocos2D-X V3.0正式版本發布！

歷經半年多的精心打磨，在的Cocos2D-X V3.0正式版本最終發布！

相比於去年9月份的的的Cocos2D-X v3.0-alpha版，

正式版本在渲染器、性能、兼容性、

稳定性等方面都得到了质的提升，并新增对WinPhone8的支持。

此外，引擎团队更分别针对C++、Lua、

JavaScript三种编程接口的使用体验做了大量提升，

我们来看一下各语言的优化：

C + +的基礎底層優化：新渲染器，新的API，性能飛躍

新的渲染器 -更优雅，更灵活，更易用；

可创建渲染队列，每个节点独立发布渲染指令，分解draw命令，

实现批量渲染；所有OpenGL集中在渲染器中，

使跨平台更加容易；

同时，通过创建一个自定义的渲染命令，

用回调函数放入渲染逻辑而保留了自定义定制OpenGL的功能。

新修改過的API -使用C + +11特性取代了Objective-C语言的特性，  

稳定性与可读性得到提升;重做了许多容器，直接包装了Std，  

可自动保存，使用起来更加方便；将object慢慢移除使用，  

改成Ref来继承；另外还做了基于内存引用技术池，  

可自动释放内存，方便管理。

   Cocos2d-x 2.0 網格動畫深入分析

[Cocos2d-x相關教程來源於紅孩兒的遊戲編程之路CSDN博客地址：http://blog.csdn.net/honghaier]

紅孩兒Cocos2d-X學習園地QQ2群：44208467 加群寫：Cocos2d-x
紅孩兒Cocos2d-X學習園地QQ群：249941957 [暫滿]加群寫：Cocos2d-x 

本章為我的Cocos2d-x教程一書初稿。望各位看官多提建議！

Cocos2d-x 2.0 網格動畫深入分析

另：本章所用Cocos2d-x版本為:

cocos2d-2.0-x-2.0.2 @ Aug 30 2012

http://cn.cocos2d-x.org/download

        寫在前面：請各位大大在轉載博文時註明來源，紅孩兒每天熬夜寫博實屬不易，但屢有一些同學拿來主義，把本博的文章去頭掐尾，抹掉作者，然後赤裸裸的改成自已的 " 原創  "，實在令人氣憤。在此特聲明：本博博文，歡迎您收藏，轉載，如果有需要，也可以借用段落或插圖，請您經我同意，我不是一個刻板吝嗇的人。但如果直接剽竊，我將奮起反擊！

在TestCpp中的EffectsTest示例中展示了一些屏幕特效，  

它是將屏幕劃分為多個格子，並對這些格子進行了動畫處理從而產生出相應的屏幕特效。  

今天我們來學習一下這些動畫。

主要是涉及到以下幾個文件：

CCGrid.h /cpp :網格數據及渲染，包括基本網格數據和3D網格數據，這是數據的基礎。

CCActionGrid.h /cpp :網格基本動畫，這是動畫的基礎。

CCActionGrid3D.h/cpp: 3D網格基本動畫，這是3D網格動畫的基礎。
CCActionTiledGrid.h / cpp :網格衍生動畫，這是最終的特效實現。

咱們首先來看 關於網格數據及渲染的文件：CCGrid.h  

#ifndef __EFFECTS_CCGRID_H__ #define __EFFECTS_CCGRID_H__   #include "cocoa/CCObject.h" #include "base_nodes/CCNode.h" #include "CCCamera.h" #include "ccTypes.h" #include "textures/CCTexture2D.h" #include "CCDirector.h" #include "kazmath/mat4.h"  //使用Cocos2d命名空間 NS_CC_BEGIN  //當前.h文件要用到以下三個類的指針。  class CCTexture2D; class CCGrabber; class CCGLProgram;  //網格基類。由CCObject派生。 class CC_DLL CCGridBase : public CCObject { public:  //析構     virtual ~CCGridBase(void);      //是否激活狀態。 inline bool isActive(void) { return m_bActive; } //設置為激活狀態。     void setActive(bool bActive);      //取得     inline int getReuseGrid(void) { return m_nReuseGrid; }     inline void setReuseGrid(int nReuseGrid) { m_nReuseGrid = nReuseGrid; }      //取得網格的大小。 inline const ccGridSize& getGridSize(void) { return m_sGridSize; } //設置網格的大小。     inline void setGridSize(const ccGridSize& gridSize) { m_sGridSize = gridSize; }      //取得每個格子佔用的圖像點數。即圖像大於與格子大小的比值。     inline const CCPoint& getStep(void) { return m_obStep; }     inline void setStep(const CCPoint& step) { m_obStep = step; }      //取得紋理是否上下反轉 inline bool isTextureFlipped(void) { return m_bIsTextureFlipped; } //設置紋理是否上下反轉。     void setTextureFlipped(bool bFlipped);   //初始化網格，參一為網格大小，參二為對應的紋理，參三為設置紋理是否反轉。 bool initWithSize(const ccGridSize& gridSize, CCTexture2D *pTexture, bool bFlipped); ////初始化網格，參數為網格大小。     bool initWithSize(const ccGridSize& gridSize);    //在渲染之前要做的處理。 void beforeDraw(void); //在渲染之後要做的處理。 void afterDraw(CCNode *pTarget); //渲染處理 virtual void blit(void); //還原到原頂點位置 virtual void reuse(void); //計算頂點緩衝     virtual void calculateVertexPoints(void);  public:     //詳細創建函數，參一為網格大小，參二為對應的紋理，參三為設置紋理是否反轉。內部調用create實現。 CC_DEPRECATED_ATTRIBUTE static CCGridBase* gridWithSize(const ccGridSize& gridSize, CCTexture2D *texture, bool flipped);      //簡單創建函數，參數為網格大小。內部調用create實現。     CC_DEPRECATED_ATTRIBUTE static CCGridBase* gridWithSize(const ccGridSize& gridSize);      //對應詳細創建函數的create實現。     static CCGridBase* create(const ccGridSize& gridSize, CCTexture2D *texture, bool flipped); //對應簡單創建函數的create實現。 static CCGridBase* create(const ccGridSize& gridSize);   //設置2D投影矩陣。     void set2DProjection(void);  protected:  //是否被激活。     bool m_bActive; int  m_nReuseGrid; //格子大小 ccGridSize m_sGridSize; //所用紋理 CCTexture2D *m_pTexture; //每格的圖像點數 CCPoint m_obStep; //將屏幕畫面渲染到紋理的處理器。 CCGrabber *m_pGrabber; //紋理是否上下反轉。 bool m_bIsTextureFlipped; //Shader代碼片段指針。 CCGLProgram* m_pShaderProgram; //投影方式     ccDirectorProjection m_directorProjection; };  對應CPP： //簡單創建函數，參一為網格大小，參二為對應的紋理，參三為設置紋理是否反轉。內部調用create實現。CCGridBase* CCGridBase::gridWithSize(const ccGridSize& gridSize) {     return CCGridBase::create(gridSize); }  //對應簡單創建函數的create實現。 CCGridBase* CCGridBase::create(const ccGridSize& gridSize) {  //先new出一個當前類實例。     CCGridBase *pGridBase = new CCGridBase();  //如果成功     if (pGridBase) {   //進行初始化。         if (pGridBase->initWithSize(gridSize))         {     //如果初始化成功交由內存管理器進行管理。             pGridBase->autorelease();         }         else         {     //如果失敗釋放並置空。             CC_SAFE_RELEASE_NULL(pGridBase);         }     }  //如果成功返回創建的類實例，否則反回NULL。     return pGridBase; }  //詳細創建函數，參數為網格大小。內部調用create實現。 CCGridBase* CCGridBase::gridWithSize(const ccGridSize& gridSize, CCTexture2D *texture, bool flipped) {     return CCGridBase::create(gridSize, texture, flipped); } //對應詳細創建函數的create實現。 CCGridBase* CCGridBase::create(const ccGridSize& gridSize, CCTexture2D *texture, bool flipped) {  //先new出一個當前類實例。     CCGridBase *pGridBase = new CCGridBase();  //如果成功     if (pGridBase)     { //進行初始化。         if (pGridBase->initWithSize(gridSize, texture, flipped))         {   //如果初始化成功交由內存管理器進行管理。             pGridBase->autorelease();         }         else         {  //如果失敗釋放並置空。             CC_SAFE_RELEASE_NULL(pGridBase);         }     }  //如果成功返回創建的類實例，否則反回NULL。     return pGridBase; } //初始化函數。 bool CCGridBase::initWithSize(const ccGridSize& gridSize, CCTexture2D *pTexture, bool bFlipped) {     bool bRet = true;  //未激活。     m_bActive = false; m_nReuseGrid = 0; //保存格子大小。     m_sGridSize = gridSize;  //保存紋理。 m_pTexture = pTexture; //佔用紋理，對其引用計數器加一操作。 CC_SAFE_RETAIN(m_pTexture); //保存是否進行紋理反轉的變數。     m_bIsTextureFlipped = bFlipped;  //取得紋理中的圖像大小。 const CCSize& texSize = m_pTexture->getContentSize(); //計算出一個格子所佔的紋理定址長度。     m_obStep.x = texSize.width / m_sGridSize.x;     m_obStep.y = texSize.height / m_sGridSize.y;  //新建一個屏幕圖像獲取器，這傢伙是幹嘛的？其實就是一個獲取屏幕圖像的類，可以將屏幕上渲染出的圖像輸出到一張指定的紋理中，類似DX中的RTT。      m_pGrabber = new CCGrabber();     if (m_pGrabber) {   //將紋理設置為輸出紋理。         m_pGrabber->grab(m_pTexture);     }     else {   //如果圖像獲取器創建失敗，做下返回值處理。         bRet = false;     }     //取得對應的Shader代碼片段。 m_pShaderProgram = CCShaderCache::sharedShaderCache()->programForKey(kCCShader_PositionTexture); //計算所要用到的頂點數據並創建頂點緩衝區。     calculateVertexPoints();      return bRet; }  //初始化。 bool CCGridBase::initWithSize(const ccGridSize& gridSize) {  //取得設備指針，並通過它取得屏幕大小。     CCDirector *pDirector = CCDirector::sharedDirector();     CCSize s = pDirector->getWinSizeInPixels();     //計算相應大小對應的2次冪大小。     unsigned long POTWide = ccNextPOT((unsigned int)s.width);     unsigned long POTHigh = ccNextPOT((unsigned int)s.height);      // 使用ARGB8888格式。     CCTexture2DPixelFormat format = kCCTexture2DPixelFormat_RGBA8888;  //創建相應的像素繪沖區。     void *data = calloc((int)(POTWide * POTHigh * 4), 1);     if (! data)     {         CCLOG("cocos2d: CCGrid: not enough memory.");         this->release();         return false; }   //創建一個紋理。 CCTexture2D *pTexture = new CCTexture2D(); //使用像素數據初始化紋理。     pTexture->initWithData(data, format, POTWide, POTHigh, s);     //釋放像素數據。     free(data);  //如果失敗，返回false。     if (! pTexture)     {         CCLOG("cocos2d: CCGrid: error creating texture");         delete this;         return false;     }  //使用創建的紋理初始化     initWithSize(gridSize, pTexture, false);  //釋放紋理。 pTexture->release();      return true; }  //析構。 CCGridBase::~CCGridBase(void) {     CCLOGINFO("cocos2d: deallocing %p", this); //釋放紋理。 CC_SAFE_RELEASE(m_pTexture); //釋放屏幕     CC_SAFE_RELEASE(m_pGrabber); }  //設置激活。 void CCGridBase::setActive(bool bActive) {  //保存激活設置     m_bActive = bActive;     if (! bActive) {   //如果未激活，復原投影矩陣。         CCDirector *pDirector = CCDirector::sharedDirector();         ccDirectorProjection proj = pDirector->getProjection();         pDirector->setProjection(proj);     } } //設置紋理反轉。 void CCGridBase::setTextureFlipped(bool bFlipped) {  //如果參數與原設置不同，更新設置並計算頂點緩衝。     if (m_bIsTextureFlipped != bFlipped)     {         m_bIsTextureFlipped = bFlipped;         calculateVertexPoints();     } }  //設置2D投影。 void CCGridBase::set2DProjection() {  //取得窗口大小     CCDirector *director = CCDirector::sharedDirector();     CCSize    size = director->getWinSizeInPixels();  //重新設置視口大小 glViewport(0, 0, (GLsizei)(size.width * CC_CONTENT_SCALE_FACTOR()), (GLsizei)(size.height * CC_CONTENT_SCALE_FACTOR()) ); //開始設置投影矩陣。 kmGLMatrixMode(KM_GL_PROJECTION); //先將投影矩陣單位化。     kmGLLoadIdentity();  //創建一個矩陣變數。 kmMat4 orthoMatrix; //通過參數生成出投影矩陣變數的值，此處使用的是正交投影矩陣。 kmMat4OrthographicProjection(&orthoMatrix, 0, size.width * CC_CONTENT_SCALE_FACTOR(), 0, size.height * CC_CONTENT_SCALE_FACTOR(), -1, 1); //將原單位化矩陣與正交投影矩陣相乘，當然還是正交投影矩陣了，做為投影矩陣的結果。     kmGLMultMatrix( &orthoMatrix );  //下面開始設置模型觀察矩陣。 kmGLMatrixMode(KM_GL_MODELVIEW); //將矩陣單位化。     kmGLLoadIdentity();   //設置投影矩陣。     ccSetProjectionMatrixDirty(); }  //在開始渲染前的處理。 void CCGridBase::beforeDraw(void) {     // 先取得當前的投影矩陣保存到變數中     CCDirector *director = CCDirector::sharedDirector();     m_directorProjection = director->getProjection();      // 設置新的投影矩陣。 set2DProjection(); // 設置開啟屏幕渲染到紋理。     m_pGrabber->beforeRender(m_pTexture); }  //在渲染結束后的處理。 void CCGridBase::afterDraw(cocos2d::CCNode *pTarget) {  //設置完成屏幕渲染到紋理。     m_pGrabber->afterRender(m_pTexture);      //恢復原投影矩陣。     CCDirector *director = CCDirector::sharedDirector();     director->setProjection(m_directorProjection);  //     if (pTarget->getCamera()->isDirty()) {   //取得演示的錨點做為攝像機的矩陣轉換中心點。         const CCPoint& offset = pTarget->getAnchorPointInPoints();    //注意：下面三句的意義是對攝像機進行矩陣變換，這個矩陣變換是相對於自身中心點位置，俗稱自身矩陣變換。         //先將當前模型矩陣偏移到這個中心點。         kmGLTranslatef(offset.x, offset.y, 0);    //進行本地矩陣的轉換         pTarget->getCamera()->locate();    //恢復原位置。         kmGLTranslatef(-offset.x, -offset.y, 0);        }  //設置使用紋理。     ccGLBindTexture2D(m_pTexture->getName());      // restore projection for default FBO .fixed bug #543 #544 //TODO:         CCDirector::sharedDirector()->setProjection(CCDirector::sharedDirector()->getProjection()); //TODO:         CCDirector::sharedDirector()->applyOrientation();  //進行渲染     blit(); }  //進行渲染 void CCGridBase::blit(void) {     CCAssert(0, ""); }  //還原到原來頂點位置。 void CCGridBase::reuse(void) {     CCAssert(0, ""); }  //計算頂點緩衝區。 void CCGridBase::calculateVertexPoints(void) {     CCAssert(0, ""); }    //3D網格類，派生於格子基類， class CC_DLL CCGrid3D : public CCGridBase { public:  //構造 CCGrid3D(); //析構     ~CCGrid3D(void);      //返回對應位置的頂點。     ccVertex3F vertex(const ccGridSize& pos);     //返回對應位置的原始頂點。     ccVertex3F originalVertex(const ccGridSize& pos);     //設置對應位置的頂點。     void setVertex(const ccGridSize& pos, const ccVertex3F& vertex);  //重載基類的函數。  //渲染。 virtual void blit(void); //還原到原來頂點位置 virtual void reuse(void); //計算頂點緩衝。     virtual void calculateVertexPoints(void);  public:     //靜態函數：詳細參數的創建3D網格，參一為格子大小，參二為紋理指針，參三為是否進行紋理反轉,內部調用create實現。     CC_DEPRECATED_ATTRIBUTE static CCGrid3D* gridWithSize(const ccGridSize& gridSize, CCTexture2D *pTexture, bool bFlipped);     //靜態函數：簡單參數的創建3D網格，參數為格子大小,內部調用create實現。      CC_DEPRECATED_ATTRIBUTE static CCGrid3D* gridWithSize(const ccGridSize& gridSize);          //詳細參數的創建3D網格     static CCGrid3D* create(const ccGridSize& gridSize, CCTexture2D *pTexture, bool bFlipped);     //簡單參數的創建3D網格     static CCGrid3D* create(const ccGridSize& gridSize);      protected:  //頂點緩衝指針_紋理UV GLvoid *m_pTexCoordinates; //頂點緩衝指針_位置 GLvoid *m_pVertices; //原始頂點緩衝指針_位置 GLvoid *m_pOriginalVertices; //索引緩衝指針     GLushort *m_pIndices; };  對應CPP： //靜態函數：詳細參數的創建3D網格，參一為格子大小，參二為紋理指針，參三為是否進行紋理反轉,內部調用create實現。 CCGrid3D* CCGrid3D::gridWithSize(const ccGridSize& gridSize, CCTexture2D *pTexture, bool bFlipped) {     return CCGrid3D::create(gridSize, pTexture, bFlipped); } //上面的create實現 CCGrid3D* CCGrid3D::create(const ccGridSize& gridSize, CCTexture2D *pTexture, bool bFlipped) {  //先new出一個當前類實例     CCGrid3D *pRet= new CCGrid3D();  //如果成功     if (pRet) {  //初始化並交由內存管理器進行引用計數器的管理         if (pRet->initWithSize(gridSize, pTexture, bFlipped))         {             pRet->autorelease();         }         else         { //如果失敗，則釋放並置空。             delete pRet;             pRet = NULL;         }     }  //返回結果。     return pRet; } //簡單參數的創建3D網格,內部調用create實現。 CCGrid3D* CCGrid3D::gridWithSize(const ccGridSize& gridSize) {     return CCGrid3D::create(gridSize); } //上面函數的create實現。 CCGrid3D* CCGrid3D::create(const ccGridSize& gridSize) { //先new出一個當前類實例     CCGrid3D *pRet= new CCGrid3D();  //如果成功     if (pRet) {  //初始化並交由內存管理器進行引用計數器的管理         if (pRet->initWithSize(gridSize))         {             pRet->autorelease();         }         else         { //如果失敗，則釋放並置空。             delete pRet;             pRet = NULL;         }     } //返回結果。     return pRet; }  //構造 CCGrid3D::CCGrid3D()     : m_pTexCoordinates(NULL)     , m_pVertices(NULL)     , m_pOriginalVertices(NULL)     , m_pIndices(NULL) {  } //析構 CCGrid3D::~CCGrid3D(void) {  //釋放各緩衝區     CC_SAFE_FREE(m_pTexCoordinates);     CC_SAFE_FREE(m_pVertices);     CC_SAFE_FREE(m_pIndices);     CC_SAFE_FREE(m_pOriginalVertices); } //進行渲染處理 void CCGrid3D::blit(void) {  //計算格子的數量     int n = m_sGridSize.x * m_sGridSize.y;      //設置渲染頂點的格式 ccGLEnableVertexAttribs( kCCVertexAttribFlag_Position | kCCVertexAttribFlag_TexCoords ); //開啟使用Shader m_pShaderProgram->use(); //設置Shader中的 頂點矩陣，其值 = 投影矩陣X模型矩陣X觀察矩陣的結果，用於在Shader中進行頂點的最終位置計算。     m_pShaderProgram->setUniformForModelViewProjectionMatrix();;       //頂點緩衝中位置屬性的指定。     glVertexAttribPointer(kCCVertexAttrib_Position, 3, GL_FLOAT, GL_FALSE, 0, m_pVertices);      //頂點緩衝中紋理貼圖UV屬性的指定。     glVertexAttribPointer(kCCVertexAttrib_TexCoords, 2, GL_FLOAT, GL_FALSE, 0, m_pTexCoordinates);   //繪製三角形，每個格子兩個三角形，使用GL_TRIANGLES方式進行繪製，則每個格子需要6個頂點。所以頂點數為n*6,渲染時按照索引繪沖m_pIndices所指定的三角形頂點索引來進行繪製。 glDrawElements(GL_TRIANGLES, (GLsizei) n*6, GL_UNSIGNED_SHORT, m_pIndices); //增加一次DP統計值。     CC_INCREMENT_GL_DRAWS(1); } //計算頂點緩衝數據 void CCGrid3D::calculateVertexPoints(void) {  //取得紋理的寬高。     float width = (float)m_pTexture->getPixelsWide(); float height = (float)m_pTexture->getPixelsHigh(); //取得紋理中圖像區域的高度。     float imageH = m_pTexture->getContentSizeInPixels().height;   //定義臨時變數。 int x, y, i; //如果相應的頂點緩衝數據有值，先釋放乾淨並置空。     CC_SAFE_FREE(m_pVertices);     CC_SAFE_FREE(m_pOriginalVertices);     CC_SAFE_FREE(m_pTexCoordinates);     CC_SAFE_FREE(m_pIndices);  //計算總頂點數，每一行的頂點數為格子列數+1，每一列的頂點數為格子行數+1。     unsigned int numOfPoints = (m_sGridSize.x+1) * (m_sGridSize.y+1);  //為相應的頂點緩衝區申請相應大小的內存。  //m_pVertices中存入的是頂點位置，使用ccVertex3F來存儲。所申請的內存大小即為頂點數乘以ccVertex3F的位元組數大小。 m_pVertices = malloc(numOfPoints * sizeof(ccVertex3F)); //同上。 m_pOriginalVertices = malloc(numOfPoints * sizeof(ccVertex3F)); //紋理UV使用ccVertex2F來存儲。 m_pTexCoordinates = malloc(numOfPoints * sizeof(ccVertex2F)); //索引緩衝m_pIndices使用GLushort來存儲繪製三角形所用的頂點的索引值，因為每個面3個索引，一個格子就需要6個索引。     m_pIndices = (GLushort*)malloc(m_sGridSize.x * m_sGridSize.y * sizeof(GLushort) * 6);    //為了方便填充數據，將緩衝區地址轉換成相應的指針變數。     GLfloat *vertArray = (GLfloat*)m_pVertices;     GLfloat *texArray = (GLfloat*)m_pTexCoordinates;     GLushort *idxArray = m_pIndices;   //雙循環遍歷每個格子。     for (x = 0; x < m_sGridSize.x; ++x)     {         for (y = 0; y < m_sGridSize.y; ++y)         {     //取得格子索引。             int idx = (y * m_sGridSize.x) + x;      //取得格子的左上角和右下角在圖像中的相應位置。m_obStep是每個格子佔用的圖像點數。             GLfloat x1 = x * m_obStep.x;             GLfloat x2 = x1 + m_obStep.x;             GLfloat y1 = y * m_obStep.y;             GLfloat y2= y1 + m_obStep.y;      //取得格子的四個頂點的索引。             GLushort a = (GLushort)(x * (m_sGridSize.y + 1) + y);             GLushort b = (GLushort)((x + 1) * (m_sGridSize.y + 1) + y);             GLushort c = (GLushort)((x + 1) * (m_sGridSize.y + 1) + (y + 1));             GLushort d = (GLushort)(x * (m_sGridSize.y + 1) + (y + 1));      //按照三角形的繪製方式將格子頂點的索引組成兩個三角形的頂點索引。             GLushort tempidx[6] = {a, b, d, b, c, d};      //填充到相應的索引緩衝中。             memcpy(&idxArray[6*idx], tempidx, 6*sizeof(GLushort));       //格子四個頂點的位置。             int l1[4] = {a*3, b*3, c*3, d*3};             ccVertex3F e = {x1, y1, 0};             ccVertex3F f = {x2, y1, 0};             ccVertex3F g = {x2, y2, 0};             ccVertex3F h = {x1, y2, 0};              ccVertex3F l2[4] = {e, f, g, h};              int tex1[4] = {a*2, b*2, c*2, d*2};             CCPoint tex2[4] = {ccp(x1, y1), ccp(x2, y1), ccp(x2, y2), ccp(x1, y2)};     //遍歷放入相應的頂點位置和紋理UV中。             for (i = 0; i < 4; ++i)             {       //頂點的x,y,z                 vertArray[l1[i]] = l2[i].x;                 vertArray[l1[i] + 1] = l2[i].y;                 vertArray[l1[i] + 2] = l2[i].z;        //紋理U值                 texArray[tex1[i]] = tex2[i].x / width;       //紋理V值                 if (m_bIsTextureFlipped)                 {        //上下反轉                     texArray[tex1[i] + 1] = (imageH - tex2[i].y) / height;                 }                 else                 {        //正常                     texArray[tex1[i] + 1] = tex2[i].y / height;                 }             }         }     }  //將頂點位置數據填充到保存原始頂點位置的內存中。     memcpy(m_pOriginalVertices, m_pVertices, (m_sGridSize.x+1) * (m_sGridSize.y+1) * sizeof(ccVertex3F)); } //返回對應網格位置的頂點。 ccVertex3F CCGrid3D::vertex(const ccGridSize& pos) {  //通過網格位置計算出起始頂點的索引。 int index = (pos.x * (m_sGridSize.y+1) + pos.y) * 3; //為方便獲取頂點數據，將頂點緩衝地址轉換為相應的指針變數。     float *vertArray = (float*)m_pVertices;  //通過索引取得相應的頂點x,y,z。     ccVertex3F vert = {vertArray[index], vertArray[index+1], vertArray[index+2]};  //返回頂點     return vert; } //返回網格對應位置的原始頂點。 ccVertex3F CCGrid3D::originalVertex(const ccGridSize& pos) {  //通過格子位置計算出起始頂點的索引。     int index = (pos.x * (m_sGridSize.y+1) + pos.y) * 3;  //為方便獲取頂點數據，將頂點緩衝地址轉換為相應的指針變數。 float *vertArray = (float*)m_pOriginalVertices;  //通過索引取得相應的頂點x,y,z。     ccVertex3F vert = {vertArray[index], vertArray[index+1], vertArray[index+2]};  //返回頂點     return vert; } //設置對應網格位置的頂點。 void CCGrid3D::setVertex(const ccGridSize& pos, const ccVertex3F& vertex) { //通過格子位置計算出起始頂點的索引。 int index = (pos.x * (m_sGridSize.y + 1) + pos.y) * 3; //為方便獲取頂點數據，將頂點緩衝地址轉換為相應的指針變數。 float *vertArray = (float*)m_pVertices; 設置對應索引位置的頂點的x,y,z。     vertArray[index] = vertex.x;     vertArray[index+1] = vertex.y;     vertArray[index+2] = vertex.z; } //還原原來位置。 void CCGrid3D::reuse(void) {  //如果還原格子的變數大於0。     if (m_nReuseGrid > 0) {   //將原始頂點位置拷貝到頂點緩衝中。         memcpy(m_pOriginalVertices, m_pVertices, (m_sGridSize.x+1) * (m_sGridSize.y+1) * sizeof(ccVertex3F));   //還原格子的變數做減1操作。         --m_nReuseGrid;     } }  //這也是一個網格類，但它在網格的每個位置點存的不是一個頂點，而是一個四邊形格子。 class CC_DLL CCTiledGrid3D : public CCGridBase { public:  //構造 CCTiledGrid3D(); //析構     ~CCTiledGrid3D(void);      //返回相應位置的格子數據     ccQuad3 tile(const ccGridSize& pos);     //返回原始位置的格子數據。     ccQuad3 originalTile(const ccGridSize& pos);     //設置相應位置的格子數據。     void setTile(const ccGridSize& pos, const ccQuad3& coords);  //重載相應基類函數。     virtual void blit(void);     virtual void reuse(void);     virtual void calculateVertexPoints(void);  public:  //靜態函數：創建一個當前類的實例。參一為格子大小，參二為對應的紋理，參三為是否進行紋理反轉。內部調用create實現。 CC_DEPRECATED_ATTRIBUTE static CCTiledGrid3D* gridWithSize(const ccGridSize& gridSize, CCTexture2D *pTexture, bool bFlipped); //上面函數的簡化版本。     CC_DEPRECATED_ATTRIBUTE static CCTiledGrid3D* gridWithSize(const ccGridSize& gridSize);     //對應創建函數的實現。     static CCTiledGrid3D* create(const ccGridSize& gridSize, CCTexture2D *pTexture, bool bFlipped);     //對應創建函數的實現。     static CCTiledGrid3D* create(const ccGridSize& gridSize);      protected:  //所要用到的頂點數據緩衝區。     GLvoid *m_pTexCoordinates;     GLvoid *m_pVertices;     GLvoid *m_pOriginalVertices;     GLushort *m_pIndices; };  對應CPP： //構造函數。 CCTiledGrid3D::CCTiledGrid3D()     : m_pTexCoordinates(NULL)     , m_pVertices(NULL)     , m_pOriginalVertices(NULL)     , m_pIndices(NULL) {  } //析構函數。 CCTiledGrid3D::~CCTiledGrid3D(void) {  //釋放各頂點所用的數據緩衝區。     CC_SAFE_FREE(m_pTexCoordinates);     CC_SAFE_FREE(m_pVertices);     CC_SAFE_FREE(m_pOriginalVertices);     CC_SAFE_FREE(m_pIndices); } //靜態函數：創建一個當前類的實例。參一為格子大小，參二為對應的紋理，參三為是否進行紋理反轉。內部調用create實現。  CCTiledGrid3D* CCTiledGrid3D::gridWithSize(const ccGridSize& gridSize, CCTexture2D *pTexture, bool bFlipped) {     return CCTiledGrid3D::create(gridSize, pTexture, bFlipped); } //上面函數的具體實現。 CCTiledGrid3D* CCTiledGrid3D::create(const ccGridSize& gridSize, CCTexture2D *pTexture, bool bFlipped) {  //先用new創建一個當前類的實例。     CCTiledGrid3D *pRet= new CCTiledGrid3D();  //如果成功。     if (pRet) {  //進行初始化並交由內存管理器進行引用計數器的管理。         if (pRet->initWithSize(gridSize, pTexture, bFlipped))         {             pRet->autorelease();         }         else         {     //如果失敗，釋放new出來的實例指針並置空。             delete pRet;             pRet = NULL;         }     }  //返回實例指針。     return pRet; }  //靜態函數：創建一個當前類的實例。簡化版本。 CCTiledGrid3D* CCTiledGrid3D::gridWithSize(const ccGridSize& gridSize) {     return CCTiledGrid3D::create(gridSize); } //上面函數的具體實現。 CCTiledGrid3D* CCTiledGrid3D::create(const ccGridSize& gridSize) {  //先用new創建一個當前類的實例。     CCTiledGrid3D *pRet= new CCTiledGrid3D();      if (pRet) {  /進行初始化並交由內存管理器進行引用計數器的管理。         if (pRet->initWithSize(gridSize))         {             pRet->autorelease();         }         else         {    //如果失敗，釋放new出來的實例指針並置空。             delete pRet;             pRet = NULL;         }     }  //返回實例指針。     return pRet; } //實際渲染處理。 void CCTiledGrid3D::blit(void) {  //取得格子的數量。     int n = m_sGridSize.x * m_sGridSize.y;      //開啟使用shader片段 m_pShaderProgram->use(); //設置Shader中的 頂點矩陣，其值 = 投影矩陣X模型矩陣X觀察矩陣的結果，用於在Shader中進行頂點的最終位置計算。     m_pShaderProgram->setUniformForModelViewProjectionMatrix();       //設置頂點緩衝的結構，由位置和紋理坐構構成。 ccGLEnableVertexAttribs( kCCVertexAttribFlag_Position | kCCVertexAttribFlag_TexCoords );     //頂點緩衝中位置屬性的指定       glVertexAttribPointer(kCCVertexAttrib_Position, 3, GL_FLOAT, GL_FALSE, 0, m_pVertices);     //紋理坐標通道     glVertexAttribPointer(kCCVertexAttrib_TexCoords, 2, GL_FLOAT, GL_FALSE, 0, m_pTexCoordinates); //繪製圖形     glDrawElements(GL_TRIANGLES, (GLsizei)n*6, GL_UNSIGNED_SHORT, m_pIndices);  //更新DP統計     CC_INCREMENT_GL_DRAWS(1); }  //計算頂點緩衝的數據 void CCTiledGrid3D::calculateVertexPoints(void) {  //取得紋理的寬高     float width = (float)m_pTexture->getPixelsWide(); float height = (float)m_pTexture->getPixelsHigh(); //取得紋理中圖像區域的高度。     float imageH = m_pTexture->getContentSizeInPixels().height;     //定義臨時變數。     int numQuads = m_sGridSize.x * m_sGridSize.y; //如果相應的頂點緩衝數據有值，先釋放乾淨並置空。  CC_SAFE_FREE(m_pVertices);     CC_SAFE_FREE(m_pOriginalVertices);     CC_SAFE_FREE(m_pTexCoordinates);     CC_SAFE_FREE(m_pIndices); //為相應的頂點緩衝區申請相應大小的內存。     m_pVertices = malloc(numQuads*4*sizeof(ccVertex3F));     m_pOriginalVertices = malloc(numQuads*4*sizeof(ccVertex3F));     m_pTexCoordinates = malloc(numQuads*4*sizeof(ccVertex2F));     m_pIndices = (GLushort*)malloc(numQuads*6*sizeof(GLushort));  //為了方便填充數據，將緩衝區地址轉換成相應的指針變數。     GLfloat *vertArray = (GLfloat*)m_pVertices;     GLfloat *texArray = (GLfloat*)m_pTexCoordinates;     GLushort *idxArray = m_pIndices;          int x, y;         //雙循環遍歷每個格子。     for (x = 0; x < m_sGridSize.x; ++x)     {         for (y = 0; y < m_sGridSize.y; ++y)         {     //取得格子的左上角和右下角在圖像中的位置。             float x1 = x * m_obStep.x;             float x2 = x1 + m_obStep.x;             float y1 = y * m_obStep.y;             float y2 = y1 + m_obStep.y;             //填充數據             *vertArray++ = x1;             *vertArray++ = y1;             *vertArray++ = 0;             *vertArray++ = x2;             *vertArray++ = y1;             *vertArray++ = 0;             *vertArray++ = x1;             *vertArray++ = y2;             *vertArray++ = 0;             *vertArray++ = x2;             *vertArray++ = y2;             *vertArray++ = 0;                          float newY1 = y1;             float newY2 = y2;             //如果紋理V值上下反轉，則做下處理。             if (m_bIsTextureFlipped)              {                 newY1 = imageH - y1;                 newY2 = imageH - y2;             }     //填充數據。             *texArray++ = x1 / width;             *texArray++ = newY1 / height;             *texArray++ = x2 / width;             *texArray++ = newY1 / height;             *texArray++ = x1 / width;             *texArray++ = newY2 / height;             *texArray++ = x2 / width;             *texArray++ = newY2 / height;         }     }     //索引緩衝數據填充。     for (x = 0; x < numQuads; x++)     {         idxArray[x*6+0] = (GLushort)(x * 4 + 0);         idxArray[x*6+1] = (GLushort)(x * 4 + 1);         idxArray[x*6+2] = (GLushort)(x * 4 + 2);                  idxArray[x*6+3] = (GLushort)(x * 4 + 1);         idxArray[x*6+4] = (GLushort)(x * 4 + 2);         idxArray[x*6+5] = (GLushort)(x * 4 + 3);     }     //填充原始位置頂點緩衝     memcpy(m_pOriginalVertices, m_pVertices, numQuads * 12 * sizeof(GLfloat)); }   //設置相應位置的格子數據。 void CCTiledGrid3D::setTile(const ccGridSize& pos, const ccQuad3& coords) {  //先計算出對應格子的頂點索引 int idx = (m_sGridSize.y * pos.x + pos.y) * 4 * 3; //為了方便填充數據，將緩衝區地址轉換成相應的指針變數。 float *vertArray = (float*)m_pVertices; //填充對應的數據     memcpy(&vertArray[idx], &coords, sizeof(ccQuad3)); } //返回原始位置的格子數據。 ccQuad3 CCTiledGrid3D::originalTile(const ccGridSize& pos) {  //先計算出對應格子的頂點索引     int idx = (m_sGridSize.y * pos.x + pos.y) * 4 * 3; //為了方便取得數據，將緩衝區地址轉換成相應的指針變數。 float *vertArray = (float*)m_pOriginalVertices;  //定義變數值做為返回結果。 ccQuad3 ret; //由索引取得數據填充到返回值中。     memcpy(&ret, &vertArray[idx], sizeof(ccQuad3));      return ret; } //返回相應位置的格子數據 ccQuad3 CCTiledGrid3D::tile(const ccGridSize& pos) {  //先計算出對應格子的頂點索引 int idx = (m_sGridSize.y * pos.x + pos.y) * 4 * 3; //為了方便取得數據，將緩衝區地址轉換成相應的指針變數。     float *vertArray = (float*)m_pVertices;  //定義變數值做為返回結果。 ccQuad3 ret; //由索引取得數據填充到返回值中。     memcpy(&ret, &vertArray[idx], sizeof(ccQuad3));      return ret; } //恢復為原始頂點 void CCTiledGrid3D::reuse(void) {  //如果還原格子的變數大於0。     if (m_nReuseGrid > 0)     {         int numQuads = m_sGridSize.x * m_sGridSize.y;   //將原始頂點位置拷貝到頂點緩衝中。         memcpy(m_pOriginalVertices, m_pVertices, numQuads * 12 * sizeof(GLfloat)); //還原格子的變數做減1操作。         --m_nReuseGrid;     } } 

上面講的是網格的的數據和渲染基類CCGridBase及其派生CCGrid3D和CCTiledGrid3D，CCGridBase的關鍵是處理了將屏幕渲染到紋理這個功能。

它有兩個重要的函數：

//在渲染之前要做的處理。

voidbeforeDraw(void);

//在渲染之後要做的處理。

voidafterDraw(CCNode *pTarget);

我們來看一下這兩個函數是在哪裡調用的。

經過搜索，我們可以在CCNode.h中發現這一句：

    /** A CCGrid object that is used when applying effects */

    CC_PROPERTY(CCGridBase *, m_pGrid, Grid)

即每個CCNode有一個CCGridBase類型的成員指針變數。在其cpp的visit中發現了要找的東西。

void CCNode::visit() {     if (!m_bIsVisible)     {         return;     }      kmGLPushMatrix();       //如果m_pGrid有值並且被激活則開啟渲染到紋理。      if (m_pGrid && m_pGrid->isActive())      {          m_pGrid->beforeDraw();  }   //相應結點的渲染處理。  …     //如果m_pGrid有值並且被激活則關閉渲染到紋理，這樣當前結點上所有繪製的圖像都被輸出到m_pGrid中對應的紋理中了。      if (m_pGrid && m_pGrid->isActive())      {          m_pGrid->afterDraw(this);     }       kmGLPopMatrix(); } 

而CCGrid3D是一個基本的網格渲染類，他內部有所需要的頂點緩衝區。可以實現帶紋理貼圖的網格渲染功能。

CCTiledGrid3D比較有趣，它與CCGrid3D的不同之處是它的網格不是由一個個頂點構成，而是由一個個四邊形構成，CCGrid3D所表現的是網格各頂點的動畫，而CCTiledGrid3D是表現每個格子中的四邊形的動畫。

OK,下面我們來看一下操控網格數據表現一些基本動畫的類。

打開CCActionGrid.h:

#ifndef __ACTION_CCGRID_ACTION_H__ #define __ACTION_CCGRID_ACTION_H__  #include "CCActionInterval.h" #include "CCActionInstant.h" //使用Cocos2d命名空間 NS_CC_BEGIN //用到CCGridBase類的指針。 class CCGridBase; //網格動畫基類 class CC_DLL CCGridAction : public CCActionInterval { public:  //產生一個當前類的實例拷貝 virtual CCObject* copyWithZone(CCZone* pZone); //設定演示當前動畫的演員。 virtual void startWithTarget(CCNode *pTarget); //創建一個反向播放的動畫。     virtual CCActionInterval* reverse(void);     //初始化網格的大小和動畫的時長。     virtual bool initWithSize(const ccGridSize& gridSize, float duration);     //返回網格     virtual CCGridBase* getGrid(void);  public:     //靜態創建函數。參數一為格子大小，參數二為動畫時長，內部調用create實現。     CC_DEPRECATED_ATTRIBUTE static CCGridAction* actionWithSize(const ccGridSize& gridSize, float duration);     //同上     static CCGridAction* create(const ccGridSize& gridSize, float duration); protected:  //格子大小。     ccGridSize m_sGridSize; };  對應CPP： //靜態創建函數。參數一為格子大小，參數二為動畫時長，內部調用create實現。 CCGridAction* CCGridAction::actionWithSize(const ccGridSize& gridSize, float duration) {     return CCGridAction::create(gridSize, duration); } //同上 CCGridAction* CCGridAction::create(const ccGridSize& gridSize, float duration) {  //先new出一個CCGridAction     CCGridAction *pAction = new CCGridAction();     if (pAction) {  //初始化並放入內存管理器中。         if (pAction->initWithSize(gridSize, duration))         {             pAction->autorelease();         }         else         {     //如果初始化失敗，釋放並置空。             CC_SAFE_DELETE(pAction);         }     }  //返回創建的實例指針，當然，也可能返回NULL。     return pAction; } //初始化函數。 bool CCGridAction::initWithSize(const ccGridSize& gridSize, float duration) {  //調用時間動畫基類的初始化函數保存動畫時長。     if (CCActionInterval::initWithDuration(duration)) {  //保存格子大小。         m_sGridSize = gridSize;          return true;     }      return false; } //設置演示當前動畫的演員，注意這個演員是什麼？不是精靈，而是 void CCGridAction::startWithTarget(CCNode *pTarget) {  //調用時間動畫基類的相應函數。     CCActionInterval::startWithTarget(pTarget);  //取得網格數據類。     CCGridBase *newgrid = this->getGrid();      CCNode *t = m_pTarget;     //取得演員的對應網格數據。 CCGridBase *targetGrid = t->getGrid();  //有效性判斷，如果演員有網格數據並且已經填充了數據。     if (targetGrid && targetGrid->getReuseGrid() > 0) {  //如果網格數據被激活並且其格子大小與本類實例的網格大小相同。         if (targetGrid->isActive() && targetGrid->getGridSize().x == m_sGridSize.x             && targetGrid->getGridSize().y == m_sGridSize.y /*&& dynamic_cast<CCGridBase*>(targetGrid) != NULL*/)         {     //演員的網格數據恢復為原始數據。             targetGrid->reuse();         }         else         {             CCAssert(0, "");         }     }     else {  //如果演員沒有創建網格數據或者網格數據已經恢復為原始頂點。    //如果演員的網格數據有效並且是激活狀態。         if (targetGrid && targetGrid->isActive())         {     //將其設為未激活。             targetGrid->setActive(false);         }    //將當前類實例的網格數據設置給演員之後激活。         t->setGrid(newgrid);         t->getGrid()->setActive(true);     } } //純虛函數：取得網格。做為基類沒做任何處理。 CCGridBase* CCGridAction::getGrid(void) {     // Abstract class needs implementation     CCAssert(0, "");      return NULL; } //創建一個反向播放的動畫。 CCActionInterval* CCGridAction::reverse(void) {     return CCReverseTime::create(this); } //創建一個當前類實例的拷貝。 CCObject* CCGridAction::copyWithZone(CCZone *pZone) {     CCZone* pNewZone = NULL; CCGridAction* pCopy = NULL; //如果pZone有效且已有拷貝數據。     if(pZone && pZone->m_pCopyObject)      {         //直接取用         pCopy = (CCGridAction*)(pZone->m_pCopyObject);     }     else {  //否則新建一個當前類實例並設為pNewZone的拷貝數據。         pCopy = new CCGridAction();         pZone = pNewZone = new CCZone(pCopy);     }  //調用基類的相應函數。     CCActionInterval::copyWithZone(pZone);  //初始化拷貝     pCopy->initWithSize(m_sGridSize, m_fDuration);     //釋放臨時變數     CC_SAFE_DELETE(pNewZone);     return pCopy; }   //3D網格動畫基類 class CC_DLL CCGrid3DAction : public CCGridAction { public:     //取得網格數據。     virtual CCGridBase* getGrid(void);     //返回對應網格位置的頂點。     ccVertex3F vertex(const ccGridSize& pos);     //返回對應網格位置的原始頂點。     ccVertex3F originalVertex(const ccGridSize& pos);     //設置對應網格位置的頂點。     void setVertex(const ccGridSize& pos, const ccVertex3F& vertex);  public:     //靜態創建函數:參一為格子大小，參二為動畫時長，內部調用create實現。     CC_DEPRECATED_ATTRIBUTE static CCGrid3DAction* actionWithSize(const ccGridSize& gridSize, float duration);     //上面的create實現。     static CCGrid3DAction* create(const ccGridSize& gridSize, float duration); };  對應CPP： //取得網格數據。 CCGridBase* CCGrid3DAction::getGrid(void) {  //創建一個對應大小的3D網格數據。     return CCGrid3D::create(m_sGridSize); } //返回對應網格位置的頂點。 ccVertex3F CCGrid3DAction::vertex(const ccGridSize& pos) {  //取得演員的網格數據，調用網格數據的相應函數。     CCGrid3D *g = (CCGrid3D*)m_pTarget->getGrid();     return g->vertex(pos); } //返回對應網格位置的原始頂點。 ccVertex3F CCGrid3DAction::originalVertex(const ccGridSize& pos) {  //取得演員的網格數據，調用網格數據的相應函數。     CCGrid3D *g = (CCGrid3D*)m_pTarget->getGrid();     return g->originalVertex(pos); } //設置對應網格位置的頂點。 void CCGrid3DAction::setVertex(const ccGridSize& pos, const ccVertex3F& vertex) {  //取得演員的網格數據，調用網格數據的相應函數。     CCGrid3D *g = (CCGrid3D*)m_pTarget->getGrid();     g->setVertex(pos, vertex); }   //派生於CCGridAction的3D格子動畫類。 class CC_DLL CCTiledGrid3DAction : public CCGridAction { public:     //返回對應位置的格子頂點數據。     ccQuad3 tile(const ccGridSize& pos);     //返回對應位置的原始格子頂點數據。     ccQuad3 originalTile(const ccGridSize& pos);     //設置對應位置的格子數據。     void setTile(const ccGridSize& pos, const ccQuad3& coords);      //返回網格數據。     virtual CCGridBase* getGrid(void);  public:     //靜態創建函數：參一為格子大小，參二為動畫時長，內部調用creat來實現。     CC_DEPRECATED_ATTRIBUTE static CCTiledGrid3DAction* actionWithSize(const ccGridSize& gridSize, float duration);     //上面的create實現。     static CCTiledGrid3DAction* create(const ccGridSize& gridSize, float duration); }; //取得網格數據。 CCGridBase* CCTiledGrid3DAction::getGrid(void) {     return CCTiledGrid3D::create(m_sGridSize); } //返回對應位置的格子頂點數據。 ccQuad3 CCTiledGrid3DAction::tile(const ccGridSize& pos) {  //取得演員的網格數據，調用網格數據的相應函數。     CCTiledGrid3D *g = (CCTiledGrid3D*)m_pTarget->getGrid();     return g->tile(pos); } //返回對應位置的原始格子頂點數據。 ccQuad3 CCTiledGrid3DAction::originalTile(const ccGridSize& pos) {  //取得演員的網格數據，調用網格數據的相應函數。     CCTiledGrid3D *g = (CCTiledGrid3D*)m_pTarget->getGrid();     return g->originalTile(pos); } //設置對應位置的格子數據。  void CCTiledGrid3DAction::setTile(const ccGridSize& pos, const ccQuad3& coords) {  //取得演員的網格數據，調用網格數據的相應函數。     CCTiledGrid3D *g = (CCTiledGrid3D*)m_pTarget->getGrid();     return g->setTile(pos, coords); }  //網格所用的變速動畫基類：先加速再減速。 class CC_DLL CCAccelDeccelAmplitude : public CCActionInterval { public:  //析構     virtual ~CCAccelDeccelAmplitude(void);     //初始化     bool initWithAction(CCAction *pAction, float duration);  //設置演示動畫的演員。 virtual void startWithTarget(CCNode *pTarget); //更新動畫。 virtual void update(float time); //創建一個當前類的反向動畫實例。     virtual CCActionInterval* reverse(void);      //取得速率     inline float getRate(void) { return m_fRate; }     //設置速率     inline void setRate(float fRate) { m_fRate = fRate; }  public:     //靜態創建函數:參一為動畫實例指針，參二為動畫時長，內部調用create實現。     CC_DEPRECATED_ATTRIBUTE static CCAccelDeccelAmplitude* actionWithAction(CCAction *pAction, float duration);     //上面函數的create實現。     static CCAccelDeccelAmplitude* create(CCAction *pAction, float duration);  protected:  //速率 float m_fRate; //所控制的時間動畫。     CCActionInterval *m_pOther; };  對應CPP: //靜態創建函數:參一為動畫實例指針，參二為動畫時長，內部調用create實現。 CCAccelDeccelAmplitude* CCAccelDeccelAmplitude::actionWithAction(CCAction *pAction, float duration) {     return CCAccelDeccelAmplitude::create(pAction, duration); } //上面函數的create實現。 CCAccelDeccelAmplitude* CCAccelDeccelAmplitude::create(CCAction *pAction, float duration) {  //先new出一個當前類的實例。     CCAccelDeccelAmplitude *pRet = new CCAccelDeccelAmplitude();     if (pRet) {  //初始化並交由內存管理器去進行引用計數器的管理。         if (pRet->initWithAction(pAction, duration))         {             pRet->autorelease();         }         else         {     //如果失敗，釋放並置空。             CC_SAFE_DELETE(pRet);         }     }  //返回創建的當前類實例，當然可能為NULL。     return pRet; } //初始化處理。 bool CCAccelDeccelAmplitude::initWithAction(CCAction *pAction, float duration) {  //調用基類的初始化函數。     if (CCActionInterval::initWithDuration(duration)) {  //保存相應的變數值，佔用控制的動畫故對其引用計數加一。         m_fRate = 1.0f;         m_pOther = (CCActionInterval*)(pAction);         pAction->retain();          return true;     }      return false; } //析構 CCAccelDeccelAmplitude::~CCAccelDeccelAmplitude(void) {  //不再佔用控制的時間動畫，對其引用計數器減一。     CC_SAFE_RELEASE(m_pOther); } //設置演示當前動畫的演員。 void CCAccelDeccelAmplitude::startWithTarget(CCNode *pTarget) {  //先調用基類的相應函數。 CCActionInterval::startWithTarget(pTarget); //設置控制動畫使用此演員。     m_pOther->startWithTarget(pTarget); } //更新動畫。 void CCAccelDeccelAmplitude::update(float time) {  //創建一個f值變為進度的2倍。     float f = time * 2;  //如果動畫時間大於一半，讓進度由1再變為0。     if (f > 1)     {         f -= 1;         f = 1 - f;     }  //使用powf處理來形成一個變速曲線公式來達到變速目的。     ((CCAccelDeccelAmplitude*)(m_pOther))->setAmplitudeRate(powf(f, m_fRate)); } //創建當前類的反向動畫實例。 CCActionInterval* CCAccelDeccelAmplitude::reverse(void) {     return CCAccelDeccelAmplitude::create(m_pOther->reverse(), m_fDuration); }   //網格所用的變速動畫基類：加速動畫。 class CC_DLL CCAccelAmplitude : public CCActionInterval { public:  //析構     ~CCAccelAmplitude(void);     //初始化處理。     bool initWithAction(CCAction *pAction, float duration);      //取得速率     inline float getRate(void) { return m_fRate; }     //設置速率     inline void setRate(float fRate) { m_fRate = fRate; }  //設置演示當前動畫的演員。 virtual void startWithTarget(CCNode *pTarget); //更新動畫 virtual void update(float time); //創建一個當前動畫的反向動畫實例。     virtual CCActionInterval* reverse(void);  public:     //靜態創建函數：參一為一個時間動畫，參二為時長。內部調用create實現。     CC_DEPRECATED_ATTRIBUTE static CCAccelAmplitude* actionWithAction(CCAction *pAction, float duration);     //上面函數的create實現。     static CCAccelAmplitude* create(CCAction *pAction, float duration); protected:  //速率 float m_fRate; //控制動畫。     CCActionInterval *m_pOther; };  對應CPP： //靜態創建函數：參一為一個時間動畫，參二為時長。內部調用create實現。 CCAccelAmplitude* CCAccelAmplitude::actionWithAction(CCAction *pAction, float duration) {     return CCAccelAmplitude::create(pAction, duration); } //上面函數的create實現。 CCAccelAmplitude* CCAccelAmplitude::create(CCAction *pAction, float duration) {  //創建三部曲，new,初始化,autorelease，一個不少。     CCAccelAmplitude *pRet = new CCAccelAmplitude();     if (pRet)     {         if (pRet->initWithAction(pAction, duration))         {             pRet->autorelease();         }         else         {     //當然，要有失敗處理。             CC_SAFE_DELETE(pRet);         }     }      return pRet; } //初始化 bool CCAccelAmplitude::initWithAction(CCAction *pAction, float duration) {  //先調用基類的初始化函數。     if (CCActionInterval::initWithDuration(duration)) {  //速率設為1.0。         m_fRate = 1.0f;   //保存動畫。佔用對其引用計數加一。         m_pOther = (CCActionInterval*)(pAction);         pAction->retain();          return true;     }      return false; } //析構函數。 CCAccelAmplitude::~CCAccelAmplitude(void) {  //不佔用，對其引用計數減一。     CC_SAFE_DELETE(m_pOther); } //設置演示當前動畫的演員。 void CCAccelAmplitude::startWithTarget(CCNode *pTarget) {  //調用基類的相應函數。 CCActionInterval::startWithTarget(pTarget); //設置控制動畫使用此演員。     m_pOther->startWithTarget(pTarget); } //動畫更新處理。 void CCAccelAmplitude::update(float time) {  //創建變速曲線來設置控制動畫的速率。 ((CCAccelAmplitude*)(m_pOther))->setAmplitudeRate(powf(time, m_fRate)); //更新控制動畫。     m_pOther->update(time); } //創建一個當前類的反向動畫實例。 CCActionInterval* CCAccelAmplitude::reverse(void) {     return CCAccelAmplitude::create(m_pOther->reverse(), m_fDuration); }  //網格所用的變速動畫基類：減速動畫。 class CC_DLL CCDeccelAmplitude : public CCActionInterval { public:  //析構函數。     ~CCDeccelAmplitude(void);     //初始化     bool initWithAction(CCAction *pAction, float duration);      //取得速率     inline float getRate(void) { return m_fRate; }     //設置速率     inline void setRate(float fRate) { m_fRate = fRate; }    //設置演示當前動畫的演員。 virtual void startWithTarget(CCNode *pTarget); //更新處理。 virtual void update(float time); //創建一個當前類的反向播放的實例。     virtual CCActionInterval* reverse(void);  public:     //靜態創建函數，參一為一個動畫，參二為動畫時長。內部調用create實現。     CC_DEPRECATED_ATTRIBUTE static CCDeccelAmplitude* actionWithAction(CCAction *pAction, float duration);     //上面的create實現。     static CCDeccelAmplitude* create(CCAction *pAction, float duration);  protected:  //速率 float m_fRate; //控制動畫。     CCActionInterval *m_pOther; };  對應CPP： //靜態創建函數，參一為一個動畫，參二為動畫時長。內部調用create實現。 CCDeccelAmplitude* CCDeccelAmplitude::actionWithAction(CCAction *pAction, float duration) {     return CCDeccelAmplitude::create(pAction, duration); } //上面的create實現。 CCDeccelAmplitude* CCDeccelAmplitude::create(CCAction *pAction, float duration) {  //new, initWithAction, autorelease三部曲，當然別忘了失敗處理。      CCDeccelAmplitude *pRet = new CCDeccelAmplitude();     if (pRet)     {         if (pRet->initWithAction(pAction, duration))         {             pRet->autorelease();         }         else         {             CC_SAFE_DELETE(pRet);         }     }      return pRet; }  //初始化處理。 bool CCDeccelAmplitude::initWithAction(CCAction *pAction, float duration) {  //先調用基類的初始化處理。     if (CCActionInterval::initWithDuration(duration)) {  //速率置1。         m_fRate = 1.0f;   //佔用控制動畫，對其引用計數器加一。         m_pOther = (CCActionInterval*)(pAction);         pAction->retain();          return true;     }      return false; } //析構 CCDeccelAmplitude::~CCDeccelAmplitude(void) {  //不再佔用控制動畫，對其引用計數器減一。     CC_SAFE_RELEASE(m_pOther); } //設置演示當前動畫的演員。 void CCDeccelAmplitude::startWithTarget(CCNode *pTarget) {  //調用基類的相應函數。 CCActionInterval::startWithTarget(pTarget); //調用控制動畫的相應函數。     m_pOther->startWithTarget(pTarget); } //更新動畫。 void CCDeccelAmplitude::update(float time) {  //與加速動畫有什麼不同?很容易明白。     ((CCDeccelAmplitude*)(m_pOther))->setAmplitudeRate(powf((1 - time), m_fRate));     m_pOther->update(time); } //創建一個當前類的反向動畫實例。 CCActionInterval* CCDeccelAmplitude::reverse(void) {     return CCDeccelAmplitude::create(m_pOther->reverse(), m_fDuration); }  //停止網格動畫。 class CC_DLL CCStopGrid : public CCActionInstant { public:  //設置演示該動畫的演員。     virtual void startWithTarget(CCNode *pTarget);  public:     //靜態函數:創建一個當前類的實例動畫，內部調用create實現。     CC_DEPRECATED_ATTRIBUTE static CCStopGrid* action(void);     //上面的create實現。     static CCStopGrid* create(void); }; 對應CPP： //設置演示當前動畫的演員。 void CCStopGrid::startWithTarget(CCNode *pTarget) {  //調用基類的相應函數。     CCActionInstant::startWithTarget(pTarget);  //取得演員所用的網格數據。     CCGridBase *pGrid = m_pTarget->getGrid();     if (pGrid && pGrid->isActive()) {  //如果是激活狀態，取消激活。         pGrid->setActive(false);     } } //靜態函數:創建一個當前類的實例動畫，內部調用create實現。 CCStopGrid* CCStopGrid::action(void) {     return CCStopGrid::create(); } //上面的create實現。 CCStopGrid* CCStopGrid::create(void) {     CCStopGrid* pAction = new CCStopGrid();     pAction->autorelease();      return pAction; }  //恢復網格動畫。 class CC_DLL CCReuseGrid : public CCActionInstant { public:     //初始化     bool initWithTimes(int times);  //設置演示當前動畫的演員。     virtual void startWithTarget(CCNode *pTarget);  public:     //靜態函數：創建一個當前類的實例。參數為，內部調用create實現。     CC_DEPRECATED_ATTRIBUTE static CCReuseGrid* actionWithTimes(int times);     //上面函數的create實現。     static CCReuseGrid* create(int times); protected:  //     int m_nTimes; };  對應CPP： // CCReuseGrid* CCReuseGrid::actionWithTimes(int times) {     return CCReuseGrid::create(times); } //上面函數的create實現。 CCReuseGrid* CCReuseGrid::create(int times) {  //先new出一個當前類的實例。     CCReuseGrid *pAction = new CCReuseGrid();     if (pAction) {  //進行初始化，成功后交由內存管理器進行引用計數器的管理。         if (pAction->initWithTimes(times))         {             pAction->autorelease();         }         else         {     //初始化失敗則釋放並置空。             CC_SAFE_DELETE(pAction);         }     }  //返回創建的動畫實例，當然，也可能為NULL。     return pAction; }  //初始化。 bool CCReuseGrid::initWithTimes(int times) {     m_nTimes = times;      return true; } //設置演示當前動畫的演員。 void CCReuseGrid::startWithTarget(CCNode *pTarget) {  //調用基類的相應函數。     CCActionInstant::startWithTarget(pTarget);  //如果演員有正在使用的網格動畫。     if (m_pTarget->getGrid() && m_pTarget->getGrid()->isActive())     { //取得這個網格動畫並激活。     m_pTarget->getGrid()->setReuseGrid(m_pTarget->getGrid()->getReuseGrid() + m_nTimes);     } } 

有了網格基本動畫，我們再來看一下3D網格基本動畫

CCActionGrid3D.h/cpp:

#include "CCActionGrid.h"  NS_CC_BEGIN //波浪動畫 class CC_DLL CCWaves3D : public CCGrid3DAction  public:  //取得和設置振幅     inline float getAmplitude(void) { return m_fAmplitude; }     inline void setAmplitude(float fAmplitude) { m_fAmplitude = fAmplitude; }  //取得和設置頻率     inline float getAmplitudeRate(void) { return m_fAmplitudeRate; }     inline void setAmplitudeRate(float fAmplitudeRate) { m_fAmplitudeRate = fAmplitudeRate; }      //初始化     bool initWithWaves(int wav, float amp, const ccGridSize& gridSize, float duration);   //產生一個實例的拷貝。 virtual CCObject* copyWithZone(CCZone* pZone); //動畫更新。     virtual void update(float time);  public:     //創建一個波浪動畫，參一為波浪動畫搖動的次數，參二為波浪的振幅，參三為格子的大小，參四為動畫時長。    CC_DEPRECATED_ATTRIBUTE static CCWaves3D* actionWithWaves(int wav, float amp, const ccGridSize& gridSize, float duration);     //上面的create實現。     static CCWaves3D* create(int wav, float amp, const ccGridSize& gridSize, float duration); protected:  //波浪搖動的次數。     int m_nWaves;  //搖動的振幅。     float m_fAmplitude;  //搖動的頻率。     float m_fAmplitudeRate; };  CPP實現：  //創建一個波浪動畫，參一為波浪動畫搖動的次數，參二為波浪的振幅，參三為格子的大小，參四為動畫時長。 CCWaves3D* CCWaves3D::actionWithWaves(int wav, float amp, const ccGridSize& gridSize, float duration) {     return CCWaves3D::create(wav, amp, gridSize, duration); } //上面的create實現。 CCWaves3D* CCWaves3D::create(int wav, float amp, const ccGridSize& gridSize, float duration) {  //new,初始化，autorelease，失敗處理。     CCWaves3D *pAction = new CCWaves3D();      if (pAction)     {         if (pAction->initWithWaves(wav, amp, gridSize, duration))         {             pAction->autorelease();         }         else         {             CC_SAFE_RELEASE_NULL(pAction);         }     }      return pAction;     } //初始化。 bool CCWaves3D::initWithWaves(int wav, float amp, const ccGridSize& gridSize, float duration) {  //先調用基類的初始化函數。     if (CCGrid3DAction::initWithSize(gridSize, duration))     {    //保存相應的參數。         m_nWaves = wav;         m_fAmplitude = amp;         m_fAmplitudeRate = 1.0f;         return true;     }      return false; } //產生一個當前類的實例。 CCObject* CCWaves3D::copyWithZone(CCZone *pZone) {     CCZone* pNewZone = NULL;     CCWaves3D* pCopy = NULL;     if(pZone && pZone->m_pCopyObject)      {         //in case of being called at sub class         pCopy = (CCWaves3D*)(pZone->m_pCopyObject);     }     else     {         pCopy = new CCWaves3D();         pZone = pNewZone = new CCZone(pCopy);     }      CCGrid3DAction::copyWithZone(pZone);       pCopy->initWithWaves(m_nWaves, m_fAmplitude, m_sGridSize, m_fDuration);      CC_SAFE_DELETE(pNewZone);     return pCopy; } //更新動畫。 void CCWaves3D::update(float time) {  //雙循環遍歷格子。     int i, j;     for (i = 0; i < m_sGridSize.x + 1; ++i)     {         for (j = 0; j < m_sGridSize.y + 1; ++j)         {     //取出當前格子原始頂點，對z值進行sin曲線的變化加值。形成來回搖動的效果。             ccVertex3F v = originalVertex(ccg(i ,j));             v.z += (sinf((float)M_PI * time * m_nWaves * 2 + (v.y+v.x) * .01f) * m_fAmplitude * m_fAmplitudeRate);             CCLog("v.z offset is %f\n", (sinf((float)M_PI * time * m_nWaves * 2 + (v.y+v.x) * .01f) * m_fAmplitude * m_fAmplitudeRate));     //將頂點設置到格子中。             setVertex(ccg(i, j), v);         }     } }  對應圖： 

//繞X軸翻轉。 class CC_DLL CCFlipX3D : public CCGrid3DAction { public:     //初始化動畫。 bool initWithDuration(float duration); //初始化格子大小。 virtual bool initWithSize(const ccGridSize& gridSize, float duration); //產生一個當前類的實例拷貝。 virtual CCObject* copyWithZone(CCZone* pZone); //動畫更新。     virtual void update(float time);  public:     //創建一個繞X軸翻轉的3D網格動畫。參數為動畫時長。     CC_DEPRECATED_ATTRIBUTE static CCFlipX3D* actionWithDuration(float duration);     //上面的create實現。     static CCFlipX3D* create(float duration); };  對應的CPP實現：  //創建一個繞X軸翻轉的3D網格動畫。參數為動畫時長。CCFlipX3D::actionWithDuration(float duration) {     return CCFlipX3D::create(duration); } //上面的create實現。 CCFlipX3D* CCFlipX3D::create(float duration) { //new ,初始化, autorelease,失敗處理。     CCFlipX3D *pAction = new CCFlipX3D();      if (pAction)     {         if (pAction->initWithSize(ccg(1, 1), duration))         {             pAction->autorelease();         }         else         {             CC_SAFE_RELEASE_NULL(pAction);         }     }      return pAction; } //初始化動畫。 bool CCFlipX3D::initWithDuration(float duration) {     return CCGrid3DAction::initWithSize(ccg(1, 1), duration); } //初始化格子大小。 bool CCFlipX3D::initWithSize(const ccGridSize& gridSize, float duration) {     if (gridSize.x != 1 || gridSize.y != 1)     {         // Grid size must be (1,1)         CCAssert(0, "Grid size must be (1,1)");          return false;     }      return CCGrid3DAction::initWithSize(gridSize, duration); } //產生一個當前類的實例拷貝。 CCObject* CCFlipX3D::copyWithZone(CCZone *pZone) {     CCZone* pNewZone = NULL;     CCFlipX3D* pCopy = NULL;     if(pZone && pZone->m_pCopyObject)      {         //in case of being called at sub class         pCopy = (CCFlipX3D*)(pZone->m_pCopyObject);     }     else     {         pCopy = new CCFlipX3D();         pZone = pNewZone = new CCZone(pCopy);     }      CCGrid3DAction::copyWithZone(pZone);      pCopy->initWithSize(m_sGridSize, m_fDuration);      CC_SAFE_DELETE(pNewZone);     return pCopy; } //動畫更新。 void CCFlipX3D::update(float time) {     //角度，從0~180變化。     float angle = (float)M_PI * time; // 180 degrees     //計算其sin值     float mz = sinf(angle);     //對基除2後計算cos值。     angle = angle / 2.0f; // x calculates degrees from 0 to 90     float mx = cosf(angle);     //定義臨時變數。     ccVertex3F v0, v1, v, diff;     //     v0 = originalVertex(ccg(1, 1));     v1 = originalVertex(ccg(0, 0));     //     float    x0 = v0.x;     float    x1 = v1.x;     float x;     ccGridSize    a, b, c, d;     //     if ( x0 > x1 )     {         // Normal Grid         a = ccg(0,0);         b = ccg(0,1);         c = ccg(1,0);         d = ccg(1,1);         x = x0;     }     else     {         // Reversed Grid         c = ccg(0,0);         d = ccg(0,1);         a = ccg(1,0);         b = ccg(1,1);         x = x1;     }     //     diff.x = ( x - x * mx );     diff.z = fabsf( floorf( (x * mz) / 4.0f ) );     //取得左下角頂點，設置X和Z值。     v = originalVertex(a);     v.x = diff.x;     v.z += diff.z;     setVertex(a, v);     //取得左上角頂點。計算X和Z值。     v = originalVertex(b);     v.x = diff.x;     v.z += diff.z;     setVertex(b, v);     //取得右下角頂點。計算X和Z值。     v = originalVertex(c);     v.x -= diff.x;     v.z -= diff.z;     setVertex(c, v);     //取得右上角頂點。計算X和Z值。     v = originalVertex(d);     v.x -= diff.x;     v.z -= diff.z;     setVertex(d, v); }  對應圖： 

//繞Y軸反轉的3D網格動畫。 class CC_DLL CCFlipY3D : public CCFlipX3D { public:  //動畫更新。     virtual void update(float time);  //產生一個當前類的實例拷貝。     virtual CCObject* copyWithZone(CCZone* pZone);  public:     //創建一個繞Y軸反轉的3D網格動畫，內部調用create實現。     CC_DEPRECATED_ATTRIBUTE static CCFlipY3D* actionWithDuration(float duration);     //上面的create實現。     static CCFlipY3D* create(float duration); }; 對應CPP實現： //創建一個繞Y軸反轉的3D網格動畫，內部調用create實現。 CCFlipY3D* CCFlipY3D::actionWithDuration(float duration) {     return CCFlipY3D::create(duration); } //上面的create實現。 CCFlipY3D* CCFlipY3D::create(float duration) { //new ,初始化, autorelease,失敗處理。     CCFlipY3D *pAction = new CCFlipY3D();      if (pAction)     {         if (pAction->initWithSize(ccg(1, 1), duration))         {             pAction->autorelease();         }         else         {             CC_SAFE_RELEASE_NULL(pAction);         }     }      return pAction; } //產生一個當前類的實例拷貝。 CCObject* CCFlipY3D::copyWithZone(CCZone* pZone) {     CCZone* pNewZone = NULL;     CCFlipY3D* pCopy = NULL;     if(pZone && pZone->m_pCopyObject)      {         //in case of being called at sub class         pCopy = (CCFlipY3D*)(pZone->m_pCopyObject);     }     else     {         pCopy = new CCFlipY3D();         pZone = pNewZone = new CCZone(pCopy);     }      CCFlipX3D::copyWithZone(pZone);      pCopy->initWithSize(m_sGridSize, m_fDuration);      CC_SAFE_DELETE(pNewZone);     return pCopy; } //動畫更新。 void CCFlipY3D::update(float time) { //角度從0~180 float angle = (float)M_PI * time; // 180 degrees //對其進行sin計算。 float mz = sinf( angle ); //對其做除2計算。 angle = angle / 2.0f;     // x calculates degrees from 0 to 90 //對其進行cos計算。     float my = cosf(angle);          ccVertex3F    v0, v1, v, diff;          v0 = originalVertex(ccg(1, 1));     v1 = originalVertex(ccg(0, 0));          float    y0 = v0.y;     float    y1 = v1.y;     float y;     ccGridSize    a, b, c, d;          if (y0 > y1)     {         // Normal Grid         a = ccg(0,0);         b = ccg(0,1);         c = ccg(1,0);         d = ccg(1,1);         y = y0;     }     else     {         // Reversed Grid         b = ccg(0,0);         a = ccg(0,1);         d = ccg(1,0);         c = ccg(1,1);         y = y1;     }          diff.y = y - y * my;     diff.z = fabsf(floorf((y * mz) / 4.0f));          // bottom-left     v = originalVertex(a);     v.y = diff.y;     v.z += diff.z;     setVertex(a, v);          // upper-left     v = originalVertex(b);     v.y -= diff.y;     v.z -= diff.z;     setVertex(b, v);          // bottom-right     v = originalVertex(c);     v.y = diff.y;     v.z += diff.z;     setVertex(c, v);          // upper-right     v = originalVertex(d);     v.y -= diff.y;     v.z -= diff.z;     setVertex(d, v); } 對應圖： 

//球體3D網格動畫。 class CC_DLL CCLens3D : public CCGrid3DAction { public:     //     inline float getLensEffect(void) { return m_fLensEffect; }     //     inline void setLensEffect(float fLensEffect) { m_fLensEffect = fLensEffect; }     //設置中心位置。     inline const CCPoint& getPosition(void) { return m_position; }     void setPosition(const CCPoint& position);      //初始化。 bool initWithPosition(const CCPoint& pos, float r, const ccGridSize& gridSize, float duration); //創建一個當前類的實例拷貝。 virtual CCObject* copyWithZone(CCZone* pZone); //動畫更新。     virtual void update(float time);  public:     //創建一個球體的3D網格動畫。參一為中心點位置，參二為半徑，參三為格子大小，參四為動畫時長。     CC_DEPRECATED_ATTRIBUTE static CCLens3D* actionWithPosition(const CCPoint& pos, float r, const ccGridSize& gridSize, float duration);     //上面的create實現。     static CCLens3D* create(const CCPoint& pos, float r, const ccGridSize& gridSize, float duration); protected:     //球體的中心位置。     CCPoint m_position;  //球體的半徑。     float m_fRadius;     //效果公式的參數。     float m_fLensEffect;  //這個命名本意是使用臟矩形，即相同的矩形沒有改變就不要重新更新。但可惜它在使用時的true與false應該反過來。這裡可以理解成是否更新中心點位置，需要重新計算。     bool    m_bDirty; };  對應的CPP： //創建一個球體的3D網格動畫。參一為中心點位置，參二為半徑，參三為格子大小，參四為動畫時長。 CCLens3D* CCLens3D::actionWithPosition(const CCPoint& pos, float r, const ccGridSize& gridSize, float duration) {     return CCLens3D::create(pos, r, gridSize, duration); } //上面的create實現。 CCLens3D* CCLens3D::create(const CCPoint& pos, float r, const ccGridSize& gridSize, float duration) {  //new,初始化，autorelease，失敗處理。     CCLens3D *pAction = new CCLens3D();      if (pAction)     {         if (pAction->initWithPosition(pos, r, gridSize, duration))         {             pAction->autorelease();         }         else         {             CC_SAFE_RELEASE_NULL(pAction);         }     }      return pAction; } //初始化。 bool CCLens3D::initWithPosition(const CCPoint& pos, float r, const ccGridSize& gridSize, float duration) {  //先調用基類的相應函數。     if (CCGrid3DAction::initWithSize(gridSize, duration)) {  //保存參數到成員變數。         m_position = ccp(-1, -1);         setPosition(pos);         m_fRadius = r;         m_fLensEffect = 0.7f;         //設置需要重新計算。         m_bDirty = true;          return true;     }      return false; } //產生一個當前類的實例拷貝。 CCObject* CCLens3D::copyWithZone(CCZone *pZone) {     CCZone* pNewZone = NULL;     CCLens3D* pCopy = NULL;     if(pZone && pZone->m_pCopyObject)      {         //in case of being called at sub class         pCopy = (CCLens3D*)(pZone->m_pCopyObject);     }     else     {         pCopy = new CCLens3D();         pZone = pNewZone = new CCZone(pCopy);     }      CCGrid3DAction::copyWithZone(pZone);      pCopy->initWithPosition(m_position, m_fRadius, m_sGridSize, m_fDuration);          CC_SAFE_DELETE(pNewZone);     return pCopy; } //設置球體的中心位置。 void CCLens3D::setPosition(const CCPoint& pos) {     if( !pos.equals(m_position))     {//位置有更新，則設置需要重新計算。         m_position = pos;         m_bDirty = true;     } } //動畫更新。 void CCLens3D::update(float time) { CC_UNUSED_PARAM(time); //如果需要重新計算。     if (m_bDirty)     {         int i, j;         //雙循環遍歷格子。         for (i = 0; i < m_sGridSize.x + 1; ++i)         {             for (j = 0; j < m_sGridSize.y + 1; ++j)             {                 //取出格子對應的頂點。                 ccVertex3F v = originalVertex(ccg(i, j));                //計算格子頂點與中心點的差。                 CCPoint vect = ccpSub(m_position, ccp(v.x, v.y));                 //計算格子頂點與中心點的距離。                 float r = ccpLength(vect);                 //如果距離在半徑內。                 if (r < m_fRadius)                 {                     r = m_fRadius - r;                     float pre_log = r / m_fRadius;                     if ( pre_log == 0 )                      {                         pre_log = 0.001f;                     }                     //通過一些函數來取得相應的頂點影響值。                     float l = logf(pre_log) * m_fLensEffect;                     float new_r = expf( l ) * m_fRadius;                     //如果不是中心點，就進行位置的更新。                     if (ccpLength(vect) > 0)                     {                         vect = ccpNormalize(vect);                         CCPoint new_vect = ccpMult(vect, new_r);                         v.z += ccpLength(new_vect) * m_fLensEffect;                     }                 }                 //設置格子的新頂點。                 setVertex(ccg(i, j), v);             }         }                  m_bDirty = false;     } }  對應圖： 

//漣漪3D網格特效。 class CC_DLL CCRipple3D : public CCGrid3DAction { public:     //取得和設置中心位置。     inline const CCPoint& getPosition(void) { return m_position; }     void setPosition(const CCPoint& position);  //取得和設置振幅。     inline float getAmplitude(void) { return m_fAmplitude; }     inline void setAmplitude(float fAmplitude) { m_fAmplitude = fAmplitude; }  //取得和設置頻率。     inline float getAmplitudeRate(void) { return m_fAmplitudeRate; }     inline void setAmplitudeRate(float fAmplitudeRate) { m_fAmplitudeRate = fAmplitudeRate; }      //初始化位置。 bool initWithPosition(const CCPoint& pos, float r, int wav, float amp,          const ccGridSize& gridSize, float duration);     virtual CCObject* copyWithZone(CCZone* pZone);     virtual void update(float time);  public:     //創建一個漣漪3D網格特效。參一為中心位置，參二為半徑，參三為振幅，參四為格子大小，參五為動畫時長。     CC_DEPRECATED_ATTRIBUTE static CCRipple3D* actionWithPosition(const CCPoint& pos, float r, int wav, float amp,          const ccGridSize& gridSize, float duration);     //上面的create實現。     static CCRipple3D* create(const CCPoint& pos, float r, int wav, float amp,          const ccGridSize& gridSize, float duration); protected:     //中心位置。 CCPoint m_position; //半徑。 float m_fRadius; //振動次數。 int m_nWaves; //振幅。 float m_fAmplitude; //振動頻率。     float m_fAmplitudeRate; }; CPP實現： //創建一個漣漪3D網格特效。 CCRipple3D* CCRipple3D::actionWithPosition(const CCPoint& pos, float r, int wav, float amp, const ccGridSize& gridSize, float duration) {     return CCRipple3D::create(pos, r, wav, amp, gridSize, duration); } //上面的create實現。 CCRipple3D* CCRipple3D::create(const CCPoint& pos, float r, int wav, float amp, const ccGridSize& gridSize, float duration) { //先new出一個當前類的實例。     CCRipple3D *pAction = new CCRipple3D(); //如果成功。     if (pAction) { //進行初始化。         if (pAction->initWithPosition(pos, r, wav, amp, gridSize, duration))         { //如果初始化成功，交由內存管理器進行引用計數管理。             pAction->autorelease();         }         else         { //如果失敗，釋放並置空。             CC_SAFE_RELEASE_NULL(pAction);         }     }      return pAction; }  //初始化。 bool CCRipple3D::initWithPosition(const CCPoint& pos, float r, int wav, float amp, const ccGridSize& gridSize, float duration) { //先調用基類的初始化處理。     if (CCGrid3DAction::initWithSize(gridSize, duration)) { //設置中心點位置。         setPosition(pos);         //將參數保存到成員變數中。         m_fRadius = r;         m_nWaves = wav;         m_fAmplitude = amp;         m_fAmplitudeRate = 1.0f;          return true;     }      return false; } //設置中心點位置。 void CCRipple3D::setPosition(const CCPoint& position) {     m_position = position; } //產生一個當前類的實例拷貝。 CCObject* CCRipple3D::copyWithZone(CCZone *pZone) {     CCZone* pNewZone = NULL;     CCRipple3D* pCopy = NULL;     if(pZone && pZone->m_pCopyObject)     {         //in case of being called at sub class         pCopy = (CCRipple3D*)(pZone->m_pCopyObject);     }     else     {         pCopy = new CCRipple3D();         pZone = pNewZone = new CCZone(pCopy);     }      CCGrid3DAction::copyWithZone(pZone);      pCopy->initWithPosition(m_position, m_fRadius, m_nWaves, m_fAmplitude, m_sGridSize, m_fDuration);          CC_SAFE_DELETE(pNewZone);     return pCopy; } //更新動畫處理。 void CCRipple3D::update(float time) {     int i, j; //雙循環遍歷每個格子。     for (i = 0; i < (m_sGridSize.x+1); ++i)     {         for (j = 0; j < (m_sGridSize.y+1); ++j)         {             //取得格子的原始頂點。             ccVertex3F v = originalVertex(ccg(i, j));             //計算頂點與中心點的位置之差。             CCPoint vect = ccpSub(m_position, ccp(v.x,v.y));             //計算出頂點與中心點的距離。             float r = ccpLength(vect);             //如果在半徑範圍內。通過距離做為參數按照sin曲線公式計算出相應的Z值偏移。             if (r < m_fRadius)             {                    r = m_fRadius - r;                 float rate = powf(r / m_fRadius, 2);                 v.z += (sinf( time*(float)M_PI * m_nWaves * 2 + r * 0.1f) * m_fAmplitude * m_fAmplitudeRate * rate);             }             //將偏移后的頂點設置給格子。             setVertex(ccg(i, j), v);         }     } } 效果圖： 

//3D搖動的網格動畫。 class CC_DLL CCShaky3D : public CCGrid3DAction { public:     //初始化。 bool initWithRange(int range, bool shakeZ, const ccGridSize& gridSize, float duration); //產生一個實例的拷貝。 virtual CCObject* copyWithZone(CCZone* pZone); //更新動畫。     virtual void update(float time);  public:     //創建一個3D搖動的網格動畫。參一是隨機範圍，參二指定是否在Z值上搖動，參三為格子大小，參四為動畫時長。     CC_DEPRECATED_ATTRIBUTE static CCShaky3D* actionWithRange(int range, bool shakeZ, const ccGridSize& gridSize, float duration);     //上面的create實現。     static CCShaky3D* create(int range, bool shakeZ, const ccGridSize& gridSize, float duration); protected:     //隨機範圍。     int m_nRandrange;     //是否在Z值上搖動。     bool m_bShakeZ; }; //創建一個3D搖動的網格動畫。參一是隨機範圍，參二指定是否在Z值上搖動，參三為格子大小，參四為動畫時長。 CCShaky3D* CCShaky3D::actionWithRange(int range, bool shakeZ, const ccGridSize& gridSize, float duration) {     return CCShaky3D::create(range, shakeZ, gridSize, duration); } //上面的create實現。 CCShaky3D* CCShaky3D::create(int range, bool shakeZ, const ccGridSize& gridSize, float duration) { //先new出一個當前類的實例，     CCShaky3D *pAction = new CCShaky3D();      if (pAction) { //如果成功，對其進行初始化。         if (pAction->initWithRange(range, shakeZ, gridSize, duration))         {  //如果初始化成功，交由內存管理器進行引用計數的管理。             pAction->autorelease();         }         else         {                //如果失敗，釋放並置空。             CC_SAFE_RELEASE_NULL(pAction);         }     }      return pAction; }  //初始化。 bool CCShaky3D::initWithRange(int range, bool shakeZ, const ccGridSize& gridSize, float duration) { //先調用基類的初始化函數。     if (CCGrid3DAction::initWithSize(gridSize, duration)) {         //如果成功，保存參數到成員變數中。         m_nRandrange = range;         m_bShakeZ = shakeZ;          return true;     }      return false; } //產生一個當前類的實例。 CCObject* CCShaky3D::copyWithZone(CCZone *pZone) {     CCZone* pNewZone = NULL;     CCShaky3D* pCopy = NULL;     if(pZone && pZone->m_pCopyObject)     {         //in case of being called at sub class         pCopy = (CCShaky3D*)(pZone->m_pCopyObject);     }     else     {         pCopy = new CCShaky3D();         pZone = pNewZone = new CCZone(pCopy);     }      CCGrid3DAction::copyWithZone(pZone);      pCopy->initWithRange(m_nRandrange, m_bShakeZ, m_sGridSize, m_fDuration);          CC_SAFE_DELETE(pNewZone);     return pCopy; } //動畫更新。 void CCShaky3D::update(float time) {     CC_UNUSED_PARAM(time);     int i, j;     //雙循環遍歷所有格子。     for (i = 0; i < (m_sGridSize.x+1); ++i)     {         for (j = 0; j < (m_sGridSize.y+1); ++j)         {             //取得格子的原始頂點。             ccVertex3F v = originalVertex(ccg(i ,j));             //對頂點的x,y進行隨機的的加成。             v.x += (rand() % (m_nRandrange*2)) - m_nRandrange;             v.y += (rand() % (m_nRandrange*2)) - m_nRandrange;             //如果需要Z值的搖動，對頂點的z進行隨機的的加成。             if (m_bShakeZ)             {                 v.z += (rand() % (m_nRandrange*2)) - m_nRandrange;             }             //將頂點設置到相應格子中。             setVertex(ccg(i, j), v);         }     } } 對應圖： 

//流體效果的3D網格動畫。 class CC_DLL CCLiquid : public CCGrid3DAction { public:     //取得和設置振幅。     inline float getAmplitude(void) { return m_fAmplitude; }     inline void setAmplitude(float fAmplitude) { m_fAmplitude = fAmplitude; }     //取得和設置頻率。     inline float getAmplitudeRate(void) { return m_fAmplitudeRate; }     inline void setAmplitudeRate(float fAmplitudeRate) { m_fAmplitudeRate = fAmplitudeRate; }  //初始化     bool initWithWaves(int wav, float amp, const ccGridSize& gridSize, float duration);     //產生一個當前類的實例。     virtual CCObject* copyWithZone(CCZone* pZone);     //更新動畫。     virtual void update(float time);  public: //創建一個流體效果的3D網格動畫。參一為動畫的次數，參二為振幅，參三為格子大小，參四為動畫時長。     CC_DEPRECATED_ATTRIBUTE static CCLiquid* actionWithWaves(int wav, float amp, const ccGridSize& gridSize, float duration);     //上面的create實現。     static CCLiquid* create(int wav, float amp, const ccGridSize& gridSize, float duration); protected:     //動畫的次數。     int m_nWaves;     //振幅。     float m_fAmplitude;     //頻率。     float m_fAmplitudeRate; }; 對應的CPP: //創建一個流體效果的3D網格動畫。參一為動畫的次數，參二為振幅，參三為格子大小，參四為動畫時長。 CCLiquid* CCLiquid::actionWithWaves(int wav, float amp, const ccGridSize& gridSize, float duration) {     return CCLiquid::create(wav, amp, gridSize, duration); } //上面的create實現。 CCLiquid* CCLiquid::create(int wav, float amp, const ccGridSize& gridSize, float duration) {     //先new出一個當前類的實例動畫。     CCLiquid *pAction = new CCLiquid();     if (pAction)     {         //如果成功，進行初始化。         if (pAction->initWithWaves(wav, amp, gridSize, duration))         {             //初始化成功交由內存管理器進行引用計數器的管理。             pAction->autorelease();         }         else         {             //如果失敗，釋放並置空。             CC_SAFE_RELEASE_NULL(pAction);         }     }      return pAction; }  //初始化 bool CCLiquid::initWithWaves(int wav, float amp, const ccGridSize& gridSize, float duration) {     //先調用基類的初始化函數。     if (CCGrid3DAction::initWithSize(gridSize, duration))     {         //將相應的參數保存到成員變數中。         m_nWaves = wav;         m_fAmplitude = amp;         m_fAmplitudeRate = 1.0f;          return true;     }      return false; } //產生一個當前類的實例拷貝。 CCObject* CCLiquid::copyWithZone(CCZone *pZone) {     CCZone* pNewZone = NULL;     CCLiquid* pCopy = NULL;     if(pZone && pZone->m_pCopyObject)      {         //in case of being called at sub class         pCopy = (CCLiquid*)(pZone->m_pCopyObject);     }     else     {         pCopy = new CCLiquid();         pZone = pNewZone = new CCZone(pCopy);     }      CCGrid3DAction::copyWithZone(pZone);      pCopy->initWithWaves(m_nWaves, m_fAmplitude, m_sGridSize, m_fDuration);      CC_SAFE_DELETE(pNewZone);     return pCopy; } //動畫更新。 void CCLiquid::update(float time) {     int i, j;     //雙循環遍歷所有的格子。     for (i = 1; i < m_sGridSize.x; ++i)     {         for (j = 1; j < m_sGridSize.y; ++j)         {             //取出格子的原始頂點位置。             ccVertex3F v = originalVertex(ccg(i, j));             //設置頂點的x,y值。             v.x = (v.x + (sinf(time * (float)M_PI * m_nWaves * 2 + v.x * .01f) * m_fAmplitude * m_fAmplitudeRate));             v.y = (v.y + (sinf(time * (float)M_PI * m_nWaves * 2 + v.y * .01f) * m_fAmplitude * m_fAmplitudeRate));             //將頂點數據設置給相應格子。             setVertex(ccg(i, j), v);         }     } } 對應圖： 

//波浪效果的網格動畫，與CCWaves3D的區別是少了Z值的變化。 class CC_DLL CCWaves : public CCGrid3DAction { public:     //設置振幅。     inline float getAmplitude(void) { return m_fAmplitude; }     inline void setAmplitude(float fAmplitude) { m_fAmplitude = fAmplitude; }     //設置頻率。     inline float getAmplitudeRate(void) { return m_fAmplitudeRate; }     inline void setAmplitudeRate(float fAmplitudeRate) { m_fAmplitudeRate = fAmplitudeRate; }      //初始化。     bool initWithWaves(int wav, float amp, bool h, bool v, const ccGridSize& gridSize,         float duration);     //產生一個當前類的實例拷貝。     virtual CCObject* copyWithZone(CCZone* pZone);     //更新動畫。     virtual void update(float time);  public:     //創建一個波浪效果的網格動畫，參一為波浪的次數，參二為振幅，參三為是否進行橫向運動，參四為是否進行豎向運動,參五為格子大小，參六為動畫時長。     CC_DEPRECATED_ATTRIBUTE static CCWaves* actionWithWaves(int wav, float amp, bool h, bool v, const ccGridSize& gridSize,          float duration);      //上面的create實現。     static CCWaves* create(int wav, float amp, bool h, bool v, const ccGridSize& gridSize,         float duration); protected:     //波浪次數。     int m_nWaves;     //振幅。     float m_fAmplitude;     //頻率。     float m_fAmplitudeRate;     //豎向     bool m_bVertical;     //橫向。     bool m_bHorizontal; };  //創建一個波浪效果的網格動畫，參一為波浪的次數，參二為振幅，參三為是否進行橫向運動，參四為是否進行豎向運動,參五為格子大小，參六為動畫時長。 CCWaves* CCWaves::actionWithWaves(int wav, float amp, bool h, bool v, const ccGridSize& gridSize, float duration) {     return CCWaves::create(wav, amp, h, v, gridSize, duration); } //上面的create實現。 CCWaves* CCWaves::create(int wav, float amp, bool h, bool v, const ccGridSize& gridSize, float duration) {    //先new出一個當前類的實例。     CCWaves *pAction = new CCWaves();     //如果成功。     if (pAction)     {  //進行初始化。         if (pAction->initWithWaves(wav, amp, h, v, gridSize, duration))         {  //初始化成功，則交給內存管理器進行引用計數器的管理。             pAction->autorelease();         }         else         {             //否則釋放並置空。             CC_SAFE_RELEASE_NULL(pAction);         }     }      return pAction; } //初始化。 bool CCWaves::initWithWaves(int wav, float amp, bool h, bool v, const ccGridSize& gridSize, float duration) {     if (CCGrid3DAction::initWithSize(gridSize, duration))     {         m_nWaves = wav;         m_fAmplitude = amp;         m_fAmplitudeRate = 1.0f;         m_bHorizontal = h;         m_bVertical = v;          return true;     }      return false; } //產生一個當前類的實例拷貝。 CCObject* CCWaves::copyWithZone(CCZone *pZone) {     CCZone* pNewZone = NULL;     CCWaves* pCopy = NULL;     if(pZone && pZone->m_pCopyObject)      {         //in case of being called at sub class         pCopy = (CCWaves*)(pZone->m_pCopyObject);     }     else     {         pCopy = new CCWaves();         pZone = pNewZone = new CCZone(pCopy);     }      CCGrid3DAction::copyWithZone(pZone);      pCopy->initWithWaves(m_nWaves, m_fAmplitude, m_bHorizontal, m_bVertical, m_sGridSize, m_fDuration);          CC_SAFE_DELETE(pNewZone);     return pCopy; } //動畫更新。 void CCWaves::update(float time) {     int i, j;     //雙循環遍歷所有格子。     for (i = 0; i < m_sGridSize.x + 1; ++i)     {         for (j = 0; j < m_sGridSize.y + 1; ++j)         {             //取得對應格子的頂點。             ccVertex3F v = originalVertex(ccg(i, j));             //如果進行橫向運動。             if (m_bVertical)             {                //計算X值。                 v.x = (v.x + (sinf(time * (float)M_PI * m_nWaves * 2 + v.y * .01f) * m_fAmplitude * m_fAmplitudeRate));             }             //如果進行豎向運動。             if (m_bHorizontal)             {   //計算Y值。                 v.y = (v.y + (sinf(time * (float)M_PI * m_nWaves * 2 + v.x * .01f) * m_fAmplitude * m_fAmplitudeRate));             }             //將頂點數據設置到相應格子中。             setVertex(ccg(i, j), v);         }     } } 對應圖： 

//盤旋扭曲效果的3D網格動畫。 class CC_DLL CCTwirl : public CCGrid3DAction { public:     //取得中心位置。     inline const CCPoint& getPosition(void) { return m_position; }     //設置中心位置。     void setPosition(const CCPoint& position);     //取得振幅。     inline float getAmplitude(void) { return m_fAmplitude; }     //設置振幅。     inline void setAmplitude(float fAmplitude) { m_fAmplitude = fAmplitude; }     //取得和設置頻率。     inline float getAmplitudeRate(void) { return m_fAmplitudeRate; }     inline void setAmplitudeRate(float fAmplitudeRate) { m_fAmplitudeRate = fAmplitudeRate; }      //初始化。     bool initWithPosition(const CCPoint& pos, int t, float amp, const ccGridSize& gridSize,         float duration);     //產生一個當前類的實例拷貝。 virtual CCObject* copyWithZone(CCZone* pZone); //更新動畫。     virtual void update(float time);  public:     //創建一個盤旋扭曲效果的3D網格動畫。參一為中心位置，參二為盤旋扭曲的次數，參三為振幅，參四為格子大小，參五為動畫時長。     CC_DEPRECATED_ATTRIBUTE static CCTwirl* actionWithPosition(CCPoint pos, int t, float amp, const ccGridSize& gridSize,          float duration);     //上面的create實現。     static CCTwirl* create(CCPoint pos, int t, float amp, const ccGridSize& gridSize,         float duration); protected:     //中心點位置。     CCPoint m_position;     //盤旋扭曲的次數。     int m_nTwirls;     //振幅。     float m_fAmplitude;     //頻率。     float m_fAmplitudeRate; };  //創建一個盤旋扭曲效果的3D網格動畫。參一為中心位置，參二為盤旋扭曲的次數，參三為振幅，參四為格子大小，參五為動畫時長。 CCTwirl* CCTwirl::actionWithPosition(CCPoint pos, int t, float amp, const ccGridSize& gridSize, float duration) {     return CCTwirl::create(pos, t, amp, gridSize, duration); } //上面的create實現。 CCTwirl* CCTwirl::create(CCPoint pos, int t, float amp, const ccGridSize& gridSize, float duration) {     //先new出一個當前類的實例。     CCTwirl *pAction = new CCTwirl();      if (pAction) {     //進行初始化。         if (pAction->initWithPosition(pos, t, amp, gridSize, duration))         {             //成功則交由內存管理器進行引用計數器管理。             pAction->autorelease();         }         else         {   //失敗則釋放並置空。             CC_SAFE_RELEASE_NULL(pAction);         }     }      return pAction; }  //初始化。 bool CCTwirl::initWithPosition(const CCPoint& pos, int t, float amp, const ccGridSize& gridSize, float duration) {     if (CCGrid3DAction::initWithSize(gridSize, duration))     {         setPosition(pos);         m_nTwirls = t;         m_fAmplitude = amp;         m_fAmplitudeRate = 1.0f;          return true;     }      return false; } //設置中心點位置。 void CCTwirl::setPosition(const CCPoint& position) {     m_position = position; } //產生一個當前類的實例拷貝。 CCObject* CCTwirl::copyWithZone(CCZone *pZone) {     CCZone* pNewZone = NULL;     CCTwirl* pCopy = NULL;     if(pZone && pZone->m_pCopyObject)     {         //in case of being called at sub class         pCopy = (CCTwirl*)(pZone->m_pCopyObject);     }     else     {         pCopy = new CCTwirl();         pZone = pNewZone = new CCZone(pCopy);     }      CCGrid3DAction::copyWithZone(pZone);       pCopy->initWithPosition(m_position, m_nTwirls, m_fAmplitude, m_sGridSize, m_fDuration);      CC_SAFE_DELETE(pNewZone);     return pCopy; } //更新動畫。 void CCTwirl::update(float time) { int i, j; //將動畫的中心點位置保存到點c中。     CCPoint    c = m_position;     //雙循環遍歷每個格子。     for (i = 0; i < (m_sGridSize.x+1); ++i)     {         for (j = 0; j < (m_sGridSize.y+1); ++j)         {             //取得對應格子的頂點。             ccVertex3F v = originalVertex(ccg(i ,j));             //取得當前格子與格子中心位置的差。             CCPoint    avg = ccp(i-(m_sGridSize.x/2.0f), j-(m_sGridSize.y/2.0f));             //計算當前格子與中心點位置的距離。             float r = ccpLength(avg);             //計算振幅。             float amp = 0.1f * m_fAmplitude * m_fAmplitudeRate;             //使用cos公式來計算出曲線變化值。             float a = r * cosf( (float)M_PI/2.0f + time * (float)M_PI * m_nTwirls * 2 ) * amp;             //計算出一個偏移。             CCPoint d = ccp(                 sinf(a) * (v.y-c.y) + cosf(a) * (v.x-c.x),                 cosf(a) * (v.y-c.y) - sinf(a) * (v.x-c.x));             //當前頂點位置為動畫中心點位置加上偏移。             v.x = c.x + d.x;             v.y = c.y + d.y;             //將頂點設置給相應的格子。             setVertex(ccg(i ,j), v);         }     } } 對應圖： 

    上面講的是操控網格數據表現一些基本動畫的類。下面我們來看一下由這些基本動畫的類衍生出來的複雜動畫。

打開CCActionTiledGrid.h:

#ifndef __ACTION_CCTILEDGRID_ACTION_H__ #define __ACTION_CCTILEDGRID_ACTION_H__  #include "CCActionGrid.h" //使用Cocos2d命名空間 NS_CC_BEGIN  //搖動的3D格子動畫。 class CC_DLL CCShakyTiles3D : public CCTiledGrid3DAction { public: //初始化，參數一為範圍大小，參數2為是否在Z值上搖動，參數3為格子的大小，參數4為動畫的持續時間。     bool initWithRange(int nRange, bool bShakeZ, const ccGridSize& gridSize,         float duration);  //創建一個當前類的實例拷貝 virtual CCObject* copyWithZone(CCZone* pZone); //更新動畫。     virtual void update(float time);  public:     //靜態函數：創建一個搖動的3D格子動畫。參一為範圍大小，參數2為是否在Z值上搖動，參數3為格子的大小，參數4為動畫的持續時間。內部調用create實現。      CC_DEPRECATED_ATTRIBUTE static CCShakyTiles3D* actionWithRange(int nRange, bool bShakeZ, const ccGridSize& gridSize, float duration);      //上面的create實現。     static CCShakyTiles3D* create(int nRange, bool bShakeZ, const ccGridSize& gridSize, float duration);  protected:  //隨機範圍。 int m_nRandrange; //是否在Z值上搖動     bool m_bShakeZ; }; struct Tile {     CCPoint    position;     CCPoint    startPosition;     ccGridSize    delta; };  //靜態函數：創建一個搖動的3D格子動畫。參一為範圍大小，參數2為是否在Z值上搖動，參數3為格子的大小，參數4為動畫的持續時間。內部調用create實現。 CCShakyTiles3D* CCShakyTiles3D::actionWithRange(int nRange, bool bShakeZ,const ccGridSize& gridSize, float duration) {     return CCShakyTiles3D::create(nRange, bShakeZ, gridSize, duration);     } //上面的create實現。 CCShakyTiles3D* CCShakyTiles3D::create(int nRange, bool bShakeZ,const ccGridSize& gridSize, float duration) {  //先new出一個當前類的實例。     CCShakyTiles3D *pAction = new CCShakyTiles3D();  //如果成功。初始化並交由內存管理器進行引用計數管理。     if (pAction)     {         if (pAction->initWithRange(nRange, bShakeZ, gridSize, duration))         {             pAction->autorelease();         }         else         { //失敗處理。             CC_SAFE_RELEASE_NULL(pAction);         }     }  //返回結果。     return pAction;     }  //初始化。 bool CCShakyTiles3D::initWithRange(int nRange, bool bShakeZ, const ccGridSize& gridSize, float duration) {  //先調用基類的相應函數。     if (CCTiledGrid3DAction::initWithSize(gridSize, duration)) {  //保存相應的值到成員變數。         m_nRandrange = nRange;         m_bShakeZ = bShakeZ;          return true;     }      return false; } //產生一個當前類的實例拷貝。講的太多，略過。 CCObject* CCShakyTiles3D::copyWithZone(CCZone *pZone) {     CCZone* pNewZone = NULL;     CCShakyTiles3D* pCopy = NULL;     if(pZone && pZone->m_pCopyObject)      {         //in case of being called at sub class         pCopy = (CCShakyTiles3D*)(pZone->m_pCopyObject);     }     else     {         pCopy = new CCShakyTiles3D();         pZone = pNewZone = new CCZone(pCopy);     }          CCTiledGrid3DAction::copyWithZone(pZone);      pCopy->initWithRange(m_nRandrange, m_bShakeZ, m_sGridSize, m_fDuration);          CC_SAFE_DELETE(pNewZone);     return pCopy; } //更新動畫。 void CCShakyTiles3D::update(float time) {     CC_UNUSED_PARAM(time);     int i, j;  //雙循環遍歷每個格子。     for (i = 0; i < m_sGridSize.x; ++i)     {         for (j = 0; j < m_sGridSize.y; ++j)         {    //取得格子的位置。             ccQuad3 coords = originalTile(ccg(i, j));              // 計算格子四個頂點的X坐標。             coords.bl.x += ( rand() % (m_nRandrange*2) ) - m_nRandrange;             coords.br.x += ( rand() % (m_nRandrange*2) ) - m_nRandrange;             coords.tl.x += ( rand() % (m_nRandrange*2) ) - m_nRandrange;             coords.tr.x += ( rand() % (m_nRandrange*2) ) - m_nRandrange;              // 計算格子四個頂點的Y坐標。             coords.bl.y += ( rand() % (m_nRandrange*2) ) - m_nRandrange;             coords.br.y += ( rand() % (m_nRandrange*2) ) - m_nRandrange;             coords.tl.y += ( rand() % (m_nRandrange*2) ) - m_nRandrange;             coords.tr.y += ( rand() % (m_nRandrange*2) ) - m_nRandrange;      // 是否在Z軸上搖動。             if (m_bShakeZ)             {       //如果搖動在四個頂點的Z值上有隨機的加成。                 coords.bl.z += ( rand() % (m_nRandrange*2) ) - m_nRandrange;                 coords.br.z += ( rand() % (m_nRandrange*2) ) - m_nRandrange;                 coords.tl.z += ( rand() % (m_nRandrange*2) ) - m_nRandrange;                 coords.tr.z += ( rand() % (m_nRandrange*2) ) - m_nRandrange;             }             //重新設置格子的頂點。             setTile(ccg(i, j), coords);         }     } } 對應圖： 

//隨機抖動效果的3D網格動畫。 class CC_DLL CCShatteredTiles3D : public CCTiledGrid3DAction { public:     //初始化函數。     bool initWithRange(int nRange, bool bShatterZ, const ccGridSize& gridSize, float duration);  //創建一個當前類的實例拷貝。 virtual CCObject* copyWithZone(CCZone* pZone); //更新動畫。     virtual void update(float time);  public:     //靜態函數：創建一個當前類的實例 。參一為範圍，參數為是否在Z抽上震動，參三為格子大小，參四為動畫時長。     CC_DEPRECATED_ATTRIBUTE static CCShatteredTiles3D* actionWithRange(int nRange, bool bShatterZ, const ccGridSize& gridSize,         float duration);      //上面的create實現。     static CCShatteredTiles3D* create(int nRange, bool bShatterZ, const ccGridSize& gridSize,         float duration); protected:  //隨機範圍 int m_nRandrange; //區分第一次渲染所用。 bool m_bOnce; //是否在Z抽上震動。     bool m_bShatterZ; };  //靜態函數：創建一個當前類的實例 。參一為範圍，參數為是否在Z抽上震動，參三為格子大小，參四為動畫時長。 CCShatteredTiles3D* CCShatteredTiles3D::actionWithRange(int nRange, bool bShatterZ, const ccGridSize& gridSize, float duration) {     return CCShatteredTiles3D::create(nRange, bShatterZ, gridSize, duration);     } //上面的create實現。 CCShatteredTiles3D* CCShatteredTiles3D::create(int nRange, bool bShatterZ, const ccGridSize& gridSize, float duration) {  //new,初始化，autorelease，失敗處理一條龍！      CCShatteredTiles3D *pAction = new CCShatteredTiles3D();      if (pAction)     {         if (pAction->initWithRange(nRange, bShatterZ, gridSize, duration))         {             pAction->autorelease();         }         else         {             CC_SAFE_RELEASE_NULL(pAction);         }     }  //返在回結果。     return pAction;     }  //初始化。 bool CCShatteredTiles3D::initWithRange(int nRange, bool bShatterZ, const ccGridSize& gridSize,  float duration) {  //先調用基類的初始化處理。     if (CCTiledGrid3DAction::initWithSize(gridSize, duration)) {  //設置標記提示在更新動理時指明是第一次進行更新。         m_bOnce = false;   //將相應的參數值保存到成員變數中。         m_nRandrange = nRange;         m_bShatterZ = bShatterZ;          return true;     }      return false; } //產生一個當前類的實例。 CCObject* CCShatteredTiles3D::copyWithZone(CCZone *pZone) {     CCZone* pNewZone = NULL;     CCShatteredTiles3D* pCopy = NULL;     if(pZone && pZone->m_pCopyObject)     {         pCopy = (CCShatteredTiles3D*)(pZone->m_pCopyObject);     }     else     {         pCopy = new CCShatteredTiles3D();         pZone = pNewZone = new CCZone(pCopy);     }      //copy super class's member     CCTiledGrid3DAction::copyWithZone(pZone);      pCopy->initWithRange(m_nRandrange, m_bShatterZ, m_sGridSize, m_fDuration);      CC_SAFE_DELETE(pNewZone);     return pCopy; } //更新動畫。 void CCShatteredTiles3D::update(float time) {     CC_UNUSED_PARAM(time);     int i, j;  //如果是第一次渲染。     if (m_bOnce == false) {   //雙循環遍歷格子。         for (i = 0; i < m_sGridSize.x; ++i)         {             for (j = 0; j < m_sGridSize.y; ++j)             {       //取得格子的坐標。                 ccQuad3 coords = originalTile(ccg(i ,j));                                  // 計算格子四個頂點的X坐標。                 coords.bl.x += ( rand() % (m_nRandrange*2) ) - m_nRandrange;                 coords.br.x += ( rand() % (m_nRandrange*2) ) - m_nRandrange;                 coords.tl.x += ( rand() % (m_nRandrange*2) ) - m_nRandrange;                 coords.tr.x += ( rand() % (m_nRandrange*2) ) - m_nRandrange;                                  // 計算格子四個頂點的Y坐標。                 coords.bl.y += ( rand() % (m_nRandrange*2) ) - m_nRandrange;                 coords.br.y += ( rand() % (m_nRandrange*2) ) - m_nRandrange;                 coords.tl.y += ( rand() % (m_nRandrange*2) ) - m_nRandrange;                 coords.tr.y += ( rand() % (m_nRandrange*2) ) - m_nRandrange;                  if (m_bShatterZ)                  {                     coords.bl.z += ( rand() % (m_nRandrange*2) ) - m_nRandrange;                     coords.br.z += ( rand() % (m_nRandrange*2) ) - m_nRandrange;                                     coords.tl.z += ( rand() % (m_nRandrange*2) ) - m_nRandrange;                     coords.tr.z += ( rand() % (m_nRandrange*2) ) - m_nRandrange;                 }                 //重新設置格子的頂點。                 setTile(ccg(i, j), coords);             }         }         //設置不是第一次更新。         m_bOnce = true;     } } struct Tile; 對應圖: 

//重新排列格子效果的3D網格動畫。 class CC_DLL CCShuffleTiles : public CCTiledGrid3DAction { public:  //析構     ~CCShuffleTiles(void);     //初始化函數。 bool initWithSeed(int s, const ccGridSize& gridSize, float duration); //重新排列處理 void shuffle(int *pArray, unsigned int nLen); //取得 ccGridSize getDelta(const ccGridSize& pos); //     void placeTile(const ccGridSize& pos, Tile *t);  //重載基類的相應函數。     virtual void startWithTarget(CCNode *pTarget);     virtual void update(float time);     virtual CCObject* copyWithZone(CCZone* pZone);  public:     //創建一個重新排列格子的動畫:參一為，參二為格子大小，參三為動畫時長。     CC_DEPRECATED_ATTRIBUTE static CCShuffleTiles* actionWithSeed(int s, const ccGridSize& gridSize, float duration);     //上面的create實現。     static CCShuffleTiles* create(int s, const ccGridSize& gridSize, float duration); protected:  //     int             m_nSeed;     unsigned int m_nTilesCount;     int             *m_pTilesOrder;     Tile         *m_pTiles; };  //創建一個重新排列格子的動畫:參一為，參二為格子大小，參三為動畫時長。 CCShuffleTiles* CCShuffleTiles::actionWithSeed(int s, const ccGridSize& gridSize, float duration) {     return CCShuffleTiles::create(s, gridSize, duration);     } //上面的create實現。 CCShuffleTiles* CCShuffleTiles::create(int s, const ccGridSize& gridSize, float duration) {  //new ,初始化，autorelease,失敗處理一條龍！     CCShuffleTiles *pAction = new CCShuffleTiles();      if (pAction)     {         if (pAction->initWithSeed(s, gridSize, duration))         {             pAction->autorelease();         }         else         {             CC_SAFE_RELEASE_NULL(pAction);         }     }      return pAction;     } //初始化處理。 bool CCShuffleTiles::initWithSeed(int s, const ccGridSize& gridSize, float duration) {  //先調用基類的相應函數。     if (CCTiledGrid3DAction::initWithSize(gridSize, duration)) {  //將參數值保存到成員變數中。         m_nSeed = s;         m_pTilesOrder = NULL;         m_pTiles = NULL;          return true;     }      return false; } //產生一個當前類的實例拷貝。 CCObject* CCShuffleTiles::copyWithZone(CCZone *pZone) {     CCZone* pNewZone = NULL;     CCShuffleTiles* pCopy = NULL;     if(pZone && pZone->m_pCopyObject)     {         pCopy = (CCShuffleTiles*)(pZone->m_pCopyObject);     }     else     {         pCopy = new CCShuffleTiles();         pZone = pNewZone = new CCZone(pCopy);     }      CCTiledGrid3DAction::copyWithZone(pZone);      pCopy->initWithSeed(m_nSeed, m_sGridSize, m_fDuration);      CC_SAFE_DELETE(pNewZone);     return pCopy; } //析構。 CCShuffleTiles::~CCShuffleTiles(void) {  //釋放申請的內存。     CC_SAFE_DELETE_ARRAY(m_pTilesOrder);     CC_SAFE_DELETE_ARRAY(m_pTiles); } //重新隨機排列處理。 void CCShuffleTiles::shuffle(int *pArray, unsigned int nLen) {  //定義臨時變數，並循環進行隨機排列。     int i;     for( i = nLen - 1; i >= 0; i-- )     {         unsigned int j = rand() % (i+1);    //隨機交換         int v = pArray[i];         pArray[i] = pArray[j];         pArray[j] = v;     } } //取得 ccGridSize CCShuffleTiles::getDelta(const ccGridSize& pos) {     CCPoint    pos2;  //計算格子的位置索引      unsigned int idx = pos.x * m_sGridSize.y + pos.y;  //取出     pos2.x = (float)(m_pTilesOrder[idx] / (int)m_sGridSize.y);     pos2.y = (float)(m_pTilesOrder[idx] % (int)m_sGridSize.y);  //     return ccg((int)(pos2.x - pos.x), (int)(pos2.y - pos.y)); } //替換指定格子中的數據 void CCShuffleTiles::placeTile(const ccGridSize& pos, Tile *t) {  //取得對應格子大小的原始頂點數據     ccQuad3 coords = originalTile(pos);  //取得演員所用格子數據中格子的間隔。 CCPoint step = m_pTarget->getGrid()->getStep();  //計算出對應位置。     coords.bl.x += (int)(t->position.x * step.x);     coords.bl.y += (int)(t->position.y * step.y);      coords.br.x += (int)(t->position.x * step.x);     coords.br.y += (int)(t->position.y * step.y);      coords.tl.x += (int)(t->position.x * step.x);     coords.tl.y += (int)(t->position.y * step.y);      coords.tr.x += (int)(t->position.x * step.x);     coords.tr.y += (int)(t->position.y * step.y);  //設置對應格子的數據。     setTile(pos, coords); }  //設置演示當前動畫的演員。 void CCShuffleTiles::startWithTarget(CCNode *pTarget) {  //調用基類的相應函數。     CCTiledGrid3DAction::startWithTarget(pTarget);   //如果m_nSeed有效，則做為隨機種子。     if (m_nSeed != -1)     {         srand(m_nSeed);     }  //創建索引數組m_pTilesOrder     m_nTilesCount = m_sGridSize.x * m_sGridSize.y;     m_pTilesOrder = new int[m_nTilesCount];     int i, j;     unsigned int k;     //將順序索引填充到m_pTilesOrder     for (k = 0; k < m_nTilesCount; ++k)     {         m_pTilesOrder[k] = k;     }  //對順序索引數組進行重新隨機排序。     shuffle(m_pTilesOrder, m_nTilesCount);  //創建格子數據。     m_pTiles = (struct Tile *)new Tile[m_nTilesCount];     Tile *tileArray = (Tile*) m_pTiles;   //雙循環遍歷，通過結構指針設置相應格子的數據。     for (i = 0; i < m_sGridSize.x; ++i)     {         for (j = 0; j < m_sGridSize.y; ++j)         {             tileArray->position = ccp((float)i, (float)j);             tileArray->startPosition = ccp((float)i, (float)j);             tileArray->delta = getDelta(ccg(i, j));             ++tileArray;         }     } } //更新動畫。 void CCShuffleTiles::update(float time) {     int i, j;  //取得格子的數據指針。     Tile *tileArray = (Tile*)m_pTiles;  //雙循環遍歷。     for (i = 0; i < m_sGridSize.x; ++i)     {         for (j = 0; j < m_sGridSize.y; ++j)         {     //重新計算格子位置。             tileArray->position = ccpMult(ccp((float)tileArray->delta.x, (float)tileArray->delta.y), time);      //將指針數據填充到對應格子。             placeTile(ccg(i, j), tileArray);             ++tileArray;         }     } }  對應圖： 

//從右上角開始漸隱格子的動畫。 class CC_DLL CCFadeOutTRTiles : public CCTiledGrid3DAction { public:  //為了檢測是否滿足相應條件的函數。 virtual float testFunc(const ccGridSize& pos, float time); //開啟格子。 void turnOnTile(const ccGridSize& pos); //關閉格子。 void turnOffTile(const ccGridSize& pos); //跟據距離轉換格子。 virtual void transformTile(const ccGridSize& pos, float distance); //更新動畫。     virtual void update(float time);  public:     //靜態函數：創建一個從右上角漸隱格子的動畫。參一為格子大小，參二為。     CC_DEPRECATED_ATTRIBUTE static CCFadeOutTRTiles* actionWithSize(const ccGridSize& gridSize, float time);      //上面的create實現。     static CCFadeOutTRTiles* create(const ccGridSize& gridSize, float time); }; //靜態函數：創建一個從右上角漸隱格子的動畫。參一為格子大小，參二為。 CCFadeOutTRTiles* CCFadeOutTRTiles::actionWithSize(const ccGridSize& gridSize, float time) {     return CCFadeOutTRTiles::create( gridSize, time);     } //上面的create實現。 CCFadeOutTRTiles* CCFadeOutTRTiles::create(const ccGridSize& gridSize, float time) {  //new,初始化，autorelease，失敗處理一條龍！     CCFadeOutTRTiles *pAction = new CCFadeOutTRTiles();      if (pAction)     {         if (pAction->initWithSize(gridSize, time))         {             pAction->autorelease();         }         else         {             CC_SAFE_RELEASE_NULL(pAction);         }     }      return pAction;     } //為了檢測是否滿足相應條件的函數。 float CCFadeOutTRTiles::testFunc(const ccGridSize& pos, float time) {  //計算出格子的位置。 CCPoint n = ccpMult(ccp((float)m_sGridSize.x, (float)m_sGridSize.y), time); //為了後面powf中的除法避免除零而做的判斷。     if ((n.x + n.y) == 0.0f)     {         return 1.0f;     }  //計算出一個powf處理后的值。     return powf((pos.x + pos.y) / (n.x + n.y), 6); } //開啟格子。 void CCFadeOutTRTiles::turnOnTile(const ccGridSize& pos) {  //設置格子位置為原始數據。     setTile(pos, originalTile(pos)); }  //關閉格子。 void CCFadeOutTRTiles::turnOffTile(const ccGridSize& pos) {  //定義一個新的頂點數據，都清零後設置為對應格子的頂點數據。     ccQuad3 coords;     memset(&coords, 0, sizeof(ccQuad3));     setTile(pos, coords); } //跟據距離轉換格子。 void CCFadeOutTRTiles::transformTile(const ccGridSize& pos, float distance) {  //取得對應格子的頂點數據。 ccQuad3 coords = originalTile(pos); //取得每個像素所佔的圖像大小。     CCPoint step = m_pTarget->getGrid()->getStep();  //通過距離進行位置的重新計算。     coords.bl.x += (step.x / 2) * (1.0f - distance);     coords.bl.y += (step.y / 2) * (1.0f - distance);      coords.br.x -= (step.x / 2) * (1.0f - distance);     coords.br.y += (step.y / 2) * (1.0f - distance);      coords.tl.x += (step.x / 2) * (1.0f - distance);     coords.tl.y -= (step.y / 2) * (1.0f - distance);      coords.tr.x -= (step.x / 2) * (1.0f - distance);     coords.tr.y -= (step.y / 2) * (1.0f - distance);  //用新數據設置對應格子的頂點數據。     setTile(pos, coords); } //更新動畫。 void CCFadeOutTRTiles::update(float time) {     int i, j;  //雙循環遍歷。     for (i = 0; i < m_sGridSize.x; ++i)     {         for (j = 0; j < m_sGridSize.y; ++j)         {     //為了檢測是否滿足相應條件的函數，返回距離值。             float distance = testFunc(ccg(i, j), time);             if ( distance == 0 )             {      //如果距離為0，關閉格子。                 turnOffTile(ccg(i, j));             } else              if (distance < 1)             {       //如果距離在0~1間，進行格子的轉換處理。                 transformTile(ccg(i, j), distance);             }             else             {      //如果距離大於等於1，開啟格子。                 turnOnTile(ccg(i, j));             }         }     } } 對應圖： 

//從左下角漸隱格子的動畫。 class CC_DLL CCFadeOutBLTiles : public CCFadeOutTRTiles { public:  //檢測是否滿足相應條件的函數     virtual float testFunc(const ccGridSize& pos, float time);  public:     //靜態函數：創建一個從左下角漸隱格子的動畫。參一為格子大小，參二為。     CC_DEPRECATED_ATTRIBUTE static CCFadeOutBLTiles* actionWithSize(const ccGridSize& gridSize, float time);  //上面的create實現。     static CCFadeOutBLTiles* create(const ccGridSize& gridSize, float time); }; // //靜態函數：創建一個從左下角漸隱格子的動畫。參一為格子大小，參二為。  CCFadeOutBLTiles* CCFadeOutBLTiles::actionWithSize(const ccGridSize& gridSize, float time) {     return CCFadeOutBLTiles::create(gridSize, time); } //上面的create實現。 CCFadeOutBLTiles* CCFadeOutBLTiles::create(const ccGridSize& gridSize, float time) {  //new ,初始化,autorelease,失敗處理一條龍！     CCFadeOutBLTiles *pAction = new CCFadeOutBLTiles();      if (pAction)     {         if (pAction->initWithSize(gridSize, time))         {             pAction->autorelease();         }         else         {             CC_SAFE_RELEASE_NULL(pAction);         }     }      return pAction; } //檢測是否滿足相應條件的函數 float CCFadeOutBLTiles::testFunc(const ccGridSize& pos, float time) {  //計算出格子的位置。 CCPoint n = ccpMult(ccp((float)m_sGridSize.x, (float)m_sGridSize.y), (1.0f - time)); //為了後面powf中的除法避免除零而做的判斷。      if ((pos.x + pos.y) == 0)     {         return 1.0f;     }  //計算出一個powf處理后的值。      return powf((n.x + n.y) / (pos.x + pos.y), 6); } //向上部漸隱格子的動畫。 class CC_DLL CCFadeOutUpTiles : public CCFadeOutTRTiles { public:  //檢測是否滿足相應條件的函數 virtual float testFunc(const ccGridSize& pos, float time); //跟據距離轉換格子。     virtual void transformTile(const ccGridSize& pos, float distance);  public: //靜態函數：創建一個從上部漸隱格子的動畫。參一為格子大小，參二為動畫時長。     CC_DEPRECATED_ATTRIBUTE static CCFadeOutUpTiles* actionWithSize(const ccGridSize& gridSize, float time);     //上面的create實現。     static CCFadeOutUpTiles* create(const ccGridSize& gridSize, float time);  }; //靜態函數：創建一個從上部漸隱格子的動畫。參一為格子大小，參二為動畫時長。  CCFadeOutUpTiles* CCFadeOutUpTiles::actionWithSize(const ccGridSize& gridSize, float time) {     return CCFadeOutUpTiles::create(gridSize, time); } //上面的create實現。 CCFadeOutUpTiles* CCFadeOutUpTiles::create(const ccGridSize& gridSize, float time) {  //new ,初始化,autorelease,失敗處理一條龍！      CCFadeOutUpTiles *pAction = new CCFadeOutUpTiles();      if (pAction)     {         if (pAction->initWithSize(gridSize, time))         {             pAction->autorelease();         }         else         {             CC_SAFE_RELEASE_NULL(pAction);         }     }      return pAction; } //檢測是否滿足相應條件的函數 float CCFadeOutUpTiles::testFunc(const ccGridSize& pos, float time) {  //計算出格子的位置。 CCPoint n = ccpMult(ccp((float)m_sGridSize.x, (float)m_sGridSize.y), time); //為了後面powf中的除法避免除零而做的判斷。      if (n.y == 0.0f)     {         return 1.0f;     }  //計算出一個powf處理后的值。      return powf(pos.y / n.y, 6); } //跟據距離轉換格子。 void CCFadeOutUpTiles::transformTile(const ccGridSize& pos, float distance) {  //取得對應格子的頂點數據。 ccQuad3 coords = originalTile(pos); //取得一個格子所佔用的圖像大小。     CCPoint step = m_pTarget->getGrid()->getStep();  //通過距離進行位置的重新計算。  //讓格子的下部的Y值上移，上部的Y值下移，這樣格子就像被壓扁了一樣的效果。     coords.bl.y += (step.y / 2) * (1.0f - distance);     coords.br.y += (step.y / 2) * (1.0f - distance);     coords.tl.y -= (step.y / 2) * (1.0f - distance);     coords.tr.y -= (step.y / 2) * (1.0f - distance);  //設置格子的新位置。     setTile(pos, coords); } 對應圖: 

//從左下角漸隱格子的動畫。 class CC_DLL CCFadeOutBLTiles : public CCFadeOutTRTiles { public:  //檢測是否滿足相應條件的函數     virtual float testFunc(const ccGridSize& pos, float time);  public:     //靜態函數：創建一個從左下角漸隱格子的動畫。參一為格子大小，參二為。     CC_DEPRECATED_ATTRIBUTE static CCFadeOutBLTiles* actionWithSize(const ccGridSize& gridSize, float time);  //上面的create實現。     static CCFadeOutBLTiles* create(const ccGridSize& gridSize, float time); }; // //靜態函數：創建一個從左下角漸隱格子的動畫。參一為格子大小，參二為。  CCFadeOutBLTiles* CCFadeOutBLTiles::actionWithSize(const ccGridSize& gridSize, float time) {     return CCFadeOutBLTiles::create(gridSize, time); } //上面的create實現。 CCFadeOutBLTiles* CCFadeOutBLTiles::create(const ccGridSize& gridSize, float time) {  //new ,初始化,autorelease,失敗處理一條龍！     CCFadeOutBLTiles *pAction = new CCFadeOutBLTiles();      if (pAction)     {         if (pAction->initWithSize(gridSize, time))         {             pAction->autorelease();         }         else         {             CC_SAFE_RELEASE_NULL(pAction);         }     }      return pAction; } //檢測是否滿足相應條件的函數 float CCFadeOutBLTiles::testFunc(const ccGridSize& pos, float time) {  //計算出格子的位置。 CCPoint n = ccpMult(ccp((float)m_sGridSize.x, (float)m_sGridSize.y), (1.0f - time)); //為了後面powf中的除法避免除零而做的判斷。      if ((pos.x + pos.y) == 0)     {         return 1.0f;     }  //計算出一個powf處理后的值。      return powf((n.x + n.y) / (pos.x + pos.y), 6); } 

對應圖：

//向上部漸隱格子的動畫。 class CC_DLL CCFadeOutUpTiles : public CCFadeOutTRTiles { public:  //檢測是否滿足相應條件的函數 virtual float testFunc(const ccGridSize& pos, float time); //跟據距離轉換格子。     virtual void transformTile(const ccGridSize& pos, float distance);  public: //靜態函數：創建一個從上部漸隱格子的動畫。參一為格子大小，參二為動畫時長。     CC_DEPRECATED_ATTRIBUTE static CCFadeOutUpTiles* actionWithSize(const ccGridSize& gridSize, float time);     //上面的create實現。     static CCFadeOutUpTiles* create(const ccGridSize& gridSize, float time);  }; //靜態函數：創建一個從上部漸隱格子的動畫。參一為格子大小，參二為動畫時長。  CCFadeOutUpTiles* CCFadeOutUpTiles::actionWithSize(const ccGridSize& gridSize, float time) {     return CCFadeOutUpTiles::create(gridSize, time); } //上面的create實現。 CCFadeOutUpTiles* CCFadeOutUpTiles::create(const ccGridSize& gridSize, float time) {  //new ,初始化,autorelease,失敗處理一條龍！      CCFadeOutUpTiles *pAction = new CCFadeOutUpTiles();      if (pAction)     {         if (pAction->initWithSize(gridSize, time))         {             pAction->autorelease();         }         else         {             CC_SAFE_RELEASE_NULL(pAction);         }     }      return pAction; } //檢測是否滿足相應條件的函數 float CCFadeOutUpTiles::testFunc(const ccGridSize& pos, float time) {  //計算出格子的位置。 CCPoint n = ccpMult(ccp((float)m_sGridSize.x, (float)m_sGridSize.y), time); //為了後面powf中的除法避免除零而做的判斷。      if (n.y == 0.0f)     {         return 1.0f;     }  //計算出一個powf處理后的值。      return powf(pos.y / n.y, 6); } //跟據距離轉換格子。 void CCFadeOutUpTiles::transformTile(const ccGridSize& pos, float distance) {  //取得對應格子的頂點數據。 ccQuad3 coords = originalTile(pos); //取得一個格子所佔用的圖像大小。     CCPoint step = m_pTarget->getGrid()->getStep();  //通過距離進行位置的重新計算。  //讓格子的下部的Y值上移，上部的Y值下移，這樣格子就像被壓扁了一樣的效果。     coords.bl.y += (step.y / 2) * (1.0f - distance);     coords.br.y += (step.y / 2) * (1.0f - distance);     coords.tl.y -= (step.y / 2) * (1.0f - distance);     coords.tr.y -= (step.y / 2) * (1.0f - distance);  //設置格子的新位置。     setTile(pos, coords); } 對應圖: 

//向下部漸隱格子的動畫。 class CC_DLL CCFadeOutDownTiles : public CCFadeOutUpTiles { public:  //檢測是否滿足相應條件的函數      virtual float testFunc(const ccGridSize& pos, float time);  public:  //靜態函數：創建一個從下部漸隱格子的動畫。參一為格子大小，參二為動畫時長。      CC_DEPRECATED_ATTRIBUTE static CCFadeOutDownTiles* actionWithSize(const ccGridSize& gridSize, float time);      //上面的create實現。     static CCFadeOutDownTiles* create(const ccGridSize& gridSize, float time); }; //靜態函數：創建一個從下部漸隱格子的動畫。參一為格子大小，參二為動畫時長。  CCFadeOutDownTiles* CCFadeOutDownTiles::actionWithSize(const ccGridSize& gridSize, float time) {     return CCFadeOutDownTiles::create(gridSize, time); } //上面的create實現。 CCFadeOutDownTiles* CCFadeOutDownTiles::create(const ccGridSize& gridSize, float time) {  //new ,初始化,autorelease,失敗處理一條龍！      CCFadeOutDownTiles *pAction = new CCFadeOutDownTiles();      if (pAction)     {         if (pAction->initWithSize(gridSize, time))         {             pAction->autorelease();         }         else         {             CC_SAFE_RELEASE_NULL(pAction);         }     }      return pAction; }  //檢測是否滿足相應條件的函數 float CCFadeOutDownTiles::testFunc(const ccGridSize& pos, float time) {  //計算出格子的位置。 CCPoint n = ccpMult(ccp((float)m_sGridSize.x, (float)m_sGridSize.y), (1.0f - time)); //為了後面powf中的除法避免除零而做的判斷。     if (pos.y == 0)     {         return 1.0f;     }  //計算出一個powf處理后的值。     return powf(n.y / pos.y, 6); } 對應圖: 

//格子的消失動畫 class CC_DLL CCTurnOffTiles : public CCTiledGrid3DAction { public:  //析構     ~CCTurnOffTiles(void);     //初始化 bool initWithSeed(int s, const ccGridSize& gridSize, float duration); //重新排列格子。 void shuffle(int *pArray, unsigned int nLen); //開啟格子。 void turnOnTile(const ccGridSize& pos); //關閉格子。     void turnOffTile(const ccGridSize& pos);  //重載基類的相應函數。     virtual CCObject* copyWithZone(CCZone* pZone);     virtual void startWithTarget(CCNode *pTarget);     virtual void update(float time);  public:     //創建一個     CC_DEPRECATED_ATTRIBUTE static CCTurnOffTiles* actionWithSize(const ccGridSize& size, float d);     //      CC_DEPRECATED_ATTRIBUTE static CCTurnOffTiles* actionWithSeed(int s, const ccGridSize& gridSize, float duration);      //上面的create實現。     static CCTurnOffTiles* create(const ccGridSize& size, float d);     //上面的create實現。     static CCTurnOffTiles* create(int s, const ccGridSize& gridSize, float duration);  protected:     int                m_nSeed;     unsigned int    m_nTilesCount;     int                *m_pTilesOrder; }; //創建一個 CCTurnOffTiles* CCTurnOffTiles::actionWithSize(const ccGridSize& size, float d) {     return CCTurnOffTiles::create( size, d); } //上面的create實現。 CCTurnOffTiles* CCTurnOffTiles::create(const ccGridSize& size, float d) {  //new ,初始化,autorelease,失敗處理一條龍！      CCTurnOffTiles* pAction = new CCTurnOffTiles();     if (pAction->initWithSize(size, d))     {         pAction->autorelease();     }     else     {         CC_SAFE_RELEASE_NULL(pAction);     }     return pAction; }  //創建一個 CCTurnOffTiles* CCTurnOffTiles::actionWithSeed(int s, const ccGridSize& gridSize, float duration) {     return CCTurnOffTiles::create(s, gridSize, duration); } //上面的create實現。  CCTurnOffTiles* CCTurnOffTiles::create(int s, const ccGridSize& gridSize, float duration) {  //new ,初始化,autorelease,失敗處理一條龍！     CCTurnOffTiles *pAction = new CCTurnOffTiles();      if (pAction)     {         if (pAction->initWithSeed(s, gridSize, duration))         {             pAction->autorelease();         }         else         {             CC_SAFE_RELEASE_NULL(pAction);         }     }      return pAction; } //初始化。 bool CCTurnOffTiles::initWithSeed(int s, const ccGridSize& gridSize, float duration) {  //調用基類的相應函數。     if (CCTiledGrid3DAction::initWithSize(gridSize, duration)) {  //保存參數到成員變數。         m_nSeed = s;         m_pTilesOrder = NULL;          return true;     }      return false; } //產生一個當前類的實例拷貝。 CCObject* CCTurnOffTiles::copyWithZone(CCZone *pZone) {     CCZone* pNewZone = NULL;     CCTurnOffTiles* pCopy = NULL;     if(pZone && pZone->m_pCopyObject)      {         pCopy = (CCTurnOffTiles*)(pZone->m_pCopyObject);     }     else     {         pCopy = new CCTurnOffTiles();         pZone = pNewZone = new CCZone(pCopy);     }      CCTiledGrid3DAction::copyWithZone(pZone);      pCopy->initWithSeed(m_nSeed, m_sGridSize, m_fDuration);      CC_SAFE_DELETE(pNewZone);     return pCopy; } //析構。 CCTurnOffTiles::~CCTurnOffTiles(void) {     CC_SAFE_DELETE_ARRAY(m_pTilesOrder); } //重新隨機排列。 void CCTurnOffTiles::shuffle(int *pArray, unsigned int nLen) {  //定義臨時變數，並循環進行隨機排列。     int i;     for (i = nLen - 1; i >= 0; i--) {  //隨機交換。         unsigned int j = rand() % (i+1);         int v = pArray[i];         pArray[i] = pArray[j];         pArray[j] = v;     } } //開啟格子 void CCTurnOffTiles::turnOnTile(const ccGridSize& pos) {  //設置格子的數據為原始數據。     setTile(pos, originalTile(pos)); } //關閉格子。 void CCTurnOffTiles::turnOffTile(const ccGridSize& pos) {  //定義一個新的頂點數據，都清零後設置為對應格子的頂點數據。      ccQuad3 coords;     memset(&coords, 0, sizeof(ccQuad3));     setTile(pos, coords); }  //設置演示當前動畫的演員。 void CCTurnOffTiles::startWithTarget(CCNode *pTarget) {  //     unsigned int i;  //調用基類的相應函數。     CCTiledGrid3DAction::startWithTarget(pTarget);  //初始化隨機種子。     if (m_nSeed != -1)     {         srand(m_nSeed);     }  //取得格子數量 m_nTilesCount = m_sGridSize.x * m_sGridSize.y; //創建相應大小的排序索引數組。     m_pTilesOrder = new int[m_nTilesCount];  //填充數據。     for (i = 0; i < m_nTilesCount; ++i)     {         m_pTilesOrder[i] = i;     }  //隨機排列格子。     shuffle(m_pTilesOrder, m_nTilesCount); } //更新動畫。 void CCTurnOffTiles::update(float time) {     unsigned int i, l, t;  //通過進度值計算要消失的格子的數量。     l = (int)(time * (float)m_nTilesCount);  //遍歷每個格子     for( i = 0; i < m_nTilesCount; i++ ) {  //取出順序索引，並計算出相應的格子位置。         t = m_pTilesOrder[i];         ccGridSize tilePos = ccg( t / m_sGridSize.y, t % m_sGridSize.y );   //如果當前索引i小於要消失的可子的數量值，關閉格子。         if ( i < l )         {             turnOffTile(tilePos);         }         else         { //開啟格子。             turnOnTile(tilePos);         }     } } 對應圖: 

//波浪狀的格子動畫。 class CC_DLL CCWavesTiles3D : public CCTiledGrid3DAction { public:     //取得和設置振幅。     inline float getAmplitude(void) { return m_fAmplitude; }     inline void setAmplitude(float fAmplitude) { m_fAmplitude = fAmplitude; }      //取得和設置頻率。     inline float getAmplitudeRate(void) { return m_fAmplitudeRate; }     inline void setAmplitudeRate(float fAmplitudeRate) { m_fAmplitudeRate = fAmplitudeRate; }      //初始化波浪狀網格的動畫     bool initWithWaves(int wav, float amp, const ccGridSize& gridSize, float duration);  //創建一個當前類的實例拷貝。 virtual CCObject* copyWithZone(CCZone* pZone); //更新動畫。     virtual void update(float time);  public:     //靜態函數：創建一個當前類的實例對象指針，參數一為     CC_DEPRECATED_ATTRIBUTE static CCWavesTiles3D* actionWithWaves(int wav, float amp, const ccGridSize& gridSize, float duration);     //上面的create實現。     static CCWavesTiles3D* create(int wav, float amp, const ccGridSize& gridSize, float duration); protected: int m_nWaves; //振幅。 float m_fAmplitude; //頻率。     float m_fAmplitudeRate; }; //靜態函數：創建一個當前類的實例對象指針，參數一為 CCWavesTiles3D* CCWavesTiles3D::actionWithWaves(int wav, float amp, const ccGridSize& gridSize, float duration) {     return CCWavesTiles3D::create(wav, amp, gridSize, duration); } //上面的create實現。 CCWavesTiles3D* CCWavesTiles3D::create(int wav, float amp, const ccGridSize& gridSize, float duration) {  //new ,初始化,autorelease,失敗處理一條龍！     CCWavesTiles3D *pAction = new CCWavesTiles3D();      if (pAction)     {         if (pAction->initWithWaves(wav, amp, gridSize, duration))         {             pAction->autorelease();         }         else         {             CC_SAFE_RELEASE_NULL(pAction);         }     }      return pAction; } //初始化。 bool CCWavesTiles3D::initWithWaves(int wav, float amp, const ccGridSize& gridSize, float duration) {  //調用基類的初始化函數。     if (CCTiledGrid3DAction::initWithSize(gridSize, duration)) {  //將相應參數保存到成員變數中。         m_nWaves = wav;         m_fAmplitude = amp;         m_fAmplitudeRate = 1.0f;          return true;     }      return false; } //產生一個當前類的實例拷貝。 CCObject* CCWavesTiles3D::copyWithZone(CCZone *pZone) {     CCZone* pNewZone = NULL;     CCWavesTiles3D* pCopy = NULL;     if(pZone && pZone->m_pCopyObject)     {         pCopy = (CCWavesTiles3D*)(pZone->m_pCopyObject);     }     else     {         pCopy = new CCWavesTiles3D();         pZone = pNewZone = new CCZone(pCopy);     }      CCTiledGrid3DAction::copyWithZone(pZone);      pCopy->initWithWaves(m_nWaves, m_fAmplitude, m_sGridSize, m_fDuration);      CC_SAFE_DELETE(pNewZone);     return pCopy; } //更新動畫。 void CCWavesTiles3D::update(float time) {     int i, j;  //雙循環遍歷。     for( i = 0; i < m_sGridSize.x; i++ )     {         for( j = 0; j < m_sGridSize.y; j++ )         {    //取得對應格子的頂點數據。             ccQuad3 coords = originalTile(ccg(i, j));      //重新設置頂點數據位置。             coords.bl.z = (sinf(time * (float)M_PI  *m_nWaves * 2 +                  (coords.bl.y+coords.bl.x) * .01f) * m_fAmplitude * m_fAmplitudeRate );             coords.br.z    = coords.bl.z;             coords.tl.z = coords.bl.z;             coords.tr.z = coords.bl.z;      //將新的位置數據設置給相應格子。             setTile(ccg(i, j), coords);         }     } } 對應圖: 

//跳動的格子動畫。 class CC_DLL CCJumpTiles3D : public CCTiledGrid3DAction { public:     //取得跳動的範圍。     inline float getAmplitude(void) { return m_fAmplitude; }     inline void setAmplitude(float fAmplitude) { m_fAmplitude = fAmplitude; }  //取和和設置頻率。     inline float getAmplitudeRate(void) { return m_fAmplitudeRate; }     inline void setAmplitudeRate(float fAmplitudeRate) { m_fAmplitudeRate = fAmplitudeRate; }      //初始化。 bool initWithJumps(int j, float amp, const ccGridSize& gridSize, float duration); //創建一個當前類的實例拷貝。 virtual CCObject* copyWithZone(CCZone* pZone); //更新動畫。     virtual void update(float time);  public:     //靜態函數：創建一個當前類的動畫實例。     CC_DEPRECATED_ATTRIBUTE static CCJumpTiles3D* actionWithJumps(int j, float amp, const ccGridSize& gridSize, float duration);     //上面的create實現。     static CCJumpTiles3D* create(int j, float amp, const ccGridSize& gridSize, float duration); protected:  //跳躍的次數。 int m_nJumps; //振幅。 float m_fAmplitude; //頻率。     float m_fAmplitudeRate; }; //靜態函數：創建一個當前類的動畫實例。 CCJumpTiles3D* CCJumpTiles3D::actionWithJumps(int j, float amp, const ccGridSize& gridSize, float duration) {     return CCJumpTiles3D::create(j, amp, gridSize, duration); } //上面的create實現。 CCJumpTiles3D* CCJumpTiles3D::create(int j, float amp, const ccGridSize& gridSize, float duration) {  //new ,初始化,autorelease,失敗處理一條龍！      CCJumpTiles3D *pAction = new CCJumpTiles3D();      if (pAction)     {         if (pAction->initWithJumps(j, amp, gridSize, duration))         {             pAction->autorelease();         }         else         {             CC_SAFE_RELEASE_NULL(pAction);         }     }      return pAction; } //初始化。 bool CCJumpTiles3D::initWithJumps(int j, float amp, const ccGridSize& gridSize, float duration) {  //調用基類的相應函數。     if (CCTiledGrid3DAction::initWithSize(gridSize, duration)) {  //保存參數到成員變數。         m_nJumps = j;         m_fAmplitude = amp;         m_fAmplitudeRate = 1.0f;          return true;     }      return false; } //產生一個當前類的實例拷貝。 CCObject* CCJumpTiles3D::copyWithZone(CCZone *pZone) {     CCZone* pNewZone = NULL;     CCJumpTiles3D* pCopy = NULL;     if(pZone && pZone->m_pCopyObject)      {         pCopy = (CCJumpTiles3D*)(pZone->m_pCopyObject);     }     else     {         pCopy = new CCJumpTiles3D();         pZone = pNewZone = new CCZone(pCopy);     }      CCTiledGrid3DAction::copyWithZone(pZone);     pCopy->initWithJumps(m_nJumps, m_fAmplitude, m_sGridSize, m_fDuration);      CC_SAFE_DELETE(pNewZone);     return pCopy; } //更新動畫。 void CCJumpTiles3D::update(float time) {     int i, j;   //定義兩個臨時變數，分別設置為不同的sin曲線變化值。     float sinz =  (sinf((float)M_PI * time * m_nJumps * 2) * m_fAmplitude * m_fAmplitudeRate );     float sinz2 = (sinf((float)M_PI * (time * m_nJumps * 2 + 1)) * m_fAmplitude * m_fAmplitudeRate );   //雙循環遍歷。     for( i = 0; i < m_sGridSize.x; i++ )     {         for( j = 0; j < m_sGridSize.y; j++ )         {    //取得對應格子的頂點數據。             ccQuad3 coords = originalTile(ccg(i, j));     //(i+j)的值對2取模，可以實現上，下，左，右相鄰的Z值加成不同。             if ( ((i+j) % 2) == 0 )             {                 coords.bl.z += sinz;                 coords.br.z += sinz;                 coords.tl.z += sinz;                 coords.tr.z += sinz;             }             else             {                 coords.bl.z += sinz2;                 coords.br.z += sinz2;                 coords.tl.z += sinz2;                 coords.tr.z += sinz2;             }      //將新的頂點數據設置給相應格子。             setTile(ccg(i, j), coords);         }     } } 對應圖: 

//橫向分割的格子動畫。 class CC_DLL CCSplitRows : public CCTiledGrid3DAction { public :     //初始化。     bool initWithRows(int nRows, float duration);  //重載基類的相應函數。     virtual CCObject* copyWithZone(CCZone* pZone);     virtual void update(float time);     virtual void startWithTarget(CCNode *pTarget);  public:     //靜態函數：創建一個橫向分割的格子動畫。參一為橫向分的份數，參二為動畫時長。內部調用create實現。     CC_DEPRECATED_ATTRIBUTE static CCSplitRows* actionWithRows(int nRows, float duration);     //上面的create實現。     static CCSplitRows* create(int nRows, float duration); protected:  //切分的行數。 int m_nRows; //屏幕大小。     CCSize m_winSize; }; //靜態函數：創建一個橫向分割的格子動畫。參一為橫向分的份數，參二為動畫時長。內部調用create實現。 CCSplitRows* CCSplitRows::actionWithRows(int nRows, float duration) {     return CCSplitRows::create(nRows, duration); } //上面的create實現。 CCSplitRows* CCSplitRows::create(int nRows, float duration) {  //new ,初始化,autorelease,失敗處理一條龍！      CCSplitRows *pAction = new CCSplitRows();      if (pAction)     {         if (pAction->initWithRows(nRows, duration))         {             pAction->autorelease();         }         else         {             CC_SAFE_RELEASE_NULL(pAction);         }     }      return pAction; } //初始化。 bool CCSplitRows::initWithRows(int nRows, float duration) {  //保存切分的份數。     m_nRows = nRows; //將切分的份數做為參數放在格子大小的Y值中初始化3D格子動畫。     return CCTiledGrid3DAction::initWithSize(ccg(1, nRows), duration); } //產生一個當前類的實例拷貝。 CCObject* CCSplitRows::copyWithZone(CCZone *pZone) {     CCZone* pNewZone = NULL;     CCSplitRows* pCopy = NULL;     if(pZone && pZone->m_pCopyObject)      {         pCopy = (CCSplitRows*)(pZone->m_pCopyObject);     }     else     {         pCopy = new CCSplitRows();         pZone = pNewZone = new CCZone(pCopy);     }      CCTiledGrid3DAction::copyWithZone(pZone);      pCopy->initWithRows(m_nRows, m_fDuration);      CC_SAFE_DELETE(pNewZone);     return pCopy; } //以置演示當前動畫的演員。 void CCSplitRows::startWithTarget(CCNode *pTarget) {     CCTiledGrid3DAction::startWithTarget(pTarget);     m_winSize = CCDirector::sharedDirector()->getWinSizeInPixels(); } //更新動畫。 void CCSplitRows::update(float time) {     int j;  //遍歷切分的格子。在初始化時說過格子大小的Y值中保存了切分的份數。     for (j = 0; j < m_sGridSize.y; ++j) {  //通過格子的的索引取得原始的頂點位置。         ccQuad3 coords = originalTile(ccg(0, j)); //創建臨時變數保存方向。         float    direction = 1;   //對i取2的模，可使相鄰的切分塊方向不同。         if ( (j % 2 ) == 0 )         {             direction = -1;         }   //根據方向來對頂點X值進行偏移。         coords.bl.x += direction * m_winSize.width * time;         coords.br.x += direction * m_winSize.width * time;         coords.tl.x += direction * m_winSize.width * time;         coords.tr.x += direction * m_winSize.width * time;   //設置格子的頂點數據，這樣就可以實現每個切分格子的運動了。         setTile(ccg(0, j), coords);     } } 對應圖: 

//縱向切分的格子運動動畫。 class CC_DLL CCSplitCols : public CCTiledGrid3DAction { public:     //初始化。     bool initWithCols(int nCols, float duration);  //重載基類的相應函數。     virtual CCObject* copyWithZone(CCZone* pZone);     virtual void update(float time);     virtual void startWithTarget(CCNode *pTarget);  public:     //靜態函數：創建一個縱向分割的格子動畫。參一為縱向切分的份數，參二為動畫時長。內部調用create實現。     CC_DEPRECATED_ATTRIBUTE static CCSplitCols* actionWithCols(int nCols, float duration);     //上面的create實現。     static CCSplitCols* create(int nCols, float duration); protected:  //切分的列數。 int m_nCols; //屏幕大小。     CCSize m_winSize; }; //靜態函數：創建一個縱向分割的格子動畫。參一為縱向切分的份數，參二為動畫時長。內部調用create實現。  CCSplitCols* CCSplitCols::actionWithCols(int nCols, float duration) {     return CCSplitCols::create(nCols, duration); } //上面的create實現。 CCSplitCols* CCSplitCols::create(int nCols, float duration) {  //new ,初始化,autorelease,失敗處理一條龍！     CCSplitCols *pAction = new CCSplitCols();      if (pAction)     {         if (pAction->initWithCols(nCols, duration))         {             pAction->autorelease();         }         else         {             CC_SAFE_RELEASE_NULL(pAction);         }     }      return pAction; } //初始化。 bool CCSplitCols::initWithCols(int nCols, float duration) {  //保存切分的份數。 m_nCols = nCols; //將切分的份數做為參數放在格子大小的X值中初始化3D格子動畫。     return CCTiledGrid3DAction::initWithSize(ccg(nCols, 1), duration); } //產生一個當前類的實例拷貝。 CCObject* CCSplitCols::copyWithZone(CCZone *pZone) {     CCZone* pNewZone = NULL;     CCSplitCols* pCopy = NULL;     if(pZone && pZone->m_pCopyObject)      {         pCopy = (CCSplitCols*)(pZone->m_pCopyObject);     }     else     {         pCopy = new CCSplitCols();         pZone = pNewZone = new CCZone(pCopy);     }      CCTiledGrid3DAction::copyWithZone(pZone);     pCopy->initWithCols(m_nCols, m_fDuration);      CC_SAFE_DELETE(pNewZone);     return pCopy; } //設置演示當前動畫的演員。 void CCSplitCols::startWithTarget(CCNode *pTarget) {  //調用基類的相應函數。 CCTiledGrid3DAction::startWithTarget(pTarget); //取得屏幕大小     m_winSize = CCDirector::sharedDirector()->getWinSizeInPixels(); } //更新動畫。 void CCSplitCols::update(float time) {     int i;  //遍歷切分的格子。在初始化時說過格子大小的X值中保存了切分的份數。     for (i = 0; i < m_sGridSize.x; ++i) {  //通過格子的的索引取得原始的頂點位置。         ccQuad3 coords = originalTile(ccg(i, 0));   //創建臨時變數保存方向。         float    direction = 1;   //對i取2的模，可使相鄰的切分塊方向不同。         if ( (i % 2 ) == 0 )         {             direction = -1;         }   //根據方向來對頂點Y值進行偏移。         coords.bl.y += direction * m_winSize.height * time;         coords.br.y += direction * m_winSize.height * time;         coords.tl.y += direction * m_winSize.height * time;         coords.tr.y += direction * m_winSize.height * time;   //設置格子的頂點數據，這樣就可以實現每個切分格子的運動了。         setTile(ccg(i, 0), coords);     } }  對應圖: 

最後我們來看一下EffectsTest的場景演示方面的代碼：

EffectsTest.h:

//由TestScene派生出一個場景。 class EffectTestScene : public TestScene { public:     //運行這個場景。     virtual void runThisTest(); }; //由CCLayerColor派生出一個TextLayer，用於演示各動畫效果。 class TextLayer : public CCLayerColor { protected:     //UxString    m_strTitle;  public:     TextLayer(void);     ~TextLayer(void);      void checkAnim(float dt);      virtual void onEnter();      void restartCallback(CCObject* pSender);     void nextCallback(CCObject* pSender);     void backCallback(CCObject* pSender);      void newScene();      static TextLayer* create(); };  

對應CPP:

// enum {     kTagTextLayer = 1,     kTagBackground = 1,     kTagLabel = 2, }; //動畫的索引 static int actionIdx=0;  //效果標題列表。 static std::string effectsList[] = {     "Shaky3D",     "Waves3D",     "FlipX3D",     "FlipY3D",     "Lens3D",     "Ripple3D",     "Liquid",     "Waves",     "Twirl",     "ShakyTiles3D",     "ShatteredTiles3D",     "ShuffleTiles",     "FadeOutTRTiles",     "FadeOutBLTiles",     "FadeOutUpTiles",     "FadeOutDownTiles",     "TurnOffTiles",     "WavesTiles3D",     "JumpTiles3D",     "SplitRows",     "SplitCols",     "PageTurn3D", };   //由CCShaky3D派生出一個動畫演示。 class Shaky3DDemo : public CCShaky3D  { public:     //重載其創建函數。     static CCActionInterval* create(float t)     {    //調用基類相應函數創建一個具體的動畫演示。         return CCShaky3D::create(5, false, ccg(15,10), t);     } }; //由CCWaves3D派生出一個動畫演示。 class Waves3DDemo : public CCWaves3D  { public:     //重載其創建函數。     static CCActionInterval* create(float t)     {         //調用基類相應函數創建一個具體的動畫演示。         return CCWaves3D::create(5, 40, ccg(15,10), t);     } }; //由CCFlipX3D派生出一個動畫演示。 class FlipX3DDemo : public CCFlipX3D  { public:     //重載其創建函數。     static CCActionInterval* create(float t)     {         CCFlipX3D* flipx  = CCFlipX3D::create(t);         CCActionInterval* flipx_back = flipx->reverse();         CCDelayTime* delay = CCDelayTime::create(2);         //調用基類相應函數創建一個具體的動畫演示。         return (CCActionInterval*)(CCSequence::create(flipx, delay, flipx_back, NULL));     } }; //由CCFlipY3D派生出一個動畫演示。 class FlipY3DDemo : public CCFlipY3D  { public:     //重載其創建函數。     static CCActionInterval* create(float t)     {         CCFlipY3D* flipy  = CCFlipY3D::create(t);         CCActionInterval* flipy_back = flipy->reverse();         CCDelayTime* delay = CCDelayTime::create(2);         //調用基類相應函數創建一個具體的動畫演示。         return (CCActionInterval*)(CCSequence::create(flipy, delay, flipy_back, NULL));     } }; //由CCLens3D派生出一個動畫演示。 class Lens3DDemo : public CCLens3D  { public:     //重載其創建函數。     static CCActionInterval* create(float t)     {         CCSize size = CCDirector::sharedDirector()->getWinSize();         //調用基類相應函數創建一個具體的動畫演示。         return CCLens3D::create(CCPointMake(size.width/2,size.height/2), 240, ccg(15,10), t);      } };  //由CCRipple3D派生出一個動畫演示。 class Ripple3DDemo : public CCRipple3D  { public:     //重載其創建函數。     static CCActionInterval* create(float t)     {         CCSize size = CCDirector::sharedDirector()->getWinSize();         //調用基類相應函數創建一個具體的動畫演示。         return CCRipple3D::create(CCPointMake(size.width/2,size.height/2), 240, 4, 160, ccg(32,24), t);     } };  //由CCLiquid派生出一個動畫演示。 class LiquidDemo : public CCLiquid { public:      //重載其創建函數。     static CCActionInterval* create(float t)     {         //調用基類相應函數創建一個具體的動畫演示。         return CCLiquid::create(4, 20, ccg(16,12), t);      } };  //由CCWaves派生出一個動畫演示。 class WavesDemo : public CCWaves  { public:     //重載其創建函數。     static CCActionInterval* create(float t)     {//調用基類相應函數創建一個具體的動畫演示。         return CCWaves::create(4, 20, true, true, ccg(16,12), t);       } };  //由CCTwirl派生出一個動畫演示。 class TwirlDemo : public CCTwirl  { public:     //重載其創建函數。     static CCActionInterval* create(float t)     {//調用基類相應函數創建一個具體的動畫演示。         CCSize size = CCDirector::sharedDirector()->getWinSize();         return CCTwirl::create(CCPointMake(size.width/2, size.height/2), 1, 2.5f, ccg(12,8), t);      } };  //由CCShakyTiles3D派生出一個動畫演示。 class ShakyTiles3DDemo : public CCShakyTiles3D { public:     //重載其創建函數。     static CCActionInterval* create(float t)     {//調用基類相應函數創建一個具體的動畫演示。         return CCShakyTiles3D::create(5, false, ccg(16,12), t) ;     }  };   //由CCShatteredTiles3D派生出一個動畫演示。 class ShatteredTiles3DDemo : public CCShatteredTiles3D { public:     //重載其創建函數。     static CCActionInterval* create(float t)     {//調用基類相應函數創建一個具體的動畫演示。         return CCShatteredTiles3D::create(5, false, ccg(16,12), t);      } };  //由CCShuffleTiles派生出一個動畫演示。 class ShuffleTilesDemo : public CCShuffleTiles { public:     //重載其創建函數。     static CCActionInterval* create(float t)     {         CCShuffleTiles* shuffle = CCShuffleTiles::create(25, ccg(16,12), t);         CCActionInterval* shuffle_back = shuffle->reverse();         CCDelayTime* delay = CCDelayTime::create(2); //調用基類相應函數創建一個具體的動畫演示。         return (CCActionInterval*)(CCSequence::create(shuffle, delay, shuffle_back, NULL));     } };  //由CCFadeOutTRTiles派生出一個動畫演示。 class FadeOutTRTilesDemo : public CCFadeOutTRTiles { public:     //重載其創建函數。     static CCActionInterval* create(float t)     {         CCFadeOutTRTiles* fadeout = CCFadeOutTRTiles::create(ccg(16,12), t);         CCActionInterval* back = fadeout->reverse();         CCDelayTime* delay = CCDelayTime::create(0.5f);         //調用基類相應函數創建一個具體的動畫演示。         return (CCActionInterval*)(CCSequence::create(fadeout, delay, back, NULL));     } };  //由CCFadeOutBLTiles派生出一個動畫演示。 class FadeOutBLTilesDemo : public CCFadeOutBLTiles { public:     //重載其創建函數。     static CCActionInterval* create(float t)     {         CCFadeOutBLTiles* fadeout = CCFadeOutBLTiles::create(ccg(16,12), t);         CCActionInterval* back = fadeout->reverse();         CCDelayTime* delay = CCDelayTime::create(0.5f);          //調用基類相應函數創建一個具體的動畫演示。         return (CCActionInterval*)(CCSequence::create(fadeout, delay, back, NULL));     } };  //由CCFadeOutUpTiles派生出一個動畫演示。 class FadeOutUpTilesDemo : public CCFadeOutUpTiles { public:     //重載其創建函數。     static CCActionInterval* create(float t)     {         CCFadeOutUpTiles* fadeout = CCFadeOutUpTiles::create(ccg(16,12), t);         CCActionInterval* back = fadeout->reverse();         CCDelayTime* delay = CCDelayTime::create(0.5f);         //調用基類相應函數創建一個具體的動畫演示。         return (CCActionInterval*)(CCSequence::create(fadeout, delay, back, NULL));     } };  //由CCFadeOutDownTiles派生出一個動畫演示。 class FadeOutDownTilesDemo : public CCFadeOutDownTiles { public:     //重載其創建函數。     static CCActionInterval* create(float t)     {         CCFadeOutDownTiles* fadeout = CCFadeOutDownTiles::create(ccg(16,12), t);         CCActionInterval* back = fadeout->reverse();         CCDelayTime* delay = CCDelayTime::create(0.5f);         //調用基類相應函數創建一個具體的動畫演示。         return (CCActionInterval*)(CCSequence::create(fadeout, delay, back, NULL));     } };  //由CCTurnOffTiles派生出一個動畫演示。 class TurnOffTilesDemo : public CCTurnOffTiles { public:     //重載其創建函數。     static CCActionInterval* create(float t)     {         CCTurnOffTiles* fadeout = CCTurnOffTiles::create(25, ccg(48,32) , t);         CCActionInterval* back = fadeout->reverse();         CCDelayTime* delay = CCDelayTime::create(0.5f);        //調用基類相應函數創建一個具體的動畫演示。         return (CCActionInterval*)(CCSequence::create(fadeout, delay, back, NULL));     } };  //由CCWavesTiles3D派生出一個動畫演示。 class WavesTiles3DDemo : public CCWavesTiles3D { public:     //重載其創建函數。     static CCActionInterval* create(float t)     {//調用基類相應函數創建一個具體的動畫演示。         return CCWavesTiles3D::create(4, 120, ccg(15,10), t);      } };  //由CCJumpTiles3D派生出一個動畫演示。 class JumpTiles3DDemo : public CCJumpTiles3D { public:     //重載其創建函數。     static CCActionInterval* create(float t)     {         CCSize size = CCDirector::sharedDirector()->getWinSize();         //調用基類相應函數創建一個具體的動畫演示。         return CCJumpTiles3D::create(2, 30, ccg(15,10), t);      } };  //由CCSplitRows派生出一個動畫演示。 class SplitRowsDemo : public CCSplitRows { public:     //重載其創建函數。     static CCActionInterval* create(float t)     {         //調用基類相應函數創建一個具體的動畫演示。         return CCSplitRows::create(9, t);      } };  //由CCSplitCols派生出一個動畫演示。 class SplitColsDemo : public CCSplitCols { public:     //重載其創建函數。     static CCActionInterval* create(float t)     {         //調用基類相應函數創建一個具體的動畫演示。         return CCSplitCols::create(9, t);      } };  //由CCPageTurn3D派生出一個動畫演示。 class PageTurn3DDemo : public CCPageTurn3D { public:     //重載其創建函數。     static CCActionInterval* create(float t)     {         //調用基類相應函數創建一個具體的動畫演示。         CCDirector::sharedDirector()->setDepthTest(true);         return CCPageTurn3D::create(ccg(15,10), t);      } };  #define MAX_LAYER    22  //創建相應的效果。 CCActionInterval* createEffect(int nIndex, float t) {     //設置     CCDirector::sharedDirector()->setDepthTest(false);     //根據索引來創建相應的動畫實例。     switch(nIndex)     {         case 0: return Shaky3DDemo::create(t);         case 1: return Waves3DDemo::create(t);         case 2: return FlipX3DDemo::create(t);         case 3: return FlipY3DDemo::create(t);         case 4: return Lens3DDemo::create(t);         case 5: return Ripple3DDemo::create(t);         case 6: return LiquidDemo::create(t);         case 7: return WavesDemo::create(t);         case 8: return TwirlDemo::create(t);         case 9: return ShakyTiles3DDemo::create(t);         case 10: return ShatteredTiles3DDemo::create(t);         case 11: return ShuffleTilesDemo::create(t);         case 12: return FadeOutTRTilesDemo::create(t);         case 13: return FadeOutBLTilesDemo::create(t);         case 14: return FadeOutUpTilesDemo::create(t);         case 15: return FadeOutDownTilesDemo::create(t);         case 16: return TurnOffTilesDemo::create(t);         case 17: return WavesTiles3DDemo::create(t);         case 18: return JumpTiles3DDemo::create(t);         case 19: return SplitRowsDemo::create(t);         case 20: return SplitColsDemo::create(t);         case 21: return PageTurn3DDemo::create(t);     }      return NULL; }  //取得相應的動畫。 CCActionInterval* getAction() {     CCActionInterval* pEffect = createEffect(actionIdx, 3);      return pEffect; }   //運行當前的場景。 void EffectTestScene::runThisTest() {     //創建一個當前的動畫演示層放入場景，並運行這個場景。     addChild(TextLayer::create());     CCDirector::sharedDirector()->replaceScene(this); }  #define SID_RESTART        1 //構造函數。 TextLayer::TextLayer(void) {     //調用基類LayerColor的初始化函數，設置當前層的背景色。     initWithColor( ccc4(32,128,32,255) );     //     float x,y;     //取得屏幕大小。     CCSize s = CCDirector::sharedDirector()->getWinSize();     x = s.width;     y = s.height;     //創建一個節點。     CCNode* node = CCNode::create();     //創建一個動畫。     CCActionInterval* effect = getAction();     //將動畫綁定到這個節點上。     node->runAction(effect);     //將這個節點再放入到當前層中。     addChild(node, 0, kTagBackground);     //創建第一個精靈做為背景。     CCSprite *bg = CCSprite::create(s_back3);     node->addChild(bg, 0); //  bg->setAnchorPoint( CCPointZero );     bg->setPosition(ccp(s.width/2, s.height/2));     //創建第二個精靈（女一號）。     CCSprite* grossini = CCSprite::create(s_pPathSister2);     node->addChild(grossini, 1);     grossini->setPosition( CCPointMake(x/3,y/2) );     //創建一個縮放動畫及對應的反向動畫。     CCActionInterval* sc = CCScaleBy::create(2, 5);     CCActionInterval* sc_back = sc->reverse();     //讓第二個精靈運行相應的動畫序列。 grossini->runAction( CCRepeatForever::create((CCActionInterval*)(CCSequence::create(sc, sc_back, NULL)) ) );     //創建第三個精靈。（女二號）     CCSprite* tamara = CCSprite::create(s_pPathSister1);     node->addChild(tamara, 1); tamara->setPosition( CCPointMake(2*x/3,y/2) ); //創建一個縮放動畫及對應的反向動畫。     CCActionInterval* sc2 = CCScaleBy::create(2, 5);     CCActionInterval* sc2_back = sc2->reverse();     //讓第三個精靈運行相應的動畫序列。tamara->runAction( CCRepeatForever::create((CCActionInterval*)(CCSequence::create(sc2, sc2_back, NULL))) );     //創建一個文字標籤。     CCLabelTTF* label = CCLabelTTF::create((effectsList[actionIdx]).c_str(), "Marker Felt", 32);     //設置標籤的位置並放入當前層中。     label->setPosition( CCPointMake(x/2,y-80) );     addChild(label);     label->setTag( kTagLabel );     //創建三個菜單按鈕分別代表運行上一個，重新運行當前動畫，運行下一個動畫。     CCMenuItemImage *item1 = CCMenuItemImage::create(s_pPathB1, s_pPathB2, this, menu_selector(TextLayer::backCallback) );     CCMenuItemImage *item2 = CCMenuItemImage::create(s_pPathR1, s_pPathR2, this, menu_selector(TextLayer::restartCallback) );     CCMenuItemImage *item3 = CCMenuItemImage::create(s_pPathF1, s_pPathF2, this, menu_selector(TextLayer::nextCallback) );     //由三個菜單按鈕創建菜單。     CCMenu *menu = CCMenu::create(item1, item2, item3, NULL);     //設置相應菜單按鈕的位置。     menu->setPosition(CCPointZero);     item1->setPosition(CCPointMake( s.width/2 - item2->getContentSize().width*2, item2->getContentSize().height/2));     item2->setPosition(CCPointMake( s.width/2, item2->getContentSize().height/2));     item3->setPosition(CCPointMake( s.width/2 + item2->getContentSize().width*2, item2->getContentSize().height/2));     //將菜單加入當前層中。     addChild(menu, 1);         //對當前層調用一個函數。     schedule( schedule_selector(TextLayer::checkAnim) ); }  //檢查動畫。 void TextLayer::checkAnim(float dt) {     //取得對應結點。 CCNode* s2 = getChildByTag(kTagBackground); //判斷如果沒有正在運行中的動畫，並且其有格子數據，則將其格子數據釋放並置空。     if ( s2->numberOfRunningActions() == 0 && s2->getGrid() != NULL)         s2->setGrid(NULL);; }  //析構。 TextLayer::~TextLayer(void) { }  //創建一個當前層的函數。 TextLayer* TextLayer::create() {     TextLayer* pLayer = new TextLayer();     pLayer->autorelease();          return pLayer; } //當前層被載入時的處理。 void TextLayer::onEnter() {     CCLayer::onEnter(); } //創建一個新場景。 void TextLayer::newScene() {     CCScene* s = new EffectTestScene();     CCNode* child = TextLayer::create();     s->addChild(child);     CCDirector::sharedDirector()->replaceScene(s);     s->release(); } //重啟當前動畫演示。 void TextLayer::restartCallback(CCObject* pSender) {     newScene(); } //前進到下一個動畫演示。 void TextLayer::nextCallback(CCObject* pSender) {     // update the action index     actionIdx++;     actionIdx = actionIdx % MAX_LAYER;      newScene(); } //回退到上一個動畫演示。 void TextLayer::backCallback(CCObject* pSender) {     // update the action index     actionIdx--;     int total = MAX_LAYER;     if( actionIdx < 0 )         actionIdx += total;          newScene(); } 

 最後做個總結：

     Cocos2d-x提供了屏幕畫面上的一些基於網格的動畫，首先將要渲染的畫面輸出到一張紋理上，然後跟據屏幕大小創建相應數量的網格，通過對於網格上的頂點進行改變，形成頂點的運動動畫，然後將紋理貼在網格上再繪製出來，就能夠出現很多屏幕特效了。

     覺得怎麼樣？是不是恍然大悟呢?如果有這樣的感覺，則我的辛苦就沒有白費。

     最後，祝大家快樂 !!

Bookmark the permalink ，來源：互聯網

One thought on “Cocos2d-x 2.0 格子動畫深入分析”

更多關於Cocos2d-x 2.0 格子動畫深入分析資訊...

推薦閱讀文章

• 深入分析Cocos2d-x 2.0中的「紋路」
• Cocos2d-x 2.0 格子動畫深入分析
• Cocos2d-x之LUA腳本發動機深入分析
• (譯）OpenGL ES2.0 – Iphone開發引導
• C++筆考試題匯總二
• Cocos2d-x2.0 進度卡通片 深入分析
• Cocos2d-x 2.0 拖尾成效深入分析
• Cocos2d-x2.0 粒子系統深入分析三部曲(1)
• 怎麼優化cocos2d/x程序的內存使用和程序
• iOS開發從學習到產品/推廣的全面總結和經驗

---

*PT(FDZ)*--*O Cocos2D-X 3.0 (Download) 
Versão chinesa das notas de lançamento (clique para ver) 
Cocos IDE Guia de Introdução (clique para ver) 
Tutoriais relacionados recomendada: 
[No Video Tutorial Cocos2D-x3.x] coordenadas detalhadas 
[No vídeo tutorial Cocos2D-X3.0] três jogos de eliminação SushiCrush S01E01 
[No vídeo tutorial Cocos2D-X3.0] três jogos de eliminação SushiCrush S01E02 
  
[No Tutorial Cocos2D-X] 's empurrão integração iOS 
[No Cocos2D-X Tutorial] Cocos2dx 3.0 - o valor de jogabilidade simples fresco cozido 
[Nos Cocos2D-X Tutorial] passos cocos2dx3.0rc métodos de classe personalizado exportação detalhado para LUA 
[No Cocos2D-X Tutorial] a Cocos2D-X integração função 3.0 imagem de tela 
[No Cocos2D-X Tutorial] a Cocos2D-X 3.0 para tutoriais de ligação RC LUA e novas funcionalidades introduzidas. 
[No Cocos2D-X Tutorial] Cocos2dx 3.0 - Não rótulo apoio FREETYPE 
[Nos Cocos2D-X Tutorial] Cocos2dx 3.0 - uso de expressões lambda 
  
Cocos2d-X jogos 3.0 iphone fazer um simples tutorial sobre como usar a (primeira parte) 
Como usar o cocos2d-X3.0 fazer um jogo simples: a segunda parte (torre rotativa) 
Como usar cocos2d-X3.0 fazer um jogo simples: Parte III (monstros violentos e mais pontos) 
  
Usado Cocos2D-X-3.0 motor de jogo. Escreva uma versão completa telha mapa do jogo 
Com a Cocos2D-X 3.0 para fazer um jogo de Cobra 
"Onslaught da Serpente", baseado cocos2dx3.0 nova versão de produção, usar os novos recursos, e não o código 2.X transplante. 
Como usar o Cocos2D-X 3.0 para fazer uma serpente, incluindo multi-plataforma professor _DZ [code] gráfico Dummies 
O X-cocos2d 3.0 ambiente e a versão oficial do Android para construir tutorial detalhado 
  
[Tutorial] resumiu a essência do Resumo Cocos2D-X Tutorial (Fase I) 
[Tutorial] resumiu a essência da Cocos2D-X Tutorial Resumo (Fase II) 
CocoaChina é a maior comunidade chinesa Apple Developer do mundo, o micro-canal impulso regular diário oficial uma variedade de recursos e ferramentas interessantes de pesquisa e desenvolvimento tutorial apresenta aplicativo de experiência no mercado de promoção, o recrutamento de novos negócios e outsourcing de informação, bem como motor Cocos2d, Cocostudio mais recente kit de desenvolvimento e treinamento de informações. Preocupado com o micro-canal pode ser o primeiro a conhecer os mais recentes produtos e serviços para micro dinâmica carta na mão, o mundo que eu tenho! 
Por favor, procure Micro Signal "CocoaChina" Siga-nos!
*Internacia Lingvo' ----"'' nova mejloŝtono: Cocos2D-X v3.0 liberigis la oficiala versio + + + + estas multaj aliaj ..!. 
*La Cocos2D-X 3.0 (Elŝuti) 
Ĉina versio de la eldonajn rimarkojn (klaku por vidi) 
Cocos IDE ekuzi Gvidilo (klaku por vidi) 
Rilataj Lerniloj Rekomenditaj: 
[En la Cocos2D-x3.x Video Tutorial] Detalaj koordinatoj 
[En la Cocos2D-X3.0 video lernilo] tri elimino ludoj SushiCrush S01E01 
[En la Cocos2D-X3.0 video lernilo] tri elimino ludoj SushiCrush S01E02 
  
[En la Cocos2D-X Tutorial] 's IOS integriĝo puŝo 
[En la Cocos2D-X Tutorial] Cocos2dx 3.0 - la valoron de simpla ludo freŝbakitaj 
[En la Cocos2D-X Tutorial] cocos2dx3.0rc eksporti kutimo klaso metodoj detalaj paŝoj al LUA 
[En la Cocos2D-X Tutorial] la Cocos2D-X 3.0 ekrankopio funkcio integralado 
[En la Cocos2D-X Tutorial] la Cocos2D-X 3.0 por RC LUA katenante lernilojn kaj novaj funkcioj enkondukita. 
[En la Cocos2D-X Tutorial] Cocos2dx 3.0 - Tie FreeType subtenon etiketon 
[En la Cocos2D-X Tutorial] Cocos2dx 3.0 - uzo lambda esprimoj 
  
Cocos2d-X 3.0 iphone ludoj fari simplan lernilo pri kiel uzi la (unua parto) 
Kiel uzi la cocos2d-X3.0 farante simplan ludon: la dua parto (turnanta turon) 
Kiel uzi cocos2d-X3.0 farante simplan ludo: Parto III (perforta monstroj kaj pli da poentoj) 
  
Uzataj Cocos2D-X-3.0 ludo motoro. Skribu kahelo mapo ludo kompleta versio 
Kun la Cocos2D-X 3.0 fari Snake ludo 
"Lavango de la Culebra," bazita cocos2dx3.0 nova versio de produktado, uzu la novajn funkciojn, ne la transplanto 2.x kodo. 
Kiel uzi la Cocos2D-X 3.0 fari Culebra, inkluzive de transversa kajo _DZ majstron [grafikaj kodo] Dummies 
La cocos2d-X 3.0 medio kaj la oficiala versio de Android konstrui detalajn lernilo 
  
[Tutorial] resumis la esencon de la Cocos2D-X Tutorial Resumo (fazo) 
[Tutorial] resumis la esencon de Cocos2D-X Tutorial Resumo (Fazo II) 
CocoaChina estas la plej granda monda Apple Developer ĉina komunumo, la oficiala mikro-kanalo regula ĉiutaga puŝo vario de ekscita esplorado kaj evoluo rimedoj kaj iloj lernilo enkondukas app promocion marketing sperto, novaj negocoj varbado kaj ekstera fonto de informo, tiel kiel Cocos2d motoron, Cocostudio lastajn evoluo kit kaj trejnante informo. Zorgas pri la mikro-kanalo povas esti la unua por lerni pri la plej novaj produktoj kaj servoj al dinamika, mikro letero en la mano, la mondo mi havas! 
Bonvolu serĉi Micro Signalo "CocoaChina" Sekvu nin!  **

*-한국 언어*South of Koren---'새로운 이정표 :적인 Cocos2D-X V3.0은 많은 사람들이 공식 버전 + + + +를 출시 ..!. *
*적인 Cocos2D-X 3.0 (다운로드) 
릴리스 노트의 중국어 버전 (클릭) 
코코스 IDE가 시작 안내서 (클릭) 
관련 자습서 추천 : 
[적인 Cocos2D-x3.x 비디오 튜토리얼] 자세한 좌표 
[적인 Cocos2D-X3.0 비디오 자습서] 세 제거 게임 S01E01을 SushiCrush 
[적인 Cocos2D-X3.0 비디오 자습서] 세 제거 게임 S01E02을 SushiCrush 
  
[적인 Cocos2D-X 튜토리얼] 아이폰 OS 통합 푸시보기 
Cocos2dx 3.0 【적인 Cocos2D-X 튜토리얼] - 간단한 게임 플레이의 값은 신선한 구운 
LUA에 cocos2dx3.0rc 수출 사용자 정의 클래스 방법 자세한 단계 [적인 Cocos2D-X 튜토리얼]이 
[적인 Cocos2D-X 튜토리얼]적인 Cocos2D-X 3.0 스크린 샷 기능 통합 
[적인 Cocos2D-X 튜토리얼] 도입 RC LUA 바인딩 튜토리얼과 새로운 기능적인 Cocos2D-X 3.0. 
Cocos2dx 3.0 【적인 Cocos2D-X 튜토리얼] -이 FreeType에서 뒷면 라벨 
Cocos2dx 3.0 【적인 Cocos2D-X 튜토리얼] - 사용 람다 식 
  
적인 Cocos2D-X 3.0 아이폰 게임 (첫 번째 부분)을 사용하는 방법에 대한 간단한 튜토리얼을 수행 
두 번째 부분 (회전 포탑) : 간단한 게임을 만드는적인 Cocos2D-X3.0를 사용하는 방법 
간단한 게임하기적인 Cocos2D-X3.0를 사용하는 방법 : 파트 III (폭력 괴물과 더 많은 포인트) 
  
중고적인 Cocos2D-X-3.0 게임 엔진. 타일​​지도 게임 전체 버전을 쓰기 
뱀 게임을 할 수적인 Cocos2D-X 3.0 
"뱀의 맹공,"기반 cocos2dx3.0 새로운 생산 버전의 새로운 기능, 이식 2.X 코드하지를 사용합니다. 
크로스 플랫폼 _DZ 교사 [그래픽 코드] 인형을 포함, 뱀을 할 수적인 Cocos2D-X 3.0을 사용하는 방법 
적인 Cocos2D-X 3.0 환경과 상세한 튜토리얼을 구축하기 위해 안드로이드의 공식 버전 

Cocos2d-X 3.0 iphone games do a simple tutorial on how to use the (first part) 
How to use the cocos2d-X3.0 making a simple game: the second part (rotating turret) 
How to use cocos2d-X3.0 making a simple game: Part III (violent monsters and more points) 

en--A new milestone: the Cocos2D-X V3.0 official release!
zht--新里程碑：在Cocos2D-X V3.0正式版本發布！
pt--Um novo marco: o Cocos2D-X lançamento oficial V3.0! 
south of Koren--새로운 이정표 :적인 Cocos2D-X V3.0 공식 발매! 

INT.Nova mejloŝtono: la Cocos2D-X v3.0 oficiala eldono!
  Next time adjourned to another .......oh...
下回再續其他.......ioi
oh...Da próxima vez adiada para outra ....... 
다음 번에 다른 휴회 .......oh...
Venonta tempo prokrastis al alia ...oh....... 
===Melody.Blog===THE     END===>/

&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&