现在的位置: 首页 > 综合 > 正文

Cocos2d-x 2.0 TestCpp之场景切换动画深入分析

2013年10月14日 ⁄ 综合 ⁄ 共 33106字 ⁄ 字号 小 中 大 ⁄ 评论关闭

[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 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 TestLayer1::nextCallback(CCObject*pSender)中有

 

CCDirector::sharedDirector()->replaceScene(CCTransitionScene*);

 

(2)在主循环的drawScene函数中会调用setNextScene。

 

CCDirector:: setNextScene()

{

    //当前场景是普通场景，新的场景是“场景切换控制器”。dynamic_cast会得出以下结果：

bool runningIsTransition= false ;

bool newIsTransition= true;

…

//当前场景是普通场景，进入判断

   
if ((! runningIsTransition) &&m_pRunningScene)

    {

        //调用“场景切换控制器”的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)

         {

            m_pRunningScene->onExit();

         }

        //将“场景切换控制器”进行内部的释放处理。

        if (m_bSendCleanupToScene && m_pRunningScene)

         {

            m_pRunningScene->cleanup();

         }

     }

    //将“场景切换控制器”的引用计数减一，删除场景。

   
if (m_pRunningScene)

    {

       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;

    }

//创建出供新场
返回
【上篇】
【下篇】

作者:

抱歉!评论已关闭.

返回首页

Copyright © 2013-2018 学步园  保留所有权利.
软文销售 QQ客服：2265327166 点击这里给我发消息（其他合作也可洽谈）
必威体育
必威电竞