结合源码看《我所理解的cocos2dx-3.0》——动画系统

最新推荐文章于 2021-11-20 15:29:27 发布
最新推荐文章于 2021-11-20 15:29:27 发布
阅读量471 收藏 1
点赞数
分类专栏： # 结合源码看《我所理解的cocos2dx-3.0》 文章标签： c++ cocos2d 动画 缓动函数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fztfztfzt/article/details/108297730
版权

文章目录

动画系统

简述

利用scheduleUpdate 对update进行的封装

  1. 足够早的执行，在逻辑和物理处理之前
  2. 使用action类描述动画，提供了并行和串行动画。
  3. 必须依附与node进行播放
  4. 将更新间隔转换成百分比0~1
  5. 使用CC_ENABLE_STACKABLE_ACTIONS控制是否叠加，只有Move，Jump，Besizer支持叠加

架构

在这里插入图片描述

Scheduler每一帧传入间隔时间dt调用ActionManager 的update()方法，ActionManager根据一个Action 的执行时间，在[dt,dt+duration]时间范围内调用Action的 step()方法，在 step方法内部将这个每一帧的时间进度转化为[0.0,1.0]的范围。最后将这个比例传给update进行计算。

类结构

image

动作的实现

延时动作都是在init的时候计算好要改变的值，使用startValue + diffValue * percent实现，其中percent是一个0到1的数，表示百分比，update的参数会根据初始化时的持续时间参数进行转换：

void ActionInterval::step(float dt)
{
    if (_firstTick)
    {
        _firstTick = false;
        _elapsed = 0;
    }
    else
    {
        _elapsed += dt;
    }
    float updateDt = std::max(0.0f,// needed for rewind. elapsed could be negative
                              std::min(1.0f, _elapsed / _duration));
    if (sendUpdateEventToScript(updateDt, this)) return;
    this->update(updateDt);
    _done = _elapsed >= _duration;
}

具体看2个动作的update实现

MoveBy 使用CC_ENABLE_STACKABLE_ACTIONS宏控制是否叠加。

void MoveBy::update(float t)
{
    if (_target)
    {
#if CC_ENABLE_STACKABLE_ACTIONS
        Vec3 currentPos = _target->getPosition3D();
        Vec3 diff = currentPos - _previousPosition;
        _startPosition = _startPosition + diff;
        Vec3 newPos =  _startPosition + (_positionDelta * t);
        _target->setPosition3D(newPos);
        _previousPosition = newPos;
#else
        _target->setPosition3D(_startPosition + _positionDelta * t);
#endif // CC_ENABLE_STACKABLE_ACTIONS
    }
}

void RotateTo::update(float time)
{
    if (_target)
    {
        if(_is3D)
        {
            _target->setRotation3D(Vec3(
                _startAngle.x + _diffAngle.x * time,
                _startAngle.y + _diffAngle.y * time,
                _startAngle.z + _diffAngle.z * time
            ));
        }
    }
}

叠加动作的实现

如moveBy所示，开启CC_ENABLE_STACKABLE_ACTIONS宏后，会使用_previousPosition变量保存本帧计算出的位置，在下次计算时，和当前位置计算出差异，这个差异就是一帧内其他动作叠加的变化，将这个差异叠加到_startPosition上，再计算本动作的变化值。

#if CC_ENABLE_STACKABLE_ACTIONS
        Vec3 currentPos = _target->getPosition3D();
        Vec3 diff = currentPos - _previousPosition;
        _startPosition = _startPosition + diff;
        Vec3 newPos =  _startPosition + (_positionDelta * t);
        _target->setPosition3D(newPos);
        _previousPosition = newPos;
#else

关于XXTo和XXBy的update实现

大部分都是XXTO继承自XXBy，也有XXBy继承XXTo，都是避免重写update方法，直接复用父类的方法。有些必须重写的方法还是要重写的，比如reverse、clone。

reverse

  • XXTo 类动作是不允许调用reverse接口的，如：
JumpTo* JumpTo::reverse() const
{
    CCASSERT(false, "reverse() not supported in JumpTo");
    return nullptr;
}
  • XXBy类接口的reverse是将参数翻转实现
  • 瞬时动作，如Show、Hide、Flip的reverse是创建一个对应的反义动作。

speed——速度的控制

通过speed可以控制ActionInterval延时动作的速度：

auto moveBy = MoveBy::Create(5,Vec2(200,0));
sprite->runAction(Speed::Create(moveBy,2));

在Speed的内部重写了step方法，它直接将速度参数乘以子动画的更新时间线。

void Speed::step(float dt)
{
    _innerAction->step(dt * _speed);
}

动画的回调

一般动画系统的实现都会利用事件机制，比如在播放完成时发出complete事件，以实现在动画完成时做某些逻辑的功能。cocos2dx的动画系统并没有这么做。

runAction并不提供动画完成时的回调，如果需要在动画完成时得到通知，则需要使用CallFunc即时动画来提供一个回调函数，并将它串联至一个动画后面，串联的所有Action将会被按顺序执行，最后一个动画CallFunc是一个即时动画，它立即执行指定的回调函数来实现动画完成时的功能。
除此之外，CannFunc可以放在任意一个 Action前面或者后面，用来实现如动画执行的前置条件或该动画完成时的回调等功能。

缓动函数——速度曲线的控制

Step和update参数使用百分比的设计另一个好处是缓动实现方便,只要在step里对百分比进行换算即可，cocos2dx的缓动函数的实现逻辑直接贴出来了，之后实现一些缓动效果可以用上:)


namespace tweenfunc {
    

#ifndef M_PI_X_2
#define M_PI_X_2 (float)M_PI * 2.0f
#endif




float tweenTo(float time, TweenType type, float *easingParam)
{
    float delta = 0;

    switch (type)
    {
        case CUSTOM_EASING:
            delta = customEase(time, easingParam);
            break;
            
        case Linear:
            delta = linear(time);
            break;
            
        case Sine_EaseIn:
            delta = sineEaseIn(time);
            break;
        case Sine_EaseOut:
            delta = sineEaseOut(time);
            break;
        case Sine_EaseInOut:
            delta = sineEaseInOut(time);
            break;
            
        case Quad_EaseIn:
            delta = quadEaseIn(time);
            break;
        case Quad_EaseOut:
            delta = quadEaseOut(time);
            break;
        case Quad_EaseInOut:
            delta = quadEaseInOut(time);
            break;
            
        case Cubic_EaseIn:
            delta = cubicEaseIn(time);
            break;
        case Cubic_EaseOut:
            delta = cubicEaseOut(time);
            break;
        case Cubic_EaseInOut:
            delta = cubicEaseInOut(time);
            break;
            
        case Quart_EaseIn:
            delta = quartEaseIn(time);
            break;
        case Quart_EaseOut:
            delta = quartEaseOut(time);
            break;
        case Quart_EaseInOut:
            delta = quartEaseInOut(time);
            break;
            
        case Quint_EaseIn:
            delta = quintEaseIn(time);
            break;
        case Quint_EaseOut:
            delta = quintEaseOut(time);
            break;
        case Quint_EaseInOut:
            delta = quintEaseInOut(time);
            break;
            
        case Expo_EaseIn:
            delta = expoEaseIn(time);
            break;
        case Expo_EaseOut:
            delta = expoEaseOut(time);
            break;
        case Expo_EaseInOut:
            delta = expoEaseInOut(time);
            break;
            
        case Circ_EaseIn:
            delta = circEaseIn(time);
            break;
        case Circ_EaseOut:
            delta = circEaseOut(time);
            break;
        case Circ_EaseInOut:
            delta = circEaseInOut(time);
            break;
            
        case Elastic_EaseIn:
        {
            float period = 0.3f;
            if (nullptr != easingParam) {
                period = easingParam[0];
            }
            delta = elasticEaseIn(time, period);
        }
            break;
        case Elastic_EaseOut:
        {
            float period = 0.3f;
            if (nullptr != easingParam) {
                period = easingParam[0];
            }
            delta = elasticEaseOut(time, period);
        }
            break;
        case Elastic_EaseInOut:
        {
            float period = 0.3f;
            if (nullptr != easingParam) {
                period = easingParam[0];
            }
            delta = elasticEaseInOut(time, period);
        }
            break;
            
            
        case Back_EaseIn:
            delta = backEaseIn(time);
            break;
        case Back_EaseOut:
            delta = backEaseOut(time);
            break;
        case Back_EaseInOut:
            delta = backEaseInOut(time);
            break;
            
        case Bounce_EaseIn:
            delta = bounceEaseIn(time);
            break;
        case Bounce_EaseOut:
            delta = bounceEaseOut(time);
            break;
        case Bounce_EaseInOut:
            delta = bounceEaseInOut(time);
            break;
            
        default:
            delta = sineEaseInOut(time);
            break;
    }

    return delta;
}

// Linear
float linear(float time)
{
    return time;
}


// Sine Ease
float sineEaseIn(float time)
{
    return -1 * cosf(time * (float)M_PI_2) + 1;
}
    
float sineEaseOut(float time)
{
    return sinf(time * (float)M_PI_2);
}
    
float sineEaseInOut(float time)
{
    return -0.5f * (cosf((float)M_PI * time) - 1);
}


// Quad Ease
float quadEaseIn(float time)
{
    return time * time;
}
    
float quadEaseOut(float time)
{
    return -1 * time * (time - 2);
}
    
float quadEaseInOut(float time)
{
    time = time*2;
    if (time < 1)
        return 0.5f * time * time;
    --time;
    return -0.5f * (time * (time - 2) - 1);
}



// Cubic Ease
float cubicEaseIn(float time)
{
    return time * time * time;
}
float cubicEaseOut(float time)
{
    time -= 1;
    return (time * time * time + 1);
}
float cubicEaseInOut(float time)
{
    time = time*2;
    if (time < 1)
        return 0.5f * time * time * time;
    time -= 2;
    return 0.5f * (time * time * time + 2);
}


// Quart Ease
float quartEaseIn(float time)
{
    return time * time * time * time;
}
    
float quartEaseOut(float time)
{
    time -= 1;
    return -(time * time * time * time - 1);
}
    
float quartEaseInOut(float time)
{
    time = time*2;
    if (time < 1)
        return 0.5f * time * time * time * time;
    time -= 2;
    return -0.5f * (time * time * time * time - 2);
}


// Quint Ease
float quintEaseIn(float time)
{
    return time * time * time * time * time;
}
    
float quintEaseOut(float time)
{
    time -=1;
    return (time * time * time * time * time + 1);
}
    
float quintEaseInOut(float time)
{
    time = time*2;
    if (time < 1)
        return 0.5f * time * time * time * time * time;
    time -= 2;
    return 0.5f * (time * time * time * time * time + 2);
}


// Expo Ease
float expoEaseIn(float time)
{
    return time == 0 ? 0 : powf(2, 10 * (time/1 - 1)) - 1 * 0.001f;
}
float expoEaseOut(float time)
{
    return time == 1 ? 1 : (-powf(2, -10 * time / 1) + 1);
}
float expoEaseInOut(float time)
{
    if(time == 0 || time == 1) 
        return time;
    
    if (time < 0.5f)
        return 0.5f * powf(2, 10 * (time * 2 - 1));

    return 0.5f * (-powf(2, -10 * (time * 2 - 1)) + 2);
}


// Circ Ease
float circEaseIn(float time)
{
    return -1 * (sqrt(1 - time * time) - 1);
}
float circEaseOut(float time)
{
    time = time - 1;
    return sqrt(1 - time * time);
}
float circEaseInOut(float time)
{
    time = time * 2;
    if (time < 1)
        return -0.5f * (sqrt(1 - time * time) - 1);
    time -= 2;
    return 0.5f * (sqrt(1 - time * time) + 1);
}


// Elastic Ease
float elasticEaseIn(float time, float period)
{

    float newT = 0;
    if (time == 0 || time == 1)
    {
        newT = time;
    }
    else
    {
        float s = period / 4;
        time = time - 1;
        newT = -powf(2, 10 * time) * sinf((time - s) * M_PI_X_2 / period);
    }

    return newT;
}
float elasticEaseOut(float time, float period)
{

    float newT = 0;
    if (time == 0 || time == 1)
    {
        newT = time;
    }
    else
    {
        float s = period / 4;
        newT = powf(2, -10 * time) * sinf((time - s) * M_PI_X_2 / period) + 1;
    }

    return newT;
}
float elasticEaseInOut(float time, float period)
{

    float newT = 0;
    if (time == 0 || time == 1)
    {
        newT = time;
    }
    else
    {
        time = time * 2;
        if (! period)
        {
            period = 0.3f * 1.5f;
        }

        float s = period / 4;

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


// Back Ease
float backEaseIn(float time)
{
    float overshoot = 1.70158f;
    return time * time * ((overshoot + 1) * time - overshoot);
}
float backEaseOut(float time)
{
    float overshoot = 1.70158f;

    time = time - 1;
    return time * time * ((overshoot + 1) * time + overshoot) + 1;
}
float backEaseInOut(float time)
{
    float overshoot = 1.70158f * 1.525f;

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



// Bounce Ease
float bounceTime(float time)
{
    if (time < 1 / 2.75f)
    {
        return 7.5625f * time * time;
    }
    else if (time < 2 / 2.75f)
    {
        time -= 1.5f / 2.75f;
        return 7.5625f * time * time + 0.75f;
    }
    else if(time < 2.5f / 2.75f)
    {
        time -= 2.25f / 2.75f;
        return 7.5625f * time * time + 0.9375f;
    }

    time -= 2.625f / 2.75f;
    return 7.5625f * time * time + 0.984375f;
}
float bounceEaseIn(float time)
{
    return 1 - bounceTime(1 - time);
}

float bounceEaseOut(float time)
{
    return bounceTime(time);
}

float bounceEaseInOut(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;
    }

    return newT;
}


// Custom Ease
float customEase(float time, float *easingParam)
{
    if (easingParam)
    {
        float tt = 1-time;
        return easingParam[1]*tt*tt*tt + 3*easingParam[3]*time*tt*tt + 3*easingParam[5]*time*time*tt + easingParam[7]*time*time*time;
    }
    return time;
}

float easeIn(float time, float rate)
{
    return powf(time, rate);
}

float easeOut(float time, float rate)
{
    return powf(time, 1 / rate);
}
    
float easeInOut(float time, float rate)
{
    time *= 2;
    if (time < 1)
    {
        return 0.5f * powf(time, rate);
    }
    else
    {
        return (1.0f - 0.5f * powf(2 - time, rate));
    }
}
    
float quadraticIn(float time)
{
    return   powf(time,2);
}
    
float quadraticOut(float time)
{
    return -time*(time-2);
}
    
float quadraticInOut(float time)
{
    
    float resultTime = time;
    time = time*2;
    if (time < 1)
    {
        resultTime = time * time * 0.5f;
    }
    else
    {
        --time;
        resultTime = -0.5f * (time * (time - 2) - 1);
    }
    return resultTime;
}
    
float bezieratFunction( float a, float b, float c, float d, float t )
{
    return (powf(1-t,3) * a + 3*t*(powf(1-t,2))*b + 3*powf(t,2)*(1-t)*c + powf(t,3)*d );
}
    
}

结合node运行

使用node的runAction接口会将action添加到director的actionManager中：_actionManager = _director->getActionManager();

Action * Node::runAction(Action* action)
{
    CCASSERT( action != nullptr, "Argument must be non-nil");
    _actionManager->addAction(action, this, !_running);
    return action;
}

actionManager的addAction会将action加入action数组中，并设置action的target

ActionManager

执行时机

动画在游戏循环中相对于游戏状态更新逻辑应该是一个比较低阶的系统，它的优先级应该足够低，所以它被较早地执行。因为还有其他的如物理系统及后面的逻辑处理阶段，这些都有可能修改游戏对象的属性。实际上物理碰撞也是一个相对比较低阶的系统，最终这些对游戏对象的影响都可以被逻辑更新所修改。
那么，Cocos2d-x如何保证动画系统被最早地执行呢?实际上，Cocos2d-x 中的所有动画都是通过一个Schedule 来完成的，它首先保证所有动画在一起执行。然而，与其他Schedule不同的是，动画系统被指定为一个特殊的优先级:PRIORITY_SYSTEM。

在Director::init()中,将ActionManager加入定时器。

    _actionManager = new (std::nothrow) ActionManager();
    _scheduler->scheduleUpdate(_actionManager, Scheduler::PRIORITY_SYSTEM, false);

执行逻辑

在update中，调用所有对象的action，执行update方法。如果action执行完成（isDone），就先调用action的stop接口，再移出数组。

// main loop
void ActionManager::update(float dt)
{
    for (tHashElement *elt = _targets; elt != nullptr; )
    {
        _currentTarget = elt;
        _currentTargetSalvaged = false;

        if (! _currentTarget->paused)
        {
            // The 'actions' MutableArray may change while inside this loop.
            for (_currentTarget->actionIndex = 0; _currentTarget->actionIndex < _currentTarget->actions->num;
                _currentTarget->actionIndex++)
            {
                _currentTarget->currentAction = static_cast<Action*>(_currentTarget->actions->arr[_currentTarget->actionIndex]);
                if (_currentTarget->currentAction == nullptr)
                {
                    continue;
                }

                _currentTarget->currentActionSalvaged = false;

                _currentTarget->currentAction->step(dt);

                if (_currentTarget->currentActionSalvaged)
                {
                    // The currentAction told the node to remove it. To prevent the action from
                    // accidentally deallocating itself before finishing its step, we retained
                    // it. Now that step is done, it's safe to release it.
                    _currentTarget->currentAction->release();
                } else
                if (_currentTarget->currentAction->isDone())
                {
                    _currentTarget->currentAction->stop();

                    Action *action = _currentTarget->currentAction;
                    // Make currentAction nil to prevent removeAction from salvaging it.
                    _currentTarget->currentAction = nullptr;
                    removeAction(action);
                }

                _currentTarget->currentAction = nullptr;
            }
        }

        // elt, at this moment, is still valid
        // so it is safe to ask this here (issue #490)
        elt = (tHashElement*)(elt->hh.next);

        // only delete currentTarget if no actions were scheduled during the cycle (issue #481)
        if (_currentTargetSalvaged && _currentTarget->actions->num == 0)
        {
            deleteHashElement(_currentTarget);
        }
        //if some node reference 'target', it's reference count >= 2 (issues #14050)
        else if (_currentTarget->target->getReferenceCount() == 1)
        {
            deleteHashElement(_currentTarget);
        }
    }

    // issue #635
    _currentTarget = nullptr;
}
细节
  • 在遍历不同target时，设置当前正在变量的target到_currentTarget上，在update结束时，将_currentTarget置空。
  • 在target没有action时，移出target
  • 如果target的action执行完一次后，其引用计数变成了1，表示没有其他引用了，可以移出队列。

动作队列

cocos2dx提供了3种类型的动画队列

  • 一个Sequence动画包含多个子动画，Sequence中的每个子动画按顺序一个接着一个地执行。
  • 一个Spawn动画包含多个子动画，Sawan中的所有子动画同时开始执行。
  • 一个Repeat和RepeatForever动画包含一个子动画，Repeat对子动画重复执行指定次数，而 RepeatForever一直重复执行子动画。

Sequence

一个Sequence动画是一个连续执行的动画集合，它按照每个子Action被构造的顺序执行，如果一个动画执行完毕，立即接着执行下一个动画，当最后一个动画执行完毕后，则 Sequence动画执行完毕。
Sequence的动画执行时间是所有子动画执行时间的总和。

Sequence本身也是一个动作，继承自延时动作基类ActionInterval

/** @class Sequence
 * @brief Runs actions sequentially, one after another.
 */
class CC_DLL Sequence : public ActionInterval
{
public:
    static Sequence* create(FiniteTimeAction *action1, ...) CC_REQUIRES_NULL_TERMINATION;
    static Sequence* create(const Vector<FiniteTimeAction*>& arrayOfActions);
    static Sequence* createWithTwoActions(FiniteTimeAction *actionOne, FiniteTimeAction *actionTwo);
    virtual void update(float t) override;

protected:
    FiniteTimeAction *_actions[2];
}

Sequence是一个二叉树的结构，init接口中，如果动画数量是0则直接delete掉，返回null，不创建队列。只有一个时，构造个ExtraAction动画。大小大于1时，构造一个二叉树。

bool Sequence::init(const Vector<FiniteTimeAction*>& arrayOfActions)
{
    auto count = arrayOfActions.size();
    if (count == 0)
        return false;

    if (count == 1)
        return initWithTwoActions(arrayOfActions.at(0), ExtraAction::create());

    // else size > 1
    auto prev = arrayOfActions.at(0);
    for (int i = 1; i < count-1; ++i)
    {
        prev = createWithTwoActions(prev, arrayOfActions.at(i));
    }

    return initWithTwoActions(prev, arrayOfActions.at(count-1));
}

在这里插入图片描述
Sequence的update:因为只有左右2个子节点，计算好时间调用子节点的update即可。

Spawn

与Sequence相反，Sawan则让所有子动画同时执行。例如想要让一个轮子移动一段距离，由于受摩擦力作用，它应该一边旋转一边移动，例如:

auto moveBy=MoveBy::create(5,Vec2(200,O));
auto rotateBy=RotateBy::create(5,360);
auto spawn=Spawn::create(moveBy,rotateBy,NULL);
sprite->runAction(spawn);

与Sequence一样，Spawn也接收一个变长的参数列表，并以NULL 结尾。Spawn动画执行的时间是所有子动画中执行时间最长的时间。

Spawn的create过程和Sequence一样，也是一个二叉树。
在这里插入图片描述
相比较Sequence，Spawn的update实现就简单很多了，直接调用每个action的update即可。


void Spawn::update(float time)
{
    if (_one)
    {
        if (!(sendUpdateEventToScript(time, _one)))
            _one->update(time);
    }
    if (_two)
    {
        if (!(sendUpdateEventToScript(time, _two)))
            _two->update(time);
    }
}

Repeat和RepeatForever

还有一种控制动画，它用来控制子动画的重复行为。例如我们想要红灯忽闪忽闪的效果，可以使用前面讲述的Sequence来组合一个FadeIn和FadeOut的序列，然后使用RepeatForever来使其一直重复。

auto fadeIn=FadeIn: :create(0.8);
auto fadeout-Fadeout::create(O.8);
auto sequence=Sequence::create (fadeIn,fadeout,NULL);
auto repeaterForever=RepeatForever::create (sequence);
sprite->runAction(repeaterForever);

RepeatForever永远不会停止，isDone直接返回false了。step接口直接调用了action的step，之后判断动作如果执行完成则重新初始化。

void RepeatForever::step(float dt)
{
    _innerAction->step(dt);
    // only action interval should prevent jerk, issue #17808
    if (_innerAction->isDone() && _innerAction->getDuration() > 0)
    {
        float diff = _innerAction->getElapsed() - _innerAction->getDuration();
        if (diff > _innerAction->getDuration())
            diff = fmodf(diff, _innerAction->getDuration());
        _innerAction->startWithTarget(_target);
        // to prevent jerk. cocos2d-iphone issue #390, 1247
        _innerAction->step(0.0f);
        _innerAction->step(diff);
    }
}

bool RepeatForever::isDone() const
{
    return false;
}
fztfztfzt
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
cocos2dx-3.0功能强大的richText控件源码
09-11
在Cocos2dx 3.0版本中，引入了名为RichText的控件，这是一个非常强大的文本渲染工具，尤其适合需要展示复杂格式化文本的场景，比如聊天应用、游戏内的提示信息或者菜单界面。 RichText控件的核心特性在于它能够支持...
5.Spring Boot Data JPA
minipa blog 博客
01-16 212
[作者信息] github: https://github.com/MiniPa email: eric.fourpackcn@outlook.com [项目代码：https://github.com/MiniPa/spring_boot_demos] =====================================================================
【教程】Cocos Sequence动画不执行CallFunc问题
Cocos的博客
05-31 58
感谢『简书ID： 不求甚解_b44d』友情提供http://www.jianshu.com/p/2552901b471f使用Cocos的开发者越来越多，不仅国内受用，足迹还遍布了东南亚和欧美等海外国家。优越的性能和代码值得我们在项目开发工作中不断探索和研究。最近，我在开发一个项目，我需要在场景中添加一个动画，并且在动画执行完毕后就移除它。一般做法是这样的先创建一个Animate:添加我们的回调函数...
Cocos2dx - 缓动Action
极客七
08-07 1717
cocos2d-x + lua 编程基础 之 动作篇普通动作瞬时动作有限时动作缓冲动作指数缓冲赛因缓冲弹性缓冲跳跃缓冲![在这里插入图片描述](https://img-blog.csdnimg.cn/20190807001057847.jpg)回震缓冲组合动作序列帧动画并行混合动画 普通动作 瞬时动作 用法: local hideAction = cc.Hide:create() node:ru...
cocoscreator缓动动作,比如easebackout自定义设置超出目标距离
Kade's Code
02-13 5640
this._easeBackOutObj = { easing: function(time1) { var overshoot = 0.90158; time1 = time1 - 1; return time1 * time1 * ((overshoot + 1) * time1 + overshoot) + 1; }, }; let actMove = cc.moveTo(0....
【Cocos2d-x游戏引擎开发笔记(4)】系统动画
卡尔
12-07 9875
原创文章，转载请注明出处：http://blog.csdn.net/zhy_cheng/article/details/8271154 Cocos2d-x提供的动画主要是瞬时动画和延时动画。 瞬时动作就是不需要时间，马上就完成的动作。瞬时动作的共同基类是CCActionInstant。 延时动作就是指动作的完成需要一段时间。因此，几乎所有的延时动作都使用执行时间作为第一个参数，它们有着共
cocos2dx-3.0api
08-18
cocos api
cocos2dx-3.0+Box2D例子
08-28
《cocos2dx 3.0与Box2D结合应用详解》 在游戏开发领域，cocos2dx是一个广泛使用的2D游戏开发框架，而Box2D则是一款强大的物理引擎，用于模拟现实世界的物理效果。本教程将深入探讨如何在cocos2dx 3.0版本中直接使用...
Cocos2d-x 3.0 开发（八）骨骼动画的动态换肤
01-31
游戏中人物的状态会发生改变，而这种改变通常要通过局部的变化来表现出来。比如获得一件装备后人物形象的改变，或者战斗中武器、防具的损坏等。这些变化的实现就要通过动态换肤来实现。在这个Demo中，点击屏幕会动态...
Cocos2dx Action动画机制
XIANG__jiangsu的专栏
10-11 1932
1 动画执行过程cocos中的动画通过节点执行，如： node:runAction( cc.Sequence:create(cc.DelayTime:create(1.4),cc.CallFunc:create(removeThis))) runAction方法将动画添加至动画管理器中。动画管理器将节点的动画信息全部关联至element中，并以节点作为key，element作为value生成ha
cocos creator 牌面翻转
热门推荐
jia_ly的博客
02-22 1万+
cocos creator 牌面翻转 思路描述 利用方法 var rotationTo = cc.rotateTo(1, 0, 180); this.paiNode.runAction(rotationTo); 进行位置的移动。移动完成之后，Node.setScaleX(-1); 完成翻转。在 update 中监 Node.rotationY 的值，达到自己要求的时候，更换精灵图...
ccConfig（设置一些底层接口状态：是否支持动作叠加 设置fps更新间隔和位置 是否画边框等。。）
sssssNian的专栏
06-03 1769
#ifndef __CCCONFIG_H__ #define __CCCONFIG_H__ #include "platform/CCPlatformConfig.h" /**  @file  cocos2d (cc) configuration file */ /** @def CC_ENABLE_STACKABLE_ACTIONS  If e
Cocos Creator里cc.tween的stopAllActions() 和 repeatForever的用法
Dust的博客
11-20 5617
this.useNowBtn.stopAllActions(); this.useNowBtn.setPosition(46 + t * 120, 360); cc.tween(this.useNowBtn) .repeatForever( cc.tween() .by(0.3, { position: cc.v2(0, -30) }) .by(0.3, { position: cc.v2(0, 30) }) ) .start(); 注意stopAllActions()只能停止挂在
cocos2dx 常见的49中动作详解
weixin_30340353的博客
04-06 398
bool HelloWorld::init() { ////////////////////////////// // 1. super init first if ( !CCLayer::init() ) { return false; } CCSprite * sp= CCSprite::create("I...
cocos2d-x实现多个精灵动画同步播放(一)
qiou2719的专栏
07-13 4452
2D游戏经常有角色穿装备的情况，如下图角色手部加了一个武器.此外还有格斗游戏里常有的投技： 我们要想让武器随角色一起联动，自然想到设定好位置和zorder后，调用CCSpawn同时动作的方法。可这有个大问题，就是独立执行两个不同的动画会有很大机率产生不同步的问题。为了解决这一问题，必须实现一种动画组的机制，就是让人物作为动画组的主动画，武器作为动画组的子成员，当主动画帧切换时子动画才切换。也就是我动你才你，要动一起动。
cocos2dx 3.1从零学习（五）——动画
Ben_OnceMore
06-25 3675
动画是游戏中最重要的表现部分，本篇只是初步学习大部分动画的使用方法，没有什么原理性的东西，没有太多的干活，但是例子有很多，如果有不熟的地方要练一下。 特别是Spawn和Sequence的组合使用，什么时候使用Spawn，什么使用使用Sequence，怎么在它们之间相互嵌套对方。用光你的脑细胞尽力的去折磨这几个函数吧！做出尽可能多的绚丽的组合！
cocos2dx多个动作并列执行或按照顺序执行
Lampard的博客
04-23 2890
cocos2dx多个动作并列执行或按照顺序执行 大家好，我是Lampard 我在【捕鱼达人】游戏开发的时候，遇到了不知道如何让鱼类的多个动作同时执行的问题 所以今天为了解决这个问题写下了这篇博客 （一）顺序执行Sequence 首先是顺序执行，我们的鱼类是在游戏层的时候利用计时器调用回调函数生成的。在鱼类生成了之后，它就会向着屏幕的另一方向...
cocos2d-x帧动画与平移动作组合问题
chen13216824835的博客
06-12 957
今天看到一道题，大概就是把MoveTo和Animate动作在组合在一起或者说是同时进行。我一开始是将MoveTo和Animate以参数的形式加入到Spwan类的create中去，代码如下： auto* action1 = Animate::create(animation); auto* action2 = MoveTo::create(5.0f, Vec2(640, 180)); auto*...
cocos2d-x实现多个精灵动画同步播放(二)
qiou2719的专栏
07-13 3111
在上一篇文章里，提到了两个不同类的对象动画组合在一起需要注意更多的xla
cocos2dx-lua 模拟鼠标按下
最新发布
01-20
cocos2dx-lua是一个基于Cocos2d-x游戏引擎的Lua语言绑定框架。要在cocos2dx-lua中模拟鼠标按下操作，可以使用Cocos2d-x引擎提供的触摸事件相关的方法来实现。 首先，需要在Lua代码中创建一个事件监听器，并重写...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值