#include "JSONDataParser.h"

DRAGONBONES_NAMESPACE_BEGIN

void JSONDataParser::_getCurvePoint(
    float x1, float y1, float x2, float y2, float x3, float y3, float x4, float y4,
    float t,
    Point& result
)
{
    const auto l_t = 1.0f - t;
    const auto powA = l_t * l_t;
    const auto powB = t * t;
    const auto kA = l_t * powA;
    const auto kB = 3.0f * t * powA;
    const auto kC = 3.0f * l_t * powB;
    const auto kD = t * powB;

    result.x = kA * x1 + kB * x2 + kC * x3 + kD * x4;
    result.y = kA * y1 + kB * y2 + kC * y3 + kD * y4;
}

void JSONDataParser::_samplingEasingCurve(const rapidjson::Value& curve, std::vector<float>& samples)
{
    int curveCount = curve.Size();
    int stepIndex = -2;
    for (std::size_t i = 0, l = samples.size(); i < l; ++i) 
    {
        float t = (float)(i + 1) / (l + 1); // float
        while ((stepIndex + 6 < curveCount ? curve[stepIndex + 6].GetDouble() : 1) < t) // stepIndex + 3 * 2
        {
            stepIndex += 6;
        }

        const auto isInCurve = stepIndex >= 0 && stepIndex + 6 < curveCount;
        const auto x1 = isInCurve ? curve[stepIndex].GetDouble() : 0.0f;
        const auto y1 = isInCurve ? curve[stepIndex + 1].GetDouble() : 0.0f;
        const auto x2 = curve[stepIndex + 2].GetDouble();
        const auto y2 = curve[stepIndex + 3].GetDouble();
        const auto x3 = curve[stepIndex + 4].GetDouble();
        const auto y3 = curve[stepIndex + 5].GetDouble();
        const auto x4 = isInCurve ? curve[stepIndex + 6].GetDouble() : 1.0f;
        const auto y4 = isInCurve ? curve[stepIndex + 7].GetDouble() : 1.0f;

        float lower = 0.0f;
        float higher = 1.0f;
        while (higher - lower > 0.0001f) 
        {
            const auto percentage = (higher + lower) * 0.5f;
            _getCurvePoint(x1, y1, x2, y2, x3, y3, x4, y4, percentage, _helpPoint);
            if (t - _helpPoint.x > 0.0f) 
            {
                lower = percentage;
            }
            else {
                higher = percentage;
            }
        }

        samples[i] = _helpPoint.y;
    }
}

void JSONDataParser::_parseActionDataInFrame(const rapidjson::Value& rawData, unsigned frameStart, BoneData* bone, SlotData* slot)
{
    if (rawData.HasMember(EVENT))
    {
        _mergeActionFrame(rawData[EVENT], frameStart, ActionType::Frame, bone, slot);
    }

    if (rawData.HasMember(SOUND))
    {
        _mergeActionFrame(rawData[SOUND], frameStart, ActionType::Sound, bone, slot);
    }

    if (rawData.HasMember(ACTION))
    {
        _mergeActionFrame(rawData[ACTION], frameStart, ActionType::Play, bone, slot);
    }
    
    if (rawData.HasMember(EVENTS))
    {
        _mergeActionFrame(rawData[EVENTS], frameStart, ActionType::Frame, bone, slot);
    }

    if (rawData.HasMember(ACTIONS))
    {
        _mergeActionFrame(rawData[ACTIONS], frameStart, ActionType::Play, bone, slot);
    }
}

void JSONDataParser::_mergeActionFrame(const rapidjson::Value& rawData, unsigned frameStart, ActionType type, BoneData* bone, SlotData* slot)
{
    const auto actionOffset = _armature->actions.size();
    const auto& actions = _parseActionData(rawData, type, bone, slot);
    ActionFrame* frame = nullptr;

    for (const auto action : actions) 
    {
        _armature->addAction(action, false);
    }

    if (_actionFrames.empty()) // First frame.
    {
        _actionFrames.resize(1);
        _actionFrames[0].frameStart = 0;
    }

    for (auto& eachFrame : _actionFrames) // Get same frame.
    {
        if (eachFrame.frameStart == frameStart) 
        {
            frame = &eachFrame;
            break;
        }
    }

    if (frame == nullptr) // Create and cache frame.
    {
        const auto frameCount = _actionFrames.size();
        _actionFrames.resize(frameCount + 1);
        frame = &_actionFrames[frameCount];
        frame->frameStart = frameStart;
    }

    for (std::size_t i = 0; i < actions.size(); ++i) // Cache action offsets.
    {
        frame->actions.push_back(actionOffset + i);
    }
}

unsigned JSONDataParser::_parseCacheActionFrame(ActionFrame& frame)
{
    const auto frameOffset = _frameArray.size();
    const auto actionCount = frame.actions.size();
    _frameArray.resize(_frameArray.size() + 1 + 1 + actionCount);
    _frameArray[frameOffset + (unsigned)BinaryOffset::FramePosition] = frame.frameStart;
    _frameArray[frameOffset + (unsigned)BinaryOffset::FramePosition + 1] = actionCount; // Action count.

    for (std::size_t i = 0; i < actionCount; ++i) // Action offsets.
    {
        _frameArray[frameOffset + (unsigned)BinaryOffset::FramePosition + 2 + i] = frame.actions[i];
    }

    return frameOffset;
}

ArmatureData* JSONDataParser::_parseArmature(const rapidjson::Value& rawData, float scale)
{
    const auto armature = BaseObject::borrowObject<ArmatureData>();
    armature->name = _getString(rawData, NAME, "");
    armature->frameRate = _getNumber(rawData, FRAME_RATE, _data->frameRate);
    armature->scale = scale;

    if (rawData.HasMember(TYPE) && rawData[TYPE].IsString())
    {
        armature->type = _getArmatureType(rawData[TYPE].GetString());
    }
    else
    {
        armature->type = (ArmatureType)_getNumber(rawData, TYPE, (int)ArmatureType::Armature);
    }

    if (armature->frameRate == 0) // Data error.
    {
        armature->frameRate = 24;
    }

    _armature = armature;

    if (rawData.HasMember(CANVAS))
    {
        const auto& rawCanvas = rawData[CANVAS];
        const auto canvas = BaseObject::borrowObject<CanvasData>();
        canvas->hasBackground = rawCanvas.HasMember(COLOR);
        canvas->color = _getNumber(rawCanvas, COLOR, 0);
        canvas->aabb.x = _getNumber(rawCanvas, X, 0.0f) * armature->scale;
        canvas->aabb.y = _getNumber(rawCanvas, Y, 0.0f) * armature->scale;
        canvas->aabb.width = _getNumber(rawCanvas, WIDTH, 0.0f) * armature->scale;
        canvas->aabb.height = _getNumber(rawCanvas, HEIGHT, 0.0f) * armature->scale;
        //
        armature->canvas = canvas;
    }

    if (rawData.HasMember(AABB))
    {
        const auto& rawAABB = rawData[AABB];
        armature->aabb.x = _getNumber(rawAABB, X, 0.0f) * armature->scale;
        armature->aabb.y = _getNumber(rawAABB, Y, 0.0f) * armature->scale;
        armature->aabb.width = _getNumber(rawAABB, WIDTH, 0.0f) * armature->scale;
        armature->aabb.height = _getNumber(rawAABB, HEIGHT, 0.0f) * armature->scale;
    }

    if (rawData.HasMember(BONE))
    {
        const auto& rawBones = rawData[BONE];
        for (std::size_t i = 0, l = rawBones.Size(); i < l; ++i)
        {
            const auto& rawBone = rawBones[i];
            const auto& parentName = _getString(rawBone, PARENT, "");
            const auto bone = _parseBone(rawBone);

            if (!parentName.empty()) // Get bone parent.
            {
                const auto parent = armature->getBone(parentName);
                if (parent != nullptr) 
                {
                    bone->parent = parent;
                }
                else // Cache.
                {
                    auto& cacheBones = _cacheBones[parentName];
                    cacheBones.push_back(bone);
                }
            }
            
            auto iterator = _cacheBones.find(bone->name);
            if (iterator != _cacheBones.end())
            {
                for (const auto child : _cacheBones[bone->name]) 
                {
                    child->parent = bone;
                }

                _cacheBones.erase(iterator);
            }

            armature->addBone(bone);
            _rawBones.push_back(bone); // Cache raw bones sort.
        }
    }

    if (rawData.HasMember(IK))
    {
        const auto& rawIKS = rawData[IK];
        for (std::size_t i = 0, l = rawIKS.Size(); i < l; ++i)
        {
            const auto constraint = _parseIKConstraint(rawIKS[i]);
            if (constraint)
            {
                armature->addConstraint(constraint);
            }
        }
    }

    armature->sortBones();

    if (rawData.HasMember(SLOT))
    {
        int zOrder = 0;
        const auto& rawSlots = rawData[SLOT];
        for (std::size_t i = 0, l = rawSlots.Size(); i < l; ++i)
        {
            armature->addSlot(_parseSlot(rawSlots[i], zOrder++));
        }
    }

    if (rawData.HasMember(SKIN))
    {
        const auto& rawSkins = rawData[SKIN];
        for (std::size_t i = 0, l = rawSkins.Size(); i < l; ++i)
        {
            armature->addSkin(_parseSkin(rawSkins[i]));
        }
    }

    for (std::size_t i = 0, l = _cacheRawMeshes.size(); i < l; ++i) // Link mesh.
    { 
        const auto rawMeshData = _cacheRawMeshes[i];
        const auto& shareName = _getString(*rawMeshData, SHARE, "");
        if (shareName.empty()) {
            continue;
        }

        auto skinName = _getString(*rawMeshData, SKIN, DEFAULT_NAME);
        if (skinName.empty()) //
        {
            skinName = DEFAULT_NAME;
        }

        const auto shareMesh = armature->getMesh(skinName, "", shareName); // TODO slot;
        if (shareMesh == nullptr) {
            continue; // Error.
        }

        const auto mesh = _cacheMeshes[i];
        mesh->vertices.shareFrom(shareMesh->vertices);
    }

    if (rawData.HasMember(ANIMATION))
    {
        const auto& rawAnimations = rawData[ANIMATION];
        for (std::size_t i = 0, l = rawAnimations.Size(); i < l; ++i)
        {
            armature->addAnimation(_parseAnimation(rawAnimations[i]));
        }
    }

    if (rawData.HasMember(DEFAULT_ACTIONS))
    {
        const auto& actions = _parseActionData(rawData[DEFAULT_ACTIONS], ActionType::Play, nullptr, nullptr);
        for (const auto action : actions) 
        {
            armature->addAction(action, true);

            if (action->type == ActionType::Play) // Set default animation from default action.
            { 
                const auto animation = armature->getAnimation(action->name);
                if (animation != nullptr)
                {
                    armature->defaultAnimation = animation;
                }
            }
        }
    }

    if (rawData.HasMember(ACTIONS))
    {
        const auto& actions = _parseActionData(rawData[ACTIONS], ActionType::Play, nullptr, nullptr);

        for (const auto action : actions)
        {
            armature->addAction(action, false);
        }
    }

    // Clear helper.
    _rawBones.clear();
    _cacheRawMeshes.clear();
    _cacheMeshes.clear();
    _armature = nullptr;

    _weightSlotPose.clear();
    _weightBonePoses.clear();
    _cacheBones.clear();
    _slotChildActions.clear();

    return armature;
}

BoneData* JSONDataParser::_parseBone(const rapidjson::Value& rawData)
{
    const auto bone = BaseObject::borrowObject<BoneData>();
    bone->inheritTranslation = _getBoolean(rawData, INHERIT_TRANSLATION, true);
    bone->inheritRotation = _getBoolean(rawData, INHERIT_ROTATION, true);
    bone->inheritScale = _getBoolean(rawData, INHERIT_SCALE, true);
    bone->inheritReflection = _getBoolean(rawData, INHERIT_REFLECTION, true);
    bone->length = _getNumber(rawData, LENGTH, 0.0f) * _armature->scale;
    bone->name = _getString(rawData, NAME, "");

    if (rawData.HasMember(TRANSFORM))
    {
        _parseTransform(rawData[TRANSFORM], bone->transform, _armature->scale);
    }

    return bone;
}

ConstraintData* JSONDataParser::_parseIKConstraint(const rapidjson::Value& rawData)
{
    const auto bone = _armature->getBone(_getString(rawData, BONE, ""));
    if (bone == nullptr)
    {
        return nullptr;
    }

    const auto target = _armature->getBone(_getString(rawData, TARGET, ""));
    if (target == nullptr)
    {
        return nullptr;
    }

    const auto constraint = BaseObject::borrowObject<IKConstraintData>();
    constraint->scaleEnabled = _getBoolean(rawData, SCALE, false);
    constraint->bendPositive = _getBoolean(rawData, BEND_POSITIVE, true);
    constraint->weight = _getNumber(rawData, WEIGHT, 1.0f);
    constraint->name = _getString(rawData, NAME, "");
    constraint->bone = bone;
    constraint->target = target;

    const auto chain = _getNumber(rawData, CHAIN, (unsigned)0);
    if (chain > 0 && bone->parent != nullptr) 
    {
        constraint->root = bone->parent;
        constraint->bone = bone;
    }
    else 
    {
        constraint->root = bone;
        constraint->bone = nullptr;
    }

    return constraint;
}

SlotData* JSONDataParser::_parseSlot(const rapidjson::Value& rawData, int zOrder)
{
    const auto slot = BaseObject::borrowObject<SlotData>();
    slot->displayIndex = _getNumber(rawData, DISPLAY_INDEX, (int)0);
    slot->zOrder = zOrder;
    slot->name = _getString(rawData, NAME, "");
    slot->parent = _armature->getBone(_getString(rawData, PARENT, ""));

    if (rawData.HasMember(BLEND_MODE) && rawData[BLEND_MODE].IsString())
    {
        slot->blendMode = _getBlendMode(rawData[BLEND_MODE].GetString());
    }
    else
    {
        slot->blendMode = (BlendMode)_getNumber(rawData, BLEND_MODE, (int)BlendMode::Normal);
    }

    if (rawData.HasMember(COLOR))
    {
        slot->color = SlotData::createColor();
        _parseColorTransform(rawData[COLOR], *slot->color);
    }
    else
    {
        slot->color = &SlotData::DEFAULT_COLOR;
    }

    if (rawData.HasMember(ACTIONS))
    {
        _slotChildActions[slot->name] = _parseActionData(rawData[ACTIONS], ActionType::Play, nullptr, nullptr);
    }

    return slot;
}

SkinData * JSONDataParser::_parseSkin(const rapidjson::Value& rawData)
{
    const auto skin = BaseObject::borrowObject<SkinData>();
    skin->name = _getString(rawData, NAME, DEFAULT_NAME);
    if (skin->name.empty())
    {
        skin->name = DEFAULT_NAME;
    }

    if (rawData.HasMember(SLOT))
    {
        const auto& rawSlots = rawData[SLOT];
        _skin = skin;

        for (std::size_t i = 0, l = rawSlots.Size(); i < l; ++i)
        {
            const auto& rawSlot = rawSlots[i];
            const auto& slotName = _getString(rawSlot, NAME, "");
            const auto slot = _armature->getSlot(slotName);
            if (slot != nullptr) 
            {
                _slot = slot;

                if (rawSlot.HasMember(DISPLAY)) 
                {
                    const auto& rawDisplays = rawSlot[DISPLAY];
                    for (std::size_t j = 0, lJ = rawDisplays.Size(); j < lJ; ++j)
                    {
                        const auto& rawDisplay = rawDisplays[j];
                        if (!rawDisplay.IsNull()) 
                        {
                            skin->addDisplay(slotName, _parseDisplay(rawDisplay));
                        }
                        else 
                        {
                            skin->addDisplay(slotName, nullptr);
                        }
                    }
                }

                _slot = nullptr;
            }
        }

        _skin = nullptr;
    }

    return skin;
}

DisplayData* JSONDataParser::_parseDisplay(const rapidjson::Value& rawData)
{
    const auto& name = _getString(rawData, NAME, "");
    const auto& path = _getString(rawData, PATH, "");
    auto type = DisplayType::Image;
    DisplayData* display = nullptr;

    if (rawData.HasMember(TYPE) && rawData[TYPE].IsString())
    {
        type = _getDisplayType(rawData[TYPE].GetString());
    }
    else
    {
        type = (DisplayType)_getNumber(rawData, TYPE, (int)DisplayType::Image);
    }

    switch (type)
    {
        case dragonBones::DisplayType::Image:
        {
            const auto imageDisplay = BaseObject::borrowObject<ImageDisplayData>();
            imageDisplay->name = name;
            imageDisplay->path = !path.empty() ? path : name;
            _parsePivot(rawData, *imageDisplay);

            display = imageDisplay;
            break;
        }

        case dragonBones::DisplayType::Armature:
        {
            const auto armatureDisplay = BaseObject::borrowObject<ArmatureDisplayData>();
            armatureDisplay->name = name;
            armatureDisplay->path = !path.empty() ? path : name;
            armatureDisplay->inheritAnimation = true;

            if (rawData.HasMember(ACTIONS))
            {
                const auto& actions = _parseActionData(rawData[ACTIONS], ActionType::Play, nullptr, nullptr);

                for (const auto action : actions) 
                {
                    armatureDisplay->addAction(action);
                }
            }
            else if (_slotChildActions.find(_slot->name) != _slotChildActions.cend())
            {
                const auto displays = _skin->getDisplays(_slot->name);
                if (displays == nullptr ? _slot->displayIndex == 0 : (std::size_t)_slot->displayIndex == displays->size())
                {
                    for (const auto action : _slotChildActions[_slot->name])
                    {
                        armatureDisplay->addAction(action);
                    }

                    _slotChildActions.erase(_slotChildActions.find(_slot->name));
                }
            }

            display = armatureDisplay;
            break;
        }

        case dragonBones::DisplayType::Mesh:
        {
            const auto meshDisplay = BaseObject::borrowObject<MeshDisplayData>();
            meshDisplay->vertices.inheritDeform = _getBoolean(rawData, INHERIT_DEFORM, true);
            meshDisplay->name = name;
            meshDisplay->path = !path.empty() ? path : name;
            meshDisplay->vertices.data = _data;

            if (rawData.HasMember(SHARE))
            {
                _cacheRawMeshes.push_back(&rawData);
                _cacheMeshes.push_back(meshDisplay);
            }
            else
            {
                _parseMesh(rawData, *meshDisplay);
            }

            display = meshDisplay;
            break;
        }

        case dragonBones::DisplayType::BoundingBox:
        {
            const auto boundingBox = _parseBoundingBox(rawData);
            if (boundingBox != nullptr)
            {
                const auto boundingBoxDisplay = BaseObject::borrowObject<BoundingBoxDisplayData>();
                boundingBoxDisplay->name = name;
                boundingBoxDisplay->path = !path.empty() ? path : name;
                boundingBoxDisplay->boundingBox = boundingBox;

                display = boundingBoxDisplay;
            }
            break;
        }
    }

    if (display != nullptr && rawData.HasMember(TRANSFORM))
    {
        _parseTransform(rawData[TRANSFORM], display->transform, _armature->scale);
    }

    return display;
}

void JSONDataParser::_parsePivot(const rapidjson::Value& rawData, ImageDisplayData& display)
{
    if (rawData.HasMember(PIVOT))
    {
        const auto& rawPivot = rawData[PIVOT];
        display.pivot.x = _getNumber(rawPivot, X, 0.0f);
        display.pivot.y = _getNumber(rawPivot, Y, 0.0f);
    }
    else 
    {
        display.pivot.x = 0.5f;
        display.pivot.y = 0.5f;
    }
}

void JSONDataParser::_parseMesh(const rapidjson::Value& rawData, MeshDisplayData& mesh)
{
    const auto& rawVertices = rawData[VERTICES];
    const auto& rawUVs = rawData[UVS];
    const auto& rawTriangles = rawData[TRIANGLES];
    const auto vertexCount = rawVertices.Size() / 2;
    const auto triangleCount = rawTriangles.Size() / 3;
    const auto vertexOffset = _floatArray.size();
    const auto uvOffset = vertexOffset + vertexCount * 2;
    const auto meshOffset = _intArray.size();
    const auto meshName = _skin->name + "_" + _slot->name + "_" + mesh.name;  // Cache pose data.

    mesh.vertices.offset = meshOffset;
    _intArray.resize(_intArray.size() + 1 + 1 + 1 + 1 + triangleCount * 3);
    _intArray[meshOffset + (unsigned)BinaryOffset::MeshVertexCount] = vertexCount;
    _intArray[meshOffset + (unsigned)BinaryOffset::MeshTriangleCount] = triangleCount;
    _intArray[meshOffset + (unsigned)BinaryOffset::MeshFloatOffset] = vertexOffset;
    for (std::size_t i = 0, l = triangleCount * 3; i < l; ++i) 
    {
        _intArray[meshOffset + (unsigned)BinaryOffset::MeshVertexIndices + i] = rawTriangles[i].GetUint();
    }

    _floatArray.resize(_floatArray.size() + vertexCount * 2 + vertexCount * 2);
    for (std::size_t i = 0, l = vertexCount * 2; i < l; ++i) 
    {
        _floatArray[vertexOffset + i] = rawVertices[i].GetDouble();
        _floatArray[uvOffset + i] = rawUVs[i].GetDouble();
    }

    if (rawData.HasMember(WEIGHTS)) 
    {
        const auto& rawWeights = rawData[WEIGHTS];
        const auto& rawSlotPose = rawData[SLOT_POSE];
        const auto& rawBonePoses = rawData[BONE_POSE];
        const auto& sortedBones = _armature->sortedBones;
        std::vector<unsigned> weightBoneIndices;
        const unsigned weightBoneCount = rawBonePoses.Size() / 7;
        const auto floatOffset = _floatArray.size();
        const auto weightCount = (rawWeights.Size() - vertexCount) / 2; // uint
        const auto weightOffset = _intArray.size();
        const auto weight = BaseObject::borrowObject<WeightData>();

        weight->count = weightCount;
        weight->offset = weightOffset;
        weightBoneIndices.resize(weightBoneCount);
        _intArray.resize(_intArray.size() + 1 + 1 + weightBoneCount + vertexCount + weightCount);
        _intArray[weightOffset + (unsigned)BinaryOffset::WeigthFloatOffset] = floatOffset;

        for (std::size_t i = 0; i < weightBoneCount; ++i) 
        {
            const auto rawBoneIndex = rawBonePoses[i * 7].GetUint();
            const auto bone = _rawBones[rawBoneIndex];
            weight->addBone(bone);
            weightBoneIndices[i] = rawBoneIndex;
            _intArray[weightOffset + (unsigned)BinaryOffset::WeigthBoneIndices + i] = indexOf(sortedBones, bone);
        }

        _floatArray.resize(_floatArray.size() + weightCount * 3);

        _helpMatrixA.a = rawSlotPose[0].GetDouble();
        _helpMatrixA.b = rawSlotPose[1].GetDouble();
        _helpMatrixA.c = rawSlotPose[2].GetDouble();
        _helpMatrixA.d = rawSlotPose[3].GetDouble();
        _helpMatrixA.tx = rawSlotPose[4].GetDouble();
        _helpMatrixA.ty = rawSlotPose[5].GetDouble();

        for (
            std::size_t i = 0, iW = 0, iB = weightOffset + (unsigned)BinaryOffset::WeigthBoneIndices + weightBoneCount, iV = floatOffset;
            i < vertexCount;
            ++i
        ) 
        {
            const auto iD = i * 2;
            const auto vertexBoneCount = rawWeights[iW++].GetUint();
            _intArray[iB++] = vertexBoneCount;

            auto x = _floatArray[vertexOffset + iD];
            auto y = _floatArray[vertexOffset + iD + 1];
            _helpMatrixA.transformPoint(x, y, _helpPoint);

            x = _helpPoint.x;
            y = _helpPoint.y;

            for (std::size_t j = 0; j < vertexBoneCount; ++j)
            {
                const auto rawBoneIndex = rawWeights[iW++].GetUint();
                const auto boneIndex = indexOf(weightBoneIndices, rawBoneIndex);
                const auto matrixOffset = boneIndex * 7 + 1;

                _helpMatrixB.a = rawBonePoses[matrixOffset + 0].GetDouble();
                _helpMatrixB.b = rawBonePoses[matrixOffset + 1].GetDouble();
                _helpMatrixB.c = rawBonePoses[matrixOffset + 2].GetDouble();
                _helpMatrixB.d = rawBonePoses[matrixOffset + 3].GetDouble();
                _helpMatrixB.tx = rawBonePoses[matrixOffset + 4].GetDouble();
                _helpMatrixB.ty = rawBonePoses[matrixOffset + 5].GetDouble();
                _helpMatrixB.invert();
                _helpMatrixB.transformPoint(x, y, _helpPoint);

                _intArray[iB++] = boneIndex;
                _floatArray[iV++] = rawWeights[iW++].GetDouble();
                _floatArray[iV++] = _helpPoint.x;
                _floatArray[iV++] = _helpPoint.y;
            }
        }

        mesh.vertices.weight = weight;
        _weightSlotPose[meshName] = &rawSlotPose;
        _weightBonePoses[meshName] = &rawBonePoses;
    }
}

BoundingBoxData* JSONDataParser::_parseBoundingBox(const rapidjson::Value& rawData)
{
    BoundingBoxData* boundingBox = nullptr;
    BoundingBoxType type = BoundingBoxType::Rectangle;
    if (rawData.HasMember(SUB_TYPE) && rawData[SUB_TYPE].IsString())
    {
        type = _getBoundingBoxType(rawData[SUB_TYPE].GetString());
    }
    else 
    {
        type = (BoundingBoxType)_getNumber(rawData, SUB_TYPE, (int)type);
    }

    switch (type) 
    {
        case BoundingBoxType::Rectangle:
            boundingBox = BaseObject::borrowObject<RectangleBoundingBoxData>();
            break;

        case BoundingBoxType::Ellipse:
            boundingBox = BaseObject::borrowObject<EllipseBoundingBoxData>();
            break;

        case BoundingBoxType::Polygon:
            boundingBox = _parsePolygonBoundingBox(rawData);
            break;
    }

    if (boundingBox != nullptr) 
    {
        boundingBox->color = _getNumber(rawData, COLOR, 0x000000);
        if (boundingBox->type == BoundingBoxType::Rectangle || boundingBox->type == BoundingBoxType::Ellipse)
        {
            boundingBox->width = _getNumber(rawData, WIDTH, 0.0f);
            boundingBox->height = _getNumber(rawData, HEIGHT, 0.0f);
        }
    }

    return boundingBox;
}

PolygonBoundingBoxData* JSONDataParser::_parsePolygonBoundingBox(const rapidjson::Value& rawData)
{
    const auto polygonBoundingBox = BaseObject::borrowObject<PolygonBoundingBoxData>();

    if (rawData.HasMember(VERTICES))
    {
        const auto& rawVertices = rawData[VERTICES];
        auto& vertices = polygonBoundingBox->vertices;

        polygonBoundingBox->vertices.resize(rawVertices.Size());

        for (std::size_t i = 0, l = rawVertices.Size(); i < l; i += 2)
        {
            const auto x = rawVertices[i].GetDouble();
            const auto y = rawVertices[i + 1].GetDouble();
            vertices[i] = x;
            vertices[i + 1] = y;

            // AABB.
            if (i == 0)
            {
                polygonBoundingBox->x = x;
                polygonBoundingBox->y = y;
                polygonBoundingBox->width = x;
                polygonBoundingBox->height = y;
            }
            else
            {
                if (x < polygonBoundingBox->x)
                {
                    polygonBoundingBox->x = x;
                }
                else if (x > polygonBoundingBox->width)
                {
                    polygonBoundingBox->width = x;
                }

                if (y < polygonBoundingBox->y)
                {
                    polygonBoundingBox->y = y;
                }
                else if (y > polygonBoundingBox->height)
                {
                    polygonBoundingBox->height = y;
                }
            }
        }

        polygonBoundingBox->width -= polygonBoundingBox->x;
        polygonBoundingBox->height -= polygonBoundingBox->y;
    }
    else 
    {
        DRAGONBONES_ASSERT(false, "Data error.\n Please reexport DragonBones Data to fixed the bug.");
    }

    return polygonBoundingBox;
}

AnimationData* JSONDataParser::_parseAnimation(const rapidjson::Value& rawData)
{
    const auto animation = BaseObject::borrowObject<AnimationData>();
    animation->frameCount = std::max(_getNumber(rawData, DURATION, (unsigned)1), (unsigned)1);
    animation->playTimes = _getNumber(rawData, PLAY_TIMES, (unsigned)1);
    animation->duration = (float)animation->frameCount / _armature->frameRate; // float
    animation->fadeInTime = _getNumber(rawData, FADE_IN_TIME, 0.0f);
    animation->scale = _getNumber(rawData, SCALE, 1.0f);
    animation->name = _getString(rawData, NAME, DEFAULT_NAME);

    if (animation->name.empty())
    {
        animation->name = DEFAULT_NAME;
    }

    animation->frameIntOffset = _frameIntArray.size();
    animation->frameFloatOffset = _frameFloatArray.size();
    animation->frameOffset = _frameArray.size();

    _animation = animation;

    if (rawData.HasMember(FRAME))
    {
        const auto& rawFrames = rawData[FRAME];
        const auto keyFrameCount = rawFrames.Size();
        if (keyFrameCount > 0) 
        {
            for (std::size_t i = 0, frameStart = 0; i < keyFrameCount; ++i) 
            {
                const auto& rawFrame = rawFrames[i];
                _parseActionDataInFrame(rawFrame, frameStart, nullptr, nullptr);
                frameStart += _getNumber(rawFrame, DURATION, (unsigned)1);
            }
        }
    }

    if (rawData.HasMember(Z_ORDER))
    {
        _animation->zOrderTimeline = _parseTimeline(
            rawData[Z_ORDER], FRAME, TimelineType::ZOrder,
            false, false, 0,
            std::bind(&JSONDataParser::_parseZOrderFrame, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3)
        );
    }

    if (rawData.HasMember(BONE))
    {
        const auto& rawTimelines = rawData[BONE];
        for (std::size_t i = 0, l = rawTimelines.Size(); i < l; ++i)
        {
            _parseBoneTimeline(rawTimelines[i]);
        }
    }

    if (rawData.HasMember(SLOT))
    {
        const auto& rawTimelines = rawData[SLOT];
        for (std::size_t i = 0, l = rawTimelines.Size(); i < l; ++i)
        {
            _parseSlotTimeline(rawTimelines[i]);
        }
    }

    if (rawData.HasMember(FFD))
    {
        const auto& rawTimelines = rawData[FFD];
        for (std::size_t i = 0, l = rawTimelines.Size(); i < l; ++i)
        {
            const auto& rawTimeline = rawTimelines[i];
            auto skinName = _getString(rawTimeline, SKIN, DEFAULT_NAME);
            const auto& slotName = _getString(rawTimeline, SLOT, "");
            const auto& displayName = _getString(rawTimeline, NAME, "");

            if (skinName.empty()) //
            {
                skinName = DEFAULT_NAME;
            }

            _slot = _armature->getSlot(slotName);
            _mesh = _armature->getMesh(skinName, slotName, displayName);
            if (_slot == nullptr || _mesh == nullptr)
            {
                continue;
            }

            const auto timeline = _parseTimeline(
                rawTimeline, FRAME, TimelineType::SlotDeform, 
                false, true, 0, 
                std::bind(&JSONDataParser::_parseSlotFFDFrame, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3)
            );
            if (timeline != nullptr)
            {
                _animation->addSlotTimeline(_slot, timeline);
            }

            _slot = nullptr;
            _mesh = nullptr;
        }
    }

    if (rawData.HasMember(IK))
    {
        const auto& rawTimelines = rawData[IK];
        for (std::size_t i = 0, l = rawTimelines.Size(); i < l; ++i)
        {
            const auto& rawTimeline = rawTimelines[i];
            const auto& constraintName = _getString(rawTimeline, NAME, "");
            const auto constraint = _armature->getConstraint(constraintName);
            if (constraint == nullptr)
            {
                continue;
            }

            const auto timeline = _parseTimeline(
                rawTimeline, FRAME, TimelineType::IKConstraint, 
                true, false, 2,
                std::bind(&JSONDataParser::_parseIKConstraintFrame, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3)
            );

            if (timeline != nullptr)
            {
                _animation->addConstraintTimeline(constraint, timeline);
            }
        }
    }

    if (_actionFrames.size() > 0)
    {
        std::sort(_actionFrames.begin(), _actionFrames.end());

        const auto timeline = _animation->actionTimeline = BaseObject::borrowObject<TimelineData>();
        const auto keyFrameCount = _actionFrames.size();
        timeline->type = TimelineType::Action;
        timeline->offset = _timelineArray.size();
        _timelineArray.resize(_timelineArray.size() + 1 + 1 + 1 + 1 + 1 + keyFrameCount);
        _timelineArray[timeline->offset + (unsigned)BinaryOffset::TimelineScale] = 100;
        _timelineArray[timeline->offset + (unsigned)BinaryOffset::TimelineOffset] = 0;
        _timelineArray[timeline->offset + (unsigned)BinaryOffset::TimelineKeyFrameCount] = keyFrameCount;
        _timelineArray[timeline->offset + (unsigned)BinaryOffset::TimelineFrameValueCount] = 0;
        _timelineArray[timeline->offset + (unsigned)BinaryOffset::TimelineFrameValueOffset] = 0;

        _timeline = timeline;

        if (keyFrameCount == 1)
        {
            timeline->frameIndicesOffset = -1;
            _timelineArray[timeline->offset + (unsigned)BinaryOffset::TimelineFrameOffset + 0] = _parseCacheActionFrame(_actionFrames[0]) - _animation->frameOffset;
        }
        else {
            const auto totalFrameCount = _animation->frameCount + 1; // One more frame than animation.
            auto& frameIndices = _data->frameIndices;
            timeline->frameIndicesOffset = frameIndices.size();
            frameIndices.resize(frameIndices.size() + totalFrameCount);

            for (
                std::size_t i = 0, iK = 0, frameStart = 0, frameCount = 0;
                i < totalFrameCount;
                ++i
                )
            {
                if (frameStart + frameCount <= i && iK < keyFrameCount)
                {
                    auto& frame = _actionFrames[iK];
                    frameStart = frame.frameStart;
                    if (iK == keyFrameCount - 1)
                    {
                        frameCount = _animation->frameCount - frameStart;
                    }
                    else {
                        frameCount = _actionFrames[iK + 1].frameStart - frameStart;
                    }

                    _timelineArray[timeline->offset + (unsigned)BinaryOffset::TimelineFrameOffset + iK] = _parseActionFrame(frame, frameStart, frameCount) - _animation->frameOffset;
                    iK++;
                }

                frameIndices[timeline->frameIndicesOffset + i] = iK - 1;
            }
        }

        _timeline = nullptr;
        _actionFrames.clear();
    }

    _animation = nullptr;

    return animation;
}

TimelineData* JSONDataParser::_parseTimeline(
    const rapidjson::Value& rawData, const char* framesKey, TimelineType type,
    bool addIntOffset, bool addFloatOffset, unsigned frameValueCount,
    const std::function<unsigned(const rapidjson::Value& rawData, unsigned frameStart, unsigned frameCount)>& frameParser
)
{
    if (!rawData.HasMember(framesKey))
    {
        return nullptr;
    }

    const auto& rawFrames = rawData[framesKey];
    const auto keyFrameCount = rawFrames.Size();
    if (keyFrameCount == 0) 
    {
        return nullptr;
    }

    const auto timeline = BaseObject::borrowObject<TimelineData>();
    timeline->type = type;
    timeline->offset = _timelineArray.size();
    _timelineArray.resize(_timelineArray.size() + 1 + 1 + 1 + 1 + 1 + keyFrameCount);
    _timelineArray[timeline->offset + (unsigned)BinaryOffset::TimelineScale] = _getNumber(rawData, SCALE, 1.0f) * 100.f;
    _timelineArray[timeline->offset + (unsigned)BinaryOffset::TimelineOffset] = _getNumber(rawData, OFFSET, 0.0f) * 100.f;
    _timelineArray[timeline->offset + (unsigned)BinaryOffset::TimelineKeyFrameCount] = keyFrameCount;
    _timelineArray[timeline->offset + (unsigned)BinaryOffset::TimelineFrameValueCount] = frameValueCount;
    if (addIntOffset) 
    {
        _timelineArray[timeline->offset + (unsigned)BinaryOffset::TimelineFrameValueOffset] = _frameIntArray.size() - _animation->frameIntOffset;
    }
    else if (addFloatOffset) 
    {
        _timelineArray[timeline->offset + (unsigned)BinaryOffset::TimelineFrameValueOffset] = _frameFloatArray.size() - _animation->frameFloatOffset;
    }
    else 
    {
        _timelineArray[timeline->offset + (unsigned)BinaryOffset::TimelineFrameValueOffset] = 0;
    }

    _timeline = timeline;

    if (keyFrameCount == 1) // Only one frame.
    {
        timeline->frameIndicesOffset = -1;
        _timelineArray[timeline->offset + (unsigned)BinaryOffset::TimelineFrameOffset + 0] = frameParser(rawFrames[0], 0, 0) - _animation->frameOffset;
    }
    else {
        unsigned frameIndicesOffset = 0;
        auto& frameIndices = _data->frameIndices;
        const auto totalFrameCount = _animation->frameCount + 1; // One more frame than animation.
        frameIndicesOffset = frameIndices.size();
        frameIndices.resize(frameIndicesOffset + totalFrameCount);
        timeline->frameIndicesOffset = frameIndicesOffset;

        for (
            std::size_t i = 0, iK = 0, frameStart = 0, frameCount = 0;
            i < totalFrameCount;
            ++i
        )
        {
            if (frameStart + frameCount <= i && iK < keyFrameCount) 
            {
                const auto&  rawFrame = rawFrames[iK];
                frameStart = i;
                frameCount = _getNumber(rawFrame, DURATION, (unsigned)1);
                if (iK == keyFrameCount - 1) 
                {
                    frameCount = _animation->frameCount - frameStart;
                }

                _timelineArray[timeline->offset + (unsigned)BinaryOffset::TimelineFrameOffset + iK] = frameParser(rawFrame, frameStart, frameCount) - _animation->frameOffset;
                iK++;
            }

            frameIndices[frameIndicesOffset + i] = iK - 1;
        }
    }

    _timeline = nullptr;

    return timeline;
}

void JSONDataParser::_parseBoneTimeline(const rapidjson::Value& rawData)
{
    const auto bone = _armature->getBone(_getString(rawData, NAME, ""));
    if (bone == nullptr) 
    {
        return;
    }

    _bone = bone;
    _slot = _armature->getSlot(_bone->name);

    if (rawData.HasMember(TRANSLATE_FRAME))
    {
        const auto timeline = _parseTimeline(
            rawData, TRANSLATE_FRAME, TimelineType::BoneTranslate,
            false, true, 2,
            std::bind(&JSONDataParser::_parseBoneTranslateFrame, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3)
        );
        if (timeline != nullptr)
        {
            _animation->addBoneTimeline(bone, timeline);
        }
    }

    if (rawData.HasMember(ROTATE_FRAME))
    {
        const auto timeline = _parseTimeline(
            rawData, ROTATE_FRAME, TimelineType::BoneRotate,
            false, true, 2,
            std::bind(&JSONDataParser::_parseBoneRotateFrame, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3)
        );
        if (timeline != nullptr)
        {
            _animation->addBoneTimeline(bone, timeline);
        }
    }

    if (rawData.HasMember(SCALE_FRAME))
    {
        const auto timeline = _parseTimeline(
            rawData, SCALE_FRAME, TimelineType::BoneScale,
            false, true, 2,
            std::bind(&JSONDataParser::_parseBoneScaleFrame, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3)
        );
        if (timeline != nullptr)
        {
            _animation->addBoneTimeline(bone, timeline);
        }
    }

    if (rawData.HasMember(FRAME))
    {
        const auto timeline = _parseTimeline(
            rawData, FRAME, TimelineType::BoneAll,
            false, true, 6,
            std::bind(&JSONDataParser::_parseBoneAllFrame, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3)
        );
        if (timeline != nullptr)
        {
            _animation->addBoneTimeline(bone, timeline);
        }
    }

    _bone = nullptr;
    _slot = nullptr;
}

void JSONDataParser::_parseSlotTimeline(const rapidjson::Value& rawData)
{
    const auto slot = _armature->getSlot(_getString(rawData, NAME, ""));
    if (slot == nullptr) 
    {
        return;
    }

    TimelineData* displayTimeline = nullptr;
    TimelineData* colorTimeline = nullptr;
    _slot = slot;

    if (rawData.HasMember(DISPLAY_FRAME))
    {
        displayTimeline = _parseTimeline(
            rawData, DISPLAY_FRAME, TimelineType::SlotDisplay,
            false, false, 0,
            std::bind(&JSONDataParser::_parseSlotDisplayFrame, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3)
        );
    }
    else
    {
        displayTimeline = _parseTimeline(
            rawData, FRAME, TimelineType::SlotDisplay,
            false, false, 0,
            std::bind(&JSONDataParser::_parseSlotDisplayFrame, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3)
        );
    }

    if (rawData.HasMember(COLOR_FRAME))
    {
        colorTimeline = _parseTimeline(
            rawData, COLOR_FRAME, TimelineType::SlotColor,
            true, false, 1,
            std::bind(&JSONDataParser::_parseSlotColorFrame, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3)
        );
    }
    else 
    {
        colorTimeline = _parseTimeline(
            rawData, FRAME, TimelineType::SlotColor,
            true, false, 1,
            std::bind(&JSONDataParser::_parseSlotColorFrame, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3)
        );
    }

    if (displayTimeline != nullptr)
    {
        _animation->addSlotTimeline(slot, displayTimeline);
    }

    if (colorTimeline != nullptr) 
    {
        _animation->addSlotTimeline(slot, colorTimeline);
    }

    _slot = nullptr;
}

unsigned JSONDataParser::_parseFrame(const rapidjson::Value& rawData, unsigned frameStart, unsigned frameCount)
{
    const auto frameOffset = _frameArray.size();
    _frameArray.resize(_frameArray.size() + 1);
    _frameArray[frameOffset + (unsigned)BinaryOffset::FramePosition] = frameStart;

    return frameOffset;
}

unsigned JSONDataParser::_parseTweenFrame(const rapidjson::Value& rawData, unsigned frameStart, unsigned frameCount)
{
    const auto frameOffset = _parseFrame(rawData, frameStart, frameCount);

    if (frameCount > 0) 
    {
        if (rawData.HasMember(CURVE))
        {
            const auto sampleCount = frameCount + 1;
            _helpArray.resize(sampleCount);
            _samplingEasingCurve(rawData[CURVE], _helpArray);
            _frameArray.resize(_frameArray.size() + 1 + 1 + _helpArray.size());
            _frameArray[frameOffset + (unsigned)BinaryOffset::FrameTweenType] = (int)TweenType::Curve;
            _frameArray[frameOffset + (unsigned)BinaryOffset::FrameTweenEasingOrCurveSampleCount] = sampleCount;
            for (std::size_t i = 0; i < sampleCount; ++i)
            {
                _frameArray[frameOffset + (unsigned)BinaryOffset::FrameCurveSamples + i] = _helpArray[i] * 10000.0f;
            }
        }
        else 
        {
            const auto noTween = -2.0f;
            auto tweenEasing = noTween;
            if (rawData.HasMember(TWEEN_EASING))
            {
                tweenEasing = _getNumber(rawData, TWEEN_EASING, noTween);
            }

            if (tweenEasing == noTween) 
            {
                _frameArray.resize(_frameArray.size() + 1);
                _frameArray[frameOffset + (unsigned)BinaryOffset::FrameTweenType] = (int16_t)TweenType::None;
            }
            else if (tweenEasing == 0.0f)
            {
                _frameArray.resize(_frameArray.size() + 1);
                _frameArray[frameOffset + (unsigned)BinaryOffset::FrameTweenType] = (int16_t)TweenType::Line;
            }
            else if (tweenEasing < 0.0f) 
            {
                _frameArray.resize(_frameArray.size() + 1 + 1);
                _frameArray[frameOffset + (unsigned)BinaryOffset::FrameTweenType] = (int16_t)TweenType::QuadIn;
                _frameArray[frameOffset + (unsigned)BinaryOffset::FrameTweenEasingOrCurveSampleCount] = -tweenEasing * 100.0f;
            }
            else if (tweenEasing <= 1.0f) 
            {
                _frameArray.resize(_frameArray.size() + 1 + 1);
                _frameArray[frameOffset + (unsigned)BinaryOffset::FrameTweenType] = (int16_t)TweenType::QuadOut;
                _frameArray[frameOffset + (unsigned)BinaryOffset::FrameTweenEasingOrCurveSampleCount] = tweenEasing * 100.0f;
            }
            else 
            {
                _frameArray.resize(_frameArray.size() + 1 + 1);
                _frameArray[frameOffset + (unsigned)BinaryOffset::FrameTweenType] = (int16_t)TweenType::QuadInOut;
                _frameArray[frameOffset + (unsigned)BinaryOffset::FrameTweenEasingOrCurveSampleCount] = tweenEasing * 100.0f - 100.0f;
            }
        }
    }
    else 
    {
        _frameArray.resize(_frameArray.size() + 1);
        _frameArray[frameOffset + (unsigned)BinaryOffset::FrameTweenType] = (int16_t)TweenType::None;
    }

    return frameOffset;
}

unsigned JSONDataParser::_parseActionFrame(const ActionFrame& frame, unsigned frameStart, unsigned frameCount)
{
    const auto frameOffset = _frameArray.size();
    const auto actionCount = frame.actions.size();
    _frameArray.resize(_frameArray.size() + 1 + 1 + actionCount);
    _frameArray[frameOffset + (unsigned)BinaryOffset::FramePosition] = frameStart;
    _frameArray[frameOffset + (unsigned)BinaryOffset::FramePosition + 1] = actionCount; // Action count.

    for (std::size_t i = 0; i < actionCount; ++i) // Action offsets.
    {
        _frameArray[frameOffset + (unsigned)BinaryOffset::FramePosition + 2 + i] = frame.actions[i];
    }

    return frameOffset;
}

unsigned JSONDataParser::_parseZOrderFrame(const rapidjson::Value& rawData, unsigned frameStart, unsigned frameCount)
{
    const auto frameOffset = _parseFrame(rawData, frameStart, frameCount);

    if (rawData.HasMember(Z_ORDER))
    {
        const auto& rawZOrder = rawData[Z_ORDER];
        if (!rawZOrder.Empty()) 
        {
            const auto slotCount = _armature->sortedSlots.size();
            std::vector<int> unchanged;
            std::vector<int> zOrders;
            unchanged.resize(slotCount - rawZOrder.Size() / 2);
            zOrders.resize(slotCount);

            for (std::size_t i = 0; i < unchanged.size(); ++i)
            {
                unchanged[i] = 0;
            }

            for (std::size_t i = 0; i < slotCount; ++i) 
            {
                zOrders[i] = -1;
            }

            unsigned originalIndex = 0;
            unsigned unchangedIndex = 0;
            for (std::size_t i = 0, l = rawZOrder.Size(); i < l; i += 2) 
            {
                const auto slotIndex = rawZOrder[i].GetInt();
                const auto zOrderOffset = rawZOrder[i + 1].GetInt();
                while (originalIndex != (unsigned)slotIndex)
                {
                    unchanged[unchangedIndex++] = originalIndex++;
                }
                
                unsigned index = originalIndex + zOrderOffset;
                zOrders[index] = originalIndex++;
            }

            while (originalIndex < slotCount) 
            {
                unchanged[unchangedIndex++] = originalIndex++;
            }

            _frameArray.resize(_frameArray.size() + 1 + slotCount);
            _frameArray[frameOffset + 1] = slotCount;

            int i = slotCount;
            while (i--) 
            {
                if (zOrders[i] == -1) 
                {
                    _frameArray[frameOffset + 2 + i] = unchanged[--unchangedIndex];
                }
                else {
                    _frameArray[frameOffset + 2 + i] = zOrders[i];
                }
            }

            return frameOffset;
        }
    }

    _frameArray.resize(_frameArray.size() + 1);
    _frameArray[frameOffset + 1] = 0;

    return frameOffset;
}

unsigned JSONDataParser::_parseBoneAllFrame(const rapidjson::Value& rawData, unsigned frameStart, unsigned frameCount)
{
    _helpTransform.identity();
    if (rawData.HasMember(TRANSFORM))
    {
        _parseTransform(rawData[TRANSFORM], _helpTransform, 1.0f);
    }

    // Modify rotation.
    auto rotation = _helpTransform.rotation;
    if (frameStart != 0) 
    {
        if (_prevClockwise == 0) 
        {
            rotation = _prevRotation + Transform::normalizeRadian(rotation - _prevRotation);
        }
        else 
        {
            if (_prevClockwise > 0 ? rotation >= _prevRotation : rotation <= _prevRotation) 
            {
                _prevClockwise = _prevClockwise > 0 ? _prevClockwise - 1 : _prevClockwise + 1;
            }

            rotation = _prevRotation + rotation - _prevRotation + Transform::PI_D * _prevClockwise;
        }
    }

    _prevClockwise = _getNumber(rawData, TWEEN_ROTATE, 0.0f);
    _prevRotation = rotation;
    //
    const auto frameOffset = _parseTweenFrame(rawData, frameStart, frameCount);
    auto frameFloatOffset = _frameFloatArray.size();
    _frameFloatArray.resize(_frameFloatArray.size() + 6);
    _frameFloatArray[frameFloatOffset++] = _helpTransform.x;
    _frameFloatArray[frameFloatOffset++] = _helpTransform.y;
    _frameFloatArray[frameFloatOffset++] = rotation;
    _frameFloatArray[frameFloatOffset++] = _helpTransform.skew;
    _frameFloatArray[frameFloatOffset++] = _helpTransform.scaleX;
    _frameFloatArray[frameFloatOffset++] = _helpTransform.scaleY;
    _parseActionDataInFrame(rawData, frameStart, _bone, _slot);

    return frameOffset;
}

unsigned JSONDataParser::_parseBoneTranslateFrame(const rapidjson::Value& rawData, unsigned frameStart, unsigned frameCount)
{
    const auto frameOffset = _parseTweenFrame(rawData, frameStart, frameCount);
    auto frameFloatOffset = _frameFloatArray.size();
    _frameFloatArray.resize(_frameFloatArray.size() + 2);
    _frameFloatArray[frameFloatOffset++] = _getNumber(rawData, X, 0.0f);
    _frameFloatArray[frameFloatOffset++] = _getNumber(rawData, Y, 0.0f);

    return frameOffset;
}

unsigned JSONDataParser::_parseBoneRotateFrame(const rapidjson::Value& rawData, unsigned frameStart, unsigned frameCount)
{
    // Modify rotation.
    auto rotation = _getNumber(rawData, ROTATE, 0.0f) * Transform::DEG_RAD;
    if (frameStart != 0)
    {
        if (_prevClockwise == 0)
        {
            rotation = _prevRotation + Transform::normalizeRadian(rotation - _prevRotation);
        }
        else
        {
            if (_prevClockwise > 0 ? rotation >= _prevRotation : rotation <= _prevRotation)
            {
                _prevClockwise = _prevClockwise > 0 ? _prevClockwise - 1 : _prevClockwise + 1;
            }

            rotation = _prevRotation + rotation - _prevRotation + Transform::PI_D * _prevClockwise;
        }
    }

    _prevClockwise = _getNumber(rawData, CLOCK_WISE, 0.0f);
    _prevRotation = rotation;
    //
    const auto frameOffset = _parseTweenFrame(rawData, frameStart, frameCount);
    auto frameFloatOffset = _frameFloatArray.size();
    _frameFloatArray.resize(_frameFloatArray.size() + 2);
    _frameFloatArray[frameFloatOffset++] = rotation;
    _frameFloatArray[frameFloatOffset++] = _getNumber(rawData, SKEW, 0.0f) * Transform::DEG_RAD;

    return frameOffset;
}

unsigned JSONDataParser::_parseBoneScaleFrame(const rapidjson::Value& rawData, unsigned frameStart, unsigned frameCount)
{
    const auto frameOffset = _parseTweenFrame(rawData, frameStart, frameCount);

    auto frameFloatOffset = _frameFloatArray.size();
    _frameFloatArray.resize(_frameFloatArray.size() + 2);
    _frameFloatArray[frameFloatOffset++] = _getNumber(rawData, X, 1.0f);
    _frameFloatArray[frameFloatOffset++] = _getNumber(rawData, Y, 1.0f);

    return frameOffset;
}

unsigned JSONDataParser::_parseSlotDisplayFrame(const rapidjson::Value& rawData, unsigned frameStart, unsigned frameCount)
{
    const auto frameOffset = _parseFrame(rawData, frameStart, frameCount);

    _frameArray.resize(_frameArray.size() + 1);

    if (rawData.HasMember(VALUE))
    {
        _frameArray[frameOffset + 1] = _getNumber(rawData, VALUE, 0);
    }
    else 
    {
        _frameArray[frameOffset + 1] = _getNumber(rawData, DISPLAY_INDEX, 0);
    }

    _parseActionDataInFrame(rawData, frameStart, _slot->parent, _slot);

    return frameOffset;
}

unsigned JSONDataParser::_parseSlotColorFrame(const rapidjson::Value& rawData, unsigned frameStart, unsigned frameCount)
{
    const auto frameOffset = _parseTweenFrame(rawData, frameStart, frameCount);
    auto colorOffset = -1;

    if (rawData.HasMember(VALUE) || rawData.HasMember(COLOR))
    {
        const auto& rawColor = rawData.HasMember(VALUE) ? rawData[VALUE] : rawData[COLOR];
        if (
            rawColor.HasMember(ALPHA_MULTIPLIER) ||
            rawColor.HasMember(RED_MULTIPLIER) ||
            rawColor.HasMember(GREEN_MULTIPLIER) ||
            rawColor.HasMember(BLUE_MULTIPLIER) ||
            rawColor.HasMember(ALPHA_OFFSET) ||
            rawColor.HasMember(RED_OFFSET) ||
            rawColor.HasMember(GREEN_OFFSET) ||
            rawColor.HasMember(BLUE_OFFSET)
        )
        {
            _parseColorTransform(rawColor, _helpColorTransform);
            colorOffset = _intArray.size();
            _intArray.resize(_intArray.size() + 8);
            _intArray[colorOffset++] = _helpColorTransform.alphaMultiplier * 100;
            _intArray[colorOffset++] = _helpColorTransform.redMultiplier * 100;
            _intArray[colorOffset++] = _helpColorTransform.greenMultiplier * 100;
            _intArray[colorOffset++] = _helpColorTransform.blueMultiplier * 100;
            _intArray[colorOffset++] = _helpColorTransform.alphaOffset;
            _intArray[colorOffset++] = _helpColorTransform.redOffset;
            _intArray[colorOffset++] = _helpColorTransform.greenOffset;
            _intArray[colorOffset++] = _helpColorTransform.blueOffset;
            colorOffset -= 8;
        }
    }

    if (colorOffset < 0) 
    {
        if (_defaultColorOffset < 0) 
        {
            _defaultColorOffset = colorOffset = _intArray.size();
            _intArray.resize(_intArray.size() + 8);
            _intArray[colorOffset++] = 100;
            _intArray[colorOffset++] = 100;
            _intArray[colorOffset++] = 100;
            _intArray[colorOffset++] = 100;
            _intArray[colorOffset++] = 0;
            _intArray[colorOffset++] = 0;
            _intArray[colorOffset++] = 0;
            _intArray[colorOffset++] = 0;
        }

        colorOffset = _defaultColorOffset;
    }

    const auto frameIntOffset = _frameIntArray.size();
    _frameIntArray.resize(_frameIntArray.size() + 1);
    _frameIntArray[frameIntOffset] = colorOffset;

    return frameOffset;
}

unsigned JSONDataParser::_parseSlotFFDFrame(const rapidjson::Value& rawData, unsigned frameStart, unsigned frameCount)
{
    const auto frameFloatOffset = _frameFloatArray.size();
    const auto frameOffset = _parseTweenFrame(rawData, frameStart, frameCount);
    const auto offset = _getNumber(rawData, OFFSET, (unsigned)0);
    const auto vertexCount = (unsigned)_intArray[_mesh->vertices.offset + (unsigned)BinaryOffset::MeshVertexCount];
    const auto meshName = _mesh->parent->name + "_" + _slot->name + "_" + _mesh->name;
    const auto weight = _mesh->vertices.weight;

    auto x = 0.0f;
    auto y = 0.0f;
    unsigned iB = 0;
    unsigned iV = 0;
    if (weight != nullptr)
    {
        const auto& rawSlotPose = *(_weightSlotPose[meshName]);

        _helpMatrixA.a = rawSlotPose[0].GetDouble();
        _helpMatrixA.b = rawSlotPose[1].GetDouble();
        _helpMatrixA.c = rawSlotPose[2].GetDouble();
        _helpMatrixA.d = rawSlotPose[3].GetDouble();
        _helpMatrixA.tx = rawSlotPose[4].GetDouble();
        _helpMatrixA.ty = rawSlotPose[5].GetDouble();

        _frameFloatArray.resize(_frameFloatArray.size() + weight->count * 2);
        iB = weight->offset + (unsigned)BinaryOffset::WeigthBoneIndices + weight->bones.size();
    }
    else 
    {
        _frameFloatArray.resize(_frameFloatArray.size() + vertexCount * 2);
    }

    for (
        std::size_t i = 0;
        i < vertexCount * 2;
        i += 2
    )
    {
        if (!rawData.HasMember(VERTICES)) // Fill 0.
        {
            x = 0.0f;
            y = 0.0f;
        }
        else 
        {
            if (i < offset || i - offset >= rawData[VERTICES].Size()) {
                x = 0.0f;
            }
            else 
            {
                x = rawData[VERTICES][i - offset].GetDouble();
            }

            if (i + 1 < offset || i + 1 - offset >= rawData[VERTICES].Size()) {
                y = 0.0f;
            }
            else 
            {
                y = rawData[VERTICES][i + 1 - offset].GetDouble();
            }
        }

        if (weight != nullptr) // If mesh is skinned, transform point by bone bind pose.
        {
            const auto& rawBonePoses = *(_weightBonePoses[meshName]);
            const unsigned vertexBoneCount = _intArray[iB++];

            _helpMatrixA.transformPoint(x, y, _helpPoint, true);
            x = _helpPoint.x;
            y = _helpPoint.y;

            for (std::size_t j = 0; j < vertexBoneCount; ++j)
            {
                const auto boneIndex = _intArray[iB++];
                const auto matrixOffset = boneIndex * 7 + 1;

                _helpMatrixB.a = rawBonePoses[matrixOffset + 0].GetDouble();
                _helpMatrixB.b = rawBonePoses[matrixOffset + 1].GetDouble();
                _helpMatrixB.c = rawBonePoses[matrixOffset + 2].GetDouble();
                _helpMatrixB.d = rawBonePoses[matrixOffset + 3].GetDouble();
                _helpMatrixB.tx = rawBonePoses[matrixOffset + 4].GetDouble();
                _helpMatrixB.ty = rawBonePoses[matrixOffset + 5].GetDouble();
                _helpMatrixB.invert();
                _helpMatrixB.transformPoint(x, y, _helpPoint, true);

                _frameFloatArray[frameFloatOffset + iV++] = _helpPoint.x;
                _frameFloatArray[frameFloatOffset + iV++] = _helpPoint.y;
            }
        }
        else 
        {
            _frameFloatArray[frameFloatOffset + i] = x;
            _frameFloatArray[frameFloatOffset + i + 1] = y;
        }
    }

    if (frameStart == 0) 
    {
        const auto frameIntOffset = _frameIntArray.size();
        _frameIntArray.resize(_frameIntArray.size() + 1 + 1 + 1 + 1 + 1);
        _frameIntArray[frameIntOffset + (unsigned)BinaryOffset::DeformVertexOffset] = _mesh->vertices.offset;
        _frameIntArray[frameIntOffset + (unsigned)BinaryOffset::DeformCount] = _frameFloatArray.size() - frameFloatOffset;
        _frameIntArray[frameIntOffset + (unsigned)BinaryOffset::DeformValueCount] = _frameFloatArray.size() - frameFloatOffset;
        _frameIntArray[frameIntOffset + (unsigned)BinaryOffset::DeformValueOffset] = 0;
        _frameIntArray[frameIntOffset + (unsigned)BinaryOffset::DeformFloatOffset] = frameFloatOffset;
        _timelineArray[_timeline->offset + (unsigned)BinaryOffset::TimelineFrameValueCount] = frameIntOffset - _animation->frameIntOffset;
    }

    return frameOffset;
}

unsigned JSONDataParser::_parseIKConstraintFrame(const rapidjson::Value& rawData, unsigned frameStart, unsigned frameCount)
{
    const auto frameOffset = _parseTweenFrame(rawData, frameStart, frameCount);

    auto frameIntOffset = _frameIntArray.size();
    _frameIntArray.resize(_frameIntArray.size() + 2);
    _frameIntArray[frameIntOffset++] = _getBoolean(rawData, BEND_POSITIVE, true) ? 1 : 0;
    _frameIntArray[frameIntOffset++] = round(_getNumber(rawData, WEIGHT, 1.0f) * 100.0f);

    return frameOffset;
}

const std::vector<ActionData*>& JSONDataParser::_parseActionData(const rapidjson::Value& rawData, ActionType type, BoneData* bone, SlotData* slot)
{
    static std::vector<ActionData*> actions;
    actions.clear();

    if (rawData.IsString())
    {
        const auto action = BaseObject::borrowObject<ActionData>();
        action->type = type;
        action->name = rawData.GetString();
        action->bone = bone;
        action->slot = slot;
        actions.push_back(action);
    }
    else if (rawData.IsArray())
    {
        for (std::size_t iA = 0, lA = rawData.Size(); iA < lA; ++iA)
        {
            const auto& rawAction = rawData[iA];
            const auto action = BaseObject::borrowObject<ActionData>();

            if (rawAction.HasMember(GOTO_AND_PLAY))
            {
                action->type = ActionType::Play;
                action->name = _getString(rawAction, GOTO_AND_PLAY, "");
            }
            else 
            {
                if (rawAction.HasMember(TYPE) && rawAction[TYPE].IsString())
                {
                    action->type = _getActionType(rawAction[TYPE].GetString());
                }
                else 
                {
                    action->type = (ActionType)_getNumber(rawAction, TYPE, (int)type);
                }

                action->name = _getString(rawAction, NAME, "");
            }

            if (rawAction.HasMember(BONE))
            {
                const auto& boneName = _getString(rawAction, BONE, "");
                action->bone = _armature->getBone(boneName);
            }
            else {
                action->bone = bone;
            }

            if (rawAction.HasMember(SLOT))
            {
                const auto& slotName = _getString(rawAction, SLOT, "");
                action->slot = _armature->getSlot(slotName);
            }
            else 
            {
                action->slot = slot;
            }

            if (rawAction.HasMember(INTS))
            {
                if (action->data == nullptr) 
                {
                    action->data = BaseObject::borrowObject<UserData>();
                }

                const auto& rawInts = rawAction[INTS];
                for (std::size_t i = 0, l = rawInts.Size(); i < l; ++i)
                {
                    action->data->addInt(rawInts[i].GetInt());
                }
            }

            if (rawAction.HasMember(FLOATS))
            {
                if (action->data == nullptr)
                {
                    action->data = BaseObject::borrowObject<UserData>();
                }

                const auto& rawFloats = rawAction[FLOATS];
                for (std::size_t i = 0, l = rawFloats.Size(); i < l; ++i)
                {
                    action->data->addFloat(rawFloats[i].GetDouble());
                }
            }

            if (rawAction.HasMember(STRINGS))
            {
                if (action->data == nullptr)
                {
                    action->data = BaseObject::borrowObject<UserData>();
                }

                const auto& rawStrings = rawAction[STRINGS];
                for (std::size_t i = 0, l = rawStrings.Size(); i < l; ++i)
                {
                    action->data->addString(rawStrings[i].GetString());
                }
            }

            actions.push_back(action);
        }
    }

    return actions;
}

void JSONDataParser::_parseTransform(const rapidjson::Value& rawData, Transform& transform, float scale)
{
    transform.x = _getNumber(rawData, X, 0.0f) * scale;
    transform.y = _getNumber(rawData, Y, 0.0f) * scale;

    if (rawData.HasMember(ROTATE) || rawData.HasMember(SKEW))
    {
        transform.rotation = Transform::normalizeRadian(_getNumber(rawData, ROTATE, 0.0f) * Transform::DEG_RAD);
        transform.skew = Transform::normalizeRadian(_getNumber(rawData, SKEW, 0.0f) * Transform::DEG_RAD);
    }
    else if (rawData.HasMember(SKEW_X) || rawData.HasMember(SKEW_Y))
    {
        transform.rotation = Transform::normalizeRadian(_getNumber(rawData, SKEW_Y, 0.0f) * Transform::DEG_RAD);
        transform.skew = Transform::normalizeRadian(_getNumber(rawData, SKEW_X, 0.0f) * Transform::DEG_RAD) - transform.rotation;
    }

    transform.scaleX = _getNumber(rawData, SCALE_X, 1.0f);
    transform.scaleY = _getNumber(rawData, SCALE_Y, 1.0f);
}

void JSONDataParser::_parseColorTransform(const rapidjson::Value& rawData, ColorTransform& color)
{
    color.alphaMultiplier = _getNumber(rawData, ALPHA_MULTIPLIER, (int)100) * 0.01f;
    color.redMultiplier = _getNumber(rawData, RED_MULTIPLIER, (int)100) * 0.01f;
    color.greenMultiplier = _getNumber(rawData, GREEN_MULTIPLIER, (int)100) * 0.01f;
    color.blueMultiplier = _getNumber(rawData, BLUE_MULTIPLIER, (int)100) * 0.01f;
    color.alphaOffset = _getNumber(rawData, ALPHA_OFFSET, (int)0);
    color.redOffset = _getNumber(rawData, RED_OFFSET, (int)0);
    color.greenOffset = _getNumber(rawData, GREEN_OFFSET, (int)0);
    color.blueOffset = _getNumber(rawData, BLUE_OFFSET, (int)0);
}

void JSONDataParser::_parseArray(const rapidjson::Value& rawData)
{
    _intArray.clear();
    _floatArray.clear();
    _frameIntArray.clear();
    _frameFloatArray.clear();
    _frameArray.clear();
    _timelineArray.clear();
}

DragonBonesData* JSONDataParser::_parseDragonBonesData(const rapidjson::Value& rawData, float scale)
{
    const auto& version = _getString(rawData, VERSION, "");
    const auto& compatibleVersion = _getString(rawData, COMPATIBLE_VERSION, "");

    if (
        indexOf(DATA_VERSIONS, version) >= 0 ||
        indexOf(DATA_VERSIONS, compatibleVersion) >= 0
        )
    {
        const auto data = BaseObject::borrowObject<DragonBonesData>();
        data->version = version;
        data->name = _getString(rawData, NAME, "");
        data->frameRate = _getNumber(rawData, FRAME_RATE, 24);

        if (data->frameRate == 0) // Data error.
        {
            data->frameRate = 24;
        }

        if (rawData.HasMember(ARMATURE))
        {
            _data = data;
            _parseArray(rawData);

            const auto& rawArmatures = rawData[ARMATURE];
            for (std::size_t i = 0, l = rawArmatures.Size(); i < l; ++i)
            {
                data->addArmature(_parseArmature(rawArmatures[i], scale));
            }

            if (data->binary == nullptr)
            {
                // Align.
                if (fmod(_intArray.size(), 2) != 0)
                {
                    _intArray.push_back(0);
                }

                if (fmod(_frameIntArray.size(), 2) != 0)
                {
                    _frameIntArray.push_back(0);
                }

                if (fmod(_frameArray.size(), 2) != 0)
                {
                    _frameArray.push_back(0);
                }

                if (fmod(_timelineArray.size(), 2) != 0)
                {
                    _timelineArray.push_back(0);
                }

                const auto l1 = _intArray.size() * 2;
                const auto l2 = _floatArray.size() * 4;
                const auto l3 = _frameIntArray.size() * 2;
                const auto l4 = _frameFloatArray.size() * 4;
                const auto l5 = _frameArray.size() * 2;
                const auto l6 = _timelineArray.size() * 2;
                
                auto binary = new char[l1 + l2 + l3 + l4 + l5 + l6];
                auto intArray = (int16_t*)binary;
                auto floatArray = (float*)(binary + l1);
                auto frameIntArray = (int16_t*)(binary + l1 + l2);
                auto frameFloatArray = (float*)(binary + l1 + l2 + l3);
                auto frameArray = (int16_t*)(binary + l1 + l2 + l3 + l4);
                auto timelineArray = (uint16_t*)(binary + l1 + l2 + l3 + l4 + l5);

                for (std::size_t i = 0, l = _intArray.size(); i < l; ++i)
                {
                    intArray[i] = _intArray[i];
                }

                for (std::size_t i = 0, l = _floatArray.size(); i < l; ++i)
                {
                    floatArray[i] = _floatArray[i];
                }

                for (std::size_t i = 0, l = _frameIntArray.size(); i < l; ++i)
                {
                    frameIntArray[i] = _frameIntArray[i];
                }

                for (std::size_t i = 0, l = _frameFloatArray.size(); i < l; ++i)
                {
                    frameFloatArray[i] = _frameFloatArray[i];
                }

                for (std::size_t i = 0, l = _frameArray.size(); i < l; ++i)
                {
                    frameArray[i] = _frameArray[i];
                }

                for (std::size_t i = 0, l = _timelineArray.size(); i < l; ++i)
                {
                    timelineArray[i] = _timelineArray[i];
                }

                data->binary = binary;
                data->intArray = intArray;
                data->floatArray = floatArray;
                data->frameIntArray = frameIntArray;
                data->frameFloatArray = frameFloatArray;
                data->frameArray = frameArray;
                data->timelineArray = timelineArray;
            }

            _defaultColorOffset = -1;
            _data = nullptr;
        }

        if (rawData.HasMember(TEXTURE_ATLAS))
        {
            _rawTextureAtlases = (rapidjson::Value*)&(rawData[TEXTURE_ATLAS]);
        }

        return data;
    }
    else
    {
        DRAGONBONES_ASSERT(
            false,
            "Nonsupport data version: " + version + "\n" +
            "Please convert DragonBones data to support version.\n" +
            "Read more: https://github.com/DragonBones/Tools/"
        );
    }

    return nullptr;
}

void JSONDataParser::_parseTextureAtlasData(const rapidjson::Value& rawData, TextureAtlasData& textureAtlasData, float scale)
{
    textureAtlasData.format = _getTextureFormat(_getString(rawData, FORMAT, ""));
    textureAtlasData.width = _getNumber(rawData, WIDTH, (unsigned)0);
    textureAtlasData.height = _getNumber(rawData, HEIGHT, (unsigned)0);
    textureAtlasData.scale = scale == 1.0f ? 1.0f / _getNumber(rawData, SCALE, 1.0f) : scale;
    textureAtlasData.name = _getString(rawData, NAME, "");
    textureAtlasData.imagePath = _getString(rawData, IMAGE_PATH, "");

    if (rawData.HasMember(SUB_TEXTURE))
    {
        const auto& rawTextures = rawData[SUB_TEXTURE];
        for (std::size_t i = 0, l = rawTextures.Size(); i < l; ++i)
        {
            const auto& rawTexture = rawTextures[i];
            const auto textureData = textureAtlasData.createTexture();
            textureData->rotated = _getBoolean(rawTexture, ROTATED, false);
            textureData->name = _getString(rawTexture, NAME, "");
            textureData->region.x = _getNumber(rawTexture, X, 0.0f);
            textureData->region.y = _getNumber(rawTexture, Y, 0.0f);
            textureData->region.width = _getNumber(rawTexture, WIDTH, 0.0f);
            textureData->region.height = _getNumber(rawTexture, HEIGHT, 0.0f);

            const auto frameWidth = _getNumber(rawTexture, FRAME_WIDTH, -1.0f);
            const auto frameHeight = _getNumber(rawTexture, FRAME_HEIGHT, -1.0f);
            if (frameWidth > 0.0f && frameHeight > 0.0f)
            {
                textureData->frame = TextureData::createRectangle();
                textureData->frame->x = _getNumber(rawTexture, FRAME_X, 0.0f);
                textureData->frame->y = _getNumber(rawTexture, FRAME_Y, 0.0f);
                textureData->frame->width = frameWidth;
                textureData->frame->height = frameHeight;
            }

            textureAtlasData.addTexture(textureData);
        }
    }
}

DragonBonesData* JSONDataParser::parseDragonBonesData(const char* rawData, float scale)
{
    DRAGONBONES_ASSERT(rawData != nullptr, "");

    rapidjson::Document document;
    document.Parse(rawData);

    return _parseDragonBonesData(document, scale);
}

bool JSONDataParser::parseTextureAtlasData(const char* rawData, TextureAtlasData& textureAtlasData, float scale)
{
    if (rawData == nullptr)
    {
        if (_rawTextureAtlases == nullptr || _rawTextureAtlases->Empty())
        {
            return false;
        }

        const auto& rawTextureAtlas = (*_rawTextureAtlases)[_rawTextureAtlasIndex++];
        _parseTextureAtlasData(rawTextureAtlas, textureAtlasData, scale);
        if (_rawTextureAtlasIndex >= _rawTextureAtlases->Size()) 
        {
            _rawTextureAtlasIndex = 0;
            _rawTextureAtlases = nullptr;
        }

        return true;
    }

    rapidjson::Document document;
    document.Parse(rawData);
    _parseTextureAtlasData(document, textureAtlasData, scale);

    return true;
}

DRAGONBONES_NAMESPACE_END