Cocos2d-x 2.0 变速动画深入分析

最新推荐文章于 2019-10-12 14:39:31 发布
最新推荐文章于 2019-10-12 14:39:31 发布
阅读量8.7k 收藏 16
点赞数 10
分类专栏： Cocos2d-x学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/honghaier/article/details/8296655
版权

[Cocos2d-x相关教程来源于红孩儿的游戏编程之路CSDN博客地址：http://blog.csdn.net/honghaier]

红孩儿Cocos2d-X学习园地QQ2群：44208467 加群写：Cocos2d-x 
红孩儿Cocos2d-X学习园地QQ群：249941957 [暂满]加群写：Cocos2d-x 

本章为我的Cocos2d-x教程一书初稿。望各位看官多提建议！

Cocos2d-x 2.0变速动画深入分析

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

cocos2d-2.0-x-2.0.2 @ Aug 30 2012

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

       变速动画都是由时间动画所衍生出来的，它是通过对一个匀速动画的进度进行调节来实现的，所以你要运行一个变速动画，首先要给他指定一个匀速动画，播放这个变速动画，它也播放被指定的匀速动画，在变速动画的更新函数中对被指定的匀速动画通过一个变速曲线计算得到相应的播放进度，变速动画停止播放时，被指定的匀速动画也必须被停止。所以，变速动画其实就是一个控制器，用来控制一个匀速动画的播放进度，使其产生变速的效果。

      为了讲述好本节，我专门写了一个曲线生成工具，这样可以更直观的看到变速曲线的形态。有兴趣的可以到我的群里下载这个工具。

      打开CActionEase.h:


#ifndef __ACTION_CCEASE_ACTION_H__
#define __ACTION_CCEASE_ACTION_H__

#include "CCActionInterval.h"
//使用Cocos2d命名空间
NS_CC_BEGIN
//要用到以下两个类
class CCObject;
class CCZone;

//所有变速动画的基类。
class CC_DLL CCActionEase : public CCActionInterval
{
public:
	//析构
    virtual ~CCActionEase(void);

    //初始化动画，参数为一个匀速时间动画。
    bool initWithAction(CCActionInterval *pAction);
	//产生一个当前实例的拷贝。
　　virtual CCObject* copyWithZone(CCZone* pZone);
　　//指定演示当前动画的演员。
　　virtual void startWithTarget(CCNode *pTarget);
　　//停止当前动画。
　　virtual void stop(void);
　　//更新动画。
　　virtual void update(float time);
　　　//创建一个反向播放的当前动画。
　　 virtual CCActionInterval* reverse(void);

public:
    //静态函数：创建对应匀速动画的变速动画，参数为一个匀速动画。内部调用create实现。
    CC_DEPRECATED_ATTRIBUTE static CCActionEase* actionWithAction(CCActionInterval *pAction);

    //同上
    static CCActionEase* create(CCActionInterval *pAction);

protected:
	//保存对应的匀速动画。
    CCActionInterval *m_pOther;
};

对应CPP：


//静态函数：创建对应匀速动画的变速动画，参数为一个匀速动画。内部调用create实现。
CCActionEase* CCActionEase::actionWithAction(CCActionInterval *pAction)
{
    return CCActionEase::create(pAction);
}
//同上
CCActionEase* CCActionEase::create(CCActionInterval *pAction)
{
　　//使用new创建一个当前类实例.
    CCActionEase *pRet = new CCActionEase();
    if (pRet)
　　　{
　　　　　//初始化.
        if (pRet->initWithAction(pAction))
        {
　　 //交由内存管理器进行释放管理.
            pRet->autorelease();
        }
        else
        {
　　 //如果初始化失败,则直接释放
            CC_SAFE_RELEASE_NULL(pRet);
        }
    }
　　//返回创建的实例.
    return pRet;
}
//初始化.
bool CCActionEase::initWithAction(CCActionInterval *pAction)
{
　　//有效性判断.
    CCAssert(pAction != NULL, "");
　　//先调用基类的初始化函数.
    if (CCActionInterval::initWithDuration(pAction->getDuration()))
　　　{
　　　　　//如果成功保存参数动画,本着"占用就加1"的原则,对其引用计数加一.
        m_pOther = pAction;
        pAction->retain();

        return true;
    }

    return false;
}
//产生一个当前类的实例拷贝.
CCObject* CCActionEase::copyWithZone(CCZone *pZone)
{
　　//
    CCZone* pNewZone = NULL;
    CCActionEase* pCopy = NULL;
    //判断参数有效以及其内部已经有创建好的拷贝。
　　if(pZone && pZone->m_pCopyObject) 
    {
        //直接强转后返回这个创建好的拷贝。
        pCopy = (CCActionEase*)(pZone->m_pCopyObject);
    }
    else
　　　{
　　　　　//如果无效，新创建一个当前类实例，并创建一个用于拷贝的类实例，将当前类实例设为拷贝类实例的内部拷贝，其实就是建立一个通用的拷贝对象，它内部有一个万物基类CCObject的指针，用来保存各个派生类的实例对象。
        pCopy = new CCActionEase();
        pZone = pNewZone = new CCZone(pCopy);
    }
　　//先调用基类的相应函数对其进行基类属性的相关初始化，这个函数会一层层调用当前类基类直至CCAction的相应函数。
    CCActionInterval::copyWithZone(pZone);
　　//使用保存的匀速动画来初始化拷贝实例。
    pCopy->initWithAction((CCActionInterval *)(m_pOther->copy()->autorelease()));
    //释放通用的拷贝对象。
    CC_SAFE_DELETE(pNewZone);
    return pCopy;
}
//析构
CCActionEase::~CCActionEase(void)
{
　　//释放占用的匀速动画实例。
    CC_SAFE_RELEASE(m_pOther);
}

//指定演示当前动画的演员。
void CCActionEase::startWithTarget(CCNode *pTarget)
{
　　//调用基类的相应函数。
　　　CCActionInterval::startWithTarget(pTarget);
　　　//设定匀速动画的演员。
    m_pOther->startWithTarget(m_pTarget);
}
//停止当前动画。
void CCActionEase::stop(void)
{
　　//让匀速动画停止播放。
　　　m_pOther->stop();
　　　//调用基类的相应函数停止当前动画。
    CCActionInterval::stop();
}
//更新动画。
void CCActionEase::update(float time)
{
　　//更新匀速动画。
    m_pOther->update(time);
}
//创建一个反向播放的变速动画。
CCActionInterval* CCActionEase::reverse(void)
{
　　//通过创建一个反向播放的匀速动画做为参数来创建相应的变速动画。
    return CCActionEase::create(m_pOther->reverse());
}

       上面只是一个基类，它并未真正的提供速度的变化调节，下面还有一个基类，提供了一个速度调节系数值。

//可以设定速度的变速动画基类。
class CC_DLL CCEaseRateAction : public CCActionEase
{
public:
	//析构函数。
    virtual ~CCEaseRateAction(void);

    //设置速度调节系数。
    inline void setRate(float rate) { m_fRate = rate; }
    //取得速度调节系数。
    inline float getRate(void) { return m_fRate; }

    //初始化当前动画。
    bool initWithAction(CCActionInterval *pAction, float fRate);
	//创建一个当前动画的实例拷贝。
　　　virtual CCObject* copyWithZone(CCZone* pZone);
　　　//创建一个反向播放的当前动画。
    virtual CCActionInterval* reverse(void);

public:
    //静态函数：创建对应匀速动画的变速动画，参数一为一个匀速动画。参数二为速度。内部调用create实现。
    CC_DEPRECATED_ATTRIBUTE static CCEaseRateAction* actionWithAction(CCActionInterval* pAction, float fRate);

   //同上。
    static CCEaseRateAction* create(CCActionInterval* pAction, float fRate);

protected:
	//保存速度调节系数值。
    float m_fRate;
};

CPP实现:


 //静态函数：创建对应匀速动画的变速动画，参数一为一个匀速动画。参数二为速度。内部调用create实现。
CCEaseRateAction* CCEaseRateAction::actionWithAction(CCActionInterval *pAction, float fRate)
{
    return CCEaseRateAction::create(pAction, fRate);
}
//同上。
CCEaseRateAction* CCEaseRateAction::create(CCActionInterval *pAction, float fRate)
{
　　//先创建相应的变速动画。
    CCEaseRateAction *pRet = new CCEaseRateAction();
    if (pRet)
　　　{
　　　　　//如果成功，进行初始化后交由内存管理器处理。
        if (pRet->initWithAction(pAction, fRate))
        {
            pRet->autorelease();
        }
        else
        {
　　//如果失败，释放并置空。
            CC_SAFE_RELEASE_NULL(pRet);
        }
    }

    return pRet;
}

//初始化函数。
bool CCEaseRateAction::initWithAction(CCActionInterval *pAction, float fRate)
{
　　//调用基类的初始化处理。
    if (CCActionEase::initWithAction(pAction))
　　　{
　　　　　//保存速度。
        m_fRate = fRate;
        return true;
    }

    return false;
}

//产生一个当前类的实例拷贝。参见基类的解释。
CCObject* CCEaseRateAction::copyWithZone(CCZone *pZone)
{
    CCZone* pNewZone = NULL;
    CCEaseRateAction* pCopy = NULL;
    if(pZone && pZone->m_pCopyObject) 
    {
        //in case of being called at sub class
        pCopy = (CCEaseRateAction*)(pZone->m_pCopyObject);
    }
    else
    {
        pCopy = new CCEaseRateAction();
        pNewZone = new CCZone(pCopy);
    }

    pCopy->initWithAction((CCActionInterval*)(m_pOther->copy()->autorelease()), m_fRate);

    CC_SAFE_DELETE(pNewZone);
    return pCopy;
}

//析构
CCEaseRateAction::~CCEaseRateAction(void)
{
}
//创建一个反向播放的变速动画。
CCActionInterval* CCEaseRateAction::reverse(void)
{
    return CCEaseRateAction::create(m_pOther->reverse(), 1 / m_fRate);
}

       第二个类有了速度属性，但这个速度属性并未对动画起任何作用。后面的类由这个带速度属性的动画基类派生，真正实现相应的变速效果。


//由快变慢的变速动画。
class CC_DLL CCEaseIn : public CCEaseRateAction
{
public:
	//更新动画。
　　　virtual void update(float time);
　　　//创建一个反向播放的当前动画。
　　　virtual CCActionInterval* reverse(void);
　　　//创建一个当前动画的实例拷贝。
    virtual CCObject* copyWithZone(CCZone* pZone);
public:
　　　//静态函数：创建对应匀速动画的变速动画，参数一为一个匀速动画。参数二为速度。内部调用create实现。
　　　  CC_DEPRECATED_ATTRIBUTE static CCEaseIn* actionWithAction(CCActionInterval* pAction, float fRate);

     //同上。
    static CCEaseIn* create(CCActionInterval* pAction, float fRate);
};

CPP:


//静态函数：创建对应匀速动画的变速动画，参数一为一个匀速动画。参数二为速度。内部调用create实现。
CCEaseIn* CCEaseIn::actionWithAction(CCActionInterval *pAction, float fRate)
{
    return CCEaseIn::create(pAction, fRate);
}
//同上，参见CCEaseRateAction的create函数。
CCEaseIn* CCEaseIn::create(CCActionInterval *pAction, float fRate)
{
    CCEaseIn *pRet = new CCEaseIn();
    if (pRet)
    {
        if (pRet->initWithAction(pAction, fRate))
        {
            pRet->autorelease();
        }
        else
        {
            CC_SAFE_RELEASE_NULL(pRet);
        }
    }

    return pRet;
}
//产生一个当前类的实例的拷贝，参见CCEaseRateAction的相应函数。
CCObject* CCEaseIn::copyWithZone(CCZone *pZone)
{
    CCZone* pNewZone = NULL;
    CCEaseIn* pCopy = NULL;
    if(pZone && pZone->m_pCopyObject) 
    {
        //in case of being called at sub class
        pCopy = (CCEaseIn*)(pZone->m_pCopyObject);
    }
    else
    {
        pCopy = new CCEaseIn();
        pNewZone = new CCZone(pCopy);
    }

    pCopy->initWithAction((CCActionInterval*)(m_pOther->copy()->autorelease()), m_fRate);

    CC_SAFE_DELETE(pNewZone);
    return pCopy;
}
//更新动画。
void CCEaseIn::update(float time)
{
　　//这里使用了一个浮点的m_fRate次方计算,time值在0~1间变化，但使用powf（time,m_fRate）会在第一象限生成一个曲线。
　　　m_pOther->update(powf(time, m_fRate));
　　　//后面的图把m_fRate在0.1到10之间的曲线表现出来，其中X方向代表的是time，也就是进度，系数值就是m_fRate，红色线代表了powf(time,m_fRate)函数。大家可以看到，在m_fRate小于1时函数是先很短时间内达到接近1之后的增速越来越慢，大于1时函数是开始基本都不递增，到后面增速加快，最后非常快。
}

//创建一个反向播放的变速动画。
CCActionInterval*   CCEaseIn::reverse(void)
{
       return       CCEaseIn::create(m_pOther->reverse(),m_fRate);
}




//由慢变快的变速动画，与上个类基个相同，只是在更新函数中速度值不同。
class CC_DLL CCEaseOut : public CCEaseRateAction
{
public:
   //更新动画。
　　　virtual void update(float time);
　　　//创建一个反向播放的当前动画。
　　　virtual CCActionInterval* reverse(void);
　　　//创建一个当前动画的实例拷贝。
    virtual CCObject* copyWithZone(CCZone* pZone);

public:
　　　//静态函数：创建对应匀速动画的变速动画，参数为一个匀速动画。内部调用create实现。
    CC_DEPRECATED_ATTRIBUTE static CCEaseOut* actionWithAction(CCActionInterval* pAction, float fRate);

     //同上。
    static CCEaseOut* create(CCActionInterval* pAction, float fRate);
};

CPP: 

//静态函数：创建对应匀速动画的变速动画，参数一为一个匀速动画。参数二为速度。内部调用create实现。
CCEaseOut* CCEaseOut::actionWithAction(CCActionInterval *pAction, float fRate)
{
    return CCEaseOut::create(pAction, fRate);
}
//同上。
CCEaseOut* CCEaseOut::create(CCActionInterval *pAction, float fRate)
{
    CCEaseOut *pRet = new CCEaseOut();
    if (pRet)
    {
        if (pRet->initWithAction(pAction, fRate))
        {
            pRet->autorelease();
        }
        else
        {
            CC_SAFE_RELEASE_NULL(pRet);
        }
    }

    return pRet;   
}
//产生一个当前类的实例拷贝
CCObject* CCEaseOut::copyWithZone(CCZone *pZone)
{
    CCZone* pNewZone = NULL;
    CCEaseOut* pCopy = NULL;
    if(pZone && pZone->m_pCopyObject) 
    {
        //in case of being called at sub class
        pCopy = (CCEaseOut*)(pZone->m_pCopyObject);
    }
    else
    {
        pCopy = new CCEaseOut();
        pNewZone = new CCZone(pCopy);
    }

    pCopy->initWithAction((CCActionInterval*)(m_pOther->copy()->autorelease()), m_fRate);

    CC_SAFE_DELETE(pNewZone);
    return pCopy;
}
//更新函数。
void CCEaseOut::update(float time)
{
　　//本动画与上面的动画相似。我也给出曲线图：
    m_pOther->update(powf(time, 1 / m_fRate));
}
//创建一个反向播放的变速动画。
CCActionInterval* CCEaseOut::reverse()
{
    return CCEaseOut::create(m_pOther->reverse(), 1 / m_fRate);
}



class CC_DLL CCEaseInOut : public CCEaseRateAction
{
public:
   //更新动画。
　　　virtual void update(float time);
　　　//创建一个反向播放的当前动画。
　　　virtual CCActionInterval* reverse(void);
　　　//创建一个当前动画的实例拷贝。
    virtual CCObject* copyWithZone(CCZone* pZone);

public:
　　//静态函数：创建对应匀速动画的变速动画，参数一为一个匀速动画。参数二为速度。内部调用create实现。
    CC_DEPRECATED_ATTRIBUTE static CCEaseInOut* actionWithAction(CCActionInterval* pAction, float fRate);

     //同上。
    static CCEaseInOut* create(CCActionInterval* pAction, float fRate);
};
//静态函数：创建对应匀速动画的变速动画，参数一为一个匀速动画。参数二为速度。内部调用create实现。
CCEaseInOut* CCEaseInOut::actionWithAction(CCActionInterval *pAction, float fRate)
{
    return CCEaseInOut::create(pAction, fRate);
}
//同上
CCEaseInOut* CCEaseInOut::create(CCActionInterval *pAction, float fRate)
{
    CCEaseInOut *pRet = new CCEaseInOut();
    if (pRet)
    {
        if (pRet->initWithAction(pAction, fRate))
        {
            pRet->autorelease();
        }
        else
        {
            CC_SAFE_RELEASE_NULL(pRet);
        }
    }

    return pRet; 
}
//创建一个当前类的实例拷贝。
CCObject* CCEaseInOut::copyWithZone(CCZone *pZone)
{
    CCZone* pNewZone = NULL;
    CCEaseInOut* pCopy = NULL;
    if(pZone && pZone->m_pCopyObject) 
    {
        //in case of being called at sub class
        pCopy = (CCEaseInOut*)(pZone->m_pCopyObject);
    }
    else
    {
        pCopy = new CCEaseInOut();
        pNewZone = new CCZone(pCopy);
    }

    pCopy->initWithAction((CCActionInterval*)(m_pOther->copy()->autorelease()), m_fRate);

    CC_SAFE_DELETE(pNewZone);
    return pCopy;
}

//更新动画的函数。
void CCEaseInOut::update(float time)
{
　　//这个曲线稍复杂，继续上图
    time *= 2;
    if (time < 1)
    {
        m_pOther->update(0.5f * powf(time, m_fRate));
    }
    else
    {
        m_pOther->update(1.0f - 0.5f * powf(2-time, m_fRate));
    }
}
//创建一个反向播放的变速动画。
CCActionInterval* CCEaseInOut::reverse(void)
{
    return CCEaseInOut::create(m_pOther->reverse(), m_fRate);
}



class CC_DLL CCEaseExponentialIn : public CCActionEase
{
public:
    //更新动画。
　　　virtual void update(float time);
　　　//创建一个反向播放的当前动画。
　　　virtual CCActionInterval* reverse(void);
　　　//创建一个当前动画的实例拷贝。
    virtual CCObject* copyWithZone(CCZone* pZone);

public:
　　　 //静态函数：创建对应匀速动画的变速动画，参数为一个匀速动画。内部调用create实现。
    CC_DEPRECATED_ATTRIBUTE static CCEaseExponentialIn* actionWithAction(CCActionInterval* pAction);
     //同上。
    static CCEaseExponentialIn* create(CCActionInterval* pAction);
};
//静态函数：创建对应匀速动画的变速动画，参数为一个匀速动画。内部调用create实现。
CCEaseExponentialIn* CCEaseExponentialIn::actionWithAction(CCActionInterval* pAction)
{
    return CCEaseExponentialIn::create(pAction);
}
//同上。
CCEaseExponentialIn* CCEaseExponentialIn::create(CCActionInterval* pAction)
{
    CCEaseExponentialIn *pRet = new CCEaseExponentialIn();
    if (pRet)
    {
        if (pRet->initWithAction(pAction))
        {
            pRet->autorelease();
        }
        else
        {
            CC_SAFE_RELEASE_NULL(pRet);
        }
    }

    return pRet;    
}
//创建一个当前类的实例拷贝。
CCObject* CCEaseExponentialIn::copyWithZone(CCZone *pZone)
{
    CCZone* pNewZone = NULL;
    CCEaseExponentialIn* pCopy = NULL;
    if(pZone && pZone->m_pCopyObject) 
    {
        //in case of being called at sub class
        pCopy = (CCEaseExponentialIn*)(pZone->m_pCopyObject);
    }
    else
    {
        pCopy = new CCEaseExponentialIn();
        pNewZone = new CCZone(pCopy);
    }

    pCopy->initWithAction((CCActionInterval *)(m_pOther->copy()->autorelease()));
    
    CC_SAFE_DELETE(pNewZone);
    return pCopy;
}

//更新动画。
void CCEaseExponentialIn::update(float time)
{
　　//不废话，上曲线，此曲线没有系数。是固定曲线。
    m_pOther->update(time == 0 ? 0 : powf(2, 10 * (time/1 - 1)) - 1 * 0.001f);
}

//创建一个反向播放的变速动画。
CCActionInterval* CCEaseExponentialIn::reverse(void)
{
    return CCEaseExponentialOut::create(m_pOther->reverse());
}



class CC_DLL CCEaseExponentialOut : public CCActionEase
{
public:
    //更新动画。
　　　virtual void update(float time);
　　　//创建一个反向播放的当前动画。
　　　virtual CCActionInterval* reverse(void);
　　　//创建一个当前动画的实例拷贝。
    virtual CCObject* copyWithZone(CCZone* pZone);

public:
　　　//静态函数：创建对应匀速动画的变速动画，参数为一个匀速动画。内部调用create实现。
    CC_DEPRECATED_ATTRIBUTE static CCEaseExponentialOut* actionWithAction(CCActionInterval* pAction);
     //同上。
    static CCEaseExponentialOut* create(CCActionInterval* pAction);
};
//静态函数：创建对应匀速动画的变速动画，参数为一个匀速动画。内部调用create实现。
CCEaseExponentialOut* CCEaseExponentialOut::actionWithAction(CCActionInterval* pAction)
{
    return CCEaseExponentialOut::create(pAction);
}
 //同上。
CCEaseExponentialOut* CCEaseExponentialOut::create(CCActionInterval* pAction)
{
    CCEaseExponentialOut *pRet = new CCEaseExponentialOut();
    if (pRet)
    {
        if (pRet->initWithAction(pAction))
        {
            pRet->autorelease();
        }
        else
        {
            CC_SAFE_RELEASE_NULL(pRet);
        }
    }

    return pRet; 
}
//创建一个当前动画的实例拷贝。
CCObject* CCEaseExponentialOut::copyWithZone(CCZone *pZone)
{
    CCZone* pNewZone = NULL;
    CCEaseExponentialOut* pCopy = NULL;
    if(pZone && pZone->m_pCopyObject) 
    {
        //in case of being called at sub class
        pCopy = (CCEaseExponentialOut*)(pZone->m_pCopyObject);
    }
    else
    {
        pCopy = new CCEaseExponentialOut();
        pNewZone = new CCZone(pCopy);
    }

    pCopy->initWithAction((CCActionInterval *)(m_pOther->copy()->autorelease()));
    
    CC_SAFE_DELETE(pNewZone);
    return pCopy;
}
//更新函数。
void CCEaseExponentialOut::update(float time)
{
　　//上曲线说明，此曲线没有系数。是固定曲线。
　　
    m_pOther->update(time == 1 ? 1 : (-powf(2, -10 * time / 1) + 1));
}
//创建一个反向播放的当前动画。
CCActionInterval* CCEaseExponentialOut::reverse(void)
{
    return CCEaseExponentialIn::create(m_pOther->reverse());
}



class CC_DLL CCEaseExponentialInOut : public CCActionEase
{
public:
    //更新动画。
　　　virtual void update(float time);
　　　//创建一个反向播放的当前动画。
　　　virtual CCActionInterval* reverse(void);
　　　//创建一个当前动画的实例拷贝。
    virtual CCObject* copyWithZone(CCZone* pZone);
public:
　　　//静态函数：创建对应匀速动画的变速动画，参数为一个匀速动画。内部调用create实现。
    CC_DEPRECATED_ATTRIBUTE static CCEaseExponentialInOut* actionWithAction(CCActionInterval* pAction);

　　　//同上。
    static CCEaseExponentialInOut* create(CCActionInterval* pAction);
};
//静态函数：创建对应匀速动画的变速动画，参数为一个匀速动画。内部调用create实现。
CCEaseExponentialInOut* CCEaseExponentialInOut::actionWithAction(CCActionInterval *pAction)
{
    return CCEaseExponentialInOut::create(pAction);
}
//同上。
CCEaseExponentialInOut* CCEaseExponentialInOut::create(CCActionInterval *pAction)
{
    CCEaseExponentialInOut *pRet = new CCEaseExponentialInOut();
    if (pRet)
    {
        if (pRet->initWithAction(pAction))
        {
            pRet->autorelease();
        }
        else
        {
            CC_SAFE_RELEASE_NULL(pRet);
        }
    }

    return pRet; 
}
//创建一个当前动画的实例拷贝。
CCObject* CCEaseExponentialInOut::copyWithZone(CCZone *pZone)
{
    CCZone* pNewZone = NULL;
    CCEaseExponentialInOut* pCopy = NULL;
    if(pZone && pZone->m_pCopyObject) 
    {
        //in case of being called at sub class
        pCopy = (CCEaseExponentialInOut*)(pZone->m_pCopyObject);
    }
    else
    {
        pCopy = new CCEaseExponentialInOut();
        pNewZone = new CCZone(pCopy);
    }

    pCopy->initWithAction((CCActionInterval *)(m_pOther->copy()->autorelease()));
    
    CC_SAFE_DELETE(pNewZone);
    return pCopy;
}
//动画更新。
void CCEaseExponentialInOut::update(float time)
{
　　//上曲线，没有系数，固定曲线
　　
    time /= 0.5f;
    if (time < 1)
    {
        time = 0.5f * powf(2, 10 * (time - 1));
    }
    else
    {
        time = 0.5f * (-powf(2, -10 * (time - 1)) + 2);
    }

    m_pOther->update(time);
}
//创建一个反向播放的当前动画。
CCActionInterval* CCEaseExponentialInOut::reverse()
{
    return CCEaseExponentialInOut::create(m_pOther->reverse());
}


//cos曲线方式变化的变速动画。
class CC_DLL CCEaseSineIn : public CCActionEase
{
public:
    //更新动画。
　　　virtual void update(float time);
　　　//创建一个反向播放的当前动画。
　　　virtual CCActionInterval* reverse(void);
　　　//创建一个当前动画的实例拷贝。
    virtual CCObject* copyWithZone(CCZone* pZone);

public:
　　　//静态函数：创建对应匀速动画的变速动画，参数为一个匀速动画。内部调用create实现。
    CC_DEPRECATED_ATTRIBUTE static CCEaseSineIn* actionWithAction(CCActionInterval* pAction);
    //同上
    static CCEaseSineIn* create(CCActionInterval* pAction);
};
//静态函数：创建对应匀速动画的变速动画，参数为一个匀速动画。内部调用create实现。
CCEaseSineIn* CCEaseSineIn::actionWithAction(CCActionInterval* pAction)
{
    return CCEaseSineIn::create(pAction);
}
//同上
CCEaseSineIn* CCEaseSineIn::create(CCActionInterval* pAction)
{
    CCEaseSineIn *pRet = new CCEaseSineIn();
    if (pRet)
    {
        if (pRet->initWithAction(pAction))
        {
            pRet->autorelease();
        }
        else
        {
            CC_SAFE_RELEASE_NULL(pRet);
        }
    }

    return pRet; 
}
//创建一个当前动画的实例拷贝。
CCObject* CCEaseSineIn::copyWithZone(CCZone *pZone)
{
    CCZone* pNewZone = NULL;
    CCEaseSineIn* pCopy = NULL;
    if(pZone && pZone->m_pCopyObject)
    {
        //in case of being called at sub class
        pCopy = (CCEaseSineIn*)(pZone->m_pCopyObject);
    }
    else
    {
        pCopy = new CCEaseSineIn();
        pNewZone = new CCZone(pCopy);
    }

    pCopy->initWithAction((CCActionInterval *)(m_pOther->copy()->autorelease()));
    
    CC_SAFE_DELETE(pNewZone);
    return pCopy;
}
//更新
void CCEaseSineIn::update(float time)
{	//上曲线图，无需参数，固定曲线:
　　
    m_pOther->update(-1 * cosf(time * (float)M_PI_2) + 1);
}
//创建一个反向播放的当前动画。
CCActionInterval* CCEaseSineIn::reverse(void)
{
    return CCEaseSineOut::create(m_pOther->reverse());
}



//sin曲线方式变化的变速动画。
class CC_DLL CCEaseSineOut : public CCActionEase
{
public:
    //更新动画。
　　　virtual void update(float time);
　　　//创建一个反向播放的当前动画。
　　　virtual CCActionInterval* reverse(void);
　　　//创建一个当前动画的实例拷贝。
    virtual CCObject* copyWithZone(CCZone* pZone);

public:
　　　//静态函数：创建对应匀速动画的变速动画，参数为一个匀速动画。内部调用create实现。
    CC_DEPRECATED_ATTRIBUTE static CCEaseSineOut* actionWithAction(CCActionInterval* pAction);
    //同上
    static CCEaseSineOut* create(CCActionInterval* pAction);
};
//静态函数：创建对应匀速动画的变速动画，参数为一个匀速动画。内部调用create实现。
CCEaseSineOut* CCEaseSineOut::actionWithAction(CCActionInterval* pAction)
{
    return CCEaseSineOut::create(pAction);
}
//同上
CCEaseSineOut* CCEaseSineOut::create(CCActionInterval* pAction)
{
    CCEaseSineOut *pRet = new CCEaseSineOut();
    if (pRet)
    {
        if (pRet->initWithAction(pAction))
        {
            pRet->autorelease();
        }
        else
        {
            CC_SAFE_RELEASE_NULL(pRet);
        }
    }

    return pRet; 
}
//创建一个当前动画的实例拷贝。
CCObject* CCEaseSineOut::copyWithZone(CCZone *pZone)
{
    CCZone* pNewZone = NULL;
    CCEaseSineOut* pCopy = NULL;
    if(pZone && pZone->m_pCopyObject) 
    {
        //in case of being called at sub class
        pCopy = (CCEaseSineOut*)(pZone->m_pCopyObject);
    }
    else
    {
        pCopy = new CCEaseSineOut();
        pNewZone = new CCZone(pCopy);
    }

    pCopy->initWithAction((CCActionInterval *)(m_pOther->copy()->autorelease()));
    
    CC_SAFE_DELETE(pNewZone);
    return pCopy;
}
//更新
void CCEaseSineOut::update(float time)
{
　　//上图说明:
　　
    m_pOther->update(sinf(time * (float)M_PI_2));
}
//创建一个反向播放的当前动画。
CCActionInterval* CCEaseSineOut::reverse(void)
{
    return CCEaseSineIn::create(m_pOther->reverse());
}



//另种cos曲线方式变化的变速动画。
class CC_DLL CCEaseSineInOut : public CCActionEase
{
public:
    //更新动画。
　　　virtual void update(float time);
　　　//创建一个反向播放的当前动画。
　　　virtual CCActionInterval* reverse(void);
　　　//创建一个当前动画的实例拷贝。
    virtual CCObject* copyWithZone(CCZone* pZone);

public:
　　　//静态函数：创建对应匀速动画的变速动画，参数为一个匀速动画。内部调用create实现。
    CC_DEPRECATED_ATTRIBUTE static CCEaseSineInOut* actionWithAction(CCActionInterval* pAction);
　　　//同上
    static CCEaseSineInOut* create(CCActionInterval* pAction);
};

//静态函数：创建对应匀速动画的变速动画，参数为一个匀速动画。内部调用create实现。
CCEaseSineInOut* CCEaseSineInOut::actionWithAction(CCActionInterval* pAction)
{
    return CCEaseSineInOut::create(pAction);
}
//同上
CCEaseSineInOut* CCEaseSineInOut::create(CCActionInterval* pAction)
{
    CCEaseSineInOut *pRet = new CCEaseSineInOut();
    if (pRet)
    {
        if (pRet->initWithAction(pAction))
        {
            pRet->autorelease();
        }
        else
        {
            CC_SAFE_RELEASE_NULL(pRet);
        }
    }

    return pRet; 
}
//创建一个当前动画的实例拷贝。
CCObject* CCEaseSineInOut::copyWithZone(CCZone *pZone)
{
    CCZone* pNewZone = NULL;
    CCEaseSineInOut* pCopy = NULL;
    if(pZone && pZone->m_pCopyObject) 
    {
        //in case of being called at sub class
        pCopy = (CCEaseSineInOut*)(pZone->m_pCopyObject);
    }
    else
    {
        pCopy = new CCEaseSineInOut();
        pNewZone = new CCZone(pCopy);
    }

    pCopy->initWithAction((CCActionInterval *)(m_pOther->copy()->autorelease()));
    
    CC_SAFE_DELETE(pNewZone);
    return pCopy;
}
//更新函数。
void CCEaseSineInOut::update(float time)
{
　　//上曲线说明：
    m_pOther->update(-0.5f * (cosf((float)M_PI * time) - 1));
}

//创建一个反向播放的当前动画。
CCActionInterval* CCEaseSineInOut::reverse()
{
    return CCEaseSineInOut::create(m_pOther->reverse());
}



//一个基类，用于衍生后面的变速动画。
class CC_DLL CCEaseElastic : public CCActionEase
{
public:
    //取得系数
    inline float getPeriod(void) { return m_fPeriod; }
　　　//设置系数
    inline void setPeriod(float fPeriod) { m_fPeriod = fPeriod; }

    //初始化函数。
    bool initWithAction(CCActionInterval *pAction, float fPeriod = 0.3f);
　　//创建一个反向播放的当前动画。
　　　virtual CCActionInterval* reverse(void);
　　　
　　//创建一个当前动画的实例拷贝。
    virtual CCObject* copyWithZone(CCZone* pZone);

public:
    //静态函数：创建对应匀速动画的变速动画，参数一为一个匀速动画。参数二为系数。内部调用create实现。
    CC_DEPRECATED_ATTRIBUTE static CCEaseElastic* actionWithAction(CCActionInterval *pAction, float fPeriod = 0.3f);
    //同上
    static CCEaseElastic* create(CCActionInterval *pAction, float fPeriod = 0.3f);
protected:
　　 //曲线系数。
    float m_fPeriod;
};

//静态函数：创建对应匀速动画的变速动画，参数一为一个匀速动画。参数二为系数。内部调用create实现。
CCEaseElastic* CCEaseElastic::actionWithAction(CCActionInterval *pAction, float fPeriod/* = 0.3f*/)
{
    return CCEaseElastic::create(pAction, fPeriod);
}
 //同上
CCEaseElastic* CCEaseElastic::create(CCActionInterval *pAction, float fPeriod/* = 0.3f*/)
{
    CCEaseElastic *pRet = new CCEaseElastic();
    if (pRet)
    {
        if (pRet->initWithAction(pAction, fPeriod))
        {
            pRet->autorelease();
        }
        else
        {
            CC_SAFE_RELEASE_NULL(pRet);
        }
    }

    return pRet; 
}
//初始化函数。
bool CCEaseElastic::initWithAction(CCActionInterval *pAction, float fPeriod/* = 0.3f*/)
{
    if (CCActionEase::initWithAction(pAction))
　　　{
　　　　　//保存曲线系数。
        m_fPeriod = fPeriod;
        return true;
    }

    return false;
}
　　
//创建一个当前动画的实例拷贝。
CCObject* CCEaseElastic::copyWithZone(CCZone *pZone)
{
    CCZone* pNewZone = NULL;
    CCEaseElastic* pCopy = NULL;
    if(pZone && pZone->m_pCopyObject) 
    {
        //in case of being called at sub class
        pCopy = (CCEaseElastic*)(pZone->m_pCopyObject);
    }
    else
    {
        pCopy = new CCEaseElastic();
        pNewZone = new CCZone(pCopy);
    }

    pCopy->initWithAction((CCActionInterval *)(m_pOther->copy()->autorelease()), m_fPeriod);

    CC_SAFE_DELETE(pNewZone);
    return pCopy;
}
//创建一个反向播放的当前动画。
CCActionInterval* CCEaseElastic::reverse(void)
{
    CCAssert(0, "Override me");

    return NULL;
}

//上面基类衍生的新类。
class CC_DLL CCEaseElasticIn : public CCEaseElastic
{
public:
    //更新动画。
　　　virtual void update(float time);
　　　//创建一个反向播放的当前动画。
　　　virtual CCActionInterval* reverse(void);
　　　//创建一个当前动画的实例拷贝。
    virtual CCObject* copyWithZone(CCZone* pZone);

public:
　　　//静态函数：创建对应匀速动画的变速动画，第一参数为一个匀速动画。第二参数为曲线系数，内部调用create实现。
    CC_DEPRECATED_ATTRIBUTE static CCEaseElasticIn* actionWithAction(CCActionInterval *pAction, float fPeriod = 0.3f);
    //同上。
    static CCEaseElasticIn* create(CCActionInterval *pAction, float fPeriod = 0.3f);
};

//静态函数：创建对应匀速动画的变速动画，第一参数为一个匀速动画。第二参数为曲线系数，内部调用create实现。
CCEaseElasticIn* CCEaseElasticIn::actionWithAction(CCActionInterval *pAction, float fPeriod/* = 0.3f*/)
{
    return CCEaseElasticIn::create(pAction, fPeriod);
}
 //同上。
CCEaseElasticIn* CCEaseElasticIn::create(CCActionInterval *pAction, float fPeriod/* = 0.3f*/)
{
    CCEaseElasticIn *pRet = new CCEaseElasticIn();
    if (pRet)
    {
        if (pRet->initWithAction(pAction, fPeriod))
        {
            pRet->autorelease();
        }
        else
        {
            CC_SAFE_RELEASE_NULL(pRet);
        }
    }

    return pRet; 
}
//创建一个当前动画的实例拷贝。
CCObject* CCEaseElasticIn::copyWithZone(CCZone *pZone)
{
    CCZone* pNewZone = NULL;
    CCEaseElasticIn* pCopy = NULL;
    if(pZone && pZone->m_pCopyObject) 
    {
        //in case of being called at sub class
        pCopy = (CCEaseElasticIn*)(pZone->m_pCopyObject);
    }
    else
    {
        pCopy = new CCEaseElasticIn();
        pNewZone = new CCZone(pCopy);
    }

    pCopy->initWithAction((CCActionInterval *)(m_pOther->copy()->autorelease()), m_fPeriod);

    CC_SAFE_DELETE(pNewZone);
    return pCopy;
}
//更新动画。
void CCEaseElasticIn::update(float time)
{
　　//比较复杂，上图说明在不同的系数时的曲线结果：
　　
    float newT = 0;
    if (time == 0 || time == 1)
    {
        newT = time;
    }
    else
    {
        float s = m_fPeriod / 4;
        time = time - 1;
        newT = -powf(2, 10 * time) * sinf((time - s) * M_PI_X_2 / m_fPeriod);
    }

    m_pOther->update(newT);
}
//创建一个反向播放的当前动画。
CCActionInterval* CCEaseElasticIn::reverse(void)
{
    return CCEaseElasticOut::create(m_pOther->reverse(), m_fPeriod);
}


class CC_DLL CCEaseElasticOut : public CCEaseElastic
{
public:
    //更新动画。
　　　virtual void update(float time);
　　　//创建一个反向播放的当前动画。
　　　virtual CCActionInterval* reverse(void);
　　　//创建一个当前动画的实例拷贝。
    virtual CCObject* copyWithZone(CCZone* pZone);

public:
　　　//静态函数：创建对应匀速动画的变速动画，第一参数为一个匀速动画。第二参数为曲线系数，内部调用create实现。
    CC_DEPRECATED_ATTRIBUTE static CCEaseElasticOut* actionWithAction(CCActionInterval *pAction, float fPeriod = 0.3f);

    //同上
    static CCEaseElasticOut* create(CCActionInterval *pAction, float fPeriod = 0.3f);
};
　　　//静态函数：创建对应匀速动画的变速动画，第一参数为一个匀速动画。第二参数为曲线系数，内部调用create实现。

CCEaseElasticOut* CCEaseElasticOut::actionWithAction(CCActionInterval *pAction, float fPeriod/* = 0.3f*/)
{
    return CCEaseElasticOut::create(pAction, fPeriod);
}
//同上
CCEaseElasticOut* CCEaseElasticOut::create(CCActionInterval *pAction, float fPeriod/* = 0.3f*/)
{
    CCEaseElasticOut *pRet = new CCEaseElasticOut();
    if (pRet)
    {
        if (pRet->initWithAction(pAction, fPeriod))
        {
            pRet->autorelease();
        }
        else
        {
            CC_SAFE_RELEASE_NULL(pRet);
        }
    }

    return pRet; 
}
//创建一个当前动画的实例拷贝。
CCObject *CCEaseElasticOut::copyWithZone(CCZone *pZone)
{
    CCZone* pNewZone = NULL;
    CCEaseElasticOut* pCopy = NULL;
    if(pZone && pZone->m_pCopyObject) 
    {
        //in case of being called at sub class
        pCopy = (CCEaseElasticOut*)(pZone->m_pCopyObject);
    }
    else
    {
        pCopy = new CCEaseElasticOut();
        pNewZone = new CCZone(pCopy);
    }

    pCopy->initWithAction((CCActionInterval *)(m_pOther->copy()->autorelease()), m_fPeriod);

    CC_SAFE_DELETE(pNewZone);
    return pCopy;
}
//更新动画。
void CCEaseElasticOut::update(float time)
{
　　//继续上曲线说明：
　　
    float newT = 0;
    if (time == 0 || time == 1)
    {
        newT = time;
    }
    else
    {
        float s = m_fPeriod / 4;
        newT = powf(2, -10 * time) * sinf((time - s) * M_PI_X_2 / m_fPeriod) + 1;
    }

    m_pOther->update(newT);
}
//创建一个反向播放的当前动画。
CCActionInterval* CCEaseElasticOut::reverse(void)
{
    return CCEaseElasticIn::create(m_pOther->reverse(), m_fPeriod);
}



class CC_DLL CCEaseElasticInOut : public CCEaseElastic
{
public:
    //更新动画。
　　　virtual void update(float time);
　　　//创建一个反向播放的当前动画。
　　　virtual CCActionInterval* reverse(void);
　　　//创建一个当前动画的实例拷贝。
    virtual CCObject* copyWithZone(CCZone* pZone);

public:
　　　//静态函数：创建对应匀速动画的变速动画，第一参数为一个匀速动画。第二参数为曲线系数，内部调用create实现。
    CC_DEPRECATED_ATTRIBUTE static CCEaseElasticInOut* actionWithAction(CCActionInterval *pAction, float fPeriod = 0.3f);

    //同上
    static CCEaseElasticInOut* create(CCActionInterval *pAction, float fPeriod = 0.3f);
};
//静态函数：创建对应匀速动画的变速动画，第一参数为一个匀速动画。第二参数为曲线系数，内部调用create实现。
CCEaseElasticInOut* CCEaseElasticInOut::actionWithAction(CCActionInterval *pAction, float fPeriod/* = 0.3f*/)
{
    return CCEaseElasticInOut::create(pAction, fPeriod);
}
//同上
CCEaseElasticInOut* CCEaseElasticInOut::create(CCActionInterval *pAction, float fPeriod/* = 0.3f*/)
{
    CCEaseElasticInOut *pRet = new CCEaseElasticInOut();
    if (pRet)
    {
        if (pRet->initWithAction(pAction, fPeriod))
        {
            pRet->autorelease();
        }
        else
        {
            CC_SAFE_RELEASE_NULL(pRet);
        }
    }

    return pRet; 
}
//创建一个当前动画的实例拷贝。
CCObject* CCEaseElasticInOut::copyWithZone(CCZone *pZone)
{
    CCZone* pNewZone = NULL;
    CCEaseElasticInOut* pCopy = NULL;
    if(pZone && pZone->m_pCopyObject) 
    {
        //in case of being called at sub class
        pCopy = (CCEaseElasticInOut*)(pZone->m_pCopyObject);
    }
    else
    {
        pCopy = new CCEaseElasticInOut();
        pNewZone = new CCZone(pCopy);
    }

    pCopy->initWithAction((CCActionInterval *)(m_pOther->copy()->autorelease()), m_fPeriod);

    CC_SAFE_DELETE(pNewZone);
    return pCopy;

}
//更新动画。
void CCEaseElasticInOut::update(float time)
{
　　//挺复杂的曲线：
　　
    float newT = 0;
    if (time == 0 || time == 1)
    {
        newT = time;
    }
    else
    {
        time = time * 2;
        if (! m_fPeriod)
        {
            m_fPeriod = 0.3f * 1.5f;
        }

        float s = m_fPeriod / 4;

        time = time - 1;
        if (time < 0)
        {
            newT = -0.5f * powf(2, 10 * time) * sinf((time -s) * M_PI_X_2 / m_fPeriod);
        }
        else
        {
            newT = powf(2, -10 * time) * sinf((time - s) * M_PI_X_2 / m_fPeriod) * 0.5f + 1;
        }
    }

    m_pOther->update(newT);
}
//创建一个反向播放的当前动画。
CCActionInterval* CCEaseElasticInOut::reverse(void)
{
    return CCEaseElasticInOut::create(m_pOther->reverse(), m_fPeriod);
}


//又是一个变速动画的基类，用于衍生一些复杂的变速曲线。
class CC_DLL CCEaseBounce : public CCActionEase
{
public:
　　//计算曲线处理
　　　float bounceTime(float time);
　　　//产生一个当前类的实例拷贝。
　　　virtual CCObject* copyWithZone(CCZone* pZone);
　　　//创建一个反向播放的当前动画
    virtual CCActionInterval* reverse();

public:
　　　//静态函数：创建对应匀速动画的变速动画，参数为一个匀速动画。内部调用create实现。
    CC_DEPRECATED_ATTRIBUTE static CCEaseBounce* actionWithAction(CCActionInterval* pAction);
    //同上。
    static CCEaseBounce* create(CCActionInterval* pAction);
};
　　　
//静态函数：创建对应匀速动画的变速动画，参数为一个匀速动画。内部调用create实现。
CCEaseBounce* CCEaseBounce::actionWithAction(CCActionInterval* pAction)
{
    return CCEaseBounce::create(pAction);
}
//同上。
CCEaseBounce* CCEaseBounce::create(CCActionInterval* pAction)
{
    CCEaseBounce *pRet = new CCEaseBounce();
    if (pRet)
    {
        if (pRet->initWithAction(pAction))
        {
            pRet->autorelease();
        }
        else
        {
            CC_SAFE_RELEASE_NULL(pRet);
        }
    }

    return pRet; 
}
//产生一个当前类的实例拷贝。
CCObject* CCEaseBounce::copyWithZone(CCZone *pZone)
{
    CCZone* pNewZone = NULL;
    CCEaseBounce* pCopy = NULL;
    if(pZone && pZone->m_pCopyObject) 
    {
        //in case of being called at sub class
        pCopy = (CCEaseBounce*)(pZone->m_pCopyObject);
    }
    else
    {
        pCopy = new CCEaseBounce();
        pNewZone = new CCZone(pCopy);
    }

    pCopy->initWithAction((CCActionInterval *)(m_pOther->copy()->autorelease()));
    
    CC_SAFE_DELETE(pNewZone);
    return pCopy;
}
//计算曲线处理
float CCEaseBounce::bounceTime(float time)
{
　　//复杂曲线说明：
　　
    if (time < 1 / 2.75)
    {
        return 7.5625f * time * time;
    } else 
    if (time < 2 / 2.75)
    {
        time -= 1.5f / 2.75f;
        return 7.5625f * time * time + 0.75f;
    } else
    if(time < 2.5 / 2.75)
    {
        time -= 2.25f / 2.75f;
        return 7.5625f * time * time + 0.9375f;
    }

    time -= 2.625f / 2.75f;
    return 7.5625f * time * time + 0.984375f;
}
//创建一个反向播放的当前动画
CCActionInterval* CCEaseBounce::reverse()
{
    return CCEaseBounce::create(m_pOther->reverse());
}


//上面类的衍生类。
class CC_DLL CCEaseBounceIn : public CCEaseBounce
{
public:
    //更新动画。
　　　virtual void update(float time);
　　　//创建一个反向播放的当前动画。
　　　virtual CCActionInterval* reverse(void);
　　　//创建一个当前动画的实例拷贝。
    virtual CCObject* copyWithZone(CCZone* pZone);

public:
　　　//静态函数：创建对应匀速动画的变速动画，参数为一个匀速动画。内部调用create实现。
    CC_DEPRECATED_ATTRIBUTE static CCEaseBounceIn* actionWithAction(CCActionInterval* pAction);
    //同上。
    static CCEaseBounceIn* create(CCActionInterval* pAction);
};
//静态函数：创建对应匀速动画的变速动画，参数为一个匀速动画。内部调用create实现。
CCEaseBounceIn* CCEaseBounceIn::actionWithAction(CCActionInterval* pAction)
{
    return CCEaseBounceIn::create(pAction);
}
//同上。
CCEaseBounceIn* CCEaseBounceIn::create(CCActionInterval* pAction)
{
    CCEaseBounceIn *pRet = new CCEaseBounceIn();
    if (pRet)
    {
        if (pRet->initWithAction(pAction))
        {
            pRet->autorelease();
        }
        else
        {
            CC_SAFE_RELEASE_NULL(pRet);
        }
    }

    return pRet; 
}
//创建一个当前动画的实例拷贝。
CCObject* CCEaseBounceIn::copyWithZone(CCZone *pZone)
{
    CCZone* pNewZone = NULL;
    CCEaseBounceIn* pCopy = NULL;
    if(pZone && pZone->m_pCopyObject) 
    {
        //in case of being called at sub class
        pCopy = (CCEaseBounceIn*)(pZone->m_pCopyObject);
    }
    else
    {
        pCopy = new CCEaseBounceIn();
        pNewZone = new CCZone(pCopy);
    }

    pCopy->initWithAction((CCActionInterval *)(m_pOther->copy()->autorelease()));
    
    CC_SAFE_DELETE(pNewZone);
    return pCopy;
}
//更新动画。
void CCEaseBounceIn::update(float time)
{
　　//先计算出变速曲线的结果然后做为进度值设置给匀速动画。
　　//曲线未设系数，为固定曲线。
　　
    float newT = 1 - bounceTime(1 - time);
    m_pOther->update(newT);
}
//创建一个反向播放的当前动画。
CCActionInterval* CCEaseBounceIn::reverse(void)
{
    return CCEaseBounceOut::create(m_pOther->reverse());
}



class CC_DLL CCEaseBounceOut : public CCEaseBounce
{
public:
    //更新动画。
　　　virtual void update(float time);
　　　//创建一个反向播放的当前动画。
　　　virtual CCActionInterval* reverse(void);
　　　//创建一个当前动画的实例拷贝。
    virtual CCObject* copyWithZone(CCZone* pZone);

public:
　　　//静态函数：创建对应匀速动画的变速动画，参数为一个匀速动画。内部调用create实现。
    CC_DEPRECATED_ATTRIBUTE static CCEaseBounceOut* actionWithAction(CCActionInterval* pAction);
    //同上
    static CCEaseBounceOut* create(CCActionInterval* pAction);
};
//静态函数：创建对应匀速动画的变速动画，参数为一个匀速动画。内部调用create实现。
CCEaseBounceOut* CCEaseBounceOut::actionWithAction(CCActionInterval* pAction)
{
    return CCEaseBounceOut::create(pAction);
}
//同上
CCEaseBounceOut* CCEaseBounceOut::create(CCActionInterval* pAction)
{
    CCEaseBounceOut *pRet = new CCEaseBounceOut();
    if (pRet)
    {
        if (pRet->initWithAction(pAction))
        {
            pRet->autorelease();
        }
        else
        {
            CC_SAFE_RELEASE_NULL(pRet);
        }
    }

    return pRet; 
}
//创建一个当前动画的实例拷贝。
CCObject* CCEaseBounceOut::copyWithZone(CCZone *pZone)
{
    CCZone* pNewZone = NULL;
    CCEaseBounceOut* pCopy = NULL;
    if(pZone && pZone->m_pCopyObject)
    {
        //in case of being called at sub class
        pCopy = (CCEaseBounceOut*)(pZone->m_pCopyObject);
    }
    else
    {
        pCopy = new CCEaseBounceOut();
        pNewZone = new CCZone(pCopy);
    }

    pCopy->initWithAction((CCActionInterval *)(m_pOther->copy()->autorelease()));
    
    CC_SAFE_DELETE(pNewZone);
    return pCopy;
}
//更新动画
void CCEaseBounceOut::update(float time)
{
　　//曲线说明:
　　//曲线未设系数，为固定曲线。
　　
    float newT = bounceTime(time);
    m_pOther->update(newT);
}
//创建一个反向播放的当前动画。
CCActionInterval* CCEaseBounceOut::reverse(void)
{
    return CCEaseBounceIn::create(m_pOther->reverse());
}


class CC_DLL CCEaseBounceInOut : public CCEaseBounce
{
public:
    //更新动画。
　　　virtual void update(float time);
　　　//创建一个反向播放的当前动画。
　　　virtual CCActionInterval* reverse(void);
　　　//创建一个当前动画的实例拷贝。
    virtual CCObject* copyWithZone(CCZone* pZone);

public:
　　　//静态函数：创建对应匀速动画的变速动画，参数为一个匀速动画。内部调用create实现。
    CC_DEPRECATED_ATTRIBUTE static CCEaseBounceInOut* actionWithAction(CCActionInterval* pAction);
    //同上
    static CCEaseBounceInOut* create(CCActionInterval* pAction);
};
　　　//静态函数：创建对应匀速动画的变速动画，参数为一个匀速动画。内部调用create实现。
CCEaseBounceInOut* CCEaseBounceInOut::actionWithAction(CCActionInterval* pAction)
{
    return CCEaseBounceInOut::create(pAction);
}
//同上
CCEaseBounceInOut* CCEaseBounceInOut::create(CCActionInterval* pAction)
{
    CCEaseBounceInOut *pRet = new CCEaseBounceInOut();
    if (pRet)
    {
        if (pRet->initWithAction(pAction))
        {
            pRet->autorelease();
        }
        else
        {
            CC_SAFE_RELEASE_NULL(pRet);
        }
    }

    return pRet; 
}
//创建一个当前动画的实例拷贝。
CCObject* CCEaseBounceInOut::copyWithZone(CCZone *pZone)
{
    CCZone* pNewZone = NULL;
    CCEaseBounceInOut* pCopy = NULL;
    if(pZone && pZone->m_pCopyObject) 
    {
        //in case of being called at sub class
        pCopy = (CCEaseBounceInOut*)(pZone->m_pCopyObject);
    }
    else
    {
        pCopy = new CCEaseBounceInOut();
        pNewZone = new CCZone(pCopy);
    }

    pCopy->initWithAction((CCActionInterval *)(m_pOther->copy()->autorelease()));
    
    CC_SAFE_DELETE(pNewZone);
    return pCopy;
}
//动画更新
void CCEaseBounceInOut::update(float time)
{
　　//曲线说明:
　　
    float newT = 0;
    if (time < 0.5f)
    {
        time = time * 2;
        newT = (1 - bounceTime(1 - time)) * 0.5f;
    }
    else
    {
        newT = bounceTime(time * 2 - 1) * 0.5f + 0.5f;
    }

    m_pOther->update(newT);
}
//创建一个反向播放的当前动画。

CCActionInterval* CCEaseBounceInOut::reverse()
{
    return CCEaseBounceInOut::create(m_pOther->reverse());
}


class CC_DLL CCEaseBackIn : public CCActionEase
{
public:
    //更新动画。
　　　virtual void update(float time);
　　　//创建一个反向播放的当前动画。
　　　virtual CCActionInterval* reverse(void);
　　　//创建一个当前动画的实例拷贝。
    virtual CCObject* copyWithZone(CCZone* pZone);

public:
　　　//静态函数：创建对应匀速动画的变速动画，参数为一个匀速动画。内部调用create实现。
    CC_DEPRECATED_ATTRIBUTE static CCEaseBackIn* actionWithAction(CCActionInterval* pAction);
    //同上
    static CCEaseBackIn* create(CCActionInterval* pAction);
};
//静态函数：创建对应匀速动画的变速动画，参数为一个匀速动画。内部调用create实现。
CCEaseBackIn* CCEaseBackIn::actionWithAction(CCActionInterval *pAction)
{
    return CCEaseBackIn::create(pAction);
}
//同上
CCEaseBackIn* CCEaseBackIn::create(CCActionInterval *pAction)
{
    CCEaseBackIn *pRet = new CCEaseBackIn();
    if (pRet)
    {
        if (pRet->initWithAction(pAction))
        {
            pRet->autorelease();
        }
        else
        {
            CC_SAFE_RELEASE_NULL(pRet);
        }
    }

    return pRet;
}
//创建一个当前动画的实例拷贝。
CCObject* CCEaseBackIn::copyWithZone(CCZone *pZone)
{
    CCZone* pNewZone = NULL;
    CCEaseBackIn* pCopy = NULL;
    if(pZone && pZone->m_pCopyObject) 
    {
        //in case of being called at sub class
        pCopy = (CCEaseBackIn*)(pZone->m_pCopyObject);
    }
    else
    {
        pCopy = new CCEaseBackIn();
        pNewZone = new CCZone(pCopy);
    }

    pCopy->initWithAction((CCActionInterval *)(m_pOther->copy()->autorelease()));
    
    CC_SAFE_DELETE(pNewZone);
    return pCopy;
}
//更新动画.
void CCEaseBackIn::update(float time)
{
　　//菜花,上曲线!
　　
    float overshoot = 1.70158f;
    m_pOther->update(time * time * ((overshoot + 1) * time - overshoot));
}
//创建一个反向播放的当前动画。
CCActionInterval* CCEaseBackIn::reverse(void)
{
    return CCEaseBackOut::create(m_pOther->reverse());
}



class CC_DLL CCEaseBackOut : public CCActionEase
{
public:
    //更新动画。
　　　virtual void update(float time);
　　　//创建一个反向播放的当前动画。
　　　virtual CCActionInterval* reverse(void);
　　　//创建一个当前动画的实例拷贝。
    virtual CCObject* copyWithZone(CCZone* pZone);

public:
　　　//静态函数：创建对应匀速动画的变速动画，参数为一个匀速动画。内部调用create实现。
    CC_DEPRECATED_ATTRIBUTE static CCEaseBackOut* actionWithAction(CCActionInterval* pAction);
    //同上
    static CCEaseBackOut* create(CCActionInterval* pAction);
};
//静态函数：创建对应匀速动画的变速动画，参数为一个匀速动画。内部调用create实现。
CCEaseBackOut* CCEaseBackOut::actionWithAction(CCActionInterval* pAction)
{
    return CCEaseBackOut::create(pAction);
}
//同上
CCEaseBackOut* CCEaseBackOut::create(CCActionInterval* pAction)
{
    CCEaseBackOut *pRet = new CCEaseBackOut();
    if (pRet)
    {
        if (pRet->initWithAction(pAction))
        {
            pRet->autorelease();
        }
        else
        {
            CC_SAFE_RELEASE_NULL(pRet);
        }
    }

    return pRet;
}
//创建一个当前动画的实例拷贝。
CCObject* CCEaseBackOut::copyWithZone(CCZone *pZone)
{
    CCZone* pNewZone = NULL;
    CCEaseBackOut* pCopy = NULL;
    if(pZone && pZone->m_pCopyObject) 
    {
        //in case of being called at sub class
        pCopy = (CCEaseBackOut*)(pZone->m_pCopyObject);
    }
    else
    {
        pCopy = new CCEaseBackOut();
        pNewZone = new CCZone(pCopy);
    }

    pCopy->initWithAction((CCActionInterval *)(m_pOther->copy()->autorelease()));
    
    CC_SAFE_DELETE(pNewZone);
    return pCopy;
}
//更新动画.
void CCEaseBackOut::update(float time)
{
　　//奶妈,上曲线!
　　
    float overshoot = 1.70158f;

    time = time - 1;
    m_pOther->update(time * time * ((overshoot + 1) * time + overshoot) + 1);
}
//创建一个反向播放的当前动画。
CCActionInterval* CCEaseBackOut::reverse(void)
{
    return CCEaseBackIn::create(m_pOther->reverse());
}



class CC_DLL CCEaseBackInOut : public CCActionEase
{
public:
    //更新动画。
　　　virtual void update(float time);
　　　//创建一个反向播放的当前动画。
　　　virtual CCActionInterval* reverse(void);
　　　//创建一个当前动画的实例拷贝。
    virtual CCObject* copyWithZone(CCZone* pZone);

public:
　　　//静态函数：创建对应匀速动画的变速动画，参数为一个匀速动画。内部调用create实现。
    CC_DEPRECATED_ATTRIBUTE static CCEaseBackInOut* actionWithAction(CCActionInterval* pAction);
　　　//同上
    static CCEaseBackInOut* create(CCActionInterval* pAction);
};
//静态函数：创建对应匀速动画的变速动画，参数为一个匀速动画。内部调用create实现。
CCEaseBackInOut* CCEaseBackInOut::actionWithAction(CCActionInterval* pAction)
{
    return CCEaseBackInOut::create(pAction);
}
//同上
CCEaseBackInOut* CCEaseBackInOut::create(CCActionInterval* pAction)
{
    CCEaseBackInOut *pRet = new CCEaseBackInOut();
    if (pRet)
    {
        if (pRet->initWithAction(pAction))
        {
            pRet->autorelease();
        }
        else
        {
            CC_SAFE_RELEASE_NULL(pRet);
        }
    }

    return pRet;
}
//创建一个当前动画的实例拷贝。
CCObject* CCEaseBackInOut::copyWithZone(CCZone *pZone)
{
    CCZone* pNewZone = NULL;
    CCEaseBackInOut* pCopy = NULL;
    if(pZone && pZone->m_pCopyObject) 
    {
        //in case of being called at sub class
        pCopy = (CCEaseBackInOut*)(pZone->m_pCopyObject);
    }
    else
    {
        pCopy = new CCEaseBackInOut();
        pNewZone = new CCZone(pCopy);
    }

    pCopy->initWithAction((CCActionInterval *)(m_pOther->copy()->autorelease()));
    
    CC_SAFE_DELETE(pNewZone);
    return pCopy;
}
//动画更新
void CCEaseBackInOut::update(float time)
{
　　//容嬷嬷，上曲线!
　　
    float overshoot = 1.70158f * 1.525f;

    time = time * 2;
    if (time < 1)
    {
        m_pOther->update((time * time * ((overshoot + 1) * time - overshoot)) / 2);
    }
    else
    {
        time = time - 2;
        m_pOther->update((time * time * ((overshoot + 1) * time + overshoot)) / 2 + 1);
    }
}

//创建一个反向播放的当前动画。
CCActionInterval* CCEaseBackInOut::reverse()
{
    return CCEaseBackInOut::create(m_pOther->reverse());
}



     虽然大部分代码很无聊，但是我相信，时间久了，各位同学会发现，本博的代码仍是您在进行Cocos2d-x开发的超级帮助。最后，周末愉快！~

                          

     

火云洞红孩儿
关注
  • 10
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 12
    评论
专栏目录
Cocos2d-x 2.0的俄罗斯方块代码
03-15
公司人说代码太老了，就没要资源分。
贝塞尔曲线生成算法
热门推荐
高兴的地方
08-21 4万+
这里先介绍另一个经典的曲线逼近方法，称作Bezier曲线。想必学过图形图像的都应该知道啦，所以概念性问题就不说啦。该曲线分为一次/二次/三次/多次贝塞尔曲线，之所以这么分是为了更好的理解其中的内涵。一次贝塞尔曲线，实际上就是一条连接两点的直线段。二次贝塞尔曲线，就是两点间的一条抛物线，利用一个控制点来控制抛物线的形状。三次贝塞尔曲线，则需要一个起点，一个终点，两个控制点来控制曲线的形状。实例如下图：通用的贝塞尔曲线的生成算法，可以简单表示如下： typedef struct{float x; float y
cocos2d-x动作、特效和动画（四）贝赛尔曲线动作
果汁的专栏
01-15 2841
首先是贝赛尔曲线的简单了解（链接）：http://www.byywee.com/page/M0/S890/890471.html 简单说，贝塞尔曲线是应用与二维图形应用程序的数学曲线，每一个定点都有两个控制点，用于控制两个侧端点曲线的初始和最终弧度。 CCBezierTo和CCBezierBy两个都是贝赛尔曲线动作。两者的create函数没有区别，都是两个参数，第一个参数是动作时间，第二个参数
cocos2d-x动画加速与减速（转载）
杨名天吓
04-21 1万+
最近的游戏学习中使用到精灵运动的加速与减速，于是征集了一些权威的文章供参考。 文章一： cocos2d-x动画加速与减速 动画是游戏的必然要素之一，在整个游戏过程中，又有着加速、减速动画的需求。以塔防为例子，布塔的时候希望能够将游戏减速，布好塔后，则希 望能将游戏加速；当某个怪被冰冻后，移动速度减缓，而其他怪的移动速度不变。cocos2d-x引擎为我们提供了很强大的接口，下面
cocos2dx动画加速与减速
尘墨
11-16 1373
cocos2d-x动画加速与减速 动画是游戏的必然要素之一，在整个游戏过程中，又有着加速、减速动画的需求。以塔防为例子，布塔的时候希望能够将游戏减速，布好塔后，则希望能将游戏加速；当某个怪被冰冻后，移动速度减缓，而其他怪的移动速度不变。cocos2d-x引擎为我们提供了很强大的接口，下面就将我实验的过程复述一遍，也方便他人。 1）实现全局的加速、减速。 通过设置Scheduler的
cocos2d-x-3rd-party-libs-src:cocos2d-x的依存关系
05-28
cocos2d-x第三方库 该存储库包含与cocos2d-x捆绑在一起的第三方库（二进制）的源代码。 对于cocos2d-x开发人员和/或想要： 生成特定库的更新版本（例如：将libpng 1.6.2升级到1.6.14） 将cocos2d-x移植到其他平台...
Cocos2d-Lua-社区：基于Cocos2d-x 4.0，打造易用稳定的Cocos2d-x lua引擎
02-03
Cocos2d-Lua社区Cocos2d-Lua-Community是Cocos2d-x 4.0的改进，并且易于使用Lua游戏引擎。 它是与Quick-Cocos2dx-Community v3.7.x兼容的Lua“框架”。得到帮助 QQ群：社区版千人群（1群）号：361920466社区版2群：...
Cocos2d-x实战：JS卷——Cocos2d-JS开发
07-23
资源名称：Cocos2d-x实战：JS卷——Cocos2d-JS开发内容简介：本书是介绍Cocos2d-x游戏编程和开发技术书籍，介绍了使用Cocos2d-JS中核心类、瓦片地图、物理引擎、音乐音效、数据持久化、网络通信、性能优化、多平台...
cocos2d-x 2.0 绘制圆角矩形
04-13
分享个cocos2d-x 2.0.x后绘制圆角矩形的方法，值得一看！
Cocos2d-x 动作之变速动作
fyn6417的专栏
10-16 2303
大部分动作的变化过程是与时间成线性关系的，即一个动作经过相同时间产生的变化相同，例如，CCMoveBy会使节点在同样长的时间内经过同样的位移。这是因为Cocos2d-x把动作的速度变化控制抽离了出来，形成一个独立的机制。借助这个机制，我们可以很方便地实现诸如鱼的变速游动、金币的加速飞行以及后面将要介绍的动作平滑化等效果。普通动作配合变速动作，可以构造出很有趣的动作效果。 与复合动作类似，变速
Cocos 2dx 控制动画播放速度（实现减速.加速效果）
shuhao97919的博客
10-12 1860
//创建及初始化 //获取全局时间管理者 Scheduler* pSchedule = Director::getInstance()->getScheduler(); //创建新的时间管理者 m_pSchedule = new Scheduler(); 将新的时间管理者交予全局时间管理者控制 pSchedule->scheduleUpdate(m_pSched...
CCActionEase(可以对动作进行包装 使动作的in和out速度发生改变 使动作更平滑)
sssssNian的专栏
05-21 1070
#ifndef __ACTION_CCEASE_ACTION_H__ #define __ACTION_CCEASE_ACTION_H__ #include "CCActionInterval.h" NS_CC_BEGIN class CCObject; class CCZone; /**  * @addto
CCActionEase 笔记
Jchn lau
09-14 854
------------------------- Ease动作 ------------------------- cocos2dx的动作都是以时间增量为自变量，通过某种数学公式计算 出另外的一个时间增量，然后将计算出来的这个增量传给实际的Action。 这样就可以呈现出复合的效果。通过这种复合，可以实现和多不同的复杂 效果。 1. CCActionEase Ease动作的父
变速动画封装代码
前端小白的博客
06-28 234
记得给要移动的div加上绝对定位。function my$(id) { return document.getElementById(id); } function animate(element,target) { clearInterval(element.timer); element.timer=setInterval(function () { v...
cocos2dx 之Action变速运动
iamlegendary的博客
12-31 5408
在cocos2d Action中，用CCSpeed可以改变动作的速度，但实际上只是按比例改变目标动作的速度。 在做Action动作时，如果你直接去改变目标动作的运动时间，时间的长短决定了速度，其实就是按比例修改其运动的速度。那么CCSpeed的用处并不是很大，一般项目中不太喜欢用，还不如直接按比例的调整时间来得利索。而在实际项目中，变速运动的需求相对来说还是比较多的。比如幸运大转盘的转动，或者小车
cocos2dx之CCActionEase,CCEaseExponentialIn等变速Action
专注，努力，勤奋
01-16 1万+
虽然使用CCSpeed能够改变动作的速度，然而它只能按比例改变目标动作的速度。如果我们要实现动作由快到慢、速度随时间改变的变速运动，需要不停地修改它的speed属性才能实现，显然这是一个很烦琐的方法。下面将要介绍的CCActionEase系列动作通过使用内置的多种自动速度变化来解决这一问题。CCActionEase系列包含15个动作，它们可以被概括为5类动作：指数缓冲、Sine缓冲、弹性缓冲、跳跃
cocos2dx 3.1.1中EaseRateAction动作类的变化
fanzhang1990的专栏
10-29 1906
在学习action繁多的动作类中，EaseAction是一个
如何学习cocos2d-x
最新发布
07-17
cocos2d-x 4. 学习之路 cocos2d-x是一款开源的跨平台游戏引擎，支持多种平台，包括iOS、Android、Windows、Mac OS X等。cocos2d-x 4.是最新版本，相比之前版本，它有很多新特性和改进，如增强的渲染性能、更好的3D支持、更好的物理引擎等。 如果你想学习cocos2d-x 4.，可以从以下几个方面入手： 1. 学习基础知识：了解cocos2d-x的基本概念、架构和工作原理，掌握cocos2d-x的编程语言和开发环境。 2. 学习API：熟悉cocos2d-x的API，包括场景管理、精灵、动画、音频、物理引擎等。 3. 学习示例代码：通过阅读和分析cocos2d-x的示例代码，了解如何使用cocos2d-x开发游戏。 4. 学习实践：通过实践开发小游戏，掌握cocos2d-x的开发流程和技巧，提高自己的编程能力。 总之，学习cocos2d-x 4.需要一定的时间和耐心，但只要你有兴趣和热情，相信你一定能够掌握它。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 12
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

火云洞红孩儿

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值