本文来自http://blog.csdn.net/runaying ，引用必须注明出处！

cocos2d-x节点（CCActionEase.h)API

温馨提醒：为了大家能更好学习，强烈推荐大家看看本人的这篇博客 Cocos2d-X权威指南笔记

放缓（Easing）action 相关的类 

///cocos2d-x-3.0alpha0/cocos2dx/actions
//放缓（Easing）action 相关的类


#ifndef __ACTION_CCEASE_ACTION_H__
#define __ACTION_CCEASE_ACTION_H__

#include "CCActionInterval.h"

NS_CC_BEGIN

class Object;

/**
 * @addtogroup actions
 * @{
 */

/** 
 @brief 缓和（Easing）行动的基类
 @ingroup Actions
 */
class CC_DLL ActionEase : public ActionInterval
{
public:
    /**
     * @js NA
     * @lua NA
     */
    virtual ~ActionEase(void);

    /** 初始化action */
    bool initWithAction(ActionInterval *pAction);

    virtual ActionInterval* getInnerAction();

    //
    // 覆盖
    //
	virtual ActionEase* clone() const override = 0;
    virtual ActionEase* reverse() const override = 0;
    virtual void startWithTarget(Node *target) override;
    virtual void stop(void) override;
    virtual void update(float time) override;

protected:
    /** 内部 action */
    ActionInterval *_inner;
};

/** 
 @brief 缓和（Easing）行动速率参数的基类
 @ingroup Actions
 */
class CC_DLL EaseRateAction : public ActionEase
{
public:
    /**
     * @js NA
     * @lua NA
     */
    virtual ~EaseRateAction(void);

    /**使用 内部的 action 和速度参数 初始化一个 action */
    bool initWithAction(ActionInterval *pAction, float fRate);

    /** set actions 的速度值 */
    inline void setRate(float rate) { _rate = rate; }
    /** get actions 的速度值 */
    inline float getRate(void) const { return _rate; }

    //
    // 覆盖
    //
	virtual EaseRateAction* clone() const override = 0;
    virtual EaseRateAction* reverse() const override = 0;

protected:
    float _rate;
};

/** 
 @brief EaseIn（放缓）action 的速度
 @ingroup Actions
 */
class CC_DLL EaseIn : public EaseRateAction
{
public:
    /** 使用 内部的 action 和速度参数 初始化一个 action */
    static EaseIn* create(ActionInterval* pAction, float fRate);

    // Overrides
    virtual void update(float time) override;
	virtual EaseIn* clone() const override;
	virtual EaseIn* reverse() const override;
};

/** 
 @brief EaseOut action 的速度
 @ingroup Actions
 */
class CC_DLL EaseOut : public EaseRateAction
{
public:
    /** 使用 内部的 action 和速度参数 初始化一个 action */
    static EaseOut* create(ActionInterval* pAction, float fRate);

    // Overrides
    virtual void update(float time) override;
	virtual EaseOut* clone() const  override;
	virtual EaseOut* reverse() const  override;
};

/** 
 @brief EaseInOut action 的速度
 @ingroup Actions
 */
class CC_DLL EaseInOut : public EaseRateAction
{
public:
    /** 使用 内部的 action 和速度参数 初始化一个 action */
    static EaseInOut* create(ActionInterval* pAction, float fRate);

    // Overrides
    virtual void update(float time) override;
	virtual EaseInOut* clone() const  override;
	virtual EaseInOut* reverse() const  override;
};

/** 
 @brief Ease Exponential（指数） In
 @ingroup Actions
 */
class CC_DLL EaseExponentialIn : public ActionEase
{
public:
    /** 创建 action */
    static EaseExponentialIn* create(ActionInterval* pAction);

    // Overrides
    virtual void update(float time) override;
	virtual EaseExponentialIn* clone() const override;
	virtual ActionEase* reverse() const override;
};

/** 
 @brief Ease Exponential（指数） Out
 @ingroup Actions
 */
class CC_DLL EaseExponentialOut : public ActionEase
{
public:
    /** 创建 action */
    static EaseExponentialOut* create(ActionInterval* pAction);

    // Overrides
    virtual void update(float time) override;
	virtual EaseExponentialOut* clone() const override;
	virtual ActionEase* reverse() const override;
};

/** 
 @brief Ease Exponential（指数） InOut
 @ingroup Actions
 */
class CC_DLL EaseExponentialInOut : public ActionEase
{
public:
    /** 创建 action */
    static EaseExponentialInOut* create(ActionInterval* pAction);

    // Overrides
    virtual void update(float time) override;
	virtual EaseExponentialInOut* clone() const override;
	virtual EaseExponentialInOut* reverse() const override;
};

/** 
 @brief Ease Sine（正弦波） In
 @ingroup Actions
 */
class CC_DLL EaseSineIn : public ActionEase
{
public:
    /** 创建 action */
    static EaseSineIn* create(ActionInterval* pAction);

    // Overrides
    virtual void update(float time) override;
	virtual EaseSineIn* clone() const override;
	virtual ActionEase* reverse() const override;
};

/** 
 @brief Ease Sine（正弦波） Out
 @ingroup Actions
 */
class CC_DLL EaseSineOut : public ActionEase
{
public:
    /** 创建 action */
    static EaseSineOut* create(ActionInterval* pAction);

    // Overrides
    virtual void update(float time) override;
	virtual EaseSineOut* clone() const override;
	virtual ActionEase* reverse() const override;
};

/** 
 @brief Ease Sine（正弦波）InOut
 @ingroup Actions
 */
class CC_DLL EaseSineInOut : public ActionEase
{
public:
    /** 创建 action */
    static EaseSineInOut* create(ActionInterval* pAction);

    // Overrides
    virtual void update(float time) override;
	virtual EaseSineInOut* clone() const override;
	virtual EaseSineInOut* reverse() const override;
};

/** 
 @brief Ease Elastic（伸缩） abstract（抽象） class
 @since v0.8.2
 @ingroup Actions
 */
class CC_DLL EaseElastic : public ActionEase
{
public:
    /** 使用 内部的 action 、在这 period（期间）的弧度 初始化一个 action (默认值是 0.3) */
    bool initWithAction(ActionInterval *pAction, float fPeriod = 0.3f);

    /** get 在这期间波的弧度. 默认值是 0.3 */
    inline float getPeriod(void) const { return _period; }
    /** set 在这期间波的弧度. */
    inline void setPeriod(float fPeriod) { _period = fPeriod; }

    //
    // Overrides
    //
	virtual EaseElastic* clone() const override = 0;
	virtual EaseElastic* reverse() const override = 0;

protected:
    float _period;
};

/** 
 @brief Ease Elastic（伸缩） In action.
 @warning 这个 action 不会使用 bijective function（双射函数）. 使用这个 Action 时，一系列的动作可能会有意想不到的结果.
 @since v0.8.2
 @ingroup Actions
 */
class CC_DLL EaseElasticIn : public EaseElastic
{
public:
    /** 使用 内部的 action 、在这 period（期间）的弧度 创建一个 action (默认值是 0.3)  */
    static EaseElasticIn* create(ActionInterval *pAction, float fPeriod);
    static EaseElasticIn* create(ActionInterval *pAction);

    // Overrides
    virtual void update(float time) override;
	virtual EaseElasticIn* clone() const override;
	virtual EaseElastic* reverse() const override;
};

/** 
 @brief Ease Elastic（伸缩） Out action.
 @warning 这个 action 不会使用 bijective function（双射函数）. 使用这个 Action 时，一系列的动作可能会有意想不到的结果
 @since v0.8.2
 @ingroup Actions
 */
class CC_DLL EaseElasticOut : public EaseElastic
{
public:
    /** 使用 内部的 action 、在这 period（期间）的弧度 创建一个 action (默认值是 0.3)  */
    static EaseElasticOut* create(ActionInterval *pAction, float fPeriod);
    static EaseElasticOut* create(ActionInterval *pAction);

    // Overrides
    virtual void update(float time) override;
	virtual EaseElasticOut* clone() const override;
	virtual EaseElastic* reverse() const override;
};

/** 
 @brief Ease Elastic（伸缩） InOut action.
 @warning 这个 action 不会使用 bijective function（双射函数）. 使用这个 Action 时，一系列的动作可能会有意想不到的结果
 @since v0.8.2
 @ingroup Actions
 */
class CC_DLL EaseElasticInOut : public EaseElastic
{
public:
    /** 使用 内部的 action 、在这 period（期间）的弧度 创建一个 action (默认值是 0.3)  */
    static EaseElasticInOut* create(ActionInterval *pAction, float fPeriod);
    static EaseElasticInOut* create(ActionInterval *pAction);

    // Overrides
    virtual void update(float time) override;
	virtual EaseElasticInOut* clone() const override;
	virtual EaseElasticInOut* reverse() const override;
};

/** 
 @brief EaseBounce abstract class.
 @since v0.8.2
 @ingroup Actions
*/
class CC_DLL EaseBounce : public ActionEase
{
public:
    float bounceTime(float time);

    // Overrides
	virtual EaseBounce* clone() const override = 0;
	virtual EaseBounce* reverse() const override = 0;
};

/** 
 @brief EaseBounceIn action.
 @warning 这个 action 不会使用 bijective function（双射函数）. 使用这个 Action 时，一系列的动作可能会有意想不到的结果
 @since v0.8.2
 @ingroup Actions
*/
class CC_DLL EaseBounceIn : public EaseBounce
{
public:
    /** 创建 action */
    static EaseBounceIn* create(ActionInterval* pAction);

    // Overrides
    virtual void update(float time) override;
	virtual EaseBounceIn* clone() const override;
	virtual EaseBounce* reverse() const override;
};

/** 
 @brief EaseBounceOut action.
 @warning 这个 action 不会使用 bijective function（双射函数）. 使用这个 Action 时，一系列的动作可能会有意想不到的结果
 @since v0.8.2
 @ingroup Actions
 */
class CC_DLL EaseBounceOut : public EaseBounce
{
public:
    /** 创建 action */
    static EaseBounceOut* create(ActionInterval* pAction);

    // Overrides
    virtual void update(float time) override;
	virtual EaseBounceOut* clone() const override;
	virtual EaseBounce* reverse() const override;
};

/** 
 @brief EaseBounceInOut action.
 @warning 这个 action 不会使用 bijective function（双射函数）. 使用这个 Action 时，一系列的动作可能会有意想不到的结果
 @since v0.8.2
 @ingroup Actions
 */
class CC_DLL EaseBounceInOut : public EaseBounce
{
public:
    /** 创建 action */
    static EaseBounceInOut* create(ActionInterval* pAction);

    // Overrides
    virtual void update(float time) override;
	virtual EaseBounceInOut* clone() const override;
	virtual EaseBounceInOut* reverse() const override;
};

/** 
 @brief EaseBackIn action.
 @warning 这个 action 不会使用 bijective function（双射函数）. 使用这个 Action 时，一系列的动作可能会有意想不到的结果
 @since v0.8.2
 @ingroup Actions
 */
class CC_DLL EaseBackIn : public ActionEase
{
public:
    /** 创建 action */
    static EaseBackIn* create(ActionInterval* pAction);

    // Overrides
    virtual void update(float time) override;
	virtual EaseBackIn* clone() const override;
	virtual ActionEase* reverse() const override;
};

/** 
 @brief EaseBackOut action.
 @warning 这个 action 不会使用 bijective function（双射函数）. 使用这个 Action 时，一系列的动作可能会有意想不到的结果
 @since v0.8.2
 @ingroup Actions
 */
class CC_DLL EaseBackOut : public ActionEase
{
public:
    /** 创建 action */
    static EaseBackOut* create(ActionInterval* pAction);

    // Overrides
    virtual void update(float time) override;
	virtual EaseBackOut* clone() const override;
	virtual ActionEase* reverse() const override;
};

/** 
 @brief EaseBackInOut action.
 @warning 这个 action 不会使用 bijective function（双射函数）. 使用这个 Action 时，一系列的动作可能会有意想不到的结果
 @since v0.8.2
 @ingroup Actions
 */
class CC_DLL EaseBackInOut : public ActionEase
{
public:
    /** 创建 action */
    static EaseBackInOut* create(ActionInterval* pAction);

    // Overrides
    virtual void update(float time) override;
	virtual EaseBackInOut* clone() const override;
	virtual EaseBackInOut* reverse() const override;
};

// end of actions group
/// @}

NS_CC_END

#endif // __ACTION_CCEASE_ACTION_H__