初始化

cocos2d-x/cocos/editor-support/dragonbones/parser/BinaryDataParser.cpp

@@ -0,0 +1,237 @@
+#include "BinaryDataParser.h"
+
+DRAGONBONES_NAMESPACE_BEGIN
+
+TimelineData* BinaryDataParser::_parseBinaryTimeline(TimelineType type, unsigned offset, TimelineData* timelineData)
+{
+    const auto timeline = timelineData != nullptr ? timelineData : BaseObject::borrowObject<TimelineData>();
+    timeline->type = type;
+    timeline->offset = offset;
+
+    _timeline = timeline;
+
+    const auto keyFrameCount = (unsigned)_timelineArray[timeline->offset + (unsigned)BinaryOffset::TimelineKeyFrameCount];
+    if (keyFrameCount == 1) 
+    {
+        timeline->frameIndicesOffset = -1;
+    }
+    else 
+    {
+        unsigned frameIndicesOffset = 0;
+        const auto totalFrameCount = _animation->frameCount + 1; // One more frame than animation.
+        auto& frameIndices = _data->frameIndices;
+
+        frameIndicesOffset = frameIndices.size();
+        timeline->frameIndicesOffset = frameIndicesOffset;
+        frameIndices.resize(frameIndicesOffset + totalFrameCount);
+
+        for (
+            std::size_t i = 0, iK = 0, frameStart = 0, frameCount = 0;
+            i < totalFrameCount;
+            ++i
+        ) 
+        {
+            if (frameStart + frameCount <= i && iK < keyFrameCount) 
+            {
+                frameStart = _frameArray[_animation->frameOffset + _timelineArray[timeline->offset + (unsigned)BinaryOffset::TimelineFrameOffset + iK]];
+                if (iK == keyFrameCount - 1) 
+                {
+                    frameCount = _animation->frameCount - frameStart;
+                }
+                else 
+                {
+                    frameCount = _frameArray[_animation->frameOffset + _timelineArray[timeline->offset + (unsigned)BinaryOffset::TimelineFrameOffset + iK + 1]] - frameStart;
+                }
+
+                iK++;
+            }
+
+            frameIndices[frameIndicesOffset + i] = iK - 1;
+        }
+    }
+
+    _timeline = nullptr;
+
+    return timeline;
+}
+
+void BinaryDataParser::_parseVertices(const rapidjson::Value& rawData, VerticesData& vertices)
+{
+    vertices.offset = rawData[OFFSET].GetUint();
+
+    const auto weightOffset = _intArray[vertices.offset + (unsigned)BinaryOffset::MeshWeightOffset];
+    if (weightOffset >= 0)
+    {
+        const auto weight = BaseObject::borrowObject<WeightData>();
+        const auto vertexCount = _intArray[vertices.offset + (unsigned)BinaryOffset::MeshVertexCount];
+        const auto boneCount = (unsigned)_intArray[weightOffset + (unsigned)BinaryOffset::WeigthBoneCount];
+        weight->offset = weightOffset;
+
+        for (std::size_t i = 0; i < boneCount; ++i)
+        {
+            const auto boneIndex = _intArray[weightOffset + (unsigned)BinaryOffset::WeigthBoneIndices + i];
+            weight->addBone(_rawBones[boneIndex]);
+        }
+
+        auto boneIndicesOffset = weightOffset + (unsigned)BinaryOffset::WeigthBoneIndices + boneCount;
+        unsigned weightCount = 0;
+        for (std::size_t i = 0, l = vertexCount; i < l; ++i)
+        {
+            const auto vertexBoneCount = (unsigned)_intArray[boneIndicesOffset++];
+            weightCount += vertexBoneCount;
+            boneIndicesOffset += vertexBoneCount;
+        }
+
+        weight->count = weightCount;
+        vertices.weight = weight;
+    }
+}
+
+void BinaryDataParser::_parseMesh(const rapidjson::Value& rawData, MeshDisplayData& mesh)
+{
+    _parseVertices(rawData, mesh.vertices);
+}
+
+AnimationData* BinaryDataParser::_parseAnimation(const rapidjson::Value& rawData)
+{
+    const auto animation =  BaseObject::borrowObject<AnimationData>();
+    animation->frameCount = std::max(_getNumber(rawData, DURATION, 1), 1);
+    animation->playTimes = _getNumber(rawData, PLAY_TIMES, 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;
+    }
+
+    // Offsets.
+    const auto& offsets = rawData[OFFSET];
+    animation->frameIntOffset = offsets[0].GetUint();
+    animation->frameFloatOffset = offsets[1].GetUint();
+    animation->frameOffset = offsets[2].GetUint();
+
+    _animation = animation;
+
+    if (rawData.HasMember(ACTION))
+    {
+        animation->actionTimeline = _parseBinaryTimeline(TimelineType::Action, rawData[ACTION].GetUint());
+    }
+
+    if (rawData.HasMember(Z_ORDER))
+    {
+        animation->zOrderTimeline = _parseBinaryTimeline(TimelineType::ZOrder, rawData[Z_ORDER].GetUint());
+    }
+
+    if (rawData.HasMember(BONE))
+    {
+        const auto& rawTimeliness = rawData[BONE];
+        for (auto iterator = rawTimeliness.MemberBegin(); iterator != rawTimeliness.MemberEnd(); ++iterator)
+        {
+            const auto bone = _armature->getBone(iterator->name.GetString());
+            if (bone == nullptr)
+            {
+                continue;
+            }
+
+            const auto& rawTimelines = *&(iterator->value);
+            for (std::size_t i = 0, l = rawTimelines.Size(); i < l; i += 2) 
+            {
+                const auto timelineType = (TimelineType)rawTimelines[i].GetInt();
+                const auto timelineOffset = rawTimelines[i + 1].GetUint();
+                const auto timeline = _parseBinaryTimeline(timelineType, timelineOffset);
+                _animation->addBoneTimeline(bone, timeline);
+            }
+        }
+    }
+
+    if (rawData.HasMember(SLOT))
+    {
+        const auto& rawTimeliness = rawData[SLOT];
+        for (auto iterator = rawTimeliness.MemberBegin(); iterator != rawTimeliness.MemberEnd(); ++iterator)
+        {
+            const auto slot = _armature->getSlot(iterator->name.GetString());
+            if (slot == nullptr) 
+            {
+                continue;
+            }
+
+            const auto& rawTimelines = *&(iterator->value);
+            for (std::size_t i = 0, l = rawTimelines.Size(); i < l; i += 2)
+            {
+                const auto timelineType = (TimelineType)rawTimelines[i].GetInt();
+                const auto timelineOffset = rawTimelines[i + 1].GetUint();
+                const auto timeline = _parseBinaryTimeline(timelineType, timelineOffset);
+                _animation->addSlotTimeline(slot, timeline);
+            }
+        }
+    }
+
+    if (rawData.HasMember(CONSTRAINT))
+    {
+        const auto& rawTimeliness = rawData[CONSTRAINT];
+        for (auto iterator = rawTimeliness.MemberBegin(); iterator != rawTimeliness.MemberEnd(); ++iterator)
+        {
+            const auto constraint = _armature->getConstraint(iterator->name.GetString());
+            if (constraint == nullptr)
+            {
+                continue;
+            }
+
+            const auto& rawTimelines = *&(iterator->value);
+            for (std::size_t i = 0, l = rawTimelines.Size(); i < l; i += 2)
+            {
+                const auto timelineType = (TimelineType)rawTimelines[i].GetInt();
+                const auto timelineOffset = rawTimelines[i + 1].GetUint();
+                const auto timeline = _parseBinaryTimeline(timelineType, timelineOffset);
+                _animation->addConstraintTimeline(constraint, timeline);
+            }
+        }
+    }
+
+    _animation = nullptr;
+
+    return animation;
+}
+
+void BinaryDataParser::_parseArray(const rapidjson::Value& rawData)
+{
+    const auto& offsets = rawData[OFFSET];
+
+	_data->binary = _binary;
+    _data->intArray = _intArray = (int16_t*)(_binary + _binaryOffset + offsets[0].GetUint());
+    _data->floatArray = _floatArray = (float*)(_binary + _binaryOffset + offsets[2].GetUint());
+    _data->frameIntArray = _frameIntArray = (int16_t*)(_binary + _binaryOffset + offsets[4].GetUint());
+    _data->frameFloatArray = _frameFloatArray = (float*)(_binary + _binaryOffset + offsets[6].GetUint());
+    _data->frameArray = _frameArray = (int16_t*)(_binary + _binaryOffset + offsets[8].GetUint());
+    _data->timelineArray = _timelineArray = (uint16_t*)(_binary + _binaryOffset + offsets[10].GetUint());
+}
+
+DragonBonesData* BinaryDataParser::parseDragonBonesData(const char* rawData, float scale)
+{
+    DRAGONBONES_ASSERT(rawData != nullptr, "");
+
+    if (
+        rawData[0] != 'D' ||
+        rawData[1] != 'B' ||
+        rawData[2] != 'D' ||
+        rawData[3] != 'T'
+    ) 
+    {
+        DRAGONBONES_ASSERT(false, "Nonsupport data.");
+        return nullptr;
+    }
+
+    const auto headerLength = (std::size_t)(((uint32_t*)(rawData + 8))[0]);
+    const auto headerBytes = rawData + 8 + 4;
+    rapidjson::Document document;
+    document.Parse(headerBytes, headerLength);
+
+    _binaryOffset = 8 + 4 + headerLength;
+    _binary = rawData;
+
+    return JSONDataParser::_parseDragonBonesData(document, scale);
+}
+
+DRAGONBONES_NAMESPACE_END

cocos2d-x/cocos/editor-support/dragonbones/parser/BinaryDataParser.h

@@ -0,0 +1,72 @@
+/**
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2012-2018 DragonBones team and other contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+#ifndef DRAGONBONES_BINARY_DATA_PARSER_H
+#define DRAGONBONES_BINARY_DATA_PARSER_H
+
+#include "JSONDataParser.h"
+
+DRAGONBONES_NAMESPACE_BEGIN
+
+/**
+ * @internal
+ */
+class BinaryDataParser : public JSONDataParser
+{
+    DRAGONBONES_DISALLOW_COPY_AND_ASSIGN(BinaryDataParser)
+
+private:
+    unsigned _binaryOffset;
+    const char* _binary;
+    const int16_t* _intArray;
+    const float* _floatArray;
+    const int16_t* _frameIntArray;
+    const float* _frameFloatArray;
+    const int16_t* _frameArray;
+    const uint16_t* _timelineArray;
+
+    TimelineData* _parseBinaryTimeline(TimelineType type, unsigned offset, TimelineData* timelineData = nullptr);
+    void _parseVertices(const rapidjson::Value& rawData, VerticesData& vertices);
+
+protected:
+    virtual void _parseMesh(const rapidjson::Value& rawData, MeshDisplayData& mesh) override;
+    virtual AnimationData* _parseAnimation(const rapidjson::Value& rawData) override;
+    virtual void _parseArray(const rapidjson::Value& rawData) override;
+
+public:
+    BinaryDataParser() :
+        _binaryOffset(0),
+        _binary(nullptr),
+        _intArray(nullptr),
+        _floatArray(nullptr),
+        _frameIntArray(nullptr),
+        _frameFloatArray(nullptr),
+        _frameArray(nullptr),
+        _timelineArray(nullptr)
+    {}
+    virtual ~BinaryDataParser() {}
+
+    virtual DragonBonesData* parseDragonBonesData(const char* rawData, float scale = 1.0f) override;
+};
+
+DRAGONBONES_NAMESPACE_END
+#endif // DRAGONBONES_BINARY_DATA_PARSER_H

cocos2d-x/cocos/editor-support/dragonbones/parser/DataParser.cpp

@@ -0,0 +1,319 @@
+#include "DataParser.h"
+
+DRAGONBONES_NAMESPACE_BEGIN
+
+const char* DataParser::DATA_VERSION_2_3 = "2.3";
+const char* DataParser::DATA_VERSION_3_0 = "3.0";
+const char* DataParser::DATA_VERSION_4_0 = "4.0";
+const char* DataParser::DATA_VERSION_4_5 = "4.5";
+const char* DataParser::DATA_VERSION_5_0 = "5.0";
+const char* DataParser::DATA_VERSION_5_5 = "5.5";
+const char* DataParser::DATA_VERSION = DataParser::DATA_VERSION_5_5;
+
+const std::vector<std::string> DataParser::DATA_VERSIONS
+{ 
+    DataParser::DATA_VERSION_4_0,
+    DataParser::DATA_VERSION_4_5,
+    DataParser::DATA_VERSION_5_0,
+    DataParser::DATA_VERSION_5_5
+};
+
+const char* DataParser::TEXTURE_ATLAS = "TextureAtlas";
+const char* DataParser::SUB_TEXTURE = "SubTexture";
+const char* DataParser::FORMAT = "format";
+const char* DataParser::IMAGE_PATH = "imagePath";
+const char* DataParser::WIDTH = "width";
+const char* DataParser::HEIGHT = "height";
+const char* DataParser::ROTATED = "rotated";
+const char* DataParser::FRAME_X = "frameX";
+const char* DataParser::FRAME_Y = "frameY";
+const char* DataParser::FRAME_WIDTH = "frameWidth";
+const char* DataParser::FRAME_HEIGHT = "frameHeight";
+
+const char* DataParser::DRADON_BONES = "dragonBones";
+const char* DataParser::USER_DATA = "userData";
+const char* DataParser::ARMATURE = "armature";
+const char* DataParser::BONE = "bone";
+const char* DataParser::SLOT = "slot";
+const char* DataParser::CONSTRAINT = "constraint";
+const char* DataParser::IK = "ik";
+const char* DataParser::SKIN = "skin";
+const char* DataParser::DISPLAY = "display";
+const char* DataParser::ANIMATION = "animation";
+const char* DataParser::Z_ORDER = "zOrder";
+const char* DataParser::FFD = "ffd";
+const char* DataParser::FRAME = "frame";
+const char* DataParser::TRANSLATE_FRAME = "translateFrame";
+const char* DataParser::ROTATE_FRAME = "rotateFrame";
+const char* DataParser::SCALE_FRAME = "scaleFrame";
+const char* DataParser::DISPLAY_FRAME = "displayFrame";
+const char* DataParser::COLOR_FRAME = "colorFrame";
+const char* DataParser::DEFAULT_ACTIONS = "defaultActions";
+const char* DataParser::ACTIONS = "actions";
+const char* DataParser::EVENTS = "events";
+const char* DataParser::INTS = "ints";
+const char* DataParser::FLOATS = "floats";
+const char* DataParser::STRINGS = "strings";
+const char* DataParser::CANVAS = "canvas";
+
+const char* DataParser::TRANSFORM = "transform";
+const char* DataParser::PIVOT = "pivot";
+const char* DataParser::AABB = "aabb";
+const char* DataParser::COLOR = "color";
+
+const char* DataParser::VERSION = "version";
+const char* DataParser::COMPATIBLE_VERSION = "compatibleVersion";
+const char* DataParser::FRAME_RATE = "frameRate";
+const char* DataParser::TYPE = "type";
+const char* DataParser::SUB_TYPE = "subType";
+const char* DataParser::NAME = "name";
+const char* DataParser::PARENT = "parent";
+const char* DataParser::TARGET = "target";
+const char* DataParser::STAGE = "stage";
+const char* DataParser::SHARE = "share";
+const char* DataParser::PATH = "path";
+const char* DataParser::LENGTH = "length";
+const char* DataParser::DISPLAY_INDEX = "displayIndex";
+const char* DataParser::BLEND_MODE = "blendMode";
+const char* DataParser::INHERIT_TRANSLATION = "inheritTranslation";
+const char* DataParser::INHERIT_ROTATION = "inheritRotation";
+const char* DataParser::INHERIT_SCALE = "inheritScale";
+const char* DataParser::INHERIT_REFLECTION = "inheritReflection";
+const char* DataParser::INHERIT_ANIMATION = "inheritAnimation";
+const char* DataParser::INHERIT_DEFORM = "inheritDeform";
+const char* DataParser::BEND_POSITIVE = "bendPositive";
+const char* DataParser::CHAIN = "chain";
+const char* DataParser::WEIGHT = "weight";
+
+const char* DataParser::FADE_IN_TIME = "fadeInTime";
+const char* DataParser::PLAY_TIMES = "playTimes";
+const char* DataParser::SCALE = "scale";
+const char* DataParser::OFFSET = "offset";
+const char* DataParser::POSITION = "position";
+const char* DataParser::DURATION = "duration";
+const char* DataParser::TWEEN_EASING = "tweenEasing";
+const char* DataParser::TWEEN_ROTATE = "tweenRotate";
+const char* DataParser::TWEEN_SCALE = "tweenScale";
+const char* DataParser::CLOCK_WISE = "clockwise";
+const char* DataParser::CURVE = "curve";
+const char* DataParser::EVENT = "event";
+const char* DataParser::SOUND = "sound";
+const char* DataParser::ACTION = "action";
+
+const char* DataParser::X = "x";
+const char* DataParser::Y = "y";
+const char* DataParser::SKEW_X = "skX";
+const char* DataParser::SKEW_Y = "skY";
+const char* DataParser::SCALE_X = "scX";
+const char* DataParser::SCALE_Y = "scY";
+const char* DataParser::VALUE = "value";
+const char* DataParser::ROTATE = "rotate";
+const char* DataParser::SKEW = "skew";
+
+const char* DataParser::ALPHA_OFFSET = "aO";
+const char* DataParser::RED_OFFSET = "rO";
+const char* DataParser::GREEN_OFFSET = "gO";
+const char* DataParser::BLUE_OFFSET = "bO";
+const char* DataParser::ALPHA_MULTIPLIER = "aM";
+const char* DataParser::RED_MULTIPLIER = "rM";
+const char* DataParser::GREEN_MULTIPLIER = "gM";
+const char* DataParser::BLUE_MULTIPLIER = "bM";
+
+const char* DataParser::UVS = "uvs";
+const char* DataParser::VERTICES = "vertices";
+const char* DataParser::TRIANGLES = "triangles";
+const char* DataParser::WEIGHTS = "weights";
+const char* DataParser::SLOT_POSE = "slotPose";
+const char* DataParser::BONE_POSE = "bonePose";
+
+const char* DataParser::GOTO_AND_PLAY = "gotoAndPlay";
+
+const char* DataParser::DEFAULT_NAME = "default";
+
+TextureFormat DataParser::_getTextureFormat(const std::string& value)
+{
+    auto lower = value;
+    std::transform(lower.begin(), lower.end(), lower.begin(), ::tolower);
+
+    if (lower == "rgba8888")
+    {
+        return TextureFormat::RGBA8888;
+    }
+    else if (lower == "bgra8888")
+    {
+        return TextureFormat::BGRA8888;
+    }
+    else if (lower == "rgba4444")
+    {
+        return TextureFormat::RGBA4444;
+    }
+    else if (lower == "rgb888")
+    {
+        return TextureFormat::RGB888;
+    }
+    else if (lower == "rgb565")
+    {
+        return TextureFormat::RGB565;
+    }
+    else if (lower == "rgba5551")
+    {
+        return TextureFormat::RGBA5551;
+    }
+
+    return TextureFormat::DEFAULT;
+}
+
+ArmatureType DataParser::_getArmatureType(const std::string& value)
+{
+    auto lower = value;
+    std::transform(lower.begin(), lower.end(), lower.begin(), ::tolower);
+
+    if (lower == "armature")
+    {
+        return ArmatureType::Armature;
+    }
+    else if (lower == "movieClip")
+    {
+        return ArmatureType::MovieClip;
+    }
+    else if (lower == "stage")
+    {
+        return ArmatureType::Stage;
+    }
+
+    return ArmatureType::Armature;
+}
+
+DisplayType DataParser::_getDisplayType(const std::string& value)
+{
+    auto lower = value;
+    std::transform(lower.begin(), lower.end(), lower.begin(), ::tolower);
+
+    if (lower == "image")
+    {
+        return DisplayType::Image;
+    }
+    else if (lower == "armature")
+    {
+        return DisplayType::Armature;
+    }
+    else if (lower == "mesh")
+    {
+        return DisplayType::Mesh;
+    }
+    else if (lower == "boundingbox")
+    {
+        return DisplayType::BoundingBox;
+    }
+
+    return DisplayType::Image;
+}
+
+BoundingBoxType DataParser::_getBoundingBoxType(const std::string & value)
+{
+    auto lower = value;
+    std::transform(lower.begin(), lower.end(), lower.begin(), ::tolower);
+
+    if (lower == "rectangle")
+    {
+        return BoundingBoxType::Rectangle;
+    }
+    else if (lower == "ellipse")
+    {
+        return BoundingBoxType::Ellipse;
+    }
+    else if (lower == "polygon")
+    {
+        return BoundingBoxType::Polygon;
+    }
+
+    return BoundingBoxType::Rectangle;
+}
+
+ActionType DataParser::_getActionType(const std::string& value)
+{
+    auto lower = value;
+    std::transform(lower.begin(), lower.end(), lower.begin(), ::tolower);
+
+    if (lower == "play")
+    {
+        return ActionType::Play;
+    }
+    else if (lower == "frame")
+    {
+        return ActionType::Frame;
+    }
+    else if (lower == "sound")
+    {
+        return ActionType::Sound;
+    }
+
+    return ActionType::Play;
+}
+
+BlendMode DataParser::_getBlendMode(const std::string& value)
+{
+    auto lower = value;
+    std::transform(lower.begin(), lower.end(), lower.begin(), ::tolower);
+
+    if (lower == "normal")
+    {
+        return BlendMode::Normal;
+    }
+    else if (lower == "add")
+    {
+        return BlendMode::Add;
+    }
+    else if (lower == "alpha")
+    {
+        return BlendMode::Alpha;
+    }
+    else if (lower == "darken")
+    {
+        return BlendMode::Darken;
+    }
+    else if (lower == "difference")
+    {
+        return BlendMode::Difference;
+    }
+    else if (lower == "erase")
+    {
+        return BlendMode::Erase;
+    }
+    else if (lower == "hardlight")
+    {
+        return BlendMode::HardLight;
+    }
+    else if (lower == "invert")
+    {
+        return BlendMode::Invert;
+    }
+    else if (lower == "layer")
+    {
+        return BlendMode::Layer;
+    }
+    else if (lower == "lighten")
+    {
+        return BlendMode::Lighten;
+    }
+    else if (lower == "multiply")
+    {
+        return BlendMode::Multiply;
+    }
+    else if (lower == "overlay")
+    {
+        return BlendMode::Overlay;
+    }
+    else if (lower == "screen")
+    {
+        return BlendMode::Screen;
+    }
+    else if (lower == "subtract")
+    {
+        return BlendMode::Subtract;
+    }
+
+    return BlendMode::Normal;
+}
+
+DRAGONBONES_NAMESPACE_END

cocos2d-x/cocos/editor-support/dragonbones/parser/DataParser.h

@@ -0,0 +1,182 @@
+/**
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2012-2018 DragonBones team and other contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+#ifndef DRAGONBONES_DATA_PARSER_H
+#define DRAGONBONES_DATA_PARSER_H
+
+#include "../core/DragonBones.h"
+#include "../model/UserData.h"
+#include "../model/DragonBonesData.h"
+#include "../model/ArmatureData.h"
+#include "../model/CanvasData.h"
+#include "../model/ConstraintData.h"
+#include "../model/SkinData.h"
+#include "../model/DisplayData.h"
+#include "../model/BoundingBoxData.h"
+#include "../model/AnimationData.h"
+#include "../model/TextureAtlasData.h"
+
+DRAGONBONES_NAMESPACE_BEGIN
+/**
+ * @internal
+ */
+class DataParser
+{
+    ABSTRACT_CLASS(DataParser)
+
+protected:
+    static const char* DATA_VERSION_2_3;
+    static const char* DATA_VERSION_3_0;
+    static const char* DATA_VERSION_4_0;
+    static const char* DATA_VERSION_4_5;
+    static const char* DATA_VERSION_5_0;
+    static const char* DATA_VERSION_5_5;
+    static const char* DATA_VERSION;
+
+    static const std::vector<std::string> DATA_VERSIONS;
+
+    static const char* TEXTURE_ATLAS;
+    static const char* SUB_TEXTURE;
+    static const char* FORMAT;
+    static const char* IMAGE_PATH;
+    static const char* WIDTH;
+    static const char* HEIGHT;
+    static const char* ROTATED;
+    static const char* FRAME_X;
+    static const char* FRAME_Y;
+    static const char* FRAME_WIDTH;
+    static const char* FRAME_HEIGHT;
+
+    static const char* DRADON_BONES;
+    static const char* USER_DATA;
+    static const char* ARMATURE;
+    static const char* BONE;
+    static const char* SLOT;
+    static const char* CONSTRAINT;
+    static const char* IK;
+    static const char* SKIN;
+    static const char* DISPLAY;
+    static const char* ANIMATION;
+    static const char* Z_ORDER;
+    static const char* FFD;
+    static const char* FRAME;
+    static const char* TRANSLATE_FRAME;
+    static const char* ROTATE_FRAME;
+    static const char* SCALE_FRAME;
+    static const char* DISPLAY_FRAME;
+    static const char* COLOR_FRAME;
+    static const char* DEFAULT_ACTIONS;
+    static const char* ACTIONS;
+    static const char* EVENTS;
+    static const char* INTS;
+    static const char* FLOATS;
+    static const char* STRINGS;
+    static const char* CANVAS;
+
+    static const char* PIVOT;
+    static const char* TRANSFORM;
+    static const char* AABB;
+    static const char* COLOR;
+
+    static const char* VERSION;
+    static const char* COMPATIBLE_VERSION;
+    static const char* FRAME_RATE;
+    static const char* TYPE;
+    static const char* SUB_TYPE;
+    static const char* NAME;
+    static const char* PARENT;
+    static const char* TARGET;
+    static const char* STAGE;
+    static const char* SHARE;
+    static const char* PATH;
+    static const char* LENGTH;
+    static const char* DISPLAY_INDEX;
+    static const char* BLEND_MODE;
+    static const char* INHERIT_TRANSLATION;
+    static const char* INHERIT_ROTATION;
+    static const char* INHERIT_SCALE;
+    static const char* INHERIT_REFLECTION;
+    static const char* INHERIT_ANIMATION;
+    static const char* INHERIT_DEFORM;
+    static const char* BEND_POSITIVE;
+    static const char* CHAIN;
+    static const char* WEIGHT;
+
+    static const char* FADE_IN_TIME;
+    static const char* PLAY_TIMES;
+    static const char* SCALE;
+    static const char* OFFSET;
+    static const char* POSITION;
+    static const char* DURATION;
+    static const char* TWEEN_EASING;
+    static const char* TWEEN_ROTATE;
+    static const char* TWEEN_SCALE;
+    static const char* CLOCK_WISE;
+    static const char* CURVE;
+    static const char* EVENT;
+    static const char* SOUND;
+    static const char* ACTION;
+
+    static const char* X;
+    static const char* Y;
+    static const char* SKEW_X;
+    static const char* SKEW_Y;
+    static const char* SCALE_X;
+    static const char* SCALE_Y;
+    static const char* VALUE;
+    static const char* ROTATE;
+    static const char* SKEW;
+
+    static const char* ALPHA_OFFSET;
+    static const char* RED_OFFSET;
+    static const char* GREEN_OFFSET;
+    static const char* BLUE_OFFSET;
+    static const char* ALPHA_MULTIPLIER;
+    static const char* RED_MULTIPLIER;
+    static const char* GREEN_MULTIPLIER;
+    static const char* BLUE_MULTIPLIER;
+
+    static const char* UVS;
+    static const char* VERTICES;
+    static const char* TRIANGLES;
+    static const char* WEIGHTS;
+    static const char* SLOT_POSE;
+    static const char* BONE_POSE;
+
+    static const char* GOTO_AND_PLAY;
+
+    static const char* DEFAULT_NAME;
+
+    static TextureFormat _getTextureFormat(const std::string& value);
+    static ArmatureType _getArmatureType(const std::string& value);
+    static DisplayType _getDisplayType(const std::string& value);
+    static BoundingBoxType _getBoundingBoxType(const std::string& value);
+    static ActionType _getActionType(const std::string& value);
+    static BlendMode _getBlendMode(const std::string& value);
+
+public:
+    virtual DragonBonesData* parseDragonBonesData(const char* rawData, float scale = 1.0f) = 0;
+    virtual bool parseTextureAtlasData(const char* rawData, TextureAtlasData& textureAtlasData, float scale = 1.0f) = 0;
+};
+
+DRAGONBONES_NAMESPACE_END
+#endif // DRAGONBONES_DATA_PARSER_H

cocos2d-x/cocos/editor-support/dragonbones/parser/JSONDataParser.h

@@ -0,0 +1,270 @@
+#ifndef DRAGONBONES_JSON_DATA_PARSER_H
+#define DRAGONBONES_JSON_DATA_PARSER_H
+
+#include "DataParser.h"
+#include "json/document.h"
+
+DRAGONBONES_NAMESPACE_BEGIN
+
+class ActionFrame 
+{
+public:
+    unsigned frameStart;
+    std::vector<unsigned> actions;
+
+    bool operator < (const ActionFrame& b) const
+    {
+        return frameStart < b.frameStart;
+    }
+};
+
+class JSONDataParser : public DataParser
+{
+    DRAGONBONES_DISALLOW_COPY_AND_ASSIGN(JSONDataParser)
+
+protected:
+    inline static bool _getBoolean(const rapidjson::Value& rawData, const char* key, bool defaultValue)
+    {
+        if (rawData.HasMember(key))
+        {
+            const auto& value = rawData[key];
+            if (value.IsBool())
+            {
+                return value.GetBool();
+            }
+            else if (value.IsString())
+            {
+                const std::string stringValue = value.GetString();
+                if (
+                    stringValue == "0" ||
+                    stringValue == "NaN" ||
+                    stringValue == "" ||
+                    stringValue == "false" ||
+                    stringValue == "null" ||
+                    stringValue == "undefined"
+                )
+                {
+                    return false;
+                }
+
+                return true;
+            }
+            else if (value.IsNumber())
+            {
+                return value.GetInt() != 0;
+            }
+        }
+
+        return defaultValue;
+    }
+
+    inline static unsigned _getNumber(const rapidjson::Value& rawData, const char* key, unsigned defaultValue)
+    {
+        if (rawData.HasMember(key))
+        {
+            return rawData[key].GetUint();
+        }
+
+        return defaultValue;
+    }
+
+    inline static int _getNumber(const rapidjson::Value& rawData, const char* key, int defaultValue)
+    {
+        if (rawData.HasMember(key))
+        {
+            return rawData[key].GetInt();
+        }
+
+        return defaultValue;
+    }
+
+    inline static float _getNumber(const rapidjson::Value& rawData, const char* key, float defaultValue)
+    {
+        if (rawData.HasMember(key) && rawData[key].IsNumber())
+        {
+            return rawData[key].GetDouble(); // cocos can not support GetFloat();
+        }
+
+        return defaultValue;
+    }
+
+    inline static std::string _getString(const rapidjson::Value& rawData, const char* key, const std::string& defaultValue)
+    {
+        if (rawData.HasMember(key))
+        {
+            if (rawData[key].IsString())
+            {
+                return rawData[key].GetString();
+            }
+
+            return dragonBones::to_string(rawData[key].GetDouble());
+        }
+
+        return defaultValue;
+    }
+
+    inline static int _getParameter(const rapidjson::Value& rawData, std::size_t index, int defaultValue)
+    {
+        if (rawData.Size() > index)
+        {
+            return rawData[(int) index].GetInt();
+        }
+
+        return defaultValue;
+    }
+
+    inline static float _getParameter(const rapidjson::Value& rawData, std::size_t index, float defaultValue)
+    {
+        if (rawData.Size() > index)
+        {
+            return rawData[(int) index].GetDouble();
+        }
+
+        return defaultValue;
+    }
+
+    inline static std::string _getParameter(const rapidjson::Value& rawData, std::size_t index, const std::string& defaultValue)
+    {
+        if (rawData.Size() > index)
+        {
+            return rawData[(int) index].GetString();
+        }
+
+        return defaultValue;
+    }
+
+protected:
+    unsigned _rawTextureAtlasIndex;
+    std::vector<BoneData*> _rawBones;
+    DragonBonesData* _data;
+    ArmatureData* _armature;
+    BoneData* _bone;
+    SlotData* _slot;
+    SkinData* _skin;
+    MeshDisplayData* _mesh;
+    AnimationData* _animation;
+    TimelineData* _timeline;
+    rapidjson::Value* _rawTextureAtlases;
+
+private:
+    int _defaultColorOffset;
+    int _prevClockwise;
+    float _prevRotation;
+    Matrix _helpMatrixA;
+    Matrix _helpMatrixB;
+    Transform _helpTransform;
+    ColorTransform _helpColorTransform;
+    Point _helpPoint;
+    std::vector<float> _helpArray;
+    std::vector<std::int16_t> _intArray;
+    std::vector<float> _floatArray;
+    std::vector<std::int16_t> _frameIntArray;
+    std::vector<float> _frameFloatArray;
+    std::vector<std::int16_t> _frameArray;
+    std::vector<std::uint16_t> _timelineArray;
+    std::vector<const rapidjson::Value*> _cacheRawMeshes;
+    std::vector<MeshDisplayData*> _cacheMeshes;
+    std::vector<ActionFrame> _actionFrames;
+    std::map<std::string, const rapidjson::Value*> _weightSlotPose;
+    std::map<std::string, const rapidjson::Value*> _weightBonePoses;
+    std::map<std::string, std::vector<BoneData*>> _cacheBones;
+    std::map<std::string, std::vector<ActionData*>> _slotChildActions;
+
+public:
+    JSONDataParser() :
+        _rawTextureAtlasIndex(0),
+        _rawBones(),
+        _data(nullptr),
+        _armature(nullptr),
+        _bone(nullptr),
+        _slot(nullptr),
+        _skin(nullptr),
+        _mesh(nullptr),
+        _animation(nullptr),
+        _timeline(nullptr),
+        _rawTextureAtlases(nullptr),
+
+        _defaultColorOffset(-1),
+        _prevClockwise(0),
+        _prevRotation(0.0f),
+        _helpMatrixA(),
+        _helpMatrixB(),
+        _helpTransform(),
+        _helpColorTransform(),
+        _helpPoint(),
+        _helpArray(),
+        _intArray(),
+        _floatArray(),
+        _frameIntArray(),
+        _frameFloatArray(),
+        _frameArray(),
+        _timelineArray(),
+        _cacheMeshes(),
+        _cacheRawMeshes(),
+        _actionFrames(),
+        _weightSlotPose(),
+        _weightBonePoses(),
+        _cacheBones(),
+        _slotChildActions()
+    {
+    }
+    virtual ~JSONDataParser()
+    {
+    }
+
+private:
+    void _getCurvePoint(
+        float x1, float y1, float x2, float y2, float x3, float y3, float x4, float y4, 
+        float t,
+        Point& result
+    );
+    void _samplingEasingCurve(const rapidjson::Value& curve, std::vector<float>& samples);
+    void _parseActionDataInFrame(const rapidjson::Value& rawData, unsigned frameStart, BoneData* bone, SlotData* slot);
+    void _mergeActionFrame(const rapidjson::Value& rawData, unsigned frameStart, ActionType type, BoneData* bone, SlotData* slot);
+    unsigned _parseCacheActionFrame(ActionFrame& frame);
+
+protected:
+    virtual ArmatureData* _parseArmature(const rapidjson::Value& rawData, float scale);
+    virtual BoneData* _parseBone(const rapidjson::Value& rawData);
+    virtual ConstraintData* _parseIKConstraint(const rapidjson::Value& rawData);
+    virtual SlotData* _parseSlot(const rapidjson::Value& rawData, int zOrder);
+    virtual SkinData* _parseSkin(const rapidjson::Value& rawData);
+    virtual DisplayData* _parseDisplay(const rapidjson::Value& rawData);
+    virtual void _parsePivot(const rapidjson::Value& rawData, ImageDisplayData& display);
+    virtual void _parseMesh(const rapidjson::Value& rawData, MeshDisplayData& mesh);
+    virtual BoundingBoxData* _parseBoundingBox(const rapidjson::Value& rawData);
+    virtual PolygonBoundingBoxData* _parsePolygonBoundingBox(const rapidjson::Value& rawData);
+    virtual AnimationData* _parseAnimation(const rapidjson::Value& rawData);
+    virtual TimelineData* _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
+    );
+    virtual void _parseBoneTimeline(const rapidjson::Value& rawData);
+    virtual void _parseSlotTimeline(const rapidjson::Value& rawData);
+    virtual unsigned _parseFrame(const rapidjson::Value& rawData, unsigned frameStart, unsigned frameCount);
+    virtual unsigned _parseTweenFrame(const rapidjson::Value& rawData, unsigned frameStart, unsigned frameCount);
+    virtual unsigned _parseActionFrame(const ActionFrame& rawData, unsigned frameStart, unsigned frameCount);
+    virtual unsigned _parseZOrderFrame(const rapidjson::Value& rawData, unsigned frameStart, unsigned frameCount);
+    virtual unsigned _parseBoneAllFrame(const rapidjson::Value& rawData, unsigned frameStart, unsigned frameCount);
+    virtual unsigned _parseBoneTranslateFrame(const rapidjson::Value& rawData, unsigned frameStart, unsigned frameCount);
+    virtual unsigned _parseBoneRotateFrame(const rapidjson::Value& rawData, unsigned frameStart, unsigned frameCount);
+    virtual unsigned _parseBoneScaleFrame(const rapidjson::Value& rawData, unsigned frameStart, unsigned frameCount);
+    virtual unsigned _parseSlotDisplayFrame(const rapidjson::Value& rawData, unsigned frameStart, unsigned frameCount);
+    virtual unsigned _parseSlotColorFrame(const rapidjson::Value& rawData, unsigned frameStart, unsigned frameCount);
+    virtual unsigned _parseSlotFFDFrame(const rapidjson::Value& rawData, unsigned frameStart, unsigned frameCount);
+    virtual unsigned _parseIKConstraintFrame(const rapidjson::Value& rawData, unsigned frameStart, unsigned frameCount);
+    virtual const std::vector<ActionData*>& _parseActionData(const rapidjson::Value& rawData, ActionType type, BoneData* bone, SlotData* slot);
+    virtual void _parseTransform(const rapidjson::Value& rawData, Transform& transform, float scale);
+    virtual void _parseColorTransform(const rapidjson::Value& rawData, ColorTransform& color);
+    virtual void _parseArray(const rapidjson::Value& rawData);
+    virtual DragonBonesData* _parseDragonBonesData(const rapidjson::Value& rawData, float scale = 1.0f);
+    virtual void _parseTextureAtlasData(const rapidjson::Value& rawData, TextureAtlasData& textureAtlasData, float scale = 1.0f);
+
+public:
+    virtual DragonBonesData* parseDragonBonesData(const char* rawData, float scale = 1.0f) override;
+    virtual bool parseTextureAtlasData(const char* rawData, TextureAtlasData& textureAtlasData, float scale = 1.0f) override;
+};
+
+DRAGONBONES_NAMESPACE_END
+#endif // DRAGONBONES_JSON_DATA_PARSER_H