本章为我的Cocos2d-x教程一书初稿。望各位看官多提建议！
另请转载者注明转载地址及作者。
Cocos2d-x 2.0 TestCpp之场景切换动画深入分析
另：本章所用Cocos2d-x版本为:
cocos2d-2.0-x-2.0.2@ Aug 30 2012
http://cn.cocos2d-x.org/download
大家好，今天我们来学习一下Cocos2d-x中的场景切换效果，我们在玩一些2D的RPG游戏时，常常会遇到场景的转换，这时候当前场景的画面会以百叶窗翻页或者是缩放消失的动画效果切换到新的场景。Cocos2d-x提供了大量可以直接使用的场景切换效果，我们本节将深入分析一下这些效果的实现原理。
我们知道，Cocos2d-x提供了大量的精灵动画效果，红孩儿用了“三板斧”才将这些精灵动画效果讲解完，之后又讲解了进度动画，变速动画，网格动画，这些知识对于本章的理解非常重要，希望同学们先好好理解之前的内容，如果您已经理解了这些知识，那我们现在就开始学习场景切换吧！
首先，我们来概述一下切景切换的核心原理：
场景的切换，是将当前正在运行的场景运行一个动画序列，这个动画序列一般由两部分构成，第一部分为一个精灵动画或者进度动画，第二部分为一个回调函数，场景在切换过程中，本身会进行精灵动画或进度动画的过程，比如移动或缩放动画造成场景的移出，在动画结束后，执行回调函数将原场景隐藏释放，新场景设置为显示。
为了进一步的把这个原理说明给大家，咱们来进行源码的分析。在Cocos2d-x 2.0中，提供了大量封装好的场景类来实现相应的切换动画。我们打开CCTransition.h来看一下。
首先， Cocos2d-x定义了一个用于场景切换的基类CCTransitionScene,这个类是由CCScene派生的，它本质上只是一个具有场景属性的控制器，控制在进行场景切换时的新老场景的切换处理。
class CC_DLL CCTransitionScene : public CCScene
{
protected:
//要切入的新场景
CCScene * m_pInScene;
//要切出的旧场景
CCScene * m_pOutScene;
//切换动画效果的时长
float m_fDuration;
//是否对场景进行渲染排序，是否保证新场景在最上面。
bool m_bIsInSceneOnTop;
//在切换完成后是否清空旧场景。
bool m_bIsSendCleanupToScene;
public:
//构造
CCTransitionScene();
//析构
virtual ~CCTransitionScene();
//重载场景的绘制函数，修改其绘制内容。
virtual void draw();
//重载场景在被载入时调用的函数，做一些初始化的操作。
virtual void onEnter();
//重载场景在被卸载时调用的函数，做一些清理的操作。
virtual void onExit();
//重载场景在被释放时调用的函数，做一些释放的操作。
virtual void cleanup();
//静态函数，创建一个场景切换动画，这里的参数一为动画的时长，参数二为要切换到的新场景，其内部调用create来实现。
CC_DEPRECATED_ATTRIBUTE static CCTransitionScene * transitionWithDuration(float t, CCScene *scene);
//同上
static CCTransitionScene * create(float t, CCScene *scene);
//初始化场景切换动画。
virtual bool initWithDuration(float t,CCScene* scene);
//在场景切换动画结束后调用。
void finish(void);
//用来隐藏老场景。
void hideOutShowIn(void);
protected:
//设置对场景进行排序。
virtual void sceneOrder();
private:
//私有函数，用于在场景切换动画完成后，设置新场景为当前游戏场景。
void setNewScene(float dt);
};
代码很清楚的交待了场景切换的新场景创建，初始化，排序，以及结束的一些基本函数，其CPP中对应代码我也粘贴在这里进行解释：
//构造函数
CCTransitionScene::CCTransitionScene()
{
}
//析构函数
CCTransitionScene::~CCTransitionScene()
{
//因为在初始化时开始占用新老场景，所以对其引用计数器做了加一操作，这里自然要减一操作。
m_pInScene->release();
m_pOutScene->release();
}
//静态函数，创建一个场景切换动画，这里的参数一为动画的时长，参数二为要切换到的新场景，其内部调用create来实现。
CCTransitionScene * CCTransitionScene::transitionWithDuration(float t, CCScene *scene)
{
return CCTransitionScene::create(t,scene);
}
//同上
CCTransitionScene * CCTransitionScene::create(float t, CCScene *scene)
{
//使用new创建一个用来切换到的新场景。
CCTransitionScene * pScene = new CCTransitionScene();
//如果有效，则对其进行初始化。
if(pScene && pScene->initWithDuration(t,scene))
{
//如果初始化成功，交由内存管理器进行管理。
pScene->autorelease();
//返回这个新的场景。
return pScene;
}
//如果无效或初始化失败，释放后返回NULL。
CC_SAFE_DELETE(pScene);
return NULL;
}
//初始化场景。
bool CCTransitionScene::initWithDuration(float t, CCScene *scene)
{
//参数有效性判断
CCAssert( scene != NULL, "Argument scene must be non-nil");
//先调用基类的init函数进行基类成员变量初始化。
if (CCScene::init())
{
//将动画时长保存到变量m_fDuration中。
m_fDuration = t;
//保存要切换到的场景。
m_pInScene = scene;
//动画过程会占用新场景，所以对其引用计数器加1
m_pInScene->retain();
//保存当前的场景返回到m_pOutScene中。
m_pOutScene = CCDirector::sharedDirector()->getRunningScene();
if (m_pOutScene == NULL)
{ //如果当前没有任何场景，就创建一个场景返回到m_pOutScene中并初始化。
m_pOutScene = CCScene::create();
m_pOutScene->init();
}
//动画过程会占用当前场景，所以对其引用计数器也加1
m_pOutScene->retain();
//确保切换的两个场景不相同。
CCAssert( m_pInScene != m_pOutScene, "Incoming scene must be different from the outgoing scene" );
// 取得设备管理器。
CCDirector* pDirector = CCDirector::sharedDirector();
//在这个过程中将场景的触屏响应关闭，以免切换动画被中断。
pDirector->getTouchDispatcher()->setDispatchEvents(false);
//进行场景的排序。
this->sceneOrder();
//返回成功。
return true;
}
else
{ //如果初始化不成功，返回false。
return false;
}
}
//设置场景进行排序。
void CCTransitionScene::sceneOrder()
{
//设置将新场景放在最前面。
m_bIsInSceneOnTop = true;
}
//场景的绘制函数。
void CCTransitionScene::draw()
{
//先调用基类的场景绘制函数。
CCScene::draw();
//如果场景有排序，则先绘制旧的场景，再绘制新的场景，新场景最后绘制，就能保证在最前面。
if( m_bIsInSceneOnTop ) {
m_pOutScene->visit();
m_pInScene->visit();
} else {//否则则相反。
m_pInScene->visit();
m_pOutScene->visit();
}
}
//场景切换动画结束后调用的函数。
void CCTransitionScene::finish()
{
//先将新场景设为显示，并设置位置，缩放，旋转参数，摄像机重置。
m_pInScene->setVisible(true);
m_pInScene->setPosition(ccp(0,0));
m_pInScene->setScale(1.0f);
m_pInScene->setRotation(0.0f);
m_pInScene->getCamera()->restore();
//再将旧场景设为不显示，也设置位置，缩放，旋转参数，摄像机重置。
m_pOutScene->setVisible(false);
m_pOutScene->setPosition(ccp(0,0));
m_pOutScene->setScale(1.0f);
m_pOutScene->setRotation(0.0f);
m_pOutScene->getCamera()->restore();
//调用函数设置新场景为当前游戏场景的函数。
//[self schedule:@selector(setNewScene:) interval:0];
this->schedule(schedule_selector(CCTransitionScene::setNewScene), 0);
}
//设置新场景为当前游戏场景的函数。
void CCTransitionScene::setNewScene(float dt)
{
CC_UNUSED_PARAM(dt);
//将当前函数中当前类所挂接的回调函数容器的删除。
this->unschedule(schedule_selector(CCTransitionScene::setNewScene));
//取得当前设备。
CCDirector *director = CCDirector::sharedDirector();
//取得当前设备是否设置了被替换的场景将被释放，将其保存到变量m_bIsSendCleanupToScene。
m_bIsSendCleanupToScene = director->isSendCleanupToScene();
//将新场景设置为当前运行的场景。
director->replaceScene(m_pInScene);
//开启响应触屏事件。
director->getTouchDispatcher()->setDispatchEvents(true);
//设置被替换的场景显示，这样在主循环中设备才会对其进行相应的处理而使其被释放。
m_pOutScene->setVisible(true);
}
//用来隐藏老场景。
void CCTransitionScene::hideOutShowIn()
{
//设置显示新场景，隐藏老场景。
m_pInScene->setVisible(true);
m_pOutScene->setVisible(false);
}
//当前场景被加载时响应的函数。
void CCTransitionScene::onEnter()
{
//调用基类的相应函数。
CCScene::onEnter();
//对新场景调用相应函数。
m_pInScene->onEnter();
}
//当前场景被卸载时响应的函数。
void CCTransitionScene::onExit()
{
//调用基类的相应函数。
CCScene::onExit();
//对老场景调用相应函数。
m_pOutScene->onExit();
//新场景响应onEnterTransitionDidFinish函数。
m_pInScene->onEnterTransitionDidFinish();
}
// 清空
void CCTransitionScene::cleanup()
{ //调用基类的相应函数。
CCScene::cleanup();
//如果m_bIsSendCleanupToScene为true，则调用老场景的cleanup函数。
if( m_bIsSendCleanupToScene )
m_pOutScene->cleanup();
}
这个“场景切换控制器”里有一些重要的场景处理函数，比如onEnter,onExit, onEnterTransitionDidFinish, cleanup.我们必须搞清楚它们是在什么时候被调用的，这对于理解场景切换的过程至关重要。当我们取得设备并利用replaceScene来设置一个新场景时，这个新场景会被存入设备的指针变量m_pNextScene中。
void CCDirector::replaceScene(CCScene *pScene)
{
//参数的有效性判断
CCAssert(pScene != NULL, "the scene should not be null");
//取得存放场景的容器中的场景数量。
unsigned int index = m_pobScenesStack->count();
//设置清空场景标记为true。
m_bSendCleanupToScene = true;
//将场景放在容器的结尾
m_pobScenesStack->replaceObjectAtIndex(index - 1, pScene);
//设置新场景指针变量为参数场景。
m_pNextScene = pScene;
}
在主循环中，我们会调用设备的drawScene函数。
void CCDirector::drawScene(void)
{
// 计算帧间隔时间
calculateDeltaTime();
// 更新回调函数管理器。
if (! m_bPaused)
{
m_pScheduler->update(m_fDeltaTime);
}
//OPENGL清除后台缓冲区的颜色和深度，这是每一帧OPENGL进行渲染前要做的处理。
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
//如果有新的场景要设置，调用setNextScene函数进行相关处理。
if (m_pNextScene)
{
setNextScene();
}
…
}
很明显，一切尽在setNextScene函数：
void CCDirector::setNextScene(void)
{
//定义bool变量runningIsTransition，判断当前运行中的场景是否是切换场景类，如果是，将runningIsTransition设为true。
bool runningIsTransition = dynamic_cast<CCTransitionScene*>(m_pRunningScene) != NULL;
//定义bool变量newIsTransition，判断要设置的新场景是否是切换场景类，如果是，将newIsTransition设为true。
bool newIsTransition = dynamic_cast<CCTransitionScene*>(m_pNextScene) != NULL;
// 如果新场景不是切换场景类而是一个普通场景。
if (! newIsTransition)
{
//释放当前正在运行的场景，注意，这可能是一个切换场景。
if (m_pRunningScene)
{
m_pRunningScene->onExit();
}
//如果m_bSendCleanupToScene标记为true且有正在运行的场景则调用它的cleanup函数。
if (m_bSendCleanupToScene && m_pRunningScene)
{
m_pRunningScene->cleanup();
}
}
//调用当前正在运行的场景的释放函数。
if (m_pRunningScene)
{
m_pRunningScene->release();
}
//更新当前正在运行的场景为新的场景。
m_pRunningScene = m_pNextScene;
//占用新的场景，所以对其引用计数器减1操作。
m_pNextScene->retain();
//将新场景指针变量置空。
m_pNextScene = NULL;
//如果旧场景不是场景切换控制场景。
if ((! runningIsTransition) && m_pRunningScene)
{
//调用新场景的onEnter函数。
m_pRunningScene->onEnter();
//设用新场景的onEnterTransitionDidFinish函数。
m_pRunningScene->onEnterTransitionDidFinish();
}
}
看代码是比较枯燥的一件事，我来用实例讲一下这个流程吧。大家知道 , TestCpp工程下的TransitionsTest有很多场景切换的效果，当我们运行这个例子时。会先出现一个场景，这个场景只有一个CCLayer，它是一个普通场景，当我们点击代表“切到到下一个场景”的菜单按钮时，这时候会开始演示一个场景切换效果。整个过程为：
(1)创建CCTransitionScene并调用replaceScene。
例：
在void
CCDirector::sharedDirector()->replaceScene(CCTransitionScene*);
(2)在主循环的drawScene函数中会调用setNextScene。
CCDirector:: setNextScene()
{
//当前场景是普通场景，新的场景是“场景切换控制器”。dynamic_cast会得出以下结果：
bool runningIsTransition= false ;
bool newIsTransition= true;
…
//当前场景是普通场景，进入判断
if
{
//调用“场景切换控制器”的onEnter函数。
m_pRunningScene->onEnter();
//设用“场景切换控制器”的onEnterTransitionDidFinish函数。
m_pRunningScene->onEnterTransitionDidFinish();
}
}
(3) 然后是CCTransitionScene “场景切换控制器”切换动画的更新过程，结束后调用其finish函数，finish函数调用setNewScene函数，并将新切换的场景设置为当前运行的场景。
director->replaceScene(m_pInScene);
(4)主循环的drawScene函数中调用setNextScene
CCDirector:: setNextScene()
{
//当前场景是“场景切换控制器”，新的场景是普通场景。dynamic_cast会得出以下结果：
bool runningIsTransition= true ;
bool newIsTransition= false ;
if (!newIsTransition)
{
//将“场景切换控制器”退出
if
{
m_pRunningScene->onExit();
}
//将“场景切换控制器”进行内部的释放处理。
if
{
m_pRunningScene->cleanup();
}
}
//将“场景切换控制器”的引用计数减一，删除场景。
if
{
m_pRunningScene->release();
}
}
“场景切换控制器” --CCTransitionScene，Cocos2d-x派生出了许多种切换场景的动画形式。下面我们就来一一学习。
打开CCTransition.h，我们继续学习各种派生类:
//控制单方向进行切换动画的场景切换控制器
class CC_DLL CCTransitionSceneOriented : public CCTransitionScene
{
protected:
//切换动画的方向
tOrientation m_eOrientation;
public:
//构造函数。
CCTransitionSceneOriented();
//析构函数。
virtual ~CCTransitionSceneOriented();
//静态函数:创建一个单方向的场景切换控制器，内部调用create实现。参数一为动画的时长，参数二为要切换到的场景，参数三为切换的方向。
CC_DEPRECATED_ATTRIBUTE static CCTransitionSceneOriented * transitionWithDuration(float t,CCScene* scene, tOrientation orientation);
//上面的create实现。
static CCTransitionSceneOriented * create(float t,CCScene* scene, tOrientation orientation);
//初始化函数。
virtual bool initWithDuration(float t,CCScene* scene,tOrientation orientation);
};
对应CPP：
//构造函数。
CCTransitionSceneOriented::CCTransitionSceneOriented()
{
}
//析构函数。
CCTransitionSceneOriented::~CCTransitionSceneOriented()
{
}
//静态函数:创建一个单方向的场景切换控制器，内部调用create实现。参数一为动画的时长，参数二为要切换到的场景，参数三为切换的方向。CCTransitionSceneOriented * CCTransitionSceneOriented::transitionWithDuration(float t, CCScene *scene, tOrientation orientation)
{
return CCTransitionSceneOriented::create(t,scene,orientation);
}
//上面的create实现。
CCTransitionSceneOriented * CCTransitionSceneOriented::create(float t, CCScene *scene, tOrientation orientation)
{
//使用new创建一个单方向的场景切换控制器。
CCTransitionSceneOriented * pScene = new CCTransitionSceneOriented();
//初始化
pScene->initWithDuration(t,scene,orientation);
//交由内存管理器进行释放处理。
pScene->autorelease();
//返回创建的场景切换控制器。
return pScene;
}
//初始化。
bool CCTransitionSceneOriented::initWithDuration(float t, CCScene *scene, tOrientation orientation)
{
//调用基类的初始化。
if ( CCTransitionScene::initWithDuration(t, scene) )
{
//如果成功，保存方向。
m_eOrientation = orientation;
}
return true;
}
//控制旋转并缩放（涡轮效果）切换动画的场景切换控制器。
class CC_DLL CCTransitionRotoZoom : public CCTransitionScene
{
public:
//构造
CCTransitionRotoZoom();
//析构
virtual ~CCTransitionRotoZoom();
//加载场景控制器时调有的函数。
virtual void onEnter();
//新老创建函数。
TRANSITION_CREATE_FUNC(CCTransitionRotoZoom);
OLD_TRANSITION_CREATE_FUNC(CCTransitionRotoZoom);
};
对应CPP：
//构造函数。
CCTransitionRotoZoom::CCTransitionRotoZoom()
{
}
//析构函数。
CCTransitionRotoZoom::~CCTransitionRotoZoom()
{
}
//加载场景控制器时调有的函数。
void CCTransitionRotoZoom:: onEnter()
{
//调用基类的相应函数。
CCTransitionScene::onEnter();
//设置新场景的初始缩放值为0.001，缩小了100倍。
m_pInScene->setScale(0.001f);
//设置原场景的初始缩放值为原大小。
m_pOutScene->setScale(1.0f);
//设置场景的锚点做为旋转缩放中心。
m_pInScene->setAnchorPoint(ccp(0.5f, 0.5f));
m_pOutScene->setAnchorPoint(ccp(0.5f, 0.5f));
//创建一个序列动画。
CCActionInterval *rotozoom = (CCActionInterval*)(CCSequence::create
(
//这个序列动画有两部分，第一部分是一个组合动画，这个组合动画由缩放和旋转组合而成。
CCSpawn::create
(
//一半动画时间内从当前缩放值缩小100倍。
CCScaleBy::create(m_fDuration/2, 0.001f),
//一半动画时间内从当前旋转状态旋转两圈。
CCRotateBy::create(m_fDuration/2, 360 * 2),
NULL
),
//序列动画的第二部分是一个暂停一半动画时间的暂停动画。
CCDelayTime::create(m_fDuration/2),
NULL
));
//对原场景运行上面创建的序列动画，让它在一半动画时长内旋转2圈，并由原大小缩小100倍，然后暂停一半动画时长。
m_pOutScene->runAction(rotozoom);
//对新的场景运行另一个序列动画。
m_pInScene->runAction
(
CCSequence::create
(
//这个序列动画也有两部分构成，第一部分是上面序列动画的反向动画，第二部分是调用finish函数。
rotozoom->reverse(),
CCCallFunc::create(this, callfunc_selector(CCTransitionScene::finish)),
NULL
)
);
}
//控制跳跃缩放切换动画的场景切换控制器。
class CC_DLL CCTransitionJumpZoom : public CCTransitionScene
{
public:
//构造
CCTransitionJumpZoom();
//析构
virtual ~CCTransitionJumpZoom();
//加载场景控制器时调有的函数。
virtual void onEnter();
//新老创建函数。
TRANSITION_CREATE_FUNC(CCTransitionJumpZoom);
OLD_TRANSITION_CREATE_FUNC(CCTransitionJumpZoom);
};
对应CPP：
CCTransitionJumpZoom::CCTransitionJumpZoom()
{
}
CCTransitionJumpZoom::~CCTransitionJumpZoom()
{
}
//加载场景控制器时调有的函数。
void CCTransitionJumpZoom::onEnter()
{
//调用基类的相应函数。
CCTransitionScene::onEnter();
//取得屏幕大小
CCSize s = CCDirector::sharedDirector()->getWinSize();
//设置新场景大小为原来的一半。
m_pInScene->setScale(0.5f);
//设置新场景在屏幕靠右外面位置。
m_pInScene->setPosition(ccp(s.width, 0));
//设置新场景的锚点为中心点。
m_pInScene->setAnchorPoint(ccp(0.5f, 0.5f));
//设置旧场景的锚点为中心点。
m_pOutScene->setAnchorPoint(ccp(0.5f, 0.5f));
//创建一个跳跃动画。
CCActionInterval *jump = CCJumpBy::create(m_fDuration/4, ccp(-s.width,0), s.width/4, 2);
//创建一个新场景用的缩放动画。
CCActionInterval *scaleIn = CCScaleTo::create(m_fDuration/4, 1.0f);
//创建一个旧场景用的缩放动画。
CCActionInterval *scaleOut = CCScaleTo::create(m_fDuration/4, 0.5f);
//创建一个旧场景用的动画序列：先缩小，后跳跃。
CCActionInterval *jumpZoomOut = (CCActionInterval*)(CCSequence::create(scaleOut, jump, NULL));
//创建一个新场景用的动画序列：先跳跃，后放大 。
CCActionInterval *jumpZoomIn = (CCActionInterval*)(CCSequence::create(jump, scaleIn, NULL));
//创建一个暂停动画。暂停一半动画时长。
CCActionInterval *delay = CCDelayTime::create(m_fDuration/2);
//旧场景运行动画序列。
m_pOutScene->runAction(jumpZoomOut);
//新场景运行一个新的动画序列。
m_pInScene->runAction
(
//新的动画序列先暂停，然后运行上面创建的新场景用动画序列，最后调用finish函数。
CCSequence::create
(
delay,
jumpZoomIn,
CCCallFunc::create(this, callfunc_selector(CCTransitionScene::finish)),
NULL
)
);
}
//从屏幕左边移动进来的场景切换控制器。这里由CCTransitionScene和CCTransitionEaseScene派生，CCTransitionEaseScene是一个纯虚类，由它派生必须重载其纯虚函数easeActionWithAction,意义是产生一个变速动画。
class CC_DLL CCTransitionMoveInL : public CCTransitionScene, public CCTransitionEaseScene
{
public:
//构造
CCTransitionMoveInL();
//析构
virtual ~CCTransitionMoveInL();
//初始化场景。
virtual void initScenes(void);
//取得当前所用的时间动画。
virtual CCActionInterval* action(void);
//产生相应的变速动画。
virtual CCActionInterval* easeActionWithAction(CCActionInterval * action);
//加载场景控制器时调有的函数。
virtual void onEnter();
//新老创建函数。
TRANSITION_CREATE_FUNC(CCTransitionMoveInL);
OLD_TRANSITION_CREATE_FUNC(CCTransitionMoveInL);
};
对应CPP：
//构造函数。
CCTransitionMoveInL::CCTransitionMoveInL()
{
}
//析构函数。
CCTransitionMoveInL::~CCTransitionMoveInL()
{
}
//加载场景控制器时调有的函数。
void CCTransitionMoveInL::onEnter()
{
//调用基类的相应函数。
CCTransitionScene::onEnter();
//调用初始化场景函数。
this->initScenes();
//取得当前的时间动画。
CCActionInterval *a = this->action();
//新场景运行一个动画序列。
m_pInScene->runAction
(
//这个动画序列首先要运行重载函数产生的变速动画，然后调用finish。
CCSequence::create
(
this->easeActionWithAction(a),
CCCallFunc::create(this, callfunc_selector(CCTransitionScene::finish)),
NULL
)
);
}
//取得当前所用的时间动画。
CCActionInterval* CCTransitionMoveInL::action()
{
//在动画时长内移动到0,0位置。
return CCMoveTo::create(m_fDuration, ccp(0,0));
}
//产生相应的变速动画。
CCActionInterval* CCTransitionMoveInL::easeActionWithAction(CCActionInterval* action)
{
//产生一个基于EaseOut变速曲线的动画（可参见红孩儿的博文-“曲线动画深入分析”一文）
return CCEaseOut::create(action, 2.0f);
// return [EaseElasticOut actionWithAction:action period:0.4f];
}
//初始化场景。
void CCTransitionMoveInL::initScenes()
{
//取得屏幕位置，并设置初始位置在屏幕外面靠左边位置。
CCSize s = CCDirector::sharedDirector()->getWinSize();
m_pInScene->setPosition( ccp(-s.width,0) );
}
//从屏幕右边移动进来的场景切换控制器。由上面的类派生，只是移动方向不同。
class CC_DLL CCTransitionMoveInR : public CCTransitionMoveInL
{
public:
//构造
CCTransitionMoveInR();
//析构
virtual ~CCTransitionMoveInR();
//初始化场景。
virtual void initScenes();
//新老创建函数。
TRANSITION_CREATE_FUNC(CCTransitionMoveInR);
OLD_TRANSITION_CREATE_FUNC(CCTransitionMoveInR);
};
对应CPP：
//构造
CCTransitionMoveInR::CCTransitionMoveInR()
{
}
//析构
CCTransitionMoveInR::~CCTransitionMoveInR()
{
}
//初始化场景。
void CCTransitionMoveInR::initScenes()
{
//取得屏幕位置，并设置初始位置在屏幕外面靠右边位置。
CCSize s = CCDirector::sharedDirector()->getWinSize();
m_pInScene->setPosition( ccp(s.width,0) );
}
//从屏幕上边移动进来的场景切换控制器。由上面的类派生，只是移动方向不同。
class CC_DLL CCTransitionMoveInT : public CCTransitionMoveInL
{
public:
//构造
CCTransitionMoveInT();
//析构
virtual ~CCTransitionMoveInT();
//初始化场景。
virtual void initScenes();
//新老创建函数。
TRANSITION_CREATE_FUNC(CCTransitionMoveInT);
OLD_TRANSITION_CREATE_FUNC(CCTransitionMoveInT);
};
对应CPP：
//构造
CCTransitionMoveInT::CCTransitionMoveInT()
{
}
//析构
CCTransitionMoveInT::~CCTransitionMoveInT()
{
}
//初始化场景。
void CCTransitionMoveInT::initScenes()
{
//取得屏幕位置，并设置初始位置在屏幕外面靠上边位置。
CCSize s = CCDirector::sharedDirector()->getWinSize();
m_pInScene->setPosition( ccp(0,s.height) );
}
//从屏幕上边移动进来的场景切换控制器。由上面的类派生，只是移动方向不同。
class CC_DLL CCTransitionMoveInB : public CCTransitionMoveInL
{
public:
//构造
CCTransitionMoveInB();
//析构
virtual ~CCTransitionMoveInB();
//初始化场景。
virtual void initScenes();
//新老创建函数。
TRANSITION_CREATE_FUNC(CCTransitionMoveInB);
OLD_TRANSITION_CREATE_FUNC(CCTransitionMoveInB);
};
对应CPP：
//构造
CCTransitionMoveInB::CCTransitionMoveInB()
{
}
//析构
CCTransitionMoveInB::~CCTransitionMoveInB()
{
}
//初始化场景。
void CCTransitionMoveInB::initScenes()
{
//取得屏幕位置，并设置初始位置在屏幕外面靠下边位置。
CCSize s = CCDirector::sharedDirector()->getWinSize();
m_pInScene->setPosition( ccp(0,-s.height) );
}
//从屏幕左边移动新场景进来并推动旧场景离开屏幕的场景切换控制器。这里由CCTransitionScene和CCTransitionEaseScene派生，CCTransitionEaseScene是一个纯虚类，由它派生必须重载其纯虚函数easeActionWithAction,意义是产生一个变速动画。
class CC_DLL CCTransitionSlideInL : public CCTransitionScene, public CCTransitionEaseScene
{
public:
//构造
CCTransitionSlideInL();
//析构
virtual ~CCTransitionSlideInL();
//初始化场景。
virtual void initScenes(void);
//返回所用的时间动画。
virtual CCActionInterval* action(void);
//加载场景控制器时调有的函数。
virtual void onEnter();
//产生相应的变速动画。
virtual CCActionInterval* easeActionWithAction(CCActionInterval * action);
//新老创建函数。
TRANSITION_CREATE_FUNC(CCTransitionSlideInL);
OLD_TRANSITION_CREATE_FUNC(CCTransitionSlideInL);
protected:
//设置场景排序。
virtual void sceneOrder();
};
对应CPP：
#define ADJUST_FACTOR 0.5f
//构造
CCTransitionSlideInL::CCTransitionSlideInL()
{
}
//析构
CCTransitionSlideInL::~CCTransitionSlideInL()
{
}
//加载场景控制器时调有的函数。
void CCTransitionSlideInL::onEnter()
{
//调用基类的相应函数。
CCTransitionScene::onEnter();
//初始化
this->initScenes();
//创建当前的时间动画分别给时间动画指针变量in和out
CCActionInterval *in = this->action();
CCActionInterval *out = this->action();
//由in产生一个变速动画inAction。
CCActionInterval* inAction = easeActionWithAction(in);
//创建一个动画序列，先是运行由out产生的变速动画，之后调用finish函数。将这个动画序列返回给outAction;
CCActionInterval* outAction = (CCActionInterval*)CCSequence::create
(
easeActionWithAction(out),
CCCallFunc::create(this, callfunc_selector(CCTransitionScene::finish)),
NULL
);
//新场景运行inAction。
m_pInScene->runAction(inAction);
//老场景运行outAction。
m_pOutScene->runAction(outAction);
}
//设置场景排序，新场景在下面。
void CCTransitionSlideInL::sceneOrder()
{
m_bIsInSceneOnTop = false;
}
//初始化
void CCTransitionSlideInL:: initScenes()
{
//取得屏幕大小。
CCSize s = CCDirector::sharedDirector()->getWinSize();
//设置新场景的初始位置。
m_pInScene->setPosition( ccp(-(s.width-ADJUST_FACTOR),0) );
}
//取得当前动画所要表现的时间动画。
CCActionInterval* CCTransitionSlideInL::action()
{
//创建一个从当前位置横向移动指定距离的动画。
CCSize s = CCDirector::sharedDirector()->getWinSize();
return CCMoveBy::create(m_fDuration, ccp(s.width-ADJUST_FACTOR,0));
}
//取得对应的时间动画的变速动画。
CCActionInterval* CCTransitionSlideInL::easeActionWithAction(CCActionInterval* action)
{
//由CCEaseOut变速曲线生成变速动画，可参看 红孩儿博文 – “变速动画深入解析”一章。
return CCEaseOut::create(action, 2.0f);
// return [EaseElasticOut actionWithAction:action period:0.4f];
}
//从屏幕右边移动新场景进来并推动旧场景离开屏幕的场景切换控制器。这里由CCTransitionSlideInL 派生。
class CC_DLL CCTransitionSlideInR : public CCTransitionSlideInL
{
public:
//构造
CCTransitionSlideInR();
//析构
virtual ~CCTransitionSlideInR();
//初始化场景
virtual void initScenes(void);
//返回所用的时间动画。
virtual CCActionInterval* action(void);
//新老创建函数。
TRANSITION_CREATE_FUNC(CCTransitionSlideInR);
OLD_TRANSITION_CREATE_FUNC(CCTransitionSlideInR);
protected:
//场景排序
virtual void sceneOrder();
};
对应CPP：
//构造
CCTransitionSlideInR::CCTransitionSlideInR()
{
}
//析构
CCTransitionSlideInR::~CCTransitionSlideInR()
{
}
//场景排序
void CCTransitionSlideInR::sceneOrder()
{
m_bIsInSceneOnTop = true;
}
//初始化场景
void CCTransitionSlideInR::initScenes()
{
//取得屏幕大小。
CCSize s = CCDirector::sharedDirector()->getWinSize();
//设置新场景的初始位置。
m_pInScene->setPosition( ccp(s.width-ADJUST_FACTOR,0) );
}
//返回所用的时间动画。
CCActionInterval* CCTransitionSlideInR:: action()
{
//创建一个从当前位置横向移动指定距离的动画。
CCSize s = CCDirector::sharedDirector()->getWinSize();
return CCMoveBy::create(m_fDuration, ccp(-(s.width-ADJUST_FACTOR),0));
}
//从屏幕下边移动新场景进来并推动旧场景离开屏幕的场景切换控制器。这里由CCTransitionSlideInL派生。
class CC_DLL CCTransitionSlideInB : public CCTransitionSlideInL
{
public:
//构造
CCTransitionSlideInB();
//析构
virtual ~CCTransitionSlideInB();
//初始化场景
virtual void initScenes(void);
//返回所用的时间动画。
virtual CCActionInterval* action(void);
//新老创建函数。
TRANSITION_CREATE_FUNC(CCTransitionSlideInB);
OLD_TRANSITION_CREATE_FUNC(CCTransitionSlideInB);
protected:
//场景排序。
virtual void sceneOrder();
};
对应CPP：
//构造
CCTransitionSlideInB::CCTransitionSlideInB()
{
}
//析构
CCTransitionSlideInB::~CCTransitionSlideInB()
{
}
//场景排序。
void CCTransitionSlideInB::sceneOrder()
{
m_bIsInSceneOnTop = true;
}
//初始化场景.
void CCTransitionSlideInB:: initScenes()
{
//取得屏幕大小。
CCSize s = CCDirector::sharedDirector()->getWinSize();
//设置新场景的初始位置。
m_pInScene->setPosition( ccp(0,-(s.height-ADJUST_FACTOR)) );
}
//返回所用的时间动画。
CCActionInterval* CCTransitionSlideInB::action()
{
//创建一个从当前位置纵向移动指定距离的动画。
CCSize s = CCDirector::sharedDirector()->getWinSize();
return CCMoveBy::create(m_fDuration, ccp(0,s.height-ADJUST_FACTOR));
}
//从屏幕上边移动新场景进来并推动旧场景离开屏幕的场景切换控制器。这里由CCTransitionSlideInL派生。
class CC_DLL CCTransitionSlideInT : public CCTransitionSlideInL
{
public:
//构造
CCTransitionSlideInT();
//析构
virtual ~CCTransitionSlideInT();
//初始化场景。
virtual void initScenes(void);
//返回所用的时间动画。
virtual CCActionInterval* action(void);
//新老创建函数。
TRANSITION_CREATE_FUNC(CCTransitionSlideInT);
OLD_TRANSITION_CREATE_FUNC(CCTransitionSlideInT);
protected:
//场景排序
virtual void sceneOrder();
};
对应CPP：
//构造
CCTransitionSlideInT::CCTransitionSlideInT()
{
}
//析构
CCTransitionSlideInT::~CCTransitionSlideInT()
{
}
//场景排序
void CCTransitionSlideInT::sceneOrder()
{
m_bIsInSceneOnTop = false;
}
//初始化场景
void CCTransitionSlideInT::initScenes()
{
//取得屏幕大小。
CCSize s = CCDirector::sharedDirector()->getWinSize();
//设置新场景的初始位置。
m_pInScene->setPosition( ccp(0,s.height-ADJUST_FACTOR) );
}
//返回所用的时间动画。
CCActionInterval* CCTransitionSlideInT::action()
{
//创建一个从当前位置纵向移动指定距离的动画。
CCSize s = CCDirector::sharedDirector()->getWinSize();
return CCMoveBy::create(m_fDuration, ccp(0,-(s.height-ADJUST_FACTOR)));
}
//环绕切换场景的场景切换控制器。
class CC_DLL CCTransitionShrinkGrow : public CCTransitionScene , public CCTransitionEaseScene
{
public:
//构造
CCTransitionShrinkGrow();
//析构
virtual ~CCTransitionShrinkGrow();
//加载场景切换控制器时调用的函数。
virtual void onEnter();
//由指定的时间动画创建相应的变速动画。
virtual CCActionInterval* easeActionWithAction(CCActionInterval * action);
//新老创建函数.
TRANSITION_CREATE_FUNC(CCTransitionShrinkGrow);
OLD_TRANSITION_CREATE_FUNC(CCTransitionShrinkGrow);
};
对应CPP:
//构造
CCTransitionShrinkGrow::CCTransitionShrinkGrow()
{
}
//析构
CCTransitionShrinkGrow::~CCTransitionShrinkGrow()
{
}
//加载场景切换控制器时调用的函数。
void CCTransitionShrinkGrow::onEnter()
{
//调用基类的相应函数。
CCTransitionScene::onEnter();
//设置新场景原始缩放值为0.001
m_pInScene->setScale(0.001f);
//设置旧场景原始缩放值为1.0
m_pOutScene->setScale(1.0f);
//设置锚点。
m_pInScene->setAnchorPoint(ccp(2/3.0f,0.5f));
m_pOutScene->setAnchorPoint(ccp(1/3.0f,0.5f));
//创建新旧场景所用的缩放动画。
CCActionInterval* scaleOut = CCScaleTo::create(m_fDuration, 0.01f);
CCActionInterval* scaleIn = CCScaleTo::create(m_fDuration, 1.0f);
//让新场景运行一个变速缩放动画。
m_pInScene->runAction(this->easeActionWithAction(scaleIn));
//让旧场景运行一个动画序列。先变速缩放再调用finish函数。
m_pOutScene->runAction
(
CCSequence::create
(
this->easeActionWithAction(scaleOut),
CCCallFunc::create(this, callfunc_selector(CCTransitionScene::finish)),
NULL
)
);
}
//由指定的时间动画创建相应的变速动画。
CCActionInterval* CCTransitionShrinkGrow:: easeActionWithAction(CCActionInterval* action)
{
//由CCEaseOut变速曲线生成变速动画，可参加变速动画深入解析一章。
return CCEaseOut::create(action, 2.0f);
// return [EaseElasticOut actionWithAction:action period:0.3f];
}
//绕X轴翻转切换场景的场景切换控制器。
class CC_DLL CCTransitionFlipX : public CCTransitionSceneOriented
{
public:
//构造
CCTransitionFlipX();
//析构
virtual ~CCTransitionFlipX();
//加载场景切换控制器时调用的函数。
virtual void onEnter();
//创建一个绕X轴翻转切换场景的场景切换控制器。内部调用create实现，参一为动画时长，数二为要切换到的场景，参数三为翻转的方向。
CC_DEPRECATED_ATTRIBUTE static CCTransitionFlipX* transitionWithDuration(float t, CCScene* s, tOrientation o = kOrientationRightOver);
//上面的create实现。
static CCTransitionFlipX* create(float t, CCScene* s, tOrientation o = kOrientationRightOver);
};
对应CPP：
//构造
CCTransitionFlipX::CCTransitionFlipX()
{
}
//析构
CCTransitionFlipX::~CCTransitionFlipX()
{
}
//加载场景切换控制器时调用的函数。
void CCTransitionFlipX::onEnter()
{
//调用基类的相应函数。
CCTransitionSceneOriented::onEnter();
//创建临时指针变量来保存生成的时间动画。
CCActionInterval *inA, *outA;
//新场景初始时设为不显示。
m_pInScene->setVisible(false);
//定义变量保存起始角度和结束角度。
float inDeltaZ, inAngleZ;
float outDeltaZ, outAngleZ;
//如果是从右向左翻转。
if( m_eOrientation == kOrientationRightOver )
{
inDeltaZ = 90;
inAngleZ = 270;
outDeltaZ = 90;
outAngleZ = 0;
}
else
{ //从左向右翻转。
inDeltaZ = -90;
inAngleZ = 90;
outDeltaZ = -90;
outAngleZ = 0;
}
//创建出供新场景使用的相应的时间动画。
inA = (CCActionInterval*)CCSequence::create
(
//这个动画在前1/2时长内处于等待状态，然后使自已显示出来，再然后1/2时长运行摄像机动画表现出翻转效果（可参看Actions“三板斧”之三的ActionOrbit的摄像机动画原理），最后调用finish函数。
CCDelayTime::create(m_fDuration/2),
CCShow::create(),
CCOrbitCamera::create(m_fDuration/2, 1, 0, inAngleZ, inDeltaZ, 0, 0),
CCCallFunc::create(this, callfunc_selector(CCTransitionScene::finish)),
NULL
);
//创建出供旧场景使用的相应的时间动画。
outA = (CCActionInterval *)CCSequence::create
( //这个动画在前1/2时长运行摄像机动画表现出翻转效果，然后使自已隐藏起来，再然后1/2时长内处于等待状态，最后调用finish函数。
CCOrbitCamera::create(m_fDuration/2, 1, 0, outAngleZ, outDeltaZ, 0, 0),
CCHide::create(),
CCDelayTime::create(m_fDuration/2),
NULL
);
//新老场景分别运行相应的动画。
m_pInScene->runAction(inA);
m_pOutScene->runAction(outA);
}
//创建一个绕X轴翻转切换场景的场景切换控制器。内部调用create实现，参一为动画时长，数二为要切换到的场景，参数三为切换的方向。
CCTransitionFlipX* CCTransitionFlipX::transitionWithDuration(float t, CCScene* s, tOrientation o)
{
return CCTransitionFlipX::create(t, s, o);
}
//上面的create实现。
CCTransitionFlipX* CCTransitionFlipX::create(float t, CCScene* s, tOrientation o)
{
//创建出相应的动画，并初始化后交由内存管理器进行引用计数管理。
CCTransitionFlipX* pScene = new CCTransitionFlipX();
pScene->initWithDuration(t, s, o);
pScene->autorelease();
//返回创建成功的场景切换控制器。
return pScene;
}
//绕Y轴翻转切换场景的场景切换控制器。
class CC_DLL CCTransitionFlipY : public CCTransitionSceneOriented
{
public:
//构造
CCTransitionFlipY();
//析构
virtual ~CCTransitionFlipY();
//加载场景切换控制器时调用的函数。
virtual void onEnter();
//新老创建函数。
CC_DEPRECATED_ATTRIBUTE static CCTransitionFlipY* transitionWithDuration(float t, CCScene* s, tOrientation o = kOrientationUpOver);
//上面的create实现。
static CCTransitionFlipY* create(float t, CCScene* s, tOrientation o = kOrientationUpOver);
};
对应CPP：
//构造
CCTransitionFlipY::CCTransitionFlipY()
{
}
//析构
CCTransitionFlipY::~CCTransitionFlipY()
{
}
//加载场景切换控制器时调用的函数。
void CCTransitionFlipY::onEnter()
{
//调用基类的相应函数。
CCTransitionSceneOriented::onEnter();
//创建临时指针变量来保存生成的时间动画。
CCActionInterval *inA, *outA;
//新场景初始时设为不显示。
m_pInScene->setVisible(false);
//定义变量保存起始角度和结束角度。
float inDeltaZ, inAngleZ;
float outDeltaZ, outAngleZ;
//如果是从上向下翻转。
if( m_eOrientation == kOrientationUpOver )
{
inDeltaZ = 90;
inAngleZ = 270;
outDeltaZ = 90;
outAngleZ = 0;
}
else
{
//如果是从下向上翻转。
inDeltaZ = -90;
inAngleZ = 90;
outDeltaZ = -90;
outAngleZ = 0;
}
//创建出供新场景使用的相应的时间动画。
inA = (CCActionInterval*)CCSequence::create
(
//这个动画在前1/2时长内处于等待状态，然后使自已显示出来，再然后1/2时长运行摄像机动画表现出翻转效果（可参看Actions“三板斧”之三的ActionOrbit的摄像机动画原理,这里注意要先让摄像机绕横向轴转动90度），最后调用finish函数。
CCDelayTime::create(m_fDuration/2),
CCShow::create(),
CCOrbitCamera::create(m_fDuration/2, 1, 0, inAngleZ, inDeltaZ, 90, 0),
CCCallFunc::create(this, callfunc_selector(CCTransitionScene::finish)),
NULL
);
//创建出供旧场景使用的相应的时间动画。
outA = (CCActionInterval*)CCSequence::create
(
//这个动画在前1/2时长运行摄像机动画表现出翻转效果，然后使自已隐藏起来，再然后1/2时长内处于等待状态（可参看Actions“三板斧”之三的ActionOrbit的摄像机动画原理,这里注意要先让摄像机绕横向轴转动90度），最后调用finish函数。
CCOrbitCamera::create(m_fDuration/2, 1, 0, outAngleZ, outDeltaZ, 90, 0),
CCHide::create(),
CCDelayTime::create(m_fDuration/2),
NULL
);
//新老场景分别运行相应的动画。
m_pInScene->runAction(inA);
m_pOutScene->runAction(outA);
}
//创建一个绕X轴翻转切换场景的场景切换控制器。内部调用create实现，参一为动画时长，数二为要切换到的场景，参数三为翻转的方向。
CCTransitionFlipY* CCTransitionFlipY::transitionWithDuration(float t, CCScene* s, tOrientation o)
{
return CCTransitionFlipY::create(t, s, o);
}
//上面的create实现。
CCTransitionFlipY* CCTransitionFlipY::create(float t, CCScene* s, tOrientation o)
{
//创建出相应的动画，并初始化后交由内存管理器进行引用计数管理。
CCTransitionFlipY* pScene = new CCTransitionFlipY();
pScene->initWithDuration(t, s, o);
pScene->autorelease();
//返回创建成功的场景切换控制器。
return pScene;
}
//绕左下右上对角线翻转切换场景的场景切换控制器。
class CC_DLL CCTransitionFlipAngular : public CCTransitionSceneOriented
{
public:
//构造
CCTransitionFlipAngular();
//析构
virtual ~CCTransitionFlipAngular();
//加载场景切换控制器时调用的函数。
virtual void onEnter();
//创建一个绕左下右上对角线翻转切换场景的场景切换控制器。内部调用create实现。参一是动画时长，参二为要切换到的场景，参三为翻转方向。
CC_DEPRECATED_ATTRIBUTE static CCTransitionFlipAngular* transitionWithDuration(float t, CCScene* s, tOrientation o = kOrientationRightOver);
//上面的create实现。
static CCTransitionFlipAngular* create(float t, CCScene* s, tOrientation o = kOrientationRightOver);
};
对应CPP：
//构造
CCTransitionFlipAngular::CCTransitionFlipAngular()
{
}
//析构
CCTransitionFlipAngular::~CCTransitionFlipAngular()
{
}
//加载场景切换控制器时调用的函数。
void CCTransitionFlipAngular::onEnter()
{
//调用基类的相应函数。
CCTransitionSceneOriented::onEnter();
//创建临时指针变量来保存生成的时间动画。
CCActionInterval *inA, *outA;
//新场景初始时设为不显示。
m_pInScene->setVisible(false);
//定义变量保存起始角度和结束角度。
float inDeltaZ, inAngleZ;
float outDeltaZ, outAngleZ;
//如果是从右向左翻转。
if( m_eOrientation == kOrientationRightOver )
{
inDeltaZ = 90;
inAngleZ = 270;
outDeltaZ = 90;
outAngleZ = 0;
}
else
{ //如果是从左向右翻转。
inDeltaZ = -90;
inAngleZ = 90;
outDeltaZ = -90;
outAngleZ = 0;
}
//创建出供新场景使用的相应的时间动画。
inA = (CCActionInterval *)CCSequence::create
(
//这个动画在前1/2时长内处于等待状态，然后使自已显示出来，再然后1/2时长运行摄像机动画表现出翻转效果（可参看Actions“三板斧”之三的ActionOrbit的摄像机动画原理,这里注意要先让摄像机绕横向轴转动-45度），最后调用finish函数。
CCDelayTime::create(m_fDuration/2),
CCShow::create(),
CCOrbitCamera::create(m_fDuration/2, 1, 0, inAngleZ, inDeltaZ, -45, 0),
CCCallFunc::create(this, callfunc_selector(CCTransitionScene::finish)),
NULL
);
//创建出供旧场景使用的相应的时间动画。
outA = (CCActionInterval *)CCSequence::create
(
//这个动画在前1/2时长运行摄像机动画表现出翻转效果（可参看Actions“三板斧”之三的ActionOrbit的摄像机动画原理,这里注意要先让摄像机绕横向轴转动45度），然后使自已隐藏起来，再然后1/2时长内处于等待状态，最后调用finish函数。
CCOrbitCamera::create(m_fDuration/2, 1, 0, outAngleZ, outDeltaZ, 45, 0),
CCHide::create(),
CCDelayTime::create(m_fDuration/2),
NULL
);
//新老场景分别运行相应的动画。
m_pInScene->runAction(inA);
m_pOutScene->runAction(outA);
}
//创建一个绕左下右上对角线翻转切换场景的场景切换控制器。内部调用create实现。参一是动画时长，参二为要切换到的场景，参三为翻转方向。
CCTransitionFlipAngular* CCTransitionFlipAngular::transitionWithDuration(float t, CCScene* s, tOrientation o)
{
return CCTransitionFlipAngular::create(t, s, o);
}
//上面的create实现。
CCTransitionFlipAngular* CCTransitionFlipAngular::create(float t, CCScene* s, tOrientation o)
{
//创建出相应的动画，并初始化后交由内存管理器进行引用计数管理。
CCTransitionFlipAngular* pScene = new CCTransitionFlipAngular();
pScene->initWithDuration(t, s, o);
pScene->autorelease();
//返回创建成功的场景切换控制器。
return pScene;
}
//绕X轴翻转并缩放切换场景的场景切换控制器。
class CC_DLL CCTransitionZoomFlipX : public CCTransitionSceneOriented
{
public:
//构造
CCTransitionZoomFlipX();
//析构
virtual ~CCTransitionZoomFlipX();
//加载场景切换控制器时调用的函数。
virtual void onEnter();
//创建一个绕X轴翻转并缩放切换场景的场景切换控制器。
参一是动画时长，参二为要切换到的场景，参三为翻转方向。
CC_DEPRECATED_ATTRIBUTE static CCTransitionZoomFlipX* transitionWithDuration(float t, CCScene* s, tOrientation o = kOrientationRightOver);
//上面的create实现。
static CCTransitionZoomFlipX* create(float t, CCScene* s, tOrientation o = kOrientationRightOver);
};
对应CPP：
//构造
CCTransitionZoomFlipX::CCTransitionZoomFlipX()
{
}
//析构
CCTransitionZoomFlipX::~CCTransitionZoomFlipX()
{
}
//加载场景切换控制器时调用的函数。
void CCTransitionZoomFlipX::onEnter()
{
//调用基类的相应函数。
CCTransitionSceneOriented::onEnter();
//创建临时指针变量来保存生成的时间动画。
CCActionInterval *inA, *outA;
//新场景初始时设为不显示。
m_pInScene->setVisible(false);
//定义变量保存起始角度和结束角度。
float inDeltaZ, inAngleZ;
float outDeltaZ, outAngleZ;
//从右往左翻转。
if( m_eOrientation == kOrientationRightOver ) {
inDeltaZ = 90;
inAngleZ = 270;
outDeltaZ = 90;
outAngleZ = 0;
}
else
{
inDeltaZ = -90;
inAngleZ = 90;
outDeltaZ = -90;
outAngleZ = 0;
}
//创建出供新场景使用的相应的时间动画。
inA = (CCActionInterval *)CCSequence::create
(
//这个动画在前1/2时长内处于等待状态，然后使自已显示出来，再然后1/2时长运行摄像机动画表现出翻转效果（可参看Actions“三板斧”之三的ActionOrbit的摄像机动画原理）同时要缩放到原始大小并显示，最后调用finish函数。
CCDelayTime::create(m_fDuration/2),
CCSpawn::create
(
CCOrbitCamera::create(m_fDuration/2, 1, 0, inAngleZ, inDeltaZ, 0, 0),
CCScaleTo::create(m_fDuration/2, 1),
CCShow::create(),
NULL
),
CCCallFunc::create(this, callfunc_selector(CCTransitionScene::finish)),
NULL
);
//创建出供旧场景使用的相应的时间动画。
outA = (CCActionInterval *)CCSequence::create
(
//这个动画在前1/2时长运行摄像机动画表现出翻转效果并同时缩放到0.5倍大小，然后使自已隐藏起来，再然后1/2时长内处于等待状态，最后调用finish函数。
CCSpawn::create
(
CCOrbitCamera::create(m_fDuration/2, 1, 0, outAngleZ, outDeltaZ, 0, 0),
CCScaleTo::create(m_fDuration/2, 0.5f),
NULL
),
CCHide::create(),
CCDelayTime::create(m_fDuration/2),
NULL
);
//设置新场景缩放值为0.5
m_pInScene->setScale(0.5f);
//新老场景运行相应的动画。
m_pInScene->runAction(inA);
m_pOutScene->runAction(outA);
}
//创建一个绕X轴翻转并缩放切换场景的场景切换控制器。
参一是动画时长，参二为要切换到的场景，参三为翻转方向。
CCTransitionZoomFlipX* CCTransitionZoomFlipX::transitionWithDuration(float t, CCScene* s, tOrientation o)
{
return CCTransitionZoomFlipX::create(t, s, o);
}
//上面的create函数。
CCTransitionZoomFlipX* CCTransitionZoomFlipX::create(float t, CCScene* s, tOrientation o)
{
//创建出相应的动画，并初始化后交由内存管理器进行引用计数管理。
CCTransitionZoomFlipX* pScene = new CCTransitionZoomFlipX();
pScene->initWithDuration(t, s, o);
pScene->autorelease();
//返回创建成功的场景切换控制器。
return pScene;
}
//绕X轴翻转并缩放切换场景的场景切换控制器。
class CC_DLL CCTransitionZoomFlipY : public CCTransitionSceneOriented
{
public:
//构造
CCTransitionZoomFlipY();
//析构
virtual ~CCTransitionZoomFlipY();
//加载场景切换控制器时调用的函数。
virtual void onEnter();
//创建一个绕Y轴翻转并缩放切换场景的场景切换控制器。内部调用create实现，参一为动画时长，参二为要切换到的场景，参三为翻转方向。
CC_DEPRECATED_ATTRIBUTE static CCTransitionZoomFlipY* transitionWithDuration(float t, CCScene* s, tOrientation o = kOrientationUpOver);
//上面的create实现。
static CCTransitionZoomFlipY* create(float t, CCScene* s, tOrientation o = kOrientationUpOver);
};
对应CPP：
//构造
CCTransitionZoomFlipY::CCTransitionZoomFlipY()
{
}
//析构
CCTransitionZoomFlipY::~CCTransitionZoomFlipY()
{
}
//加载场景切换控制器时调用的函数。
void CCTransitionZoomFlipY::onEnter()
{
//调用基类的相应函数。
CCTransitionSceneOriented::onEnter();
//创建临时指针变量来保存生成的时间动画。
CCActionInterval *inA, *outA;
//新场景初始时设为不显示。
m_pInScene->setVisible(false);
//定义变量保存起始角度和结束角度。
float inDeltaZ, inAngleZ;
float outDeltaZ, outAngleZ;
//如果方向为从上到下翻转。
if( m_eOrientation== kOrientationUpOver ) {
inDeltaZ = 90;
inAngleZ = 270;
outDeltaZ = 90;
outAngleZ = 0;
} else {
//方向为从下到上翻转。
inDeltaZ = -90;
inAngleZ = 90;
outDeltaZ = -90;
outAngleZ = 0;
}
//创建出供新场景使用的相应的时间动画。
inA = (CCActionInterval *)CCSequence::create
(
//这个动画在前1/2时长内处于等待状态，然后使自已显示出来，再然后1/2时长运行摄像机动画表现出翻转效果（可参看Actions“三板斧”之三的ActionOrbit的摄像机动画原理）同时要缩放到原始大小并显示，最后调用finish函数。
CCDelayTime::create(m_fDuration/2),
CCSpawn::create
(
CCOrbitCamera::create(m_fDuration/2, 1, 0, inAngleZ, inDeltaZ, 90, 0),
CCScaleTo::create(m_fDuration/2, 1),
CCShow::create(),
NULL
),
CCCallFunc::create(this, callfunc_selector(CCTransitionScene::finish)),
NULL
);
//创建出供旧场景使用的相应的时间动画。
outA = (CCActionInterval *)CCSequence::create
(
//这个动画在前1/2时长运行摄像机动画表现出翻转效果并同时缩放到0.5倍大小，然后使自已隐藏起来，再然后1/2时长内处于等待状态，最后调用finish函数。
CCSpawn::create
(
CCOrbitCamera::create(m_fDuration/2, 1, 0, outAngleZ, outDeltaZ, 90, 0),
CCScaleTo::create(m_fDuration/2, 0.5f),
NULL
),
CCHide::create(),
CCDelayTime::create(m_fDuration/2),
NULL
);
//设置新场景缩放值为0.5
m_pInScene->setScale(0.5f);
//新老场景运行相应的动画。
m_pInScene->runAction(inA);
m_pOutScene->runAction(outA);
}
//创建一个绕Y轴翻转并缩放切换场景的场景切换控制器。内部调用create实现，参一为动画时长，参二为要切换到的场景，参三为翻转方向。
CCTransitionZoomFlipY* CCTransitionZoomFlipY::transitionWithDuration(float t, CCScene* s, tOrientation o)
{
return CCTransitionZoomFlipY::create(t, s, o);
}
//上面的create实现。
CCTransitionZoomFlipY* CCTransitionZoomFlipY::create(float t, CCScene* s, tOrientation o)
{
//创建出相应的动画，并初始化后交由内存管理器进行引用计数管理。
CCTransitionZoomFlipY* pScene = new CCTransitionZoomFlipY();
pScene->initWithDuration(t, s, o);
pScene->autorelease();
//返回创建成功的场景切换控制器。
return pScene;
}
//绕左下右上对角线翻转并缩放切换场景的场景切换控制器。
class CC_DLL CCTransitionZoomFlipAngular : public CCTransitionSceneOriented
{
public:
//构造
CCTransitionZoomFlipAngular();
//析构
virtual ~CCTransitionZoomFlipAngular();
//加载场景切换控制器时调用的函数。
virtual void onEnter();
//创建一个绕左下右上对角线翻转并缩放切换场景的场景切换控制器。内部调用create实现，参一为动画时长，参二为要切换到的场景，参三为翻转方向。
CC_DEPRECATED_ATTRIBUTE static CCTransitionZoomFlipAngular* transitionWithDuration(float t, CCScene* s, tOrientation o = kOrientationRightOver);
//上面的create实现。
static CCTransitionZoomFlipAngular* create(float t, CCScene* s, tOrientation o = kOrientationRightOver);
};
对应CPP：
//构造
CCTransitionZoomFlipAngular::CCTransitionZoomFlipAngular()
{
}
//析构
CCTransitionZoomFlipAngular::~CCTransitionZoomFlipAngular()
{
}
//加载场景切换控制器时调用的函数。
void CCTransitionZoomFlipAngular::onEnter()
{
//调用基类的相应函数。
CCTransitionSceneOriented::onEnter();
//创建临时指针变量来保存生成的时间动画。
CCActionInterval *inA, *outA;
//新场景初始时设为不显示。
m_pInScene->setVisible(false);
//定义变量保存起始角度和结束角度。
float inDeltaZ, inAngleZ;
float outDeltaZ, outAngleZ;
//如果方向为从右到左翻转。
if( m_eOrientation == kOrientationRightOver ) {
inDeltaZ = 90;
inAngleZ = 270;
outDeltaZ = 90;
outAngleZ = 0;
}
else
{
//如果方向为从左到右翻转。
inDeltaZ = -90;
inAngleZ = 90;
outDeltaZ = -90;
outAngleZ = 0;
}
//创建出供新场景使用的相应的时间动画。
inA = (CCActionInterval *)CCSequence::create
(
//这个动画在前1/2时长内处于等待状态，然后使自已显示出来，再然后1/2时长运行摄像机动画表现出翻转效果（可参看Actions“三板斧”之三的ActionOrbit的摄像机动画原理）同时要缩放到原始大小并显示，最后调用finish函数。
CCDelayTime::create(m_fDuration/2),
CCSpawn::create
(
CCOrbitCamera::create(m_fDuration/2, 1, 0, inAngleZ, inDeltaZ, -45, 0),
CCScaleTo::create(m_fDuration/2, 1),
CCShow::create(),
NULL
),
CCShow::create(),//这个貌似无用
CCCallFunc::create(this, callfunc_selector(CCTransitionScene::finish)),
NULL
);
//创建出供旧场景使用的相应的时间动画。
outA = (CCActionInterval *)CCSequence::create
(
//这个动画在前1/2时长运行摄像机动画表现出翻转效果并同时缩放到0.5倍大小，然后使自已隐藏起来，再然后1/2时长内处于等待状态，最后调用finish函数。
CCSpawn::create
(
CCOrbitCamera::create(m_fDuration/2, 1, 0 , outAngleZ, outDeltaZ, 45, 0),
CCScaleTo::create(m_fDuration/2, 0.5f),
NULL
),
CCHide::create(),
CCDelayTime::create(m_fDuration/2),
NULL
);
//设置新场景缩放值为0.5
m_pInScene->setScale(0.5f);
//新老场景运行相应的动画。
m_pInScene->runAction(inA);
m_pOutScene->runAction(outA);
}
//创建一个绕左下右上对角线翻转并缩放切换场景的场景切换控制器。内部调用create实现，参一为动画时长，参二为要切换到的场景，参三为翻转方向。
CCTransitionZoomFlipAngular* CCTransitionZoomFlipAngular::transitionWithDuration(float t, CCScene* s, tOrientation o)
{
return CCTransitionZoomFlipAngular::create(t, s, o);
}
//上面的create实现。
CCTransitionZoomFlipAngular* CCTransitionZoomFlipAngular::create(float t, CCScene* s, tOrientation o)
{
//创建出相应的动画，并初始化后交由内存管理器进行引用计数管理。
CCTransitionZoomFlipAngular* pScene = new CCTransitionZoomFlipAngular();
pScene->initWithDuration(t, s, o);
pScene->autorelease();
//返回创建成功的场景切换控制器。
return pScene;
}
//淡入淡出(亮度渐变到黑，再渐变到白)切换场景的场景切换控制器。
class CC_DLL CCTransitionFade : public CCTransitionScene
{
protected:
//色彩值
ccColor4B m_tColor;
public:
//构造
CCTransitionFade();
//析构
virtual ~CCTransitionFade();
//创建一个淡入淡出切换场景的场景切换控制器。内部调用create实现。参一为动画时长，参二为要切换到的场景，参三为初始色彩。
CC_DEPRECATED_ATTRIBUTE static CCTransitionFade* transitionWithDuration(float duration,CCScene* scene, const ccColor3B& color = ccBLACK);
//上面的create实现。
static CCTransitionFade* create(float duration,CCScene* scene, const ccColor3B& color = ccBLACK);
//初始化动画。
virtual bool initWithDuration(float t, CCScene*scene ,const ccColor3B& color);
///初始化动画。
virtual bool initWithDuration(float t,CCScene* scene);
//加载场景切换控制器时调用的函数。
virtual void onEnter();
//卸载场景切换控制器时调用的函数。
virtual void onExit();
};
对应CPP：
//构造
CCTransitionFade::CCTransitionFade()
{
}
//析构
CCTransitionFade::~CCTransitionFade()
{
}
//创建一个淡入淡出切换场景的场景切换控制器。内部调用create实现。参一为动画时长，参二为要切换到的场景，参三为初始色彩。
CCTransitionFade * CCTransitionFade::transitionWithDuration(float duration, CCScene *scene, const ccColor3B& color)
{
return CCTransitionFade::create(duration, scene, color);
}
//上面的create实现。
CCTransitionFade * CCTransitionFade::create(float duration, CCScene *scene, const ccColor3B& color)
{
//创建，初始化，交由内存管理器进行引用计数器的管理，返回。
CCTransitionFade * pTransition = new CCTransitionFade();
pTransition->initWithDuration(duration, scene, color);
pTransition->autorelease();
return pTransition;
}
//初始化。
bool CCTransitionFade::initWithDuration(float duration, CCScene *scene, const ccColor3B& color)
{
//调用基类的相应初始化函数。
if (CCTransitionScene::initWithDuration(duration, scene))
{
m_tColor.r = color.r;
m_tColor.g = color.g;
m_tColor.b = color.b;
m_tColor.a = 0;
}
return true;
}
//初始化。
bool CCTransitionFade::initWithDuration(float t, CCScene *scene)
{
//使用黑色来调用上面的初始化函数。
this->initWithDuration(t, scene, ccBLACK);
return true;
}
//加载场景切换控制器时调用的函数。
void CCTransitionFade :: onEnter()
{
//调用基类的相应函数。
CCTransitionScene::onEnter();
//创建一个色块层
CCLayerColor* l = CCLayerColor::create(m_tColor);
//设置新场景初始不显示。
m_pInScene->setVisible(false);
//将色块层加入当前场景中，设置tag为kSceneFade。
addChild(l, 2, kSceneFade);
//通过tag值取得子结点，返回给f。这个f指向的仍是色层l。
CCNode* f = getChildByTag(kSceneFade);
//创建一个序列动画。
CCActionInterval* a = (CCActionInterval *)CCSequence::create
(
//先运行淡入动画，时长为总时长的1/2。然后调用隐藏旧场景，显示新场景的函数，再运行淡出动画，时长为总时长的1/2，最后调用finish函数。
CCFadeIn::create(m_fDuration/2),
CCCallFunc::create(this, callfunc_selector(CCTransitionScene::hideOutShowIn)),//CCCallFunc::create:self selector:@selector(hideOutShowIn)],
CCFadeOut::create(m_fDuration/2),
CCCallFunc::create(this, callfunc_selector(CCTransitionScene::finish)), //:self selector:@selector(finish)],
NULL
);
//让f运行这个动画。
f->runAction(a);
}
//卸载场景切换控制器时调用的函数。
void CCTransitionFade::onExit()
{
CCTransitionScene::onExit();
//将kSceneFade指定的层删除。
this->removeChildByTag(kSceneFade, false);
}
//渲染纹理类。
class CCRenderTexture;
//融合方式切换场景的场景切换控制器。
class CC_DLL CCTransitionCrossFade : public CCTransitionScene
{
public :
//构造
CCTransitionCrossFade();
//析构
virtual ~CCTransitionCrossFade();
//绘制函数。
virtual void draw();
//加载场景切换控制器时调用的函数。
virtual void onEnter();
//卸载场景切换控制器时调用的函数。
virtual void onExit();
public:
//新老创建函数。
TRANSITION_CREATE_FUNC(CCTransitionCrossFade);
OLD_TRANSITION_CREATE_FUNC(CCTransitionCrossFade);
};
对应CPP：
//构造
CCTransitionCrossFade::CCTransitionCrossFade()
{
}
//析构
CCTransitionCrossFade::~CCTransitionCrossFade()
{
}
//绘制函数。
void CCTransitionCrossFade::draw()
{
// override draw since both scenes (textures) are rendered in 1 scene
}
//加载场景切换控制器时调用的函数。
void CCTransitionCrossFade::onEnter()
{
//调用基类的相应函数。
CCTransitionScene::onEnter();
//创建一个透明的层。
ccColor4B color = {0,0,0,0};
CCSize size = CCDirector::sharedDirector()->getWinSize();
CCLayerColor* layer = CCLayerColor::create(color);
// 创建一个用于“渲染到纹理”的纹理对象，大小为屏幕大小。
CCRenderTexture* inTexture = CCRenderTexture::create((int)size.width, (int)size.height);
if (NULL == inTexture)
{
return;
}
//设置纹理对象成员精灵的锚点。
inTexture->getSprite()->setAnchorPoint( ccp(0.5f,0.5f) );
//设置位置。
inTexture->setPosition( ccp(size.width/2, size.height/2) );
//设置纹理对象的锚点。
inTexture->setAnchorPoint( ccp(0.5f,0.5f) );
//将新场景渲染到这个纹理对象中。
inTexture->begin();
m_pInScene->visit();
inTexture->end();
// create the second render texture for outScene
// 再创建一个用于“渲染到纹理”的纹理对象，大小为屏幕大小。
CCRenderTexture* outTexture = CCRenderTexture::create((int)size.width, (int)size.height);
//设置纹理对象成员精灵的锚点。
outTexture->getSprite()->setAnchorPoint( ccp(0.5f,0.5f) );
outTexture->setPosition( ccp(size.width/2, size.height/2) );
outTexture->setAnchorPoint( ccp(0.5f,0.5f) );
//将旧场景渲染到这个纹理对象中。
outTexture->begin();
m_pOutScene->visit();
outTexture->end();
// 新场景的混合状态:做为背景，只显示自已。
ccBlendFunc blend1 = {GL_ONE, GL_ONE};
// 老场景的混合状态:与背景像素按透明度做为混合比例进行混合。
ccBlendFunc blend2 = {GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA};
//设置新老场景的混合状态。 inTexture->getSprite()->setBlendFunc(blend1);
outTexture->getSprite()->setBlendFunc(blend2);
// 将两个纹理对象放入透明层中。
layer->addChild(inTexture);
layer->addChild(outTexture);
//设置纹理对象的成员精灵的初始透明度值。
inTexture->getSprite()->setOpacity(255);
outTexture->getSprite()->setOpacity(255);
//创建一个动画序列。
CCAction* layerAction = CCSequence::create
(
//先是一个透明度变化为0的动画，然后隐藏旧场景显示新场景。最后调用finish函数。
CCFadeTo::create(m_fDuration, 0),
CCCallFunc::create(this, callfunc_selector(CCTransitionScene::hideOutShowIn)),
CCCallFunc::create(this, callfunc_selector(CCTransitionScene::finish)),
NULL
);
//旧场景运行上面的动画序列。
outTexture->getSprite()->runAction( layerAction );
// 将色层指定tag值放入当前场景。
addChild(layer, 2, kSceneFade);
}
//卸载场景切换控制器时调用的函数。
void CCTransitionCrossFade::onExit()
{
// 删除对应的结点。
this->removeChildByTag(kSceneFade, false);
CCTransitionScene::onExit();
}
//使用随机网格显示方式切换场景的场景切换控制器。
class CC_DLL CCTransitionTurnOffTiles : public CCTransitionScene ,public CCTransitionEaseScene
{
public :
//构造
CCTransitionTurnOffTiles();
//析构
virtual ~CCTransitionTurnOffTiles();
//加载场景切换控制器时调用的函数。
virtual void onEnter();
//创建对应的变速动画。
virtual CCActionInterval * easeActionWithAction(CCActionInterval * action);
public:
//新老创建函数。
TRANSITION_CREATE_FUNC(CCTransitionTurnOffTiles);
OLD_TRANSITION_CREATE_FUNC(CCTransitionTurnOffTiles);
protected:
//进行场景排序。
virtual void sceneOrder();
};
对应CPP：
//构造。
CCTransitionTurnOffTiles::CCTransitionTurnOffTiles()
{
}
//析构。
CCTransitionTurnOffTiles::~CCTransitionTurnOffTiles()
{
}
//场景排序。
void CCTransitionTurnOffTiles::sceneOrder()
{
m_bIsInSceneOnTop = false;
}
//加载场景切换控制器时调用的函数。
void CCTransitionTurnOffTiles::onEnter()
{
//调用基类的相应函数。
CCTransitionScene::onEnter();
//取得屏幕大小。
CCSize s = CCDirector::sharedDirector()->getWinSize();
float aspect = s.width / s.height;
int x = (int)(12 * aspect);
int y = 12;
//创建格子动画,(参见“网格动画深入分析”一文)。这里创建的格子大小为x,y。
CCTurnOffTiles* toff = CCTurnOffTiles::create( ccg(x,y), m_fDuration);
//由格子动画创建出来一个变速动画。
CCActionInterval* action = easeActionWithAction(toff);
//老场景运行一个动画序列。
m_pOutScene->runAction
(
CCSequence::create
(
//首先是上面的变速动画，然后调用finish函数，之后停止网格动画。
action,
CCCallFunc::create(this, callfunc_selector(CCTransitionScene::finish)),
CCStopGrid::create(),
NULL
)
);
}
//创建出相应的变速动画。
CCActionInterval* CCTransitionTurnOffTiles:: easeActionWithAction(CCActionInterval* action)
{
//不做处理，直接返回。
return action;
}
//使用网格纵向切分方式切换场景的场景切换控制器。
class CC_DLL CCTransitionSplitCols : public CCTransitionScene , public CCTransitionEaseScene
{
public:
//构造
CCTransitionSplitCols();
//析构
virtual ~CCTransitionSplitCols();
//创建相应的时间动画。
virtual CCActionInterval* action(void);
//加载场景切换控制器时调用的函数。
virtual void onEnter();
//创建相应时间动画的变速动画。
virtual CCActionInterval * easeActionWithAction(CCActionInterval * action);
public:
//新老创建函数。
TRANSITION_CREATE_FUNC(CCTransitionSplitCols);
OLD_TRANSITION_CREATE_FUNC(CCTransitionSplitCols);
};
对应CPP：
//构造函数。
CCTransitionSplitCols::CCTransitionSplitCols()
{
}
//析构函数。
CCTransitionSplitCols::~CCTransitionSplitCols()
{
}
//加载场景切换控制器时调用的函数。
void CCTransitionSplitCols::onEnter()
{
//先调用基类的相应函数。
CCTransitionScene::onEnter();
//设置新场景隐藏。
m_pInScene->setVisible(false);
//取得当前的时间动画，具体的切分动画实现在action里。
CCActionInterval* split = action();
//创建一个动画序列。
CCActionInterval* seq = (CCActionInterval*)CCSequence::create
(
//先播放上面的时间动画，然后隐藏旧场景显示新场景，最后反向播放上面的时间动画。
split,
CCCallFunc::create(this, callfunc_selector(CCTransitionScene::hideOutShowIn)),
split->reverse(),
NULL
);
//当前场景运行一个动画序列。
this->runAction
(
CCSequence::create
(
//上面动画序列的变速动画。然后调用finish，最后停止网格动画。
easeActionWithAction(seq),
CCCallFunc::create(this, callfunc_selector(CCTransitionScene::finish)),
CCStopGrid::create(),
NULL
)
);
}
//创建所用的网格切分动画。
CCActionInterval* CCTransitionSplitCols:: action()
{
//创建相应的网格切分动画,纵向切分为三分，动画时间为总时间的一半。
return CCSplitCols::create(3, m_fDuration/2.0f);
}
//创建相应动画的变速动画。
CCActionInterval* CCTransitionSplitCols::easeActionWithAction(CCActionInterval * action)
{
//这里使用CCEaseInOut变速曲线来调节动画的速度变化。
return CCEaseInOut::create(action, 3.0f);
}
//使用网格横向切分方式切换场景的场景切换控制器。
class CC_DLL CCTransitionSplitRows : public CCTransitionSplitCols
{
public:
//构造
CCTransitionSplitRows();
//析构
virtual ~CCTransitionSplitRows();
//创建相应的时间动画。
virtual CCActionInterval* action(void);
public:
//新老创建函数。
TRANSITION_CREATE_FUNC(CCTransitionSplitRows)
OLD_TRANSITION_CREATE_FUNC(CCTransitionSplitRows)
};
对应CPP：
//构造
CCTransitionSplitRows::CCTransitionSplitRows()
{
}
//析构
CCTransitionSplitRows::~CCTransitionSplitRows()
{
}
//创建相应的时间动画。
CCActionInterval* CCTransitionSplitRows::action()
{
//创建相应的网格切分动画,横向切分为三分，动画时间为总时间的一半。
return CCSplitRows::create(3, m_fDuration/2.0f);
}
//从左下向右上角网格渐隐方式切换场景的场景切换控制器。
class CC_DLL CCTransitionFadeTR : public CCTransitionScene , public CCTransitionEaseScene
{
public:
//构造
CCTransitionFadeTR();
//析构
virtual ~CCTransitionFadeTR();
//创建相应的时间动画
virtual CCActionInterval* actionWithSize(const ccGridSize& size);
//加载场景切换控制器时调用的函数。
virtual void onEnter();
//创建相应时间动画的变速动画。
virtual CCActionInterval* easeActionWithAction(CCActionInterval * action);
public:
//新老创建函数。
TRANSITION_CREATE_FUNC(CCTransitionFadeTR)
OLD_TRANSITION_CREATE_FUNC(CCTransitionFadeTR)
protected:
//场景排序。
virtual void sceneOrder();
};
对应CPP：
//构造
CCTransitionFadeTR::CCTransitionFadeTR()
{
}
//析构
CCTransitionFadeTR::~CCTransitionFadeTR()
{
}
//场景排序。
void CCTransitionFadeTR::sceneOrder()
{
//设置新场景在上面。
m_bIsInSceneOnTop = false;
}
//加载场景切换控制器时调用的函数。
void CCTransitionFadeTR::onEnter()
{
//调用基类的相应函数。
CCTransitionScene::onEnter();
//取得屏幕大小。
CCSize s = CCDirector::sharedDirector()->getWinSize();
float aspect = s.width / s.height;
int x = (int)(12 * aspect);
int y = 12;
//创建相应的网格动画。
CCActionInterval* action = actionWithSize(ccg(x,y));
//旧场景运行一个序列动画。
m_pOutScene->runAction
(
CCSequence::create
(
//先是由网格动画生成的变速动画。然后调用finish，最后停止网格动画。
easeActionWithAction(action),
CCCallFunc::create(this, callfunc_selector(CCTransitionScene::finish)),
CCStopGrid::create(),
NULL
)
);
}
//创建所用的网格动画。
CCActionInterval* CCTransitionFadeTR::actionWithSize(const ccGridSize& size)
{
//使用网格动画中的从右上角开始渐隐动画。
return CCFadeOutTRTiles::create(size, m_fDuration);
}
//创建所用网格动画的变速动画。
CCActionInterval* CCTransitionFadeTR:: easeActionWithAction(CCActionInterval* action)
{
//未做处理，直接返回了。
return action;
}
//从右上向左下角网格渐隐方式切换场景的场景切换控制器。
class CC_DLL CCTransitionFadeBL : public CCTransitionFadeTR
{
public:
//构造
CCTransitionFadeBL();
//析构
virtual ~CCTransitionFadeBL();
//创建所用的网格动画。
virtual CCActionInterval* actionWithSize(const ccGridSize& size);
public:
//新老创建函数。
TRANSITION_CREATE_FUNC(CCTransitionFadeBL)
OLD_TRANSITION_CREATE_FUNC(CCTransitionFadeBL)
};
对应CPP：
//构造
CCTransitionFadeBL::CCTransitionFadeBL()
{
}
//析构
CCTransitionFadeBL::~CCTransitionFadeBL()
{
}
//创建所用的网格动画。
CCActionInterval* CCTransitionFadeBL::actionWithSize(const ccGridSize& size)
{
//使用网格动画中的从左下角开始渐隐动画。
return CCFadeOutBLTiles::create(size, m_fDuration);
}
//从下面向上面网格渐隐方式切换场景的场景切换控制器。
class CC_DLL CCTransitionFadeUp : public CCTransitionFadeTR
{
public:
//构造
CCTransitionFadeUp();
//析构
virtual ~CCTransitionFadeUp();
//创建所用的网格动画。
virtual CCActionInterval* actionWithSize(const ccGridSize& size);
public:
//新老创建函数。
TRANSITION_CREATE_FUNC(CCTransitionFadeUp)
OLD_TRANSITION_CREATE_FUNC(CCTransitionFadeUp)
};
对应CPP：
//构造
CCTransitionFadeUp::CCTransitionFadeUp()
{
}
//析构
CCTransitionFadeUp::~CCTransitionFadeUp()
{
}
//创建所用的网格动画。
CCActionInterval* CCTransitionFadeUp::actionWithSize(const ccGridSize& size)
{
//使用网格动画中的从上面开始网格渐隐动画。
return CCFadeOutUpTiles::create(size, m_fDuration);
}
//从上面向下面网格渐隐方式切换场景的场景切换控制器。
class CC_DLL CCTransitionFadeDown : public CCTransitionFadeTR
{
public:
//构造
CCTransitionFadeDown();
//析构
virtual ~CCTransitionFadeDown();
//创建所用的网格动画。
virtual CCActionInterval* actionWithSize(const ccGridSize& size);
public:
//新老创建函数。
TRANSITION_CREATE_FUNC(CCTransitionFadeDown)
OLD_TRANSITION_CREATE_FUNC(CCTransitionFadeDown)
};
对应CPP：
//构造
CCTransitionFadeDown::CCTransitionFadeDown()
{
}
//析构
CCTransitionFadeDown::~CCTransitionFadeDown()
{
}
//创建所用的网格动画。
CCActionInterval* CCTransitionFadeDown::actionWithSize(const ccGridSize& size)
{
//使用网格动画中的从下面开始渐隐动画。
return CCFadeOutDownTiles::create(size, m_fDuration);
}
除了这些基本的场景切换动画之外，仍然有更多高级的场景切换动画。分别为基于换页方式进切换场景的动画和基于进度动画方式切换场景的动画。它们分别被放在CCTransitionPageTurn.h/cpp和CCTransitionProgress.h/cpp中。下面我们继续来学习它们。
深呼吸，然后打开CCTransitionPageTurn.h,这里只有一个类：
//换页方式切换场景的场景切换控制器。
class CC_DLL CCTransitionPageTurn : public CCTransitionScene
{
protected:
//换页的方向,朝前还是朝后换。
bool m_bBack;
public:
//构造
CCTransitionPageTurn();
//析构
virtual ~CCTransitionPageTurn();
//创建一个换页方式切换场景的场景切换控制器，内部调用create实现，参一为动画时长，参二为要切换到的场景，参三为换页的方向。
CC_DEPRECATED_ATTRIBUTE static CCTransitionPageTurn* transitionWithDuration(float t,CCScene* scene,bool backwards);
//上面的create实现。
static CCTransitionPageTurn* create(float t,CCScene* scene,bool backwards);
//初始化动画。
virtual bool initWithDuration(float t,CCScene* scene,bool backwards);
//创建相应的格子动画。
CCActionInterval* actionWithSize(const ccGridSize& vector);
//加载当前场景控制器时的处理。
virtual void onEnter();
protected:
//是否进行场景排序。
virtual void sceneOrder();
};
其对应的CPP：
//构造。
CCTransitionPageTurn::CCTransitionPageTurn()
{
}
//析构。
CCTransitionPageTurn::~CCTransitionPageTurn()
{
}
//创建一个换页方式切换场景的场景切换控制器，内部调用create实现，参一为动画时长，参二为要切换到的场景，参三为换页的方向。
CCTransitionPageTurn * CCTransitionPageTurn::transitionWithDuration(float t, CCScene *scene, bool backwards)
{
return CCTransitionPageTurn::create(t,scene,backwards);
}
//上面的create实现。
CCTransitionPageTurn * CCTransitionPageTurn::create(float t, CCScene *scene, bool backwards)
{
//先new出相应的实例，然后初始化，之后交由内存管理器进行引用计数管理，最后返回这个实例。
CCTransitionPageTurn * pTransition = new CCTransitionPageTurn();
pTransition->initWithDuration(t,scene,backwards);
pTransition->autorelease();
return pTransition;
}
//初始化。
bool CCTransitionPageTurn::initWithDuration(float t, CCScene *scene, bool backwards)
{
// 保存换页的方向。
m_bBack = backwards;
//调用基类的初始化处理。
if( CCTransitionScene::initWithDuration(t, scene) )
{
// do something
}
return true;
}
//进行场景排序。
void CCTransitionPageTurn::sceneOrder()
{
//将新场景放在上面。
m_bIsInSceneOnTop = m_bBack;
}
//加载当前场景控制器时的处理。
void CCTransitionPageTurn::onEnter()
{
//调用基类的相应函数。
CCTransitionScene::onEnter();
//取得屏幕大小。
CCSize s = CCDirector::sharedDirector()->getWinSize();
int x,y;
if( s.width > s.height)
{
x=16;
y=12;
}
else
{
x=12;
y=16;
}
//创建当前演示所用的动画。
CCActionInterval *action = this->actionWithSize(ccg(x,y));
//根据方向来运行不同的动画。
if(! m_bBack )
{
//老场景运行一个动画序列。
m_pOutScene->runAction
(
//先运行上面创建的换页动画。之后调用finish函数。最后停止格子动画。
CCSequence::create
(
action,
CCCallFunc::create(this, callfunc_selector(CCTransitionScene::finish)),
CCStopGrid::create(),
NULL
)
);
}
else
{
// 先将新场景设为隐藏，之后新场景运行一个动画序列。
m_pInScene->setVisible(false);
m_pInScene->runAction
(
//先显示，再运行上面的换页动画，之后调用finish函数，最后停止网格动画。
CCSequence::create
(
CCShow::create(),
action,
CCCallFunc::create(this, callfunc_selector(CCTransitionScene::finish)),
CCStopGrid::create(),
NULL
)
);
}
}
//创建所用的网格动画。
CCActionInterval* CCTransitionPageTurn:: actionWithSize(const ccGridSize& vector)
{
//根据方向创建相应的网格动画。这里用到一个换页类CCPageTurn3D，咱们马上后面讲。
if( m_bBack )
{
return CCReverseTime::create
(
CCPageTurn3D::create(vector, m_fDuration)
);
}
else
{
return CCPageTurn3D::create(vector, m_fDuration);
}
}
可以看到，CCPageTurn3D才是真正换页的动画实现。打破沙锅问到底~，追！
打开CCActionPageTurn3D.h中可以看到这个类：
//换页动画，由3D网格动画派生。可参看我上一章博文“网格动画深入分析”。
class CC_DLL CCPageTurn3D : public CCGrid3DAction
{
public:
//每帧更新时调用处理。
virtual void update(float time);
public:
//创建一个换页动画，内部调用create实现，参数一为网格大小，参数二为动画时长。
CC_DEPRECATED_ATTRIBUTE static CCPageTurn3D* actionWithSize(const ccGridSize& gridSize, float time);
//上面的create实现。
static CCPageTurn3D* create(const ccGridSize& gridSize, float time);
};
CPP实现：
//创建一个换页动画，内部调用create实现，参数一为网格大小，参数二为动画时长。
CCPageTurn3D* CCPageTurn3D::actionWithSize(const ccGridSize& gridSize, float time)
{
return CCPageTurn3D::create(gridSize, time);
}
//上面的create实现。
CCPageTurn3D* CCPageTurn3D::create(const ccGridSize& gridSize, float time)
{
//创建一个实例。
CCPageTurn3D *pAction = new CCPageTurn3D();
//如果成功，进行初始化并交由内存管理器进行引用计数器的管理。
if (pAction)
{
if (pAction->initWithSize(gridSize, time))
{
pAction->autorelease();
}
else
{ //如果失败，释放并置空。
CC_SAFE_RELEASE_NULL(pAction);
}
}
//返回创建的动画实例。
return pAction;
}
//核心函数，每帧调用的更新处理。
void CCPageTurn3D::update(float time)
{
//写的有点复杂，大概意思是通过一些参数计数出一个系数用来计算sin和cos值。
float tt = MAX(0, time - 0.25f);
float deltaAy = (tt * tt * 500);
float ay = -100 - deltaAy;
float deltaTheta = - (float) M_PI_2 * sqrtf( time) ;
float theta = /*0.01f */ + (float) M_PI_2 +deltaTheta;
float sinTheta = sinf(theta);
float cosTheta = cosf(theta);
//双循环遍历每个网格。
for (int i = 0; i <= m_sGridSize.x; ++i)
{
for (int j = 0; j <= m_sGridSize.y; ++j)
{
// 取得对应格子的顶点计算顶点的更新。
ccVertex3F p = originalVertex(ccg(i ,j));
//
float R = sqrtf((p.x * p.x) + ((p.y - ay) * (p.y - ay)));
float r = R * sinTheta;
float alpha = asinf( p.x / R );
float beta = alpha / sinTheta;
float cosBeta = cosf( beta );
// If beta > PI then we've wrapped around the cone
// Reduce the radius to stop these points interfering with others
if (beta <= M_PI)
{
p.x = ( r * sinf(beta));
}
else
{
// Force X = 0 to stop wrapped
// points
p.x = 0;
}
p.y = ( R + ay - ( r * (1 - cosBeta) * sinTheta));
// 对Z值的更新。
p.z = (r * ( 1 - cosBeta ) * cosTheta) / 7;// "100" didn't work for
// Stop z coord from dropping beneath underlying page in a transition
// issue #751
if( p.z < 0.5f )
{
p.z = 0.5f;
}
// 设置新的顶点数据。
setVertex(ccg(i, j), p);
}
}
}
这个换页动画讲完了，下面来看一下如何使用进度动画方式进行场景切换。打开CCTransitionProgress.h：
这里要用到以下两个类。
class CCProgressTimer;
class CCRenderTexture;
//以进度动画方式切换场景的场景切换控制器的基类。
class CC_DLL CCTransitionProgress : public CCTransitionScene
{
public:
//新老创建函数。
OLD_TRANSITION_CREATE_FUNC(CCTransitionProgress)
TRANSITION_CREATE_FUNC(CCTransitionProgress)
//构造
CCTransitionProgress();
//加载当前场景切换控制器时的处理。
virtual void onEnter();
//卸载当前场景切换控制器时的处理。
virtual void onExit();
protected:
//由“渲染到纹理”的纹理对象创建出相应的进度动画渲染器。
virtual CCProgressTimer* progressTimerNodeWithRenderTexture(CCRenderTexture* texture);
//初始化场景切换
virtual void setupTransition();
//设置场景排序。
virtual void sceneOrder();
//进度的终止值。
float m_fTo;
//进度的起始值。
float m_fFrom;
//用于保存要切换到的场景。
CCScene* m_pSceneToBeModified;
};
对应CPP：
//枚举值，用于设置相应的tag值
enum {
kCCSceneRadial = 0xc001,
};
//构造函数。
CCTransitionProgress::CCTransitionProgress()
: m_fTo(0.0f)
, m_fFrom(0.0f)
, m_pSceneToBeModified(NULL)
{
}
//加载当前场景切换控制器时的处理。
void CCTransitionProgress::onEnter()
{
//调用基类的函数。
CCTransitionScene::onEnter();
//初始化场景切换。
setupTransition();
//取得屏幕大小。
CCSize size = CCDirector::sharedDirector()->getWinSize();
// 创建一个用于“渲染到纹理”的纹理对象。
CCRenderTexture *texture = CCRenderTexture::create((int)size.width, (int)size.height);
//设置其成员的精灵的锚点。
texture->getSprite()->setAnchorPoint(ccp(0.5f,0.5f));
//设置位置。
texture->setPosition(ccp(size.width/2, size.height/2));
//设置锚点。
texture->setAnchorPoint(ccp(0.5f,0.5f));
//将场景m_pSceneToBeModified渲染到这个纹理对象上。
texture->clear(0, 0, 0, 1);
texture->begin();
m_pSceneToBeModified->visit();
texture->end();
//如果m_pSceneToBeModified是旧场景,隐藏旧场景，显示新场景。
if (m_pSceneToBeModified == m_pOutScene)
{
hideOutShowIn();
}
// 使用上面的纹理对象创建出一个进度动画渲染器来表现进动动画。(可参见之前博文《进度动画深入分析》一文)。这是很关键的一句，因为进度动画所操作的是纹理对象而不是场景，所以它不能像其它场景切换的动画是直接对场景使用一个动画，而是通过渲染了场景画面的纹理对象来表现进度动画的。
CCProgressTimer *pNode = progressTimerNodeWithRenderTexture(texture);
//创建所用的动画序列，先运行进度动画，之后调用finish。
CCActionInterval* layerAction = (CCActionInterval*)CCSequence::create(
//创建FromTo进度控制器。在指定时长内由起始值变化到终止值。
CCProgressFromTo::create(m_fDuration, m_fFrom, m_fTo),
CCCallFunc::create(this, callfunc_selector(CCTransitionProgress::finish)),
NULL);
//让进度动画渲染器运行上面的动画序列。
pNode->runAction(layerAction);
//将进度动画渲染器放入当前场景中。
addChild(pNode, 2, kCCSceneRadial);
}
//卸载当前场景切换控制器时的处理。
void CCTransitionProgress::onExit()
{
// 删除所用的进度动画渲染器节点。
removeChildByTag(kCCSceneRadial, false);
CCTransitionScene::onExit();
}
//设置场景排序。
void CCTransitionProgress::sceneOrder()
{
m_bIsInSceneOnTop = false;
}
//初始化当前的场景控制器。
void CCTransitionProgress::setupTransition()
{
//保存旧场景指针到成员变量m_pSceneToBeModified。
m_pSceneToBeModified = m_pOutScene;
//设置起始100和终止进度值0。
m_fFrom = 100;
m_fTo = 0;
}
//由“渲染到纹理”的纹理对象创建出相应的进度动画渲染器。
CCProgressTimer* CCTransitionProgress::progressTimerNodeWithRenderTexture(CCRenderTexture* texture)
{
CCAssert(false, "override me - abstract class");
return NULL;
}
这后面就都是由CCTransitionProgress派生的场景切换控制器了。
//逆时针旋转的进度动画方式切换场景的场景切换控制器。
class CC_DLL CCTransitionProgressRadialCCW : public CCTransitionProgress
{
public:
//老新创建函数。
OLD_TRANSITION_CREATE_FUNC(CCTransitionProgressRadialCCW)
TRANSITION_CREATE_FUNC(CCTransitionProgressRadialCCW)
protected:
//由“渲染到纹理”的纹理对象创建出相应的进度动画渲染器。
virtual CCProgressTimer* progressTimerNodeWithRenderTexture(CCRenderTexture* texture);
};
对应CPP：
//由“渲染到纹理”的纹理对象创建出相应的进度动画渲染器。
CCProgressTimer* CCTransitionProgressRadialCCW::progressTimerNodeWithRenderTexture(CCRenderTexture* texture)
{
//取得屏幕大小。
CCSize size = CCDirector::sharedDirector()->getWinSize();
//由参数指定的纹理对象的精灵创建出所用的进度动画渲染器。
CCProgressTimer* pNode = CCProgressTimer::create(texture->getSprite());
//设置进度动画渲染器的精灵绕Y轴镜像。
pNode->getSprite()->setFlipY(true);
//设置进度动画渲染器的表现方式为绕中心旋转的进度方式。
pNode->setType(kCCProgressTimerTypeRadial);
// 设置非反向播放动画。
pNode->setReverseDirection(false);
//设置初始进度为100。
pNode->setPercentage(100);
//设置进度动画渲染器的位置。
pNode->setPosition(ccp(size.width/2, size.height/2));
//设置进度动画渲染器的锚点。
pNode->setAnchorPoint(ccp(0.5f,0.5f));
//返回进度动画渲染器。
return pNode;
}
//顺时针旋转的进度动画方式切换场景的场景切换控制器。
class CC_DLL CCTransitionProgressRadialCW : public CCTransitionProgress
{
public:
//老新创建函数。
OLD_TRANSITION_CREATE_FUNC(CCTransitionProgressRadialCW)
TRANSITION_CREATE_FUNC(CCTransitionProgressRadialCW)
protected:
//由“渲染到纹理”的纹理对象创建出相应的进度动画渲染器。
virtual CCProgressTimer* progressTimerNodeWithRenderTexture(CCRenderTexture* texture);
};
对应CPP：
//由“渲染到纹理”的纹理对象创建出相应的进度动画渲染器。
CCProgressTimer* CCTransitionProgressRadialCCW::progressTimerNodeWithRenderTexture(CCRenderTexture* texture)
{
//取得屏幕大小。
CCSize size = CCDirector::sharedDirector()->getWinSize();
//由参数指定的纹理对象的精灵创建出所用的进度动画渲染器。
CCProgressTimer* pNode = CCProgressTimer::create(texture->getSprite());
//设置进度动画渲染器的精灵绕Y轴镜像。
pNode->getSprite()->setFlipY(true);
//设置进度动画渲染器的表现方式为绕中心旋转的进度方式。
pNode->setType(kCCProgressTimerTypeRadial);
// 设置非反向播放动画。
pNode->setReverseDirection(false);
//设置初始进度为100。
pNode->setPercentage(100);
//设置进度动画渲染器的位置。
pNode->setPosition(ccp(size.width/2, size.height/2));
//设置进度动画渲染器的锚点。
pNode->setAnchorPoint(ccp(0.5f,0.5f));
//返回进度动画渲染器。
return pNode;
}
//横向进度条动画方式切换场景的场景切换控制器。
class CC_DLL CCTransitionProgressHorizontal : public CCTransitionProgress
{
public:
//老新创建函数。
OLD_TRANSITION_CREATE_FUNC(CCTransitionProgressHorizontal)
TRANSITION_CREATE_FUNC(CCTransitionProgressHorizontal)
protected:
//由“渲染到纹理”的纹理对象创建出相应的进度动画渲染器。
virtual CCProgressTimer* progressTimerNodeWithRenderTexture(CCRenderTexture* texture);
};
对应CPP：
//由“渲染到纹理”的纹理对象创建出相应的进度动画渲染器。
CCProgressTimer* CCTransitionProgressHorizontal::progressTimerNodeWithRenderTexture(CCRenderTexture* texture)
{
//取得屏幕大小。
CCSize size = CCDirector::sharedDirector()->getWinSize();
//由参数指定的纹理对象的精灵创建出所用的进度动画渲染器。
CCProgressTimer* pNode = CCProgressTimer::create(texture->getSprite());
//设置进度动画渲染器的精灵绕Y轴镜像。
pNode->getSprite()->setFlipY(true);
//设置进度动画渲染器的表现方式为进度条方式。
pNode->setType( kCCProgressTimerTypeBar);
//设置进度的起点
pNode->setMidpoint(ccp(1, 0));
//设置进度条为从左向右随进度增长而显现。
pNode->setBarChangeRate(ccp(1,0));
//设置初始进度值100
pNode->setPercentage(100);
//设置进度动画渲染器的位置
pNode->setPosition(ccp(size.width/2, size.height/2));
//设置进度动画渲染器的锚点。
pNode->setAnchorPoint(ccp(0.5f,0.5f));
//返回进度动画渲染器。
return pNode;
}
//纵向进度条动画方式切换场景的场景切换控制器。
class CC_DLL CCTransitionProgressVertical : public CCTransitionProgress
{
public:
//老新创建函数。
OLD_TRANSITION_CREATE_FUNC(CCTransitionProgressVertical)
TRANSITION_CREATE_FUNC(CCTransitionProgressVertical)
protected:
//由“渲染到纹理”的纹理对象创建出相应的进度动画渲染器。
virtual CCProgressTimer* progressTimerNodeWithRenderTexture(CCRenderTexture* texture);
};
对应CPP：
//由“渲染到纹理”的纹理对象创建出相应的进度动画渲染器。
CCProgressTimer* CCTransitionProgressVertical::progressTimerNodeWithRenderTexture(CCRenderTexture* texture)
{
//取得屏幕大小。
CCSize size = CCDirector::sharedDirector()->getWinSize();
//由参数指定的纹理对象的精灵创建出所用的进度动画渲染器。
CCProgressTimer* pNode = CCProgressTimer::create(texture->getSprite());
//设置进度动画渲染器的精灵绕Y轴镜像。
pNode->getSprite()->setFlipY(true);
//设置进度动画渲染器的表现方式为进度条方式。
pNode->setType(kCCProgressTimerTypeBar);
//设置进度的起点
pNode->setMidpoint(ccp(0, 0));
//设置进度条为从上向下随进度增长而显现。
pNode->setBarChangeRate(ccp(0,1));
//设置初始进度值100
pNode->setPercentage(100);
//设置进度动画渲染器的位置
pNode->setPosition(ccp(size.width/2, size.height/2));
//设置进度动画渲染器的锚点。
pNode->setAnchorPoint(ccp(0.5f,0.5f));
//返回进度动画渲染器。
return pNode;
}
//新场景由中心向四周扩散显现的动画方式切换场景的场景切换控制器。
class CC_DLL CCTransitionProgressInOut : public CCTransitionProgress
{
public:
//老新创建函数。
OLD_TRANSITION_CREATE_FUNC(CCTransitionProgressInOut)
TRANSITION_CREATE_FUNC(CCTransitionProgressInOut)
protected:
//由“渲染到纹理”的纹理对象创建出相应的进度动画渲染器。
virtual CCProgressTimer* progressTimerNodeWithRenderTexture(CCRenderTexture* texture);
//场景排序。
virtual void sceneOrder();
//初始化场景切换。
virtual void setupTransition();
};
对应CPP：
//场景排序。
void CCTransitionProgressInOut::sceneOrder()
{ //新场景在上面。
m_bIsInSceneOnTop = false;
}
//初始化场景切换。
void CCTransitionProgressInOut::setupTransition()
{
//保存新场景，并初始化起始和终止的进度值。
m_pSceneToBeModified = m_pInScene;
m_fFrom = 0;
m_fTo = 100;
}
//由“渲染到纹理”的纹理对象创建出相应的进度动画渲染器。
CCProgressTimer* CCTransitionProgressInOut::progressTimerNodeWithRenderTexture(CCRenderTexture* texture)
{
//取得屏幕大小。
CCSize size = CCDirector::sharedDirector()->getWinSize();
//由参数指定的纹理对象的精灵创建出所用的进度动画渲染器。
CCProgressTimer* pNode = CCProgressTimer::create(texture->getSprite());
//设置进度动画渲染器的精灵绕Y轴镜像。
pNode->getSprite()->setFlipY(true);
//设置进度动画渲染器的表现方式为进度条方式。
pNode->setType( kCCProgressTimerTypeBar);
//设置进度的起点
pNode->setMidpoint(ccp(0.5f, 0.5f));
//设置进度动画表现为随时间向四周扩散显现。
pNode->setBarChangeRate(ccp(1, 1));
//设置初始进度值为0。
pNode->setPercentage(0);
//设置进度动画渲染器位置
pNode->setPosition(ccp(size.width/2, size.height/2));
//设置进度动画渲染器锚点。
pNode->setAnchorPoint(ccp(0.5f,0.5f));
//返回进度动画渲染器.
return pNode;
}
//老场景由四周向中心收缩消失的动画方式切换场景的场景切换控制器。
class CC_DLL CCTransitionProgressOutIn : public CCTransitionProgress
{
public:
//老新创建函数。
OLD_TRANSITION_CREATE_FUNC(CCTransitionProgressOutIn)
TRANSITION_CREATE_FUNC(CCTransitionProgressOutIn)
protected:
//由“渲染到纹理”的纹理对象创建出相应的进度动画渲染器。
virtual CCProgressTimer* progressTimerNodeWithRenderTexture(CCRenderTexture* texture);
};
对应CPP：
//由“渲染到纹理”的纹理对象创建出相应的进度动画渲染器。
CCProgressTimer* CCTransitionProgressInOut::progressTimerNodeWithRenderTexture(CCRenderTexture* texture)
{
//取得屏幕大小。
CCSize size = CCDirector::sharedDirector()->getWinSize();
//由参数指定的纹理对象的精灵创建出所用的进度动画渲染器。
CCProgressTimer* pNode = CCProgressTimer::create(texture->getSprite());
//设置进度动画渲染器的精灵绕Y轴镜像。
pNode->getSprite()->setFlipY(true);
//设置进度动画渲染器的表现方式为进度条方式。
pNode->setType( kCCProgressTimerTypeBar);
//设置进度的起点
pNode->setMidpoint(ccp(0.5f, 0.5f));
//设置进度动画表现为随时间向四周扩散显现。
pNode->setBarChangeRate(ccp(1, 1));
//设置初始进度值为100。
pNode->setPercentage(100);
//设置进度动画渲染器位置
pNode->setPosition(ccp(size.width/2, size.height/2));
//设置进度动画渲染器锚点。
pNode->setAnchorPoint(ccp(0.5f,0.5f));
//返回进度动画渲染器.
return pNode;
}
最后，以我的习惯，我们仍要看一下这个示例是如何被组织和演示的。
打开TranslationsTest.h:
#ifndef _TRANSITIONS_TEST_H_
#define _TRANSITIONS_TEST_H_
//
#include "../testBasic.h"
//Cocos2d命名空间
USING_NS_CC;
//用于演示场景切换效果的Scene
class TransitionsTestScene : public TestScene
{
public:
//启动场景函数要重载才能实现相应的功能。
virtual void runThisTest();
};
//用于做为第一个场景的Layer
class TestLayer1 : public CCLayer
{
public:
//构造
TestLayer1(void);
//析构
~TestLayer1(void);
//重启当前动画切换的演示。
void restartCallback(CCObject* pSender);
//演示下一个动画切换。
void nextCallback(CCObject* pSender);
//演示上一个动画切换。
void backCallback(CCObject* pSender);
//动画进度处理函数。
void step(float dt);
//加载当前层所调用的函数。
virtual void onEnter();
//加载结束所调用的函数。
virtual void onEnterTransitionDidFinish();
//卸载当前层时所调用的函数。
virtual void onExitTransitionDidStart();
//卸载当前层结束所调用的函数。
virtual void onExit();
};
//用于做为第二个场景的Layer
class TestLayer2 : public CCLayer
{
public:
//构造。
TestLayer2(void);
//析构
~TestLayer2(void);
//重启当前动画切换的演示。
void restartCallback(CCObject* pSender);
//演示下一个动画切换。
void nextCallback(CCObject* pSender);
//演示上一个动画切换。
void backCallback(CCObject* pSender);
//动画进度处理函数。
void step(float dt);
//加载当前层所调用的函数。
virtual void onEnter();
//加载结束所调用的函数。
virtual void onEnterTransitionDidFinish();
//卸载当前层时所调用的函数。
virtual void onExitTransitionDidStart();
//卸载当前层结束所调用的函数。
virtual void onExit();
};
#endif
CPP文件:
#include "TransitionsTest.h"
#include "../testResource.h"
#include "CCConfiguration.h"
//这里定义一个时间值做为场景切换效果所需要的时长。
#define TRANSITION_DURATION (1.2f)
//下面是封装了一下所用到的场景切换的控制类。
//渐隐切换场景效果。
class FadeWhiteTransition : public CCTransitionFade
{
public:
//重载create函数，内部调用CCTransitionFade的create函数，将要切换成的场景设为一个纯色ccWHITE。
static CCTransitionScene* create(float t, CCScene* s)
{
return CCTransitionFade::create(t, s, ccWHITE);
}
};
//向左切换场景效果。
class FlipXLeftOver : public CCTransitionFlipX
{
public:
//重载create函数，内部调用CCTransitionFlipX的create函数，将要切换成的场景方向设为向左。
static CCTransitionScene* create(float t, CCScene* s)
{
return CCTransitionFlipX::create(t, s, kOrientationLeftOver);
}
};
//向右切换场景效果。
class FlipXRightOver : public CCTransitionFlipX
{
public:
//重载create函数，内部调用CCTransitionFlipX的create函数，将要切换成的场景方向设为向右。
static CCTransitionScene* create(float t, CCScene* s)
{
return CCTransitionFlipX::create(t, s, kOrientationRightOver);
}
};
//向上切换场景效果。
class FlipYUpOver : public CCTransitionFlipY
{
public:
//重载create函数，内部调用CCTransitionFlipY的create函数，将要切换成的场景方向设为向上。
static CCTransitionScene* create(float t, CCScene* s)
{
return CCTransitionFlipY::create(t, s, kOrientationUpOver);
}
};
//向下切换场景效果。
class FlipYDownOver : public CCTransitionFlipY
{
public:
//重载create函数，内部调用CCTransitionFlipY的create函数，将要切换成的场景方向设为向下。
static CCTransitionScene* create(float t, CCScene* s)
{
return CCTransitionFlipY::create(t, s, kOrientationDownOver);
}
};
//左向上，右向下切换场景效果。
class FlipAngularLeftOver : public CCTransitionFlipAngular
{
public:
//重载create函数，内部调用CCTransitionFlipAngular的create函数，将要切换成的场景方向设为左向上，右向下。
static CCTransitionScene* create(float t, CCScene* s)
{
return CCTransitionFlipAngular::create(t, s, kOrientationLeftOver);
}
};
//右向上，左向下切换场景效果。
class FlipAngularRightOver : public CCTransitionFlipAngular
{
public:
//重载create函数，内部调用CCTransitionFlipAngular的create函数，将要切换成的场景方向设为右向上，左向下。
static CCTransitionScene* create(float t, CCScene* s)
{
return CCTransitionFlipAngular::create(t, s, kOrientationRightOver);
}
};
//向左横向缩放切换场景效果。
class ZoomFlipXLeftOver : public CCTransitionZoomFlipX
{
public:
//重载create函数，内部调用CCTransitionZoomFlipX的create函数，将要缩放场景效果方向设为向左。
static CCTransitionScene* create(float t, CCScene* s)
{
return CCTransitionZoomFlipX::create(t, s, kOrientationLeftOver);
}
};
//向右横向缩放切换场景效果。
class ZoomFlipXRightOver : public CCTransitionZoomFlipX
{
public:
//重载create函数，内部调用CCTransitionZoomFlipX的create函数，将要缩放场景效果方向设为向右。
static CCTransitionScene* create(float t, CCScene* s)
{
return CCTransitionZoomFlipX::create(t, s, kOrientationRightOver);
}
};
//向上缩放切换场景效果。
class ZoomFlipYUpOver : public CCTransitionZoomFlipY
{
public:
//重载create函数，内部调用CCTransitionZoomFlipY的create函数，将要缩放场景效果方向设为向上。
static CCTransitionScene* create(float t, CCScene* s)
{
return CCTransitionZoomFlipY::create(t, s, kOrientationUpOver);
}
};
//向下缩放切换场景效果。
class ZoomFlipYDownOver : public CCTransitionZoomFlipY
{
public:
//重载create函数，内部调用CCTransitionZoomFlipY的create函数，将要缩放场景效果方向设为向下。
static CCTransitionScene* create(float t, CCScene* s)
{
return CCTransitionZoomFlipY::create(t, s, kOrientationDownOver);
}
};
//左向上，右向下缩放切换场景效果。
class ZoomFlipAngularLeftOver : public CCTransitionZoomFlipAngular
{
public:
//重载create函数，内部调用CCTransitionZoomFlipAngular的create函数，将要缩放场景效果方向设为左向上，右向下。
static CCTransitionScene* create(float t, CCScene* s)
{
return CCTransitionZoomFlipAngular::create(t, s, kOrientationLeftOver);
}
};
//右向上，左向下缩放切换场景效果。
class ZoomFlipAngularRightOver : public CCTransitionZoomFlipAngular
{
public:
//重载create函数，内部调用CCTransitionZoomFlipAngular的create函数，将要缩放场景效果方向设为右向上，左向下。
static CCTransitionScene* create(float t, CCScene* s)
{
return CCTransitionZoomFlipAngular::create(t, s, kOrientationRightOver);
}
};
//向前翻页切换场景效果。
class PageTransitionForward : public CCTransitionPageTurn
{
public:
//重载create函数，内部调用CCTransitionPageTurn的create函数，将要翻页切换场景的效果方向设为向前翻页。
static CCTransitionScene* create(float t, CCScene* s)
{
//翻页效果会影响图像顶点的Z值，为了正确的处理Z的关系，这里开启了深度测试。
CCDirector::sharedDirector()->setDepthTest(true);
return CCTransitionPageTurn::create(t, s, false);
}
};
//向后翻页切换场景效果。
class PageTransitionBackward : public CCTransitionPageTurn
{
public:
//重载create函数，内部调用CCTransitionPageTurn的create函数，将要翻页切换场景的效果方向设为向后翻页。
static CCTransitionScene* create(float t, CCScene* s)
{
CCDirector::sharedDirector()->setDepthTest(true);
return CCTransitionPageTurn::create(t, s, true);
}
};
//切换场景的效果数量。
#define MAX_LAYER 41
//这里定义一个字符串数组存储每种切换效果的显示标题。
static std::string transitions[MAX_LAYER] = {
"CCTransitionJumpZoom",
"CCTransitionProgressRadialCCW",
"CCTransitionProgressRadialCW",
"CCTransitionProgressHorizontal",
"CCTransitionProgressVertical",
"CCTransitionProgressInOut",
"CCTransitionProgressOutIn",
"CCTransitionCrossFade",
"TransitionPageForward",
"TransitionPageBackward",
"CCTransitionFadeTR",
"CCTransitionFadeBL",
"CCTransitionFadeUp",
"CCTransitionFadeDown",
"CCTransitionTurnOffTiles",
"CCTransitionSplitRows",
"CCTransitionSplitCols",
"CCTransitionFade",
"FadeWhiteTransition",
"FlipXLeftOver",
"FlipXRightOver",
"FlipYUpOver",
"FlipYDownOver",
"FlipAngularLeftOver",
"FlipAngularRightOver",
"ZoomFlipXLeftOver",
"ZoomFlipXRightOver",
"ZoomFlipYUpOver",
"ZoomFlipYDownOver",
"ZoomFlipAngularLeftOver",
"ZoomFlipAngularRightOver",
"CCTransitionShrinkGrow",
"CCTransitionRotoZoom",
"CCTransitionMoveInL",
"CCTransitionMoveInR",
"CCTransitionMoveInT",
"CCTransitionMoveInB",
"CCTransitionSlideInL",
"CCTransitionSlideInR",
"CCTransitionSlideInT",
"CCTransitionSlideInB",
};
//当前在演示中的场景切换效果的索引。
static int s_nSceneIdx = 0;
//创建相应的场景切换效果，参数1为对应的索引，参数2为切换效果动画的时长，参数3为用于演示效果的场景。
CCTransitionScene* createTransition(int nIndex, float t, CCScene* s)
{
// fix bug #486, without setDepthTest(false), FlipX,Y will flickers
CCDirector::sharedDirector()->setDepthTest(false);
switch(nIndex)
{
case 0: return CCTransitionJumpZoom::create(t, s);
case 1: return CCTransitionProgressRadialCCW::create(t, s);
case 2: return CCTransitionProgressRadialCW::create(t, s);
case 3: return CCTransitionProgressHorizontal::create(t, s);
case 4: return CCTransitionProgressVertical::create(t, s);
case 5: return CCTransitionProgressInOut::create(t, s);
case 6: return CCTransitionProgressOutIn::create(t, s);
case 7: return CCTransitionCrossFade::create(t,s);
case 8: return PageTransitionForward::create(t, s);
case 9: return PageTransitionBackward::create(t, s);
case 10: return CCTransitionFadeTR::create(t, s);
case 11: return CCTransitionFadeBL::create(t, s);
case 12: return CCTransitionFadeUp::create(t, s);
case 13: return CCTransitionFadeDown::create(t, s);
case 14: return CCTransitionTurnOffTiles::create(t, s);
case 15: return CCTransitionSplitRows::create(t, s);
case 16: return CCTransitionSplitCols::create(t, s);
case 17: return CCTransitionFade::create(t, s);
case 18: return FadeWhiteTransition::create(t, s);
case 19: return FlipXLeftOver::create(t, s);
case 20: return FlipXRightOver::create(t, s);
case 21: return FlipYUpOver::create(t, s);
case 22: return FlipYDownOver::create(t, s);
case 23: return FlipAngularLeftOver::create(t, s);
case 24: return FlipAngularRightOver::create(t, s);
case 25: return ZoomFlipXLeftOver::create(t, s);
case 26: return ZoomFlipXRightOver::create(t, s);
case 27: return ZoomFlipYUpOver::create(t, s);
case 28: return ZoomFlipYDownOver::create(t, s);
case 29: return ZoomFlipAngularLeftOver::create(t, s);
case 30: return ZoomFlipAngularRightOver::create(t, s);
case 31: return CCTransitionShrinkGrow::create(t, s);
case 32: return CCTransitionRotoZoom::create(t, s);
case 33: return CCTransitionMoveInL::create(t, s);
case 34: return CCTransitionMoveInR::create(t, s);
case 35: return CCTransitionMoveInT::create(t, s);
case 36: return CCTransitionMoveInB::create(t, s);
case 37: return CCTransitionSlideInL::create(t, s);
case 38: return CCTransitionSlideInR::create(t, s);
case 39: return CCTransitionSlideInT::create(t, s);
case 40: return CCTransitionSlideInB::create(t, s);
default: break;
}
return NULL;
}
//启动当前程序场景。
void TransitionsTestScene::runThisTest()
{
//创建一个TestLayer1并加入当前场景。
CCLayer * pLayer = new TestLayer1();
addChild(pLayer);
pLayer->release();
//激活当前场景。
CCDirector::sharedDirector()->replaceScene(this);
}
//TetsLayer1的构造函数。
TestLayer1::TestLayer1(void)
{
//定义两个临时变量x,y,
float x,y;
//取得窗口的大小值存入x,y.
CCSize size = CCDirector::sharedDirector()->getWinSize();
x = size.width;
y = size.height;
//创建一个精灵，图片数据放在静态字符串s_back1中。
CCSprite* bg1 = CCSprite::create(s_back1);
//设置精灵居于屏幕中央位置。
bg1->setPosition( CCPointMake(size.width/2, size.height/2) );
//将精灵放入当前Layer中。
addChild(bg1, -1);
//创建一个文字标签，写的字符串由索引s_nSceneIdx从标题数组中取得，字体为“Thonburi”，字的大小为32。
CCLabelTTF* title = CCLabelTTF::create( (transitions[s_nSceneIdx]).c_str(), "Thonburi", 32 );
//将文字标签放入当前Layer.
addChild(title);
//设置文字标签的色彩值及显示的位置。
title->setColor( ccc3(255,32,32) );
title->setPosition( CCPointMake(x/2, y-100) );
//创建第二个文字标签，写的字符串为"SCENE 1"，字体为“Marker Felt”，字的大小为38。
CCLabelTTF* label = CCLabelTTF::create("SCENE 1", "Marker Felt", 38);
//设置文字标签的色彩值及显示的位置。
label->setColor( ccc3(16,16,255));
label->setPosition( CCPointMake(x/2,y/2));
//将文字标签放入当前Layer.
addChild( label);
//创建“上一个演示”，“重启当前演示”和“下一个演示”的菜单按钮项。
CCMenuItemImage *item1 = CCMenuItemImage::create(s_pPathB1, s_pPathB2, this, menu_selector(TestLayer1::backCallback) );
CCMenuItemImage *item2 = CCMenuItemImage::create(s_pPathR1, s_pPathR2, this, menu_selector(TestLayer1::restartCallback) );
CCMenuItemImage *item3 = CCMenuItemImage::create(s_pPathF1, s_pPathF2, this, menu_selector(TestLayer1::nextCallback) );
//由菜单按钮项创建菜单。
CCMenu *menu = CCMenu::create(item1, item2, item3, NULL);
//设置菜单的位置及各菜单按钮项相对于菜单的位置。
menu->setPosition( CCPointZero );
item1->setPosition( ccp( size.width/2 - item2->getContentSize().width*2, item2->getContentSize().height/2) );
item2->setPosition( ccp( size.width/2, item2->getContentSize().height/2) );
item3->setPosition( ccp( size.width/2 + item2->getContentSize().width*2, item2->getContentSize().height/2) );
//将菜单加入当前Layer。
addChild(menu, 1);
//给当前Layer挂接一个每秒触发一次的回调函数。
schedule( schedule_selector(TestLayer1::step), 1.0f);
}
//析构
TestLayer1::~TestLayer1(void)
{
}
//重启当前演示的回调函数。
void TestLayer1::restartCallback(CCObject* pSender)
{
//创建相应的场景。
CCScene* s = new TransitionsTestScene();
//创建另一个层。
CCLayer* pLayer = new TestLayer2();
//将其放入场景。
s->addChild(pLayer);
//创建出相应的场景切换控制器，设置切换到场景s。
CCScene* pScene = createTransition(s_nSceneIdx, TRANSITION_DURATION, s);
//引用计数减一.
s->release();
pLayer->release();
if (pScene)
{ //运行场景切换控制器。
CCDirector::sharedDirector()->replaceScene(pScene);
}
}
//下一个演示的回调函数。
void TestLayer1::nextCallback(CCObject* pSender)
{
//演示索引++后与最大值取模，其它与上相同。
s_nSceneIdx++;
s_nSceneIdx = s_nSceneIdx % MAX_LAYER;
CCScene* s = new TransitionsTestScene();
CCLayer* pLayer = new TestLayer2();
s->addChild(pLayer);
CCScene* pScene = createTransition(s_nSceneIdx, TRANSITION_DURATION, s);
s->release();
pLayer->release();
if (pScene)
{
CCDirector::sharedDirector()->replaceScene(pScene);
}
}
//向一个演示的回调函数。
void TestLayer1::backCallback(CCObject* pSender)
{
//演示索引--后进行有效值处理，其它与上相同。
s_nSceneIdx--;
int total = MAX_LAYER;
if( s_nSceneIdx < 0 )
s_nSceneIdx += total;
CCScene* s = new TransitionsTestScene();
CCLayer* pLayer = new TestLayer2();
s->addChild(pLayer);
CCScene* pScene = createTransition(s_nSceneIdx, TRANSITION_DURATION, s);
s->release();
pLayer->release();
if (pScene)
{
CCDirector::sharedDirector()->replaceScene(pScene);
}
}
//动画进度处理函数。
void TestLayer1::step(float dt)
{
}
//TestLayer1被加载时调用的函数。
void TestLayer1::onEnter()
{
CCLayer::onEnter();
CCLog("Scene 1 onEnter");
}
//TestLayer1加载完成时调用的函数。
void TestLayer1::onEnterTransitionDidFinish()
{
CCLayer::onEnterTransitionDidFinish();
CCLog("Scene 1: onEnterTransitionDidFinish");
}
//TestLayer1被卸载时调用的函数。
void TestLayer1::onExitTransitionDidStart()
{
CCLayer::onExitTransitionDidStart();
CCLog("Scene 1: onExitTransitionDidStart");
}
//TestLayer1被卸载完成时调用的函数。
void TestLayer1::onExit()
{
CCLayer::onExit();
CCLog("Scene 1 onExit");
}
//TestLayer2的构造函数。
TestLayer2::TestLayer2()
{
float x,y;
//取得屏幕大小.
CCSize size = CCDirector::sharedDirector()->getWinSize();
x = size.width;
y = size.height;
//创建精灵并放入当前层。
CCSprite* bg1 = CCSprite::create(s_back2);
bg1->setPosition( CCPointMake(size.width/2, size.height/2) );
addChild(bg1, -1);
//创建文字标签并放入当前层。
CCLabelTTF* title = CCLabelTTF::create((transitions[s_nSceneIdx]).c_str(), "Thonburi", 32 );
addChild(title);
//设置文字的颜色和位置。
title->setColor( ccc3(255,32,32) );
title->setPosition( CCPointMake(x/2, y-100) );
//创建另一个文字标签。
CCLabelTTF* label = CCLabelTTF::create("SCENE 2", "Marker Felt", 38);
//设置文字标答的颜色和位置。
label->setColor( ccc3(16,16,255));
label->setPosition( CCPointMake(x/2,y/2));
//将文字标签放入当前层。
addChild( label);
//创建菜单项。
CCMenuItemImage *item1 = CCMenuItemImage::create(s_pPathB1, s_pPathB2, this, menu_selector(TestLayer2::backCallback) );
CCMenuItemImage *item2 = CCMenuItemImage::create(s_pPathR1, s_pPathR2, this, menu_selector(TestLayer2::restartCallback) );
CCMenuItemImage *item3 = CCMenuItemImage::create(s_pPathF1, s_pPathF2, this, menu_selector(TestLayer2::nextCallback) );
//由菜单项创建菜单。
CCMenu *menu = CCMenu::create(item1, item2, item3, NULL);
//设置菜单与菜单项的位置。
menu->setPosition( CCPointZero );
item1->setPosition( ccp( size.width/2 - item2->getContentSize().width*2, item2->getContentSize().height/2) );
item2->setPosition( ccp( size.width/2, item2->getContentSize().height/2) );
item3->setPosition( ccp( size.width/2 + item2->getContentSize().width*2, item2->getContentSize().height/2) );
//将菜单放入当前层。
addChild(menu, 1);
//调用step函数。
schedule(schedule_selector(TestLayer2::step), 1.0f);
}
//析构。
TestLayer2::~TestLayer2()
{
}
//重启当前动画演示。
void TestLayer2::restartCallback(CCObject* pSender)
{
//创建一个相应的场景动画。
CCScene* s = new TransitionsTestScene();
//将其放入场景中。
CCLayer* pLayer = new TestLayer1();
s->addChild(pLayer);
//创建相应的演示场景切换的控制器。
CCScene* pScene = createTransition(s_nSceneIdx, TRANSITION_DURATION, s);
//引用计数减一
s->release();
pLayer->release();
if (pScene)
{
//运行场景切换的控制器。
CCDirector::sharedDirector()->replaceScene(pScene);
}
}
//下一个动画演示。
void TestLayer2::nextCallback(CCObject* pSender)
{
//将演示索引加一后与最大值取模。其它与上同。
s_nSceneIdx++;
s_nSceneIdx = s_nSceneIdx % MAX_LAYER;
CCScene* s = new TransitionsTestScene();
//创建出TestLayer1的实例对象。
CCLayer* pLayer = new TestLayer1();
s->addChild(pLayer);
CCScene* pScene = createTransition(s_nSceneIdx, TRANSITION_DURATION, s);
s->release();
pLayer->release();
if (pScene)
{
CCDirector::sharedDirector()->replaceScene(pScene);
}
}
//返回上一个动画演示。
void TestLayer2::backCallback(CCObject* pSender)
{
//将演示索引减减。其它与上同。
s_nSceneIdx--;
int total = MAX_LAYER;
if( s_nSceneIdx < 0 )
s_nSceneIdx += total;
CCScene* s = new TransitionsTestScene();
CCLayer* pLayer = new TestLayer1();
s->addChild(pLayer);
CCScene* pScene = createTransition(s_nSceneIdx, TRANSITION_DURATION, s);
s->release();
pLayer->release();
if (pScene)
{
CCDirector::sharedDirector()->replaceScene(pScene);
}
}
//动画进度处理函数。
void TestLayer2::step(float dt)
{
}
//TestLayer2被加载时调用的函数。
void TestLayer2::onEnter()
{
CCLayer::onEnter();
CCLog("Scene 2 onEnter");
}
//TestLayer2被加载完成时调用的函数。
void TestLayer2::onEnterTransitionDidFinish()
{
CCLayer::onEnterTransitionDidFinish();
CCLog("Scene 2: onEnterTransitionDidFinish");
}
//TestLayer2被卸载时调用的函数。
void TestLayer2::onExitTransitionDidStart()
{
CCLayer::onExitTransitionDidStart();
CCLog("Scene 2: onExitTransitionDidStart");
}
//TestLayer2被卸载完成时调用的函数。
void TestLayer2::onExit()
{
CCLayer::onExit();
CCLog("Scene 2 onExit");
}
OK，结束了，这篇博文是对之前所讲的精灵动画，变速动画，进度动画，网格动画的一次综合应用，我为了更好的使大家进行系统的学习，特意将其放在这个时间点来讲解。新的一年开始了，希望所有跟着我一起学习Cocos2d-x的朋友都能在新的一年里掌握好Cocos2d-x，咱们一起在路上！
