cocos2d-x节点（CCActionEase.h)API

cocos2d-x节点（CCActionEase.h)API

///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__