一、UML

点击查看【processon】
Action
所有Action动画的基类。
使用了原型设计模式，即所有Action是可以复制的，原因是每个Action都是有状态的（记录在一个target上的执行进度），Action和target是一对多的关系，不能够将一个Action同时用于多个target。

ActionInterval
间隔动画，指动画在一定时间内完成，准确的讲是动画在一定时间内的每帧执行。显著的特点就是在创建的时候需要传入时间参数，比MoveBy。

ActionInstance
即时动画，指动画是“立即地瞬间地”完成，准确的讲是动画在下一帧中完成，“立即”指的是下一帧执行，所有Action动画的执行其实就是从下一帧开始，“瞬间”指的是在下一帧的执行中就完成了，从动画启动到完成的时间在一帧之内，和ActionInterval显著的区别就是不需要时间参数，比如CallFunc。

Action可以如下分类：

  • 变换动画
    • Move, Rotate, Scale, Fade, Tint, etc.
  • 组合Action
    • Sequence, Spawn, Repeat, Reverse
  • Ease Action
    • Exp, Sin, Cubic, Elastic, etc.
  • Func Action
    • CallFunc, OrbitCamera, Follow, Tween

      二、执行原理

      （一）线性插值

      大部分游戏引擎的动画系统都是基于线性插值原理。线性插值指已知某个时间段两端的端值，和该时间段中的一个时间点，求该时间点在两个端值之间对应的值。

      1、标量插值

      端值为标量，在游戏中标量可以表示游戏对象的属性，如透明度、旋转角度、在一个范围内的攻击力。 ```cpp

// 时间段：0.0 ~ 1.0 // 时间点：t（0.0 =< t <= 1.0） // 两端值：在时间点0.0的值为v0；在时间点1.0的值为v1

// 返回在时间点t的值 float lerp(float v0, float v1, float t){ return v0 (1 - t) + v1 t; }

// 显然： // lerp(v0, v1, 0) = v0 // lerp(v0, v1, 1) = v1

  1. <a name="rlskL"></a>
  2. ### 2、矢量插值
  3. 端值是多维标量构成的矢量，矢量可表示一个游戏对象的坐标、RGB值等。<br />对矢量的插值，就是对矢量中每个标量的插值。
  4. ```cpp
  6. // 比如二维矢量插值
  7. Vec2 lerp(Vec2 v0, Vec2 v1, float t){
  8.     return v0 * (1.0 - t) + v1 * t;
  9. }

3、变换矩阵插值

一般用于3D，咱不展开。

（二）Action中的插值

  2. class CC_DLL Action : public Ref, public Clonable {
  3. public:
  4.     // 步进回调，每帧被调用一次，dt表示距离上次调用的时间间隔。
  5.     // 通过这一步，可以计算到Action的执行进度，也就是线性插值的时间点（0.0~1.0之间）
  6.     virtual void step(float dt);
  8.     // 在这里进行线性插值求值
  9.     //         时间段固定都是0.0~1.0
  10.     //         时间点time，在时间段0.0~1.0之间，从时间上衡量动画的完成度。
  11.     // 由step步进回调调用，在这里对Node进行属性修改操作
  12.     // 比如 MoveBy/To，在这里应该是node->setPosition
  13.     // 比如 TintBy/To，在这里应该是node->setColor
  14.     virtual void update(float time);
  15. };
  17. //----------------------以MoveBy为例----------------------
  18. // MoveBy是间隔动画，继承自ActionInterval
  20. void ActionInterval::step(float dt) {
  21.     if (_firstTick) {        // 第一次执行
  22.         _firstTick = false;
  24.         // _elapsed，表示该Action距离开始执行过去的过去的时间
  25.         // 注意！！！从这一步我们可以知道，每个Action都是带有状态的，记录自身的执行完成度
  26.         // 因此，同一个Action是不能同时作用于多个Node上，必须使用Action:clone()来复制一个Action
  27.         // 这也是使用原型设计模式的原因。
  28.         _elapsed = MATH_EPSILON;    // MATH_EPSILON是一个近似于0的值
  29.     }
  30.     else {                    
  31.         _elapsed += dt;        // 累加执行时间，
  32.     }
  34.     // 求线性插值时间点updateDt
  35.     // updateDt = _elapsed / _duration ，且在[0.0f, 1.0f]区间。
  36.     float updateDt = std::max(0.0f,std::min(1.0f, _elapsed / _duration) );
  38.     // 在子类MoveBy:update中进行线性插值，和对node进行属性修改操作。
  39.     this->update(updateDt);
  40. }
  42. void MoveBy::update(float t) {    //t是线性插值时间点，[0.0f, 1.0f]区间。
  43.     if (_target) {
  44. #if CC_ENABLE_STACKABLE_ACTIONS        // 多个MoveBy作用于同一个node会有叠加效果。原理比较简单。    
  45.         Vec3 currentPos = _target->getPosition3D();
  46.         Vec3 diff = currentPos - _previousPosition;
  47.         _startPosition = _startPosition + diff;
  49.         // _positionDelta 总位移
  50.         // _positionDelta * t = 从0到t事件点发生的位移
  51.         Vec3 newPos =  _startPosition + (_positionDelta * t);
  53.         _target->setPosition3D(newPos);
  54.         _previousPosition = newPos;
  55. #else // 多个MoveBy作用于同一个node不会有叠加效果。以最后一个执行的MoveBy为最终效果                    
  57.         _target->setPosition3D(_startPosition + _positionDelta * t);
  58. #endif // CC_ENABLE_STACKABLE_ACTIONS
  59.     }
  60. }

（三）主循环“驱动”动画

Action的最终执行还是要靠cocos的主循环来“驱动”ActionManager，由ActionManager来执行所有Action。
点击查看【processon】
相关源码：

  2. //--------------CCDirector.cpp
  3. bool Director::init() {
  4.     ......
  6.     _scheduler = new (std::nothrow) Scheduler();            // scheduler
  7.     _actionManager = new (std::nothrow) ActionManager();    // default action manager
  9.     // 动画是由Scheduler每帧调用ActionManager.update执行
  10.     // 优先级 : Scheduler::PRIORITY_SYSTEM，它是最高的优先级，保证了动画在所有schedule中最先执行。
  11.     _scheduler->scheduleUpdate(_actionManager, Scheduler::PRIORITY_SYSTEM, false);
  13.     ......
  14. }
  16. //--------------CCScheduler.cpp
  17. // Priority level reserved for system services.
  18. const int Scheduler::PRIORITY_SYSTEM = INT_MIN;
  20. // Minimum priority level for user scheduling.
  21. const int Scheduler::PRIORITY_NON_SYSTEM_MIN = PRIORITY_SYSTEM + 1;
  24. //--------------CCActionManager.cpp
  25. void ActionManager::update(float dt) {
  26.     // 执行每个!paused的Action，dt为距离上次调用的间隔时间，用于各Action累加时间。
  28.     ......
  29.     _currentTarget->currentAction->step(dt);
  30.     ......
  31. }

（四）执行Action：ActionManager

cocos所有的Action的都由ActionManager管理，同样也是由它来统一安排执行。

cocos引入了uthash库来实现hash表，详见uthash。

  2. class CC_DLL ActionManager : public Ref {
  3. ......
  4. protected:
  6.     // 通过一个hash表来存储所有的Action，详细结构见下面_hashElement
  8.     struct _hashElement    *_targets;            // 存储所有Action的hash表
  10.     struct _hashElement    *_currentTarget;        // 当前正在执行update的Action的target
  12.     // 如果在removeAction之后，该target的actions为空了，ActionManager会把该hash元素清除
  13.     // 但是，如果该target的action正在执行update（值为true），则不能立即清除，
  14.     // 这时候就需要这个标记，使得该target在刚好执行完action的update的时，再进行清除。
  15.     bool                  _currentTargetSalvaged;
  17. };
  19. // hash表中元素的结构
  20. typedef struct _hashElement
  21. {
  22.     // action数组，存储一个target的所有action
  23.     // actions.num 表示该数组当前存储的元素值
  24.     // actions.max 表示该数组的容量
  25.     // cocos在ccCArray.h中定义了相关的操作接口
  26.     struct _ccArray    *actions;
  28.     // node节点，hash表以此为key，transforms it into a bucket number
  29.     Node              *target;
  31.     // 如果是合法值，即在[0, actions.num)范围内，则表示该target的第actionIndex个action正在执行update
  32.     // 如果不是，则该target的action没有在执行update。
  33.     int              actionIndex;
  35.     // 意义同actionIndex
  36.     Action           *currentAction;
  38.     // 类似_currentTargetSalvaged
  39.     // 如果removeAction的action刚好就是currentAction，则不能马上删除该action
  40.     // 而是在该action的update执行完成之后在删除。
  41.     bool             currentActionSalvaged;
  43.     // target的action是否处于pause状态
  44.     bool             paused;
  46.     // uthash的用法，makes this structure hashable.
  47.     // 不需要赋值，使用名字hh可以使用更简化的调用接口。
  48.     UT_hash_handle     hh;
  50. } tHashElement;

ActionManager大部分的API都是查插删Action，也就是对hash表的查插删，这部分内容在uthash文章中有详细介绍，这里不再赘述。
这里主要学习一下Action是如何被执行的。

  2. //随着游戏主循环，每帧执行
  3. void ActionManager::update(float dt) {
  5.     // 遍历hash表中的所有元素
  6.     for (tHashElement *elt = _targets; elt != nullptr; ) {
  8.         // _currentTarget的action正在执行update
  9.         _currentTarget = elt;            
  10.         _currentTargetSalvaged = false;    
  12.         // 执行_currentTarget的所有action
  13.         if (! _currentTarget->paused) {
  14.             // The 'actions' MutableArray may change while inside this loop.
  16.             // 遍历_currentTarget的actions数组
  17.             for (_currentTarget->actionIndex = 0; 
  18.                  _currentTarget->actionIndex < _currentTarget->actions->num;
  19.                 _currentTarget->actionIndex++) {
  21.                 // _currentTarget->currentAction正在执行update
  22.                 _currentTarget->currentAction = static_cast<Action*>
  23.                     (_currentTarget->actions->arr[_currentTarget->actionIndex]);
  25.                 if (_currentTarget->currentAction == nullptr) continue;
  27.                 _currentTarget->currentActionSalvaged = false;    
  29.                 // 执行update
  30.                 _currentTarget->currentAction->step(dt);
  32.                 if (_currentTarget->currentActionSalvaged) {
  33.                     // The currentAction told the node to remove it. To prevent the action from
  34.                     // accidentally deallocating itself before finishing its step, we retained
  35.                     // it. Now that step is done, it's safe to release it.
  36.                     _currentTarget->currentAction->release();
  37.                 } 
  38.                 else if (_currentTarget->currentAction->isDone()) {
  39.                     _currentTarget->currentAction->stop();
  40.                     // action的stop函数并不是对action的用户提供，而是在这里被使用，属于回调性质的函数
  41.                     // 当前该action执行完毕时，回调。
  43.                     Action *action = _currentTarget->currentAction;
  44.                     // Make currentAction nil to prevent removeAction from salvaging it.
  45.                     _currentTarget->currentAction = nullptr;
  46.                     removeAction(action);
  47.                 }
  48.                 _currentTarget->currentAction = nullptr;
  49.             }
  50.         }
  52.         // elt, at this moment, is still valid so it is safe to ask this here (issue #490)
  53.         // 下一个hash元素，执行下一个target的Actions
  54.         elt = (tHashElement*)(elt->hh.next);
  56.         // only delete currentTarget if no actions were scheduled during the cycle (issue #481)
  57.         if (_currentTargetSalvaged && _currentTarget->actions->num == 0) {
  58.             deleteHashElement(_currentTarget);
  59.         }
  60.         //if some node reference 'target', it's reference count >= 2 (issues #14050)
  61.         else if (_currentTarget->target->getReferenceCount() == 1) {
  62.             deleteHashElement(_currentTarget);
  63.         }
  64.     }
  65.     // issue #635
  66.     _currentTarget = nullptr;
  67. }