#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