class ArmatureDataManager : public cocosd::Ref
 {
 public:
 //單例 
 static ArmatureDataManager *getInstance();
 static void destroyInstance();
 public:
 void addArmatureData(const std::string& id, ArmatureData *armatureData, const std::string& configFilePath = "");
 ArmatureData *getArmatureData(const std::string& id);
 void removeArmatureData(const std::string& id);
 void addAnimationData(const std::string& id, AnimationData *animationData, const std::string& configFilePath = "");
 AnimationData *getAnimationData(const std::string& id);
 void removeAnimationData(const std::string& id);
 void addTextureData(const std::string& id, TextureData *textureData, const std::string& configFilePath = "");
 TextureData *getTextureData(const std::string& id);
 void removeTextureData(const std::string& id);
 void addArmatureFileInfo(const std::string& configFilePath);
 const cocosd::Map& getArmatureDatas() const;
 const cocosd::Map& getAnimationDatas() const;
 const cocosd::Map& getTextureDatas() const;
 protected:
 void addRelativeData(const std::string& configFilePath);
 RelativeData *getRelativeData(const std::string& configFilePath);
 private:
 cocosd::Map _armarureDatas;
 cocosd::Map _animationDatas;
 cocosd::Map _textureDatas;
 std::unordered_map _relativeDatas;
 };

class Armature: public cocosd::Node, public cocosd::BlendProtocol {
 protected:
 //要展示動畫的ArmatureData
 ArmatureData *_armatureData;
 BatchNode *_batchNode;
 Bone *_parentBone;
 float _version;
 mutable bool _armatureTransformDirty;
 //所有Bone
 cocosd::Map _boneDic; cocosd::Vector _topBoneList;
 
 cocosd::BlendFunc _blendFunc; 
 cocosd::Vec _offsetPoint;
 cocosd::Vec _realAnchorPointInPoints;
 //動畫控制器
 ArmatureAnimation *_animation;
 };

class Bone: public cocosd::Node {
 protected:
 BoneData *_boneData;
 
 //! A weak reference to the Armature
 Armature *_armature;
 
 //! A weak reference to the child Armature
 Armature *_childArmature;
 
 DisplayManager *_displayManager;
 
 /*
 * When Armature play an animation, if there is not a MovementBoneData of this bone in this MovementData, this bone will be hidden.
 * Set IgnoreMovementBoneData to true, then this bone will also be shown.
 */
 bool _ignoreMovementBoneData;
 
 cocosd::BlendFunc _blendFunc;
 bool _blendDirty;
 
 Tween *_tween; //! Calculate tween effect
 
 //! Used for making tween effect in every frame
 FrameData *_tweenData;
 
 Bone *_parentBone; //! A weak reference to its parent
 bool _boneTransformDirty; //! Whether or not transform dirty
 
 //! self Transform, use this to change display's state
 cocosd::Mat _worldTransform;
 
 BaseData *_worldInfo;
 
 //! Armature's parent bone
 Bone *_armatureParentBone;
 
 };

class Tween : public ProcessBase{
 protected:
 //! A weak reference to the current MovementBoneData. The data is in the data pool
 MovementBoneData *_movementBoneData;
 
 FrameData *_tweenData; //! The computational tween frame data, //! A weak reference to the Bone's tweenData
 FrameData *_from; //! From frame data, used for calculate between value
 FrameData *_to; //! To frame data, used for calculate between value
 
 // total diff guan
 FrameData *_between; //! Between frame data, used for calculate current FrameData(m_pNode) value
 
 Bone *_bone; //! A weak reference to the Bone
 
 TweenType _frameTweenEasing; //! Dedermine which tween effect current frame use
 
 int _betweenDuration; //! Current key frame will last _betweenDuration frames
 
 // 總共運行了多少幀 guan
 int _totalDuration;
 
 int _fromIndex; //! The current frame index in FrameList of MovementBoneData, it's different from m_iFrameIndex
 int _toIndex; //! The next frame index in FrameList of MovementBoneData, it's different from m_iFrameIndex
 
 ArmatureAnimation *_animation;
 
 bool _passLastFrame; //! If current frame index is more than the last frame's index
 };

class ArmatureAnimation : public ProcessBase {
protected:
 //! AnimationData save all MovementDatas this animation used.
 AnimationData *_animationData;

 MovementData *_movementData; //! MovementData save all MovementFrameDatas this animation used.

 Armature *_armature; //! A weak reference of armature

 std::string _movementID; //! Current movment's name

 int _toIndex; //! The frame index in MovementData->m_pMovFrameDataArr, it's different from m_iFrameIndex.

 cocos2d::Vector _tweenList;
}

void Armature::update(float dt)
 {
 _animation->update(dt);
 for(const auto &bone : _topBoneList) {
 bone->update(dt);
 }
 _armatureTransformDirty = false;
 }

void ArmatureAnimation::update(float dt)
 {
 ProcessBase::update(dt);
 
 for (const auto &tween : _tweenList)
 {
 tween->update(dt);
 }
 //省略一堆代碼
 }

 void Tween::updateHandler()
 {
 //省略一堆代碼
 if (_loopType > ANIMATION_TO_LOOP_BACK)
 {
 percent = updateFrameData(percent);
 }
 
 if(_frameTweenEasing != ::cocosd::tweenfunc::TWEEN_EASING_MAX)
 {
 tweenNodeTo(percent);
 }
 }

 FrameData *Tween::tweenNodeTo(float percent, FrameData *node)
 {
 node = node == nullptr ? _tweenData : node;
 
 if (!_from->isTween)
 {
 percent = ;
 }
 
 node->x = _from->x + percent * _between->x;
 node->y = _from->y + percent * _between->y;
 node->scaleX = _from->scaleX + percent * _between->scaleX;
 node->scaleY = _from->scaleY + percent * _between->scaleY;
 node->skewX = _from->skewX + percent * _between->skewX;
 node->skewY = _from->skewY + percent * _between->skewY;
 
 _bone->setTransformDirty(true);
 
 if (node && _between->isUseColorInfo)
 {
 tweenColorTo(percent, node);
 }
 
 return node;
 }

 void Bone::update(float delta)
 {
 if (_parentBone)
 _boneTransformDirty = _boneTransformDirty || _parentBone->isTransformDirty();
 
 if (_armatureParentBone && !_boneTransformDirty)
 {
 _boneTransformDirty = _armatureParentBone->isTransformDirty();
 }
 
 if (_boneTransformDirty)
 {
 if (_dataVersion >= VERSION_COMBINED)
 {
 TransformHelp::nodeConcat(*_tweenData, *_boneData);
 _tweenData->scaleX -= ;
 _tweenData->scaleY -= ;
 }
 
 _worldInfo->copy(_tweenData);
 
 _worldInfo->x = _tweenData->x + _position.x;
 _worldInfo->y = _tweenData->y + _position.y;
 _worldInfo->scaleX = _tweenData->scaleX * _scaleX;
 _worldInfo->scaleY = _tweenData->scaleY * _scaleY;
 _worldInfo->skewX = _tweenData->skewX + _skewX + _rotationZ_X;
 _worldInfo->skewY = _tweenData->skewY + _skewY - _rotationZ_Y;
 
 if(_parentBone)
 {
 applyParentTransform(_parentBone);
 }
 else
 {
 if (_armatureParentBone)
 {
 applyParentTransform(_armatureParentBone);
 }
 }
 
 TransformHelp::nodeToMatrix(*_worldInfo, _worldTransform);
 
 if (_armatureParentBone)
 {
 _worldTransform = TransformConcat(_worldTransform, _armature->getNodeToParentTransform());
 }
 }
 
 DisplayFactory::updateDisplay(this, delta, _boneTransformDirty || _armature->getArmatureTransformDirty());
 
 for(const auto &obj: _children) {
 Bone *childBone = static_cast(obj);
 childBone->update(delta);
 }
 
 _boneTransformDirty = false;

 void Armature::draw(cocosd::Renderer *renderer, const Mat &transform, uint_t flags)
 {
 if (_parentBone == nullptr && _batchNode == nullptr)
 {
 // CC_NODE_DRAW_SETUP();
 }
 
 
 for (auto& object : _children)
 {
 if (Bone *bone = dynamic_cast(object))
 {
 Node *node = bone->getDisplayRenderNode();
 
 if (nullptr == node)
 continue;
 
 switch (bone->getDisplayRenderNodeType())
 {
 case CS_DISPLAY_SPRITE:
 {
 Skin *skin = static_cast(node);
 skin->updateTransform();
 
 BlendFunc func = bone->getBlendFunc();
 
 if (func.src != _blendFunc.src || func.dst != _blendFunc.dst)
 {
 skin->setBlendFunc(bone->getBlendFunc());
 }
 else
 {
 skin->setBlendFunc(_blendFunc);
 }
 skin->draw(renderer, transform, flags);
 }
 break;
 case CS_DISPLAY_ARMATURE:
 {
 node->draw(renderer, transform, flags);
 }
 break;
 default:
 {
 node->visit(renderer, transform, flags);
 // CC_NODE_DRAW_SETUP();
 }
 break;
 }
 }
 else if(Node *node = dynamic_cast(object))
 {
 node->visit(renderer, transform, flags);
 // CC_NODE_DRAW_SETUP();
 }
 }
 }

{
 Mat mv = Director::getInstance()->getMatrix(MATRIX_STACK_TYPE::MATRIX_STACK_MODELVIEW);
 
 //TODO implement z order
 _quadCommand.init(_globalZOrder, _texture->getName(), getGLProgramState(), _blendFunc, &_quad, , mv);
 renderer->addCommand(&_quadCommand);
 }