#include "TimelineState.h"
#include "WorldClock.h"
#include "Animation.h"
#include "../model/DragonBonesData.h"
#include "../model/UserData.h"
#include "../model/ArmatureData.h"
#include "../model/ConstraintData.h"
#include "../model/DisplayData.h"
#include "../model/AnimationData.h"
#include "../event/EventObject.h"
#include "../event/IEventDispatcher.h"
#include "../armature/Armature.h"
#include "../armature/Bone.h"
#include "../armature/Slot.h"
#include "../armature/Constraint.h"
#include "../armature/DeformVertices.h"
#include "AnimationState.h"

DRAGONBONES_NAMESPACE_BEGIN

void ActionTimelineState::_onCrossFrame(unsigned frameIndex) const
{
    const auto eventDispatcher = _armature->getProxy();

    if (_animationState->actionEnabled)
    {
        const auto frameOffset =
            _animationData->frameOffset +
            _timelineArray[_timelineData->offset + (unsigned)BinaryOffset::TimelineFrameOffset + frameIndex];
        const unsigned actionCount = _frameArray[frameOffset + 1];
        const auto& actions =
            _animationData->parent->actions;  // May be the animaton data not belong to this armature data.

        for (std::size_t i = 0; i < actionCount; ++i)
        {
            const auto actionIndex = _frameArray[frameOffset + 2 + i];
            const auto action      = actions[actionIndex];

            if (action->type == ActionType::Play)
            {
                const auto eventObject = BaseObject::borrowObject<EventObject>();
                // eventObject->time = _frameArray[frameOffset] * _frameRateR; // Precision problem
                eventObject->time           = _frameArray[frameOffset] / _frameRate;
                eventObject->animationState = _animationState;
                EventObject::actionDataToInstance(action, eventObject, _armature);
                _armature->_bufferAction(eventObject, true);
            }
            else
            {
                const auto eventType =
                    action->type == ActionType::Frame ? EventObject::FRAME_EVENT : EventObject::SOUND_EVENT;
                if (action->type == ActionType::Sound || eventDispatcher->hasDBEventListener(eventType))
                {
                    const auto eventObject = BaseObject::borrowObject<EventObject>();
                    // eventObject->time = _frameArray[frameOffset] * _frameRateR; // Precision problem
                    eventObject->time           = _frameArray[frameOffset] / _frameRate;
                    eventObject->animationState = _animationState;
                    EventObject::actionDataToInstance(action, eventObject, _armature);
                    _armature->_dragonBones->bufferEvent(eventObject);
                }
            }
        }
    }
}

void ActionTimelineState::update(float passedTime)
{
    const auto prevState = playState;
    auto prevPlayTimes   = currentPlayTimes;
    auto prevTime        = currentTime;

    if (_setCurrentTime(passedTime))
    {
        const auto eventDispatcher = _armature->getProxy();
        if (prevState < 0)
        {
            if (playState != prevState)
            {
                if (_animationState->displayControl && _animationState->resetToPose)  // Reset zorder to pose.
                {
                    _armature->_sortZOrder(nullptr, 0);
                }

                prevPlayTimes = currentPlayTimes;

                if (eventDispatcher->hasDBEventListener(EventObject::START))
                {
                    const auto eventObject      = BaseObject::borrowObject<EventObject>();
                    eventObject->type           = EventObject::START;
                    eventObject->armature       = _armature;
                    eventObject->animationState = _animationState;
                    _armature->_dragonBones->bufferEvent(eventObject);
                }
            }
            else
            {
                return;
            }
        }

        const auto isReverse           = _animationState->timeScale < 0.0f;
        EventObject* loopCompleteEvent = nullptr;
        EventObject* completeEvent     = nullptr;

        if (currentPlayTimes != prevPlayTimes)
        {
            if (eventDispatcher->hasDBEventListener(EventObject::LOOP_COMPLETE))
            {
                loopCompleteEvent                 = BaseObject::borrowObject<EventObject>();
                loopCompleteEvent->type           = EventObject::LOOP_COMPLETE;
                loopCompleteEvent->armature       = _armature;
                loopCompleteEvent->animationState = _animationState;
            }

            if (playState > 0)
            {
                if (eventDispatcher->hasDBEventListener(EventObject::COMPLETE))
                {
                    completeEvent                 = BaseObject::borrowObject<EventObject>();
                    completeEvent->type           = EventObject::COMPLETE;
                    completeEvent->armature       = _armature;
                    completeEvent->animationState = _animationState;
                }
            }
        }

        if (_frameCount > 1)
        {
            const auto timelineData       = _timelineData;
            const auto timelineFrameIndex = (unsigned)(currentTime * _frameRate);  // uint
            const auto frameIndex         = (*_frameIndices)[timelineData->frameIndicesOffset + timelineFrameIndex];

            if ((unsigned)_frameIndex != frameIndex)  // Arrive at frame.
            {
                auto crossedFrameIndex = _frameIndex;
                _frameIndex            = frameIndex;

                if (_timelineArray != nullptr)
                {
                    _frameOffset = _animationData->frameOffset +
                                   _timelineArray[timelineData->offset + (unsigned)BinaryOffset::TimelineFrameOffset +
                                                  _frameIndex];

                    if (isReverse)
                    {
                        if (crossedFrameIndex < 0)
                        {
                            const auto prevFrameIndex = (unsigned)(prevTime * _frameRate);
                            crossedFrameIndex = (*_frameIndices)[timelineData->frameIndicesOffset + prevFrameIndex];

                            if (currentPlayTimes == prevPlayTimes)  // Start.
                            {
                                if ((unsigned)crossedFrameIndex == frameIndex)  // Uncrossed.
                                {
                                    crossedFrameIndex = -1;
                                }
                            }
                        }

                        while (crossedFrameIndex >= 0)
                        {
                            const auto frameOffset =
                                _animationData->frameOffset +
                                _timelineArray[timelineData->offset + (unsigned)BinaryOffset::TimelineFrameOffset +
                                               crossedFrameIndex];
                            const auto framePosition = (float)_frameArray[frameOffset] / _frameRate;

                            if (_position <= framePosition &&
                                framePosition <= _position + _duration)  // Support interval play.
                            {
                                _onCrossFrame(crossedFrameIndex);
                            }

                            if (loopCompleteEvent != nullptr &&
                                crossedFrameIndex == 0)  // Add loop complete event after first frame.
                            {
                                _armature->_dragonBones->bufferEvent(loopCompleteEvent);
                                loopCompleteEvent = nullptr;
                            }

                            if (crossedFrameIndex > 0)
                            {
                                crossedFrameIndex--;
                            }
                            else
                            {
                                crossedFrameIndex = _frameCount - 1;
                            }

                            if ((unsigned)crossedFrameIndex == frameIndex)
                            {
                                break;
                            }
                        }
                    }
                    else
                    {
                        if (crossedFrameIndex < 0)
                        {
                            const auto prevFrameIndex = (unsigned)(prevTime * _frameRate);
                            crossedFrameIndex = (*_frameIndices)[timelineData->frameIndicesOffset + prevFrameIndex];
                            const auto frameOffset =
                                _animationData->frameOffset +
                                _timelineArray[timelineData->offset + (unsigned)BinaryOffset::TimelineFrameOffset +
                                               crossedFrameIndex];
                            const auto framePosition = (float)_frameArray[frameOffset] / _frameRate;

                            if (currentPlayTimes == prevPlayTimes)  // Start.
                            {
                                if (prevTime <= framePosition)  // Crossed.
                                {
                                    if (crossedFrameIndex > 0)
                                    {
                                        crossedFrameIndex--;
                                    }
                                    else
                                    {
                                        crossedFrameIndex = _frameCount - 1;
                                    }
                                }
                                else if ((unsigned)crossedFrameIndex == frameIndex)  // Uncrossed.
                                {
                                    crossedFrameIndex = -1;
                                }
                            }
                        }

                        while (crossedFrameIndex >= 0)
                        {
                            if ((unsigned)crossedFrameIndex < _frameCount - 1)
                            {
                                crossedFrameIndex++;
                            }
                            else
                            {
                                crossedFrameIndex = 0;
                            }

                            const auto frameOffset =
                                _animationData->frameOffset +
                                _timelineArray[timelineData->offset + (unsigned)BinaryOffset::TimelineFrameOffset +
                                               crossedFrameIndex];
                            const auto framePosition = (float)_frameArray[frameOffset] / _frameRate;

                            if (_position <= framePosition &&
                                framePosition <= _position + _duration)  // Support interval play.
                            {
                                _onCrossFrame(crossedFrameIndex);
                            }

                            if (loopCompleteEvent != nullptr &&
                                crossedFrameIndex == 0)  // Add loop complete event before first frame.
                            {
                                _armature->_dragonBones->bufferEvent(loopCompleteEvent);
                                loopCompleteEvent = nullptr;
                            }

                            if ((unsigned)crossedFrameIndex == frameIndex)
                            {
                                break;
                            }
                        }
                    }
                }
            }
        }
        else if (_frameIndex < 0)
        {
            _frameIndex = 0;
            if (_timelineData != nullptr)
            {
                _frameOffset = _animationData->frameOffset +
                               _timelineArray[_timelineData->offset + (unsigned)BinaryOffset::TimelineFrameOffset];
                // Arrive at frame.
                const auto framePosition = (float)_frameArray[_frameOffset] / _frameRate;

                if (currentPlayTimes == prevPlayTimes)  // Start.
                {
                    if (prevTime <= framePosition)
                    {
                        _onCrossFrame(_frameIndex);
                    }
                }
                else if (_position <= framePosition)  // Loop complete.
                {
                    if (!isReverse && loopCompleteEvent != nullptr)  // Add loop complete event before first frame.
                    {
                        _armature->_dragonBones->bufferEvent(loopCompleteEvent);
                        loopCompleteEvent = nullptr;
                    }

                    _onCrossFrame(_frameIndex);
                }
            }
        }

        if (loopCompleteEvent != nullptr)
        {
            _armature->_dragonBones->bufferEvent(loopCompleteEvent);
        }

        if (completeEvent != nullptr)
        {
            _armature->_dragonBones->bufferEvent(completeEvent);
        }
    }
}

void ActionTimelineState::setCurrentTime(float value)
{
    _setCurrentTime(value);
    _frameIndex = -1;
}

void ZOrderTimelineState::_onArriveAtFrame()
{
    if (playState >= 0)
    {
        const auto count = _frameArray[_frameOffset + 1];
        if (count > 0)
        {
            _armature->_sortZOrder(_frameArray, _frameOffset + 2);
        }
        else
        {
            _armature->_sortZOrder(nullptr, 0);
        }
    }
}

void BoneAllTimelineState::_onArriveAtFrame()
{
    BoneTimelineState::_onArriveAtFrame();

    if (_timelineData != nullptr)
    {
        auto valueOffset =
            _animationData->frameFloatOffset + _frameValueOffset +
            _frameIndex *
                6;  // ...(timeline value offset)|xxxxxx|xxxxxx|(Value offset)xxxxx|(Next offset)xxxxx|xxxxxx|xxxxxx|...
        const auto scale           = _armature->_armatureData->scale;
        const auto frameFloatArray = _frameFloatArray;
        auto& current              = bonePose->current;
        auto& delta                = bonePose->delta;
        //
        current.x        = frameFloatArray[valueOffset++] * scale;
        current.y        = frameFloatArray[valueOffset++] * scale;
        current.rotation = frameFloatArray[valueOffset++];
        current.skew     = frameFloatArray[valueOffset++];
        current.scaleX   = frameFloatArray[valueOffset++];
        current.scaleY   = frameFloatArray[valueOffset++];

        if (_tweenState == TweenState::Always)
        {
            if ((unsigned)_frameIndex == _frameCount - 1)
            {
                valueOffset = _animationData->frameFloatOffset + _frameValueOffset;
            }

            delta.x        = frameFloatArray[valueOffset++] * scale - current.x;
            delta.y        = frameFloatArray[valueOffset++] * scale - current.y;
            delta.rotation = frameFloatArray[valueOffset++] - current.rotation;
            delta.skew     = frameFloatArray[valueOffset++] - current.skew;
            delta.scaleX   = frameFloatArray[valueOffset++] - current.scaleX;
            delta.scaleY   = frameFloatArray[valueOffset++] - current.scaleY;
        }
        else
        {
            delta.x        = 0.0f;
            delta.y        = 0.0f;
            delta.rotation = 0.0f;
            delta.skew     = 0.0f;
            delta.scaleX   = 0.0f;
            delta.scaleY   = 0.0f;
        }
    }
    else
    {
        auto& current    = bonePose->current;
        auto& delta      = bonePose->delta;
        current.x        = 0.0f;
        current.y        = 0.0f;
        current.rotation = 0.0f;
        current.skew     = 0.0f;
        current.scaleX   = 1.0f;
        current.scaleY   = 1.0f;
        delta.x          = 0.0f;
        delta.y          = 0.0f;
        delta.rotation   = 0.0f;
        delta.skew       = 0.0f;
        delta.scaleX     = 0.0f;
        delta.scaleY     = 0.0f;
    }
}

void BoneAllTimelineState::_onUpdateFrame()
{
    BoneTimelineState::_onUpdateFrame();

    auto& current = bonePose->current;
    auto& delta   = bonePose->delta;
    auto& result  = bonePose->result;

    bone->_transformDirty = true;
    if (_tweenState != TweenState::Always)
    {
        _tweenState = TweenState::None;
    }

    result.x        = current.x + delta.x * _tweenProgress;
    result.y        = current.y + delta.y * _tweenProgress;
    result.rotation = current.rotation + delta.rotation * _tweenProgress;
    result.skew     = current.skew + delta.skew * _tweenProgress;
    result.scaleX   = current.scaleX + delta.scaleX * _tweenProgress;
    result.scaleY   = current.scaleY + delta.scaleY * _tweenProgress;
}

void BoneAllTimelineState::fadeOut()
{
    auto& result    = bonePose->result;
    result.rotation = Transform::normalizeRadian(result.rotation);
    result.skew     = Transform::normalizeRadian(result.skew);
}

void BoneTranslateTimelineState::_onArriveAtFrame()
{
    BoneTimelineState::_onArriveAtFrame();

    if (_timelineData != nullptr)
    {
        auto valueOffset           = _animationData->frameFloatOffset + _frameValueOffset + _frameIndex * 2;
        const auto scale           = _armature->_armatureData->scale;
        const auto frameFloatArray = _frameFloatArray;
        auto& current              = bonePose->current;
        auto& delta                = bonePose->delta;

        current.x = frameFloatArray[valueOffset++] * scale;
        current.y = frameFloatArray[valueOffset++] * scale;

        if (_tweenState == TweenState::Always)
        {
            if ((unsigned)_frameIndex == _frameCount - 1)
            {
                valueOffset = _animationData->frameFloatOffset + _frameValueOffset;  // + 0 * 2
            }

            delta.x = frameFloatArray[valueOffset++] * scale - current.x;
            delta.y = frameFloatArray[valueOffset++] * scale - current.y;
        }
        else
        {
            delta.x = 0.0f;
            delta.y = 0.0f;
        }
    }
    else
    {
        auto& current = bonePose->current;
        auto& delta   = bonePose->delta;
        current.x     = 0.0f;
        current.y     = 0.0f;
        delta.x       = 0.0f;
        delta.y       = 0.0f;
    }
}

void BoneTranslateTimelineState::_onUpdateFrame()
{
    BoneTimelineState::_onUpdateFrame();

    auto& current = bonePose->current;
    auto& delta   = bonePose->delta;
    auto& result  = bonePose->result;

    bone->_transformDirty = true;
    if (_tweenState != TweenState::Always)
    {
        _tweenState = TweenState::None;
    }

    result.x = current.x + delta.x * _tweenProgress;
    result.y = current.y + delta.y * _tweenProgress;
}

void BoneRotateTimelineState::_onArriveAtFrame()
{
    BoneTimelineState::_onArriveAtFrame();

    if (_timelineData != nullptr)
    {
        auto valueOffset           = _animationData->frameFloatOffset + _frameValueOffset + _frameIndex * 2;
        const auto frameFloatArray = _frameFloatArray;
        auto& current              = bonePose->current;
        auto& delta                = bonePose->delta;

        current.rotation = frameFloatArray[valueOffset++];
        current.skew     = frameFloatArray[valueOffset++];

        if (_tweenState == TweenState::Always)
        {
            if ((unsigned)_frameIndex == _frameCount - 1)
            {
                valueOffset    = _animationData->frameFloatOffset + _frameValueOffset;  // + 0 * 2
                delta.rotation = Transform::normalizeRadian(frameFloatArray[valueOffset++] - current.rotation);
            }
            else
            {
                delta.rotation = frameFloatArray[valueOffset++] - current.rotation;
            }

            delta.skew = frameFloatArray[valueOffset++] - current.skew;
        }
        else
        {
            delta.rotation = 0.0f;
            delta.skew     = 0.0f;
        }
    }
    else
    {
        auto& current    = bonePose->current;
        auto& delta      = bonePose->delta;
        current.rotation = 0.0f;
        current.skew     = 0.0f;
        delta.rotation   = 0.0f;
        delta.skew       = 0.0f;
    }
}

void BoneRotateTimelineState::_onUpdateFrame()
{
    BoneTimelineState::_onUpdateFrame();

    auto& current = bonePose->current;
    auto& delta   = bonePose->delta;
    auto& result  = bonePose->result;

    bone->_transformDirty = true;
    if (_tweenState != TweenState::Always)
    {
        _tweenState = TweenState::None;
    }

    result.rotation = current.rotation + delta.rotation * _tweenProgress;
    result.skew     = current.skew + delta.skew * _tweenProgress;
}

void BoneRotateTimelineState::fadeOut()
{
    auto& result    = bonePose->result;
    result.rotation = Transform::normalizeRadian(result.rotation);
    result.skew     = Transform::normalizeRadian(result.skew);
}

void BoneScaleTimelineState::_onArriveAtFrame()
{
    BoneTimelineState::_onArriveAtFrame();

    if (_timelineData != nullptr)
    {
        auto valueOffset           = _animationData->frameFloatOffset + _frameValueOffset + _frameIndex * 2;
        const auto frameFloatArray = _frameFloatArray;
        auto& current              = bonePose->current;
        auto& delta                = bonePose->delta;

        current.scaleX = frameFloatArray[valueOffset++];
        current.scaleY = frameFloatArray[valueOffset++];

        if (_tweenState == TweenState::Always)
        {
            if ((unsigned)_frameIndex == _frameCount - 1)
            {
                valueOffset = _animationData->frameFloatOffset + _frameValueOffset;  // + 0 * 2
            }

            delta.scaleX = frameFloatArray[valueOffset++] - current.scaleX;
            delta.scaleY = frameFloatArray[valueOffset++] - current.scaleY;
        }
        else
        {
            delta.scaleX = 0.0f;
            delta.scaleY = 0.0f;
        }
    }
    else
    {
        auto& current  = bonePose->current;
        auto& delta    = bonePose->delta;
        current.scaleX = 1.0f;
        current.scaleY = 1.0f;
        delta.scaleX   = 0.0f;
        delta.scaleY   = 0.0f;
    }
}

void BoneScaleTimelineState::_onUpdateFrame()
{
    BoneTimelineState::_onUpdateFrame();

    auto& current = bonePose->current;
    auto& delta   = bonePose->delta;
    auto& result  = bonePose->result;

    bone->_transformDirty = true;
    if (_tweenState != TweenState::Always)
    {
        _tweenState = TweenState::None;
    }

    result.scaleX = current.scaleX + delta.scaleX * _tweenProgress;
    result.scaleY = current.scaleY + delta.scaleY * _tweenProgress;
}

void SlotDislayTimelineState::_onArriveAtFrame()
{
    if (playState >= 0)
    {
        const auto displayIndex =
            _timelineData != nullptr ? _frameArray[_frameOffset + 1] : slot->_slotData->displayIndex;
        if (slot->getDisplayIndex() != displayIndex)
        {
            slot->_setDisplayIndex(displayIndex, true);
        }
    }
}

void SlotColorTimelineState::_onClear()
{
    SlotTimelineState::_onClear();

    _dirty = false;
}

void SlotColorTimelineState::_onArriveAtFrame()
{
    SlotTimelineState::_onArriveAtFrame();

    if (_timelineData != nullptr)
    {
        const auto intArray      = _dragonBonesData->intArray;
        const auto frameIntArray = _frameIntArray;
        const auto valueOffset =
            _animationData->frameIntOffset + _frameValueOffset +
            _frameIndex * 1;  // ...(timeline value offset)|x|x|(Value offset)|(Next offset)|x|x|...
        int colorOffset = frameIntArray[valueOffset];

        if (colorOffset < 0)
        {
            colorOffset += 65536;  // Fixed out of bouds bug.
        }

        _current[0] = intArray[colorOffset++];
        _current[1] = intArray[colorOffset++];
        _current[2] = intArray[colorOffset++];
        _current[3] = intArray[colorOffset++];
        _current[4] = intArray[colorOffset++];
        _current[5] = intArray[colorOffset++];
        _current[6] = intArray[colorOffset++];
        _current[7] = intArray[colorOffset++];

        if (_tweenState == TweenState::Always)
        {
            if ((unsigned)_frameIndex == _frameCount - 1)
            {
                colorOffset = frameIntArray[_animationData->frameIntOffset + _frameValueOffset];
            }
            else
            {
                colorOffset = frameIntArray[valueOffset + 1 * 1];
            }

            if (colorOffset < 0)
            {
                colorOffset += 65536;  // Fixed out of bouds bug.
            }

            _delta[0] = intArray[colorOffset++] - _current[0];
            _delta[1] = intArray[colorOffset++] - _current[1];
            _delta[2] = intArray[colorOffset++] - _current[2];
            _delta[3] = intArray[colorOffset++] - _current[3];
            _delta[4] = intArray[colorOffset++] - _current[4];
            _delta[5] = intArray[colorOffset++] - _current[5];
            _delta[6] = intArray[colorOffset++] - _current[6];
            _delta[7] = intArray[colorOffset++] - _current[7];
        }
    }
    else
    {
        const auto color = slot->_slotData->color;

        _current[0] = color->alphaMultiplier * 100.0f;
        _current[1] = color->redMultiplier * 100.0f;
        _current[2] = color->greenMultiplier * 100.0f;
        _current[3] = color->blueMultiplier * 100.0f;
        _current[4] = color->alphaOffset;
        _current[5] = color->redOffset;
        _current[6] = color->greenOffset;
        _current[7] = color->blueOffset;
    }
}

void SlotColorTimelineState::_onUpdateFrame()
{
    SlotTimelineState::_onUpdateFrame();

    _dirty = true;
    if (_tweenState != TweenState::Always)
    {
        _tweenState = TweenState::None;
    }

    _result[0] = (_current[0] + _delta[0] * _tweenProgress) * 0.01f;
    _result[1] = (_current[1] + _delta[1] * _tweenProgress) * 0.01f;
    _result[2] = (_current[2] + _delta[2] * _tweenProgress) * 0.01f;
    _result[3] = (_current[3] + _delta[3] * _tweenProgress) * 0.01f;
    _result[4] = _current[4] + _delta[4] * _tweenProgress;
    _result[5] = _current[5] + _delta[5] * _tweenProgress;
    _result[6] = _current[6] + _delta[6] * _tweenProgress;
    _result[7] = _current[7] + _delta[7] * _tweenProgress;
}

void SlotColorTimelineState::fadeOut()
{
    _tweenState = TweenState::None;
    _dirty      = false;
}

void SlotColorTimelineState::update(float passedTime)
{
    SlotTimelineState::update(passedTime);

    // Fade animation.
    if (_tweenState != TweenState::None || _dirty)
    {
        auto& result = slot->_colorTransform;

        if (_animationState->_fadeState != 0 || _animationState->_subFadeState != 0)
        {
            if (result.alphaMultiplier != _result[0] || result.redMultiplier != _result[1] ||
                result.greenMultiplier != _result[2] || result.blueMultiplier != _result[3] ||
                result.alphaOffset != _result[4] || result.redOffset != _result[5] ||
                result.greenOffset != _result[6] || result.blueOffset != _result[7])
            {
                const auto fadeProgress = pow(_animationState->_fadeProgress, 2);

                result.alphaMultiplier += (_result[0] - result.alphaMultiplier) * fadeProgress;
                result.redMultiplier += (_result[1] - result.redMultiplier) * fadeProgress;
                result.greenMultiplier += (_result[2] - result.greenMultiplier) * fadeProgress;
                result.blueMultiplier += (_result[3] - result.blueMultiplier) * fadeProgress;
                result.alphaOffset += (_result[4] - result.alphaOffset) * fadeProgress;
                result.redOffset += (_result[5] - result.redOffset) * fadeProgress;
                result.greenOffset += (_result[6] - result.greenOffset) * fadeProgress;
                result.blueOffset += (_result[7] - result.blueOffset) * fadeProgress;

                slot->_colorDirty = true;
            }
        }
        else if (_dirty)
        {
            _dirty = false;
            if (result.alphaMultiplier != _result[0] || result.redMultiplier != _result[1] ||
                result.greenMultiplier != _result[2] || result.blueMultiplier != _result[3] ||
                result.alphaOffset != _result[4] || result.redOffset != _result[5] ||
                result.greenOffset != _result[6] || result.blueOffset != _result[7])
            {
                result.alphaMultiplier = _result[0];
                result.redMultiplier   = _result[1];
                result.greenMultiplier = _result[2];
                result.blueMultiplier  = _result[3];
                result.alphaOffset     = _result[4];
                result.redOffset       = _result[5];
                result.greenOffset     = _result[6];
                result.blueOffset      = _result[7];

                slot->_colorDirty = true;
            }
        }
    }
}

void DeformTimelineState::_onClear()
{
    SlotTimelineState::_onClear();

    vertexOffset = 0;

    _dirty            = false;
    _frameFloatOffset = 0;
    _deformCount      = 0;
    _valueCount       = 0;
    _valueOffset      = 0;
    _current.clear();
    _delta.clear();
    _result.clear();
}

void DeformTimelineState::_onArriveAtFrame()
{
    SlotTimelineState::_onArriveAtFrame();

    if (_timelineData != nullptr)
    {
        const auto valueOffset     = _animationData->frameFloatOffset + _frameValueOffset + _frameIndex * _valueCount;
        const auto scale           = _armature->_armatureData->scale;
        const auto frameFloatArray = _frameFloatArray;

        if (_tweenState == TweenState::Always)
        {
            auto nextValueOffset = valueOffset + _valueCount;
            if ((unsigned)_frameIndex == _frameCount - 1)
            {
                nextValueOffset = _animationData->frameFloatOffset + _frameValueOffset;
            }

            for (std::size_t i = 0; i < _valueCount; ++i)
            {
                _delta[i] = frameFloatArray[nextValueOffset + i] * scale -
                            (_current[i] = frameFloatArray[valueOffset + i] * scale);
            }
        }
        else
        {
            for (std::size_t i = 0; i < _valueCount; ++i)
            {
                _current[i] = frameFloatArray[valueOffset + i] * scale;
            }
        }
    }
    else
    {
        for (std::size_t i = 0; i < _valueCount; ++i)
        {
            _current[i] = 0.0f;
        }
    }
}

void DeformTimelineState::_onUpdateFrame()
{
    SlotTimelineState::_onUpdateFrame();

    _dirty = true;
    if (_tweenState != TweenState::Always)
    {
        _tweenState = TweenState::None;
    }

    for (std::size_t i = 0; i < _valueCount; ++i)
    {
        _result[i] = _current[i] + _delta[i] * _tweenProgress;
    }
}

void DeformTimelineState::init(Armature* armature, AnimationState* animationState, TimelineData* timelineData)
{
    SlotTimelineState::init(armature, animationState, timelineData);

    if (_timelineData != nullptr)
    {
        const auto frameIntOffset =
            _animationData->frameIntOffset +
            _timelineArray[_timelineData->offset + (unsigned)BinaryOffset::TimelineFrameValueCount];
        vertexOffset = _frameIntArray[frameIntOffset + (unsigned)BinaryOffset::DeformVertexOffset];

        _deformCount      = _frameIntArray[frameIntOffset + (unsigned)BinaryOffset::DeformCount];
        _valueCount       = _frameIntArray[frameIntOffset + (unsigned)BinaryOffset::DeformValueCount];
        _valueOffset      = _frameIntArray[frameIntOffset + (unsigned)BinaryOffset::DeformValueOffset];
        _frameFloatOffset = _frameIntArray[frameIntOffset + (unsigned)BinaryOffset::DeformFloatOffset] +
                            _animationData->frameFloatOffset;
    }
    else
    {
        const auto deformVertices = slot->_deformVertices;
        _deformCount              = deformVertices != nullptr ? deformVertices->vertices.size() : 0;
        _valueCount               = _deformCount;
        _valueOffset              = 0;
        _frameFloatOffset         = 0;
    }

    _current.resize(_valueCount);
    _delta.resize(_valueCount, 0.0f);
    _result.resize(_valueCount);
}

void DeformTimelineState::fadeOut()
{
    _tweenState = TweenState::None;
    _dirty      = false;
}

void DeformTimelineState::update(float passedTime)
{
    const auto deformVertices = slot->_deformVertices;
    if (deformVertices == nullptr || deformVertices->verticesData == nullptr ||
        deformVertices->verticesData->offset != vertexOffset)
    {
        return;
    }
    else if (_timelineData != nullptr && _dragonBonesData != deformVertices->verticesData->data)
    {
        return;
    }

    SlotTimelineState::update(passedTime);

    // Fade animation.
    if (_tweenState != TweenState::None || _dirty)
    {
        auto& result = deformVertices->vertices;

        if (_animationState->_fadeState != 0 || _animationState->_subFadeState != 0)
        {
            const auto fadeProgress = pow(_animationState->_fadeProgress, 2);

            if (_timelineData != nullptr)
            {
                for (std::size_t i = 0; i < _deformCount; ++i)
                {
                    if (i < _valueOffset)
                    {
                        result[i] += (_frameFloatArray[_frameFloatOffset + i] - result[i]) * fadeProgress;
                    }
                    else if (i < _valueOffset + _valueCount)
                    {
                        result[i] += (_result[i - _valueOffset] - result[i]) * fadeProgress;
                    }
                    else
                    {
                        result[i] += (_frameFloatArray[_frameFloatOffset + i - _valueCount] - result[i]) * fadeProgress;
                    }
                }
            }
            else
            {
                _deformCount = result.size();

                for (std::size_t i = 0; i < _deformCount; ++i)
                {
                    result[i] += (0.0f - result[i]) * fadeProgress;
                }
            }

            deformVertices->verticesDirty = true;
        }
        else if (_dirty)
        {
            _dirty = false;

            if (_timelineData != nullptr)
            {
                for (std::size_t i = 0; i < _deformCount; ++i)
                {
                    if (i < _valueOffset)
                    {
                        result[i] = _frameFloatArray[_frameFloatOffset + i];
                    }
                    else if (i < _valueOffset + _valueCount)
                    {
                        result[i] = _result[i - _valueOffset];
                    }
                    else
                    {
                        result[i] = _frameFloatArray[_frameFloatOffset + i - _valueCount];
                    }
                }
            }
            else
            {
                _deformCount = result.size();

                for (std::size_t i = 0; i < _deformCount; ++i)
                {
                    result[i] = 0.0f;
                }
            }

            deformVertices->verticesDirty = true;
        }
    }
}

void IKConstraintTimelineState::_onClear()
{
    ConstraintTimelineState::_onClear();

    _current = 0.0f;
    _delta   = 0.0f;
}

void IKConstraintTimelineState::_onArriveAtFrame()
{
    ConstraintTimelineState::_onArriveAtFrame();

    const auto ikConstraint = static_cast<IKConstraint*>(constraint);

    if (_timelineData != nullptr)
    {
        auto valueOffset         = _animationData->frameIntOffset + _frameValueOffset + _frameIndex * 2;
        const auto frameIntArray = _frameIntArray;
        const auto bendPositive  = frameIntArray[valueOffset++] != 0;
        _current                 = frameIntArray[valueOffset++] * 0.01f;

        if (_tweenState == TweenState::Always)
        {
            if ((unsigned)_frameIndex == _frameCount - 1)
            {
                valueOffset = _animationData->frameIntOffset + _frameValueOffset;  // + 0 * 2
            }

            _delta = frameIntArray[valueOffset + 1] * 0.01f - _current;
        }
        else
        {
            _delta = 0.0f;
        }

        ikConstraint->_bendPositive = bendPositive;
    }
    else
    {
        const auto ikConstraintData = static_cast<IKConstraintData*>(ikConstraint->_constraintData);
        _current                    = ikConstraintData->weight;
        _delta                      = 0.0f;
        ikConstraint->_bendPositive = ikConstraintData->bendPositive;
    }

    ikConstraint->invalidUpdate();
}

void IKConstraintTimelineState::_onUpdateFrame()
{
    ConstraintTimelineState::_onUpdateFrame();

    if (_tweenState != TweenState::Always)
    {
        _tweenState = TweenState::None;
    }

    const auto ikConstraint = static_cast<IKConstraint*>(constraint);
    ikConstraint->_weight   = _current + _delta * _tweenProgress;
    ikConstraint->invalidUpdate();
}

DRAGONBONES_NAMESPACE_END