honghaier

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

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

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

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

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

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

cocos2d-2.0-x-2.0.2 @ Aug 30 2012

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

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

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

打开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开发的超级帮助。最后，周末愉快！~

你可能感兴趣的:(Cocos2d-x 2.0 变速动画深入分析)

Google earth studio 简介陟彼高冈yu 旅游
GoogleEarthStudio是一个基于Web的动画工具，专为创作使用GoogleEarth数据的动画和视频而设计。它利用了GoogleEarth强大的三维地图和卫星影像数据库，使用户能够轻松地创建逼真的地球动画、航拍视频和动态地图可视化。网址为https://www.google.com/earth/studio/。GoogleEarthStudio是一个基于Web的动画工具，专为创作使用G
2.0践行没有你的参与就不完美 x秀丽x
亲爱的伙伴们早上好，今天早上我们开了一次班委竞选的会议，全程只有20多个人参与，宫班本着对大家负责任的态度告诉我们，此次竞选作废，原因是这没有达到2.0的100%参会要求，如果没有大家的参与那么这个班委选出来还有什么意义，这说明选出来的人也是不一定是我们大家心目中认可的那个人，所以为了让大家的这个90天能够更好的激发出自己的的“做”的能力，那么要从第一次竞选班委的会议开始做到100%出席会议，竞选
读书||陶新华《教育中的积极心理学》1—28 流水淙淙2022
读一本好书，尤如和一位高尚者对话，亦能对人的精神进行洗礼。但是若不能和实践结合起来，也只能落到空读书的状态。读书摘要与感想1、塞利格曼在《持续的幸福》一书中提出了幸福2.0理论，提出幸福由5个元素决定——积极情绪、投入的工作和生活、目标和意义、和谐的人际关系、成就感。2、人的大脑皮层在进行智力活动时，都伴有皮下中枢活动，对这些活动进行体验请假，并由此产生了情感解读。人的情绪情感体验总是优先于大脑的
大雄的新恐龙：养育生命，的确不易沧浪先生
哆啦A梦这个动画片，我小时候没有看过，长大了之后似乎对这种充满童真童趣的动画片也没有太多的喜爱，所以结果很明显，我并没有看过哆啦A梦这个动画片。但是近年来大屏幕的兴起，让各家影视剧制作者发现了电影化的好处，没错，电影不仅影响力更大，钱赚得也多。《哆啦A梦·大雄的新恐龙》是最新的一部大屏幕电影，大雄和柯南一样，都永远长不大，而且他和他的小伙伴日复一日、年复一年地和机器猫哆啦A梦在一起玩耍，永远的神奇
MongoDB知识概括 GeorgeLin98 持久层 mongodb
MongoDB知识概括MongoDB相关概念单机部署基本常用命令索引-IndexSpirngDataMongoDB集成副本集分片集群安全认证MongoDB相关概念业务应用场景：传统的关系型数据库（如MySQL），在数据操作的“三高”需求以及应对Web2.0的网站需求面前，显得力不从心。解释：“三高”需求：①Highperformance-对数据库高并发读写的需求。②HugeStorage-对海量数
利用python实现图片格式之间的相互转换难得北窗高卧 python 开发语言
一、概要图片一般有多种格式，常见的图片格式包括：JPEG（.jpg或.jpeg）：一种广泛使用的有损压缩格式，适用于摄影图像和网页上的图片。PNG（.png）：一种无损压缩格式，支持透明度和更好的图像质量，常用于图标、图形和需要透明背景的图片。该图片是4通道的，外加一个透明通道。如截屏GIF（.gif）：一种支持动画和透明度的格式，常用于简单的动画和图标。BMP（.bmp）：一种无损格式，存储图像
《 C++ 修炼全景指南：九》打破编程瓶颈！掌握二叉搜索树的高效实现与技巧 Lenyiin C++修炼全景指南技术指南 c++算法 stl
摘要本文详细探讨了二叉搜索树（BinarySearchTree,BST）的核心概念和技术细节，包括插入、查找、删除、遍历等基本操作，并结合实际代码演示了如何实现这些功能。文章深入分析了二叉搜索树的性能优势及其时间复杂度，同时介绍了前驱、后继的查找方法等高级功能。通过自定义实现的二叉搜索树类，读者能够掌握其实际应用，此外，文章还建议进一步扩展为平衡树（如AVL树、红黑树）以优化极端情况下的性能退化。
绝招曝光！3小时高效利用ChatGPT写出精彩论文 kkai人工智能 chatgpt 人工智能 ai 学习媒体
在这份指南中，我将深入解析如何利用ChatGPT4.0的高级功能，指导整个学术研究和写作过程。从初步探索研究主题，到撰写结构严谨的学术论文，我将一步步展示如何在每个环节中有效运用ChatGPT。如果您还未使用PLUS版本，可以参考相关教程。**初步探索与主题的确定**起初，我处于庞大的知识领域中，寻找一个可深入研究的领域。ChatGPT如同灯塔，通过深入分析最新研究趋势和领域热点，帮助我在广阔的学
使用由 Python 编写的 lxml 实现高性能 XML 解析 hunyxv python 笔记 python xml
转载自：文章lxml简介Python从来不出现XML库短缺的情况。从2.0版本开始，它就附带了xml.dom.minidom和相关的pulldom以及SimpleAPIforXML(SAX)模块。从2.4开始，它附带了流行的ElementTreeAPI。此外，很多第三方库可以提供更高级别的或更具有python风格的接口。尽管任何XML库都足够处理简单的DocumentObjectModel(DOM
8 冰鈊夢
transition动画transform.box{width:200px;height:200px;background-color:gold;margin:50pxauto0;transition:all1sease;}.box:hover{transform:translate(50px,50px);}.box2{width:200px;height:200px;background-col
动画电影《心灵奇旅》教你怎么做人，皮克斯为全人类上了一课韩漫小说
皮克斯出品，必属精品。不知从什么时候，这句话成了中国影迷和动画迷对皮克斯的认可和肯定。作为八十年代的人，虽然现在已经迈入中年，但是从小就对动画片十分痴迷。从《奥特曼》到《高达》，从《黑猫警长》到《海贼王》。动画伴我成长，给了我很多快乐。接触皮克斯的动画，是《玩具总动员》，看了真的令人感动。这不仅是儿童的欢乐片，也是给八零九零后奉献的精美大作。然而这一次的《心灵奇旅》，更是让我对皮克斯刮目相看。这次
360前端星计划-动画可以这么玩马小蜗
动画的基本原理定时器改变对象的属性根据新的属性重新渲染动画functionupdate(context){//更新属性}constticker=newTicker();ticker.tick(update,context);动画的种类1、JavaScript动画操作DOMCanvas2、CSS动画transitionanimation3、SVG动画SMILJS动画的优缺点优点：灵活度、可控性、性能
ArcGIS Pro SDK （十四）地图探索 5 时间与动画 WineMonk ArcGIS Pro SDK arcgis arcgis pro sdk gis c#
ArcGISProSDK（十四）地图探索5时间与动画文章目录ArcGISProSDK（十四）地图探索5时间与动画1时间1.1时间提前1个月1.2禁用地图中的时间。2动画2.1设置动画长度2.2缩放动画2.3相机关键帧2.4插值相机2.5插值时间2.6插值范围2.7创建摄像机关键帧2.8创建时间关键帧2.9创建范围关键帧2.10创建图层关键帧环境：VisualStudio2022+.NET6+Arc
免费像素画绘制软件 | Pixelorama v1.0.3 dntktop 软件运维 windows
Pixelorama是一款开源像素艺术多工具软件，旨在为用户提供一个强大且易于使用的平台来创作各种像素艺术作品，包括精灵、瓷砖和动画。这款软件以其丰富的工具箱、动画支持、像素完美模式、剪裁遮罩、预制及可导入的调色板等特色功能，满足了像素艺术家们的各种需求。用户可以享受到动态工具映射、洋葱皮效果、帧标签、播放动画时绘制等高级功能，以及非破坏性的、完全可定制的图层效果，如轮廓、渐变映射、阴影和调色板化
《教育信息化2.0素养提升》思考与总结———2019兴成长4⃣️班宁都5940李娟
迎来了美好的假期生活。你可以放松。但是不可以向自己的惰性妥协。你决定不了太阳几点升起，但你可以决定你何时起床。暑假前一个星期很喜欢这样的生活。上午逛逛超市，中午陪爸妈吃饭。下午午觉或者看看书。洗洗衣服干干活。晚上七点钟开始去上课。晚上回来看看电视。熬夜、这样的生活。没有压力。没有目的。没有成果。看似乎一切都可以。这样的生活最多只能过一个星期。暑假的第一个星期学校就开始安排个为教师的素养提升以及自身
开发游戏的学习规划杰克逊的日记游戏学习
第一阶段：●C#语言快速系统地学习一遍（基础的语法、面向对象、基础的数据结构、基础的设计模式）●Unity的2D和3D部分及UI、动画、物理系统●阶段性测验：需要去用前面所学的这些基础知识来完成一个简单的2d或者3d的案例，将通过一个自制的《Flappybird》游戏案例讲解游戏开发的思想及方法，并将《Flappybird》这个游戏进一步改造成一个横版射击类游戏《Crazybird》以巩固并且升华
[转载] NoSQL简介 weixin_30325793 大数据数据库运维
摘自“百度百科”。NoSQL，泛指非关系型的数据库。随着互联网web2.0网站的兴起，传统的关系数据库在应付web2.0网站，特别是超大规模和高并发的SNS类型的web2.0纯动态网站已经显得力不从心，暴露了很多难以克服的问题，而非关系型的数据库则由于其本身的特点得到了非常迅速的发展。NoSQL数据库的产生就是为了解决大规模数据集合多重数据种类带来的挑战，尤其是大数据应用难题。虽然NoSQL流行语
详细的等保测评攻略就在这里快快小毛毛网络网络安全系统安全
信息安全等级保护，是对信息和信息载体按照重要性等级分级别进行保护的一种工作。目前我国实行的是等保2.0于2019年12月1日开始实施，等保2.0从传统的信息系统，转变成具有基础信息网络平台的多种新兴技术对象，即具有网络服务，有数据的网络服务平台都可以成为新兴的测评对象。等保2.0备案从原来的自主定级改变成系统定级，才能得到公安机关的备案，关于等保测评详细攻略如下：等保2.0定级步骤:确定定级对象—
【鸿蒙应用】总结一下ArkUI 读心悦鸿蒙基础鸿蒙应用
ArkUI是HarmonyOS应用界面的UI开发框架，提供了简洁的UI语法、UI组件、动画机制和事件交互等等UI开发基础，以此满足应用开发者对UI界面开发的需求。组件是界面搭建的最小单位，开发者通过多种组件的组合构成完整的界面。页面是ArkUI最小的调度分隔单位，开发者可以将应用设计为多个功能页面，每一个页面进行单独的文件管理，并且通过页面路由API完成页面之间的调度管理，以此来实现应用内功能的解
基于TRIZ的救援机器人轻量化设计天行健王春城老师 TRIZ 机器人
在救援机器人设计中，轻量化是一个至关重要的目标，它直接关系到机器人的便携性、运输效率以及在复杂环境中的作业能力。TRIZ理论为我们提供了一套系统化的工具和方法，用于解决设计过程中遇到的各种挑战，特别是在实现轻量化目标时，TRIZ能够帮助我们识别并消除设计中的冗余与低效部分，同时保留或增强其关键功能。具体如深圳天行健企业管理咨询公司下文所述：1.功能分析与矛盾识别TRIZ理论强调对系统功能的深入分析
前端three.js的Sprite模拟下雪动画效果 qq_35430208 three.js 前端 javascript 三维场景中下雪效果 threejs实现下雪效果
一、效果如图所示：二、原理同下雨一样三、完整代码：index.jsimport*asTHREEfrom'three';import{OrbitControls}from'three/addons/controls/OrbitControls.js';importmodelfrom'./model.js';//模型对象//场景constscene=newTHREE.Scene();scene.add
剪纸与折纸 a晟睿
暑期第47天秋高气爽，温度适宜，一天宅在家里真幸福。睿睿做完作业，看动画片，给她规定好看多长时间，虽然到时间会耍赖多看一会，基本上还是能守信用关掉。下午的时间，我找出彩纸，对睿睿说咱们剪纸吧，睿睿马上找来小剪刀，我找来剪纸的书，睿睿铺好她的瑜伽垫，我俩就面对面席地而坐，各忙各的了。睿睿的小手很灵活，照着图纸一会就叠好剪出来了，自己觉得不过瘾，又拿来我的手机，搜了一个折纸教程，一步一步跟着折起来。剪
Cloud Native Weekly | 华为云抢先发布Redis5.0，红帽宣布收购混合云提供商 weixin_34302561 数据库 devops 大数据
1——华为云抢先发布Redis5.02——DigitalOceanK8s服务正式上线3——红帽宣布收购混合云提供商NooBaa4——微软发布多项AzureKubernetes服务更新1华为云抢先发布Redis5.012月17日，华为云在DCS2.0的基础上，快人一步，抢先推出了新的Redis5.0产品，这是一个崭新的突破。目前国内在缓存领域的发展普遍停留在Redis4.0阶段，华为云率先发布了Re
Three.js AnimationUtils 和 AnimationObjectGroup 灵魂清零 three 前端 web3 javascript
AnimationObjectGroup接收共享动画状态的一组对象。在使用手册的“下一步”章节中，“动画系统”一文对three.js动画系统中的不同元素作出了概述用法:将本来要作为根对象传入构造器或者动画混合器(AnimationMixer)的clipAction方法中的对象加入组中，并将这个组对象作为根对象传递。注意，这个类的实例作为混合器中的一个对象，因此，必须对组内的单个对象做缓存控制。限制
three.js AnimationClip 和 AnimationMixer 灵魂清零 three web3 前端 javascript vue.js
AnimationClip动画剪辑（AnimationClip）是一个可重用的关键帧轨道集，它代表动画。构造器AnimationClip(name:String,duration:Number,tracks:Array)name-此剪辑的名称duration-持续时间(单位秒).如果传入负数,持续时间将会从传入的数组中计算得到。tracks-一个由关键帧轨道（KeyframeTracks）组成的数
地缚少年：源光被喊变态，八寻宁宁没有撩到源辉，却撩到了源光 ACGN安乐
细想之下花子君和八寻宁宁之所以可以走到一起，主要还是因为花子君在未经过八寻宁宁允许就亲吻了八寻宁宁，虽说这是花子君给八寻宁宁的保护咒，但严格来讲这种kiss的结果确实在八寻宁宁的心中种下了爱情的种子。动画《地缚少年花子君》第五话，神秘女生出现，可能是花子君的女票，八寻宁宁这是吃醋了。神秘女生出现后与八寻宁宁进行了一番对话，声称花子君像猫咪不但可爱还喜欢撒娇，可花子君从未在八寻宁宁身边撒过娇，随后神
Python(PyTorch)和MATLAB及Rust和C++结构相似度指数测量导图亚图跨际 Python 交叉知识算法量化检查图像压缩质量低分辨率多光谱峰值信噪比端到端优化图像压缩手术机器人三维实景实时可微分渲染重建三维可视化
要点量化检查图像压缩质量低分辨率多光谱和高分辨率图像实现超分辨率分析图像质量图像索引/多尺度结构相似度指数和光谱角映射器及视觉信息保真度多种指标峰值信噪比和结构相似度指数测量结构相似性图像分类PNG和JPEG图像相似性近似算法图像压缩，视频压缩、端到端优化图像压缩、神经图像压缩、GPU变速图像压缩手术机器人深度估计算法重建三维可视化推理图像超分辨率算法模型三维实景实时可微分渲染算法MATLAB结构
坤燕亲子日记第1063之和孩子讲述妈妈小时候的故事坤燕_634c
坤燕亲子日记第1063之和孩子讲述妈妈小时候的故事亲子共读记录之小猪2101天共读时间：睡前共读时长：50分钟共读书目：中国历史5数字家园英文动画片猜猜我有多爱你亲子共读记录之阳阳12年+201天诗一首道德经第47章睡前聊天早上读诗，中午读史，晚上读经，我真是太幸福了，托两个孩子的福得以重新上一次学，读一读诗歌，讲一讲历史，还能读经。中午读史时，阳走开了会儿，我还是继续读，小猪说，先别读，等姐姐来
应付的剧情，乏味的游戏 512song
这周晚上电脑用的少，倒也影响不大，日常的浏览、邮件收发都可以用手机来实现。唯一有影响的就是游戏了。搬家之后，每天晚上儿子在他的房间灯下苦学，我就在另一房间内玩游戏。开始还觉得甚是惭愧，但玩了一个多月，也感觉和儿子一样，是在苦玩了。每天的炉石传说的日常还有点趣味，攒足了金币，儿子开箱子抽卡，颇具仪式感。但自《魔兽世界》的主任务线完成之后的日常，就过于无聊了。暴雪的动画水平是越来越高了，其实根本没有必
Flume：大规模日志收集与数据传输的利器傲雪凌霜，松柏长青后端大数据 flume 大数据
Flume：大规模日志收集与数据传输的利器在大数据时代，随着各类应用的不断增长，产生了海量的日志和数据。这些数据不仅对业务的健康监控至关重要，还可以通过深入分析，帮助企业做出更好的决策。那么，如何高效地收集、传输和存储这些海量数据，成为了一项重要的挑战。今天我们将深入探讨ApacheFlume，它是如何帮助我们应对这些挑战的。一、Flume概述ApacheFlume是一个分布式、可靠、可扩展的日志
JAVA基础灵静志远位运算加载 Date 字符串池覆盖
一、类的初始化顺序 1 （静态变量，静态代码块）-->（变量，初始化块）--> 构造器同一括号里的，根据它们在程序中的顺序来决定。上面所述是同一类中。如果是继承的情况，那就在父类到子类交替初始化。二、String 1 String a = "abc"; JAVA虚拟机首先在字符串池中查找是否已经存在了值为"abc"的对象，根
keepalived实现redis主从高可用 bylijinnan redis
方案说明两台机器（称为A和B），以统一的VIP对外提供服务 1.正常情况下，A和B都启动，B会把A的数据同步过来（B is slave of A） 2.当A挂了后，VIP漂移到B；B的keepalived 通知redis 执行：slaveof no one，由B提供服务 3.当A起来后，VIP不切换，仍在B上面；而A的keepalived 通知redis 执行slaveof B，开始
java文件操作大全 0624chenhong java
最近在博客园看到一篇比较全面的文件操作文章，转过来留着。 http://www.cnblogs.com/zhuocheng/archive/2011/12/12/2285290.html 转自http://blog.sina.com.cn/s/blog_4a9f789a0100ik3p.html 一.获得控制台用户输入的信息 &nbs
android学习任务不懂事的小屁孩工作
任务完成情况搞清楚带箭头的pupupwindows和不带的使用已完成熟练使用pupupwindows和alertdialog，并搞清楚两者的区别已完成熟练使用android的线程handler,并敲示例代码进行中了解游戏2048的流程，并完成其代码工作进行中-差几个actionbar 研究一下android的动画效果，写一个实例已完成复习fragem
zoom.js 换个号韩国红果果 oom
它的基于bootstrap 的 https://raw.github.com/twbs/bootstrap/master/js/transition.js transition.js模块引用顺序 <link rel="stylesheet" href="style/zoom.css"> <script src=&q
详解Oracle云操作系统Solaris 11.2 蓝儿唯美 Solaris
当Oracle发布Solaris 11时，它将自己的操作系统称为第一个面向云的操作系统。Oracle在发布Solaris 11.2时继续它以云为中心的基调。但是，这些说法没有告诉我们为什么Solaris是配得上云的。幸好，我们不需要等太久。Solaris11.2有4个重要的技术可以在一个有效的云实现中发挥重要作用：OpenStack、内核域、统一存档（UA）和弹性虚拟交换（EVS）。
spring学习——springmvc（一） a-john springMVC
Spring MVC基于模型-视图-控制器（Model-View-Controller，MVC）实现，能够帮助我们构建像Spring框架那样灵活和松耦合的Web应用程序。 1，跟踪Spring MVC的请求请求的第一站是Spring的DispatcherServlet。与大多数基于Java的Web框架一样，Spring MVC所有的请求都会通过一个前端控制器Servlet。前
hdu4342 History repeat itself-------多校联合五 aijuans 数论
水题就不多说什么了。 #include<iostream>#include<cstdlib>#include<stdio.h>#define ll __int64using namespace std;int main(){ int t; ll n; scanf("%d",&t); while(t--)
EJB和javabean的区别 asia007 bean ejb
EJB不是一般的JavaBean,EJB是企业级JavaBean,EJB一共分为3种,实体Bean,消息Bean,会话Bean,书写EJB是需要遵循一定的规范的,具体规范你可以参考相关的资料.另外,要运行EJB,你需要相应的EJB容器,比如Weblogic,Jboss等,而JavaBean不需要,只需要安装Tomcat就可以了 1.EJB用于服务端应用开发, 而JavaBeans
Struts的action和Result总结百合不是茶 struts Action配置 Result配置
一:Action的配置详解: 下面是一个Struts中一个空的Struts.xml的配置文件 <?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE struts PUBLIC &quo
如何带好自已的团队 bijian1013 项目管理团队管理团队
在网上看到博客" 怎么才能让团队成员好好干活"的评论，觉得写的比较好。原文如下：我做团队管理有几年了吧，我和你分享一下我认为带好团队的几点： 1.诚信对团队内成员，无论是技术研究、交流、问题探讨，要尽可能的保持一种诚信的态度，用心去做好，你的团队会感觉得到。 2.努力提
Java代码混淆工具 sunjing ProGuard
Open Source Obfuscators ProGuard http://java-source.net/open-source/obfuscators/proguardProGuard is a free Java class file shrinker and obfuscator. It can detect and remove unused classes, fields, m
【Redis三】基于Redis sentinel的自动failover主从复制 bit1129 redis
在第二篇中使用2.8.17搭建了主从复制，但是它存在Master单点问题，为了解决这个问题，Redis从2.6开始引入sentinel，用于监控和管理Redis的主从复制环境，进行自动failover，即Master挂了后，sentinel自动从从服务器选出一个Master使主从复制集群仍然可以工作，如果Master醒来再次加入集群，只能以从服务器的形式工作。什么是Sentine
使用代理实现Hibernate Dao层自动事务白糖_ DAO spring AOP 框架 Hibernate
都说spring利用AOP实现自动事务处理机制非常好，但在只有hibernate这个框架情况下，我们开启session、管理事务就往往很麻烦。 public void save(Object obj){ Session session = this.getSession(); Transaction tran = session.beginTransaction(); try
maven3实战读书笔记 braveCS maven3
Maven简介是什么？ Is a software project management and comprehension tool.项目管理工具是基于POM概念(工程对象模型) [设计重复、编码重复、文档重复、构建重复，maven最大化消除了构建的重复] [与XP：简单、交流与反馈；测试驱动开发、十分钟构建、持续集成、富有信息的工作区] 功能：
编程之美-子数组的最大乘积 bylijinnan 编程之美
public class MaxProduct { /** * 编程之美子数组的最大乘积 * 题目: 给定一个长度为N的整数数组，只允许使用乘法，不能用除法，计算任意N-1个数的组合中乘积中最大的一组，并写出算法的时间复杂度。 * 以下程序对应书上两种方法，求得“乘积中最大的一组”的乘积——都是有溢出的可能的。 * 但按题目的意思，是要求得这个子数组，而不
读书笔记-2 chengxuyuancsdn 读书笔记
1、反射 2、oracle年-月-日时-分-秒 3、oracle创建有参、无参函数 4、oracle行转列 5、Struts2拦截器 6、Filter过滤器(web.xml) 1、反射 (1)检查类的结构在java.lang.reflect包里有3个类Field,Method,Constructor分别用于描述类的域、方法和构造器。 2、oracle年月日时分秒 s
[求学与房地产]慎重选择IT培训学校 comsci it
关于培训学校的教学和教师的问题,我们就不讨论了,我主要关心的是这个问题培训学校的教学楼和宿舍的环境和稳定性问题我们大家都知道，房子是一个比较昂贵的东西，特别是那种能够当教室的房子... &nb
RMAN配置中通道(CHANNEL)相关参数 PARALLELISM 、FILESPERSET的关系 daizj oracle rman filesperset PARALLELISM
RMAN配置中通道(CHANNEL)相关参数 PARALLELISM 、FILESPERSET的关系转 PARALLELISM --- 我们还可以通过parallelism参数来指定同时"自动"创建多少个通道： RMAN > configure device type disk parallelism 3 ; 表示启动三个通道，可以加快备份恢复的速度。
简单排序:冒泡排序 dieslrae 冒泡排序
public void bubbleSort(int[] array){ for(int i=1;i<array.length;i++){ for(int k=0;k<array.length-i;k++){ if(array[k] > array[k+1]){
初二上学期难记单词三 dcj3sjt126com sciet
concert 音乐会 tonight 今晚 famous 有名的；著名的 song 歌曲 thousand 千 accident 事故；灾难 careless 粗心的，大意的 break 折断；断裂；破碎 heart 心（脏） happen 偶尔发生，碰巧 tourist 旅游者；观光者 science （自然）科学 marry 结婚 subject 题目；
I.安装Memcahce 1. 安装依赖包libevent Memcache需要安装libevent,所以安装前可能需要执行 Shell代码收藏代码 dcj3sjt126com redis
wget http://download.redis.io/redis-stable.tar.gz tar xvzf redis-stable.tar.gz cd redis-stable make 前面3步应该没有问题，主要的问题是执行make的时候，出现了异常。异常一： make[2]: cc: Command not found 异常原因：没有安装g
并发容器 shuizhaosi888 并发容器
通过并发容器来改善同步容器的性能，同步容器将所有对容器状态的访问都串行化，来实现线程安全，这种方式严重降低并发性，当多个线程访问时，吞吐量严重降低。并发容器ConcurrentHashMap 替代同步基于散列的Map，通过Lock控制。 &nb
Spring Security（12）——Remember-Me功能 234390216 Spring Security Remember Me 记住我
Remember-Me功能目录 1.1 概述 1.2 基于简单加密token的方法 1.3 基于持久化token的方法 1.4 Remember-Me相关接口和实现
位运算焦志广位运算
一、位运算符Ｃ语言提供了六种位运算符： & 按位与 | 按位或 ^ 按位异或 ~ 取反 << 左移 >> 右移 1. 按位与运算按位与运算符"&"是双目运算符。其功能是参与运算的两数各对应的二进位相与。只有对应的两个二进位均为1时，结果位才为1 ，否则为0。参与运算的数以补码方式出现。例如：9&am
nodejs 数据库连接 mongodb mysql liguangsong mongodb mysql node 数据库连接
1.mysql 连接 package.json中dependencies加入 "mysql":"~2.7.0" 执行 npm install 在config 下创建文件 database.js
java动态编译 olive6615 java HotSpot jvm 动态编译
在HotSpot虚拟机中，有两个技术是至关重要的，即动态编译(Dynamic compilation)和Profiling。 HotSpot是如何动态编译Javad的bytecode呢？Java bytecode是以解释方式被load到虚拟机的。HotSpot里有一个运行监视器，即Profile Monitor,专门监视
Storm0.9.5的集群部署配置优化 roadrunners 优化 storm.yaml
nimbus结点配置（storm.yaml）信息： # Licensed to the Apache Software Foundation (ASF) under one # or more contributor license agreements. See the NOTICE file # distributed with this work for additional inf
101个MySQL 的调节和优化的提示 tomcat_oracle mysql
　1. 拥有足够的物理内存来把整个InnoDB文件加载到内存中——在内存中访问文件时的速度要比在硬盘中访问时快的多。　　2. 不惜一切代价避免使用Swap交换分区 – 交换时是从硬盘读取的，它的速度很慢。　　3. 使用电池供电的RAM（注：RAM即随机存储器）。　　4. 使用高级的RAID（注：Redundant Arrays of Inexpensive Disks，即磁盘阵列
zoj 3829 Known Notation(贪心) 阿尔萨斯 ZOJ
题目链接：zoj 3829 Known Notation 题目大意：给定一个不完整的后缀表达式，要求有2种不同操作，用尽量少的操作使得表达式完整。解题思路：贪心，数字的个数要要保证比∗的个数多1，不够的话优先补在开头是最优的。然后遍历一遍字符串，碰到数字+1，碰到∗-1,保证数字的个数大于等1，如果不够减的话，可以和最后面的一个数字交换位置（用栈维护十分方便），因为添加和交换代价都是1