Lothario
/
axmol
mirror of https://github.com/axmolengine/axmol.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'develop' of https://github.com/2youyouo2/cocos2d-x into develop 

Conflicts:
	extensions/CocoStudio/Armature/CCArmature.h
	extensions/CocoStudio/Armature/CCBone.h
	extensions/CocoStudio/Armature/animation/CCArmatureAnimation.h
	extensions/CocoStudio/Armature/animation/CCProcessBase.h
	extensions/CocoStudio/Armature/animation/CCTween.h
	extensions/CocoStudio/Armature/datas/CCDatas.h
	extensions/CocoStudio/Armature/display/CCDecorativeDisplay.h
	extensions/CocoStudio/Armature/display/CCDisplayManager.h
	extensions/CocoStudio/Armature/external_tool/CCTexture2DMutable.h
	extensions/CocoStudio/Armature/physics/CCColliderDetector.h
	extensions/CocoStudio/Armature/physics/CCPhysicsWorld.h
	extensions/CocoStudio/Armature/utils/CCArmatureDataManager.h
	extensions/CocoStudio/Armature/utils/CCSpriteFrameCacheHelper.h
This commit is contained in:
yinkaile 2013-09-14 19:54:49 +08:00
parent 6b0d365d91 74bd8b09d6
commit 5e1f91d396
64 changed files with 6004 additions and 5935 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
cocos2d_libs.xcodeproj/project.pbxproj.REMOVED.git-id
View File

@ -1 +1 @@
cee239faffacb79c42a315cc01d4bce887435f5b f8c6e5c68d06d713a92aea4ef3398cb8a3476c17

582
extensions/CocoStudio/Armature/CCArmature.cpp
View File

@ -29,13 +29,20 @@ THE SOFTWARE.
#include "datas/CCDatas.h" #include "datas/CCDatas.h"
#include "display/CCSkin.h" #include "display/CCSkin.h"
namespace cocos2d { namespace extension { namespace armature { #if ENABLE_PHYSICS_BOX2D_DETECT
#include "Box2D/Box2D.h"
#elif ENABLE_PHYSICS_CHIPMUNK_DETECT
#include "chipmunk.h"
#endif
std::map<int, Armature *> Armature::_armatureIndexDic;
Armature *Armature::create() NS_CC_EXT_ARMATURE_BEGIN
std::map<int, CCArmature *> CCArmature::m_sArmatureIndexDic;
CCArmature *CCArmature::create()
{ {
Armature *armature = new Armature(); CCArmature *armature = new CCArmature();
if (armature && armature->init()) if (armature && armature->init())
{ {
armature->autorelease(); armature->autorelease();
@ -46,10 +53,10 @@ Armature *Armature::create()
} }
Armature *Armature::create(const char *_name) CCArmature *CCArmature::create(const char *name)
{ {
Armature *armature = new Armature(); CCArmature *armature = new CCArmature();
if (armature && armature->init(_name)) if (armature && armature->init(name))
{ {
armature->autorelease(); armature->autorelease();
return armature; return armature;
@ -58,9 +65,9 @@ Armature *Armature::create(const char *_name)
return NULL; return NULL;
} }
Armature *Armature::create(const char *name, Bone *parentBone) CCArmature *CCArmature::create(const char *name, CCBone *parentBone)
{ {
Armature *armature = new Armature(); CCArmature *armature = new CCArmature();
if (armature && armature->init(name, parentBone)) if (armature && armature->init(name, parentBone))
{ {
armature->autorelease(); armature->autorelease();
@ -70,100 +77,101 @@ Armature *Armature::create(const char *name, Bone *parentBone)
return NULL; return NULL;
} }
Armature::Armature() CCArmature::CCArmature()
: _animation(NULL) : m_pArmatureData(NULL)
, _armatureData(NULL) , m_pBatchNode(NULL)
, _batchNode(NULL) , m_pAtlas(NULL)
, _atlas(NULL) , m_pParentBone(NULL)
, _parentBone(NULL) , m_bArmatureTransformDirty(true)
, _boneDic(NULL) , m_pBoneDic(NULL)
, _topBoneList(NULL) , m_pTopBoneList(NULL)
, m_pAnimation(NULL)
{ {
} }
Armature::~Armature(void) CCArmature::~CCArmature(void)
{ {
CCLOGINFO("deallocing Armature: %p", this); if(NULL != m_pBoneDic)
if(NULL != _boneDic)
{ {
_boneDic->removeAllObjects(); m_pBoneDic->removeAllObjects();
CC_SAFE_RELEASE(_boneDic); CC_SAFE_DELETE(m_pBoneDic);
} }
if (NULL != _topBoneList) if (NULL != m_pTopBoneList)
{ {
_topBoneList->removeAllObjects(); m_pTopBoneList->removeAllObjects();
CC_SAFE_DELETE(_topBoneList); CC_SAFE_DELETE(m_pTopBoneList);
} }
CC_SAFE_DELETE(_animation); CC_SAFE_DELETE(m_pAnimation);
} }
bool Armature::init() bool CCArmature::init()
{ {
return init(NULL); return init(NULL);
} }
bool Armature::init(const char *name) bool CCArmature::init(const char *name)
{ {
bool bRet = false; bool bRet = false;
do do
{ {
removeAllChildren(); removeAllChildren();
CC_SAFE_DELETE(_animation); CC_SAFE_DELETE(m_pAnimation);
_animation = new ArmatureAnimation(); m_pAnimation = new CCArmatureAnimation();
_animation->init(this); m_pAnimation->init(this);
CC_SAFE_RELEASE(_boneDic); CC_SAFE_DELETE(m_pBoneDic);
_boneDic = new Dictionary(); m_pBoneDic = new Dictionary();
_boneDic->init();
CC_SAFE_DELETE(_topBoneList); CC_SAFE_DELETE(m_pTopBoneList);
_topBoneList = Array::create(); m_pTopBoneList = new Array();
_topBoneList->retain(); m_pTopBoneList->init();
_blendFunc = BlendFunc::ALPHA_PREMULTIPLIED;
_name = name == NULL ? "" : name; m_sBlendFunc.src = CC_BLEND_SRC;
m_sBlendFunc.dst = CC_BLEND_DST;
ArmatureDataManager *armatureDataManager = ArmatureDataManager::sharedArmatureDataManager();
if(_name.length() != 0) m_strName = name == NULL ? "" : name;
CCArmatureDataManager *armatureDataManager = CCArmatureDataManager::sharedArmatureDataManager();
if(m_strName.length() != 0)
{ {
_name = name; m_strName = name;
AnimationData *animationData = armatureDataManager->getAnimationData(name); CCAnimationData *animationData = armatureDataManager->getAnimationData(name);
CCASSERT(animationData, "CCAnimationData not exist! "); CCAssert(animationData, "CCAnimationData not exist! ");
_animation->setAnimationData(animationData); m_pAnimation->setAnimationData(animationData);
ArmatureData *armatureData = armatureDataManager->getArmatureData(name); CCArmatureData *armatureData = armatureDataManager->getArmatureData(name);
CCASSERT(armatureData, ""); CCAssert(armatureData, "");
_armatureData = armatureData; m_pArmatureData = armatureData;
DictElement *_element = NULL; DictElement *_element = NULL;
Dictionary *boneDataDic = armatureData->boneDataDic; Dictionary *boneDataDic = &armatureData->boneDataDic;
CCDICT_FOREACH(boneDataDic, _element) CCDICT_FOREACH(boneDataDic, _element)
{ {
Bone *bone = createBone(_element->getStrKey()); CCBone *bone = createBone(_element->getStrKey());
//! init bone's Tween to 1st movement's 1st frame //! init bone's CCTween to 1st movement's 1st frame
do do
{ {
MovementData *movData = animationData->getMovement(animationData->movementNames.at(0).c_str()); CCMovementData *movData = animationData->getMovement(animationData->movementNames.at(0).c_str());
CC_BREAK_IF(!movData); CC_BREAK_IF(!movData);
MovementBoneData *movBoneData = movData->getMovementBoneData(bone->getName().c_str()); CCMovementBoneData *movBoneData = movData->getMovementBoneData(bone->getName().c_str());
CC_BREAK_IF(!movBoneData || movBoneData->frameList->count() <= 0); CC_BREAK_IF(!movBoneData || movBoneData->frameList.count() <= 0);
FrameData *frameData = movBoneData->getFrameData(0); CCFrameData *frameData = movBoneData->getFrameData(0);
CC_BREAK_IF(!frameData); CC_BREAK_IF(!frameData);
bone->getTweenData()->copy(frameData); bone->getTweenData()->copy(frameData);
@ -177,21 +185,21 @@ bool Armature::init(const char *name)
} }
else else
{ {
_name = "new_armature"; m_strName = "new_armature";
_armatureData = ArmatureData::create(); m_pArmatureData = CCArmatureData::create();
_armatureData->name = _name; m_pArmatureData->name = m_strName;
AnimationData *animationData = AnimationData::create(); CCAnimationData *animationData = CCAnimationData::create();
animationData->name = _name; animationData->name = m_strName;
armatureDataManager->addArmatureData(_name.c_str(), _armatureData); armatureDataManager->addArmatureData(m_strName.c_str(), m_pArmatureData);
armatureDataManager->addAnimationData(_name.c_str(), animationData); armatureDataManager->addAnimationData(m_strName.c_str(), animationData);
_animation->setAnimationData(animationData); m_pAnimation->setAnimationData(animationData);
} }
setShaderProgram(ShaderCache::getInstance()->programForKey(GLProgram::SHADER_NAME_POSITION_TEXTURE_COLOR)); setShaderProgram(CCShaderCache::getInstance()->getProgram(GLProgram::SHADER_NAME_POSITION_TEXTURE_COLOR));
unscheduleUpdate(); unscheduleUpdate();
scheduleUpdate(); scheduleUpdate();
@ -206,33 +214,33 @@ bool Armature::init(const char *name)
return bRet; return bRet;
} }
bool Armature::init(const char *name, Bone *parentBone) bool CCArmature::init(const char *name, CCBone *parentBone)
{ {
_parentBone = parentBone; m_pParentBone = parentBone;
return init(name); return init(name);
} }
Bone *Armature::createBone(const char *boneName) CCBone *CCArmature::createBone(const char *boneName)
{ {
Bone *existedBone = getBone(boneName); CCBone *existedBone = getBone(boneName);
if(existedBone != NULL) if(existedBone != NULL)
return existedBone; return existedBone;
BoneData *boneData = (BoneData *)_armatureData->getBoneData(boneName); CCBoneData *boneData = (CCBoneData *)m_pArmatureData->getBoneData(boneName);
std::string parentName = boneData->parentName; std::string parentName = boneData->parentName;
Bone *bone = NULL; CCBone *bone = NULL;
if( parentName.length() != 0 ) if( parentName.length() != 0 )
{ {
createBone(parentName.c_str()); createBone(parentName.c_str());
bone = Bone::create(boneName); bone = CCBone::create(boneName);
addBone(bone, parentName.c_str()); addBone(bone, parentName.c_str());
} }
else else
{ {
bone = Bone::create(boneName); bone = CCBone::create(boneName);
addBone(bone, ""); addBone(bone, "");
} }
@ -243,90 +251,103 @@ Bone *Armature::createBone(const char *boneName)
} }
void Armature::addBone(Bone *bone, const char *parentName) void CCArmature::addBone(CCBone *bone, const char *parentName)
{ {
CCASSERT( bone != NULL, "Argument must be non-nil"); CCAssert( bone != NULL, "Argument must be non-nil");
CCASSERT(_boneDic->objectForKey(bone->getName()) == NULL, "bone already added. It can't be added again"); CCAssert(m_pBoneDic->objectForKey(bone->getName()) == NULL, "bone already added. It can't be added again");
if (NULL != parentName) if (NULL != parentName)
{ {
Bone *boneParent = (Bone *)_boneDic->objectForKey(parentName); CCBone *boneParent = (CCBone *)m_pBoneDic->objectForKey(parentName);
if (boneParent) if (boneParent)
{ {
boneParent->addChildBone(bone); boneParent->addChildBone(bone);
} }
else else
{ {
if (_parentBone) if (m_pParentBone)
_parentBone->addChildBone(bone); m_pParentBone->addChildBone(bone);
else else
_topBoneList->addObject(bone); m_pTopBoneList->addObject(bone);
} }
} }
else else
{ {
if (_parentBone) if (m_pParentBone)
_parentBone->addChildBone(bone); m_pParentBone->addChildBone(bone);
else else
_topBoneList->addObject(bone); m_pTopBoneList->addObject(bone);
} }
bone->setArmature(this); bone->setArmature(this);
_boneDic->setObject(bone, bone->getName()); m_pBoneDic->setObject(bone, bone->getName());
addChild(bone); addChild(bone);
} }
void Armature::removeBone(Bone *bone, bool recursion) void CCArmature::removeBone(CCBone *bone, bool recursion)
{ {
CCASSERT(bone != NULL, "bone must be added to the bone dictionary!"); CCAssert(bone != NULL, "bone must be added to the bone dictionary!");
bone->setArmature(NULL); bone->setArmature(NULL);
bone->removeFromParent(recursion); bone->removeFromParent(recursion);
if (_topBoneList->containsObject(bone)) if (m_pTopBoneList->containsObject(bone))
{ {
_topBoneList->removeObject(bone); m_pTopBoneList->removeObject(bone);
} }
_boneDic->removeObjectForKey(bone->getName()); m_pBoneDic->removeObjectForKey(bone->getName());
removeChild(bone, true); removeChild(bone, true);
} }
Bone *Armature::getBone(const char *_name) const CCBone *CCArmature::getBone(const char *name) const
{ {
return (Bone *)_boneDic->objectForKey(_name); return (CCBone *)m_pBoneDic->objectForKey(name);
} }
void Armature::changeBoneParent(Bone *bone, const char *parentName) void CCArmature::changeBoneParent(CCBone *bone, const char *parentName)
{ {
CCASSERT(bone != NULL, "bone must be added to the bone dictionary!"); CCAssert(bone != NULL, "bone must be added to the bone dictionary!");
bone->getParentBone()->getChildren()->removeObject(bone); if(bone->getParentBone())
bone->setParentBone(NULL); {
bone->getParentBone()->getChildren()->removeObject(bone);
bone->setParentBone(NULL);
}
if (parentName != NULL) if (parentName != NULL)
{ {
Bone *boneParent = (Bone *)_boneDic->objectForKey(parentName); CCBone *boneParent = (CCBone *)m_pBoneDic->objectForKey(parentName);
if (boneParent) if (boneParent)
{ {
boneParent->addChildBone(bone); boneParent->addChildBone(bone);
if (m_pTopBoneList->containsObject(bone))
{
m_pTopBoneList->removeObject(bone);
}
}
else
{
m_pTopBoneList->addObject(bone);
} }
} }
} }
Dictionary *Armature::getBoneDic() Dictionary *CCArmature::getBoneDic()
{ {
return _boneDic; return m_pBoneDic;
} }
const AffineTransform& Armature::getNodeToParentTransform() const const AffineTransform& CCArmature::getNodeToParentTransform() const
{ {
if (_transformDirty) if (_transformDirty)
{ {
m_bArmatureTransformDirty = true;
// Translate values // Translate values
float x = _position.x; float x = _position.x;
float y = _position.y; float y = _position.y;
@ -352,8 +373,8 @@ const AffineTransform& Armature::getNodeToParentTransform() const
} }
// Add offset point // Add offset point
x += cy * _offsetPoint.x * _scaleX + -sx * _offsetPoint.y * _scaleY; x += cy * m_pOffsetPoint.x * _scaleX + -sx * m_pOffsetPoint.y * _scaleY;
y += sy * _offsetPoint.x * _scaleX + cx * _offsetPoint.y * _scaleY; y += sy * m_pOffsetPoint.x * _scaleX + cx * m_pOffsetPoint.y * _scaleY;
bool needsSkewMatrix = ( _skewX || _skewY ); bool needsSkewMatrix = ( _skewX || _skewY );
@ -401,100 +422,192 @@ const AffineTransform& Armature::getNodeToParentTransform() const
return _transform; return _transform;
} }
void Armature::updateOffsetPoint() void CCArmature::updateOffsetPoint()
{ {
// Set contentsize and Calculate anchor point. // Set contentsize and Calculate anchor point.
Rect rect = getBoundingBox(); Rect rect = boundingBox();
setContentSize(rect.size); setContentSize(rect.size);
_offsetPoint = Point(-rect.origin.x, -rect.origin.y); m_pOffsetPoint = Point(-rect.origin.x, -rect.origin.y);
setAnchorPoint(Point(_offsetPoint.x / rect.size.width, _offsetPoint.y / rect.size.height)); if (rect.size.width != 0 && rect.size.height != 0)
}
void Armature::update(float dt)
{
_animation->update(dt);
Object *object = NULL;
CCARRAY_FOREACH(_topBoneList, object)
{ {
static_cast<Bone*>(object)->update(dt); setAnchorPoint(Point(m_pOffsetPoint.x / rect.size.width, m_pOffsetPoint.y / rect.size.height));
} }
} }
void Armature::draw() void CCArmature::setAnimation(CCArmatureAnimation *animation)
{ {
if (_parentBone == NULL) m_pAnimation = animation;
}
CCArmatureAnimation *CCArmature::getAnimation()
{
return m_pAnimation;
}
bool CCArmature::getArmatureTransformDirty()
{
return m_bArmatureTransformDirty;
}
void CCArmature::update(float dt)
{
m_pAnimation->update(dt);
Object *object = NULL;
CCARRAY_FOREACH(m_pTopBoneList, object)
{
((CCBone *)object)->update(dt);
}
m_bArmatureTransformDirty = false;
}
void CCArmature::draw()
{
if (m_pParentBone == NULL)
{ {
CC_NODE_DRAW_SETUP(); CC_NODE_DRAW_SETUP();
GL::blendFunc(_blendFunc.src, _blendFunc.dst); GL::blendFunc(m_sBlendFunc.src, m_sBlendFunc.dst);
} }
Object *object = NULL; Object *object = NULL;
CCARRAY_FOREACH(_children, object) CCARRAY_FOREACH(_children, object)
{ {
Bone *bone = static_cast<Bone *>(object); if (CCBone *bone = dynamic_cast<CCBone *>(object))
DisplayManager *displayManager = bone->getDisplayManager();
Node *node = displayManager->getDisplayRenderNode();
if (NULL == node)
continue;
if(Skin *skin = dynamic_cast<Skin *>(node))
{ {
TextureAtlas *textureAtlas = skin->getTextureAtlas(); CCDisplayManager *displayManager = bone->getDisplayManager();
if(_atlas != textureAtlas) Node *node = displayManager->getDisplayRenderNode();
if (NULL == node)
continue;
switch (displayManager->getCurrentDecorativeDisplay()->getDisplayData()->displayType)
{ {
if (_atlas) case CS_DISPLAY_SPRITE:
{
CCSkin *skin = (CCSkin *)node;
TextureAtlas *textureAtlas = skin->getTextureAtlas();
CCBlendType blendType = bone->getBlendType();
if(m_pAtlas != textureAtlas || blendType != BLEND_NORMAL)
{ {
_atlas->drawQuads(); if (m_pAtlas)
_atlas->removeAllQuads(); {
m_pAtlas->drawQuads();
m_pAtlas->removeAllQuads();
}
}
m_pAtlas = textureAtlas;
if (m_pAtlas->getCapacity() == m_pAtlas->getTotalQuads() && !m_pAtlas->resizeCapacity(m_pAtlas->getCapacity() * 2))
return;
skin->updateTransform();
if (blendType != BLEND_NORMAL)
{
updateBlendType(blendType);
m_pAtlas->drawQuads();
m_pAtlas->removeAllQuads();
GL::blendFunc(m_sBlendFunc.src, m_sBlendFunc.dst);
} }
} }
break;
_atlas = textureAtlas; case CS_DISPLAY_ARMATURE:
if (_atlas->getCapacity() == _atlas->getTotalQuads() && !_atlas->resizeCapacity(_atlas->getCapacity() * 2))
return;
skin->draw();
}
else if(Armature *armature = dynamic_cast<Armature *>(node))
{
TextureAtlas *textureAtlas = armature->getTextureAtlas();
if(_atlas != textureAtlas)
{ {
if (_atlas) CCArmature *armature = (CCArmature *)(node);
TextureAtlas *textureAtlas = armature->getTextureAtlas();
if(m_pAtlas != textureAtlas)
{ {
_atlas->drawQuads(); if (m_pAtlas)
_atlas->removeAllQuads(); {
m_pAtlas->drawQuads();
m_pAtlas->removeAllQuads();
}
} }
armature->draw();
} }
armature->draw(); break;
} default:
else
{
if (_atlas)
{ {
_atlas->drawQuads(); if (m_pAtlas)
_atlas->removeAllQuads(); {
m_pAtlas->drawQuads();
m_pAtlas->removeAllQuads();
}
node->visit();
CC_NODE_DRAW_SETUP();
GL::blendFunc(m_sBlendFunc.src, m_sBlendFunc.dst);
}
break;
}
}
else if(Node *node = dynamic_cast<Node *>(object))
{
if (m_pAtlas)
{
m_pAtlas->drawQuads();
m_pAtlas->removeAllQuads();
} }
node->visit(); node->visit();
CC_NODE_DRAW_SETUP(); CC_NODE_DRAW_SETUP();
GL::blendFunc(_blendFunc.src, _blendFunc.dst); GL::blendFunc(m_sBlendFunc.src, m_sBlendFunc.dst);
} }
} }
if(_atlas && !_batchNode && _parentBone == NULL) if(m_pAtlas && !m_pBatchNode && m_pParentBone == NULL)
{ {
_atlas->drawQuads(); m_pAtlas->drawQuads();
_atlas->removeAllQuads(); m_pAtlas->removeAllQuads();
} }
} }
void Armature::visit()
void CCArmature::updateBlendType(CCBlendType blendType)
{
BlendFunc blendFunc;
switch (blendType)
{
case BLEND_NORMAL:
{
blendFunc.src = CC_BLEND_SRC;
blendFunc.dst = CC_BLEND_DST;
}
break;
case BLEND_ADD:
{
blendFunc.src = GL_SRC_ALPHA;
blendFunc.dst = GL_ONE;
}
break;
case BLEND_MULTIPLY:
{
blendFunc.src = GL_DST_COLOR;
blendFunc.dst = GL_ONE_MINUS_SRC_ALPHA;
}
break;
case BLEND_SCREEN:
{
blendFunc.src = GL_ONE;
blendFunc.dst = GL_ONE_MINUS_SRC_COLOR;
}
break;
default:
{
blendFunc.src = CC_BLEND_SRC;
blendFunc.dst = CC_BLEND_DST;
}
break;
}
GL::blendFunc(blendFunc.src, blendFunc.dst);
}
void CCArmature::visit()
{ {
// quick return if not visible. children won't be drawn. // quick return if not visible. children won't be drawn.
if (!_visible) if (!_visible)
@ -523,7 +636,7 @@ void Armature::visit()
kmGLPopMatrix(); kmGLPopMatrix();
} }
Rect Armature::getBoundingBox() const Rect CCArmature::getBoundingBox() const
{ {
float minx, miny, maxx, maxy = 0; float minx, miny, maxx, maxy = 0;
@ -534,46 +647,145 @@ Rect Armature::getBoundingBox() const
Object *object = NULL; Object *object = NULL;
CCARRAY_FOREACH(_children, object) CCARRAY_FOREACH(_children, object)
{ {
Bone *bone = static_cast<Bone *>(object); if (CCBone *bone = dynamic_cast<CCBone *>(object))
Rect r = bone->getDisplayManager()->getBoundingBox();
if(first)
{ {
minx = r.getMinX(); Rect r = bone->getDisplayManager()->getBoundingBox();
miny = r.getMinY();
maxx = r.getMaxX();
maxy = r.getMaxY();
first = false; if(first)
} {
else minx = r.getMinX();
{ miny = r.getMinY();
minx = r.getMinX() < boundingBox.getMinX() ? r.getMinX() : boundingBox.getMinX(); maxx = r.getMaxX();
miny = r.getMinY() < boundingBox.getMinY() ? r.getMinY() : boundingBox.getMinY(); maxy = r.getMaxY();
maxx = r.getMaxX() > boundingBox.getMaxX() ? r.getMaxX() : boundingBox.getMaxX();
maxy = r.getMaxY() > boundingBox.getMaxY() ? r.getMaxY() : boundingBox.getMaxY();
}
boundingBox.setRect(minx, miny, maxx - minx, maxy - miny); first = false;
}
else
{
minx = r.getMinX() < boundingBox.getMinX() ? r.getMinX() : boundingBox.getMinX();
miny = r.getMinY() < boundingBox.getMinY() ? r.getMinY() : boundingBox.getMinY();
maxx = r.getMaxX() > boundingBox.getMaxX() ? r.getMaxX() : boundingBox.getMaxX();
maxy = r.getMaxY() > boundingBox.getMaxY() ? r.getMaxY() : boundingBox.getMaxY();
}
boundingBox.setRect(minx, miny, maxx - minx, maxy - miny);
}
} }
return boundingBox; return boundingBox;
} }
Bone *Armature::getBoneAtPoint(float x, float y) CCBone *CCArmature::getBoneAtPoint(float x, float y)
{ {
int length = _children->count(); int length = _children->data->num;
Bone *bs; CCBone **bs = (CCBone **)_children->data->arr;
for(int i = length - 1; i >= 0; i--) for(int i = length - 1; i >= 0; i--)
{ {
bs = static_cast<Bone*>( _children->getObjectAtIndex(i) ); if(bs[i]->getDisplayManager()->containPoint(x, y))
if(bs->getDisplayManager()->containPoint(x, y))
{ {
return bs; return bs[i];
} }
} }
return NULL; return NULL;
} }
}}} // namespace cocos2d { namespace extension { namespace armature { #if ENABLE_PHYSICS_BOX2D_DETECT
b2Body *CCArmature::getBody()
{
return m_pBody;
}
void CCArmature::setBody(b2Body *body)
{
if (m_pBody == body)
{
return;
}
m_pBody = body;
m_pBody->SetUserData(this);
Object *object = NULL;
CCARRAY_FOREACH(_children, object)
{
if (CCBone *bone = dynamic_cast<CCBone *>(object))
{
Array *displayList = bone->getDisplayManager()->getDecorativeDisplayList();
Object *displayObject = NULL;
CCARRAY_FOREACH(displayList, displayObject)
{
CCColliderDetector *detector = ((CCDecorativeDisplay *)displayObject)->getColliderDetector();
if (detector != NULL)
{
detector->setBody(m_pBody);
}
}
}
}
}
b2Fixture *CCArmature::getShapeList()
{
if (m_pBody)
{
return m_pBody->GetFixtureList();
}
else
{
return NULL;
}
}
#elif ENABLE_PHYSICS_CHIPMUNK_DETECT
cpBody *CCArmature::getBody()
{
return m_pBody;
}
void CCArmature::setBody(cpBody *body)
{
if (m_pBody == body)
{
return;
}
m_pBody = body;
m_pBody->data = this;
Object *object = NULL;
CCARRAY_FOREACH(_children, object)
{
if (CCBone *bone = dynamic_cast<CCBone *>(object))
{
Array *displayList = bone->getDisplayManager()->getDecorativeDisplayList();
Object *displayObject = NULL;
CCARRAY_FOREACH(displayList, displayObject)
{
CCColliderDetector *detector = ((CCDecorativeDisplay *)displayObject)->getColliderDetector();
if (detector != NULL)
{
detector->setBody(m_pBody);
}
}
}
}
}
cpShape *CCArmature::getShapeList()
{
if (m_pBody)
{
return m_pBody->shapeList_private;
}
else
{
return NULL;
}
}
#endif
NS_CC_EXT_ARMATURE_END

220
extensions/CocoStudio/Armature/CCArmature.h
View File

@ -21,183 +21,173 @@ 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 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE. THE SOFTWARE.
****************************************************************************/ ****************************************************************************/
#ifndef __CCARMATURE_H__ #ifndef __CCARMATURE_H__
#define __CCARMATURE_H__ #define __CCARMATURE_H__
#include "utils/CCArmatureDefine.h" #include "utils/CCArmatureDefine.h"
#include "CCBone.h" #include "CCBone.h"
#include "display/CCBatchNode.h" #include "display/CCBatchNode.h"
#include "display/CCShaderNode.h"
#include "animation/CCArmatureAnimation.h" #include "animation/CCArmatureAnimation.h"
#include "physics/CCPhysicsWorld.h"
#include "utils/CCSpriteFrameCacheHelper.h"
#include "utils/CCArmatureDataManager.h"
namespace cocos2d { namespace extension { namespace armature { class b2Body;
struct cpBody;
CC_DEPRECATED_ATTRIBUTE typedef ProcessBase CCProcessBase; NS_CC_EXT_ARMATURE_BEGIN
CC_DEPRECATED_ATTRIBUTE typedef BaseData CCBaseData;
CC_DEPRECATED_ATTRIBUTE typedef DisplayData CCDisplayData; class CCArmature : public NodeRGBA, public BlendProtocol
CC_DEPRECATED_ATTRIBUTE typedef SpriteDisplayData CCSpriteDisplayData;
CC_DEPRECATED_ATTRIBUTE typedef ArmatureDisplayData CCArmatureDisplayData;
CC_DEPRECATED_ATTRIBUTE typedef ParticleDisplayData CCParticleDisplayData;
CC_DEPRECATED_ATTRIBUTE typedef ShaderDisplayData CCShaderDisplayData;
CC_DEPRECATED_ATTRIBUTE typedef BoneData CCBoneData;
CC_DEPRECATED_ATTRIBUTE typedef FrameData CCFrameData;
CC_DEPRECATED_ATTRIBUTE typedef MovementBoneData CCMovementBoneData;
CC_DEPRECATED_ATTRIBUTE typedef MovementData CCMovementData;
CC_DEPRECATED_ATTRIBUTE typedef AnimationData CCAnimationData;
CC_DEPRECATED_ATTRIBUTE typedef ContourData CCContourData;
CC_DEPRECATED_ATTRIBUTE typedef TextureData CCTextureData;
CC_DEPRECATED_ATTRIBUTE typedef ShaderNode CCShaderNode;
CC_DEPRECATED_ATTRIBUTE typedef DecorativeDisplay CCDecorativeDisplay;
CC_DEPRECATED_ATTRIBUTE typedef DisplayData CCDisplayData;
CC_DEPRECATED_ATTRIBUTE typedef DisplayFactory CCDisplayFactory;
CC_DEPRECATED_ATTRIBUTE typedef BatchNode CCBatchNode;
CC_DEPRECATED_ATTRIBUTE typedef DecorativeDisplay CCDecorativeDisplay;
CC_DEPRECATED_ATTRIBUTE typedef DisplayManager CCDisplayManager;
CC_DEPRECATED_ATTRIBUTE typedef ColliderBody CCColliderBody;
CC_DEPRECATED_ATTRIBUTE typedef ColliderDetector CCColliderDetector;
CC_DEPRECATED_ATTRIBUTE typedef PhysicsWorld CCPhysicsWorld;
CC_DEPRECATED_ATTRIBUTE typedef SpriteFrameCacheHelper CCSpriteFrameCacheHelper;
CC_DEPRECATED_ATTRIBUTE typedef TweenFunction CCTweenFunction;
CC_DEPRECATED_ATTRIBUTE typedef ArmatureData CCArmatureData;
CC_DEPRECATED_ATTRIBUTE typedef Bone CCBone;
CC_DEPRECATED_ATTRIBUTE typedef ArmatureAnimation CCArmatureAnimation;
CC_DEPRECATED_ATTRIBUTE typedef Armature CCArmature;
CC_DEPRECATED_ATTRIBUTE typedef ArmatureDataManager CCArmatureDataManager;
class Armature : public NodeRGBA, public BlendProtocol
{ {
public: public:
/**
* Allocates and initializes a armature.
* @return A initialized armature which is marked as "autorelease".
*/
static Armature *create();
/**
* Allocates a armature, and use the ArmatureData named name in ArmatureDataManager to initializes the armature.
*
* @param name Armature will use the name to find to the ArmatureData to initializes it.
* @return A initialized armature which is marked as "autorelease".
*/
static Armature *create(const char *name);
static Armature *create(const char *name, Bone *parentBone); /**
* Allocates and initializes an armature.
* @return An initialized armature which is marked as "autorelease".
*/
static CCArmature *create();
/**
* Allocates an armature, and use the CCArmatureData named name in CCArmatureDataManager to initializes the armature.
*
* @param name CCArmature will use the name to find the CCArmatureData to initializes it.
* @return A initialized armature which is marked as "autorelease".
*/
static CCArmature *create(const char *name);
static CCArmature *create(const char *name, CCBone *parentBone);
public: public:
/** CCArmature();
* @js ctor ~CCArmature(void);
*/
Armature();
/**
* @js NA
* @lua NA
*/
virtual ~Armature(void);
/** /**
* Init the empty armature * Init the empty armature
*/ */
virtual bool init(); virtual bool init();
/** /**
* Init a armature with specified name * Init an armature with specified name
* @param name Armature name * @param name CCArmature name
*/ */
virtual bool init(const char *name); virtual bool init(const char *name);
virtual bool init(const char *name, Bone *parentBone); virtual bool init(const char *name, CCBone *parentBone);
/** /**
* Add a Bone to this Armature, * Add a CCBone to this CCArmature,
* *
* @param bone The Bone you want to add to Armature * @param bone The CCBone you want to add to CCArmature
* @param parentName The parent Bone's name you want to add to . If it's NULL, then set Armature to it's parent * @param parentName The parent CCBone's name you want to add to . If it's NULL, then set CCArmature to its parent
*/ */
virtual void addBone(Bone *bone, const char* parentName); virtual void addBone(CCBone *bone, const char *parentName);
/** /**
* Get a bone with the specified name * Get a bone with the specified name
* *
* @param name The bone's name you want to get * @param name The bone's name you want to get
*/ */
virtual Bone *getBone(const char *name) const; virtual CCBone *getBone(const char *name) const;
/** /**
* Change a bone's parent with the specified parent name. * Change a bone's parent with the specified parent name.
* *
* @param bone The bone you want to change parent * @param bone The bone you want to change parent
* @param parentName The new parent's name. * @param parentName The new parent's name.
*/ */
virtual void changeBoneParent(Bone *bone, const char *parentName); virtual void changeBoneParent(CCBone *bone, const char *parentName);
/** /**
* Remove a bone with the specified name. If recursion it will also remove child Bone recursionly. * Remove a bone with the specified name. If recursion it will also remove child CCBone recursionly.
* *
* @param bone The bone you want to remove * @param bone The bone you want to remove
* @param recursion Determine whether remove the bone's child recursion. * @param recursion Determine whether remove the bone's child recursion.
*/ */
virtual void removeBone(Bone *bone, bool recursion); virtual void removeBone(CCBone *bone, bool recursion);
/** /**
* Get Armature's bone dictionary * Get CCArmature's bone dictionary
* @return Armature's bone dictionary * @return CCArmature's bone dictionary
*/ */
Dictionary *getBoneDic(); Dictionary *getBoneDic();
Bone *getBoneAtPoint(float x, float y);
/**
* Set contentsize and Calculate anchor point.
*/
virtual void updateOffsetPoint();
// overrides
/** /**
* @js NA * This boundingBox will calculate all bones' boundingBox every time
* @lua NA
*/ */
virtual void visit() override; virtual Rect getBoundingBox() const;
virtual void update(float dt) override;
virtual void draw() override; CCBone *getBoneAtPoint(float x, float y);
virtual const AffineTransform& getNodeToParentTransform() const override;
/** This boundingBox will calculate all bones' boundingBox every time */ virtual void visit();
virtual Rect getBoundingBox() const override; virtual void update(float dt);
inline void setBlendFunc(const BlendFunc& blendFunc) override { _blendFunc = blendFunc; } virtual void draw();
inline const BlendFunc& getBlendFunc(void) const override { return _blendFunc; }
virtual const AffineTransform& getNodeToParentTransform() const;
/**
* Set contentsize and Calculate anchor point.
*/
virtual void updateOffsetPoint();
inline void setBlendFunc(const BlendFunc &blendFunc)
{
m_sBlendFunc = blendFunc;
}
inline const BlendFunc &getBlendFunc(void) const
{
return m_sBlendFunc;
}
virtual void setAnimation(CCArmatureAnimation *animation);
virtual CCArmatureAnimation *getAnimation();
virtual bool getArmatureTransformDirty();
#if ENABLE_PHYSICS_BOX2D_DETECT
virtual b2Fixture *getShapeList();
#elif ENABLE_PHYSICS_CHIPMUNK_DETECT
virtual cpShape *getShapeList();
#endif
protected: protected:
/* /*
* Used to create Bone internal * Used to create CCBone internal
*/ */
Bone *createBone(const char *boneName ); CCBone *createBone(const char *boneName );
CC_SYNTHESIZE_RETAIN(ArmatureAnimation *, _animation, Animation); //! Update blend function
void updateBlendType(CCBlendType blendType);
CC_SYNTHESIZE(ArmatureData *, _armatureData, ArmatureData);
CC_SYNTHESIZE(BatchNode*, _batchNode, BatchNode); CC_SYNTHESIZE(CCArmatureData *, m_pArmatureData, ArmatureData);
CC_SYNTHESIZE_PASS_BY_REF(std::string, _name, Name); CC_SYNTHESIZE(CCBatchNode *, m_pBatchNode, BatchNode);
CC_SYNTHESIZE(TextureAtlas*, _atlas, TextureAtlas); CC_SYNTHESIZE(std::string, m_strName, Name);
CC_SYNTHESIZE(TextureAtlas *, m_pAtlas, TextureAtlas);
CC_SYNTHESIZE(CCBone *, m_pParentBone, ParentBone);
CC_SYNTHESIZE(float, m_fVersion, Version);
CC_SYNTHESIZE(Bone*, _parentBone, ParentBone);
protected: protected:
Dictionary *_boneDic; //! The dictionary of the bones, include all bones in the armature, no matter it is the direct bone or the indirect bone. It is different from _chindren. mutable bool m_bArmatureTransformDirty;
Array *_topBoneList; Dictionary *m_pBoneDic; //! The dictionary of the bones, include all bones in the armature, no matter it is the direct bone or the indirect bone. It is different from m_pChindren.
static std::map<int, Armature*> _armatureIndexDic; //! Use to save armature zorder info, Array *m_pTopBoneList;
BlendFunc _blendFunc; //! It's required for TextureProtocol inheritance static std::map<int, CCArmature *> m_sArmatureIndexDic; //! Use to save armature zorder info,
Point _offsetPoint; BlendFunc m_sBlendFunc; //! It's required for CCTextureProtocol inheritance
Point m_pOffsetPoint;
CCArmatureAnimation *m_pAnimation;
#if ENABLE_PHYSICS_BOX2D_DETECT
CC_PROPERTY(b2Body *, m_pBody, Body);
#elif ENABLE_PHYSICS_CHIPMUNK_DETECT
CC_PROPERTY(cpBody *, m_pBody, Body);
#endif
}; };
}}} // namespace cocos2d { namespace extension { namespace armature { NS_CC_EXT_ARMATURE_END
#endif /*__CCARMATURE_H__*/ #endif /*__CCARMATURE_H__*/

293
extensions/CocoStudio/Armature/CCBone.cpp
View File

@ -29,12 +29,12 @@ THE SOFTWARE.
#include "utils/CCTransformHelp.h" #include "utils/CCTransformHelp.h"
#include "display/CCDisplayManager.h" #include "display/CCDisplayManager.h"
namespace cocos2d { namespace extension { namespace armature { NS_CC_EXT_ARMATURE_BEGIN
Bone *Bone::create() CCBone *CCBone::create()
{ {
Bone *pBone = new Bone(); CCBone *pBone = new CCBone();
if (pBone && pBone->init()) if (pBone && pBone->init())
{ {
pBone->autorelease(); pBone->autorelease();
@ -45,10 +45,10 @@ Bone *Bone::create()
} }
Bone *Bone::create(const char *name) CCBone *CCBone::create(const char *name)
{ {
Bone *pBone = new Bone(); CCBone *pBone = new CCBone();
if (pBone && pBone->init(name)) if (pBone && pBone->init(name))
{ {
pBone->autorelease(); pBone->autorelease();
@ -58,45 +58,46 @@ Bone *Bone::create(const char *name)
return NULL; return NULL;
} }
Bone::Bone() CCBone::CCBone()
{ {
_tweenData = NULL; m_pTweenData = NULL;
_parent = NULL; m_pParentBone = NULL;
_armature = NULL; m_pArmature = NULL;
_childArmature = NULL; m_pChildArmature = NULL;
_boneData = NULL; m_pBoneData = NULL;
_tween = NULL; m_pTween = NULL;
_tween = NULL; m_pTween = NULL;
_children = NULL; _children = NULL;
_displayManager = NULL; m_pDisplayManager = NULL;
_ignoreMovementBoneData = false; m_bIgnoreMovementBoneData = false;
_worldTransform = AffineTransformMake(1, 0, 0, 1, 0, 0); m_tWorldTransform = AffineTransformMake(1, 0, 0, 1, 0, 0);
_transformDirty = true; m_bBoneTransformDirty = true;
m_eBlendType = BLEND_NORMAL;
} }
Bone::~Bone(void) CCBone::~CCBone(void)
{ {
CC_SAFE_DELETE(_tweenData); CC_SAFE_DELETE(m_pTweenData);
CC_SAFE_DELETE(_children); CC_SAFE_DELETE(_children);
CC_SAFE_DELETE(_tween); CC_SAFE_DELETE(m_pTween);
CC_SAFE_DELETE(_displayManager); CC_SAFE_DELETE(m_pDisplayManager);
if(_boneData) if(m_pBoneData)
{ {
_boneData->release(); m_pBoneData->release();
} }
CC_SAFE_RELEASE(_childArmature); CC_SAFE_RELEASE(m_pChildArmature);
} }
bool Bone::init() bool CCBone::init()
{ {
return Bone::init(NULL); return CCBone::init(NULL);
} }
bool Bone::init(const char *name) bool CCBone::init(const char *name)
{ {
bool bRet = false; bool bRet = false;
do do
@ -104,19 +105,19 @@ bool Bone::init(const char *name)
if(NULL != name) if(NULL != name)
{ {
_name = name; m_strName = name;
} }
CC_SAFE_DELETE(_tweenData); CC_SAFE_DELETE(m_pTweenData);
_tweenData = new FrameData(); m_pTweenData = new CCFrameData();
CC_SAFE_DELETE(_tween); CC_SAFE_DELETE(m_pTween);
_tween = new Tween(); m_pTween = new CCTween();
_tween->init(this); m_pTween->init(this);
CC_SAFE_DELETE(_displayManager); CC_SAFE_DELETE(m_pDisplayManager);
_displayManager = new DisplayManager(); m_pDisplayManager = new CCDisplayManager();
_displayManager->init(this); m_pDisplayManager->init(this);
bRet = true; bRet = true;
@ -126,108 +127,123 @@ bool Bone::init(const char *name)
return bRet; return bRet;
} }
void Bone::setBoneData(BoneData *boneData) void CCBone::setBoneData(CCBoneData *boneData)
{ {
CCASSERT(NULL != boneData, "_boneData must not be NULL"); CCAssert(NULL != boneData, "_boneData must not be NULL");
_boneData = boneData; m_pBoneData = boneData;
_boneData->retain(); m_pBoneData->retain();
_name = _boneData->name; m_strName = m_pBoneData->name;
_ZOrder = _boneData->zOrder; _ZOrder = m_pBoneData->zOrder;
_displayManager->initDisplayList(boneData); m_pDisplayManager->initDisplayList(boneData);
} }
BoneData *Bone::getBoneData() CCBoneData *CCBone::getBoneData()
{ {
return _boneData; return m_pBoneData;
} }
void Bone::setArmature(Armature *armature) void CCBone::setArmature(CCArmature *armature)
{ {
_armature = armature; m_pArmature = armature;
_tween->setAnimation(_armature->getAnimation()); if (m_pArmature)
}
Armature *Bone::getArmature()
{
return _armature;
}
void Bone::update(float delta)
{
if (_parent)
_transformDirty = _transformDirty || _parent->isTransformDirty();
if (_transformDirty)
{ {
float cosX = cos(_tweenData->skewX); m_pTween->setAnimation(m_pArmature->getAnimation());
float cosY = cos(_tweenData->skewY); }
float sinX = sin(_tweenData->skewX); }
float sinY = sin(_tweenData->skewY);
_worldTransform.a = _tweenData->scaleX * cosY;
_worldTransform.b = _tweenData->scaleX * sinY;
_worldTransform.c = _tweenData->scaleY * sinX;
_worldTransform.d = _tweenData->scaleY * cosX;
_worldTransform.tx = _tweenData->x;
_worldTransform.ty = _tweenData->y;
_worldTransform = AffineTransformConcat(getNodeToParentTransform(), _worldTransform); CCArmature *CCBone::getArmature()
{
return m_pArmature;
}
if(_parent) void CCBone::update(float delta)
{
if (m_pParentBone)
m_bBoneTransformDirty = m_bBoneTransformDirty || m_pParentBone->isTransformDirty();
if (m_bBoneTransformDirty)
{
if (m_pArmature->getArmatureData()->dataVersion >= VERSION_COMBINED)
{ {
_worldTransform = AffineTransformConcat(_worldTransform, _parent->_worldTransform); CCTransformHelp::nodeConcat(*m_pTweenData, *m_pBoneData);
m_pTweenData->scaleX -= 1;
m_pTweenData->scaleY -= 1;
}
CCTransformHelp::nodeToMatrix(*m_pTweenData, m_tWorldTransform);
m_tWorldTransform = AffineTransformConcat(getNodeToParentTransform(), m_tWorldTransform);
if(m_pParentBone)
{
m_tWorldTransform = AffineTransformConcat(m_tWorldTransform, m_pParentBone->m_tWorldTransform);
} }
} }
DisplayFactory::updateDisplay(this, _displayManager->getCurrentDecorativeDisplay(), delta, _transformDirty); CCDisplayFactory::updateDisplay(this, m_pDisplayManager->getCurrentDecorativeDisplay(), delta, m_bBoneTransformDirty || m_pArmature->getArmatureTransformDirty());
Object *object = NULL; Object *object = NULL;
CCARRAY_FOREACH(_children, object) CCARRAY_FOREACH(_children, object)
{ {
Bone *childBone = static_cast<Bone *>(object); CCBone *childBone = (CCBone *)object;
childBone->update(delta); childBone->update(delta);
} }
_transformDirty = false; m_bBoneTransformDirty = false;
} }
void Bone::updateDisplayedColor(const Color3B &parentColor) void CCBone::updateDisplayedColor(const Color3B &parentColor)
{ {
_realColor = Color3B(255, 255, 255);
NodeRGBA::updateDisplayedColor(parentColor); NodeRGBA::updateDisplayedColor(parentColor);
updateColor(); updateColor();
} }
void Bone::updateDisplayedOpacity(GLubyte parentOpacity) void CCBone::updateDisplayedOpacity(GLubyte parentOpacity)
{ {
_realOpacity = 255;
NodeRGBA::updateDisplayedOpacity(parentOpacity); NodeRGBA::updateDisplayedOpacity(parentOpacity);
updateColor(); updateColor();
} }
void Bone::updateColor() void CCBone::updateColor()
{ {
Node *display = _displayManager->getDisplayRenderNode(); Node *display = m_pDisplayManager->getDisplayRenderNode();
RGBAProtocol *protocol = dynamic_cast<RGBAProtocol *>(display); RGBAProtocol *protocol = dynamic_cast<RGBAProtocol *>(display);
if(protocol != NULL) if(protocol != NULL)
{ {
protocol->setColor(Color3B(_displayedColor.r * _tweenData->r / 255, _displayedColor.g * _tweenData->g / 255, _displayedColor.b * _tweenData->b / 255)); protocol->setColor(Color3B(_displayedColor.r * m_pTweenData->r / 255, _displayedColor.g * m_pTweenData->g / 255, _displayedColor.b * m_pTweenData->b / 255));
protocol->setOpacity(_displayedOpacity * _tweenData->a / 255); protocol->setOpacity(_displayedOpacity * m_pTweenData->a / 255);
} }
} }
void CCBone::updateZOrder()
void Bone::addChildBone(Bone *child)
{ {
CCASSERT( NULL != child, "Argument must be non-nil"); if (m_pArmature->getArmatureData()->dataVersion >= VERSION_COMBINED)
CCASSERT( NULL == child->_parent, "child already added. It can't be added again"); {
int zorder = m_pTweenData->zOrder + m_pBoneData->zOrder;
setZOrder(zorder);
}
else
{
setZOrder(m_pTweenData->zOrder);
}
}
void CCBone::addChildBone(CCBone *child)
{
CCAssert( NULL != child, "Argument must be non-nil");
CCAssert( NULL == child->m_pParentBone, "child already added. It can't be added again");
if(!_children) if(!_children)
{ {
childrenAlloc(); _children = Array::createWithCapacity(4);
_children->retain();
} }
if (_children->getIndexOfObject(child) == UINT_MAX) if (_children->getIndexOfObject(child) == UINT_MAX)
@ -237,7 +253,7 @@ void Bone::addChildBone(Bone *child)
} }
} }
void Bone::removeChildBone(Bone *bone, bool recursion) void CCBone::removeChildBone(CCBone *bone, bool recursion)
{ {
if ( _children->getIndexOfObject(bone) != UINT_MAX ) if ( _children->getIndexOfObject(bone) != UINT_MAX )
{ {
@ -247,7 +263,7 @@ void Bone::removeChildBone(Bone *bone, bool recursion)
Object *_object = NULL; Object *_object = NULL;
CCARRAY_FOREACH(_ccbones, _object) CCARRAY_FOREACH(_ccbones, _object)
{ {
Bone *_ccBone = static_cast<Bone *>(_object); CCBone *_ccBone = (CCBone *)_object;
bone->removeChildBone(_ccBone, recursion); bone->removeChildBone(_ccBone, recursion);
} }
} }
@ -260,86 +276,101 @@ void Bone::removeChildBone(Bone *bone, bool recursion)
} }
} }
void Bone::removeFromParent(bool recursion) void CCBone::removeFromParent(bool recursion)
{ {
if (NULL != _parent) if (NULL != m_pParentBone)
{ {
_parent->removeChildBone(this, recursion); m_pParentBone->removeChildBone(this, recursion);
} }
} }
void Bone::setParentBone(Bone *parent) void CCBone::setParentBone(CCBone *parent)
{ {
_parent = parent; m_pParentBone = parent;
} }
Bone *Bone::getParentBone() CCBone *CCBone::getParentBone()
{ {
return _parent; return m_pParentBone;
} }
void Bone::childrenAlloc(void) void CCBone::setChildArmature(CCArmature *armature)
{ {
CC_SAFE_DELETE(_children); if (m_pChildArmature != armature)
_children = Array::createWithCapacity(4);
_children->retain();
}
void Bone::setChildArmature(Armature *armature)
{
if (_childArmature != armature)
{ {
CC_SAFE_RETAIN(armature); CC_SAFE_RETAIN(armature);
CC_SAFE_RELEASE(_childArmature); CC_SAFE_RELEASE(m_pChildArmature);
_childArmature = armature; m_pChildArmature = armature;
} }
} }
Armature *Bone::getChildArmature() CCArmature *CCBone::getChildArmature()
{ {
return _childArmature; return m_pChildArmature;
} }
Array *Bone::getChildren() CCTween *CCBone::getTween()
{ {
return _children; return m_pTween;
} }
Tween *Bone::getTween() void CCBone::setZOrder(int zOrder)
{
return _tween;
}
void Bone::setZOrder(int zOrder)
{ {
if (_ZOrder != zOrder) if (_ZOrder != zOrder)
Node::setZOrder(zOrder); Node::setZOrder(zOrder);
} }
void Bone::setTransformDirty(bool dirty) void CCBone::setTransformDirty(bool dirty)
{ {
_transformDirty = dirty; m_bBoneTransformDirty = dirty;
} }
bool Bone::isTransformDirty() bool CCBone::isTransformDirty()
{ {
return _transformDirty; return m_bBoneTransformDirty;
} }
AffineTransform Bone::nodeToArmatureTransform() AffineTransform CCBone::getNodeToArmatureTransform() const
{ {
return _worldTransform; return m_tWorldTransform;
} }
void Bone::addDisplay(DisplayData *_displayData, int _index) AffineTransform CCBone::getNodeToWorldTransform() const
{ {
_displayManager->addDisplay(_displayData, _index); return AffineTransformConcat(m_tWorldTransform, m_pArmature->getNodeToWorldTransform());
} }
void Bone::changeDisplayByIndex(int _index, bool _force) Node *CCBone::getDisplayRenderNode()
{ {
_displayManager->changeDisplayByIndex(_index, _force); return m_pDisplayManager->getDisplayRenderNode();
} }
}}} // namespace cocos2d { namespace extension { namespace armature { void CCBone::addDisplay(CCDisplayData *displayData, int index)
{
m_pDisplayManager->addDisplay(displayData, index);
}
void CCBone::addDisplay(Node *display, int index)
{
m_pDisplayManager->addDisplay(display, index);
}
void CCBone::changeDisplayByIndex(int index, bool force)
{
m_pDisplayManager->changeDisplayByIndex(index, force);
}
Array *CCBone::getColliderBodyList()
{
if (CCDecorativeDisplay *decoDisplay = m_pDisplayManager->getCurrentDecorativeDisplay())
{
if (CCColliderDetector *detector = decoDisplay->getColliderDetector())
{
return detector->getColliderBodyList();
}
}
return NULL;
}
NS_CC_EXT_ARMATURE_END

118
extensions/CocoStudio/Armature/CCBone.h
View File

@ -28,97 +28,95 @@ THE SOFTWARE.
#include "utils/CCArmatureDefine.h" #include "utils/CCArmatureDefine.h"
#include "datas/CCDatas.h" #include "datas/CCDatas.h"
#include "animation/CCTween.h" #include "animation/CCTween.h"
#include "external_tool/CCTexture2DMutable.h"
#include "display/CCDecorativeDisplay.h" #include "display/CCDecorativeDisplay.h"
#include "display/CCDisplayManager.h" #include "display/CCDisplayManager.h"
namespace cocos2d { namespace extension { namespace armature { NS_CC_EXT_ARMATURE_BEGIN
class Armature;
class Bone : public NodeRGBA class CCArmature;
class CCBone : public NodeRGBA
{ {
public: public:
/** /**
* Allocates and initializes a bone. * Allocates and initializes a bone.
* @return A initialized bone which is marked as "autorelease". * @return A initialized bone which is marked as "autorelease".
*/ */
static Bone *create(); static CCBone *create();
/** /**
* Allocates and initializes a bone. * Allocates and initializes a bone.
* *
* @param name If name is not null, then set name to the bone's name * @param name If name is not null, then set name to the bone's name
* @return A initialized bone which is marked as "autorelease". * @return A initialized bone which is marked as "autorelease".
*/ */
static Bone *create(const char *name); static CCBone *create(const char *name);
public: public:
Bone(); CCBone();
/** virtual ~CCBone(void);
* @js NA
* @lua NA
*/
virtual ~Bone(void);
/** /**
* Initializes an empty Bone with nothing init. * Initializes an empty CCBone with nothing init.
*/ */
virtual bool init(); virtual bool init();
/** /**
* Initializes a Bone with the specified name * Initializes a CCBone with the specified name
* @param name Bone's name. * @param name CCBone's name.
*/ */
virtual bool init(const char *name); virtual bool init(const char *name);
/** /**
* Add display and use _DisplayData init the display. * Add display and use displayData to init the display.
* If index already have a display, then replace it. * If index already have a display, then replace it.
* If index is current display index, then also change display to _index * If index is current display index, then also change display to _index
* *
* @param displayData it include the display information, like DisplayType. * @param displayData it include the display information, like DisplayType.
* If you want to create a sprite display, then create a SpriteDisplayData param * If you want to create a sprite display, then create a CCSpriteDisplayData param
* *
* @param index the index of the display you want to replace or add to * @param index the index of the display you want to replace or add to
* -1 : append display from back * -1 : append display from back
*/ */
void addDisplay(DisplayData *displayData, int index); void addDisplay(CCDisplayData *displayData, int index);
void addDisplay(Node *display, int index);
void changeDisplayByIndex(int index, bool force); void changeDisplayByIndex(int index, bool force);
/** /**
* Add a child to this bone, and it will let this child call setParent(Bone *_parent) function to set self to it's parent * Add a child to this bone, and it will let this child call setParent(CCBone *parent) function to set self to it's parent
* @param child The child you want to add. * @param child the child you want to add
*/ */
void addChildBone(Bone *child); void addChildBone(CCBone *child);
/** /**
* Set parent bone. * Set parent bone.
* If _parent is NUll, then also remove this bone from armature. * If parent is NUll, then also remove this bone from armature.
* It will not set the Armature, if you want to add the bone to a Armature, you should use Armature::addBone(Bone *bone, const char* _parentName). * It will not set the CCArmature, if you want to add the bone to a CCArmature, you should use CCArmature::addBone(CCBone *bone, const char* parentName).
* *
* @param parent the parent bone. * @param parent the parent bone.
* NULL : remove this bone from armature * NULL : remove this bone from armature
*/ */
void setParentBone(Bone *parent); void setParentBone(CCBone *parent);
/** /**
* Get parent bone * Get parent bone
* @return parent bone * @return parent bone
*/ */
Bone *getParentBone(); CCBone *getParentBone();
/** /**
* Remove itself from its parent Bone. * Remove itself from its parent.
* @param recursion Whether to remove Child display * @param recursion whether or not to remove childBone's display
*/ */
void removeFromParent(bool recursion); void removeFromParent(bool recursion);
/** /**
* Removes a child Bone * Removes a child CCBone
* @param bone The bone you want to remove. * @param bone the bone you want to remove
*/ */
void removeChildBone(Bone *bone, bool recursion); void removeChildBone(CCBone *bone, bool recursion);
void update(float delta); void update(float delta);
@ -128,10 +126,13 @@ public:
//! Update color to render display //! Update color to render display
void updateColor(); void updateColor();
Array *getChildren(); //! Update zorder
Tween *getTween(); void updateZOrder();
virtual void setZOrder(int zOrder); virtual void setZOrder(int zOrder);
CCTween *getTween();
/* /*
* Whether or not the bone's transform property changed. if true, the bone will update the transform. * Whether or not the bone's transform property changed. if true, the bone will update the transform.
*/ */
@ -139,48 +140,53 @@ public:
virtual bool isTransformDirty(); virtual bool isTransformDirty();
virtual AffineTransform nodeToArmatureTransform(); virtual AffineTransform getNodeToArmatureTransform() const;
virtual AffineTransform getNodeToWorldTransform() const;
Node *getDisplayRenderNode();
/*
* Get the ColliderBody list in this bone. The object in the Array is ColliderBody.
*/
virtual Array *getColliderBodyList();
public: public:
/* /*
* The origin state of the Bone. Display's state is effected by _boneData, _node, _tweenData * The origin state of the CCBone. Display's state is effected by m_pBoneData, m_pNode, m_pTweenData
* when call setData function, it will copy from the BoneData. * when call setData function, it will copy from the CCBoneData.
*/ */
CC_PROPERTY(BoneData *, _boneData, BoneData); CC_PROPERTY(CCBoneData *, m_pBoneData, BoneData);
//! A weak reference to the Armature //! A weak reference to the CCArmature
CC_PROPERTY(Armature *, _armature, Armature); CC_PROPERTY(CCArmature *, m_pArmature, Armature);
//! A weak reference to the child Armature //! A weak reference to the child CCArmature
CC_PROPERTY(Armature *, _childArmature, ChildArmature); CC_PROPERTY(CCArmature *, m_pChildArmature, ChildArmature);
CC_SYNTHESIZE(DisplayManager *, _displayManager, DisplayManager) CC_SYNTHESIZE(CCDisplayManager *, m_pDisplayManager, DisplayManager)
/* /*
* When Armature play a animation, if there is not a MovementBoneData of this bone in this MovementData, this bone will hide. * When CCArmature play an animation, if there is not a CCMovementBoneData of this bone in this CCMovementData, this bone will be hidden.
* Set IgnoreMovementBoneData to true, then this bone will also show. * Set IgnoreMovementBoneData to true, then this bone will also be shown.
*/ */
CC_SYNTHESIZE_PASS_BY_REF(bool, _ignoreMovementBoneData, IgnoreMovementBoneData) CC_SYNTHESIZE(bool, m_bIgnoreMovementBoneData, IgnoreMovementBoneData)
CC_SYNTHESIZE(CCBlendType, m_eBlendType, BlendType)
protected: protected:
Tween *_tween; //! Calculate tween effect CCTween *m_pTween; //! Calculate tween effect
//! Used for make tween effect between every frame //! Used for making tween effect in every frame
CC_SYNTHESIZE_READONLY(FrameData *, _tweenData, TweenData); CC_SYNTHESIZE_READONLY(CCFrameData *, m_pTweenData, TweenData);
CC_SYNTHESIZE_PASS_BY_REF(std::string, _name, Name); CC_SYNTHESIZE(std::string, m_strName, Name);
//! Lazy allocs CCBone *m_pParentBone; //! A weak reference to its parent
void childrenAlloc(void); bool m_bBoneTransformDirty; //! Whether or not transform dirty
Array *_children;
Bone *_parent; //! A weak reference to it's parent
bool _transformDirty; //! Whether or not transform dirty
//! self Transform, use this to change display's state //! self Transform, use this to change display's state
AffineTransform _worldTransform; AffineTransform m_tWorldTransform;
}; };
}}} // namespace cocos2d { namespace extension { namespace armature { NS_CC_EXT_ARMATURE_END
#endif /*__CCBONE_H__*/ #endif /*__CCBONE_H__*/

307
extensions/CocoStudio/Armature/animation/CCArmatureAnimation.cpp
View File

@ -27,15 +27,14 @@ THE SOFTWARE.
#include "../CCBone.h" #include "../CCBone.h"
#include "../utils/CCArmatureDefine.h" #include "../utils/CCArmatureDefine.h"
#include "../utils/CCUtilMath.h" #include "../utils/CCUtilMath.h"
#include "../utils/CCConstValue.h"
#include "../datas/CCDatas.h" #include "../datas/CCDatas.h"
namespace cocos2d { namespace extension { namespace armature { NS_CC_EXT_ARMATURE_BEGIN
ArmatureAnimation *ArmatureAnimation::create(Armature *armature) CCArmatureAnimation *CCArmatureAnimation::create(CCArmature *armature)
{ {
ArmatureAnimation *pArmatureAnimation = new ArmatureAnimation(); CCArmatureAnimation *pArmatureAnimation = new CCArmatureAnimation();
if (pArmatureAnimation && pArmatureAnimation->init(armature)) if (pArmatureAnimation && pArmatureAnimation->init(armature))
{ {
pArmatureAnimation->autorelease(); pArmatureAnimation->autorelease();
@ -46,32 +45,40 @@ ArmatureAnimation *ArmatureAnimation::create(Armature *armature)
} }
ArmatureAnimation::ArmatureAnimation() CCArmatureAnimation::CCArmatureAnimation()
: _animationData(NULL) : m_pAnimationData(NULL)
, _armature(NULL) , m_fSpeedScale(1)
, _movementID("") , m_pMovementData(NULL)
, _toIndex(0) , m_pArmature(NULL)
, m_strMovementID("")
, m_iToIndex(0)
, m_sMovementEventCallFunc(NULL)
, m_sFrameEventCallFunc(NULL)
, m_sMovementEventTarget(NULL)
, m_sFrameEventTarget(NULL)
{ {
} }
ArmatureAnimation::~ArmatureAnimation(void) CCArmatureAnimation::~CCArmatureAnimation(void)
{ {
CCLOGINFO("deallocing ArmatureAnimation: %p", this); CC_SAFE_RELEASE_NULL(m_pTweenList);
CC_SAFE_RELEASE_NULL(m_pAnimationData);
CC_SAFE_RELEASE_NULL(_tweenList); CC_SAFE_RELEASE_NULL(m_sMovementEventTarget);
CC_SAFE_RELEASE_NULL(_animationData); CC_SAFE_RELEASE_NULL(m_sFrameEventTarget);
} }
bool ArmatureAnimation::init(Armature *armature) bool CCArmatureAnimation::init(CCArmature *armature)
{ {
bool bRet = false; bool bRet = false;
do do
{ {
_armature = armature; m_pArmature = armature;
_tweenList = new Array(); m_pTweenList = new Array();
_tweenList->init(); m_pTweenList->init();
bRet = true; bRet = true;
} }
@ -81,124 +88,171 @@ bool ArmatureAnimation::init(Armature *armature)
} }
void ArmatureAnimation:: pause() void CCArmatureAnimation:: pause()
{ {
Object *object = NULL; Object *object = NULL;
CCARRAY_FOREACH(_tweenList, object) CCARRAY_FOREACH(m_pTweenList, object)
{ {
static_cast<Tween *>(object)->pause(); ((CCTween *)object)->pause();
} }
ProcessBase::pause(); CCProcessBase::pause();
} }
void ArmatureAnimation::resume() void CCArmatureAnimation::resume()
{ {
Object *object = NULL; Object *object = NULL;
CCARRAY_FOREACH(_tweenList, object) CCARRAY_FOREACH(m_pTweenList, object)
{ {
static_cast<Tween *>(object)->resume(); ((CCTween *)object)->resume();
} }
ProcessBase::resume(); CCProcessBase::resume();
} }
void ArmatureAnimation::stop() void CCArmatureAnimation::stop()
{ {
Object *object = NULL; Object *object = NULL;
CCARRAY_FOREACH(_tweenList, object) CCARRAY_FOREACH(m_pTweenList, object)
{ {
static_cast<Tween *>(object)->stop(); ((CCTween *)object)->stop();
} }
_tweenList->removeAllObjects(); m_pTweenList->removeAllObjects();
ProcessBase::stop(); CCProcessBase::stop();
} }
void ArmatureAnimation::setAnimationScale(float animationScale ) void CCArmatureAnimation::setAnimationScale(float animationScale )
{ {
if(animationScale == _animationScale) setSpeedScale(animationScale);
}
float CCArmatureAnimation::getAnimationScale() const
{
return getSpeedScale();
}
void CCArmatureAnimation::setSpeedScale(float speedScale)
{
if(speedScale == m_fSpeedScale)
{ {
return; return;
} }
_animationScale = animationScale; m_fSpeedScale = speedScale;
m_fProcessScale = !m_pMovementData ? m_fSpeedScale : m_fSpeedScale * m_pMovementData->scale;
DictElement *element = NULL; DictElement *element = NULL;
Dictionary *dict = _armature->getBoneDic(); Dictionary *dict = m_pArmature->getBoneDic();
CCDICT_FOREACH(dict, element) CCDICT_FOREACH(dict, element)
{ {
Bone *bone = (Bone *)element->getObject(); CCBone *bone = (CCBone *)element->getObject();
bone->getTween()->setAnimationScale(_animationScale);
bone->getTween()->setProcessScale(m_fProcessScale);
if (bone->getChildArmature()) if (bone->getChildArmature())
{ {
bone->getChildArmature()->getAnimation()->setAnimationScale(_animationScale); bone->getChildArmature()->getAnimation()->setProcessScale(m_fProcessScale);
}
}
}
float CCArmatureAnimation::getSpeedScale() const
{
return m_fSpeedScale;
}
void CCArmatureAnimation::setAnimationInternal(float animationInternal)
{
if(animationInternal == m_fAnimationInternal)
{
return;
}
m_fAnimationInternal = animationInternal;
DictElement *element = NULL;
Dictionary *dict = m_pArmature->getBoneDic();
CCDICT_FOREACH(dict, element)
{
CCBone *bone = (CCBone *)element->getObject();
bone->getTween()->setAnimationInternal(m_fAnimationInternal);
if (bone->getChildArmature())
{
bone->getChildArmature()->getAnimation()->setAnimationInternal(m_fAnimationInternal);
} }
} }
} }
void ArmatureAnimation::play(const char *animationName, int durationTo, int durationTween, int loop, int tweenEasing) void CCArmatureAnimation::play(const char *animationName, int durationTo, int durationTween, int loop, int tweenEasing)
{ {
CCASSERT(_animationData, "_animationData can not be null"); CCAssert(m_pAnimationData, "m_pAnimationData can not be null");
_movementData = _animationData->getMovement(animationName); m_pMovementData = m_pAnimationData->getMovement(animationName);
CCASSERT(_movementData, "_movementData can not be null"); CCAssert(m_pMovementData, "m_pMovementData can not be null");
//! Get key frame count //! Get key frame count
_rawDuration = _movementData->duration; m_iRawDuration = m_pMovementData->duration;
_movementID = animationName; m_strMovementID = animationName;
m_fProcessScale = m_fSpeedScale * m_pMovementData->scale;
//! Further processing parameters //! Further processing parameters
durationTo = (durationTo == -1) ? _movementData->durationTo : durationTo; durationTo = (durationTo == -1) ? m_pMovementData->durationTo : durationTo;
durationTween = (durationTween == -1) ? _movementData->durationTween : durationTween; durationTween = (durationTween == -1) ? m_pMovementData->durationTween : durationTween;
durationTween = (durationTween == 0) ? _movementData->duration : durationTween; durationTween = (durationTween == 0) ? m_pMovementData->duration : durationTween;
tweenEasing = (tweenEasing == TWEEN_EASING_MAX) ? _movementData->tweenEasing : tweenEasing; tweenEasing = (tweenEasing == TWEEN_EASING_MAX) ? m_pMovementData->tweenEasing : tweenEasing;
loop = (loop < 0) ? _movementData->loop : loop; loop = (loop < 0) ? m_pMovementData->loop : loop;
ProcessBase::play((void *)animationName, durationTo, durationTween, loop, tweenEasing); CCProcessBase::play((void *)animationName, durationTo, durationTween, loop, tweenEasing);
if (_rawDuration == 1) if (m_iRawDuration == 0)
{ {
_loopType = SINGLE_FRAME; m_eLoopType = SINGLE_FRAME;
} }
else else
{ {
if (loop) if (loop)
{ {
_loopType = ANIMATION_TO_LOOP_FRONT; m_eLoopType = ANIMATION_TO_LOOP_FRONT;
} }
else else
{ {
_loopType = ANIMATION_NO_LOOP; m_eLoopType = ANIMATION_NO_LOOP;
_rawDuration --; m_iRawDuration --;
} }
_durationTween = durationTween; m_iDurationTween = durationTween;
} }
MovementBoneData *movementBoneData = NULL; CCMovementBoneData *movementBoneData = NULL;
_tweenList->removeAllObjects(); m_pTweenList->removeAllObjects();
DictElement *element = NULL; DictElement *element = NULL;
Dictionary *dict = _armature->getBoneDic(); Dictionary *dict = m_pArmature->getBoneDic();
CCDICT_FOREACH(dict, element) CCDICT_FOREACH(dict, element)
{ {
Bone *bone = (Bone *)element->getObject(); CCBone *bone = (CCBone *)element->getObject();
movementBoneData = (MovementBoneData *)_movementData->movBoneDataDic->objectForKey(bone->getName()); movementBoneData = (CCMovementBoneData *)m_pMovementData->movBoneDataDic.objectForKey(bone->getName());
Tween *tween = bone->getTween(); CCTween *tween = bone->getTween();
if(movementBoneData && movementBoneData->frameList->count() > 0) if(movementBoneData && movementBoneData->frameList.count() > 0)
{ {
_tweenList->addObject(tween); m_pTweenList->addObject(tween);
movementBoneData->duration = m_pMovementData->duration;
tween->play(movementBoneData, durationTo, durationTween, loop, tweenEasing); tween->play(movementBoneData, durationTo, durationTween, loop, tweenEasing);
tween->setAnimationScale(_animationScale); tween->setProcessScale(m_fProcessScale);
tween->setAnimationInternal(m_fAnimationInternal);
if (bone->getChildArmature()) if (bone->getChildArmature())
{ {
bone->getChildArmature()->getAnimation()->setAnimationScale(_animationScale); bone->getChildArmature()->getAnimation()->setProcessScale(m_fProcessScale);
bone->getChildArmature()->getAnimation()->setAnimationInternal(m_fAnimationInternal);
} }
} }
else else
@ -212,14 +266,12 @@ void ArmatureAnimation::play(const char *animationName, int durationTo, int dura
} }
} }
//_armature->update(0);
} }
void ArmatureAnimation::playByIndex(int animationIndex, int durationTo, int durationTween, int loop, int tweenEasing) void CCArmatureAnimation::playByIndex(int animationIndex, int durationTo, int durationTween, int loop, int tweenEasing)
{ {
std::vector<std::string> &movName = _animationData->movementNames; std::vector<std::string> &movName = m_pAnimationData->movementNames;
CC_ASSERT((animationIndex > -1) && ((unsigned int)animationIndex < movName.size())); CC_ASSERT((animationIndex > -1) && ((unsigned int)animationIndex < movName.size()));
std::string animationName = movName.at(animationIndex); std::string animationName = movName.at(animationIndex);
@ -228,41 +280,44 @@ void ArmatureAnimation::playByIndex(int animationIndex, int durationTo, int dura
int ArmatureAnimation::getMovementCount() int CCArmatureAnimation::getMovementCount()
{ {
return _animationData->getMovementCount(); return m_pAnimationData->getMovementCount();
} }
void ArmatureAnimation::update(float dt) void CCArmatureAnimation::update(float dt)
{ {
ProcessBase::update(dt); CCProcessBase::update(dt);
Object *object = NULL; Object *object = NULL;
CCARRAY_FOREACH(_tweenList, object) CCARRAY_FOREACH(m_pTweenList, object)
{ {
static_cast<Tween *>(object)->update(dt); ((CCTween *)object)->update(dt);
} }
} }
void ArmatureAnimation::updateHandler() void CCArmatureAnimation::updateHandler()
{ {
if (_currentPercent >= 1) if (m_fCurrentPercent >= 1)
{ {
switch(_loopType) switch(m_eLoopType)
{ {
case ANIMATION_NO_LOOP: case ANIMATION_NO_LOOP:
{ {
_loopType = ANIMATION_MAX; m_eLoopType = ANIMATION_MAX;
_currentFrame = (_currentPercent - 1) * _nextFrameIndex; m_fCurrentFrame = (m_fCurrentPercent - 1) * m_iNextFrameIndex;
_currentPercent = _currentFrame / _durationTween; m_fCurrentPercent = m_fCurrentFrame / m_iDurationTween;
if (_currentPercent >= 1.0f) if (m_fCurrentPercent >= 1.0f)
{ {
} }
else else
{ {
_nextFrameIndex = _durationTween; m_iNextFrameIndex = m_iDurationTween;
MovementEventSignal.emit(_armature, START, _movementID.c_str()); if (m_sMovementEventTarget && m_sMovementEventCallFunc)
{
(m_sMovementEventTarget->*m_sMovementEventCallFunc)(m_pArmature, START, m_strMovementID.c_str());
}
break; break;
} }
@ -271,47 +326,81 @@ void ArmatureAnimation::updateHandler()
case ANIMATION_MAX: case ANIMATION_MAX:
case SINGLE_FRAME: case SINGLE_FRAME:
{ {
_currentPercent = 1; m_fCurrentPercent = 1;
_isComplete = true; m_bIsComplete = true;
m_bIsPlaying = false;
MovementEventSignal.emit(_armature, COMPLETE, _movementID.c_str()); if (m_sMovementEventTarget && m_sMovementEventCallFunc)
{
(m_sMovementEventTarget->*m_sMovementEventCallFunc)(m_pArmature, COMPLETE, m_strMovementID.c_str());
}
} }
break; break;
case ANIMATION_TO_LOOP_FRONT: case ANIMATION_TO_LOOP_FRONT:
{ {
_loopType = ANIMATION_LOOP_FRONT; m_eLoopType = ANIMATION_LOOP_FRONT;
_currentPercent = fmodf(_currentPercent, 1); m_fCurrentPercent = fmodf(m_fCurrentPercent, 1);
_currentFrame = fmodf(_currentFrame, _nextFrameIndex); m_fCurrentFrame = m_iNextFrameIndex == 0 ? 0 : fmodf(m_fCurrentFrame, m_iNextFrameIndex);
_nextFrameIndex = _durationTween > 0 ? _durationTween : 1; m_iNextFrameIndex = m_iDurationTween > 0 ? m_iDurationTween : 1;
MovementEventSignal.emit(_armature, START, _movementID.c_str()); if (m_sMovementEventTarget && m_sMovementEventCallFunc)
{
(m_sMovementEventTarget->*m_sMovementEventCallFunc)(m_pArmature, START, m_strMovementID.c_str());
}
} }
break; break;
default: default:
{ {
_currentPercent = fmodf(_currentPercent, 1); //m_fCurrentPercent = fmodf(m_fCurrentPercent, 1);
_currentFrame = fmodf(_currentFrame, _nextFrameIndex); m_fCurrentFrame = fmodf(m_fCurrentFrame, m_iNextFrameIndex);
_toIndex = 0; m_iToIndex = 0;
MovementEventSignal.emit(_armature, LOOP_COMPLETE, _movementID.c_str()); if (m_sMovementEventTarget && m_sMovementEventCallFunc)
{
(m_sMovementEventTarget->*m_sMovementEventCallFunc)(m_pArmature, LOOP_COMPLETE, m_strMovementID.c_str());
}
} }
break; break;
} }
} }
}
if (_loopType == ANIMATION_LOOP_FRONT || _loopType == ANIMATION_LOOP_BACK) std::string CCArmatureAnimation::getCurrentMovementID()
{
if (m_bIsComplete)
{ {
updateFrameData(_currentPercent); return "";
}
return m_strMovementID;
}
void CCArmatureAnimation::setMovementEventCallFunc(Object *target, SEL_MovementEventCallFunc callFunc)
{
if (target != m_sMovementEventTarget)
{
CC_SAFE_RETAIN(target);
CC_SAFE_RELEASE_NULL(m_sMovementEventTarget);
m_sMovementEventTarget = target;
}
m_sMovementEventCallFunc = callFunc;
}
void CCArmatureAnimation::setFrameEventCallFunc(Object *target, SEL_FrameEventCallFunc callFunc)
{
if (target != m_sFrameEventTarget)
{
CC_SAFE_RETAIN(target);
CC_SAFE_RELEASE_NULL(m_sFrameEventTarget);
m_sFrameEventTarget = target;
}
m_sFrameEventCallFunc = callFunc;
}
void CCArmatureAnimation::frameEvent(CCBone *bone, const char *frameEventName, int originFrameIndex, int currentFrameIndex)
{
if (m_sFrameEventTarget && m_sFrameEventCallFunc)
{
(m_sFrameEventTarget->*m_sFrameEventCallFunc)(bone, frameEventName, originFrameIndex, currentFrameIndex);
} }
} }
NS_CC_EXT_ARMATURE_END
void ArmatureAnimation::updateFrameData(float currentPercent)
{
_prevFrameIndex = _curFrameIndex;
_curFrameIndex = _rawDuration * currentPercent;
_curFrameIndex = _curFrameIndex % _rawDuration;
}
}}} // namespace cocos2d { namespace extension { namespace armature {

150
extensions/CocoStudio/Armature/animation/CCArmatureAnimation.h
View File

@ -27,52 +27,62 @@ THE SOFTWARE.
#define __CCANIMATION_H__ #define __CCANIMATION_H__
#include "CCProcessBase.h" #include "CCProcessBase.h"
#include "../external_tool/sigslot.h"
namespace cocos2d { namespace extension { namespace armature { NS_CC_EXT_ARMATURE_BEGIN
enum MovementEventType enum MovementEventType
{ {
START, START,
COMPLETE, COMPLETE,
LOOP_COMPLETE LOOP_COMPLETE
}; };
class Armature; class CCArmature;
class Bone; class CCBone;
class ArmatureAnimation : public ProcessBase typedef void (Object::*SEL_MovementEventCallFunc)(CCArmature *, MovementEventType, const char *);
typedef void (Object::*SEL_FrameEventCallFunc)(CCBone *, const char *, int, int);
#define movementEvent_selector(_SELECTOR) (SEL_MovementEventCallFunc)(&_SELECTOR)
#define frameEvent_selector(_SELECTOR) (SEL_FrameEventCallFunc)(&_SELECTOR)
class CCArmatureAnimation : public CCProcessBase
{ {
public: public:
/** /**
* Create with a Armature * Create with a CCArmature
* @param armature The Armature ArmatureAnimation will bind to * @param armature The CCArmature CCArmatureAnimation will bind to
*/ */
static ArmatureAnimation *create(Armature *armature); static CCArmatureAnimation *create(CCArmature *armature);
public: public:
/** CCArmatureAnimation();
* @js ctor virtual ~CCArmatureAnimation(void);
*/
ArmatureAnimation();
/**
* @js NA
* @lua NA
*/
virtual ~ArmatureAnimation(void);
/** /**
* Init with a Armature * Init with a CCArmature
* @param armature The Armature ArmatureAnimation will bind to * @param armature The CCArmature CCArmatureAnimation will bind to
*/ */
virtual bool init(Armature *armature); virtual bool init(CCArmature *armature);
/** /**
* Scale animation play speed. * Scale animation play speed.
* @param animationScale Scale value * @param animationScale Scale value
*/ */
virtual void setAnimationScale(float animationScale); virtual void setAnimationScale(float animationScale);
virtual float getAnimationScale() const;
/**
* Scale animation play speed.
* @param animationScale Scale value
*/
virtual void setSpeedScale(float speedScale);
virtual float getSpeedScale() const;
//! The animation update speed
virtual void setAnimationInternal(float animationInternal);
/** /**
* Play animation by animation name. * Play animation by animation name.
@ -81,21 +91,21 @@ public:
* @param durationTo The frames between two animation changing-over. * @param durationTo The frames between two animation changing-over.
* It's meaning is changing to this animation need how many frames * It's meaning is changing to this animation need how many frames
* *
* -1 : use the value from MovementData get from flash design panel * -1 : use the value from CCMovementData get from flash design panel
* @param durationTween The frame count you want to play in the game. * @param durationTween The frame count you want to play in the game.
* if _durationTween is 80, then the animation will played 80 frames in a loop * if _durationTween is 80, then the animation will played 80 frames in a loop
* *
* -1 : use the value from MovementData get from flash design panel * -1 : use the value from CCMovementData get from flash design panel
* *
* @param loop Whether the animation is loop * @param loop Whether the animation is loop
* *
* loop < 0 : use the value from MovementData get from flash design panel * loop < 0 : use the value from CCMovementData get from flash design panel
* loop = 0 : this animation is not loop * loop = 0 : this animation is not loop
* loop > 0 : this animation is loop * loop > 0 : this animation is loop
* *
* @param tweenEasing Tween easing is used for calculate easing effect * @param tweenEasing CCTween easing is used for calculate easing effect
* *
* TWEEN_EASING_MAX : use the value from MovementData get from flash design panel * TWEEN_EASING_MAX : use the value from CCMovementData get from flash design panel
* -1 : fade out * -1 : fade out
* 0 : line * 0 : line
* 1 : fade in * 1 : fade in
@ -106,7 +116,7 @@ public:
/** /**
* Play animation by index, the other param is the same to play. * Play animation by index, the other param is the same to play.
* @param animationIndex the animation index you want to play * @param _animationIndex the animation index you want to play
*/ */
void playByIndex(int animationIndex, int durationTo = -1, int durationTween = -1, int loop = -1, int tweenEasing = TWEEN_EASING_MAX); void playByIndex(int animationIndex, int durationTo = -1, int durationTween = -1, int loop = -1, int tweenEasing = TWEEN_EASING_MAX);
@ -130,6 +140,25 @@ public:
int getMovementCount(); int getMovementCount();
void update(float dt); void update(float dt);
/**
* Get current movementID
* @return The name of current movement
*/
std::string getCurrentMovementID();
/**
* Set armature's movement event callback function
* To disconnect this event, just setMovementEventCallFunc(NULL, NULL);
*/
void setMovementEventCallFunc(Object *target, SEL_MovementEventCallFunc callFunc);
/**
* Set armature's frame event callback function
* To disconnect this event, just setFrameEventCallFunc(NULL, NULL);
*/
void setFrameEventCallFunc(Object *target, SEL_FrameEventCallFunc callFunc);
protected: protected:
/** /**
@ -142,31 +171,52 @@ protected:
*/ */
void updateFrameData(float currentPercent); void updateFrameData(float currentPercent);
protected:
//! AnimationData save all MovementDatas this animation used.
CC_SYNTHESIZE_RETAIN(AnimationData *, _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 _prevFrameIndex; //! Prev key frame index
int _toIndex; //! The frame index in MovementData->_movFrameDataArr, it's different from _frameIndex.
Array *_tweenList;
public:
/** /**
* MovementEvent signal. This will emit a signal when trigger a event. * Emit a frame event
* The 1st param is the Armature. The 2nd param is Event Type, like START, COMPLETE. The 3rd param is Movement ID, also called Movement Name.
*/ */
sigslot::signal3<Armature *, MovementEventType, const char *> MovementEventSignal; void frameEvent(CCBone *bone, const char *frameEventName, int originFrameIndex, int currentFrameIndex);
sigslot::signal2<Bone *, const char *> FrameEventSignal; friend class CCTween;
protected:
//! CCAnimationData save all MovementDatas this animation used.
CC_SYNTHESIZE_RETAIN(CCAnimationData *, m_pAnimationData, AnimationData);
//! Scale the animation speed
float m_fSpeedScale;
CCMovementData *m_pMovementData; //! CCMovementData save all MovementFrameDatas this animation used.
CCArmature *m_pArmature; //! A weak reference of armature
std::string m_strMovementID; //! Current movment's name
int m_iToIndex; //! The frame index in CCMovementData->m_pMovFrameDataArr, it's different from m_iFrameIndex.
Array *m_pTweenList;
protected:
/**
* MovementEvent CallFunc.
* @param CCArmature* a CCArmature
* @param MovementEventType, Event Type, like START, COMPLETE.
* @param const char*, Movement ID, also called Movement Name
*/
SEL_MovementEventCallFunc m_sMovementEventCallFunc;
/**
* FrameEvent CallFunc.
* @param CCBone*, a CCBone
* @param const char*, the name of this frame event
* @param int, origin frame index
* @param int, current frame index, animation may be delayed
*/
SEL_FrameEventCallFunc m_sFrameEventCallFunc;
Object *m_sMovementEventTarget;
Object *m_sFrameEventTarget;
}; };
}}} // namespace cocos2d { namespace extension { namespace armature { NS_CC_EXT_ARMATURE_END
#endif /*__CCANIMATION_H__*/ #endif /*__CCANIMATION_H__*/

125
extensions/CocoStudio/Armature/animation/CCProcessBase.cpp
View File

@ -25,121 +25,128 @@ THE SOFTWARE.
#include "CCProcessBase.h" #include "CCProcessBase.h"
#include "../utils/CCUtilMath.h" #include "../utils/CCUtilMath.h"
namespace cocos2d { namespace extension { namespace armature { NS_CC_EXT_ARMATURE_BEGIN
ProcessBase::ProcessBase(void) CCProcessBase::CCProcessBase(void)
: _animationScale(1) : m_fProcessScale(1)
, _isPause(true) , m_bIsPause(true)
, _isComplete(true) , m_bIsComplete(true)
, _isPlaying(false) , m_bIsPlaying(false)
, _currentPercent(0.0f) , m_fCurrentPercent(0.0f)
, _rawDuration(0) , m_iRawDuration(0)
, _loopType(ANIMATION_LOOP_BACK) , m_eLoopType(ANIMATION_LOOP_BACK)
, _tweenEasing(Linear) , m_eTweenEasing(Linear)
, _durationTween(0) , m_iDurationTween(0)
, _currentFrame(0) , m_fCurrentFrame(0)
, _curFrameIndex(0) , m_iCurFrameIndex(0)
, _isLoopBack(false) , m_bIsLoopBack(false)
{ {
/* /*
* set _animationInternal defualt value to Director::getInstance() * set m_fAnimationInternal defualt value to CCDirector::sharedDirector()
* ->getAnimationInterval(), in line with game update speed * ->getAnimationInterval(), in line with game update speed
*/ */
_animationInternal = Director::getInstance()->getAnimationInterval(); m_fAnimationInternal = CCDirector::getInstance()->getAnimationInterval();
} }
ProcessBase::~ProcessBase(void) CCProcessBase::~CCProcessBase(void)
{ {
} }
void ProcessBase::pause() void CCProcessBase::pause()
{ {
_isPause = true; m_bIsPause = true;
m_bIsPlaying = false;
} }
void ProcessBase::resume() void CCProcessBase::resume()
{ {
_isPause = false; m_bIsPause = false;
m_bIsPlaying = true;
} }
void ProcessBase::stop() void CCProcessBase::stop()
{ {
_isComplete = true; m_bIsComplete = true;
_currentFrame = 0; m_bIsPlaying = false;
_currentPercent = 0; m_fCurrentFrame = 0;
m_fCurrentPercent = 0;
} }
void ProcessBase::play(void *animation, int durationTo, int durationTween, int loop, int tweenEasing) void CCProcessBase::play(void *animation, int durationTo, int durationTween, int loop, int tweenEasing)
{ {
_isComplete = false; m_bIsComplete = false;
_isPause = false; m_bIsPause = false;
_isPlaying = true; m_bIsPlaying = true;
_currentFrame = 0; m_fCurrentFrame = 0;
/* /*
* Set _totalFrames to durationTo, it is used for change tween between two animation. * Set m_iTotalFrames to durationTo, it is used for change tween between two animation.
* When changing end, _totalFrames will be setted to _durationTween * When changing end, m_iTotalFrames will be setted to _durationTween
*/ */
_nextFrameIndex = durationTo; m_iNextFrameIndex = durationTo;
_tweenEasing = (TweenType)tweenEasing; m_eTweenEasing = (CCTweenType)tweenEasing;
} }
void ProcessBase::update(float dt) void CCProcessBase::update(float dt)
{ {
if (_isComplete || _isPause) if (m_bIsComplete || m_bIsPause)
{ {
return; return;
} }
/* /*
* Fileter the _duration <=0 and dt >1 * Fileter the m_iDuration <=0 and dt >1
* If dt>1, generally speaking the reason is the device is stuck. * If dt>1, generally speaking the reason is the device is stuck.
*/ */
if(_rawDuration <= 0 || dt > 1) if(m_iRawDuration <= 0 || dt > 1)
{ {
return; return;
} }
if (_nextFrameIndex <= 0) if (m_iNextFrameIndex <= 0)
{ {
_currentFrame = _nextFrameIndex = 1; m_fCurrentPercent = 1;
m_fCurrentFrame = 0;
} }
else
/* {
* update _currentFrame, every update add the frame passed. /*
* dt/_animationInternal determine it is not a frame animation. If frame speed changed, it will not make our * update m_fCurrentFrame, every update add the frame passed.
* animation speed slower or quicker. * dt/m_fAnimationInternal determine it is not a frame animation. If frame speed changed, it will not make our
*/ * animation speed slower or quicker.
_currentFrame += _animationScale * (dt / _animationInternal); */
m_fCurrentFrame += m_fProcessScale * (dt / m_fAnimationInternal);
_currentPercent = _currentFrame / _nextFrameIndex; m_fCurrentPercent = m_fCurrentFrame / m_iNextFrameIndex;
/* /*
* if _currentFrame is bigger or equal than _totalFrames, then reduce it util _currentFrame is * if m_fCurrentFrame is bigger or equal than m_iTotalFrames, then reduce it util m_fCurrentFrame is
* smaller than _totalFrames * smaller than m_iTotalFrames
*/ */
_currentFrame = fmodf(_currentFrame, _nextFrameIndex); m_fCurrentFrame = fmodf(m_fCurrentFrame, m_iNextFrameIndex);
}
updateHandler(); updateHandler();
} }
void ProcessBase::gotoFrame(int frameIndex) void CCProcessBase::gotoFrame(int frameIndex)
{ {
_curFrameIndex = frameIndex; m_iCurFrameIndex = frameIndex;
stop(); pause();
} }
int ProcessBase::getCurrentFrameIndex() int CCProcessBase::getCurrentFrameIndex()
{ {
return _curFrameIndex; m_iCurFrameIndex = m_iRawDuration * m_fCurrentPercent;
return m_iCurFrameIndex;
} }
}}} // namespace cocos2d { namespace extension { namespace armature { NS_CC_EXT_ARMATURE_END

61
extensions/CocoStudio/Armature/animation/CCProcessBase.h
View File

@ -29,7 +29,7 @@ THE SOFTWARE.
#include "../utils/CCArmatureDefine.h" #include "../utils/CCArmatureDefine.h"
#include "../datas/CCDatas.h" #include "../datas/CCDatas.h"
namespace cocos2d { namespace extension { namespace armature { NS_CC_EXT_ARMATURE_BEGIN
enum AnimationType enum AnimationType
{ {
@ -47,41 +47,34 @@ enum AnimationType
}; };
class ProcessBase : public Object class CCProcessBase : public Object
{ {
public: public:
/** CCProcessBase(void);
* @js ctor ~CCProcessBase(void);
*/
ProcessBase(void);
/**
* @js NA
* @lua NA
*/
~ProcessBase(void);
/** /**
* Play animation by animation name. * Play animation by animation name.
* *
* @param animation It will not used in the ProcessBase Class * @param animation It will not used in the CCProcessBase Class
* @param durationTo The frames between two animation changing-over. * @param durationTo The frames between two animation changing-over.
* It's meaning is changing to this animation need how many frames * It's meaning is changing to this animation need how many frames
* *
* -1 : use the value from MovementData get from flash design panel * -1 : use the value from CCMovementData get from flash design panel
* @param durationTween The frame count you want to play in the game. * @param durationTween The frame count you want to play in the game.
* if _durationTween is 80, then the animation will played 80 frames in a loop * if _durationTween is 80, then the animation will played 80 frames in a loop
* *
* -1 : use the value from MovementData get from flash design panel * -1 : use the value from CCMovementData get from flash design panel
* *
* @param loop Whether the animation is loop * @param loop Whether the animation is loop
* *
* loop < 0 : use the value from MovementData get from flash design panel * loop < 0 : use the value from CCMovementData get from flash design panel
* loop = 0 : this animation is not loop * loop = 0 : this animation is not loop
* loop > 0 : this animation is loop * loop > 0 : this animation is loop
* *
* @param tweenEasing Tween easing is used for calculate easing effect * @param tweenEasing CCTween easing is used for calculate easing effect
* *
* TWEEN_EASING_MAX : use the value from MovementData get from flash design panel * TWEEN_EASING_MAX : use the value from CCMovementData get from flash design panel
* -1 : fade out * -1 : fade out
* 0 : line * 0 : line
* 1 : fade in * 1 : fade in
@ -110,7 +103,7 @@ public:
* You should never call this function, unless you know what you do * You should never call this function, unless you know what you do
* Update the Process, include current process, current frame and son on * Update the Process, include current process, current frame and son on
* *
* @param dt The duration since last update * @param The duration since last update
*/ */
virtual void update(float dt); virtual void update(float dt);
@ -125,50 +118,50 @@ protected:
virtual void updateHandler() {}; virtual void updateHandler() {};
protected: protected:
//! Scale the animation speed //! Scale the process speed
CC_SYNTHESIZE_PASS_BY_REF(float, _animationScale, AnimationScale); CC_SYNTHESIZE(float, m_fProcessScale, ProcessScale);
//! Set and get whether the aniamtion is pause //! Set and get whether the aniamtion is pause
CC_SYNTHESIZE_PASS_BY_REF(bool, _isPause, IsPause); CC_SYNTHESIZE(bool, m_bIsPause, IsPause);
//! Set and get whether the aniamtion is complete //! Set and get whether the aniamtion is complete
CC_SYNTHESIZE_PASS_BY_REF(bool, _isComplete, IsComplete); CC_SYNTHESIZE(bool, m_bIsComplete, IsComplete);
//! Set and get whether the aniamtion is playing //! Set and get whether the aniamtion is playing
CC_SYNTHESIZE_PASS_BY_REF(bool, _isPlaying, IsPlaying); CC_SYNTHESIZE(bool, m_bIsPlaying, IsPlaying);
//! Current percent this process arrived //! Current percent this process arrived
CC_SYNTHESIZE_PASS_BY_REF(float, _currentPercent, CurrentPercent); CC_SYNTHESIZE(float, m_fCurrentPercent, CurrentPercent);
//! The raw duration //! The raw duration
CC_SYNTHESIZE_PASS_BY_REF(int, _rawDuration, RawDuration); CC_SYNTHESIZE(int, m_iRawDuration, RawDuration);
//! The animation whether or not loop //! The animation whether or not loop
CC_SYNTHESIZE_PASS_BY_REF(AnimationType, _loopType, LoopType); CC_SYNTHESIZE(AnimationType, m_eLoopType, LoopType);
//! The tween easing effect //! The tween easing effect
CC_SYNTHESIZE_PASS_BY_REF(TweenType, _tweenEasing, TweenEasing); CC_SYNTHESIZE(CCTweenType, m_eTweenEasing, TweenEasing);
//! The animation update speed //! The animation update speed
CC_SYNTHESIZE_PASS_BY_REF(float, _animationInternal, AnimationInternal); CC_SYNTHESIZE(float, m_fAnimationInternal, AnimationInternal);
protected: protected:
//! The durantion frame count will run //! The durantion frame count will run
int _durationTween; int m_iDurationTween;
//! Current frame this process arrived, this frame is tween frame //! Current frame this process arrived, this frame is tween frame
float _currentFrame; float m_fCurrentFrame;
//! Frame index it the time line //! Frame index it the time line
int _curFrameIndex; int m_iCurFrameIndex;
//! Next frame this process need run to //! Next frame this process need run to
int _nextFrameIndex; int m_iNextFrameIndex;
bool _isLoopBack; bool m_bIsLoopBack;
}; };
}}} // namespace cocos2d { namespace extension { namespace armature { NS_CC_EXT_ARMATURE_END
#endif /*__CCPROCESSBASE_H__*/ #endif /*__CCPROCESSBASE_H__*/

399
extensions/CocoStudio/Armature/animation/CCTween.cpp
View File

@ -29,13 +29,14 @@ THE SOFTWARE.
#include "../CCArmature.h" #include "../CCArmature.h"
#include "../utils/CCUtilMath.h" #include "../utils/CCUtilMath.h"
#include "../utils/CCTweenFunction.h" #include "../utils/CCTweenFunction.h"
#include "../utils/CCTransformHelp.h"
namespace cocos2d { namespace extension { namespace armature { NS_CC_EXT_ARMATURE_BEGIN
Tween *Tween::create(Bone *bone) CCTween *CCTween::create(CCBone *bone)
{ {
Tween *pTween = new Tween(); CCTween *pTween = new CCTween();
if (pTween && pTween->init(bone)) if (pTween && pTween->init(bone))
{ {
pTween->autorelease(); pTween->autorelease();
@ -48,43 +49,43 @@ Tween *Tween::create(Bone *bone)
Tween::Tween() CCTween::CCTween()
: _movementBoneData(NULL) : m_pMovementBoneData(NULL)
, _tweenData(NULL) , m_pTweenData(NULL)
, _from(NULL) , m_pFrom(NULL)
, _to(NULL) , m_pTo(NULL)
, _between(NULL) , m_pBetween(NULL)
, _currentKeyFrame(NULL) , m_pBone(NULL)
, _bone(NULL)
, m_eFrameTweenEasing(Linear)
, _frameTweenEasing(Linear) , m_iFromIndex(0)
, _fromIndex(0) , m_iToIndex(0)
, _toIndex(0) , m_pAnimation(NULL)
, _animation(NULL)
{ {
} }
Tween::~Tween(void) CCTween::~CCTween(void)
{ {
CC_SAFE_DELETE( _from ); CC_SAFE_DELETE( m_pFrom );
CC_SAFE_DELETE( _between ); CC_SAFE_DELETE( m_pBetween );
} }
bool Tween::init(Bone *bone) bool CCTween::init(CCBone *bone)
{ {
bool bRet = false; bool bRet = false;
do do
{ {
_from = new FrameData(); m_pFrom = new CCFrameData();
_between = new FrameData(); m_pBetween = new CCFrameData();
_bone = bone; m_pBone = bone;
_tweenData = _bone->getTweenData(); m_pTweenData = m_pBone->getTweenData();
m_pTweenData->displayIndex = -1;
_animation = _bone->getArmature() != NULL ? _bone->getArmature()->getAnimation() : NULL; m_pAnimation = m_pBone->getArmature() != NULL ? m_pBone->getArmature()->getAnimation() : NULL;
bRet = true; bRet = true;
} }
@ -94,200 +95,201 @@ bool Tween::init(Bone *bone)
} }
void Tween::play(MovementBoneData *movementBoneData, int durationTo, int durationTween, int loop, int tweenEasing) void CCTween::play(CCMovementBoneData *movementBoneData, int durationTo, int durationTween, int loop, int tweenEasing)
{ {
ProcessBase::play(NULL, durationTo, durationTween, loop, tweenEasing); CCProcessBase::play(NULL, durationTo, durationTween, loop, tweenEasing);
_loopType = (AnimationType)loop; m_eLoopType = (AnimationType)loop;
_currentKeyFrame = NULL; m_iTotalDuration = 0;
_isTweenKeyFrame = false; m_iBetweenDuration = 0;
m_iFromIndex = m_iToIndex = 0;
_totalDuration = 0; bool difMovement = movementBoneData != m_pMovementBoneData;
betweenDuration = 0;
_toIndex = 0;
setMovementBoneData(movementBoneData); setMovementBoneData(movementBoneData);
m_iRawDuration = m_pMovementBoneData->duration;
CCFrameData *nextKeyFrame = m_pMovementBoneData->getFrameData(0);
m_pTweenData->displayIndex = nextKeyFrame->displayIndex;
if (_movementBoneData->frameList->count() == 1) if (m_pBone->getArmature()->getArmatureData()->dataVersion >= VERSION_COMBINED)
{ {
_loopType = SINGLE_FRAME; CCTransformHelp::nodeSub(*m_pTweenData, *m_pBone->getBoneData());
FrameData *_nextKeyFrame = _movementBoneData->getFrameData(0); m_pTweenData->scaleX += 1;
m_pTweenData->scaleY += 1;
}
if (m_iRawDuration == 0 )
{
m_eLoopType = SINGLE_FRAME;
if(durationTo == 0) if(durationTo == 0)
{ {
setBetween(_nextKeyFrame, _nextKeyFrame); setBetween(nextKeyFrame, nextKeyFrame);
} }
else else
{ {
_tweenData->displayIndex = _nextKeyFrame->displayIndex; setBetween(m_pTweenData, nextKeyFrame);
setBetween(_tweenData, _nextKeyFrame);
} }
_isTweenKeyFrame = true; m_eFrameTweenEasing = Linear;
_frameTweenEasing = Linear;
_rawDuration = _movementBoneData->duration;
_fromIndex = _toIndex = 0;
} }
else if (_movementBoneData->frameList->count() > 1) else if (m_pMovementBoneData->frameList.count() > 1)
{ {
if (loop) if (loop)
{ {
_loopType = ANIMATION_TO_LOOP_BACK; m_eLoopType = ANIMATION_TO_LOOP_BACK;
_rawDuration = _movementBoneData->duration;
} }
else else
{ {
_loopType = ANIMATION_NO_LOOP; m_eLoopType = ANIMATION_NO_LOOP;
_rawDuration = _movementBoneData->duration - 1;
} }
_durationTween = durationTween * _movementBoneData->scale; m_iDurationTween = durationTween * m_pMovementBoneData->scale;
if (loop && _movementBoneData->delay != 0) if (loop && m_pMovementBoneData->delay != 0)
{ {
setBetween(_tweenData, tweenNodeTo(updateFrameData(1 - _movementBoneData->delay), _between)); setBetween(m_pTweenData, tweenNodeTo(updateFrameData(1 - m_pMovementBoneData->delay), m_pBetween));
} }
else else
{ {
FrameData *_nextKeyFrame = _movementBoneData->getFrameData(0); if (!difMovement || durationTo == 0)
setBetween(_tweenData, _nextKeyFrame); {
_isTweenKeyFrame = true; setBetween(nextKeyFrame, nextKeyFrame);
}
else
{
setBetween(m_pTweenData, nextKeyFrame);
}
} }
} }
tweenNodeTo(0);
} }
void Tween::updateHandler() void CCTween::updateHandler()
{ {
if (m_fCurrentPercent >= 1)
if (_currentPercent >= 1)
{ {
switch(_loopType) switch(m_eLoopType)
{ {
case SINGLE_FRAME: case SINGLE_FRAME:
{ {
_currentPercent = 1; m_fCurrentPercent = 1;
_isComplete = true; m_bIsComplete = true;
m_bIsPlaying = false;
} }
break; break;
case ANIMATION_NO_LOOP: case ANIMATION_NO_LOOP:
{ {
_loopType = ANIMATION_MAX; m_eLoopType = ANIMATION_MAX;
if (_durationTween <= 0) if (m_iDurationTween <= 0)
{ {
_currentPercent = 1; m_fCurrentPercent = 1;
} }
else else
{ {
_currentPercent = (_currentPercent - 1) * _nextFrameIndex / _durationTween; m_fCurrentPercent = (m_fCurrentPercent - 1) * m_iNextFrameIndex / m_iDurationTween;
} }
if (_currentPercent >= 1) if (m_fCurrentPercent >= 1)
{ {
_currentPercent = 1; m_fCurrentPercent = 1;
_isComplete = true; m_bIsComplete = true;
m_bIsPlaying = false;
break; break;
} }
else else
{ {
_nextFrameIndex = _durationTween; m_iNextFrameIndex = m_iDurationTween;
_currentFrame = _currentPercent * _nextFrameIndex; m_fCurrentFrame = m_fCurrentPercent * m_iNextFrameIndex;
_totalDuration = 0; m_iTotalDuration = 0;
betweenDuration = 0; m_iBetweenDuration = 0;
_toIndex = 0; m_iFromIndex = m_iToIndex = 0;
break; break;
} }
} }
break; break;
case ANIMATION_TO_LOOP_BACK: case ANIMATION_TO_LOOP_BACK:
{ {
_loopType = ANIMATION_LOOP_BACK; m_eLoopType = ANIMATION_LOOP_BACK;
_nextFrameIndex = _durationTween > 0 ? _durationTween : 1; m_iNextFrameIndex = m_iDurationTween > 0 ? m_iDurationTween : 1;
if (_movementBoneData->delay != 0) if (m_pMovementBoneData->delay != 0)
{ {
// //
_currentFrame = (1 - _movementBoneData->delay) * (float)_nextFrameIndex; m_fCurrentFrame = (1 - m_pMovementBoneData->delay) * (float)m_iNextFrameIndex;
_currentPercent = _currentFrame / _nextFrameIndex; m_fCurrentPercent = m_fCurrentFrame / m_iNextFrameIndex;
} }
else else
{ {
_currentPercent = 0; m_fCurrentPercent = 0;
_currentFrame = 0; m_fCurrentFrame = 0;
} }
_totalDuration = 0; m_iTotalDuration = 0;
betweenDuration = 0; m_iBetweenDuration = 0;
_toIndex = 0; m_iFromIndex = m_iToIndex = 0;
} }
break; break;
case ANIMATION_MAX: case ANIMATION_MAX:
{ {
_currentPercent = 1; m_fCurrentPercent = 1;
_isComplete = true; m_bIsComplete = true;
m_bIsPlaying = false;
} }
break; break;
default: default:
{ {
_currentPercent = fmodf(_currentPercent, 1); m_fCurrentFrame = fmodf(m_fCurrentFrame, m_iNextFrameIndex);
_currentFrame = fmodf(_currentFrame, _nextFrameIndex);
_totalDuration = 0; m_iTotalDuration = 0;
betweenDuration = 0; m_iBetweenDuration = 0;
_toIndex = 0; m_iFromIndex = m_iToIndex = 0;
} }
break; break;
} }
} }
if (m_fCurrentPercent < 1 && m_eLoopType <= ANIMATION_TO_LOOP_BACK)
if (_currentPercent < 1 && _loopType <= ANIMATION_TO_LOOP_BACK)
{ {
_currentPercent = sin(_currentPercent * CC_HALF_PI); m_fCurrentPercent = sin(m_fCurrentPercent * CC_HALF_PI);
} }
float percent = _currentPercent; float percent = m_fCurrentPercent;
if (_loopType > ANIMATION_TO_LOOP_BACK) if (m_eLoopType > ANIMATION_TO_LOOP_BACK)
{ {
percent = updateFrameData(percent, true); percent = updateFrameData(percent);
} }
if(_frameTweenEasing != TWEEN_EASING_MAX) if(m_eFrameTweenEasing != TWEEN_EASING_MAX)
{ {
tweenNodeTo(percent); tweenNodeTo(percent);
} }
else if(_currentKeyFrame)
{
tweenNodeTo(0);
}
} }
void Tween::setBetween(FrameData *from, FrameData *to) void CCTween::setBetween(CCFrameData *from, CCFrameData *to)
{ {
do do
{ {
if(to->displayIndex < 0 && from->displayIndex > 0) if(from->displayIndex < 0 && to->displayIndex >= 0)
{ {
_from->copy(from); m_pFrom->copy(to);
_between->subtract(to, to); m_pBetween->subtract(to, to);
break; break;
} }
else if(from->displayIndex < 0 && to->displayIndex > 0) else if(to->displayIndex < 0 && from->displayIndex >= 0)
{ {
_from->copy(to); m_pFrom->copy(from);
_between->subtract(to, to); m_pBetween->subtract(to, to);
break; break;
} }
_from->copy(from); m_pFrom->copy(from);
_between->subtract(from, to); m_pBetween->subtract(from, to);
} }
while (0); while (0);
@ -295,145 +297,158 @@ void Tween::setBetween(FrameData *from, FrameData *to)
} }
void Tween::arriveKeyFrame(FrameData *keyFrameData) void CCTween::arriveKeyFrame(CCFrameData *keyFrameData)
{ {
if(keyFrameData) if(keyFrameData)
{ {
CCDisplayManager *displayManager = m_pBone->getDisplayManager();
//! Change bone's display
int displayIndex = keyFrameData->displayIndex; int displayIndex = keyFrameData->displayIndex;
if (!_bone->getDisplayManager()->getForceChangeDisplay()) if (!displayManager->getForceChangeDisplay())
{ {
_bone->getDisplayManager()->changeDisplayByIndex(displayIndex, false); displayManager->changeDisplayByIndex(displayIndex, false);
} }
//! Update bone zorder, bone's zorder is determined by frame zorder and bone zorder
m_pTweenData->zOrder = keyFrameData->zOrder;
m_pBone->updateZOrder();
_bone->setZOrder(keyFrameData->zOrder); //! Update blend type
m_pBone->setBlendType(keyFrameData->blendType);
Armature *childAramture = _bone->getChildArmature();
//! Update child armature's movement
CCArmature *childAramture = m_pBone->getChildArmature();
if(childAramture) if(childAramture)
{ {
if(keyFrameData->_movement.length() != 0) if(keyFrameData->strMovement.length() != 0)
{ {
childAramture->getAnimation()->play(keyFrameData->_movement.c_str()); childAramture->getAnimation()->play(keyFrameData->strMovement.c_str());
} }
} }
if(keyFrameData->_event.length() != 0)
{
_animation->FrameEventSignal.emit(_bone, keyFrameData->_event.c_str());
}
// if(keyFrameData->_sound.length() != 0)
// {
// //soundManager.dispatchEventWith(Event.SOUND_FRAME, _currentKeyFrame->sound);
// }
} }
} }
CCFrameData *CCTween::tweenNodeTo(float percent, CCFrameData *node)
FrameData *Tween::tweenNodeTo(float percent, FrameData *node)
{ {
node = node == NULL ? m_pTweenData : node;
node = node == NULL ? _tweenData : node; node->x = m_pFrom->x + percent * m_pBetween->x;
node->y = m_pFrom->y + percent * m_pBetween->y;
node->scaleX = m_pFrom->scaleX + percent * m_pBetween->scaleX;
node->scaleY = m_pFrom->scaleY + percent * m_pBetween->scaleY;
node->skewX = m_pFrom->skewX + percent * m_pBetween->skewX;
node->skewY = m_pFrom->skewY + percent * m_pBetween->skewY;
node->x = _from->x + percent * _between->x; m_pBone->setTransformDirty(true);
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 && m_pBetween->isUseColorInfo)
if(_between->isUseColorInfo)
{ {
node->a = _from->a + percent * _between->a; tweenColorTo(percent, node);
node->r = _from->r + percent * _between->r;
node->g = _from->g + percent * _between->g;
node->b = _from->b + percent * _between->b;
_bone->updateColor();
} }
// Point p1 = Point(_from->x, _from->y);
// Point p2 = Point(100, 0);
// Point p3 = Point(200, 400);
// Point p4 = Point(_from->x + _between->x, _from->y + _between->y);
//
// Point p = bezierTo(percent, p1, p2, p3, p4);
// node->x = p.x;
// node->y = p.y;
return node; return node;
} }
float Tween::updateFrameData(float currentPrecent, bool activeFrame) void CCTween::tweenColorTo(float percent, CCFrameData *node)
{ {
node->a = m_pFrom->a + percent * m_pBetween->a;
node->r = m_pFrom->r + percent * m_pBetween->r;
node->g = m_pFrom->g + percent * m_pBetween->g;
node->b = m_pFrom->b + percent * m_pBetween->b;
m_pBone->updateColor();
}
float playedTime = (float)_rawDuration * currentPrecent; float CCTween::updateFrameData(float currentPercent)
{
if (currentPercent > 1 && m_pMovementBoneData->delay != 0)
{
currentPercent = fmodf(currentPercent, 1);
}
float playedTime = (float)m_iRawDuration * currentPercent;
FrameData *from;
FrameData *to;
bool isListEnd;
//! If play to current frame's front or back, then find current frame again //! If play to current frame's front or back, then find current frame again
if (playedTime >= _totalDuration || playedTime < _totalDuration - betweenDuration) if (playedTime < m_iTotalDuration || playedTime >= m_iTotalDuration + m_iBetweenDuration)
{ {
/* /*
* Get frame length, if _toIndex >= _length, then set _toIndex to 0, start anew. * Get frame length, if m_iToIndex >= _length, then set m_iToIndex to 0, start anew.
* _toIndex is next index will play * m_iToIndex is next index will play
*/ */
int length = _movementBoneData->frameList->count(); int length = m_pMovementBoneData->frameList.count();
CCFrameData **frames = (CCFrameData **)m_pMovementBoneData->frameList.data->arr;
CCFrameData *from = NULL;
CCFrameData *to = NULL;
if (playedTime < frames[0]->frameID)
{
from = to = frames[0];
setBetween(from, to);
return currentPercent;
}
else if(playedTime >= frames[length - 1]->frameID)
{
from = to = frames[length - 1];
setBetween(from, to);
return currentPercent;
}
do do
{ {
betweenDuration = _movementBoneData->getFrameData(_toIndex)->duration; from = frames[m_iFromIndex];
_totalDuration += betweenDuration; m_iTotalDuration = from->frameID;
_fromIndex = _toIndex;
if (++_toIndex >= length) if (++m_iToIndex >= length)
{ {
_toIndex = 0; m_iToIndex = 0;
}
m_iFromIndex = m_iToIndex;
to = frames[m_iToIndex];
//! Guaranteed to trigger frame event
if(from->strEvent.length() != 0)
{
m_pAnimation->frameEvent(m_pBone, from->strEvent.c_str(), from->frameID, playedTime);
}
if (playedTime == from->frameID)
{
break;
} }
} }
while (playedTime >= _totalDuration); while (playedTime < from->frameID || playedTime >= to->frameID);
m_iBetweenDuration = to->frameID - from->frameID;
isListEnd = _loopType == ANIMATION_MAX && _toIndex == 0; m_eFrameTweenEasing = from->tweenEasing;
if(isListEnd)
{
to = from = _movementBoneData->getFrameData(_fromIndex);
}
else
{
from = _movementBoneData->getFrameData(_fromIndex);
to = _movementBoneData->getFrameData(_toIndex);
}
_frameTweenEasing = from->tweenEasing;
setBetween(from, to); setBetween(from, to);
} }
currentPrecent = 1 - (_totalDuration - playedTime) / (float)betweenDuration; currentPercent = m_iBetweenDuration == 0 ? 0 : (playedTime - m_iTotalDuration) / (float)m_iBetweenDuration;
/* /*
* If frame tween easing equal to TWEEN_EASING_MAX, then it will not do tween. * If frame tween easing equal to TWEEN_EASING_MAX, then it will not do tween.
*/ */
TweenType tweenType; CCTweenType tweenType;
if ( _frameTweenEasing != TWEEN_EASING_MAX) if ( m_eFrameTweenEasing != TWEEN_EASING_MAX)
{ {
tweenType = (_tweenEasing == TWEEN_EASING_MAX) ? _frameTweenEasing : _tweenEasing; tweenType = (m_eTweenEasing == TWEEN_EASING_MAX) ? m_eFrameTweenEasing : m_eTweenEasing;
if (tweenType != TWEEN_EASING_MAX) if (tweenType != TWEEN_EASING_MAX && tweenType != Linear)
{ {
currentPrecent = TweenFunction::tweenTo(0, 1, currentPrecent, 1, tweenType); currentPercent = CCTweenFunction::tweenTo(0, 1, currentPercent, 1, tweenType);
} }
} }
return currentPrecent; return currentPercent;
} }
}}} // namespace cocos2d { namespace extension { namespace armature { NS_CC_EXT_ARMATURE_END

114
extensions/CocoStudio/Armature/animation/CCTween.h
View File

@ -29,68 +29,61 @@ THE SOFTWARE.
#include "CCProcessBase.h" #include "CCProcessBase.h"
#include "../utils/CCTweenFunction.h" #include "../utils/CCTweenFunction.h"
namespace cocos2d { namespace extension { namespace armature { NS_CC_EXT_ARMATURE_BEGIN
class Bone; class CCBone;
class ArmatureAnimation; class CCArmatureAnimation;
class Tween : public ProcessBase class CCTween : public CCProcessBase
{ {
public: public:
/** /**
* Create with a Bone * Create with a CCBone
* @param bone the Bone Tween will bind to * @param bone the CCBone CCTween will bind to
*/ */
static Tween *create(Bone *bone); static CCTween *create(CCBone *bone);
public: public:
/** CCTween(void);
* @js ctor virtual ~CCTween(void);
*/
Tween(void);
/**
* @js NA
* @lua NA
*/
virtual ~Tween(void);
/** /**
* Init with a Bone * Init with a CCBone
* @param bone the Bone Tween will bind to * @param bone the CCBone CCTween will bind to
*/ */
virtual bool init(Bone *bone); virtual bool init(CCBone *bone);
/** /**
* Start the Process * Start the Process
* *
* @param movementBoneData the MovementBoneData include all frame datas * @param movementBoneData the CCMovementBoneData include all CCFrameData
* @param durationTo the frames between two animation changing-over. * @param durationTo the number of frames changing to this animation needs.
* It's meaning is changing to this animation need how many frames * @param durationTween the number of frames this animation actual last.
*
* -1 : use the value from MovementData get from flash design panel
* @param durationTween the frame count you want to play in the game.
* if _durationTween is 80, then the animation will played 80 frames in a loop
*
* -1 : use the value from MovementData get from flash design panel
* *
* @param loop whether the animation is loop * @param loop whether the animation is loop
* *
* loop < 0 : use the value from MovementData get from flash design panel * loop < 0 : use the value from CCMovementData get from Action Editor
* loop = 0 : this animation is not loop * loop = 0 : this animation is not loop
* loop > 0 : this animation is loop * loop > 0 : this animation is loop
* *
* @param tweenEasing tween easing is used for calculate easing effect * @param tweenEasing tween easing is used for calculate easing effect
* *
* TWEEN_EASING_MAX : use the value from MovementData get from flash design panel * TWEEN_EASING_MAX : use the value from CCMovementData get from Action Editor
* -1 : fade out * -1 : fade out
* 0 : line * 0 : line
* 1 : fade in * 1 : fade in
* 2 : fade in and out * 2 : fade in and out
* *
*/ */
virtual void play(MovementBoneData *movementBoneData, int durationTo, int durationTween, int loop, int tweenEasing); virtual void play(CCMovementBoneData *movementBoneData, int durationTo, int durationTween, int loop, int tweenEasing);
inline void setAnimation(ArmatureAnimation *animation) { _animation = animation; } inline void setAnimation(CCArmatureAnimation *animation)
inline ArmatureAnimation *getAnimation() const { return _animation; } {
m_pAnimation = animation;
}
inline CCArmatureAnimation *getAnimation() const
{
return m_pAnimation;
}
protected: protected:
/** /**
@ -101,49 +94,52 @@ protected:
/** /**
* Calculate which frame arrived, and if current frame have event, then call the event listener * Calculate which frame arrived, and if current frame have event, then call the event listener
*/ */
virtual float updateFrameData(float currentPrecent, bool activeFrame = false); virtual float updateFrameData(float currentPercent);
/** /**
* Calculate the between value of _from and _to, and give it to between frame data * Calculate the between value of _from and _to, and give it to between frame data
*/ */
virtual void setBetween(FrameData *from, FrameData *to); virtual void setBetween(CCFrameData *from, CCFrameData *to);
/** /**
* According to the percent to calculate current FrameData with tween effect * According to the percent to calculate current CCFrameData with tween effect
*/ */
virtual FrameData *tweenNodeTo(float percent, FrameData *node = NULL); virtual CCFrameData *tweenNodeTo(float percent, CCFrameData *node = NULL);
/**
* According to the percent to calculate current color with tween effect
*/
virtual void tweenColorTo(float percent, CCFrameData *node);
/** /**
* Update display index and process the key frame event when arrived a key frame * Update display index and process the key frame event when arrived a key frame
*/ */
virtual void arriveKeyFrame(FrameData *keyFrameData); virtual void arriveKeyFrame(CCFrameData *keyFrameData);
protected: protected:
//! A weak reference to the current MovementBoneData. The data is in the data pool //! A weak reference to the current CCMovementBoneData. The data is in the data pool
CC_SYNTHESIZE(MovementBoneData *, _movementBoneData, MovementBoneData) CC_SYNTHESIZE(CCMovementBoneData *, m_pMovementBoneData, MovementBoneData)
FrameData *_tweenData; //! The computational tween frame data, //! A weak reference to the Bone's tweenData CCFrameData *m_pTweenData; //! The computational tween frame data, //! A weak reference to the CCBone's tweenData
FrameData *_from; //! From frame data, used for calculate between value CCFrameData *m_pFrom; //! From frame data, used for calculate between value
FrameData *_to; //! To frame data, used for calculate between value CCFrameData *m_pTo; //! To frame data, used for calculate between value
FrameData *_between; //! Between frame data, used for calculate current FrameData(_node) value CCFrameData *m_pBetween; //! Between frame data, used for calculate current CCFrameData(m_pNode) value
FrameData *_currentKeyFrame; //! A weak reference to the current FrameData. The data is in the data pool
Bone *_bone; //! A weak reference to the Bone
TweenType _frameTweenEasing; //! Dedermine which tween effect current frame use
bool _isTweenKeyFrame;
int betweenDuration; //! Current key frame will last betweenDuration frames
int _totalDuration;
int _fromIndex; //! The current frame index in FrameList of MovementBoneData, it's different from _frameIndex CCBone *m_pBone; //! A weak reference to the CCBone
int _toIndex; //! The next frame index in FrameList of MovementBoneData, it's different from _frameIndex
CCTweenType m_eFrameTweenEasing; //! Dedermine which tween effect current frame use
int m_iBetweenDuration; //! Current key frame will last m_iBetweenDuration frames
int m_iTotalDuration;
int m_iFromIndex; //! The current frame index in FrameList of CCMovementBoneData, it's different from m_iFrameIndex
int m_iToIndex; //! The next frame index in FrameList of CCMovementBoneData, it's different from m_iFrameIndex
CCArmatureAnimation *m_pAnimation;
ArmatureAnimation *_animation;
}; };
}}} // namespace cocos2d { namespace extension { namespace armature { NS_CC_EXT_ARMATURE_END
#endif /*__CCTWEEN_H__*/ #endif /*__CCTWEEN_H__*/

373
extensions/CocoStudio/Armature/datas/CCDatas.cpp
View File

@ -24,102 +24,119 @@ THE SOFTWARE.
#include "CCDatas.h" #include "CCDatas.h"
#include "../utils/CCUtilMath.h" #include "../utils/CCUtilMath.h"
#include "../utils/CCTransformHelp.h"
namespace cocos2d { namespace extension { namespace armature { NS_CC_EXT_ARMATURE_BEGIN
BaseData::BaseData() CCBaseData::CCBaseData()
: x(0.0f) : x(0.0f)
, y(0.0f) , y(0.0f)
, zOrder(0) , zOrder(0)
, skewX(0.0f) , skewX(0.0f)
, skewY(0.0f) , skewY(0.0f)
, scaleX(1.0f) , scaleX(1.0f)
, scaleY(1.0f) , scaleY(1.0f)
, tweenRotate(0.0f) , tweenRotate(0.0f)
, isUseColorInfo(false) , isUseColorInfo(false)
, a(255) , a(255)
, r(255) , r(255)
, g(255) , g(255)
, b(255) , b(255)
{ {
} }
BaseData::~BaseData() CCBaseData::~CCBaseData()
{ {
} }
void BaseData::copy(const BaseData *node ) void CCBaseData::copy(const CCBaseData *node )
{ {
x = node->x; x = node->x;
y = node->y; y = node->y;
zOrder = node->zOrder; zOrder = node->zOrder;
scaleX = node->scaleX; scaleX = node->scaleX;
scaleY = node->scaleY; scaleY = node->scaleY;
skewX = node->skewX; skewX = node->skewX;
skewY = node->skewY; skewY = node->skewY;
tweenRotate = node->tweenRotate; tweenRotate = node->tweenRotate;
isUseColorInfo = node->isUseColorInfo; isUseColorInfo = node->isUseColorInfo;
r = node->r; r = node->r;
g = node->g; g = node->g;
b = node->b; b = node->b;
a = node->a; a = node->a;
} }
void BaseData::subtract(BaseData *from, BaseData *to) void CCBaseData::subtract(CCBaseData *from, CCBaseData *to)
{ {
x = to->x - from->x; x = to->x - from->x;
y = to->y - from->y; y = to->y - from->y;
scaleX = to->scaleX - from->scaleX; scaleX = to->scaleX - from->scaleX;
scaleY = to->scaleY - from->scaleY; scaleY = to->scaleY - from->scaleY;
skewX = to->skewX - from->skewX; skewX = to->skewX - from->skewX;
skewY = to->skewY - from->skewY; skewY = to->skewY - from->skewY;
if(from->isUseColorInfo || to->isUseColorInfo) if(isUseColorInfo || from->isUseColorInfo || to->isUseColorInfo)
{ {
a = to->a - from->a; a = to->a - from->a;
r = to->r - from->r; r = to->r - from->r;
g = to->g - from->g; g = to->g - from->g;
b = to->b - from->b; b = to->b - from->b;
isUseColorInfo = true; isUseColorInfo = true;
} }
else
{
a = r = g = b = 0;
isUseColorInfo = false;
}
if (skewX > M_PI)
{
skewX -= (float)CC_DOUBLE_PI;
}
if (skewX < -M_PI)
{
skewX += (float)CC_DOUBLE_PI;
}
if (skewX > M_PI) if (skewY > M_PI)
{ {
skewX -= (float)CC_DOUBLE_PI; skewY -= (float)CC_DOUBLE_PI;
} }
if (skewX < -M_PI) if (skewY < -M_PI)
{ {
skewX += (float)CC_DOUBLE_PI; skewY += (float)CC_DOUBLE_PI;
} }
if (skewY > M_PI) if (to->tweenRotate)
{ {
skewY -= (float)CC_DOUBLE_PI; skewX += to->tweenRotate;
} skewY -= to->tweenRotate;
if (skewY < -M_PI) }
{
skewY += (float)CC_DOUBLE_PI;
}
if (to->tweenRotate)
{
skewX += to->tweenRotate;
skewY -= to->tweenRotate;
}
} }
void CCBaseData::setColor(const Color4B &color)
{
r = color.r;
g = color.g;
b = color.b;
a = color.a;
}
const char *DisplayData::changeDisplayToTexture(const char *displayName) Color4B CCBaseData::getColor()
{
return Color4B(r, g, b, a);
}
const char *CCDisplayData::changeDisplayToTexture(const char *displayName)
{ {
// remove .xxx // remove .xxx
std::string textureName = displayName; std::string textureName = displayName;
@ -133,304 +150,274 @@ const char *DisplayData::changeDisplayToTexture(const char *displayName)
return textureName.c_str(); return textureName.c_str();
} }
DisplayData::DisplayData(void) CCDisplayData::CCDisplayData(void)
: displayType(CS_DISPLAY_SPRITE) : displayType(CS_DISPLAY_MAX)
{ {
} }
DisplayData::~DisplayData(void) CCDisplayData::~CCDisplayData(void)
{ {
} }
SpriteDisplayData::SpriteDisplayData(void) CCSpriteDisplayData::CCSpriteDisplayData(void)
: displayName("") : displayName("")
{ {
displayType = CS_DISPLAY_SPRITE; displayType = CS_DISPLAY_SPRITE;
} }
SpriteDisplayData::~SpriteDisplayData() CCSpriteDisplayData::~CCSpriteDisplayData()
{ {
} }
void SpriteDisplayData::copy(SpriteDisplayData *displayData) void CCSpriteDisplayData::copy(CCSpriteDisplayData *displayData)
{ {
displayName = displayData->displayName; displayName = displayData->displayName;
displayType = displayData->displayType; displayType = displayData->displayType;
skinData = displayData->skinData;
} }
ArmatureDisplayData::ArmatureDisplayData(void) CCArmatureDisplayData::CCArmatureDisplayData(void)
: displayName("") : displayName("")
{ {
displayType = CS_DISPLAY_ARMATURE; displayType = CS_DISPLAY_ARMATURE;
} }
ArmatureDisplayData::~ArmatureDisplayData() CCArmatureDisplayData::~CCArmatureDisplayData()
{ {
} }
void ArmatureDisplayData::copy(ArmatureDisplayData *displayData) void CCArmatureDisplayData::copy(CCArmatureDisplayData *displayData)
{ {
displayName = displayData->displayName; displayName = displayData->displayName;
displayType = displayData->displayType; displayType = displayData->displayType;
} }
ParticleDisplayData::ParticleDisplayData(void) CCParticleDisplayData::CCParticleDisplayData(void)
: plist("") : plist("")
{ {
displayType = CS_DISPLAY_PARTICLE; displayType = CS_DISPLAY_PARTICLE;
} }
void ParticleDisplayData::copy(ParticleDisplayData *displayData) void CCParticleDisplayData::copy(CCParticleDisplayData *displayData)
{ {
plist = displayData->plist; plist = displayData->plist;
displayType = displayData->displayType; displayType = displayData->displayType;
} }
ShaderDisplayData::ShaderDisplayData(void)
: vert("")
, frag("")
{
displayType = CS_DISPLAY_SHADER;
}
void ShaderDisplayData::copy(ShaderDisplayData *displayData) CCBoneData::CCBoneData(void)
{
vert = displayData->vert;
frag = displayData->frag;
displayType = displayData->displayType;
}
BoneData::BoneData(void)
: name("") : name("")
, parentName("") , parentName("")
{ {
} }
BoneData::~BoneData(void) CCBoneData::~CCBoneData(void)
{ {
CC_SAFE_RELEASE(displayDataList);
} }
bool BoneData::init() bool CCBoneData::init()
{ {
displayDataList = new Array; displayDataList.init();
displayDataList->init();
return true; return true;
} }
void BoneData::addDisplayData(DisplayData *displayData) void CCBoneData::addDisplayData(CCDisplayData *displayData)
{ {
displayDataList->addObject(displayData); displayDataList.addObject(displayData);
} }
DisplayData *BoneData::getDisplayData(int index) CCDisplayData *CCBoneData::getDisplayData(int index)
{ {
return static_cast<DisplayData *>( displayDataList->getObjectAtIndex(index) ); return (CCDisplayData *)displayDataList.getObjectAtIndex(index);
} }
ArmatureData::ArmatureData()
CCArmatureData::CCArmatureData()
: dataVersion(0.1f)
{ {
} }
ArmatureData::~ArmatureData() CCArmatureData::~CCArmatureData()
{ {
CC_SAFE_RELEASE(boneList);
CC_SAFE_RELEASE(boneDataDic);
} }
bool ArmatureData::init() bool CCArmatureData::init()
{ {
boneList = new Array;
boneList->init();
boneDataDic = new Dictionary;
boneDataDic->init();
return true; return true;
} }
void ArmatureData::addBoneData(BoneData *boneData) void CCArmatureData::addBoneData(CCBoneData *boneData)
{ {
boneDataDic->setObject(boneData, boneData->name); boneDataDic.setObject(boneData, boneData->name);
boneList->addObject(boneData);
} }
BoneData *ArmatureData::getBoneData(const char *boneName) CCBoneData *CCArmatureData::getBoneData(const char *boneName)
{ {
return static_cast<BoneData *>( boneDataDic->objectForKey(boneName) ); return (CCBoneData *)boneDataDic.objectForKey(boneName);
} }
FrameData::FrameData(void) CCFrameData::CCFrameData(void)
: duration(1) : frameID(0)
, duration(1)
, tweenEasing(Linear) , tweenEasing(Linear)
, displayIndex(0) , displayIndex(0)
, blendType(BLEND_NORMAL)
, _movement("") , strEvent("")
, _event("") , strMovement("")
, _sound("") , strSound("")
, _soundEffect("") , strSoundEffect("")
{ {
} }
FrameData::~FrameData(void) CCFrameData::~CCFrameData(void)
{ {
} }
void FrameData::copy(FrameData *frameData) void CCFrameData::copy(const CCBaseData *baseData)
{ {
BaseData::copy(frameData); CCBaseData::copy(baseData);
duration = frameData->duration; if (const CCFrameData *frameData = dynamic_cast<const CCFrameData*>(baseData))
displayIndex = frameData->displayIndex; {
tweenEasing = frameData->tweenEasing; duration = frameData->duration;
displayIndex = frameData->displayIndex;
tweenEasing = frameData->tweenEasing;
blendType = frameData->blendType;
}
} }
MovementBoneData::MovementBoneData() CCMovementBoneData::CCMovementBoneData()
: delay(0.0f) : delay(0.0f)
, scale(1.0f) , scale(1.0f)
, duration(0) , duration(0)
, name("") , name("")
{ {
frameList = new Array;
frameList->init();
} }
MovementBoneData::~MovementBoneData(void) CCMovementBoneData::~CCMovementBoneData(void)
{ {
CC_SAFE_RELEASE(frameList);
} }
bool MovementBoneData::init() bool CCMovementBoneData::init()
{ {
return true; return frameList.init();
} }
void MovementBoneData::addFrameData(FrameData *frameData) void CCMovementBoneData::addFrameData(CCFrameData *frameData)
{ {
frameList->addObject(frameData); frameList.addObject(frameData);
duration += frameData->duration;
} }
FrameData *MovementBoneData::getFrameData(int index) CCFrameData *CCMovementBoneData::getFrameData(int index)
{ {
return static_cast<FrameData *>( frameList->getObjectAtIndex(index) ); return (CCFrameData *)frameList.getObjectAtIndex(index);
} }
MovementData::MovementData(void)
CCMovementData::CCMovementData(void)
: name("") : name("")
, duration(0) , duration(0)
, scale(1.0f)
, durationTo(0) , durationTo(0)
, durationTween(0) , durationTween(0)
, loop(true) , loop(true)
, tweenEasing(Linear) , tweenEasing(Linear)
{ {
movBoneDataDic = new Dictionary;
movBoneDataDic->init();
} }
MovementData::~MovementData(void) CCMovementData::~CCMovementData(void)
{ {
CC_SAFE_RELEASE(movBoneDataDic);
} }
void MovementData::addMovementBoneData(MovementBoneData *movBoneData) void CCMovementData::addMovementBoneData(CCMovementBoneData *movBoneData)
{ {
movBoneDataDic->setObject(movBoneData, movBoneData->name); movBoneDataDic.setObject(movBoneData, movBoneData->name);
} }
MovementBoneData *MovementData::getMovementBoneData(const char *boneName) CCMovementBoneData *CCMovementData::getMovementBoneData(const char *boneName)
{ {
return static_cast<MovementBoneData *>( movBoneDataDic->objectForKey(boneName) ); return (CCMovementBoneData *)movBoneDataDic.objectForKey(boneName);
} }
AnimationData::AnimationData(void) CCAnimationData::CCAnimationData(void)
{ {
movementDataDic = new Dictionary;
movementDataDic->init();
} }
AnimationData::~AnimationData(void) CCAnimationData::~CCAnimationData(void)
{ {
CC_SAFE_RELEASE(movementDataDic);
} }
void AnimationData::release() void CCAnimationData::addMovement(CCMovementData *movData)
{ {
Object::release(); movementDataDic.setObject(movData, movData->name);
}
void AnimationData::retain()
{
Object::retain();
}
void AnimationData::addMovement(MovementData *movData)
{
movementDataDic->setObject(movData, movData->name);
movementNames.push_back(movData->name); movementNames.push_back(movData->name);
} }
MovementData *AnimationData::getMovement(const char *movementName) CCMovementData *CCAnimationData::getMovement(const char *movementName)
{ {
return (MovementData *)movementDataDic->objectForKey(movementName); return (CCMovementData *)movementDataDic.objectForKey(movementName);
} }
int AnimationData::getMovementCount() int CCAnimationData::getMovementCount()
{ {
return movementDataDic->count(); return movementDataDic.count();
} }
ContourData::ContourData() CCContourData::CCContourData()
{ {
vertexList = new Array;
vertexList->init();
} }
ContourData::~ContourData() CCContourData::~CCContourData()
{ {
CC_SAFE_RELEASE(vertexList);
} }
bool ContourData::init() bool CCContourData::init()
{ {
return true; return vertexList.init();
} }
TextureData::TextureData() void CCContourData::addVertex(Point *vertex)
{
CCContourVertex2 *vertex2 = new CCContourVertex2(vertex->x, vertex->y);
vertex2->autorelease();
vertexList.addObject(vertex2);
}
CCTextureData::CCTextureData()
: height(0.0f) : height(0.0f)
, width(0.0f) , width(0.0f)
, pivotX(0.5f) , pivotX(0.5f)
, pivotY(0.5f) , pivotY(0.5f)
, name("") , name("")
{ {
contourDataList = new Array;
contourDataList->init();
} }
TextureData::~TextureData() CCTextureData::~CCTextureData()
{ {
CC_SAFE_RELEASE(contourDataList);
} }
bool TextureData::init() bool CCTextureData::init()
{ {
return true; return contourDataList.init();
} }
void TextureData::addContourData(ContourData *contourData) void CCTextureData::addContourData(CCContourData *contourData)
{ {
contourDataList->addObject(contourData); contourDataList.addObject(contourData);
} }
ContourData *TextureData::getContourData(int index) CCContourData *CCTextureData::getContourData(int index)
{ {
return static_cast<ContourData *>( contourDataList->getObjectAtIndex(index) ); return (CCContourData *)contourDataList.getObjectAtIndex(index);
} }
}}} // namespace cocos2d { namespace extension { namespace armature { NS_CC_EXT_ARMATURE_END

506
extensions/CocoStudio/Armature/datas/CCDatas.h
View File

@ -29,69 +29,65 @@ THE SOFTWARE.
#include "../utils/CCTweenFunction.h" #include "../utils/CCTweenFunction.h"
#define CS_CREATE_NO_PARAM_NO_INIT(varType)\ #define CC_CREATE_NO_PARAM_NO_INIT(varType)\
public: \ public: \
static inline varType *create(void){ \ static inline varType *create(void){ \
varType *var = new varType();\ varType *var = new varType();\
if (var)\ if (var)\
{\ {\
var->autorelease();\ var->autorelease();\
return var;\ return var;\
}\ }\
CC_SAFE_DELETE(var);\ CC_SAFE_DELETE(var);\
return NULL;\ return NULL;\
} }
#define CS_CREATE_NO_PARAM(varType)\ #define CC_CREATE_NO_PARAM(varType)\
public: \ public: \
static inline varType *create(void){ \ static inline varType *create(void){ \
varType *var = new varType();\ varType *var = new varType();\
if (var && var->init())\ if (var && var->init())\
{\ {\
var->autorelease();\ var->autorelease();\
return var;\ return var;\
}\ }\
CC_SAFE_DELETE(var);\ CC_SAFE_DELETE(var);\
return NULL;\ return NULL;\
} }
namespace cocos2d { namespace extension { namespace armature { NS_CC_EXT_ARMATURE_BEGIN
/** /**
* the base node include a lot of attribute. * The base node include a lot of attributes.
*/ */
class BaseData : public Object class CCBaseData : public Object
{ {
public: public:
CS_CREATE_NO_PARAM_NO_INIT(BaseData) CC_CREATE_NO_PARAM_NO_INIT(CCBaseData)
public: public:
/** CCBaseData();
* @js ctor ~CCBaseData(void);
*/
BaseData();
/**
* @js NA
* @lua NA
*/
~BaseData(void);
/* /*
* Copy datas from node * Copy data from node
* @param node A BaseData to copy datas * @param node A CCBaseData to copy data
*/ */
virtual void copy(const BaseData *node); virtual void copy(const CCBaseData *node);
/* /*
* Calculate two BaseData's between value(to - from) and set to self * Calculate two CCBaseData's between value(to - from) and set to self
* *
* @param from from BaseData * @param from from CCBaseData
* @param to to BaseData * @param to to CCBaseData
*/ */
virtual void subtract(BaseData *from, BaseData *to); virtual void subtract(CCBaseData *from, CCBaseData *to);
virtual void setColor(const Color4B &color);
virtual Color4B getColor();
public: public:
float x; //! position x attribute float x; //! position x attribute
float y; //! position y attribute float y; //! position y attribute
int zOrder; //! zorder attribute, used to order the Bone's depth order int zOrder; //! zorder attribute, used to order the CCBone's depth order
/** /**
* x y skewX skewY scaleX scaleY used to calculate transform matrix * x y skewX skewY scaleX scaleY used to calculate transform matrix
@ -103,383 +99,308 @@ public:
float scaleX; float scaleX;
float scaleY; float scaleY;
float tweenRotate; //! SkewX, SkewY, and TweenRotate effect the rotation float tweenRotate; //! SkewX, SkewY, and TweenRotate effect the rotation
bool isUseColorInfo; //! Whether or not this frame have the color changed Info bool isUseColorInfo; //! Whether or not this frame have the color changed Info
int a, r, g, b; int a, r, g, b;
}; };
/** /**
* DisplayType distinguish which type you display is. * DisplayType distinguish which type your display is.
*/ */
enum DisplayType enum DisplayType
{ {
CS_DISPLAY_SPRITE, //! display is a single Sprite CS_DISPLAY_SPRITE, //! display is a single Sprite
CS_DISPLAY_ARMATURE, //! display is a Armature CS_DISPLAY_ARMATURE, //! display is a CCArmature
CS_DISPLAY_PARTICLE, //! display is a Particle. CS_DISPLAY_PARTICLE, //! display is a CCParticle.
CS_DISPLAY_SHADER, //! display is a shader
CS_DISPLAY_MAX CS_DISPLAY_MAX
}; };
class DisplayData : public Object class CCDisplayData : public Object
{ {
public: public:
CS_CREATE_NO_PARAM_NO_INIT(DisplayData) CC_CREATE_NO_PARAM_NO_INIT(CCDisplayData)
static const char *changeDisplayToTexture(const char *); static const char *changeDisplayToTexture(const char *displayName);
public: public:
/** CCDisplayData();
* @js ctor virtual ~CCDisplayData(void);
*/
DisplayData();
/**
* @js NA
* @lua NA
*/
virtual ~DisplayData(void);
DisplayType displayType; //! mark which type your display is DisplayType displayType; //! mark which type your display is
}; };
class SpriteDisplayData : public DisplayData class CCSpriteDisplayData : public CCDisplayData
{ {
public: public:
CS_CREATE_NO_PARAM_NO_INIT(SpriteDisplayData) CC_CREATE_NO_PARAM_NO_INIT(CCSpriteDisplayData)
public: public:
/** CCSpriteDisplayData();
* @js ctor virtual ~CCSpriteDisplayData();
*/
SpriteDisplayData();
/**
* @js NA
* @lua NA
*/
virtual ~SpriteDisplayData();
inline void setParam(const char *displayName) inline void setParam(const char *displayName)
{ {
this->displayName = displayName; this->displayName = displayName;
} }
void copy(SpriteDisplayData *displayData); void copy(CCSpriteDisplayData *displayData);
public: public:
/** /**
* If DisplayType is CS_DISPLAY_SPRITE, then Bone will use this image name to create a Sprite from SpriteFrameCache. * If DisplayType is CS_DISPLAY_SPRITE, then CCBone will use this image name to create a Sprite from CCSpriteFrameCache.
* It should note that when use this name to create Sprite from SpriteFrameCache, you should use _displayName + ".png", because when use Texture Packer to pack single image file, the name have ".png". * It should note that when use this name to create Sprite from CCSpriteFrameCache, you should use m_strDisplayName + ".png", because when use Texture Packer to pack single image file, the name have ".png".
* *
* If DisplayType is CS_DISPLAY_ARMATURE, the name is the Armature's name. When Bone init display and type is CS_DISPLAY_ARMATURE, * If DisplayType is CS_DISPLAY_ARMATURE, the name is the CCArmature's name. When CCBone init display and type is CS_DISPLAY_ARMATURE,
* then Bone will create a Armature. * then CCBone will create a CCArmature.
*/
std::string displayName;
CCBaseData skinData;
};
class CCArmatureDisplayData : public CCDisplayData
{
public:
CC_CREATE_NO_PARAM_NO_INIT(CCArmatureDisplayData)
public:
CCArmatureDisplayData();
virtual ~CCArmatureDisplayData();
inline void setParam(const char *displayName)
{
this->displayName = displayName;
}
void copy(CCArmatureDisplayData *displayData);
public:
/**
* If DisplayType is CS_DISPLAY_SPRITE, then CCBone will use this image name to create a Sprite from CCSpriteFrameCache.
* It should note that when use this name to create Sprite from CCSpriteFrameCache, you should use m_strDisplayName + ".png", because when use Texture Packer to pack single image file, the name have ".png".
*
* If DisplayType is CS_DISPLAY_ARMATURE, the name is the CCArmature's name. When CCBone init display and type is CS_DISPLAY_ARMATURE,
* then CCBone will create a CCArmature.
*/ */
std::string displayName; std::string displayName;
}; };
class ArmatureDisplayData : public DisplayData class CCParticleDisplayData : public CCDisplayData
{ {
public: public:
CS_CREATE_NO_PARAM_NO_INIT(ArmatureDisplayData) CC_CREATE_NO_PARAM_NO_INIT(CCParticleDisplayData)
public: public:
/** CCParticleDisplayData();
* @js ctor virtual ~CCParticleDisplayData() {};
*/
ArmatureDisplayData();
/**
* @js NA
* @lua NA
*/
virtual ~ArmatureDisplayData();
inline void setParam(const char *displayName)
{
this->displayName = displayName;
}
void copy(ArmatureDisplayData *displayData);
public:
/**
* If DisplayType is CS_DISPLAY_SPRITE, then Bone will use this image name to create a Sprite from SpriteFrameCache.
* It should note that when use this name to create Sprite from SpriteFrameCache, you should use _displayName + ".png", because when use Texture Packer to pack single image file, the name have ".png".
*
* If DisplayType is CS_DISPLAY_ARMATURE, the name is the Armature's name. When Bone init display and type is CS_DISPLAY_ARMATURE,
* then Bone will create a Armature.
*/
std::string displayName;
};
class ParticleDisplayData : public DisplayData
{
public:
CS_CREATE_NO_PARAM_NO_INIT(ParticleDisplayData)
public:
/**
* @js ctor
*/
ParticleDisplayData();
/**
* @js NA
* @lua NA
*/
virtual ~ParticleDisplayData() {};
void setParam(const char *plist) void setParam(const char *plist)
{ {
this->plist = plist; this->plist = plist;
} }
void copy(ParticleDisplayData *displayData); void copy(CCParticleDisplayData *displayData);
public: public:
std::string plist; std::string plist;
}; };
class ShaderDisplayData : public DisplayData
{
public:
CS_CREATE_NO_PARAM_NO_INIT(ShaderDisplayData)
public:
/**
* @js ctor
*/
ShaderDisplayData();
/**
* @js NA
* @lua NA
*/
virtual ~ShaderDisplayData() {};
inline void setParam(const char *vert, const char *frag)
{
this->vert = vert;
this->frag = frag;
}
void copy(ShaderDisplayData *displayData);
public:
std::string vert;
std::string frag;
};
/** /**
* BoneData used to init a Bone. * CCBoneData used to init a CCBone.
* BoneData keeps a DisplayData list, a Bone can have many display to change. * CCBoneData keeps a CCDisplayData list, a CCBone can have many display to change.
* The display information saved in the DisplayData * The display information saved in the CCDisplayData
*/ */
class BoneData : public BaseData class CCBoneData : public CCBaseData
{ {
public: public:
CS_CREATE_NO_PARAM(BoneData) CC_CREATE_NO_PARAM(CCBoneData)
public: public:
/** CCBoneData(void);
* @js ctor ~CCBoneData(void);
*/
BoneData(void);
/**
* @js NA
* @lua NA
*/
~BoneData(void);
virtual bool init(); virtual bool init();
void addDisplayData(DisplayData *displayData); void addDisplayData(CCDisplayData *displayData);
DisplayData *getDisplayData(int index); CCDisplayData *getDisplayData(int index);
public: public:
std::string name; //! the bone's name std::string name; //! the bone's name
std::string parentName; //! the bone parent's name std::string parentName; //! the bone parent's name
Array *displayDataList; //! save DisplayData informations for the Bone Array displayDataList; //! save CCDisplayData informations for the CCBone
AffineTransform boneDataTransform;
}; };
/** /**
* ArmatureData saved the Armature name and Bonedatas needed for the Bones in this Armature * CCArmatureData saved the CCArmature name and Bonedata needed for the CCBones in this CCArmature
* When we create a Armature, we need to get each Bone's BoneData as it's init information. * When we create a CCArmature, we need to get each CCBone's CCBoneData as it's init information.
* So we can get a BoneData from the Dictionary saved in the ArmatureData. * So we can get a CCBoneData from the Dictionary saved in the CCArmatureData.
*/ */
class ArmatureData : public Object class CCArmatureData : public Object
{ {
public: public:
CS_CREATE_NO_PARAM(ArmatureData) CC_CREATE_NO_PARAM(CCArmatureData)
public: public:
/** CCArmatureData();
* @js ctor ~CCArmatureData();
*/
ArmatureData();
/**
* @js NA
* @lua NA
*/
~ArmatureData();
bool init(); bool init();
void addBoneData(BoneData *boneData); void addBoneData(CCBoneData *boneData);
BoneData *getBoneData(const char *boneName); CCBoneData *getBoneData(const char *boneName);
public: public:
std::string name; std::string name;
Dictionary *boneDataDic; Dictionary boneDataDic;
Array *boneList; float dataVersion;
};
enum CCBlendType
{
BLEND_NORMAL,
BLEND_LAYER,
BLEND_DARKEN,
BLEND_MULTIPLY,
BLEND_LIGHTEN,
BLEND_SCREEN,
BLEND_OVERLAY,
BLEND_HARD_LIGHT,
BLEND_ADD,
BLEND_SUBSTRACT,
BLEND_DIFFERENCE,
BLEND_INVERT,
BLEND_ALPHA,
BLEND_ERASE
}; };
class FrameData : public BaseData class CCFrameData : public CCBaseData
{ {
public: public:
CS_CREATE_NO_PARAM_NO_INIT(FrameData) CC_CREATE_NO_PARAM_NO_INIT(CCFrameData)
public: public:
/** CCFrameData();
* @js ctor ~CCFrameData();
*/
FrameData();
/**
* @js NA
* @lua NA
*/
~FrameData();
virtual void copy(FrameData *frameData); virtual void copy(const CCBaseData *baseData);
public: public:
int duration; //! The frame will last _duration frames int frameID;
TweenType tweenEasing; //! Every frame's tween easing effect int duration; //! The frame will last duration frames
CCTweenType tweenEasing; //! Every frame's tween easing effect
/** /**
* The current display index when change to this frame. * The current display index when change to this frame.
* If value is -1, then display will not show. * If value is -1, then display will not be shown.
*/ */
int displayIndex; int displayIndex;
CCBlendType blendType;
std::string strEvent;
/** /**
* _movement, _event, _sound, _soundEffect do not support yet * strMovement, strEvent, strSound, strSoundEffect do not support yet
*/ */
std::string _movement; std::string strMovement;
std::string _event; std::string strSound;
std::string _sound; std::string strSoundEffect;
std::string _soundEffect;
}; };
class MovementBoneData : public Object class CCMovementBoneData : public Object
{ {
public: public:
CS_CREATE_NO_PARAM(MovementBoneData) CC_CREATE_NO_PARAM(CCMovementBoneData)
public: public:
/** CCMovementBoneData();
* @js ctor ~CCMovementBoneData(void);
*/
MovementBoneData();
/**
* @js NA
* @lua NA
*/
~MovementBoneData(void);
virtual bool init(); virtual bool init();
void addFrameData(FrameData *frameData); void addFrameData(CCFrameData *frameData);
FrameData *getFrameData(int index); CCFrameData *getFrameData(int index);
public: public:
float delay; //! movement delay percent, this value can produce a delay effect float delay; //! movement delay percent, this value can produce a delay effect
float scale; //! scale this movement float scale; //! scale this movement
float duration; //! this Bone in this movement will last _duration frames float duration; //! this CCBone in this movement will last m_iDuration frames
std::string name; //! bone name std::string name; //! bone name
Array *frameList; Array frameList;
}; };
class MovementData : public Object class CCMovementData : public Object
{ {
public: public:
CS_CREATE_NO_PARAM_NO_INIT(MovementData) CC_CREATE_NO_PARAM_NO_INIT(CCMovementData)
public: public:
/** CCMovementData(void);
* @js ctor ~CCMovementData(void);
*/
MovementData(void);
/**
* @js NA
* @lua NA
*/
~MovementData(void);
void addMovementBoneData(MovementBoneData *movBoneData); void addMovementBoneData(CCMovementBoneData *movBoneData);
MovementBoneData *getMovementBoneData(const char *boneName); CCMovementBoneData *getMovementBoneData(const char *boneName);
public: public:
std::string name; std::string name;
int duration; //! the frames this movement will last int duration; //! the frames this movement will last
float scale; //! scale this movement
/** /**
* Change to this movement will last _durationTo frames. Use this effect can avoid too suddenly changing. * Change to this movement will last durationTo frames. Use this effect can avoid too suddenly changing.
* *
* Example : current movement is "stand", we want to change to "run", then we fill _durationTo frames before * Example : current movement is "stand", we want to change to "run", then we fill durationTo frames before
* change to "run" instead of changing to "run" directly. * change to "run" instead of changing to "run" directly.
*/ */
int durationTo; int durationTo;
/* /*
* This is different from _duration, _durationTween contain tween effect. * This is different from duration, durationTween contain tween effect.
* * duration is the raw time that the animation will last, it's the same with the time you edit in the Action Editor.
* Example : If we edit 10 frames in the flash, then _duration is 10. When we set _durationTween to 50, the movement will last 50 frames, the extra 40 frames will auto filled with tween effect * durationTween is the actual time you want this animation last.
* Example : If we edit 10 frames in the flash, then duration is 10. When we set durationTween to 50, the movement will last 50 frames, the extra 40 frames will auto filled with tween effect
*/ */
int durationTween; int durationTween;
bool loop; //! whether the movement is looped bool loop; //! whether the movement was looped
/** /**
* Which tween easing effect the movement use * Which tween easing effect the movement use
* TWEEN_EASING_MAX : use the value from MovementData get from flash design panel * TWEEN_EASING_MAX : use the value from CCMovementData get from flash design panel
*/ */
TweenType tweenEasing; CCTweenType tweenEasing;
/** /**
* Dictionary to save movment bone data. * @brief save movment bone data
* Key type is std::string, value type is MovementBoneData *. * @key const char *
*/ * @value CCMovementBoneData *
Dictionary *movBoneDataDic; */
Dictionary movBoneDataDic;
}; };
/** /**
* AnimationData include all movement infomation for the Armature * CCAnimationData include all movement infomation for the CCArmature
* The struct is AnimationData -> MovementData -> MovementBoneData -> FrameData * The struct is CCAnimationData -> CCMovementData -> CCMovementBoneData -> CCFrameData
* -> MovementFrameData * -> MovementFrameData
*/ */
class AnimationData : public Object class CCAnimationData : public Object
{ {
public: public:
CS_CREATE_NO_PARAM_NO_INIT(AnimationData) CC_CREATE_NO_PARAM_NO_INIT(CCAnimationData)
public: public:
/** CCAnimationData(void);
* @js ctor ~CCAnimationData(void);
*/
AnimationData(void);
/**
* @js NA
* @lua NA
*/
~AnimationData(void);
void release(); void addMovement(CCMovementData *movData);
void retain(); CCMovementData *getMovement(const char *movementName);
void addMovement(MovementData *movData);
MovementData *getMovement(const char *movementName);
int getMovementCount(); int getMovementCount();
public: public:
std::string name; std::string name;
Dictionary *movementDataDic; Dictionary movementDataDic;
std::vector<std::string> movementNames; std::vector<std::string> movementNames;
}; };
struct ContourVertex2F : public Object struct CCContourVertex2 : public Object
{ {
ContourVertex2F(float x, float y) CCContourVertex2(float x, float y)
{ {
this->x = x; this->x = x;
this->y = y; this->y = y;
@ -490,67 +411,54 @@ struct ContourVertex2F : public Object
}; };
/* /*
* ContourData include a contour vertex information * CCContourData include a contour vertex information
*/ */
class ContourData : public Object class CCContourData : public Object
{ {
public: public:
CS_CREATE_NO_PARAM(ContourData) CC_CREATE_NO_PARAM(CCContourData)
public: public:
/** CCContourData();
* @js ctor ~CCContourData(void);
*/
ContourData();
/**
* @js NA
* @lua NA
*/
~ContourData(void);
virtual bool init(); virtual bool init();
virtual void addVertex(Point *vertex);
public: public:
Array *vertexList; //! Save contour vertex info, vertex saved in a Point Array vertexList; //! Save contour vertex info, vertex saved in a Point
}; };
/* /*
* TextureData include a texture's information * CCTextureData include a texture's information
*/ */
class TextureData : public Object class CCTextureData : public Object
{ {
public: public:
CS_CREATE_NO_PARAM(TextureData) CC_CREATE_NO_PARAM(CCTextureData)
public: public:
/** CCTextureData();
* @js ctor ~CCTextureData(void);
*/
TextureData();
/**
* @js NA
* @lua NA
*/
~TextureData(void);
virtual bool init(); virtual bool init();
void addContourData(ContourData *contourData); void addContourData(CCContourData *contourData);
ContourData *getContourData(int index); CCContourData *getContourData(int index);
public: public:
float height; //! The texture's width, height float height; //! The texture's width, height
float width; float width;
float pivotX; //! The texture's anchor point float pivotX; //! The texture's anchor point
float pivotY; float pivotY;
std::string name; //! The texture's name std::string name; //! The texture's name
Array *contourDataList; Array contourDataList;
}; };
}}} // namespace cocos2d { namespace extension { namespace armature { NS_CC_EXT_ARMATURE_END
#endif /*__CCARMATURE_DATAS_H__*/ #endif /*__CCARMATURE_DATAS_H__*/

36
extensions/CocoStudio/Armature/display/CCBatchNode.cpp
View File

@ -26,11 +26,11 @@ THE SOFTWARE.
#include "../utils/CCArmatureDefine.h" #include "../utils/CCArmatureDefine.h"
#include "../CCArmature.h" #include "../CCArmature.h"
namespace cocos2d { namespace extension { namespace armature { NS_CC_EXT_ARMATURE_BEGIN
BatchNode *BatchNode::create() CCBatchNode *CCBatchNode::create()
{ {
BatchNode *batchNode = new BatchNode(); CCBatchNode *batchNode = new CCBatchNode();
if (batchNode && batchNode->init()) if (batchNode && batchNode->init())
{ {
batchNode->autorelease(); batchNode->autorelease();
@ -40,29 +40,29 @@ BatchNode *BatchNode::create()
return NULL; return NULL;
} }
BatchNode::BatchNode() CCBatchNode::CCBatchNode()
: _atlas(NULL) : m_pAtlas(NULL)
{ {
} }
bool BatchNode::init() bool CCBatchNode::init()
{ {
bool ret = Node::init(); bool ret = Node::init();
setShaderProgram(ShaderCache::getInstance()->programForKey(GLProgram::SHADER_NAME_POSITION_TEXTURE_COLOR)); setShaderProgram(CCShaderCache::getInstance()->getProgram(GLProgram::SHADER_NAME_POSITION_TEXTURE_COLOR));
return ret; return ret;
} }
void BatchNode::addChild(Node *child, int zOrder, int tag) void CCBatchNode::addChild(Node *child, int zOrder, int tag)
{ {
Node::addChild(child, zOrder, tag); Node::addChild(child, zOrder, tag);
Armature *armature = dynamic_cast<Armature *>(child); CCArmature *armature = dynamic_cast<CCArmature *>(child);
if (armature != NULL) if (armature != NULL)
{ {
armature->setBatchNode(this); armature->setBatchNode(this);
} }
} }
void BatchNode::visit() void CCBatchNode::visit()
{ {
// quick return if not visible. children won't be drawn. // quick return if not visible. children won't be drawn.
if (!_visible) if (!_visible)
@ -91,29 +91,29 @@ void BatchNode::visit()
kmGLPopMatrix(); kmGLPopMatrix();
} }
void BatchNode::draw() void CCBatchNode::draw()
{ {
CC_NODE_DRAW_SETUP(); CC_NODE_DRAW_SETUP();
Object *object = NULL; Object *object = NULL;
CCARRAY_FOREACH(_children, object) CCARRAY_FOREACH(_children, object)
{ {
Armature *armature = dynamic_cast<Armature *>(object); CCArmature *armature = dynamic_cast<CCArmature *>(object);
if (armature) if (armature)
{ {
armature->visit(); armature->visit();
_atlas = armature->getTextureAtlas(); m_pAtlas = armature->getTextureAtlas();
} }
else else
{ {
static_cast<Node*>(object)->visit(); ((Node *)object)->visit();
} }
} }
if (_atlas) if (m_pAtlas)
{ {
_atlas->drawQuads(); m_pAtlas->drawQuads();
_atlas->removeAllQuads(); m_pAtlas->removeAllQuads();
} }
} }
}}} // namespace cocos2d { namespace extension { namespace armature { NS_CC_EXT_ARMATURE_END

12
extensions/CocoStudio/Armature/display/CCBatchNode.h
View File

@ -27,14 +27,14 @@ THE SOFTWARE.
#include "../utils/CCArmatureDefine.h" #include "../utils/CCArmatureDefine.h"
namespace cocos2d { namespace extension { namespace armature { NS_CC_EXT_ARMATURE_BEGIN
class BatchNode : public Node class CCBatchNode : public Node
{ {
public: public:
static BatchNode *create(); static CCBatchNode *create();
public: public:
BatchNode(); CCBatchNode();
virtual bool init(); virtual bool init();
virtual void addChild(Node *child, int zOrder, int tag); virtual void addChild(Node *child, int zOrder, int tag);
@ -42,9 +42,9 @@ public:
void draw(); void draw();
protected: protected:
TextureAtlas *_atlas; TextureAtlas *m_pAtlas;
}; };
}}} // namespace cocos2d { namespace extension { namespace armature { NS_CC_EXT_ARMATURE_END
#endif /*__CCBATCHNODE_H__*/ #endif /*__CCBATCHNODE_H__*/

36
extensions/CocoStudio/Armature/display/CCDecorativeDisplay.cpp
View File

@ -23,13 +23,12 @@ THE SOFTWARE.
****************************************************************************/ ****************************************************************************/
#include "CCDecorativeDisplay.h" #include "CCDecorativeDisplay.h"
#include "../utils/CCConstValue.h"
namespace cocos2d { namespace extension { namespace armature { NS_CC_EXT_ARMATURE_BEGIN
DecorativeDisplay *DecorativeDisplay::create() CCDecorativeDisplay *CCDecorativeDisplay::create()
{ {
DecorativeDisplay *pDisplay = new DecorativeDisplay(); CCDecorativeDisplay *pDisplay = new CCDecorativeDisplay();
if (pDisplay && pDisplay->init()) if (pDisplay && pDisplay->init())
{ {
pDisplay->autorelease(); pDisplay->autorelease();
@ -39,35 +38,30 @@ DecorativeDisplay *DecorativeDisplay::create()
return NULL; return NULL;
} }
DecorativeDisplay::DecorativeDisplay() CCDecorativeDisplay::CCDecorativeDisplay()
: _display(NULL) : m_pDisplay(NULL)
, _displayData(NULL) , m_pDisplayData(NULL)
{ {
#if ENABLE_PHYSICS_DETECT #if ENABLE_PHYSICS_BOX2D_DETECT || ENABLE_PHYSICS_CHIPMUNK_DETECT
_colliderDetector = NULL; m_pColliderDetector = NULL;
#endif #endif
} }
DecorativeDisplay::~DecorativeDisplay(void) CCDecorativeDisplay::~CCDecorativeDisplay(void)
{ {
CC_SAFE_RELEASE_NULL(_displayData); CC_SAFE_RELEASE_NULL(m_pDisplayData);
CC_SAFE_RELEASE_NULL(_display); CC_SAFE_RELEASE_NULL(m_pDisplay);
#if ENABLE_PHYSICS_DETECT #if ENABLE_PHYSICS_BOX2D_DETECT || ENABLE_PHYSICS_CHIPMUNK_DETECT
CC_SAFE_RELEASE_NULL(_colliderDetector); CC_SAFE_RELEASE_NULL(m_pColliderDetector);
#endif #endif
} }
bool DecorativeDisplay::init() bool CCDecorativeDisplay::init()
{ {
return true; return true;
} }
NS_CC_EXT_ARMATURE_END
void DecorativeDisplay::anchorPointChanged(float pointX, float pointY)
{
}
}}} // namespace cocos2d { namespace extension { namespace armature {

32
extensions/CocoStudio/Armature/display/CCDecorativeDisplay.h
View File

@ -28,44 +28,34 @@ THE SOFTWARE.
#include "../utils/CCArmatureDefine.h" #include "../utils/CCArmatureDefine.h"
#include "CCDisplayFactory.h" #include "CCDisplayFactory.h"
#include "../datas/CCDatas.h" #include "../datas/CCDatas.h"
#include "../external_tool/sigslot.h"
#if ENABLE_PHYSICS_DETECT #if ENABLE_PHYSICS_BOX2D_DETECT || ENABLE_PHYSICS_CHIPMUNK_DETECT
#include "../physics/CCColliderDetector.h" #include "../physics/CCColliderDetector.h"
#endif #endif
namespace cocos2d { namespace extension { namespace armature { NS_CC_EXT_ARMATURE_BEGIN
class DecorativeDisplay: public Object, public sigslot::has_slots<> class CCDecorativeDisplay: public Object
{ {
public: public:
static DecorativeDisplay *create(); static CCDecorativeDisplay *create();
public: public:
/** CCDecorativeDisplay(void);
* @js ctor ~CCDecorativeDisplay(void);
*/
DecorativeDisplay(void);
/**
* @js NA
* @lua NA
*/
~DecorativeDisplay(void);
virtual bool init(); virtual bool init();
protected: protected:
CC_SYNTHESIZE_RETAIN(Node *, _display, Display); CC_SYNTHESIZE_RETAIN(Node *, m_pDisplay, Display);
CC_SYNTHESIZE_RETAIN(DisplayData *, _displayData, DisplayData); CC_SYNTHESIZE_RETAIN(CCDisplayData *, m_pDisplayData, DisplayData);
#if ENABLE_PHYSICS_DETECT #if ENABLE_PHYSICS_BOX2D_DETECT || ENABLE_PHYSICS_CHIPMUNK_DETECT
CC_SYNTHESIZE_RETAIN(ColliderDetector *, _colliderDetector, ColliderDetector); CC_SYNTHESIZE_RETAIN(CCColliderDetector *, m_pColliderDetector, ColliderDetector);
#endif #endif
public:
void anchorPointChanged(float pointX, float pointY);
}; };
}}} // namespace cocos2d { namespace extension { namespace armature { NS_CC_EXT_ARMATURE_END
#endif /*__CCDECORATIVEDISPLAY_H__*/ #endif /*__CCDECORATIVEDISPLAY_H__*/

171
extensions/CocoStudio/Armature/display/CCDisplayFactory.cpp
View File

@ -26,14 +26,13 @@ THE SOFTWARE.
#include "../CCBone.h" #include "../CCBone.h"
#include "../CCArmature.h" #include "../CCArmature.h"
#include "../display/CCSkin.h" #include "../display/CCSkin.h"
#include "../display/CCShaderNode.h"
#include "../utils/CCSpriteFrameCacheHelper.h" #include "../utils/CCSpriteFrameCacheHelper.h"
#include "../utils/CCArmatureDataManager.h" #include "../utils/CCArmatureDataManager.h"
#include "../utils/CCTransformHelp.h" #include "../utils/CCTransformHelp.h"
namespace cocos2d { namespace extension { namespace armature { NS_CC_EXT_ARMATURE_BEGIN
void DisplayFactory::addDisplay(Bone *bone, DecorativeDisplay *decoDisplay, DisplayData *displayData) void CCDisplayFactory::addDisplay(CCBone *bone, CCDecorativeDisplay *decoDisplay, CCDisplayData *displayData)
{ {
switch(displayData->displayType) switch(displayData->displayType)
{ {
@ -51,7 +50,7 @@ void DisplayFactory::addDisplay(Bone *bone, DecorativeDisplay *decoDisplay, Disp
} }
} }
void DisplayFactory::createDisplay(Bone *bone, DecorativeDisplay *decoDisplay) void CCDisplayFactory::createDisplay(CCBone *bone, CCDecorativeDisplay *decoDisplay)
{ {
switch(decoDisplay->getDisplayData()->displayType) switch(decoDisplay->getDisplayData()->displayType)
{ {
@ -69,56 +68,74 @@ void DisplayFactory::createDisplay(Bone *bone, DecorativeDisplay *decoDisplay)
} }
} }
void DisplayFactory::updateDisplay(Bone *bone, DecorativeDisplay *decoDisplay, float dt, bool dirty) void CCDisplayFactory::updateDisplay(CCBone *bone, CCDecorativeDisplay *decoDisplay, float dt, bool dirty)
{ {
CS_RETURN_IF(!decoDisplay); CS_RETURN_IF(!decoDisplay);
#if ENABLE_PHYSICS_DETECT #if ENABLE_PHYSICS_BOX2D_DETECT || ENABLE_PHYSICS_CHIPMUNK_DETECT
if (dirty) if (dirty)
{ {
ColliderDetector *detector = decoDisplay->getColliderDetector(); CCColliderDetector *detector = decoDisplay->getColliderDetector();
if (detector) if (detector)
{ {
AffineTransform t = AffineTransformConcat(bone->nodeToArmatureTransform(), bone->getArmature()->getNodeToWorldTransform()); do
detector->updateTransform(t); {
#if ENABLE_PHYSICS_BOX2D_DETECT
CC_BREAK_IF(!detector->getBody());
#elif ENABLE_PHYSICS_CHIPMUNK_DETECT
CC_BREAK_IF(!detector->getBody());
#endif
Node *node = decoDisplay->getDisplay();
AffineTransform displayTransform = node->getNodeToParentTransform();
Point anchorPoint = node->getAnchorPointInPoints();
anchorPoint = PointApplyAffineTransform(anchorPoint, displayTransform);
displayTransform.tx = anchorPoint.x;
displayTransform.ty = anchorPoint.y;
AffineTransform t = AffineTransformConcat(displayTransform, bone->getArmature()->getNodeToParentTransform());
detector->updateTransform(t);
}
while (0);
} }
} }
#endif #endif
Node *display = decoDisplay->getDisplay();
switch(decoDisplay->getDisplayData()->displayType) switch(decoDisplay->getDisplayData()->displayType)
{ {
case CS_DISPLAY_SPRITE: case CS_DISPLAY_SPRITE:
updateSpriteDisplay(bone, decoDisplay, dt, dirty); updateSpriteDisplay(bone, display, dt, dirty);
break; break;
case CS_DISPLAY_PARTICLE: case CS_DISPLAY_PARTICLE:
updateParticleDisplay(bone, decoDisplay, dt, dirty); updateParticleDisplay(bone, display, dt, dirty);
break; break;
case CS_DISPLAY_ARMATURE: case CS_DISPLAY_ARMATURE:
updateArmatureDisplay(bone, decoDisplay, dt, dirty); updateArmatureDisplay(bone, display, dt, dirty);
break; break;
default: default:
break; {
display->setAdditionalTransform(bone->getNodeToArmatureTransform());
}
break;
} }
} }
void DisplayFactory::addSpriteDisplay(Bone *bone, DecorativeDisplay *decoDisplay, DisplayData *displayData) void CCDisplayFactory::addSpriteDisplay(CCBone *bone, CCDecorativeDisplay *decoDisplay, CCDisplayData *displayData)
{ {
SpriteDisplayData *sdp = SpriteDisplayData::create(); CCSpriteDisplayData *sdp = CCSpriteDisplayData::create();
sdp->copy((SpriteDisplayData *)displayData); sdp->copy((CCSpriteDisplayData *)displayData);
decoDisplay->setDisplayData(sdp); decoDisplay->setDisplayData(sdp);
createSpriteDisplay(bone, decoDisplay); createSpriteDisplay(bone, decoDisplay);
} }
void DisplayFactory::createSpriteDisplay(Bone *bone, DecorativeDisplay *decoDisplay) void CCDisplayFactory::createSpriteDisplay(CCBone *bone, CCDecorativeDisplay *decoDisplay)
{ {
Skin *skin = NULL; CCSkin *skin = NULL;
SpriteDisplayData *displayData = (SpriteDisplayData *)decoDisplay->getDisplayData(); CCSpriteDisplayData *displayData = (CCSpriteDisplayData *)decoDisplay->getDisplayData();
//! remove .xxx
std::string textureName = displayData->displayName; std::string textureName = displayData->displayName;
size_t startPos = textureName.find_last_of("."); size_t startPos = textureName.find_last_of(".");
@ -130,75 +147,99 @@ void DisplayFactory::createSpriteDisplay(Bone *bone, DecorativeDisplay *decoDisp
//! create display //! create display
if(textureName.length() == 0) if(textureName.length() == 0)
{ {
skin = Skin::create(); skin = CCSkin::create();
} }
else else
{ {
skin = Skin::createWithSpriteFrameName((textureName + ".png").c_str()); skin = CCSkin::createWithSpriteFrameName((textureName + ".png").c_str());
} }
TextureAtlas *atlas = SpriteFrameCacheHelper::sharedSpriteFrameCacheHelper()->getTextureAtlas((textureName + ".png").c_str()); skin->setBone(bone);
skin->setTextureAtlas(atlas);
TextureData *textureData = ArmatureDataManager::sharedArmatureDataManager()->getTextureData(textureName.c_str()); initSpriteDisplay(bone, decoDisplay, displayData->displayName.c_str(), skin);
CCArmature *armature = bone->getArmature();
if (armature)
{
if (armature->getArmatureData()->dataVersion >= VERSION_COMBINED)
{
skin->setSkinData(displayData->skinData);
}
else
{
skin->setSkinData(*bone->getBoneData());
}
}
decoDisplay->setDisplay(skin);
}
void CCDisplayFactory::initSpriteDisplay(CCBone *bone, CCDecorativeDisplay *decoDisplay, const char *displayName, CCSkin *skin)
{
//! remove .xxx
std::string textureName = displayName;
size_t startPos = textureName.find_last_of(".");
if(startPos != std::string::npos)
{
textureName = textureName.erase(startPos);
}
CCTextureData *textureData = CCArmatureDataManager::sharedArmatureDataManager()->getTextureData(textureName.c_str());
if(textureData) if(textureData)
{ {
//! Init display anchorPoint, every Texture have a anchor point //! Init display anchorPoint, every Texture have a anchor point
skin->setAnchorPoint(Point( textureData->pivotX, textureData->pivotY)); skin->setAnchorPoint(Point( textureData->pivotX, textureData->pivotY));
} }
skin->setBone(bone);
skin->setSkinData(*bone->getBoneData());
decoDisplay->setDisplay(skin); #if ENABLE_PHYSICS_BOX2D_DETECT || ENABLE_PHYSICS_CHIPMUNK_DETECT
if (textureData && textureData->contourDataList.count() > 0)
#if ENABLE_PHYSICS_DETECT
if (textureData && textureData->contourDataList->count() > 0)
{ {
//! create ContourSprite //! create ContourSprite
ColliderDetector *colliderDetector = ColliderDetector::create(bone); CCColliderDetector *colliderDetector = CCColliderDetector::create(bone);
colliderDetector->addContourDataList(textureData->contourDataList); colliderDetector->addContourDataList(&textureData->contourDataList);
decoDisplay->setColliderDetector(colliderDetector); decoDisplay->setColliderDetector(colliderDetector);
} }
#endif #endif
} }
void DisplayFactory::updateSpriteDisplay(Bone *bone, DecorativeDisplay *decoDisplay, float dt, bool dirty) void CCDisplayFactory::updateSpriteDisplay(CCBone *bone, Node *display, float dt, bool dirty)
{ {
Skin *skin = (Skin *)decoDisplay->getDisplay(); CS_RETURN_IF(!dirty);
skin->updateTransform(); CCSkin *skin = (CCSkin *)display;
skin->updateArmatureTransform();
} }
void DisplayFactory::addArmatureDisplay(Bone *bone, DecorativeDisplay *decoDisplay, DisplayData *displayData) void CCDisplayFactory::addArmatureDisplay(CCBone *bone, CCDecorativeDisplay *decoDisplay, CCDisplayData *displayData)
{ {
ArmatureDisplayData *adp = ArmatureDisplayData::create(); ; CCArmatureDisplayData *adp = CCArmatureDisplayData::create(); ;
adp->copy((ArmatureDisplayData *)displayData); adp->copy((CCArmatureDisplayData *)displayData);
decoDisplay->setDisplayData(adp); decoDisplay->setDisplayData(adp);
createArmatureDisplay(bone, decoDisplay); createArmatureDisplay(bone, decoDisplay);
} }
void DisplayFactory::createArmatureDisplay(Bone *bone, DecorativeDisplay *decoDisplay) void CCDisplayFactory::createArmatureDisplay(CCBone *bone, CCDecorativeDisplay *decoDisplay)
{ {
ArmatureDisplayData *displayData = (ArmatureDisplayData *)decoDisplay->getDisplayData(); CCArmatureDisplayData *displayData = (CCArmatureDisplayData *)decoDisplay->getDisplayData();
Armature *armature = Armature::create(displayData->displayName.c_str(), bone); CCArmature *armature = CCArmature::create(displayData->displayName.c_str(), bone);
/* /*
* because this bone have called this name, so armature should change it's name, or it can't add to * because this bone have called this name, so armature should change it's name, or it can't add to
* Armature's bone children. * CCArmature's bone children.
*/ */
armature->setName((bone->getName() + "_armatureChild").c_str()); armature->setName((bone->getName() + "_armatureChild").c_str());
decoDisplay->setDisplay(armature); decoDisplay->setDisplay(armature);
} }
void DisplayFactory::updateArmatureDisplay(Bone *bone, DecorativeDisplay *decoDisplay, float dt, bool dirty) void CCDisplayFactory::updateArmatureDisplay(CCBone *bone, Node *display, float dt, bool dirty)
{ {
CS_RETURN_IF(!dirty); CCArmature *armature = (CCArmature *)display;
Armature *armature = bone->getChildArmature();
if(armature) if(armature)
{ {
armature->sortAllChildren(); armature->sortAllChildren();
@ -208,25 +249,25 @@ void DisplayFactory::updateArmatureDisplay(Bone *bone, DecorativeDisplay *decoDi
void DisplayFactory::addParticleDisplay(Bone *bone, DecorativeDisplay *decoDisplay, DisplayData *displayData) void CCDisplayFactory::addParticleDisplay(CCBone *bone, CCDecorativeDisplay *decoDisplay, CCDisplayData *displayData)
{ {
ParticleDisplayData *adp = ParticleDisplayData::create(); ; CCParticleDisplayData *adp = CCParticleDisplayData::create(); ;
adp->copy((ParticleDisplayData *)displayData); adp->copy((CCParticleDisplayData *)displayData);
decoDisplay->setDisplayData(adp); decoDisplay->setDisplayData(adp);
createParticleDisplay(bone, decoDisplay); createParticleDisplay(bone, decoDisplay);
} }
void DisplayFactory::createParticleDisplay(Bone *bone, DecorativeDisplay *decoDisplay) void CCDisplayFactory::createParticleDisplay(CCBone *bone, CCDecorativeDisplay *decoDisplay)
{ {
ParticleDisplayData *displayData = (ParticleDisplayData *)decoDisplay->getDisplayData(); CCParticleDisplayData *displayData = (CCParticleDisplayData *)decoDisplay->getDisplayData();
ParticleSystem *system = ParticleSystemQuad::create(displayData->plist.c_str()); ParticleSystem *system = ParticleSystemQuad::create(displayData->plist.c_str());
decoDisplay->setDisplay(system); decoDisplay->setDisplay(system);
} }
void DisplayFactory::updateParticleDisplay(Bone *bone, DecorativeDisplay *decoDisplay, float dt, bool dirty) void CCDisplayFactory::updateParticleDisplay(CCBone *bone, Node *display, float dt, bool dirty)
{ {
ParticleSystem *system = (ParticleSystem *)decoDisplay->getDisplay(); ParticleSystem *system = (ParticleSystem *)display;
BaseData node; CCBaseData node;
TransformHelp::matrixToNode(bone->nodeToArmatureTransform(), node); CCTransformHelp::matrixToNode(bone->getNodeToArmatureTransform(), node);
system->setPosition(node.x, node.y); system->setPosition(node.x, node.y);
system->setScaleX(node.scaleX); system->setScaleX(node.scaleX);
system->setScaleY(node.scaleY); system->setScaleY(node.scaleY);
@ -234,20 +275,4 @@ void DisplayFactory::updateParticleDisplay(Bone *bone, DecorativeDisplay *decoDi
} }
NS_CC_EXT_ARMATURE_END
void DisplayFactory::addShaderDisplay(Bone *bone, DecorativeDisplay *decoDisplay, DisplayData *displayData)
{
ShaderDisplayData *sdp = ShaderDisplayData::create();
sdp->copy((ShaderDisplayData *)displayData);
decoDisplay->setDisplayData(sdp);
createShaderDisplay(bone, decoDisplay);
}
void DisplayFactory::createShaderDisplay(Bone *bone, DecorativeDisplay *decoDisplay)
{
ShaderDisplayData *displayData = (ShaderDisplayData *)decoDisplay->getDisplayData();
ShaderNode *sn = ShaderNode::shaderNodeWithVertex(displayData->vert.c_str(), displayData->frag.c_str());
decoDisplay->setDisplay(sn);
}
}}} // namespace cocos2d { namespace extension { namespace armature {

42
extensions/CocoStudio/Armature/display/CCDisplayFactory.h
View File

@ -28,38 +28,36 @@ THE SOFTWARE.
#include "../utils/CCArmatureDefine.h" #include "../utils/CCArmatureDefine.h"
#include "../datas/CCDatas.h" #include "../datas/CCDatas.h"
namespace cocos2d { namespace extension { namespace armature { NS_CC_EXT_ARMATURE_BEGIN
class Skin; class CCSkin;
class Bone; class CCBone;
class DecorativeDisplay; class CCDecorativeDisplay;
class DisplayData; class CCDisplayData;
class DisplayFactory class CCDisplayFactory
{ {
public: public:
static void addDisplay(Bone *bone, DecorativeDisplay *decoDisplay, DisplayData *displayData); static void addDisplay(CCBone *bone, CCDecorativeDisplay *decoDisplay, CCDisplayData *displayData);
static void createDisplay(Bone *bone, DecorativeDisplay *decoDisplay); static void createDisplay(CCBone *bone, CCDecorativeDisplay *decoDisplay);
static void updateDisplay(Bone *bone, DecorativeDisplay *decoDisplay, float dt, bool dirty); static void updateDisplay(CCBone *bone, CCDecorativeDisplay *decoDisplay, float dt, bool dirty);
static void addSpriteDisplay(Bone *bone, DecorativeDisplay *decoDisplay, DisplayData *displayData); static void addSpriteDisplay(CCBone *bone, CCDecorativeDisplay *decoDisplay, CCDisplayData *displayData);
static void createSpriteDisplay(Bone *bone, DecorativeDisplay *decoDisplay); static void createSpriteDisplay(CCBone *bone, CCDecorativeDisplay *decoDisplay);
static void updateSpriteDisplay(Bone *bone, DecorativeDisplay *decoDisplay, float dt, bool dirty); static void initSpriteDisplay(CCBone *bone, CCDecorativeDisplay *decoDisplay, const char *displayName, CCSkin *skin);
static void updateSpriteDisplay(CCBone *bone, Node *display, float dt, bool dirty);
static void addArmatureDisplay(Bone *bone, DecorativeDisplay *decoDisplay, DisplayData *displayData);
static void createArmatureDisplay(Bone *bone, DecorativeDisplay *decoDisplay);
static void updateArmatureDisplay(Bone *bone, DecorativeDisplay *decoDisplay, float dt, bool dirty);
static void addParticleDisplay(Bone *bone, DecorativeDisplay *decoDisplay, DisplayData *displayData); static void addArmatureDisplay(CCBone *bone, CCDecorativeDisplay *decoDisplay, CCDisplayData *displayData);
static void createParticleDisplay(Bone *bone, DecorativeDisplay *decoDisplay); static void createArmatureDisplay(CCBone *bone, CCDecorativeDisplay *decoDisplay);
static void updateParticleDisplay(Bone *bone, DecorativeDisplay *decoDisplay, float dt, bool dirty); static void updateArmatureDisplay(CCBone *bone, Node *display, float dt, bool dirty);
static void addShaderDisplay(Bone *bone, DecorativeDisplay *decoDisplay, DisplayData *displayData);
static void createShaderDisplay(Bone *bone, DecorativeDisplay *decoDisplay);
static void addParticleDisplay(CCBone *bone, CCDecorativeDisplay *decoDisplay, CCDisplayData *displayData);
static void createParticleDisplay(CCBone *bone, CCDecorativeDisplay *decoDisplay);
static void updateParticleDisplay(CCBone *bone, Node *display, float dt, bool dirty);
}; };
}}} // namespace cocos2d { namespace extension { namespace armature { NS_CC_EXT_ARMATURE_END
#endif /*__CCDISPLAYFACTORY_H__*/ #endif /*__CCDISPLAYFACTORY_H__*/

276
extensions/CocoStudio/Armature/display/CCDisplayManager.cpp
View File

@ -28,11 +28,11 @@ THE SOFTWARE.
#include "../utils/CCUtilMath.h" #include "../utils/CCUtilMath.h"
#include "../display/CCSkin.h" #include "../display/CCSkin.h"
namespace cocos2d { namespace extension { namespace armature { NS_CC_EXT_ARMATURE_BEGIN
DisplayManager *DisplayManager::create(Bone *bone) CCDisplayManager *CCDisplayManager::create(CCBone *bone)
{ {
DisplayManager *pDisplayManager = new DisplayManager(); CCDisplayManager *pDisplayManager = new CCDisplayManager();
if (pDisplayManager && pDisplayManager->init(bone)) if (pDisplayManager && pDisplayManager->init(bone))
{ {
pDisplayManager->autorelease(); pDisplayManager->autorelease();
@ -43,38 +43,38 @@ DisplayManager *DisplayManager::create(Bone *bone)
} }
DisplayManager::DisplayManager() CCDisplayManager::CCDisplayManager()
: _decoDisplayList(NULL) : m_pDecoDisplayList(NULL)
, _displayRenderNode(NULL) , m_pDisplayRenderNode(NULL)
, _currentDecoDisplay(NULL) , m_pCurrentDecoDisplay(NULL)
, _displayIndex(-1) , m_iDisplayIndex(-1)
, _forceChangeDisplay(false) , m_bForceChangeDisplay(false)
, _visible(true) , m_bVisible(true)
, _bone(NULL) , m_pBone(NULL)
{ {
} }
DisplayManager::~DisplayManager() CCDisplayManager::~CCDisplayManager()
{ {
CC_SAFE_DELETE(_decoDisplayList); CC_SAFE_DELETE(m_pDecoDisplayList);
if( _displayRenderNode ) if( m_pDisplayRenderNode )
{ {
_displayRenderNode->removeFromParentAndCleanup(true); m_pDisplayRenderNode->removeFromParentAndCleanup(true);
if(_displayRenderNode->retainCount() > 0) if(m_pDisplayRenderNode->retainCount() > 0)
CC_SAFE_RELEASE_NULL(_displayRenderNode); CC_SAFE_RELEASE_NULL(m_pDisplayRenderNode);
} }
} }
bool DisplayManager::init(Bone *bone) bool CCDisplayManager::init(CCBone *bone)
{ {
bool ret = false; bool ret = false;
do do
{ {
_bone = bone; m_pBone = bone;
initDisplayList(bone->getBoneData()); initDisplayList(bone->getBoneData());
@ -86,167 +86,239 @@ bool DisplayManager::init(Bone *bone)
} }
void DisplayManager::addDisplay(DisplayData *displayData, int index) void CCDisplayManager::addDisplay(CCDisplayData *displayData, int index)
{ {
DecorativeDisplay *decoDisplay = NULL; CCDecorativeDisplay *decoDisplay = NULL;
if(index >= 0 && (unsigned int)index < _decoDisplayList->count()) if(index >= 0 && (unsigned int)index < m_pDecoDisplayList->count())
{ {
decoDisplay = (DecorativeDisplay *)_decoDisplayList->getObjectAtIndex(index); decoDisplay = (CCDecorativeDisplay *)m_pDecoDisplayList->getObjectAtIndex(index);
} }
else else
{ {
decoDisplay = DecorativeDisplay::create(); decoDisplay = CCDecorativeDisplay::create();
_decoDisplayList->addObject(decoDisplay); m_pDecoDisplayList->addObject(decoDisplay);
} }
DisplayFactory::addDisplay(_bone, decoDisplay, displayData); CCDisplayFactory::addDisplay(m_pBone, decoDisplay, displayData);
//! if changed display index is current display index, then change current display to the new display //! if changed display index is current display index, then change current display to the new display
if(index == _displayIndex) if(index == m_iDisplayIndex)
{ {
_displayIndex = -1; m_iDisplayIndex = -1;
changeDisplayByIndex(index, false); changeDisplayByIndex(index, false);
} }
} }
void DisplayManager::removeDisplay(int index) void CCDisplayManager::addDisplay(Node *display, int index)
{ {
_decoDisplayList->removeObjectAtIndex(index); CCDecorativeDisplay *decoDisplay = NULL;
if(index == _displayIndex) if(index >= 0 && (unsigned int)index < m_pDecoDisplayList->count())
{
decoDisplay = (CCDecorativeDisplay *)m_pDecoDisplayList->getObjectAtIndex(index);
}
else
{
decoDisplay = CCDecorativeDisplay::create();
m_pDecoDisplayList->addObject(decoDisplay);
}
CCDisplayData *displayData = NULL;
if (CCSkin *skin = dynamic_cast<CCSkin *>(display))
{
skin->setBone(m_pBone);
displayData = CCSpriteDisplayData::create();
CCDisplayFactory::initSpriteDisplay(m_pBone, decoDisplay, skin->getDisplayName().c_str(), skin);
if (CCSpriteDisplayData *spriteDisplayData = (CCSpriteDisplayData *)decoDisplay->getDisplayData())
{
skin->setSkinData(spriteDisplayData->skinData);
}
else
{
CCBaseData baseData;
skin->setSkinData(baseData);
}
}
else if (dynamic_cast<ParticleSystemQuad *>(display))
{
displayData = CCParticleDisplayData::create();
}
else if(CCArmature *armature = dynamic_cast<CCArmature *>(display))
{
displayData = CCArmatureDisplayData::create();
armature->setParentBone(m_pBone);
}
else
{
displayData = CCDisplayData::create();
}
decoDisplay->setDisplay(display);
decoDisplay->setDisplayData(displayData);
//! if changed display index is current display index, then change current display to the new display
if(index == m_iDisplayIndex)
{
m_iDisplayIndex = -1;
changeDisplayByIndex(index, false);
}
}
void CCDisplayManager::removeDisplay(int index)
{
m_pDecoDisplayList->removeObjectAtIndex(index);
if(index == m_iDisplayIndex)
{ {
setCurrentDecorativeDisplay(NULL); setCurrentDecorativeDisplay(NULL);
} }
} }
void DisplayManager::changeDisplayByIndex(int index, bool force) Array *CCDisplayManager::getDecorativeDisplayList()
{ {
CCASSERT( (_decoDisplayList ? index < (int)_decoDisplayList->count() : true), "the _index value is out of range"); return m_pDecoDisplayList;
}
_forceChangeDisplay = force; void CCDisplayManager::changeDisplayByIndex(int index, bool force)
{
CCAssert( (m_pDecoDisplayList ? index < (int)m_pDecoDisplayList->count() : true), "the _index value is out of range");
m_bForceChangeDisplay = force;
//! If index is equal to current display index,then do nothing //! If index is equal to current display index,then do nothing
if ( _displayIndex == index) if ( m_iDisplayIndex == index)
return; return;
_displayIndex = index; m_iDisplayIndex = index;
//! If displayIndex < 0, it means you want to hide you display //! If displayIndex < 0, it means you want to hide you display
if (_displayIndex < 0) if (m_iDisplayIndex < 0)
{ {
if(_displayRenderNode) if(m_pDisplayRenderNode)
{ {
_displayRenderNode->removeFromParentAndCleanup(true); m_pDisplayRenderNode->removeFromParentAndCleanup(true);
setCurrentDecorativeDisplay(NULL); setCurrentDecorativeDisplay(NULL);
} }
return; return;
} }
DecorativeDisplay *decoDisplay = (DecorativeDisplay *)_decoDisplayList->getObjectAtIndex(_displayIndex); CCDecorativeDisplay *decoDisplay = (CCDecorativeDisplay *)m_pDecoDisplayList->getObjectAtIndex(m_iDisplayIndex);
setCurrentDecorativeDisplay(decoDisplay); setCurrentDecorativeDisplay(decoDisplay);
} }
void DisplayManager::setCurrentDecorativeDisplay(DecorativeDisplay *decoDisplay) void CCDisplayManager::setCurrentDecorativeDisplay(CCDecorativeDisplay *decoDisplay)
{ {
#if ENABLE_PHYSICS_DETECT #if ENABLE_PHYSICS_BOX2D_DETECT || ENABLE_PHYSICS_CHIPMUNK_DETECT
if (_currentDecoDisplay && _currentDecoDisplay->getColliderDetector()) if (m_pCurrentDecoDisplay && m_pCurrentDecoDisplay->getColliderDetector())
{ {
_currentDecoDisplay->getColliderDetector()->setActive(false); m_pCurrentDecoDisplay->getColliderDetector()->setActive(false);
} }
#endif #endif
_currentDecoDisplay = decoDisplay; m_pCurrentDecoDisplay = decoDisplay;
#if ENABLE_PHYSICS_DETECT #if ENABLE_PHYSICS_BOX2D_DETECT || ENABLE_PHYSICS_CHIPMUNK_DETECT
if (_currentDecoDisplay && _currentDecoDisplay->getColliderDetector()) if (m_pCurrentDecoDisplay && m_pCurrentDecoDisplay->getColliderDetector())
{ {
_currentDecoDisplay->getColliderDetector()->setActive(true); m_pCurrentDecoDisplay->getColliderDetector()->setActive(true);
} }
#endif #endif
Node *displayRenderNode = _currentDecoDisplay == NULL ? NULL : _currentDecoDisplay->getDisplay(); Node *displayRenderNode = m_pCurrentDecoDisplay == NULL ? NULL : m_pCurrentDecoDisplay->getDisplay();
if (_displayRenderNode) if (m_pDisplayRenderNode)
{ {
if (dynamic_cast<Armature *>(_displayRenderNode) != NULL) if (dynamic_cast<CCArmature *>(m_pDisplayRenderNode) != NULL)
{ {
_bone->setChildArmature(NULL); m_pBone->setChildArmature(NULL);
} }
m_pDisplayRenderNode->removeFromParentAndCleanup(true);
_displayRenderNode->removeFromParentAndCleanup(true); m_pDisplayRenderNode->release();
_displayRenderNode->release();
} }
_displayRenderNode = displayRenderNode; m_pDisplayRenderNode = displayRenderNode;
if(_displayRenderNode) if(m_pDisplayRenderNode)
{ {
if (dynamic_cast<Armature *>(_displayRenderNode) != NULL) if (CCArmature *armature = dynamic_cast<CCArmature *>(m_pDisplayRenderNode))
{ {
_bone->setChildArmature((Armature *)_displayRenderNode); m_pBone->setChildArmature(armature);
} }
_displayRenderNode->retain(); else if (ParticleSystemQuad *particle = dynamic_cast<ParticleSystemQuad *>(m_pDisplayRenderNode))
_displayRenderNode->setVisible(_visible); {
particle->resetSystem();
}
if (RGBAProtocol *rgbaProtocaol = dynamic_cast<RGBAProtocol *>(m_pDisplayRenderNode))
{
rgbaProtocaol->setColor(m_pBone->getDisplayedColor());
rgbaProtocaol->setOpacity(m_pBone->getDisplayedOpacity());
}
m_pDisplayRenderNode->retain();
m_pDisplayRenderNode->setVisible(m_bVisible);
} }
} }
Node *DisplayManager::getDisplayRenderNode() Node *CCDisplayManager::getDisplayRenderNode()
{ {
return _displayRenderNode; return m_pDisplayRenderNode;
} }
int DisplayManager::getCurrentDisplayIndex() int CCDisplayManager::getCurrentDisplayIndex()
{ {
return _displayIndex; return m_iDisplayIndex;
} }
DecorativeDisplay *DisplayManager::getCurrentDecorativeDisplay() CCDecorativeDisplay *CCDisplayManager::getCurrentDecorativeDisplay()
{ {
return _currentDecoDisplay; return m_pCurrentDecoDisplay;
} }
DecorativeDisplay *DisplayManager::getDecorativeDisplayByIndex( int index) CCDecorativeDisplay *CCDisplayManager::getDecorativeDisplayByIndex( int index)
{ {
return static_cast<DecorativeDisplay *>( _decoDisplayList->getObjectAtIndex(index) ); return (CCDecorativeDisplay *)m_pDecoDisplayList->getObjectAtIndex(index);
} }
void DisplayManager::initDisplayList(BoneData *boneData) void CCDisplayManager::initDisplayList(CCBoneData *boneData)
{ {
CC_SAFE_DELETE(_decoDisplayList); CC_SAFE_DELETE(m_pDecoDisplayList);
_decoDisplayList = Array::create(); m_pDecoDisplayList = Array::create();
_decoDisplayList->retain(); m_pDecoDisplayList->retain();
CS_RETURN_IF(!boneData); CS_RETURN_IF(!boneData);
Object *object = NULL; Object *object = NULL;
Array *displayDataList = boneData->displayDataList; Array *displayDataList = &boneData->displayDataList;
CCARRAY_FOREACH(displayDataList, object) CCARRAY_FOREACH(displayDataList, object)
{ {
DisplayData *displayData = static_cast<DisplayData *>(object); CCDisplayData *displayData = (CCDisplayData *)object;
DecorativeDisplay *decoDisplay = DecorativeDisplay::create(); CCDecorativeDisplay *decoDisplay = CCDecorativeDisplay::create();
decoDisplay->setDisplayData(displayData); decoDisplay->setDisplayData(displayData);
DisplayFactory::createDisplay(_bone, decoDisplay); CCDisplayFactory::createDisplay(m_pBone, decoDisplay);
_decoDisplayList->addObject(decoDisplay); m_pDecoDisplayList->addObject(decoDisplay);
} }
} }
bool DisplayManager::containPoint(Point &point) bool CCDisplayManager::containPoint(Point &point)
{ {
if(!_visible || _displayIndex < 0) if(!m_bVisible || m_iDisplayIndex < 0)
{ {
return false; return false;
} }
bool ret = false; bool ret = false;
switch (_currentDecoDisplay->getDisplayData()->displayType) switch (m_pCurrentDecoDisplay->getDisplayData()->displayType)
{ {
case CS_DISPLAY_SPRITE: case CS_DISPLAY_SPRITE:
{ {
@ -258,7 +330,7 @@ bool DisplayManager::containPoint(Point &point)
Point outPoint = Point(0, 0); Point outPoint = Point(0, 0);
Sprite *sprite = (Sprite *)_currentDecoDisplay->getDisplay(); Sprite *sprite = (Sprite *)m_pCurrentDecoDisplay->getDisplay();
sprite = (Sprite *)sprite->getChildByTag(0); sprite = (Sprite *)sprite->getChildByTag(0);
ret = CC_SPRITE_CONTAIN_POINT_WITH_RETURN(sprite, point, outPoint); ret = CC_SPRITE_CONTAIN_POINT_WITH_RETURN(sprite, point, outPoint);
@ -272,52 +344,52 @@ bool DisplayManager::containPoint(Point &point)
return ret; return ret;
} }
bool DisplayManager::containPoint(float x, float y) bool CCDisplayManager::containPoint(float x, float y)
{ {
Point p = Point(x, y); Point p = Point(x, y);
return containPoint(p); return containPoint(p);
} }
void DisplayManager::setVisible(bool visible) void CCDisplayManager::setVisible(bool visible)
{ {
if(!_displayRenderNode) if(!m_pDisplayRenderNode)
return; return;
_visible = visible; m_bVisible = visible;
_displayRenderNode->setVisible(visible); m_pDisplayRenderNode->setVisible(visible);
} }
bool DisplayManager::isVisible() bool CCDisplayManager::isVisible()
{ {
return _visible; return m_bVisible;
} }
Size DisplayManager::getContentSize() Size CCDisplayManager::getContentSize()
{ {
CS_RETURN_IF(!_displayRenderNode) Size(0, 0); CS_RETURN_IF(!m_pDisplayRenderNode) Size(0, 0);
return _displayRenderNode->getContentSize(); return m_pDisplayRenderNode->getContentSize();
} }
Rect DisplayManager::getBoundingBox() Rect CCDisplayManager::getBoundingBox()
{ {
CS_RETURN_IF(!_displayRenderNode) Rect(0, 0, 0, 0); CS_RETURN_IF(!m_pDisplayRenderNode) Rect(0, 0, 0, 0);
return _displayRenderNode->getBoundingBox(); return m_pDisplayRenderNode->getBoundingBox();
} }
Point DisplayManager::getAnchorPoint() Point CCDisplayManager::getAnchorPoint()
{ {
CS_RETURN_IF(!_displayRenderNode) Point(0, 0); CS_RETURN_IF(!m_pDisplayRenderNode) Point(0, 0);
return _displayRenderNode->getAnchorPoint(); return m_pDisplayRenderNode->getAnchorPoint();
} }
Point DisplayManager::getAnchorPointInPoints() Point CCDisplayManager::getAnchorPointInPoints()
{ {
CS_RETURN_IF(!_displayRenderNode) Point(0, 0); CS_RETURN_IF(!m_pDisplayRenderNode) Point(0, 0);
return _displayRenderNode->getAnchorPointInPoints(); return m_pDisplayRenderNode->getAnchorPointInPoints();
} }
}}} // namespace cocos2d { namespace extension { namespace armature { NS_CC_EXT_ARMATURE_END

59
extensions/CocoStudio/Armature/display/CCDisplayManager.h
View File

@ -29,35 +29,28 @@ THE SOFTWARE.
#include "../display/CCDecorativeDisplay.h" #include "../display/CCDecorativeDisplay.h"
#include "../datas/CCDatas.h" #include "../datas/CCDatas.h"
namespace cocos2d { namespace extension { namespace armature { NS_CC_EXT_ARMATURE_BEGIN
class Bone; class CCBone;
//! DisplayManager manages Bone's display //! CCDisplayManager manages CCBone's display
class DisplayManager : public Object class CCDisplayManager : public Object
{ {
public: public:
static DisplayManager *create(Bone *bone); static CCDisplayManager *create(CCBone *bone);
public: public:
/** CCDisplayManager();
* @js ctor ~CCDisplayManager();
*/
DisplayManager();
/**
* @js NA
* @lua NA
*/
~DisplayManager();
bool init(Bone *bone); bool init(CCBone *bone);
/** /**
* Use BoneData to init the display list. * Use CCBoneData to init the display list.
* If display is a sprite, and it have texture info in the TexutreData, then use TexutreData to init the display's anchor point * If display is a sprite, and it have texture info in the TexutreData, then use TexutreData to init the display's anchor point
* If the display is a Armature, then create a new Armature * If the display is a CCArmature, then create a new CCArmature
*/ */
void initDisplayList(BoneData *boneData); virtual void initDisplayList(CCBoneData *boneData);
/** /**
* Add display and use _DisplayData init the display. * Add display and use _DisplayData init the display.
@ -65,12 +58,14 @@ public:
* If index is current display index, then also change display to _index * If index is current display index, then also change display to _index
* *
* @param displayData it include the display information, like DisplayType. * @param displayData it include the display information, like DisplayType.
* If you want to create a sprite display, then create a SpriteDisplayData param * If you want to create a sprite display, then create a CCSpriteDisplayData param
* *
* @param index the index of the display you want to replace or add to * @param index the index of the display you want to replace or add to
* -1 : append display from back * -1 : append display from back
*/ */
void addDisplay(DisplayData *displayData, int index); void addDisplay(CCDisplayData *displayData, int index);
void addDisplay(Node *display, int index);
void removeDisplay(int index); void removeDisplay(int index);
@ -92,9 +87,9 @@ public:
int getCurrentDisplayIndex(); int getCurrentDisplayIndex();
void setCurrentDecorativeDisplay(DecorativeDisplay *decoDisplay); virtual void setCurrentDecorativeDisplay(CCDecorativeDisplay *decoDisplay);
DecorativeDisplay *getCurrentDecorativeDisplay(); virtual CCDecorativeDisplay *getCurrentDecorativeDisplay();
DecorativeDisplay *getDecorativeDisplayByIndex( int index); virtual CCDecorativeDisplay *getDecorativeDisplayByIndex( int index);
/** /**
* Sets whether the display is visible * Sets whether the display is visible
@ -128,22 +123,22 @@ public:
virtual bool containPoint(float x, float y); virtual bool containPoint(float x, float y);
protected: protected:
Array *_decoDisplayList; Array *m_pDecoDisplayList;
//! Display render node. //! Display render node.
Node *_displayRenderNode; Node *m_pDisplayRenderNode;
//! Include current display information, like contour sprite, etc. //! Include current display information, like contour sprite, etc.
DecorativeDisplay *_currentDecoDisplay; CCDecorativeDisplay *m_pCurrentDecoDisplay;
//! Current display index //! Current display index
int _displayIndex; int m_iDisplayIndex;
CC_SYNTHESIZE_PASS_BY_REF(bool, _forceChangeDisplay, ForceChangeDisplay) CC_SYNTHESIZE(bool, m_bForceChangeDisplay, ForceChangeDisplay)
//! Whether of not the bone is visible. Default is true //! Whether of not the bone is visible. Default is true
bool _visible; bool m_bVisible;
Bone *_bone; CCBone *m_pBone;
}; };
}}} // namespace cocos2d { namespace extension { namespace armature { NS_CC_EXT_ARMATURE_END
#endif /*__CCDISPLAYMANAGER_H__*/ #endif /*__CCDISPLAYMANAGER_H__*/

136
extensions/CocoStudio/Armature/display/CCShaderNode.cpp
View File

@ -1,136 +0,0 @@
/****************************************************************************
Copyright (c) 2013 cocos2d-x.org
http://www.cocos2d-x.org
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.
****************************************************************************/
#include "CCShaderNode.h"
namespace cocos2d { namespace extension { namespace armature {
enum
{
SIZE_X = 128,
SIZE_Y = 128,
};
ShaderNode::ShaderNode()
: _center(Vertex2F(0.0f, 0.0f))
, _resolution(Vertex2F(0.0f, 0.0f))
, _time(0.0f)
, _uniformCenter(0)
, _uniformResolution(0)
, _uniformTime(0)
{
}
ShaderNode *ShaderNode::shaderNodeWithVertex(const char *vert, const char *frag)
{
ShaderNode *node = new ShaderNode();
node->initWithVertex(vert, frag);
node->autorelease();
return node;
}
bool ShaderNode::initWithVertex(const char *vert, const char *frag)
{
loadShaderVertex(vert, frag);
_time = 0;
_resolution = Vertex2F(SIZE_X, SIZE_Y);
scheduleUpdate();
setContentSize(Size(SIZE_X, SIZE_Y));
setAnchorPoint(Point(0.5f, 0.5f));
return true;
}
void ShaderNode::loadShaderVertex(const char *vert, const char *frag)
{
GLProgram *shader = new GLProgram();
shader->initWithVertexShaderFilename(vert, frag);
shader->addAttribute("aVertex", GLProgram::VERTEX_ATTRIB_POSITION);
shader->link();
shader->updateUniforms();
_uniformCenter = glGetUniformLocation(shader->getProgram(), "center");
_uniformResolution = glGetUniformLocation(shader->getProgram(), "resolution");
_uniformTime = glGetUniformLocation(shader->getProgram(), "time");
this->setShaderProgram(shader);
shader->release();
}
void ShaderNode::update(float dt)
{
_time += dt;
}
void ShaderNode::translateFormOtherNode(AffineTransform &transform)
{
Node::setAdditionalTransform(transform);
_center = Vertex2F(_additionalTransform.tx * CC_CONTENT_SCALE_FACTOR(), _additionalTransform.ty * CC_CONTENT_SCALE_FACTOR());
_resolution = Vertex2F( SIZE_X * _additionalTransform.a, SIZE_Y * _additionalTransform.d);
}
void ShaderNode::setPosition(const Point &newPosition)
{
Node::setPosition(newPosition);
Point position = getPosition();
_center = Vertex2F(position.x * CC_CONTENT_SCALE_FACTOR(), position.y * CC_CONTENT_SCALE_FACTOR());
}
void ShaderNode::draw()
{
CC_NODE_DRAW_SETUP();
float w = SIZE_X, h = SIZE_Y;
GLfloat vertices[12] = {0, 0, w, 0, w, h, 0, 0, 0, h, w, h};
//
// Uniforms
//
getShaderProgram()->setUniformLocationWith2f(_uniformCenter, _center.x, _center.y);
getShaderProgram()->setUniformLocationWith2f(_uniformResolution, _resolution.x, _resolution.y);
// time changes all the time, so it is Ok to call OpenGL directly, and not the "cached" version
glUniform1f(_uniformTime, _time);
GL::enableVertexAttribs(GL::VERTEX_ATTRIB_FLAG_POSITION);
glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_POSITION, 2, GL_FLOAT, GL_FALSE, 0, vertices);
glDrawArrays(GL_TRIANGLES, 0, 6);
CC_INCREMENT_GL_DRAWS(1);
}
}}} // namespace cocos2d { namespace extension { namespace armature {

57
extensions/CocoStudio/Armature/display/CCShaderNode.h
View File

@ -1,57 +0,0 @@
/****************************************************************************
Copyright (c) 2013 cocos2d-x.org
http://www.cocos2d-x.org
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 __CCSHADERNODE_H__
#define __CCSHADERNODE_H__
#include "../utils/CCArmatureDefine.h"
namespace cocos2d { namespace extension { namespace armature {
class ShaderNode : public Node
{
public:
ShaderNode();
bool initWithVertex(const char *vert, const char *frag);
void loadShaderVertex(const char *vert, const char *frag);
virtual void update(float dt);
virtual void setPosition(const Point &newPosition);
virtual void translateFormOtherNode(AffineTransform &transform);
virtual void draw();
static ShaderNode *shaderNodeWithVertex(const char *vert, const char *frag);
private:
Vertex2F _center;
Vertex2F _resolution;
float _time;
GLuint _uniformCenter, _uniformResolution, _uniformTime;
};
}}} // namespace cocos2d { namespace extension { namespace armature {
#endif /*__CCSHADERNODE_H__*/

110
extensions/CocoStudio/Armature/display/CCSkin.cpp
View File

@ -24,8 +24,10 @@ THE SOFTWARE.
#include "CCSkin.h" #include "CCSkin.h"
#include "../utils/CCTransformHelp.h" #include "../utils/CCTransformHelp.h"
#include "../utils/CCSpriteFrameCacheHelper.h"
#include "../CCArmature.h"
namespace cocos2d { namespace extension { namespace armature { NS_CC_EXT_ARMATURE_BEGIN
#if CC_SPRITEBATCHNODE_RENDER_SUBPIXEL #if CC_SPRITEBATCHNODE_RENDER_SUBPIXEL
#define RENDER_IN_SUBPIXEL #define RENDER_IN_SUBPIXEL
@ -33,9 +35,9 @@ namespace cocos2d { namespace extension { namespace armature {
#define RENDER_IN_SUBPIXEL(__ARGS__) (ceil(__ARGS__)) #define RENDER_IN_SUBPIXEL(__ARGS__) (ceil(__ARGS__))
#endif #endif
Skin *Skin::create() CCSkin *CCSkin::create()
{ {
Skin *skin = new Skin(); CCSkin *skin = new CCSkin();
if(skin && skin->init()) if(skin && skin->init())
{ {
skin->autorelease(); skin->autorelease();
@ -45,9 +47,9 @@ Skin *Skin::create()
return NULL; return NULL;
} }
Skin *Skin::createWithSpriteFrameName(const char *pszSpriteFrameName) CCSkin *CCSkin::createWithSpriteFrameName(const char *pszSpriteFrameName)
{ {
Skin *skin = new Skin(); CCSkin *skin = new CCSkin();
if(skin && skin->initWithSpriteFrameName(pszSpriteFrameName)) if(skin && skin->initWithSpriteFrameName(pszSpriteFrameName))
{ {
skin->autorelease(); skin->autorelease();
@ -57,34 +59,78 @@ Skin *Skin::createWithSpriteFrameName(const char *pszSpriteFrameName)
return NULL; return NULL;
} }
Skin::Skin() CCSkin *CCSkin::create(const char *pszFileName)
: _bone(NULL)
{ {
CCSkin *skin = new CCSkin();
if(skin && skin->initWithFile(pszFileName))
{
skin->autorelease();
return skin;
}
CC_SAFE_DELETE(skin);
return NULL;
} }
void Skin::setSkinData(const BaseData &var) CCSkin::CCSkin()
: m_pBone(NULL)
, m_strDisplayName("")
{ {
_skinData = var; m_tSkinTransform = AffineTransformIdentity;
setScaleX(_skinData.scaleX);
setScaleY(_skinData.scaleY);
setRotation(CC_RADIANS_TO_DEGREES(_skinData.skewX));
setPosition(Point(_skinData.x, _skinData.y));
_skinTransform = getNodeToParentTransform();
} }
const BaseData &Skin::getSkinData() const bool CCSkin::initWithSpriteFrameName(const char *pszSpriteFrameName)
{ {
return _skinData; bool ret = Sprite::initWithSpriteFrameName(pszSpriteFrameName);
if (ret)
{
TextureAtlas *atlas = CCSpriteFrameCacheHelper::sharedSpriteFrameCacheHelper()->getTexureAtlasWithTexture(_texture);
setTextureAtlas(atlas);
m_strDisplayName = pszSpriteFrameName;
}
return ret;
} }
void Skin::updateTransform() bool CCSkin::initWithFile(const char *pszFilename)
{ {
_transform = AffineTransformConcat(_skinTransform, _bone->nodeToArmatureTransform()); bool ret = Sprite::initWithFile(pszFilename);
if (ret)
{
TextureAtlas *atlas = CCSpriteFrameCacheHelper::sharedSpriteFrameCacheHelper()->getTexureAtlasWithTexture(_texture);
setTextureAtlas(atlas);
m_strDisplayName = pszFilename;
}
return ret;
} }
void Skin::draw() void CCSkin::setSkinData(const CCBaseData &var)
{
m_sSkinData = var;
setScaleX(m_sSkinData.scaleX);
setScaleY(m_sSkinData.scaleY);
setRotation(CC_RADIANS_TO_DEGREES(m_sSkinData.skewX));
setPosition(Point(m_sSkinData.x, m_sSkinData.y));
m_tSkinTransform = getNodeToParentTransform();
}
const CCBaseData &CCSkin::getSkinData() const
{
return m_sSkinData;
}
void CCSkin::updateArmatureTransform()
{
_transform = AffineTransformConcat(m_tSkinTransform, m_pBone->getNodeToArmatureTransform());
}
void CCSkin::updateTransform()
{ {
// If it is not visible, or one of its ancestors is not visible, then do nothing: // If it is not visible, or one of its ancestors is not visible, then do nothing:
if( !_visible) if( !_visible)
@ -97,7 +143,7 @@ void Skin::draw()
// calculate the Quad based on the Affine Matrix // calculate the Quad based on the Affine Matrix
// //
Size size = _rect.size; Size &size = _rect.size;
float x1 = _offsetPosition.x; float x1 = _offsetPosition.x;
float y1 = _offsetPosition.y; float y1 = _offsetPosition.y;
@ -137,4 +183,22 @@ void Skin::draw()
} }
} }
}}} // namespace cocos2d { namespace extension { namespace armature { AffineTransform CCSkin::getNodeToWorldTransform() const
{
return AffineTransformConcat(_transform, m_pBone->getArmature()->getNodeToWorldTransform());
}
AffineTransform CCSkin::getNodeToWorldTransformAR() const
{
AffineTransform displayTransform = _transform;
Point anchorPoint = _anchorPointInPoints;
anchorPoint = PointApplyAffineTransform(anchorPoint, displayTransform);
displayTransform.tx = anchorPoint.x;
displayTransform.ty = anchorPoint.y;
return AffineTransformConcat(displayTransform, m_pBone->getArmature()->getNodeToWorldTransform());
}
NS_CC_EXT_ARMATURE_END

28
extensions/CocoStudio/Armature/display/CCSkin.h
View File

@ -28,26 +28,34 @@ THE SOFTWARE.
#include "../utils/CCArmatureDefine.h" #include "../utils/CCArmatureDefine.h"
#include "../CCBone.h" #include "../CCBone.h"
namespace cocos2d { namespace extension { namespace armature { NS_CC_EXT_ARMATURE_BEGIN
class Skin : public Sprite class CCSkin : public Sprite
{ {
public: public:
static Skin *create(); static CCSkin *create();
static Skin *createWithSpriteFrameName(const char *pszSpriteFrameName); static CCSkin *createWithSpriteFrameName(const char *pszSpriteFrameName);
static CCSkin *create(const char *pszFileName);
public: public:
Skin(); CCSkin();
bool initWithSpriteFrameName(const char *pszSpriteFrameName);
bool initWithFile(const char *pszFilename);
void updateArmatureTransform();
void updateTransform(); void updateTransform();
void draw();
CC_PROPERTY_PASS_BY_REF(BaseData, _skinData, SkinData); AffineTransform getNodeToWorldTransform() const;
CC_SYNTHESIZE(Bone *, _bone, Bone); AffineTransform getNodeToWorldTransformAR() const;
CC_PROPERTY_PASS_BY_REF(CCBaseData, m_sSkinData, SkinData);
CC_SYNTHESIZE(CCBone *, m_pBone, Bone);
protected: protected:
AffineTransform _skinTransform; AffineTransform m_tSkinTransform;
CC_SYNTHESIZE_READONLY(std::string, m_strDisplayName, DisplayName)
}; };
}}} // namespace cocos2d { namespace extension { namespace armature { NS_CC_EXT_ARMATURE_END
#endif /*__CCSKIN_H__*/ #endif /*__CCSKIN_H__*/

312
extensions/CocoStudio/Armature/external_tool/CCTexture2DMutable.cpp
View File

@ -1,312 +0,0 @@
//
// Texture2DMutable.cpp
// Ported to C++ by Dmitry Matyukhin
//
// MutableTexture.m
// Created by Lam Hoang Pham.
// Improved by Manuel Martinez-Almeida.
//
#include "CCTexture2DMutable.h"
using namespace cocos2d;
#if CC_MUTABLE_TEXTURE_SAVE_ORIGINAL_DATA
void* Texture2DMutable::getOriginalTexData() {
return originalData_;
}
#endif
void* Texture2DMutable::getTexData() {
return data_;
}
void Texture2DMutable::setTexData(void *var) {
data_ = var;
}
void Texture2DMutable::releaseData(void* data)
{
//Don't free the data
}
void* Texture2DMutable::keepData(void* data, unsigned int lenght)
{
void *newData = malloc(lenght);
memmove(newData, data, lenght);
return newData;
}
bool Texture2DMutable::initWithImageFile(const char *imageFile, cocos2d::Texture2D::PixelFormat pixelFormat, unsigned int pixelsWide, unsigned int pixelsHigh, const cocos2d::Size& contentSize)
{
image_ = new cocos2d::Image();
image_->initWithImageFile(imageFile);
return initWithData(image_->getData(), image_->getDataLen(), pixelFormat, pixelsWide, pixelsHigh, contentSize);
}
bool Texture2DMutable::initWithImageFile(const char *imageFile)
{
image_ = new cocos2d::Image();
image_->initWithImageFile(imageFile);
bool hasAlpha = image_->hasAlpha();
Size imageSize = Size((float)(image_->getWidth()), (float)(image_->getHeight()));
size_t bpp = image_->getBitPerPixel();
cocos2d::Texture2D::PixelFormat pixelFormat;
// compute pixel format
if(hasAlpha)
{
pixelFormat = Texture2D::PixelFormat::DEFAULT;
}
else
{
if (bpp >= 8)
{
pixelFormat = Texture2D::PixelFormat::RGB888;
}
else
{
pixelFormat = Texture2D::PixelFormat::RGB565;
}
}
return initWithData(image_->getData(), image_->getDataLen(), pixelFormat, imageSize.width, imageSize.height, imageSize);
}
bool Texture2DMutable::initWithData(const void* data, int dataLen, Texture2D::PixelFormat pixelFormat, unsigned int width, unsigned int height, const Size& size)
{
if(!Texture2D::initWithData(data, dataLen, pixelFormat, width, height, size)) {
return false;
}
switch (pixelFormat) {
case Texture2D::PixelFormat::RGBA8888: bytesPerPixel_ = 4; break;
case Texture2D::PixelFormat::A8: bytesPerPixel_ = 1; break;
case Texture2D::PixelFormat::RGBA4444:
case Texture2D::PixelFormat::RGB565:
case Texture2D::PixelFormat::RGB5A1:
bytesPerPixel_ = 2;
break;
default:break;
}
data_ = (void*) data;
#if CC_MUTABLE_TEXTURE_SAVE_ORIGINAL_DATA
unsigned int max = width * height * bytesPerPixel_;
originalData_ = malloc(max);
memcpy(originalData_, data_, max);
#endif
return true;
}
Color4B Texture2DMutable::pixelAt(const Point& pt)
{
Color4B c(0, 0, 0, 0);
if(!data_) return c;
if(pt.x < 0 || pt.y < 0) return c;
if(pt.x >= _contentSize.width || pt.y >= _contentSize.height) return c;
//! modified, texture origin point is left top, cocos2d origin point is left bottom
//! unsigned int x = pt.x, y = pt.y
unsigned int x = pt.x, y = _pixelsHigh - pt.y;
if(_pixelFormat == Texture2D::PixelFormat::RGBA8888){
unsigned int *pixel = (unsigned int *)data_;
pixel = pixel + (y * _pixelsWide) + x;
c.r = *pixel & 0xff;
c.g = (*pixel >> 8) & 0xff;
c.b = (*pixel >> 16) & 0xff;
c.a = (*pixel >> 24) & 0xff;
} else if(_pixelFormat == Texture2D::PixelFormat::RGBA4444){
GLushort *pixel = (GLushort *)data_;
pixel = pixel + (y * _pixelsWide) + x;
c.a = ((*pixel & 0xf) << 4) | (*pixel & 0xf);
c.b = (((*pixel >> 4) & 0xf) << 4) | ((*pixel >> 4) & 0xf);
c.g = (((*pixel >> 8) & 0xf) << 4) | ((*pixel >> 8) & 0xf);
c.r = (((*pixel >> 12) & 0xf) << 4) | ((*pixel >> 12) & 0xf);
} else if(_pixelFormat == Texture2D::PixelFormat::RGB5A1){
GLushort *pixel = (GLushort *)data_;
pixel = pixel + (y * _pixelsWide) + x;
c.r = ((*pixel >> 11) & 0x1f)<<3;
c.g = ((*pixel >> 6) & 0x1f)<<3;
c.b = ((*pixel >> 1) & 0x1f)<<3;
c.a = (*pixel & 0x1)*255;
} else if(_pixelFormat == Texture2D::PixelFormat::RGB565){
GLushort *pixel = (GLushort *)data_;
pixel = pixel + (y * _pixelsWide) + x;
c.b = (*pixel & 0x1f)<<3;
c.g = ((*pixel >> 5) & 0x3f)<<2;
c.r = ((*pixel >> 11) & 0x1f)<<3;
c.a = 255;
} else if(_pixelFormat == Texture2D::PixelFormat::A8){
GLubyte *pixel = (GLubyte *)data_;
c.a = pixel[(y * _pixelsWide) + x];
// Default white
c.r = 255;
c.g = 255;
c.b = 255;
}
//log("color : %i, %i, %i, %i", c.r, c.g, c.b, c.a);
return c;
}
bool Texture2DMutable::setPixelAt(const Point& pt, Color4B c)
{
if(!data_)return false;
if(pt.x < 0 || pt.y < 0) return false;
if(pt.x >= _contentSize.width || pt.y >= _contentSize.height) return false;
unsigned int x = pt.x, y = pt.y;
dirty_ = true;
// Shifted bit placement based on little-endian, let's make this more
// portable =/
if(_pixelFormat == Texture2D::PixelFormat::RGBA8888){
unsigned int *pixel = (unsigned int *)data_;
pixel[(y * _pixelsWide) + x] = (c.a << 24) | (c.b << 16) | (c.g << 8) | c.r;
} else if(_pixelFormat == Texture2D::PixelFormat::RGBA4444){
GLushort *pixel = (GLushort *)data_;
pixel = pixel + (y * _pixelsWide) + x;
*pixel = ((c.r >> 4) << 12) | ((c.g >> 4) << 8) | ((c.b >> 4) << 4) | (c.a >> 4);
} else if(_pixelFormat == Texture2D::PixelFormat::RGB5A1){
GLushort *pixel = (GLushort *)data_;
pixel = pixel + (y * _pixelsWide) + x;
*pixel = ((c.r >> 3) << 11) | ((c.g >> 3) << 6) | ((c.b >> 3) << 1) | (c.a > 0);
} else if(_pixelFormat == Texture2D::PixelFormat::RGB565){
GLushort *pixel = (GLushort *)data_;
pixel = pixel + (y * _pixelsWide) + x;
*pixel = ((c.r >> 3) << 11) | ((c.g >> 2) << 5) | (c.b >> 3);
} else if(_pixelFormat == Texture2D::PixelFormat::A8){
GLubyte *pixel = (GLubyte *)data_;
pixel[(y * _pixelsWide) + x] = c.a;
} else {
dirty_ = false;
return false;
}
return true;
}
void Texture2DMutable::fill(Color4B p)
{
for(int r = 0; r < _contentSize.height; ++r)
for(int c = 0; c < _contentSize.width; ++c)
this->setPixelAt(Point(c, r), p);
}
Texture2D* Texture2DMutable::copyMutable(bool isMutable )
{
Texture2D* co;
if(isMutable)
{
int mem = _pixelsWide*_pixelsHigh*bytesPerPixel_;
void *newData = malloc(mem);
memcpy(newData, data_, mem);
co = new Texture2DMutable();
if (!co->initWithData(newData, mem, _pixelFormat, _pixelsWide, _pixelsHigh, _contentSize)) {
delete co;
co = NULL;
}
}else {
co = new Texture2D();
if (!co->initWithData(data_, _pixelsWide*_pixelsHigh*bytesPerPixel_, _pixelFormat, _pixelsWide, _pixelsHigh, _contentSize)) {
delete co;
co = NULL;
}
}
return co;
}
Texture2DMutable* Texture2DMutable::copy()
{
return (Texture2DMutable*)this->copyMutable( true );
}
void Texture2DMutable::copy(Texture2DMutable* textureToCopy, const Point& offset)
{
for(int r = 0; r < _contentSize.height;++r){
for(int c = 0; c < _contentSize.width; ++c){
setPixelAt(Point(c + offset.x, r + offset.y), textureToCopy->pixelAt(Point(c, r)));
}
}
}
void Texture2DMutable::restore()
{
#if CC_MUTABLE_TEXTURE_SAVE_ORIGINAL_DATA
memcpy(data_, originalData_, bytesPerPixel_*_pixelsWide*_pixelsHigh);
this->apply();
#else
//You should set CC_MUTABLE_TEXTURE_SAVE_ORIGINAL_DATA 1 in Texture2DMutable.h
CCASSERT(false, "Exception: MutableTexture.restore was disabled by the user.");
#endif
}
void Texture2DMutable::apply()
{
if(!data_) return;
glBindTexture(GL_TEXTURE_2D, _name);
switch(_pixelFormat)
{
case Texture2D::PixelFormat::RGBA8888:
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, _pixelsWide, _pixelsHigh, 0, GL_RGBA, GL_UNSIGNED_BYTE, data_);
break;
case Texture2D::PixelFormat::RGBA4444:
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, _pixelsWide, _pixelsHigh, 0, GL_RGBA, GL_UNSIGNED_SHORT_4_4_4_4, data_);
break;
case Texture2D::PixelFormat::RGB5A1:
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, _pixelsWide, _pixelsHigh, 0, GL_RGBA, GL_UNSIGNED_SHORT_5_5_5_1, data_);
break;
case Texture2D::PixelFormat::RGB565:
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, _pixelsWide, _pixelsHigh, 0, GL_RGB, GL_UNSIGNED_SHORT_5_6_5, data_);
break;
case Texture2D::PixelFormat::A8:
glTexImage2D(GL_TEXTURE_2D, 0, GL_ALPHA, _pixelsWide, _pixelsHigh, 0, GL_ALPHA, GL_UNSIGNED_BYTE, data_);
break;
default:
CCASSERT(false, "NSInternalInconsistencyException");
}
glBindTexture(GL_TEXTURE_2D, 0);
dirty_ = false;
}
void *Texture2DMutable::getData()
{
return data_;
}
Texture2DMutable::Texture2DMutable(void)
{
image_ = NULL;
}
Texture2DMutable::~Texture2DMutable(void)
{
CCLOGINFO("deallocing Texture2DMutable: %p", this);
CC_SAFE_DELETE(image_);
free(data_);
#if CC_MUTABLE_TEXTURE_SAVE_ORIGINAL_DATA
free(originalData_);
#endif
}

93
extensions/CocoStudio/Armature/external_tool/CCTexture2DMutable.h
View File

@ -1,93 +0,0 @@
//
// Texture2DMutable.h
// Ported to C++ by Dmitry Matyukhin
//
// MutableTexture.m
// Created by Lam Hoang Pham.
// Improved by Manuel Martinez-Almeida.
//
#ifndef Texture2DMutable_cpp
#define Texture2DMutable_cpp
#include "cocos2d.h"
#define CC_MUTABLE_TEXTURE_SAVE_ORIGINAL_DATA 0
class Texture2DMutable : public cocos2d::Texture2D
{
#if CC_MUTABLE_TEXTURE_SAVE_ORIGINAL_DATA
CC_PROPERTY_READONLY(void*, originalData_, OriginalTexData);
#endif
CC_PROPERTY(void*, data_, TexData);
unsigned int bytesPerPixel_;
bool dirty_;
cocos2d::Image *image_;
public:
/**
* @js ctor
*/
Texture2DMutable(void);
/**
* @js NA
* @lua NA
*/
~Texture2DMutable(void);
void restore();
/** These functions are needed to create mutable textures */
void releaseData(void *data);
void* keepData(void *data, unsigned int length);
bool initWithImageFile(const char *imageFile, cocos2d::Texture2D::PixelFormat pixelFormat, unsigned int pixelsWide, unsigned int pixelsHigh, const cocos2d::Size& contentSize);
bool initWithImageFile(const char *imageFilex);
/** Intializes with a texture2d with data */
bool initWithData(const void* data, int dataLen, cocos2d::Texture2D::PixelFormat pixelFormat, unsigned int pixelsWide, unsigned int pixelsHigh, const cocos2d::Size& contentSize);
cocos2d::Color4B pixelAt(const cocos2d::Point& pt);
///
// @param pt is a point to get a pixel (0,0) is top-left to (width,height) bottom-right
// @param c is a Color4B which is a colour.
// @returns if a pixel was set
// Remember to call apply to actually update the texture canvas.
///
bool setPixelAt(const cocos2d::Point& pt, cocos2d::Color4B c);
///
// Fill with specified colour
///
void fill(cocos2d::Color4B c);
///
// @param textureToCopy is the texture image to copy over
// @param offset also offset's the texture image
///
Texture2D* copyMutable(bool isMutable);
Texture2DMutable* copy();
void copy(Texture2DMutable* textureToCopy, const cocos2d::Point& offset);
///
// apply actually updates the texture with any new data we added.
///
void apply();
void *getData();
};
#endif // Texture2DMutable_cpp

254
extensions/CocoStudio/Armature/external_tool/GLES-Render.cpp
View File

@ -1,254 +0,0 @@
/*
* Copyright (c) 2006-2007 Erin Catto http://www.gphysics.com
*
* iPhone port by Simon Oliver - http://www.simonoliver.com - http://www.handcircus.com
*
* This software is provided 'as-is', without any express or implied
* warranty. In no event will the authors be held liable for any damages
* arising from the use of this software.
* Permission is granted to anyone to use this software for any purpose,
* including commercial applications, and to alter it and redistribute it
* freely, subject to the following restrictions:
* 1. The origin of this software must not be misrepresented; you must not
* claim that you wrote the original software. If you use this software
* in a product, an acknowledgment in the product documentation would be
* appreciated but is not required.
* 2. Altered source versions must be plainly marked as such, and must not be
* misrepresented as being the original software.
* 3. This notice may not be removed or altered from any source distribution.
*/
#include "GLES-Render.h"
#include "cocos2d.h"
#include <stdio.h>
#include <stdarg.h>
#include <string.h>
namespace cocos2d { namespace extension { namespace armature {
USING_NS_CC;
GLESDebugDraw::GLESDebugDraw()
: mRatio( 1.0f )
{
this->initShader();
}
GLESDebugDraw::GLESDebugDraw( float32 ratio )
: mRatio( ratio )
{
this->initShader();
}
void GLESDebugDraw::initShader( void )
{
mShaderProgram = ShaderCache::getInstance()->programForKey(GLProgram::SHADER_NAME_POSITION_U_COLOR);
mColorLocation = glGetUniformLocation( mShaderProgram->getProgram(), "u_color");
}
void GLESDebugDraw::DrawPolygon(const b2Vec2* old_vertices, int vertexCount, const b2Color& color)
{
mShaderProgram->use();
mShaderProgram->setUniformsForBuiltins();
b2Vec2* vertices = new b2Vec2[vertexCount];
for( int i=0;i<vertexCount;i++)
{
vertices[i] = old_vertices[i];
vertices[i] *= mRatio;
}
mShaderProgram->setUniformLocationWith4f(mColorLocation, color.r, color.g, color.b, 1);
glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_POSITION, 2, GL_FLOAT, GL_FALSE, 0, vertices);
glDrawArrays(GL_LINE_LOOP, 0, vertexCount);
CC_INCREMENT_GL_DRAWS(1);
CHECK_GL_ERROR_DEBUG();
delete[] vertices;
}
void GLESDebugDraw::DrawSolidPolygon(const b2Vec2* old_vertices, int vertexCount, const b2Color& color)
{
mShaderProgram->use();
mShaderProgram->setUniformsForBuiltins();
b2Vec2* vertices = new b2Vec2[vertexCount];
for( int i=0;i<vertexCount;i++) {
vertices[i] = old_vertices[i];
vertices[i] *= mRatio;
}
mShaderProgram->setUniformLocationWith4f(mColorLocation, color.r*0.5f, color.g*0.5f, color.b*0.5f, 0.5f);
glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_POSITION, 2, GL_FLOAT, GL_FALSE, 0, vertices);
glDrawArrays(GL_TRIANGLE_FAN, 0, vertexCount);
mShaderProgram->setUniformLocationWith4f(mColorLocation, color.r, color.g, color.b, 1);
glDrawArrays(GL_LINE_LOOP, 0, vertexCount);
CC_INCREMENT_GL_DRAWS(2);
CHECK_GL_ERROR_DEBUG();
delete[] vertices;
}
void GLESDebugDraw::DrawCircle(const b2Vec2& center, float32 radius, const b2Color& color)
{
mShaderProgram->use();
mShaderProgram->setUniformsForBuiltins();
const float32 k_segments = 16.0f;
int vertexCount=16;
const float32 k_increment = 2.0f * b2_pi / k_segments;
float32 theta = 0.0f;
GLfloat* glVertices = new GLfloat[vertexCount*2];
for (int i = 0; i < k_segments; ++i)
{
b2Vec2 v = center + radius * b2Vec2(cosf(theta), sinf(theta));
glVertices[i*2]=v.x * mRatio;
glVertices[i*2+1]=v.y * mRatio;
theta += k_increment;
}
mShaderProgram->setUniformLocationWith4f(mColorLocation, color.r, color.g, color.b, 1);
glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_POSITION, 2, GL_FLOAT, GL_FALSE, 0, glVertices);
glDrawArrays(GL_LINE_LOOP, 0, vertexCount);
CC_INCREMENT_GL_DRAWS(1);
CHECK_GL_ERROR_DEBUG();
delete[] glVertices;
}
void GLESDebugDraw::DrawSolidCircle(const b2Vec2& center, float32 radius, const b2Vec2& axis, const b2Color& color)
{
mShaderProgram->use();
mShaderProgram->setUniformsForBuiltins();
const float32 k_segments = 16.0f;
int vertexCount=16;
const float32 k_increment = 2.0f * b2_pi / k_segments;
float32 theta = 0.0f;
GLfloat* glVertices = new GLfloat[vertexCount*2];
for (int i = 0; i < k_segments; ++i)
{
b2Vec2 v = center + radius * b2Vec2(cosf(theta), sinf(theta));
glVertices[i*2]=v.x * mRatio;
glVertices[i*2+1]=v.y * mRatio;
theta += k_increment;
}
mShaderProgram->setUniformLocationWith4f(mColorLocation, color.r*0.5f, color.g*0.5f, color.b*0.5f, 0.5f);
glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_POSITION, 2, GL_FLOAT, GL_FALSE, 0, glVertices);
glDrawArrays(GL_TRIANGLE_FAN, 0, vertexCount);
mShaderProgram->setUniformLocationWith4f(mColorLocation, color.r, color.g, color.b, 1);
glDrawArrays(GL_LINE_LOOP, 0, vertexCount);
// Draw the axis line
DrawSegment(center,center+radius*axis,color);
CC_INCREMENT_GL_DRAWS(2);
CHECK_GL_ERROR_DEBUG();
delete[] glVertices;
}
void GLESDebugDraw::DrawSegment(const b2Vec2& p1, const b2Vec2& p2, const b2Color& color)
{
mShaderProgram->use();
mShaderProgram->setUniformsForBuiltins();
mShaderProgram->setUniformLocationWith4f(mColorLocation, color.r, color.g, color.b, 1);
GLfloat glVertices[] =
{
p1.x * mRatio, p1.y * mRatio,
p2.x * mRatio, p2.y * mRatio
};
glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_POSITION, 2, GL_FLOAT, GL_FALSE, 0, glVertices);
glDrawArrays(GL_LINES, 0, 2);
CC_INCREMENT_GL_DRAWS(1);
CHECK_GL_ERROR_DEBUG();
}
void GLESDebugDraw::DrawTransform(const b2Transform& xf)
{
b2Vec2 p1 = xf.p, p2;
const float32 k_axisScale = 0.4f;
p2 = p1 + k_axisScale * xf.q.GetXAxis();
DrawSegment(p1, p2, b2Color(1,0,0));
p2 = p1 + k_axisScale * xf.q.GetYAxis();
DrawSegment(p1,p2,b2Color(0,1,0));
}
void GLESDebugDraw::DrawPoint(const b2Vec2& p, float32 size, const b2Color& color)
{
mShaderProgram->use();
mShaderProgram->setUniformsForBuiltins();
mShaderProgram->setUniformLocationWith4f(mColorLocation, color.r, color.g, color.b, 1);
// glPointSize(size);
GLfloat glVertices[] = {
p.x * mRatio, p.y * mRatio
};
glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_POSITION, 2, GL_FLOAT, GL_FALSE, 0, glVertices);
glDrawArrays(GL_POINTS, 0, 1);
// glPointSize(1.0f);
CC_INCREMENT_GL_DRAWS(1);
CHECK_GL_ERROR_DEBUG();
}
void GLESDebugDraw::DrawString(int x, int y, const char *string, ...)
{
// NSLog(@"DrawString: unsupported: %s", string);
//printf(string);
/* Unsupported as yet. Could replace with bitmap font renderer at a later date */
}
void GLESDebugDraw::DrawAABB(b2AABB* aabb, const b2Color& color)
{
mShaderProgram->use();
mShaderProgram->setUniformsForBuiltins();
mShaderProgram->setUniformLocationWith4f(mColorLocation, color.r, color.g, color.b, 1);
GLfloat glVertices[] = {
aabb->lowerBound.x * mRatio, aabb->lowerBound.y * mRatio,
aabb->upperBound.x * mRatio, aabb->lowerBound.y * mRatio,
aabb->upperBound.x * mRatio, aabb->upperBound.y * mRatio,
aabb->lowerBound.x * mRatio, aabb->upperBound.y * mRatio
};
glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_POSITION, 2, GL_FLOAT, GL_FALSE, 0, glVertices);
glDrawArrays(GL_LINE_LOOP, 0, 8);
CC_INCREMENT_GL_DRAWS(1);
CHECK_GL_ERROR_DEBUG();
}
}}} // namespace cocos2d { namespace extension { namespace armature {

67
extensions/CocoStudio/Armature/external_tool/GLES-Render.h
View File

@ -1,67 +0,0 @@
/*
* Copyright (c) 2006-2007 Erin Catto http://www.gphysics.com
*
* iPhone port by Simon Oliver - http://www.simonoliver.com - http://www.handcircus.com
*
* This software is provided 'as-is', without any express or implied
* warranty. In no event will the authors be held liable for any damages
* arising from the use of this software.
* Permission is granted to anyone to use this software for any purpose,
* including commercial applications, and to alter it and redistribute it
* freely, subject to the following restrictions:
* 1. The origin of this software must not be misrepresented; you must not
* claim that you wrote the original software. If you use this software
* in a product, an acknowledgment in the product documentation would be
* appreciated but is not required.
* 2. Altered source versions must be plainly marked as such, and must not be
* misrepresented as being the original software.
* 3. This notice may not be removed or altered from any source distribution.
*/
#ifndef CC_ARMATURE_GLES_RENDER_H
#define CC_ARMATURE_GLES_RENDER_H
#include "Box2D/Box2D.h"
#include "cocos2d.h"
#include "ExtensionMacros.h"
struct b2AABB;
namespace cocos2d { namespace extension { namespace armature {
// This class implements debug drawing callbacks that are invoked
// inside b2World::Step.
class GLESDebugDraw : public b2Draw
{
float32 mRatio;
cocos2d::GLProgram* mShaderProgram;
GLint mColorLocation;
void initShader( void );
public:
GLESDebugDraw();
GLESDebugDraw( float32 ratio );
virtual void DrawPolygon(const b2Vec2* vertices, int vertexCount, const b2Color& color);
virtual void DrawSolidPolygon(const b2Vec2* vertices, int vertexCount, const b2Color& color);
virtual void DrawCircle(const b2Vec2& center, float32 radius, const b2Color& color);
virtual void DrawSolidCircle(const b2Vec2& center, float32 radius, const b2Vec2& axis, const b2Color& color);
virtual void DrawSegment(const b2Vec2& p1, const b2Vec2& p2, const b2Color& color);
virtual void DrawTransform(const b2Transform& xf);
virtual void DrawPoint(const b2Vec2& p, float32 size, const b2Color& color);
virtual void DrawString(int x, int y, const char* string, ...);
virtual void DrawAABB(b2AABB* aabb, const b2Color& color);
};
}}} // namespace cocos2d { namespace extension { namespace armature {
#endif

604
extensions/CocoStudio/Armature/external_tool/sigslot.h
View File

File diff suppressed because it is too large Load Diff

386
extensions/CocoStudio/Armature/physics/CCColliderDetector.cpp
View File

@ -23,15 +23,51 @@ THE SOFTWARE.
****************************************************************************/ ****************************************************************************/
#include "CCColliderDetector.h" #include "CCColliderDetector.h"
#include "CCPhysicsWorld.h"
#include "../CCBone.h" #include "../CCBone.h"
#include "../utils/CCTransformHelp.h"
#if ENABLE_PHYSICS_BOX2D_DETECT
#include "Box2D/Box2D.h" #include "Box2D/Box2D.h"
#elif ENABLE_PHYSICS_CHIPMUNK_DETECT
#include "chipmunk.h"
#endif
namespace cocos2d { namespace extension { namespace armature {
ColliderDetector *ColliderDetector::create() NS_CC_EXT_ARMATURE_BEGIN
#if ENABLE_PHYSICS_BOX2D_DETECT
ColliderBody::ColliderBody(CCContourData *contourData)
: m_pFixture(NULL)
, m_pFilter(NULL)
, m_pContourData(contourData)
{ {
ColliderDetector *pColliderDetector = new ColliderDetector(); CC_SAFE_RETAIN(m_pContourData);
}
#elif ENABLE_PHYSICS_CHIPMUNK_DETECT
ColliderBody::ColliderBody(CCContourData *contourData)
: m_pShape(NULL)
, m_pContourData(contourData)
{
CC_SAFE_RETAIN(m_pContourData);
}
#endif
ColliderBody::~ColliderBody()
{
CC_SAFE_RELEASE(m_pContourData);
#if ENABLE_PHYSICS_BOX2D_DETECT
CC_SAFE_DELETE(m_pFilter);
#endif
}
CCColliderDetector *CCColliderDetector::create()
{
CCColliderDetector *pColliderDetector = new CCColliderDetector();
if (pColliderDetector && pColliderDetector->init()) if (pColliderDetector && pColliderDetector->init())
{ {
pColliderDetector->autorelease(); pColliderDetector->autorelease();
@ -41,9 +77,9 @@ ColliderDetector *ColliderDetector::create()
return NULL; return NULL;
} }
ColliderDetector *ColliderDetector::create(Bone *bone) CCColliderDetector *CCColliderDetector::create(CCBone *bone)
{ {
ColliderDetector *pColliderDetector = new ColliderDetector(); CCColliderDetector *pColliderDetector = new CCColliderDetector();
if (pColliderDetector && pColliderDetector->init(bone)) if (pColliderDetector && pColliderDetector->init(bone))
{ {
pColliderDetector->autorelease(); pColliderDetector->autorelease();
@ -53,37 +89,33 @@ ColliderDetector *ColliderDetector::create(Bone *bone)
return NULL; return NULL;
} }
ColliderDetector::ColliderDetector() CCColliderDetector::CCColliderDetector()
: _colliderBodyList(NULL) : m_pColliderBodyList(NULL)
, m_bActive(false)
{ {
#if ENABLE_PHYSICS_BOX2D_DETECT
m_pBody = NULL;
#elif ENABLE_PHYSICS_CHIPMUNK_DETECT
m_pBody = NULL;
#endif
} }
ColliderDetector::~ColliderDetector() CCColliderDetector::~CCColliderDetector()
{ {
Object *object = NULL; m_pColliderBodyList->removeAllObjects();
CCARRAY_FOREACH(_colliderBodyList, object) CC_SAFE_DELETE(m_pColliderBodyList);
{
ColliderBody *colliderBody = static_cast<ColliderBody *>(object);
b2Body *body = colliderBody->getB2Body();
PhysicsWorld::sharedPhysicsWorld()->getNoGravityWorld()->DestroyBody(body);
}
_colliderBodyList->removeAllObjects();
CC_SAFE_DELETE(_colliderBodyList);
} }
bool ColliderDetector::init() bool CCColliderDetector::init()
{ {
_colliderBodyList = Array::create(); m_pColliderBodyList = Array::create();
CCASSERT(_colliderBodyList, "create _colliderBodyList failed!"); CCAssert(m_pColliderBodyList, "create m_pColliderBodyList failed!");
_colliderBodyList->retain(); m_pColliderBodyList->retain();
return true; return true;
} }
bool ColliderDetector::init(Bone *bone) bool CCColliderDetector::init(CCBone *bone)
{ {
init(); init();
setBone(bone); setBone(bone);
@ -91,116 +123,278 @@ bool ColliderDetector::init(Bone *bone)
return true; return true;
} }
void ColliderDetector::addContourData(ContourData *contourData) void CCColliderDetector::addContourData(CCContourData *contourData)
{ {
const Array *array = contourData->vertexList; ColliderBody *colliderBody = new ColliderBody(contourData);
Object *object = NULL; m_pColliderBodyList->addObject(colliderBody);
b2Vec2 *b2bv = new b2Vec2[contourData->vertexList->count()];
int i = 0;
CCARRAY_FOREACH(array, object)
{
ContourVertex2F *v = static_cast<ContourVertex2F *>(object);
b2bv[i].Set(v->x / PT_RATIO, v->y / PT_RATIO);
i++;
}
b2PolygonShape polygon;
polygon.Set(b2bv, contourData->vertexList->count());
CC_SAFE_DELETE(b2bv);
b2FixtureDef fixtureDef;
fixtureDef.shape = &polygon;
fixtureDef.density = 10.0f;
fixtureDef.isSensor = true;
b2BodyDef bodyDef;
bodyDef.type = b2_dynamicBody;
bodyDef.position = b2Vec2(0.0f, 0.0f);
bodyDef.userData = _bone;
b2Body *body = PhysicsWorld::sharedPhysicsWorld()->getNoGravityWorld()->CreateBody(&bodyDef);
body->CreateFixture(&fixtureDef);
ColliderBody *colliderBody = new ColliderBody(body, contourData);
_colliderBodyList->addObject(colliderBody);
colliderBody->release(); colliderBody->release();
} }
void ColliderDetector::addContourDataList(Array *contourDataList) void CCColliderDetector::addContourDataList(Array *contourDataList)
{ {
Object *object = NULL; Object *object = NULL;
CCARRAY_FOREACH(contourDataList, object) CCARRAY_FOREACH(contourDataList, object)
{ {
addContourData(static_cast<ContourData *>(object)); addContourData((CCContourData *)object);
} }
} }
void ColliderDetector::removeContourData(ContourData *_contourData) void CCColliderDetector::removeContourData(CCContourData *contourData)
{ {
_colliderBodyList->removeObject(_contourData); Object *object = NULL;
CCARRAY_FOREACH(m_pColliderBodyList, object)
{
ColliderBody *body = (ColliderBody*)object;
if (body && body->getContourData() == contourData)
{
m_pColliderBodyList->removeObject(body);
}
}
} }
void ColliderDetector::removeAll() void CCColliderDetector::removeAll()
{ {
_colliderBodyList->removeAllObjects(); m_pColliderBodyList->removeAllObjects();
} }
void ColliderDetector::setColliderFilter(b2Filter &filter)
void CCColliderDetector::setActive(bool active)
{ {
Object *object = NULL; if (m_bActive == active)
CCARRAY_FOREACH(_colliderBodyList, object)
{ {
ColliderBody *colliderBody = static_cast<ColliderBody *>(object); return;
colliderBody->getB2Body()->GetFixtureList()->SetFilterData(filter);
} }
m_bActive = active;
#if ENABLE_PHYSICS_BOX2D_DETECT
if (m_pBody)
{
if (active)
{
setBody(m_pBody);
}
else
{
Object *object = NULL;
CCARRAY_FOREACH(m_pColliderBodyList, object)
{
ColliderBody *colliderBody = (ColliderBody *)object;
b2Fixture *fixture = colliderBody->getB2Fixture();
b2Filter *filter = colliderBody->getB2Filter();
*filter = fixture->GetFilterData();
m_pBody->DestroyFixture(fixture);
colliderBody->setB2Fixture(NULL);
}
}
}
#elif ENABLE_PHYSICS_CHIPMUNK_DETECT
if (m_pBody)
{
Object *object = NULL;
if (m_bActive)
{
CCARRAY_FOREACH(m_pColliderBodyList, object)
{
ColliderBody *colliderBody = (ColliderBody *)object;
cpShape *shape = colliderBody->getShape();
cpSpaceAddShape(m_pBody->space_private, shape);
}
}
else
{
CCARRAY_FOREACH(m_pColliderBodyList, object)
{
ColliderBody *colliderBody = (ColliderBody *)object;
cpShape *shape = colliderBody->getShape();
cpSpaceRemoveShape(m_pBody->space_private, shape);
}
}
}
#endif
} }
void ColliderDetector::setActive(bool active) bool CCColliderDetector::getActive()
{ {
Object *object = NULL; return m_bActive;
CCARRAY_FOREACH(_colliderBodyList, object)
{
ColliderBody *colliderBody = static_cast<ColliderBody *>(object);
colliderBody->getB2Body()->SetActive(active);
}
} }
Array *CCColliderDetector::getColliderBodyList()
{
return m_pColliderBodyList;
}
Point helpPoint; Point helpPoint;
void ColliderDetector::updateTransform(AffineTransform &t) void CCColliderDetector::updateTransform(AffineTransform &t)
{ {
Object *object = NULL; if (!m_bActive)
CCARRAY_FOREACH(_colliderBodyList, object)
{ {
ColliderBody *colliderBody = static_cast<ColliderBody *>(object); return;
}
ContourData *contourData = colliderBody->getContourData(); Object *object = NULL;
b2Body *body = colliderBody->getB2Body(); CCARRAY_FOREACH(m_pColliderBodyList, object)
{
ColliderBody *colliderBody = (ColliderBody *)object;
CCContourData *contourData = colliderBody->getContourData();
b2PolygonShape *shape = (b2PolygonShape *)body->GetFixtureList()->GetShape(); #if ENABLE_PHYSICS_BOX2D_DETECT
b2PolygonShape *shape = NULL;
if (m_pBody != NULL)
{
shape = (b2PolygonShape *)colliderBody->getB2Fixture()->GetShape();
}
#elif ENABLE_PHYSICS_CHIPMUNK_DETECT
cpPolyShape *shape = NULL;
if (m_pBody != NULL)
{
shape = (cpPolyShape *)colliderBody->getShape();
}
#endif
//! update every vertex int num = contourData->vertexList.count();
const Array *array = contourData->vertexList; CCContourVertex2 **vs = (CCContourVertex2 **)contourData->vertexList.data->arr;
for (int i = 0; i < num; i++)
{
helpPoint.setPoint( vs[i]->x, vs[i]->y);
helpPoint = PointApplyAffineTransform(helpPoint, t);
#if ENABLE_PHYSICS_BOX2D_DETECT
if (shape != NULL)
{
b2Vec2 &bv = shape->m_vertices[i];
bv.Set(helpPoint.x / PT_RATIO, helpPoint.y / PT_RATIO);
}
#elif ENABLE_PHYSICS_CHIPMUNK_DETECT
if (shape != NULL)
{
cpVect v ;
v.x = helpPoint.x;
v.y = helpPoint.y;
shape->verts[i] = v;
}
#endif
}
#if ENABLE_PHYSICS_CHIPMUNK_DETECT
cpConvexHull(num, shape->verts, NULL, NULL, 0);
for (int i = 0; i < num; i++)
{
cpVect b = shape->verts[(i + 1) % shape->numVerts];
cpVect n = cpvnormalize(cpvperp(cpvsub(b, shape->verts[i])));
shape->planes[i].n = n;
shape->planes[i].d = cpvdot(n, shape->verts[i]);
}
#endif
}
}
#if ENABLE_PHYSICS_BOX2D_DETECT
void CCColliderDetector::setBody(b2Body *pBody)
{
m_pBody = pBody;
Object *object = NULL;
CCARRAY_FOREACH(m_pColliderBodyList, object)
{
ColliderBody *colliderBody = (ColliderBody *)object;
CCContourData *contourData = colliderBody->getContourData();
const Array *array = &contourData->vertexList;
Object *object = NULL; Object *object = NULL;
b2Vec2 *b2bv = new b2Vec2[contourData->vertexList.count()];
int i = 0; int i = 0;
CCARRAY_FOREACH(array, object) CCARRAY_FOREACH(array, object)
{ {
ContourVertex2F *cv = static_cast<ContourVertex2F *>(object); CCContourVertex2 *v = (CCContourVertex2 *)object;
b2Vec2 &bv = shape->m_vertices[i]; b2bv[i].Set(v->x / PT_RATIO, v->y / PT_RATIO);
helpPoint.setPoint(cv->x, cv->y);
helpPoint = PointApplyAffineTransform(helpPoint, t);
bv.Set(helpPoint.x / PT_RATIO, helpPoint.y / PT_RATIO);
i++; i++;
} }
b2PolygonShape polygon;
polygon.Set(b2bv, contourData->vertexList.count());
CC_SAFE_DELETE(b2bv);
b2FixtureDef fixtureDef;
fixtureDef.shape = &polygon;
fixtureDef.isSensor = true;
b2Fixture *fixture = m_pBody->CreateFixture(&fixtureDef);
fixture->SetUserData(m_pBone);
if (colliderBody->getB2Fixture() != NULL)
{
m_pBody->DestroyFixture(colliderBody->getB2Fixture());
}
colliderBody->setB2Fixture(fixture);
if (colliderBody->getB2Filter() == NULL)
{
b2Filter *filter = new b2Filter;
colliderBody->setB2Filter(filter);
}
else
{
fixture->SetFilterData(*colliderBody->getB2Filter());
}
} }
} }
b2Body *CCColliderDetector::getBody()
{
return m_pBody;
}
#elif ENABLE_PHYSICS_CHIPMUNK_DETECT
void CCColliderDetector::setBody(cpBody *pBody)
{
m_pBody = pBody;
Object *object = NULL;
CCARRAY_FOREACH(m_pColliderBodyList, object)
{
ColliderBody *colliderBody = (ColliderBody *)object;
CCContourData *contourData = colliderBody->getContourData();
int num = contourData->vertexList.count();
CCContourVertex2 **vs = (CCContourVertex2 **)contourData->vertexList.data->arr;
cpVect *verts = new cpVect[num];
for (int i = 0; i < num; i++)
{
verts[num - 1 - i].x = vs[i]->x;
verts[num - 1 - i].y = vs[i]->y;
}
cpShape *shape = cpPolyShapeNew(m_pBody, num, verts, cpvzero);
shape->sensor = true;
shape->data = m_pBone;
cpSpaceAddShape(m_pBody->space_private, shape);
colliderBody->setShape(shape);
delete []verts;
}
}
cpBody *CCColliderDetector::getBody()
{
return m_pBody;
}
#endif
}}} // namespace cocos2d { namespace extension { namespace armature { NS_CC_EXT_ARMATURE_END

111
extensions/CocoStudio/Armature/physics/CCColliderDetector.h
View File

@ -28,88 +28,87 @@ THE SOFTWARE.
#include "../utils/CCArmatureDefine.h" #include "../utils/CCArmatureDefine.h"
#include "../datas/CCDatas.h" #include "../datas/CCDatas.h"
#ifndef PT_RATIO
#define PT_RATIO 32
#endif
class b2Body; class b2Body;
class b2Fixture;
struct b2Filter; struct b2Filter;
namespace cocos2d { namespace extension { namespace armature { struct cpBody;
struct cpShape;
class Bone; NS_CC_EXT_ARMATURE_BEGIN
class CCBone;
class ColliderBody : public Object class ColliderBody : public Object
{ {
public: public:
ColliderBody(b2Body *b2b, ContourData *contourData) #if ENABLE_PHYSICS_BOX2D_DETECT
:_pB2b(NULL) CC_SYNTHESIZE(b2Fixture *, m_pFixture, B2Fixture)
,_contourData(NULL) CC_SYNTHESIZE(b2Filter *, m_pFilter, B2Filter)
{
this->_pB2b = b2b;
this->_contourData = contourData;
CC_SAFE_RETAIN(_contourData);
}
/**
* @js NA
* @lua NA
*/
~ColliderBody()
{
CC_SAFE_RELEASE(_contourData);
}
inline b2Body *getB2Body() #elif ENABLE_PHYSICS_CHIPMUNK_DETECT
{ CC_SYNTHESIZE(cpShape *, m_pShape, Shape)
return _pB2b; #endif
}
inline ContourData *getContourData() public:
{ ColliderBody(CCContourData *contourData);
return _contourData; ~ColliderBody();
}
inline CCContourData *getContourData()
{
return m_pContourData;
}
private: private:
b2Body *_pB2b; CCContourData *m_pContourData;
ContourData *_contourData;
}; };
/* /*
* @brief ContourSprite used to draw the contour of the display * @brief ContourSprite used to draw the contour of the display
*/ */
class ColliderDetector : public Object class CCColliderDetector : public Object
{ {
public: public:
static ColliderDetector *create(); static CCColliderDetector *create();
static ColliderDetector *create(Bone *bone); static CCColliderDetector *create(CCBone *bone);
public: public:
/** CCColliderDetector();
* @js ctor ~CCColliderDetector(void);
*/
ColliderDetector();
/**
* @js NA
* @lua NA
*/
~ColliderDetector(void);
virtual bool init(); virtual bool init();
virtual bool init(Bone *bone); virtual bool init(CCBone *bone);
void addContourData(ContourData *contourData); void addContourData(CCContourData *contourData);
void addContourDataList(Array *contourDataList); void addContourDataList(Array *contourDataList);
void removeContourData(ContourData *contourData); void removeContourData(CCContourData *contourData);
void removeAll(); void removeAll();
void updateTransform(AffineTransform &t); void updateTransform(AffineTransform &t);
void setColliderFilter(b2Filter &filter);
void setActive(bool active); void setActive(bool active);
private: bool getActive();
Array *_colliderBodyList;
CC_SYNTHESIZE(Bone*, _bone, Bone);
Array *getColliderBodyList();
protected:
Array *m_pColliderBodyList;
CC_SYNTHESIZE(CCBone *, m_pBone, Bone);
#if ENABLE_PHYSICS_BOX2D_DETECT
CC_PROPERTY(b2Body *, m_pBody, Body);
#elif ENABLE_PHYSICS_CHIPMUNK_DETECT
CC_PROPERTY(cpBody *, m_pBody, Body);
#endif
protected:
bool m_bActive;
}; };
}}} // namespace cocos2d { namespace extension { namespace armature { NS_CC_EXT_ARMATURE_END
#endif /*__CCCOLLIDERDETECTOR_H__*/ #endif /*__CCCOLLIDERDETECTOR_H__*/

165
extensions/CocoStudio/Armature/physics/CCPhysicsWorld.cpp
View File

@ -1,165 +0,0 @@
/****************************************************************************
Copyright (c) 2013 cocos2d-x.org
http://www.cocos2d-x.org
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.
****************************************************************************/
#include "CCPhysicsWorld.h"
#include "../utils/CCArmatureDefine.h"
#include "Box2D/Box2D.h"
#include "../external_tool/GLES-Render.h"
namespace cocos2d { namespace extension { namespace armature {
class Contact
{
public:
b2Fixture *fixtureA;
b2Fixture *fixtureB;
};
class ContactListener : public b2ContactListener
{
//! Callbacks for derived classes.
virtual void BeginContact(b2Contact *contact) override
{
if (contact)
{
Contact c;
c.fixtureA = contact->GetFixtureA();
c.fixtureB = contact->GetFixtureB();
contact_list.push_back(c);
}
B2_NOT_USED(contact);
}
virtual void EndContact(b2Contact *contact) override
{
contact_list.clear();
B2_NOT_USED(contact);
}
virtual void PreSolve(b2Contact *contact, const b2Manifold *oldManifold) override
{
B2_NOT_USED(contact);
B2_NOT_USED(oldManifold);
}
virtual void PostSolve(b2Contact *contact, const b2ContactImpulse *impulse) override
{
B2_NOT_USED(contact);
B2_NOT_USED(impulse);
}
public:
std::list<Contact> contact_list;
};
PhysicsWorld *PhysicsWorld::s_PhysicsWorld = NULL;
PhysicsWorld *PhysicsWorld::sharedPhysicsWorld()
{
if (s_PhysicsWorld == NULL)
{
s_PhysicsWorld = new PhysicsWorld();
s_PhysicsWorld->initNoGravityWorld();
}
return s_PhysicsWorld;
}
void PhysicsWorld::purgePhysicsWorld()
{
delete s_PhysicsWorld;
s_PhysicsWorld = NULL;
}
PhysicsWorld::PhysicsWorld()
: _noGravityWorld(NULL)
, _debugDraw(NULL)
{
}
PhysicsWorld::~PhysicsWorld()
{
CC_SAFE_DELETE(_debugDraw);
CC_SAFE_DELETE(_noGravityWorld);
CC_SAFE_DELETE(_contactListener);
}
void PhysicsWorld::initNoGravityWorld()
{
b2Vec2 noGravity(0, 0);
_noGravityWorld = new b2World(noGravity);
_noGravityWorld->SetAllowSleeping(true);
_contactListener = new ContactListener();
_noGravityWorld->SetContactListener(_contactListener);
#if ENABLE_PHYSICS_DEBUG
_debugDraw = new GLESDebugDraw( PT_RATIO );
_noGravityWorld->SetDebugDraw(_debugDraw);
uint32 flags = 0;
flags += b2Draw::e_shapeBit;
// flags += b2Draw::e_jointBit;
// flags += b2Draw::e_aabbBit;
// flags += b2Draw::e_pairBit;
// flags += b2Draw::e_centerOfMassBit;
_debugDraw->SetFlags(flags);
#endif
}
b2World *PhysicsWorld::getNoGravityWorld()
{
return _noGravityWorld;
}
void PhysicsWorld::update(float dt)
{
_noGravityWorld->Step(dt, 0, 0);
for (std::list<Contact>::iterator it = _contactListener->contact_list.begin(); it != _contactListener->contact_list.end(); ++it)
{
Contact &contact = *it;
b2Body *b2a = contact.fixtureA->GetBody();
b2Body *b2b = contact.fixtureB->GetBody();
Bone *ba = (Bone *)b2a->GetUserData();
Bone *bb = (Bone *)b2b->GetUserData();
BoneColliderSignal.emit(ba, bb);
}
}
void PhysicsWorld::drawDebug()
{
_noGravityWorld->DrawDebugData();
}
}}} // namespace cocos2d { namespace extension { namespace armature {

87
extensions/CocoStudio/Armature/physics/CCPhysicsWorld.h
View File

@ -1,87 +0,0 @@
/****************************************************************************
Copyright (c) 2013 cocos2d-x.org
http://www.cocos2d-x.org
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 __CCPHYSICSWORLD_H__
#define __CCPHYSICSWORLD_H__
#include "../utils/CCArmatureDefine.h"
#include "../CCBone.h"
#include "../external_tool/sigslot.h"
#include <list>
using std::list;
#ifndef PT_RATIO
#define PT_RATIO 32
#endif
struct b2Manifold;
struct b2ContactImpulse;
class b2Fixture;
class b2Contact;
class b2World;
namespace cocos2d { namespace extension { namespace armature {
class ContactListener;
class GLESDebugDraw;
class PhysicsWorld
{
public:
static PhysicsWorld *sharedPhysicsWorld();
static void purgePhysicsWorld();
void initNoGravityWorld();
private:
/**
* @js ctor
*/
PhysicsWorld();
/**
* @js NA
* @lua NA
*/
~PhysicsWorld();
private:
static PhysicsWorld *s_PhysicsWorld;
b2World *_noGravityWorld;
ContactListener *_contactListener;
GLESDebugDraw *_debugDraw;
public:
void update(float dt);
void drawDebug();
b2World *getNoGravityWorld();
sigslot::signal2<Bone *, Bone *> BoneColliderSignal;
};
}}} // namespace cocos2d { namespace extension { namespace armature {
#endif/*__CCPHYSICSWORLD_H__*/

212
extensions/CocoStudio/Armature/utils/CCArmatureDataManager.cpp
View File

@ -27,18 +27,17 @@ THE SOFTWARE.
#include "CCTransformHelp.h" #include "CCTransformHelp.h"
#include "CCDataReaderHelper.h" #include "CCDataReaderHelper.h"
#include "CCSpriteFrameCacheHelper.h" #include "CCSpriteFrameCacheHelper.h"
#include "../physics/CCPhysicsWorld.h"
namespace cocos2d { namespace extension { namespace armature { NS_CC_EXT_ARMATURE_BEGIN
static ArmatureDataManager *s_sharedArmatureDataManager = NULL; static CCArmatureDataManager *s_sharedArmatureDataManager = NULL;
ArmatureDataManager *ArmatureDataManager::sharedArmatureDataManager() CCArmatureDataManager *CCArmatureDataManager::sharedArmatureDataManager()
{ {
if (s_sharedArmatureDataManager == NULL) if (s_sharedArmatureDataManager == NULL)
{ {
s_sharedArmatureDataManager = new ArmatureDataManager(); s_sharedArmatureDataManager = new CCArmatureDataManager();
if (!s_sharedArmatureDataManager || !s_sharedArmatureDataManager->init()) if (!s_sharedArmatureDataManager || !s_sharedArmatureDataManager->init())
{ {
CC_SAFE_DELETE(s_sharedArmatureDataManager); CC_SAFE_DELETE(s_sharedArmatureDataManager);
@ -47,49 +46,48 @@ ArmatureDataManager *ArmatureDataManager::sharedArmatureDataManager()
return s_sharedArmatureDataManager; return s_sharedArmatureDataManager;
} }
ArmatureDataManager::ArmatureDataManager(void) void CCArmatureDataManager::purge()
{ {
_armarureDatas = NULL; CCSpriteFrameCacheHelper::purge();
_animationDatas = NULL; CCDataReaderHelper::purge();
_textureDatas = NULL;
}
ArmatureDataManager::~ArmatureDataManager(void)
{
CCLOGINFO("deallocing ArmatureDataManager: %p", this);
removeAll();
CC_SAFE_RELEASE(_animationDatas);
CC_SAFE_RELEASE(_armarureDatas);
CC_SAFE_RELEASE(_textureDatas);
}
void ArmatureDataManager::purgeArmatureSystem()
{
SpriteFrameCacheHelper::purgeSpriteFrameCacheHelper();
PhysicsWorld::purgePhysicsWorld();
CC_SAFE_RELEASE_NULL(s_sharedArmatureDataManager); CC_SAFE_RELEASE_NULL(s_sharedArmatureDataManager);
} }
bool ArmatureDataManager::init() CCArmatureDataManager::CCArmatureDataManager(void)
{
m_pArmarureDatas = NULL;
m_pAnimationDatas = NULL;
m_pTextureDatas = NULL;
m_bAutoLoadSpriteFile = false;
}
CCArmatureDataManager::~CCArmatureDataManager(void)
{
removeAll();
CC_SAFE_DELETE(m_pAnimationDatas);
CC_SAFE_DELETE(m_pArmarureDatas);
CC_SAFE_DELETE(m_pTextureDatas);
}
bool CCArmatureDataManager::init()
{ {
bool bRet = false; bool bRet = false;
do do
{ {
_armarureDatas = new Dictionary; m_pArmarureDatas = Dictionary::create();
CCASSERT(_armarureDatas, "create ArmatureDataManager::_armarureDatas fail!"); CCAssert(m_pArmarureDatas, "create CCArmatureDataManager::m_pArmarureDatas fail!");
_armarureDatas->init(); m_pArmarureDatas->retain();
_animationDatas = new Dictionary; m_pAnimationDatas = Dictionary::create();
CCASSERT(_animationDatas, "create ArmatureDataManager::_animationDatas fail!"); CCAssert(m_pAnimationDatas, "create CCArmatureDataManager::m_pAnimationDatas fail!");
_animationDatas->init(); m_pAnimationDatas->retain();
_textureDatas = new Dictionary; m_pTextureDatas = Dictionary::create();
CCASSERT(_textureDatas, "create ArmatureDataManager::_textureDatas fail!"); CCAssert(m_pTextureDatas, "create CCArmatureDataManager::m_pTextureDatas fail!");
_textureDatas->init(); m_pTextureDatas->retain();
bRet = true; bRet = true;
} }
@ -98,105 +96,153 @@ bool ArmatureDataManager::init()
return bRet; return bRet;
} }
void ArmatureDataManager::addArmatureData(const char *id, ArmatureData *armatureData) void CCArmatureDataManager::addArmatureData(const char *id, CCArmatureData *armatureData)
{ {
if(_armarureDatas) if(m_pArmarureDatas)
{ {
_armarureDatas->setObject(armatureData, id); m_pArmarureDatas->setObject(armatureData, id);
} }
} }
ArmatureData *ArmatureDataManager::getArmatureData(const char *id) CCArmatureData *CCArmatureDataManager::getArmatureData(const char *id)
{ {
ArmatureData *armatureData = NULL; CCArmatureData *armatureData = NULL;
if (_armarureDatas) if (m_pArmarureDatas)
{ {
armatureData = (ArmatureData *)_armarureDatas->objectForKey(id); armatureData = (CCArmatureData *)m_pArmarureDatas->objectForKey(id);
} }
return armatureData; return armatureData;
} }
void ArmatureDataManager::addAnimationData(const char *id, AnimationData *animationData) void CCArmatureDataManager::removeArmatureData(const char *id)
{ {
if(_animationDatas) if (m_pArmarureDatas)
{ {
_animationDatas->setObject(animationData, id); m_pArmarureDatas->removeObjectForKey(id);
} }
} }
void ArmatureDataManager::addTextureData(const char *id, TextureData *textureData) void CCArmatureDataManager::addAnimationData(const char *id, CCAnimationData *animationData)
{ {
if(_textureDatas) if(m_pAnimationDatas)
{ {
_textureDatas->setObject(textureData, id); m_pAnimationDatas->setObject(animationData, id);
} }
} }
AnimationData *ArmatureDataManager::getAnimationData(const char *id) CCAnimationData *CCArmatureDataManager::getAnimationData(const char *id)
{ {
AnimationData *animationData = NULL; CCAnimationData *animationData = NULL;
if (_animationDatas) if (m_pAnimationDatas)
{ {
animationData = (AnimationData *)_animationDatas->objectForKey(id); animationData = (CCAnimationData *)m_pAnimationDatas->objectForKey(id);
} }
return animationData; return animationData;
} }
TextureData *ArmatureDataManager::getTextureData(const char *id) void CCArmatureDataManager::removeAnimationData(const char *id)
{ {
TextureData *textureData = NULL; if (m_pAnimationDatas)
if (_textureDatas)
{ {
textureData = (TextureData *)_textureDatas->objectForKey(id); m_pAnimationDatas->removeObjectForKey(id);
}
}
void CCArmatureDataManager::addTextureData(const char *id, CCTextureData *textureData)
{
if(m_pTextureDatas)
{
m_pTextureDatas->setObject(textureData, id);
}
}
CCTextureData *CCArmatureDataManager::getTextureData(const char *id)
{
CCTextureData *textureData = NULL;
if (m_pTextureDatas)
{
textureData = (CCTextureData *)m_pTextureDatas->objectForKey(id);
} }
return textureData; return textureData;
} }
void CCArmatureDataManager::removeTextureData(const char *id)
void ArmatureDataManager::addArmatureFileInfo(const char *armatureName, const char *useExistFileInfo, const char *imagePath, const char *plistPath, const char *configFilePath)
{ {
addArmatureFileInfo(imagePath, plistPath, configFilePath); if(m_pTextureDatas)
{
m_pTextureDatas->removeObjectForKey(id);
}
} }
void ArmatureDataManager::addArmatureFileInfo(const char *imagePath, const char *plistPath, const char *configFilePath) void CCArmatureDataManager::addArmatureFileInfo(const char *configFilePath)
{ {
m_bAutoLoadSpriteFile = true;
CCDataReaderHelper::sharedDataReaderHelper()->addDataFromFile(configFilePath);
}
DataReaderHelper::addDataFromFile(configFilePath); void CCArmatureDataManager::addArmatureFileInfoAsync(const char *configFilePath, Object *target, SEL_SCHEDULE selector)
{
m_bAutoLoadSpriteFile = true;
CCDataReaderHelper::sharedDataReaderHelper()->addDataFromFileAsync(configFilePath, target, selector);
}
void CCArmatureDataManager::addArmatureFileInfo(const char *imagePath, const char *plistPath, const char *configFilePath)
{
m_bAutoLoadSpriteFile = false;
CCDataReaderHelper::sharedDataReaderHelper()->addDataFromFile(configFilePath);
addSpriteFrameFromFile(plistPath, imagePath); addSpriteFrameFromFile(plistPath, imagePath);
} }
void ArmatureDataManager::addSpriteFrameFromFile(const char *plistPath, const char *imagePath) void CCArmatureDataManager::addArmatureFileInfoAsync(const char *imagePath, const char *plistPath, const char *configFilePath, Object *target, SEL_SCHEDULE selector)
{ {
// if(Game::sharedGame()->isUsePackage()) m_bAutoLoadSpriteFile = false;
// { CCDataReaderHelper::sharedDataReaderHelper()->addDataFromFileAsync(configFilePath, target, selector);
// SpriteFrameCacheHelper::sharedSpriteFrameCacheHelper()->addSpriteFrameFromPak(plistPath, imagePath); addSpriteFrameFromFile(plistPath, imagePath);
// } }
// else
// { void CCArmatureDataManager::addSpriteFrameFromFile(const char *plistPath, const char *imagePath)
// SpriteFrameCacheHelper::sharedSpriteFrameCacheHelper()->addSpriteFrameFromFile(plistPath, imagePath); {
// } CCSpriteFrameCacheHelper::sharedSpriteFrameCacheHelper()->addSpriteFrameFromFile(plistPath, imagePath);
SpriteFrameCacheHelper::sharedSpriteFrameCacheHelper()->addSpriteFrameFromFile(plistPath, imagePath);
} }
void ArmatureDataManager::removeAll() void CCArmatureDataManager::removeAll()
{ {
if( _animationDatas ) if( m_pAnimationDatas )
{ {
_animationDatas->removeAllObjects(); m_pAnimationDatas->removeAllObjects();
} }
if( _armarureDatas ) if( m_pArmarureDatas )
{ {
_armarureDatas->removeAllObjects(); m_pArmarureDatas->removeAllObjects();
} }
if( _textureDatas ) if( m_pTextureDatas )
{ {
_textureDatas->removeAllObjects(); m_pTextureDatas->removeAllObjects();
} }
DataReaderHelper::clear(); CCDataReaderHelper::clear();
} }
}}} // namespace cocos2d { namespace extension { namespace armature { bool CCArmatureDataManager::isAutoLoadSpriteFile()
{
return m_bAutoLoadSpriteFile;
}
Dictionary *CCArmatureDataManager::getArmatureDatas() const
{
return m_pArmarureDatas;
}
Dictionary *CCArmatureDataManager::getAnimationDatas() const
{
return m_pAnimationDatas;
}
Dictionary *CCArmatureDataManager::getTextureDatas() const
{
return m_pTextureDatas;
}
NS_CC_EXT_ARMATURE_END

188
extensions/CocoStudio/Armature/utils/CCArmatureDataManager.h
View File

@ -26,131 +26,159 @@ THE SOFTWARE.
#define __CCARMATUREDATAMANAGER_H__ #define __CCARMATUREDATAMANAGER_H__
#include "CCArmatureDefine.h" #include "CCArmatureDefine.h"
#include "CCConstValue.h"
#include "../datas/CCDatas.h" #include "../datas/CCDatas.h"
namespace cocos2d { namespace extension { namespace armature { NS_CC_EXT_ARMATURE_BEGIN
/** /**
* @brief format and manage armature configuration and armature animation * @brief format and manage armature configuration and armature animation
*/ */
class ArmatureDataManager : public Object class CCArmatureDataManager : public Object
{ {
public: public:
static ArmatureDataManager *sharedArmatureDataManager(); static CCArmatureDataManager *sharedArmatureDataManager();
static void purgeArmatureSystem();
static void purge();
private: private:
/** CCArmatureDataManager(void);
* @js ctor ~CCArmatureDataManager(void);
*/
ArmatureDataManager(void);
/**
* @js NA
* @lua NA
*/
~ArmatureDataManager(void);
public: public:
/** /**
* Init ArmatureDataManager * Init CCArmatureDataManager
*/ */
virtual bool init(); virtual bool init();
/**
* @brief Add armature data.
*
* @param id The id of the armature data.
* @param armatureData The armature data to be added.
*/
void addArmatureData(const char *id, ArmatureData *armatureData);
/**
* @brief Get armature data.
*
* @param id The id of the armature data you want to get.
*
* @return The ArmatureData whose id is @p id.
*/
ArmatureData *getArmatureData(const char *id);
/** /**
* @brief Add animation data. * Add armature data
* * @param id The id of the armature data
* @param id The id of the animation data. * @param armatureData CCArmatureData *
* @param animationData The animation data to be added.
*/ */
void addAnimationData(const char *id, AnimationData *animationData); void addArmatureData(const char *id, CCArmatureData *armatureData);
/**
* @brief Get animation data.
*
* @param id The id of the animation data you want to get.
*
* @return The AnimationData whose id is @p id.
*/
AnimationData *getAnimationData(const char *id);
/** /**
* @brief Add texture data. * @brief get armature data
* * @param id the id of the armature data you want to get
* @param id The id of the texture data. * @return CCArmatureData *
* @param textureData The texture data to be added.
*/ */
void addTextureData(const char *id, TextureData *textureData); CCArmatureData *getArmatureData(const char *id);
/**
* @brief Get texture data.
*
* @param id The id of the texture data you want to get.
*
* @return The TextureData whose id is @p id.
*/
TextureData *getTextureData(const char *id);
/**
* @brief Add ArmatureFileInfo, it is managed by ArmatureDataManager.
*/
void addArmatureFileInfo(const char *armatureName, const char *useExistFileInfo, const char *imagePath, const char *plistPath, const char *configFilePath);
/** /**
* @brief Add ArmatureFileInfo, it is managed by ArmatureDataManager. * @brief remove armature data
* @param id the id of the armature data you want to get
*/
void removeArmatureData(const char *id);
/**
* @brief add animation data
* @param id the id of the animation data
* @return CCAnimationData *
*/
void addAnimationData(const char *id, CCAnimationData *animationData);
/**
* @brief get animation data from m_pAnimationDatas(Dictionary)
* @param id the id of the animation data you want to get
* @return CCAnimationData *
*/
CCAnimationData *getAnimationData(const char *id);
/**
* @brief remove animation data
* @param id the id of the animation data
*/
void removeAnimationData(const char *id);
/**
* @brief add texture data
* @param id the id of the texture data
* @return CCTextureData *
*/
void addTextureData(const char *id, CCTextureData *textureData);
/**
* @brief get texture data
* @param id the id of the texture data you want to get
* @return CCTextureData *
*/
CCTextureData *getTextureData(const char *id);
/**
* @brief remove texture data
* @param id the id of the texture data you want to get
*/
void removeTextureData(const char *id);
/**
* @brief Add ArmatureFileInfo, it is managed by CCArmatureDataManager.
*/
void addArmatureFileInfo(const char *configFilePath);
/**
* @brief Add ArmatureFileInfo, it is managed by CCArmatureDataManager.
* It will load data in a new thread
*/
void addArmatureFileInfoAsync(const char *configFilePath, Object *target, SEL_SCHEDULE selector);
/**
* @brief Add ArmatureFileInfo, it is managed by CCArmatureDataManager.
*/ */
void addArmatureFileInfo(const char *imagePath, const char *plistPath, const char *configFilePath); void addArmatureFileInfo(const char *imagePath, const char *plistPath, const char *configFilePath);
/** /**
* @brief Add sprite frame to SpriteFrameCache, it will save display name and it's relative image name * @brief Add ArmatureFileInfo, it is managed by CCArmatureDataManager.
* It will load data in a new thread
*/
void addArmatureFileInfoAsync(const char *imagePath, const char *plistPath, const char *configFilePath, Object *target, SEL_SCHEDULE selector);
/**
* @brief Add sprite frame to CCSpriteFrameCache, it will save display name and it's relative image name
*/ */
void addSpriteFrameFromFile(const char *plistPath, const char *imagePath); void addSpriteFrameFromFile(const char *plistPath, const char *imagePath);
/** /**
* @brief Clear the data in the _armarureDatas and _animationDatas, and set _armarureDatas and _animationDatas to NULL * @brief Clear the data in the m_pArmarureDatas and m_pAnimationDatas, and set m_pArmarureDatas and m_pAnimationDatas to NULL
*/ */
void removeAll(); void removeAll();
/**
* @brief Juge whether or not need auto load sprite file
*/
bool isAutoLoadSpriteFile();
Dictionary *getArmatureDatas() const;
Dictionary *getAnimationDatas() const;
Dictionary *getTextureDatas() const;
private: private:
/** /**
* Dictionary to save amature data. * @brief save amature datas
* Key type is std::string, value type is ArmatureData *. * @key std::string
* @value CCArmatureData *
*/ */
CC_SYNTHESIZE_READONLY(Dictionary *, _armarureDatas, ArmarureDatas); Dictionary *m_pArmarureDatas;
/** /**
* Dictionary to save animation data. * @brief save animation datas
* Key type is std::string, value type is AnimationData *. * @key std::string
* @value CCAnimationData *
*/ */
CC_SYNTHESIZE_READONLY(Dictionary *, _animationDatas, AnimationDatas); Dictionary *m_pAnimationDatas;
/** /**
* Dictionary to save texture data. * @brief save texture datas
* Key type is std::string, value type is TextureData *. * @key std::string
* @value CCTextureData *
*/ */
CC_SYNTHESIZE_READONLY(Dictionary *, _textureDatas, TextureDatas); Dictionary *m_pTextureDatas;
bool m_bAutoLoadSpriteFile;
}; };
}}} // namespace cocos2d { namespace extension { namespace armature { NS_CC_EXT_ARMATURE_END
#endif/*__CCARMATUREDATAMANAGER_H__*/ #endif/*__CCARMATUREDATAMANAGER_H__*/

11
extensions/CocoStudio/Armature/utils/CCConstValue.h → extensions/CocoStudio/Armature/utils/CCArmatureDefine.cpp
View File

@ -22,8 +22,13 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE. THE SOFTWARE.
****************************************************************************/ ****************************************************************************/
#ifndef __CCCONSTVALUE_H__ #include "CCArmatureDefine.h"
#define __CCCONSTVALUE_H__
NS_CC_EXT_ARMATURE_BEGIN
#endif /*__CCCONSTVALUE_H__*/ const char *armatureVersion()
{
return "0.4.0.0";
}
NS_CC_EXT_ARMATURE_END

32
extensions/CocoStudio/Armature/utils/CCArmatureDefine.h
View File

@ -25,27 +25,37 @@ THE SOFTWARE.
#ifndef __CCARMATUREDEFINE_H__ #ifndef __CCARMATUREDEFINE_H__
#define __CCARMATUREDEFINE_H__ #define __CCARMATUREDEFINE_H__
//#define _USRDLL 1
#include "cocos2d.h" #include "cocos2d.h"
#include "ExtensionMacros.h" #include "ExtensionMacros.h"
#define VERSION_COMBINED 0.30f
#ifndef ENABLE_PHYSICS_DEBUG
#define ENABLE_PHYSICS_DEBUG 1 #ifndef AUTO_ADD_SPRITE_FRAME_NAME_PREFIX
#define AUTO_ADD_SPRITE_FRAME_NAME_PREFIX 0
#endif // !AUTO_ADD_SPRITE_FRAME_NAME_PREFIX
#ifndef ENABLE_PHYSICS_BOX2D_DETECT
#define ENABLE_PHYSICS_BOX2D_DETECT 0
#endif #endif
#ifndef ENABLE_PHYSICS_DETECT #ifndef ENABLE_PHYSICS_CHIPMUNK_DETECT
#define ENABLE_PHYSICS_DETECT 1 #define ENABLE_PHYSICS_CHIPMUNK_DETECT 1
#endif #endif
#define MAX_VERTEXZ_VALUE 5000000.0f
#define ARMATURE_MAX_CHILD 50.0f
#define ARMATURE_MAX_ZORDER 100
#define ARMATURE_MAX_COUNT ((MAX_VERTEXZ_VALUE) / (ARMATURE_MAX_CHILD) / ARMATURE_MAX_ZORDER)
#define CS_RETURN_IF(cond) if (cond) return #define CS_RETURN_IF(cond) if (cond) return
#define CS_RETURN_NULL_IF(cond) if (cond) return NULL; #define CS_RETURN_NULL_IF(cond) if (cond) return NULL;
#define NS_CC_EXT_ARMATURE_BEGIN namespace cocos2d { namespace extension { namespace armature {
#define NS_CC_EXT_ARMATURE_END }}}
#define USING_NS_CC_EXT_ARMATURE using namespace cocos2d::extension::armature
NS_CC_EXT_ARMATURE_BEGIN
const char *armatureVersion();
NS_CC_EXT_ARMATURE_END
#endif /*__CCARMATUREDEFINE_H__*/ #endif /*__CCARMATUREDEFINE_H__*/

805
extensions/CocoStudio/Armature/utils/CCDataReaderHelper.cpp
View File

File diff suppressed because it is too large Load Diff

199
extensions/CocoStudio/Armature/utils/CCDataReaderHelper.h
View File

@ -27,19 +27,54 @@ THE SOFTWARE.
#include "CCArmatureDefine.h" #include "CCArmatureDefine.h"
#include "../datas/CCDatas.h" #include "../datas/CCDatas.h"
#include "../utils/CCConstValue.h"
#include "../CCArmature.h" #include "../CCArmature.h"
#include "../../Json/CSContentJsonDictionary.h" #include "../../Json/CSContentJsonDictionary.h"
namespace tinyxml2 { class XMLElement; } #include <string>
#include <queue>
#include <list>
#include <mutex>
#include <thread>
namespace cocos2d { namespace extension { namespace armature { namespace tinyxml2
class DataReaderHelper
{ {
class XMLElement;
}
NS_CC_EXT_ARMATURE_BEGIN
class CCDataReaderHelper : Object
{
protected:
enum ConfigType
{
DragonBone_XML,
CocoStudio_JSON
};
typedef struct _AsyncStruct
{
std::string filename;
std::string fileContent;
ConfigType configType;
std::string baseFilePath;
Object *target;
SEL_SCHEDULE selector;
bool autoLoadSpriteFile;
} AsyncStruct;
typedef struct _DataInfo
{
AsyncStruct *asyncStruct;
std::queue<std::string> configFileQueue;
} DataInfo;
public: public:
static CCDataReaderHelper *sharedDataReaderHelper();
/** /**
* Scale the position data, used for multiresolution adapter * Scale the position data, used for multiresolution adapter
* It won't effect the data already read. * It won't effect the data already read.
@ -47,85 +82,105 @@ public:
static void setPositionReadScale(float scale); static void setPositionReadScale(float scale);
static float getPositionReadScale(); static float getPositionReadScale();
static void addDataFromFile(const char *filePath); static void purge();
static void clear(); static void clear();
public: public:
CCDataReaderHelper();
~CCDataReaderHelper();
/** void addDataFromFile(const char *filePath);
* Translate XML export from Dragon Bone flash tool to datas, and save them. void addDataFromFileAsync(const char *filePath, Object *target, SEL_SCHEDULE selector);
* When you add a new xml, the data already saved will be keeped.
*
* @param xmlPath Path of xml file
*/
static void addDataFromXML(const char *xmlPath);
/** void addDataAsyncCallBack(float dt);
* Translate XML export from Dragon Bone flash tool to datas, and save them.
* When you add a new xml, the data already saved will be keeped.
*
* @param xmlPakPath Path of pak file
*/
static void addDataFromXMLPak(const char *xmlPakPath);
/**
* Translate XML export from Dragon Bone flash tool to datas, and save them.
* When you add a new xml, the data already saved will be keeped.
*
* @param fileContent The cache of the xml
*/
static void addDataFromCache(const char *fileContent);
/**
* Decode Armature Datas from xml export from Dragon Bone flash tool
*/
static ArmatureData *decodeArmature(tinyxml2::XMLElement *armatureXML);
static BoneData *decodeBone(tinyxml2::XMLElement *boneXML, tinyxml2::XMLElement *parentXML);
static DisplayData *decodeBoneDisplay(tinyxml2::XMLElement *displayXML);
/**
* Decode ArmatureAnimation Datas from xml export from Dragon Bone flash tool
*/
static AnimationData *decodeAnimation(tinyxml2::XMLElement *animationXML);
static MovementData *decodeMovement(tinyxml2::XMLElement *movementXML, ArmatureData *armatureData);
static MovementBoneData *decodeMovementBone(tinyxml2::XMLElement *movBoneXml, tinyxml2::XMLElement *parentXml, BoneData *boneData);
static FrameData *decodeFrame(tinyxml2::XMLElement *frameXML, tinyxml2::XMLElement *parentFrameXml, BoneData *boneData);
/**
* Decode Texture Datas from xml export from Dragon Bone flash tool
*/
static TextureData *decodeTexture(tinyxml2::XMLElement *textureXML);
/**
* Decode Contour Datas from xml export from Dragon Bone flash tool
*/
static ContourData *decodeContour(tinyxml2::XMLElement *contourXML);
public: public:
static void addDataFromJson(const char *filePath); /**
static void addDataFromJsonCache(const char *fileContent); * Translate XML export from Dragon CCBone flash tool to datas, and save them.
* When you add a new xml, the data already saved will be keeped.
*
* @param xmlPath The cache of the xml
*/
static void addDataFromCache(const char *pFileContent, DataInfo *dataInfo = NULL);
static ArmatureData *decodeArmature(cs::JsonDictionary &json);
static BoneData *decodeBone(cs::JsonDictionary &json);
static DisplayData *decodeBoneDisplay(cs::JsonDictionary &json);
static AnimationData *decodeAnimation(cs::JsonDictionary &json);
static MovementData *decodeMovement(cs::JsonDictionary &json);
static MovementBoneData *decodeMovementBone(cs::JsonDictionary &json);
static FrameData *decodeFrame(cs::JsonDictionary &json);
static TextureData *decodeTexture(cs::JsonDictionary &json); /**
* Decode CCArmature Datas from xml export from Dragon CCBone flash tool
*/
static CCArmatureData *decodeArmature(tinyxml2::XMLElement *armatureXML);
static CCBoneData *decodeBone(tinyxml2::XMLElement *boneXML, tinyxml2::XMLElement *parentXML);
static CCDisplayData *decodeBoneDisplay(tinyxml2::XMLElement *displayXML);
static ContourData *decodeContour(cs::JsonDictionary &json);
static void decodeNode(BaseData *node, cs::JsonDictionary &json); /**
* Decode CCArmatureAnimation Datas from xml export from Dragon CCBone flash tool
*/
static CCAnimationData *decodeAnimation(tinyxml2::XMLElement *animationXML);
static CCMovementData *decodeMovement(tinyxml2::XMLElement *movementXML, CCArmatureData *armatureData);
static CCMovementBoneData *decodeMovementBone(tinyxml2::XMLElement *movBoneXml, tinyxml2::XMLElement *parentXml, CCBoneData *boneData);
static CCFrameData *decodeFrame(tinyxml2::XMLElement *frameXML, tinyxml2::XMLElement *parentFrameXml, CCBoneData *boneData);
/**
* Decode Texture Datas from xml export from Dragon CCBone flash tool
*/
static CCTextureData *decodeTexture(tinyxml2::XMLElement *textureXML);
/**
* Decode Contour Datas from xml export from Dragon CCBone flash tool
*/
static CCContourData *decodeContour(tinyxml2::XMLElement *contourXML);
public:
static void addDataFromJsonCache(const char *fileContent, DataInfo *dataInfo = NULL);
static CCArmatureData *decodeArmature(cs::JsonDictionary &json);
static CCBoneData *decodeBone(cs::JsonDictionary &json);
static CCDisplayData *decodeBoneDisplay(cs::JsonDictionary &json);
static CCAnimationData *decodeAnimation(cs::JsonDictionary &json);
static CCMovementData *decodeMovement(cs::JsonDictionary &json);
static CCMovementBoneData *decodeMovementBone(cs::JsonDictionary &json);
static CCFrameData *decodeFrame(cs::JsonDictionary &json);
static CCTextureData *decodeTexture(cs::JsonDictionary &json);
static CCContourData *decodeContour(cs::JsonDictionary &json);
static void decodeNode(CCBaseData *node, cs::JsonDictionary &json);
protected:
void loadData();
std::condition_variable s_SleepCondition;
std::thread *s_LoadingThread;
std::mutex s_SleepMutex;
std::mutex s_AsyncStructQueueMutex;
std::mutex s_DataInfoMutex;
std::mutex s_AddDataMutex;
std::mutex s_ReadFileMutex;
unsigned long s_nAsyncRefCount;
unsigned long s_nAsyncRefTotalCount;
bool need_quit;
std::queue<AsyncStruct *> *s_pAsyncStructQueue;
std::queue<DataInfo *> *s_pDataQueue;
static CCDataReaderHelper *s_DataReaderHelper;
}; };
}}} // namespace cocos2d { namespace extension { namespace armature { NS_CC_EXT_ARMATURE_END
#endif /*__CCDATAREADERHELPER_H__*/ #endif /*__CCDATAREADERHELPER_H__*/

143
extensions/CocoStudio/Armature/utils/CCSpriteFrameCacheHelper.cpp
View File

@ -25,160 +25,51 @@ THE SOFTWARE.
#include "CCSpriteFrameCacheHelper.h" #include "CCSpriteFrameCacheHelper.h"
namespace cocos2d { namespace extension { namespace armature { NS_CC_EXT_ARMATURE_BEGIN
SpriteFrameCacheHelper *SpriteFrameCacheHelper::s_SpriteFrameCacheHelper = NULL; CCSpriteFrameCacheHelper *CCSpriteFrameCacheHelper::s_SpriteFrameCacheHelper = NULL;
SpriteFrameCacheHelper *SpriteFrameCacheHelper::sharedSpriteFrameCacheHelper() CCSpriteFrameCacheHelper *CCSpriteFrameCacheHelper::sharedSpriteFrameCacheHelper()
{ {
if(!s_SpriteFrameCacheHelper) if(!s_SpriteFrameCacheHelper)
{ {
s_SpriteFrameCacheHelper = new SpriteFrameCacheHelper(); s_SpriteFrameCacheHelper = new CCSpriteFrameCacheHelper();
} }
return s_SpriteFrameCacheHelper; return s_SpriteFrameCacheHelper;
} }
void SpriteFrameCacheHelper::purgeSpriteFrameCacheHelper() void CCSpriteFrameCacheHelper::purge()
{ {
delete s_SpriteFrameCacheHelper; delete s_SpriteFrameCacheHelper;
s_SpriteFrameCacheHelper = NULL; s_SpriteFrameCacheHelper = NULL;
} }
void SpriteFrameCacheHelper::addSpriteFrameFromFile(const char *plistPath, const char *imagePath) void CCSpriteFrameCacheHelper::addSpriteFrameFromFile(const char *plistPath, const char *imagePath)
{ {
CCSpriteFrameCache::getInstance()->addSpriteFramesWithFile(plistPath, imagePath);
std::string path = FileUtils::getInstance()->fullPathForFilename(plistPath);
Dictionary *dict = Dictionary::createWithContentsOfFileThreadSafe(path.c_str());
Texture2D *pobTexture = TextureCache::getInstance()->addImage(imagePath);
addSpriteFrameFromDict(dict, pobTexture, imagePath);
dict->release();
} }
void SpriteFrameCacheHelper::addSpriteFrameFromDict(Dictionary *dictionary, Texture2D *pobTexture, const char *imagePath) TextureAtlas *CCSpriteFrameCacheHelper::getTexureAtlasWithTexture(Texture2D *texture)
{ {
/* int key = texture->getName();
Supported Zwoptex Formats: TextureAtlas *atlas = (TextureAtlas *)m_pTextureAtlasDic->objectForKey(key);
ZWTCoordinatesFormatOptionXMLLegacy = 0, // Flash Version
ZWTCoordinatesFormatOptionXML1_0 = 1, // Desktop Version 0.0 - 0.4b
ZWTCoordinatesFormatOptionXML1_1 = 2, // Desktop Version 1.0.0 - 1.0.1
ZWTCoordinatesFormatOptionXML1_2 = 3, // Desktop Version 1.0.2+
*/
Dictionary *metadataDict = (Dictionary *)dictionary->objectForKey("metadata");
Dictionary *framesDict = (Dictionary *)dictionary->objectForKey("frames");
int format = 0;
// get the format
if(metadataDict != NULL)
{
format = metadataDict->valueForKey("format")->intValue();
}
// check the format
CCASSERT(format >= 0 && format <= 3, "format is not supported for SpriteFrameCache addSpriteFramesWithDictionary:textureFilename:");
DictElement *pElement = NULL;
CCDICT_FOREACH(framesDict, pElement)
{
Dictionary *frameDict = static_cast<Dictionary*>(pElement->getObject());
std::string spriteFrameName = pElement->getStrKey();
_display2ImageMap[spriteFrameName] = imagePath;
//log("spriteFrameName : %s, imagePath : %s", spriteFrameName.c_str(), _imagePath);
SpriteFrame *spriteFrame = (SpriteFrame *)SpriteFrameCache::getInstance()->getSpriteFrameByName(spriteFrameName.c_str());
if (spriteFrame)
{
continue;
}
if(format == 0)
{
float x = frameDict->valueForKey("x")->floatValue();
float y = frameDict->valueForKey("y")->floatValue();
float w = frameDict->valueForKey("width")->floatValue();
float h = frameDict->valueForKey("height")->floatValue();
float ox = frameDict->valueForKey("offsetX")->floatValue();
float oy = frameDict->valueForKey("offsetY")->floatValue();
int ow = frameDict->valueForKey("originalWidth")->intValue();
int oh = frameDict->valueForKey("originalHeight")->intValue();
// check ow/oh
if(!ow || !oh)
{
CCLOG("cocos2d: WARNING: originalWidth/Height not found on the SpriteFrame. AnchorPoint won't work as expected. Regenrate the .plist");
}
// abs ow/oh
ow = abs(ow);
oh = abs(oh);
// create frame
spriteFrame = new SpriteFrame();
spriteFrame->initWithTexture(pobTexture, Rect(x, y, w, h), false, Point(ox, oy), Size((float)ow, (float)oh));
}
else if(format == 1 || format == 2)
{
Rect frame = RectFromString(frameDict->valueForKey("frame")->getCString());
bool rotated = false;
// rotation
if (format == 2)
{
rotated = frameDict->valueForKey("rotated")->boolValue();
}
Point offset = PointFromString(frameDict->valueForKey("offset")->getCString());
Size sourceSize = SizeFromString(frameDict->valueForKey("sourceSize")->getCString());
// create frame
spriteFrame = new SpriteFrame();
spriteFrame->initWithTexture(pobTexture, frame, rotated, offset, sourceSize );
}
else if (format == 3)
{
}
// add sprite frame
SpriteFrameCache::getInstance()->addSpriteFrame(spriteFrame, spriteFrameName.c_str());
spriteFrame->release();
}
}
const char *SpriteFrameCacheHelper::getDisplayImagePath(const char *displayName)
{
return _display2ImageMap[displayName].c_str();
}
TextureAtlas *SpriteFrameCacheHelper::getTextureAtlas(const char *displayName)
{
const char *textureName = getDisplayImagePath(displayName);
TextureAtlas *atlas = (TextureAtlas *)_display2TextureAtlas->objectForKey(textureName);
if (atlas == NULL) if (atlas == NULL)
{ {
atlas = TextureAtlas::createWithTexture(TextureCache::getInstance()->addImage(textureName), 4); atlas = TextureAtlas::createWithTexture(texture, 4);
_display2TextureAtlas->setObject(atlas, textureName); m_pTextureAtlasDic->setObject(atlas, key);
} }
return atlas; return atlas;
} }
SpriteFrameCacheHelper::SpriteFrameCacheHelper() CCSpriteFrameCacheHelper::CCSpriteFrameCacheHelper()
{ {
_display2TextureAtlas = new Dictionary(); m_pTextureAtlasDic = new Dictionary();
_display2TextureAtlas->init();
} }
SpriteFrameCacheHelper::~SpriteFrameCacheHelper() CCSpriteFrameCacheHelper::~CCSpriteFrameCacheHelper()
{ {
CC_SAFE_RELEASE_NULL(_display2TextureAtlas); CC_SAFE_RELEASE_NULL(m_pTextureAtlasDic);
} }
}}} // namespace cocos2d { namespace extension { namespace armature { NS_CC_EXT_ARMATURE_END

37
extensions/CocoStudio/Armature/utils/CCSpriteFrameCacheHelper.h
View File

@ -29,47 +29,32 @@ THE SOFTWARE.
using namespace std; using namespace std;
namespace cocos2d { namespace extension { namespace armature { NS_CC_EXT_ARMATURE_BEGIN
class SpriteFrameCacheHelper class CCSpriteFrameCacheHelper
{ {
public: public:
static SpriteFrameCacheHelper *sharedSpriteFrameCacheHelper(); static CCSpriteFrameCacheHelper *sharedSpriteFrameCacheHelper();
static void purgeSpriteFrameCacheHelper(); static void purge();
public: public:
/** /**
* @brief Add sprite frame to SpriteFrameCache, it will save display name and it's relative image name * @brief Add sprite frame to CCSpriteFrameCache, it will save display name and it's relative image name
*
*/ */
void addSpriteFrameFromFile(const char *plistPath, const char *imagePath); void addSpriteFrameFromFile(const char *plistPath, const char *imagePath);
void addSpriteFrameFromDict(Dictionary *dictionary, Texture2D *pobTexture, const char *imagePath); TextureAtlas *getTexureAtlasWithTexture(Texture2D *texture);
/**
* Get this display in which image
*/
const char *getDisplayImagePath(const char *displayName);
TextureAtlas *getTextureAtlas(const char *displayName);
private: private:
/** CCSpriteFrameCacheHelper();
* @js ctor ~CCSpriteFrameCacheHelper();
*/
SpriteFrameCacheHelper();
/**
* @js NA
* @lua NA
*/
~SpriteFrameCacheHelper();
std::map<std::string, std::string> _display2ImageMap; Dictionary *m_pTextureAtlasDic;
Dictionary *_display2TextureAtlas;
static SpriteFrameCacheHelper *s_SpriteFrameCacheHelper; static CCSpriteFrameCacheHelper *s_SpriteFrameCacheHelper;
}; };
}}} // namespace cocos2d { namespace extension { namespace armature { NS_CC_EXT_ARMATURE_END
#endif /*__CCSPRITEFRAMECACHEHELPER_H__*/ #endif /*__CCSPRITEFRAMECACHEHELPER_H__*/

40
extensions/CocoStudio/Armature/utils/CCTransformHelp.cpp
View File

@ -25,21 +25,21 @@ THE SOFTWARE.
#include "CCTransformHelp.h" #include "CCTransformHelp.h"
#include "CCUtilMath.h" #include "CCUtilMath.h"
namespace cocos2d { namespace extension { namespace armature { NS_CC_EXT_ARMATURE_BEGIN
AffineTransform TransformHelp::helpMatrix1; AffineTransform CCTransformHelp::helpMatrix1;
AffineTransform TransformHelp::helpMatrix2; AffineTransform CCTransformHelp::helpMatrix2;
Point TransformHelp::helpPoint1; Point CCTransformHelp::helpPoint1;
Point TransformHelp::helpPoint2; Point CCTransformHelp::helpPoint2;
BaseData helpParentNode; CCBaseData helpParentNode;
TransformHelp::TransformHelp() CCTransformHelp::CCTransformHelp()
{ {
} }
void TransformHelp::transformFromParent(BaseData &node, const BaseData &parentNode) void CCTransformHelp::transformFromParent(CCBaseData &node, const CCBaseData &parentNode)
{ {
nodeToMatrix(node, helpMatrix1); nodeToMatrix(node, helpMatrix1);
nodeToMatrix(parentNode, helpMatrix2); nodeToMatrix(parentNode, helpMatrix2);
@ -50,7 +50,7 @@ void TransformHelp::transformFromParent(BaseData &node, const BaseData &parentNo
matrixToNode(helpMatrix1, node); matrixToNode(helpMatrix1, node);
} }
void TransformHelp::transformToParent(BaseData &node, const BaseData &parentNode) void CCTransformHelp::transformToParent(CCBaseData &node, const CCBaseData &parentNode)
{ {
nodeToMatrix(node, helpMatrix1); nodeToMatrix(node, helpMatrix1);
@ -61,7 +61,7 @@ void TransformHelp::transformToParent(BaseData &node, const BaseData &parentNode
matrixToNode(helpMatrix1, node); matrixToNode(helpMatrix1, node);
} }
void TransformHelp::transformFromParentWithoutScale(BaseData &node, const BaseData &parentNode) void CCTransformHelp::transformFromParentWithoutScale(CCBaseData &node, const CCBaseData &parentNode)
{ {
helpParentNode.copy(&parentNode); helpParentNode.copy(&parentNode);
@ -77,7 +77,7 @@ void TransformHelp::transformFromParentWithoutScale(BaseData &node, const BaseDa
matrixToNode(helpMatrix1, node); matrixToNode(helpMatrix1, node);
} }
void TransformHelp::transformToParentWithoutScale(BaseData &node, const BaseData &parentNode) void CCTransformHelp::transformToParentWithoutScale(CCBaseData &node, const CCBaseData &parentNode)
{ {
helpParentNode.copy(&parentNode); helpParentNode.copy(&parentNode);
@ -92,7 +92,7 @@ void TransformHelp::transformToParentWithoutScale(BaseData &node, const BaseData
matrixToNode(helpMatrix1, node); matrixToNode(helpMatrix1, node);
} }
void TransformHelp::nodeToMatrix(const BaseData &node, AffineTransform &matrix) void CCTransformHelp::nodeToMatrix(const CCBaseData &node, AffineTransform &matrix)
{ {
matrix.a = node.scaleX * cos(node.skewY); matrix.a = node.scaleX * cos(node.skewY);
matrix.b = node.scaleX * sin(node.skewY); matrix.b = node.scaleX * sin(node.skewY);
@ -103,7 +103,7 @@ void TransformHelp::nodeToMatrix(const BaseData &node, AffineTransform &matrix)
matrix.ty = node.y; matrix.ty = node.y;
} }
void TransformHelp::matrixToNode(const AffineTransform &matrix, BaseData &node) void CCTransformHelp::matrixToNode(const AffineTransform &matrix, CCBaseData &node)
{ {
/* /*
* In as3 language, there is a function called "deltaTransformPoint", it calculate a point used give Transform * In as3 language, there is a function called "deltaTransformPoint", it calculate a point used give Transform
@ -129,7 +129,7 @@ void TransformHelp::matrixToNode(const AffineTransform &matrix, BaseData &node)
node.y = matrix.ty; node.y = matrix.ty;
} }
void TransformHelp::nodeConcat(BaseData &target, BaseData &source) void CCTransformHelp::nodeConcat(CCBaseData &target, CCBaseData &source)
{ {
target.x += source.x; target.x += source.x;
target.y += source.y; target.y += source.y;
@ -139,4 +139,14 @@ void TransformHelp::nodeConcat(BaseData &target, BaseData &source)
target.scaleY += source.scaleY; target.scaleY += source.scaleY;
} }
}}} // namespace cocos2d { namespace extension { namespace armature { void CCTransformHelp::nodeSub(CCBaseData &target, CCBaseData &source)
{
target.x -= source.x;
target.y -= source.y;
target.skewX -= source.skewX;
target.skewY -= source.skewY;
target.scaleX -= source.scaleX;
target.scaleY -= source.scaleY;
}
NS_CC_EXT_ARMATURE_END

23
extensions/CocoStudio/Armature/utils/CCTransformHelp.h
View File

@ -28,26 +28,27 @@ THE SOFTWARE.
#include "CCArmatureDefine.h" #include "CCArmatureDefine.h"
#include "../datas/CCDatas.h" #include "../datas/CCDatas.h"
namespace cocos2d { namespace extension { namespace armature { NS_CC_EXT_ARMATURE_BEGIN
/* /*
* use to calculate the matrix of node from parent node * use to calculate the matrix of node from parent node
*/ */
class TransformHelp class CCTransformHelp
{ {
public: public:
TransformHelp(); CCTransformHelp();
static void transformFromParent(BaseData &node, const BaseData &parentNode); static void transformFromParent(CCBaseData &node, const CCBaseData &parentNode);
static void transformToParent(BaseData &node, const BaseData &parentNode); static void transformToParent(CCBaseData &node, const CCBaseData &parentNode);
static void transformFromParentWithoutScale(BaseData &node, const BaseData &parentNode); static void transformFromParentWithoutScale(CCBaseData &node, const CCBaseData &parentNode);
static void transformToParentWithoutScale(BaseData &node, const BaseData &parentNode); static void transformToParentWithoutScale(CCBaseData &node, const CCBaseData &parentNode);
static void nodeToMatrix(const BaseData &_node, AffineTransform &_matrix); static void nodeToMatrix(const CCBaseData &_node, AffineTransform &_matrix);
static void matrixToNode(const AffineTransform &_matrix, BaseData &_node); static void matrixToNode(const AffineTransform &_matrix, CCBaseData &_node);
static void nodeConcat(BaseData &target, BaseData &source); static void nodeConcat(CCBaseData &target, CCBaseData &source);
static void nodeSub(CCBaseData &target, CCBaseData &source);
public: public:
static AffineTransform helpMatrix1; static AffineTransform helpMatrix1;
static AffineTransform helpMatrix2; static AffineTransform helpMatrix2;
@ -56,6 +57,6 @@ public:
static Point helpPoint2; static Point helpPoint2;
}; };
}}} // namespace cocos2d { namespace extension { namespace armature { NS_CC_EXT_ARMATURE_END
#endif /*__CCTRANSFORMHELP_H__*/ #endif /*__CCTRANSFORMHELP_H__*/

154
extensions/CocoStudio/Armature/utils/CCTweenFunction.cpp
View File

@ -25,9 +25,9 @@ THE SOFTWARE.
#include "CCTweenFunction.h" #include "CCTweenFunction.h"
#include "CCUtilMath.h" #include "CCUtilMath.h"
namespace cocos2d { namespace extension { namespace armature { NS_CC_EXT_ARMATURE_BEGIN
float TweenFunction::tweenTo(float from, float change, float time, float duration, TweenType tweenType) float CCTweenFunction::tweenTo(float from, float change, float time, float duration, CCTweenType tweenType)
{ {
float delta = 0; float delta = 0;
@ -146,109 +146,109 @@ float TweenFunction::tweenTo(float from, float change, float time, float duratio
return delta; return delta;
} }
float TweenFunction::linear(float t, float b, float c, float d) float CCTweenFunction::linear(float t, float b, float c, float d)
{ {
return c * t / d + b; return c * t / d + b;
} }
float TweenFunction::quadEaseIn(float t, float b, float c, float d) float CCTweenFunction::quadEaseIn(float t, float b, float c, float d)
{ {
t /= d; t /= d;
return c * t * t + b; return c * t * t + b;
} }
float TweenFunction::quadEaseOut(float t, float b, float c, float d) float CCTweenFunction::quadEaseOut(float t, float b, float c, float d)
{ {
t /= d; t /= d;
return -c * t * (t - 2) + b; return -c * t * (t - 2) + b;
} }
float TweenFunction::quadEaseInOut(float t, float b, float c, float d) float CCTweenFunction::quadEaseInOut(float t, float b, float c, float d)
{ {
t /= d; t /= d;
if ((t / 2) < 1) if ((t / 2) < 1)
return c / 2 * t * t + b; return c / 2 * t * t + b;
--t; --t;
return -c / 2 * (t * (t - 2) - 1) + b; return -c / 2 * (t * (t - 2) - 1) + b;
} }
float TweenFunction::cubicEaseIn(float t, float b, float c, float d) float CCTweenFunction::cubicEaseIn(float t, float b, float c, float d)
{ {
t /= d; t /= d;
return c * t * t * t + b; return c * t * t * t + b;
} }
float TweenFunction::cubicEaseOut(float t, float b, float c, float d) float CCTweenFunction::cubicEaseOut(float t, float b, float c, float d)
{ {
t = t / d - 1; t = t / d - 1;
return c * (t * t * t + 1) + b; return c * (t * t * t + 1) + b;
} }
float TweenFunction::cubicEaseInOut(float t, float b, float c, float d) float CCTweenFunction::cubicEaseInOut(float t, float b, float c, float d)
{ {
t /= d; t /= d;
if ((t / 2) < 1) if ((t / 2) < 1)
return c / 2 * t * t * t + b; return c / 2 * t * t * t + b;
t -= 2; t -= 2;
return c / 2 * (t * t * t + 2) + b; return c / 2 * (t * t * t + 2) + b;
} }
float TweenFunction::quartEaseIn(float t, float b, float c, float d) float CCTweenFunction::quartEaseIn(float t, float b, float c, float d)
{ {
t /= d; t /= d;
return c * t * t * t * t + b; return c * t * t * t * t + b;
} }
float TweenFunction::quartEaseOut(float t, float b, float c, float d) float CCTweenFunction::quartEaseOut(float t, float b, float c, float d)
{ {
t = t / d - 1; t = t / d - 1;
return -c * (t * t * t * t - 1) + b; return -c * (t * t * t * t - 1) + b;
} }
float TweenFunction::quartEaseInOut(float t, float b, float c, float d) float CCTweenFunction::quartEaseInOut(float t, float b, float c, float d)
{ {
t /= d; t /= d;
if ((t / 2) < 1) if ((t / 2) < 1)
return c / 2 * t * t * t * t + b; return c / 2 * t * t * t * t + b;
t -= 2; t -= 2;
return -c / 2 * (t * t * t * t - 2) + b; return -c / 2 * (t * t * t * t - 2) + b;
} }
float TweenFunction::quintEaseIn(float t, float b, float c, float d) float CCTweenFunction::quintEaseIn(float t, float b, float c, float d)
{ {
t /= d; t /= d;
return c * t * t * t * t * t + b; return c * t * t * t * t * t + b;
} }
float TweenFunction::quintEaseOut(float t, float b, float c, float d) float CCTweenFunction::quintEaseOut(float t, float b, float c, float d)
{ {
t = t / d - 1; t = t / d - 1;
return c * (t * t * t * t * t + 1) + b; return c * (t * t * t * t * t + 1) + b;
} }
float TweenFunction::quintEaseInOut(float t, float b, float c, float d) float CCTweenFunction::quintEaseInOut(float t, float b, float c, float d)
{ {
t /= d; t /= d;
if ((t / 2) < 1) if ((t / 2) < 1)
return c / 2 * t * t * t * t * t + b; return c / 2 * t * t * t * t * t + b;
t -= 2; t -= 2;
return c / 2 * (t * t * t * t * t + 2) + b; return c / 2 * (t * t * t * t * t + 2) + b;
} }
float TweenFunction::sineEaseIn(float t, float b, float c, float d) float CCTweenFunction::sineEaseIn(float t, float b, float c, float d)
{ {
return -c * cos(t / d * (M_PI / 2)) + c + b; return -c * cos(t / d * (M_PI / 2)) + c + b;
} }
float TweenFunction::sineEaseOut(float t, float b, float c, float d) float CCTweenFunction::sineEaseOut(float t, float b, float c, float d)
{ {
return c * sin(t / d * (M_PI / 2)) + b; return c * sin(t / d * (M_PI / 2)) + b;
} }
float TweenFunction::sineEaseInOut(float t, float b, float c, float d) float CCTweenFunction::sineEaseInOut(float t, float b, float c, float d)
{ {
return -c / 2 * (cos(M_PI * t / d) - 1) + b; return -c / 2 * (cos(M_PI * t / d) - 1) + b;
} }
float TweenFunction::expoEaseIn(float t, float b, float c, float d) float CCTweenFunction::expoEaseIn(float t, float b, float c, float d)
{ {
return (t == 0) ? b : c * pow(2, 10 * (t / d - 1)) + b; return (t == 0) ? b : c * pow(2, 10 * (t / d - 1)) + b;
} }
float TweenFunction::expoEaseOut(float t, float b, float c, float d) float CCTweenFunction::expoEaseOut(float t, float b, float c, float d)
{ {
return (t == d) ? b + c : c * (-pow(2, -10 * t / d) + 1) + b; return (t == d) ? b + c : c * (-pow(2, -10 * t / d) + 1) + b;
} }
float TweenFunction::expoEaseInOut(float t, float b, float c, float d) float CCTweenFunction::expoEaseInOut(float t, float b, float c, float d)
{ {
if (t == 0) if (t == 0)
return b; return b;
@ -256,36 +256,36 @@ float TweenFunction::expoEaseInOut(float t, float b, float c, float d)
return b + c; return b + c;
if ((t /= d / 2) < 1) if ((t /= d / 2) < 1)
return c / 2 * pow(2, 10 * (t - 1)) + b; return c / 2 * pow(2, 10 * (t - 1)) + b;
--t; --t;
return c / 2 * (-pow(2, -10 * t) + 2) + b; return c / 2 * (-pow(2, -10 * t) + 2) + b;
} }
float TweenFunction::circEaseIn(float t, float b, float c, float d) float CCTweenFunction::circEaseIn(float t, float b, float c, float d)
{ {
t /= d; t /= d;
return -c * (sqrt(1 - t * t) - 1) + b; return -c * (sqrt(1 - t * t) - 1) + b;
} }
float TweenFunction::circEaseOut(float t, float b, float c, float d) float CCTweenFunction::circEaseOut(float t, float b, float c, float d)
{ {
t = t / d - 1; t = t / d - 1;
return c * sqrt(1 - t * t) + b; return c * sqrt(1 - t * t) + b;
} }
float TweenFunction::circEaseInOut(float t, float b, float c, float d) float CCTweenFunction::circEaseInOut(float t, float b, float c, float d)
{ {
t /= d; t /= d;
if ((t / 2) < 1) if ((t / 2) < 1)
return -c / 2 * (sqrt(1 - t * t) - 1) + b; return -c / 2 * (sqrt(1 - t * t) - 1) + b;
t -= 2; t -= 2;
return c / 2 * (sqrt(1 - t * t) + 1) + b; return c / 2 * (sqrt(1 - t * t) + 1) + b;
} }
float TweenFunction::elasticEaseIn(float t, float b, float c, float d, float a, float p) float CCTweenFunction::elasticEaseIn(float t, float b, float c, float d, float a, float p)
{ {
float s = 0; float s = 0;
if (t == 0) if (t == 0)
return b; return b;
t /= d; t /= d;
if (t == 1) if (t == 1)
return b + c; return b + c;
if (!p) if (!p)
p = d * .3; p = d * .3;
@ -296,15 +296,15 @@ float TweenFunction::elasticEaseIn(float t, float b, float c, float d, float a,
} }
else else
s = p / (2 * M_PI) * asin(c / a); s = p / (2 * M_PI) * asin(c / a);
t -= 1; t -= 1;
return -(a * pow(2, 10 * t) * sin((t * d - s) * (2 * M_PI) / p)) + b; return -(a * pow(2, 10 * t) * sin((t * d - s) * (2 * M_PI) / p)) + b;
} }
float TweenFunction::elasticEaseOut(float t, float b, float c, float d, float a, float p) float CCTweenFunction::elasticEaseOut(float t, float b, float c, float d, float a, float p)
{ {
float s = 0; float s = 0;
if (t == 0) if (t == 0)
return b; return b;
t /= d; t /= d;
if (t == 1) if (t == 1)
return b + c; return b + c;
if (!p) if (!p)
@ -318,13 +318,13 @@ float TweenFunction::elasticEaseOut(float t, float b, float c, float d, float a,
s = p / (2 * M_PI) * asin(c / a); s = p / (2 * M_PI) * asin(c / a);
return (a * pow(2, -10 * t) * sin((t * d - s) * (2 * M_PI) / p) + c + b); return (a * pow(2, -10 * t) * sin((t * d - s) * (2 * M_PI) / p) + c + b);
} }
float TweenFunction::elasticEaseInOut(float t, float b, float c, float d, float a, float p) float CCTweenFunction::elasticEaseInOut(float t, float b, float c, float d, float a, float p)
{ {
float s = 0; float s = 0;
if (t == 0) if (t == 0)
return b; return b;
t /= d; t /= d;
if ((t / 2) == 2) if ((t / 2) == 2)
return b + c; return b + c;
if (!p) if (!p)
p = d * (.3 * 1.5); p = d * (.3 * 1.5);
@ -336,73 +336,73 @@ float TweenFunction::elasticEaseInOut(float t, float b, float c, float d, float
else else
s = p / (2 * M_PI) * asin(c / a); s = p / (2 * M_PI) * asin(c / a);
if (t < 1) if (t < 1)
{ {
t -= 1; t -= 1;
return -.5 * (a * pow(2, 10 * t) * sin((t * d - s) * (2 * M_PI) / p)) + b; return -.5 * (a * pow(2, 10 * t) * sin((t * d - s) * (2 * M_PI) / p)) + b;
} }
t -= 1; t -= 1;
return a * pow(2, -10 * t) * sin((t * d - s) * (2 * M_PI) / p) * .5 + c + b; return a * pow(2, -10 * t) * sin((t * d - s) * (2 * M_PI) / p) * .5 + c + b;
} }
float TweenFunction::backEaseIn(float t, float b, float c, float d, float s) float CCTweenFunction::backEaseIn(float t, float b, float c, float d, float s)
{ {
if (s == 0) if (s == 0)
s = 1.70158f; s = 1.70158f;
t /= d; t /= d;
return c * t * t * ((s + 1) * t - s) + b; return c * t * t * ((s + 1) * t - s) + b;
} }
float TweenFunction::backEaseOut(float t, float b, float c, float d, float s) float CCTweenFunction::backEaseOut(float t, float b, float c, float d, float s)
{ {
if (s == 0) if (s == 0)
s = 1.70158f; s = 1.70158f;
t = t / d - 1; t = t / d - 1;
return c * (t * t * ((s + 1) * t + s) + 1) + b; return c * (t * t * ((s + 1) * t + s) + 1) + b;
} }
float TweenFunction::backEaseInOut(float t, float b, float c, float d, float s) float CCTweenFunction::backEaseInOut(float t, float b, float c, float d, float s)
{ {
if (s == 0) if (s == 0)
s = 1.70158f; s = 1.70158f;
if ((t /= d / 2) < 1) if ((t /= d / 2) < 1)
{ {
s *= (1.525f); s *= (1.525f);
return c / 2 * (t * t * ((s + 1) * t - s)) + b; return c / 2 * (t * t * ((s + 1) * t - s)) + b;
} }
t -= 2; t -= 2;
s *= (1.525f); s *= (1.525f);
return c / 2 * (t * t * ((s + 1) * t + s) + 2) + b; return c / 2 * (t * t * ((s + 1) * t + s) + 2) + b;
} }
float TweenFunction::bounceEaseIn(float t, float b, float c, float d) float CCTweenFunction::bounceEaseIn(float t, float b, float c, float d)
{ {
return c - bounceEaseOut(d - t, 0, c, d) + b; return c - bounceEaseOut(d - t, 0, c, d) + b;
} }
float TweenFunction::bounceEaseOut(float t, float b, float c, float d) float CCTweenFunction::bounceEaseOut(float t, float b, float c, float d)
{ {
t /= d; t /= d;
if (t < (1 / 2.75f)) if (t < (1 / 2.75f))
{ {
return c * (7.5625f * t * t) + b; return c * (7.5625f * t * t) + b;
} }
else if (t < (2 / 2.75f)) else if (t < (2 / 2.75f))
{ {
t -= (1.5f / 2.75f); t -= (1.5f / 2.75f);
return c * (7.5625f * t * t + .75f) + b; return c * (7.5625f * t * t + .75f) + b;
} }
else if (t < (2.5f / 2.75f)) else if (t < (2.5f / 2.75f))
{ {
t -= (2.25f / 2.75f); t -= (2.25f / 2.75f);
return c * (7.5625f * t * t + .9375f) + b; return c * (7.5625f * t * t + .9375f) + b;
} }
else else
{ {
t -= (2.625f / 2.75f); t -= (2.625f / 2.75f);
return c * (7.5625f * t * t + .984375f) + b; return c * (7.5625f * t * t + .984375f) + b;
} }
} }
float TweenFunction::bounceEaseInOut(float t, float b, float c, float d) float CCTweenFunction::bounceEaseInOut(float t, float b, float c, float d)
{ {
if (t < d / 2) if (t < d / 2)
return bounceEaseIn(t * 2, 0, c, d) * .5 + b; return bounceEaseIn(t * 2, 0, c, d) * .5 + b;
@ -411,4 +411,4 @@ float TweenFunction::bounceEaseInOut(float t, float b, float c, float d)
} }
}}} // namespace cocos2d { namespace extension { namespace armature { NS_CC_EXT_ARMATURE_END

66
extensions/CocoStudio/Armature/utils/CCTweenFunction.h
View File

@ -29,22 +29,23 @@ THE SOFTWARE.
#include "CCArmatureDefine.h" #include "CCArmatureDefine.h"
#include <math.h> #include <math.h>
namespace cocos2d { namespace extension { namespace armature { NS_CC_EXT_ARMATURE_BEGIN
enum TweenType{ enum CCTweenType
{
TWEEN_EASING_MIN = -1, TWEEN_EASING_MIN = -1,
Linear, Linear,
Sine_EaseIn, Sine_EaseIn,
Sine_EaseInOut, Sine_EaseInOut,
Sine_EaseOut, Sine_EaseOut,
Quad_EaseIn, Quad_EaseIn,
Quad_EaseOut, Quad_EaseOut,
Quad_EaseInOut, Quad_EaseInOut,
Cubic_EaseIn, Cubic_EaseIn,
Cubic_EaseOut, Cubic_EaseOut,
Cubic_EaseInOut, Cubic_EaseInOut,
@ -52,83 +53,84 @@ enum TweenType{
Quart_EaseIn, Quart_EaseIn,
Quart_EaseOut, Quart_EaseOut,
Quart_EaseInOut, Quart_EaseInOut,
Quint_EaseIn, Quint_EaseIn,
Quint_EaseOut, Quint_EaseOut,
Quint_EaseInOut, Quint_EaseInOut,
Expo_EaseIn, Expo_EaseIn,
Expo_EaseOut, Expo_EaseOut,
Expo_EaseInOut, Expo_EaseInOut,
Circ_EaseIn, Circ_EaseIn,
Circ_EaseOut, Circ_EaseOut,
Circ_EaseInOut, Circ_EaseInOut,
Elastic_EaseIn, Elastic_EaseIn,
Elastic_EaseOut, Elastic_EaseOut,
Elastic_EaseInOut, Elastic_EaseInOut,
Back_EaseIn, Back_EaseIn,
Back_EaseOut, Back_EaseOut,
Back_EaseInOut, Back_EaseInOut,
Bounce_EaseIn, Bounce_EaseIn,
Bounce_EaseOut, Bounce_EaseOut,
Bounce_EaseInOut, Bounce_EaseInOut,
TWEEN_EASING_MAX = 10000 TWEEN_EASING_MAX = 10000
}; };
class TweenFunction{ class CCTweenFunction
{
public: public:
static float tweenTo(float from, float change, float time, float duration, TweenType tweenType); static float tweenTo(float from, float change, float time, float duration, CCTweenType tweenType);
static float linear(float t, float b, float c, float d); static float linear(float t, float b, float c, float d);
static float sineEaseIn(float t, float b, float c, float d); static float sineEaseIn(float t, float b, float c, float d);
static float sineEaseOut(float t, float b, float c, float d); static float sineEaseOut(float t, float b, float c, float d);
static float sineEaseInOut(float t, float b, float c, float d); static float sineEaseInOut(float t, float b, float c, float d);
static float quadEaseIn(float t, float b, float c, float d); static float quadEaseIn(float t, float b, float c, float d);
static float quadEaseOut(float t, float b, float c, float d); static float quadEaseOut(float t, float b, float c, float d);
static float quadEaseInOut(float t, float b, float c, float d); static float quadEaseInOut(float t, float b, float c, float d);
static float cubicEaseIn(float t, float b, float c, float d); static float cubicEaseIn(float t, float b, float c, float d);
static float cubicEaseOut(float t, float b, float c, float d); static float cubicEaseOut(float t, float b, float c, float d);
static float cubicEaseInOut(float t, float b, float c, float d); static float cubicEaseInOut(float t, float b, float c, float d);
static float quartEaseIn(float t, float b, float c, float d); static float quartEaseIn(float t, float b, float c, float d);
static float quartEaseOut(float t, float b, float c, float d); static float quartEaseOut(float t, float b, float c, float d);
static float quartEaseInOut(float t, float b, float c, float d); static float quartEaseInOut(float t, float b, float c, float d);
static float quintEaseIn(float t, float b, float c, float d); static float quintEaseIn(float t, float b, float c, float d);
static float quintEaseOut(float t, float b, float c, float d); static float quintEaseOut(float t, float b, float c, float d);
static float quintEaseInOut(float t, float b, float c, float d); static float quintEaseInOut(float t, float b, float c, float d);
static float expoEaseIn(float t, float b, float c, float d); static float expoEaseIn(float t, float b, float c, float d);
static float expoEaseOut(float t, float b, float c, float d); static float expoEaseOut(float t, float b, float c, float d);
static float expoEaseInOut(float t, float b, float c, float d); static float expoEaseInOut(float t, float b, float c, float d);
static float circEaseIn(float t, float b, float c, float d); static float circEaseIn(float t, float b, float c, float d);
static float circEaseOut(float t, float b, float c, float d); static float circEaseOut(float t, float b, float c, float d);
static float circEaseInOut(float t, float b, float c, float d); static float circEaseInOut(float t, float b, float c, float d);
static float elasticEaseIn(float t, float b, float c, float d, float a = 0, float p = 0); static float elasticEaseIn(float t, float b, float c, float d, float a = 0, float p = 0);
static float elasticEaseOut(float t, float b, float c, float d, float a = 0, float p = 0); static float elasticEaseOut(float t, float b, float c, float d, float a = 0, float p = 0);
static float elasticEaseInOut(float t, float b, float c, float d, float a = 0, float p = 0); static float elasticEaseInOut(float t, float b, float c, float d, float a = 0, float p = 0);
static float backEaseIn(float t, float b, float c, float d, float s = 0); static float backEaseIn(float t, float b, float c, float d, float s = 0);
static float backEaseOut(float t, float b, float c, float d, float s = 0); static float backEaseOut(float t, float b, float c, float d, float s = 0);
static float backEaseInOut(float t, float b, float c, float d, float s = 0); static float backEaseInOut(float t, float b, float c, float d, float s = 0);
static float bounceEaseIn(float t, float b, float c, float d); static float bounceEaseIn(float t, float b, float c, float d);
static float bounceEaseOut(float t, float b, float c, float d); static float bounceEaseOut(float t, float b, float c, float d);
static float bounceEaseInOut(float t, float b, float c, float d); static float bounceEaseInOut(float t, float b, float c, float d);
}; };
}}} // namespace cocos2d { namespace extension { namespace armature {
NS_CC_EXT_ARMATURE_END
#endif /*__CCTWEENFUNCTION_H__*/ #endif /*__CCTWEENFUNCTION_H__*/

20
extensions/CocoStudio/Armature/utils/CCUtilMath.cpp
View File

@ -25,22 +25,22 @@ THE SOFTWARE.
#include "CCUtilMath.h" #include "CCUtilMath.h"
namespace cocos2d { namespace extension { namespace armature { NS_CC_EXT_ARMATURE_BEGIN
bool isSpriteContainPoint(Sprite *_sprite, Point _point, Point &_outPoint) bool isSpriteContainPoint(Sprite *sprite, Point point, Point &outPoint)
{ {
_outPoint = _sprite->convertToNodeSpace(_point); outPoint = sprite->convertToNodeSpace(point);
Size _s = _sprite->getContentSize(); Size s = sprite->getContentSize();
Rect _r(0, 0, _s.width, _s.height); Rect r(0, 0, s.width, s.height);
return _r.containsPoint(_outPoint); return r.containsPoint(outPoint);
} }
bool isSpriteContainPoint(Sprite *_sprite, Point _point) bool isSpriteContainPoint(Sprite *sprite, Point point)
{ {
Point _p = Point(0, 0); Point p = Point(0, 0);
return isSpriteContainPoint(_sprite, _point, _p); return isSpriteContainPoint(sprite, point, p);
} }
@ -75,4 +75,4 @@ Point circleTo(float t, Point &center, float radius, float fromRadian, float rad
return p; return p;
} }
}}} // namespace cocos2d { namespace extension { namespace armature { NS_CC_EXT_ARMATURE_END

4
extensions/CocoStudio/Armature/utils/CCUtilMath.h
View File

@ -28,7 +28,7 @@ THE SOFTWARE.
#include "CCArmatureDefine.h" #include "CCArmatureDefine.h"
#include <math.h> #include <math.h>
namespace cocos2d { namespace extension { namespace armature { NS_CC_EXT_ARMATURE_BEGIN
#define CC_DOUBLE_PI (M_PI*2) #define CC_DOUBLE_PI (M_PI*2)
@ -50,6 +50,6 @@ Point bezierTo(float t, Point &point1, Point &point2, Point &point3, Point &poin
Point circleTo(float t, Point &center, float radius, float fromRadian, float radianDif); Point circleTo(float t, Point &center, float radius, float fromRadian, float radianDif);
}}} // namespace cocos2d { namespace extension { namespace armature { NS_CC_EXT_ARMATURE_END
#endif /*__CCUTILMATH_H__*/ #endif /*__CCUTILMATH_H__*/

2
extensions/CocoStudio/Reader/CCSSceneReader.cpp
View File

@ -249,7 +249,7 @@ NS_CC_EXT_BEGIN
} }
cocos2d::extension::armature::Armature *pAr = cocos2d::extension::armature::Armature::create(name); cocos2d::extension::armature::CCArmature *pAr = cocos2d::extension::armature::CCArmature::create(name);
ComRender *pRender = ComRender::create(pAr, "CCArmature"); ComRender *pRender = ComRender::create(pAr, "CCArmature");
if (pComName != NULL) if (pComName != NULL)
{ {

2
extensions/cocos-ext.h
View File

@ -59,9 +59,7 @@
#include "CocoStudio/Armature/display/CCDisplayManager.h" #include "CocoStudio/Armature/display/CCDisplayManager.h"
#include "CocoStudio/Armature/display/CCSkin.h" #include "CocoStudio/Armature/display/CCSkin.h"
#include "CocoStudio/Armature/physics/CCColliderDetector.h" #include "CocoStudio/Armature/physics/CCColliderDetector.h"
#include "CocoStudio/Armature/physics/CCPhysicsWorld.h"
#include "CocoStudio/Armature/utils/CCArmatureDataManager.h" #include "CocoStudio/Armature/utils/CCArmatureDataManager.h"
#include "CocoStudio/Armature/utils/CCConstValue.h"
#include "CocoStudio/Armature/utils/CCDataReaderHelper.h" #include "CocoStudio/Armature/utils/CCDataReaderHelper.h"
#include "CocoStudio/Armature/utils/CCTweenFunction.h" #include "CocoStudio/Armature/utils/CCTweenFunction.h"
#include "CocoStudio/Armature/utils/CCArmatureDataManager.h" #include "CocoStudio/Armature/utils/CCArmatureDataManager.h"

7
extensions/proj.win32/libExtensions.vcxproj
View File

@ -127,12 +127,10 @@
<ClCompile Include="..\CocoStudio\Armature\display\CCDecorativeDisplay.cpp" /> <ClCompile Include="..\CocoStudio\Armature\display\CCDecorativeDisplay.cpp" />
<ClCompile Include="..\CocoStudio\Armature\display\CCDisplayFactory.cpp" /> <ClCompile Include="..\CocoStudio\Armature\display\CCDisplayFactory.cpp" />
<ClCompile Include="..\CocoStudio\Armature\display\CCDisplayManager.cpp" /> <ClCompile Include="..\CocoStudio\Armature\display\CCDisplayManager.cpp" />
<ClCompile Include="..\CocoStudio\Armature\display\CCShaderNode.cpp" />
<ClCompile Include="..\CocoStudio\Armature\display\CCSkin.cpp" /> <ClCompile Include="..\CocoStudio\Armature\display\CCSkin.cpp" />
<ClCompile Include="..\CocoStudio\Armature\external_tool\GLES-Render.cpp" />
<ClCompile Include="..\CocoStudio\Armature\physics\CCColliderDetector.cpp" /> <ClCompile Include="..\CocoStudio\Armature\physics\CCColliderDetector.cpp" />
<ClCompile Include="..\CocoStudio\Armature\physics\CCPhysicsWorld.cpp" />
<ClCompile Include="..\CocoStudio\Armature\utils\CCArmatureDataManager.cpp" /> <ClCompile Include="..\CocoStudio\Armature\utils\CCArmatureDataManager.cpp" />
<ClCompile Include="..\CocoStudio\Armature\utils\CCArmatureDefine.cpp" />
<ClCompile Include="..\CocoStudio\Armature\utils\CCDataReaderHelper.cpp" /> <ClCompile Include="..\CocoStudio\Armature\utils\CCDataReaderHelper.cpp" />
<ClCompile Include="..\CocoStudio\Armature\utils\CCSpriteFrameCacheHelper.cpp" /> <ClCompile Include="..\CocoStudio\Armature\utils\CCSpriteFrameCacheHelper.cpp" />
<ClCompile Include="..\CocoStudio\Armature\utils\CCTransformHelp.cpp" /> <ClCompile Include="..\CocoStudio\Armature\utils\CCTransformHelp.cpp" />
@ -235,12 +233,9 @@
<ClInclude Include="..\CocoStudio\Armature\display\CCDecorativeDisplay.h" /> <ClInclude Include="..\CocoStudio\Armature\display\CCDecorativeDisplay.h" />
<ClInclude Include="..\CocoStudio\Armature\display\CCDisplayFactory.h" /> <ClInclude Include="..\CocoStudio\Armature\display\CCDisplayFactory.h" />
<ClInclude Include="..\CocoStudio\Armature\display\CCDisplayManager.h" /> <ClInclude Include="..\CocoStudio\Armature\display\CCDisplayManager.h" />
<ClInclude Include="..\CocoStudio\Armature\display\CCShaderNode.h" />
<ClInclude Include="..\CocoStudio\Armature\display\CCSkin.h" /> <ClInclude Include="..\CocoStudio\Armature\display\CCSkin.h" />
<ClInclude Include="..\CocoStudio\Armature\external_tool\GLES-Render.h" />
<ClInclude Include="..\CocoStudio\Armature\external_tool\sigslot.h" /> <ClInclude Include="..\CocoStudio\Armature\external_tool\sigslot.h" />
<ClInclude Include="..\CocoStudio\Armature\physics\CCColliderDetector.h" /> <ClInclude Include="..\CocoStudio\Armature\physics\CCColliderDetector.h" />
<ClInclude Include="..\CocoStudio\Armature\physics\CCPhysicsWorld.h" />
<ClInclude Include="..\CocoStudio\Armature\utils\CCArmatureDataManager.h" /> <ClInclude Include="..\CocoStudio\Armature\utils\CCArmatureDataManager.h" />
<ClInclude Include="..\CocoStudio\Armature\utils\CCArmatureDefine.h" /> <ClInclude Include="..\CocoStudio\Armature\utils\CCArmatureDefine.h" />
<ClInclude Include="..\CocoStudio\Armature\utils\CCConstValue.h" /> <ClInclude Include="..\CocoStudio\Armature\utils\CCConstValue.h" />

19
extensions/proj.win32/libExtensions.vcxproj.filters
View File

@ -316,18 +316,12 @@
<ClCompile Include="..\CocoStudio\Armature\display\CCDisplayManager.cpp"> <ClCompile Include="..\CocoStudio\Armature\display\CCDisplayManager.cpp">
<Filter>CocoStudio\Armature\display</Filter> <Filter>CocoStudio\Armature\display</Filter>
</ClCompile> </ClCompile>
<ClCompile Include="..\CocoStudio\Armature\display\CCShaderNode.cpp">
<Filter>CocoStudio\Armature\display</Filter>
</ClCompile>
<ClCompile Include="..\CocoStudio\Armature\display\CCSkin.cpp"> <ClCompile Include="..\CocoStudio\Armature\display\CCSkin.cpp">
<Filter>CocoStudio\Armature\display</Filter> <Filter>CocoStudio\Armature\display</Filter>
</ClCompile> </ClCompile>
<ClCompile Include="..\CocoStudio\Armature\physics\CCColliderDetector.cpp"> <ClCompile Include="..\CocoStudio\Armature\physics\CCColliderDetector.cpp">
<Filter>CocoStudio\Armature\physics</Filter> <Filter>CocoStudio\Armature\physics</Filter>
</ClCompile> </ClCompile>
<ClCompile Include="..\CocoStudio\Armature\physics\CCPhysicsWorld.cpp">
<Filter>CocoStudio\Armature\physics</Filter>
</ClCompile>
<ClCompile Include="..\CocoStudio\Armature\utils\CCArmatureDataManager.cpp"> <ClCompile Include="..\CocoStudio\Armature\utils\CCArmatureDataManager.cpp">
<Filter>CocoStudio\Armature\utils</Filter> <Filter>CocoStudio\Armature\utils</Filter>
</ClCompile> </ClCompile>
@ -373,8 +367,8 @@
<ClCompile Include="..\CocoStudio\Components\CCComRender.cpp"> <ClCompile Include="..\CocoStudio\Components\CCComRender.cpp">
<Filter>CocoStudio\Components</Filter> <Filter>CocoStudio\Components</Filter>
</ClCompile> </ClCompile>
<ClCompile Include="..\CocoStudio\Armature\external_tool\GLES-Render.cpp"> <ClCompile Include="..\CocoStudio\Armature\utils\CCArmatureDefine.cpp">
<Filter>CocoStudio\Armature\external_tool</Filter> <Filter>CocoStudio\Armature\utils</Filter>
</ClCompile> </ClCompile>
</ItemGroup> </ItemGroup>
<ItemGroup> <ItemGroup>
@ -653,9 +647,6 @@
<ClInclude Include="..\CocoStudio\Armature\display\CCDisplayManager.h"> <ClInclude Include="..\CocoStudio\Armature\display\CCDisplayManager.h">
<Filter>CocoStudio\Armature\display</Filter> <Filter>CocoStudio\Armature\display</Filter>
</ClInclude> </ClInclude>
<ClInclude Include="..\CocoStudio\Armature\display\CCShaderNode.h">
<Filter>CocoStudio\Armature\display</Filter>
</ClInclude>
<ClInclude Include="..\CocoStudio\Armature\display\CCSkin.h"> <ClInclude Include="..\CocoStudio\Armature\display\CCSkin.h">
<Filter>CocoStudio\Armature\display</Filter> <Filter>CocoStudio\Armature\display</Filter>
</ClInclude> </ClInclude>
@ -665,9 +656,6 @@
<ClInclude Include="..\CocoStudio\Armature\physics\CCColliderDetector.h"> <ClInclude Include="..\CocoStudio\Armature\physics\CCColliderDetector.h">
<Filter>CocoStudio\Armature\physics</Filter> <Filter>CocoStudio\Armature\physics</Filter>
</ClInclude> </ClInclude>
<ClInclude Include="..\CocoStudio\Armature\physics\CCPhysicsWorld.h">
<Filter>CocoStudio\Armature\physics</Filter>
</ClInclude>
<ClInclude Include="..\CocoStudio\Armature\utils\CCArmatureDataManager.h"> <ClInclude Include="..\CocoStudio\Armature\utils\CCArmatureDataManager.h">
<Filter>CocoStudio\Armature\utils</Filter> <Filter>CocoStudio\Armature\utils</Filter>
</ClInclude> </ClInclude>
@ -740,9 +728,6 @@
<ClInclude Include="..\CocoStudio\Components\CCComRender.h"> <ClInclude Include="..\CocoStudio\Components\CCComRender.h">
<Filter>CocoStudio\Components</Filter> <Filter>CocoStudio\Components</Filter>
</ClInclude> </ClInclude>
<ClInclude Include="..\CocoStudio\Armature\external_tool\GLES-Render.h">
<Filter>CocoStudio\Armature\external_tool</Filter>
</ClInclude>
</ItemGroup> </ItemGroup>
<ItemGroup> <ItemGroup>
<None Include="..\CocoStudio\Json\lib_json\json_internalarray.inl"> <None Include="..\CocoStudio\Json\lib_json\json_internalarray.inl">

2
extensions/spine/CCSkeleton.cpp
View File

@ -59,7 +59,7 @@ void CCSkeleton::initialize () {
blendFunc = BlendFunc::ALPHA_PREMULTIPLIED; blendFunc = BlendFunc::ALPHA_PREMULTIPLIED;
setOpacityModifyRGB(true); setOpacityModifyRGB(true);
setShaderProgram(ShaderCache::getInstance()->programForKey(GLProgram::SHADER_NAME_POSITION_TEXTURE_COLOR)); setShaderProgram(ShaderCache::getInstance()->getProgram(GLProgram::SHADER_NAME_POSITION_TEXTURE_COLOR));
scheduleUpdate(); scheduleUpdate();
} }

2
samples/Cpp/TestCpp/Classes/AppDelegate.cpp
View File

@ -15,7 +15,7 @@ AppDelegate::AppDelegate()
AppDelegate::~AppDelegate() AppDelegate::~AppDelegate()
{ {
// SimpleAudioEngine::end(); // SimpleAudioEngine::end();
cocos2d::extension::armature::ArmatureDataManager::purgeArmatureSystem(); cocos2d::extension::armature::CCArmatureDataManager::purge();
} }
bool AppDelegate::applicationDidFinishLaunching() bool AppDelegate::applicationDidFinishLaunching()

1106
samples/Cpp/TestCpp/Classes/ExtensionsTest/CocoStudioArmatureTest/ArmatureScene.cpp
View File

File diff suppressed because it is too large Load Diff

128
samples/Cpp/TestCpp/Classes/ExtensionsTest/CocoStudioArmatureTest/ArmatureScene.h
View File

@ -6,6 +6,13 @@
#include "../../VisibleRect.h" #include "../../VisibleRect.h"
#include "../../testBasic.h" #include "../../testBasic.h"
#if ENABLE_PHYSICS_BOX2D_DETECT
#include "../../Box2DTestBed/GLES-Render.h"
#include "Box2D/Box2D.h"
#elif ENABLE_PHYSICS_CHIPMUNK_DETECT
#include "chipmunk.h"
#endif
class ArmatureTestScene : public TestScene class ArmatureTestScene : public TestScene
{ {
public: public:
@ -14,19 +21,19 @@ public:
virtual void runThisTest(); virtual void runThisTest();
// The CallBack for back to the main menu scene // The CallBack for back to the main menu scene
virtual void MainMenuCallback(Object* sender); virtual void MainMenuCallback(Object* pSender);
}; };
enum { enum {
TEST_COCOSTUDIO_WITH_SKELETON = 0, TEST_ASYNCHRONOUS_LOADING = 0,
TEST_COCOSTUDIO_WITHOUT_SKELETON, TEST_COCOSTUDIO_WITH_SKELETON,
TEST_DRAGON_BONES_2_0, TEST_DRAGON_BONES_2_0,
TEST_PERFORMANCE, TEST_PERFORMANCE,
TEST_CHANGE_ZORDER, TEST_CHANGE_ZORDER,
TEST_ANIMATION_EVENT, TEST_ANIMATION_EVENT,
TEST_PARTICLE_DISPLAY, TEST_PARTICLE_DISPLAY,
TEST_USE_DIFFERENT_PICTURE, TEST_USE_DIFFERENT_PICTURE,
TEST_BOX2D_DETECTOR, TEST_BCOLLIDER_DETECTOR,
TEST_BOUDINGBOX, TEST_BOUDINGBOX,
TEST_ANCHORPOINT, TEST_ANCHORPOINT,
TEST_ARMATURE_NESTING, TEST_ARMATURE_NESTING,
@ -43,32 +50,39 @@ public:
virtual std::string title(); virtual std::string title();
virtual std::string subtitle(); virtual std::string subtitle();
void restartCallback(Object* sender); virtual void restartCallback(Object* pSender);
void nextCallback(Object* sender); virtual void nextCallback(Object* pSender);
void backCallback(Object* sender); virtual void backCallback(Object* pSender);
virtual void draw(); virtual void draw();
protected:
MenuItemImage *restartItem;
MenuItemImage *nextItem;
MenuItemImage *backItem;
}; };
class TestAsynchronousLoading : public ArmatureTestLayer
class TestDragonBones20 : public ArmatureTestLayer
{ {
public: public:
virtual void onEnter(); virtual void onEnter();
virtual std::string title(); virtual std::string title();
virtual std::string subtitle();
void dataLoaded(float percent);
}; };
class TestCSWithSkeleton : public ArmatureTestLayer class TestCSWithSkeleton : public ArmatureTestLayer
{ {
virtual void onEnter(); virtual void onEnter();
virtual std::string title(); virtual std::string title();
}; };
class TestCSWithoutSkeleton : public ArmatureTestLayer
class TestDragonBones20 : public ArmatureTestLayer
{ {
public:
virtual void onEnter(); virtual void onEnter();
virtual std::string title(); virtual std::string title();
}; };
@ -82,7 +96,7 @@ public:
virtual void onEnter(); virtual void onEnter();
virtual std::string title(); virtual std::string title();
virtual std::string subtitle(); virtual std::string subtitle();
virtual void addArmature(cocos2d::extension::armature::Armature *armature); virtual void addArmature(cocos2d::extension::armature::CCArmature *armature);
void update(float delta); void update(float delta);
int armatureCount; int armatureCount;
@ -104,57 +118,116 @@ class TestChangeZorder : public ArmatureTestLayer
}; };
class TestAnimationEvent : public ArmatureTestLayer, public sigslot::has_slots<> class TestAnimationEvent : public ArmatureTestLayer
{ {
public: public:
virtual void onEnter(); virtual void onEnter();
virtual std::string title(); virtual std::string title();
void animationEvent(cocos2d::extension::armature::Armature *armature, cocos2d::extension::armature::MovementEventType movementType, const char *movementID); void animationEvent(cocos2d::extension::armature::CCArmature *armature, cocos2d::extension::armature::MovementEventType movementType, const char *movementID);
void callback1(); void callback1();
void callback2(); void callback2();
cocos2d::extension::armature::Armature *armature; cocos2d::extension::armature::CCArmature *armature;
}; };
class TestUseMutiplePicture : public ArmatureTestLayer class TestUseMutiplePicture : public ArmatureTestLayer
{ {
virtual void onEnter(); virtual void onEnter();
virtual void onExit();
virtual std::string title(); virtual std::string title();
virtual std::string subtitle(); virtual std::string subtitle();
virtual bool ccTouchBegan(Touch *touch, Event *event); virtual bool ccTouchBegan(Touch *pTouch, Event *pEvent);
virtual void registerWithTouchDispatcher(); virtual void registerWithTouchDispatcher();
int displayIndex; int displayIndex;
cocos2d::extension::armature::Armature *armature; cocos2d::extension::armature::CCArmature *armature;
}; };
class TestParticleDisplay : public ArmatureTestLayer class TestParticleDisplay : public ArmatureTestLayer
{ {
virtual void onEnter(); virtual void onEnter();
virtual void onExit();
virtual std::string title(); virtual std::string title();
virtual std::string subtitle(); virtual std::string subtitle();
virtual bool ccTouchBegan(Touch *touch, Event *event); virtual bool ccTouchBegan(Touch *pTouch, Event *pEvent);
virtual void registerWithTouchDispatcher(); virtual void registerWithTouchDispatcher();
int animationID; int animationID;
cocos2d::extension::armature::Armature *armature; cocos2d::extension::armature::CCArmature *armature;
}; };
class TestBox2DDetector : public ArmatureTestLayer, public sigslot::has_slots<>
#if ENABLE_PHYSICS_BOX2D_DETECT
class ContactListener;
class TestColliderDetector : public ArmatureTestLayer
{ {
public: public:
~TestColliderDetector();
virtual void onEnter(); virtual void onEnter();
virtual void onExit();
virtual std::string title(); virtual std::string title();
virtual void draw(); virtual void draw();
virtual void update(float delta); virtual void update(float delta);
void onHit(cocos2d::extension::armature::Bone *bone, cocos2d::extension::armature::Bone *bone2); void onFrameEvent(cocos2d::extension::armature::CCBone *bone, const char *evt, int originFrameIndex, int currentFrameIndex);
cocos2d::extension::armature::Armature *armature; void initWorld();
cocos2d::extension::armature::Armature *armature2;
cocos2d::extension::armature::CCArmature *armature;
cocos2d::extension::armature::CCArmature *armature2;
cocos2d::extension::PhysicsSprite *bullet;
b2World *world;
ContactListener *listener;
GLESDebugDraw *debugDraw;
}; };
#elif ENABLE_PHYSICS_CHIPMUNK_DETECT
class TestColliderDetector : public ArmatureTestLayer
{
public:
~TestColliderDetector();
virtual void onEnter();
virtual void onExit();
virtual std::string title();
virtual void update(float delta);
void onFrameEvent(cocos2d::extension::armature::CCBone *bone, const char *evt, int originFrameIndex, int currentFrameIndex);
void initWorld();
cocos2d::extension::armature::CCArmature *armature;
cocos2d::extension::armature::CCArmature *armature2;
cocos2d::extension::PhysicsSprite *bullet;
cpSpace *space;
static int beginHit(cpArbiter *arb, cpSpace *space, void *unused);
static void endHit(cpArbiter *arb, cpSpace *space, void *unused);
void destroyCPBody(cpBody *body);
};
#endif
class TestBoundingBox : public ArmatureTestLayer class TestBoundingBox : public ArmatureTestLayer
{ {
public: public:
@ -162,7 +235,7 @@ public:
virtual std::string title(); virtual std::string title();
virtual void draw(); virtual void draw();
cocos2d::extension::armature::Armature *armature; cocos2d::extension::armature::CCArmature *armature;
Rect rect; Rect rect;
}; };
@ -177,11 +250,12 @@ class TestArmatureNesting : public ArmatureTestLayer
{ {
public: public:
virtual void onEnter(); virtual void onEnter();
virtual void onExit();
virtual std::string title(); virtual std::string title();
virtual bool ccTouchBegan(Touch *touch, Event *event); virtual bool ccTouchBegan(Touch *pTouch, Event *pEvent);
virtual void registerWithTouchDispatcher(); virtual void registerWithTouchDispatcher();
cocos2d::extension::armature::Armature *armature; cocos2d::extension::armature::CCArmature *armature;
int weaponIndex; int weaponIndex;
}; };
#endif // __HELLOWORLD_SCENE_H__ #endif // __HELLOWORLD_SCENE_H__

4
samples/Cpp/TestCpp/Classes/ExtensionsTest/CocoStudioSceneTest/SceneEditorTest.cpp
View File

@ -95,14 +95,14 @@ void SceneEditorTestLayer::toExtensionsMainLayer(cocos2d::Object *sender)
} }
cocos2d::extension::armature::Armature* SceneEditorTestLayer::getFish(int nTag, const char *pszName) cocos2d::extension::armature::CCArmature* SceneEditorTestLayer::getFish(int nTag, const char *pszName)
{ {
if (_curNode == NULL) if (_curNode == NULL)
{ {
return NULL; return NULL;
} }
ComRender *pFishRender = (ComRender*)(_curNode->getChildByTag(nTag)->getComponent(pszName)); ComRender *pFishRender = (ComRender*)(_curNode->getChildByTag(nTag)->getComponent(pszName));
return (cocos2d::extension::armature::Armature *)(pFishRender->getNode()); return (cocos2d::extension::armature::CCArmature *)(pFishRender->getNode());
} }
void runSceneEditorTestLayer() void runSceneEditorTestLayer()

2
samples/Cpp/TestCpp/Classes/ExtensionsTest/CocoStudioSceneTest/SceneEditorTest.h
View File

@ -29,7 +29,7 @@ public:
void toExtensionsMainLayer(cocos2d::Object *sender); void toExtensionsMainLayer(cocos2d::Object *sender);
//get Fish based on Tag and name of Compoent //get Fish based on Tag and name of Compoent
cocos2d::extension::armature::Armature* getFish(int nTag, const char *pszName); cocos2d::extension::armature::CCArmature* getFish(int nTag, const char *pszName);
private: private:
cocos2d::Node *_curNode; cocos2d::Node *_curNode;

1
samples/Cpp/TestCpp/Resources/armature/Cowboy.ExportJson.REMOVED.git-id Normal file
View File

@ -0,0 +1 @@
434a36b3e7fa9c849986cf6128b7d4402a382eb7

2
samples/Cpp/TestCpp/Resources/armature/Cowboy0.png.REMOVED.git-id
View File

@ -1 +1 @@
db891b84393bfe4b806f46bbf9c2879fa9438608 2b61d3b005b4076c5ff22a78a00822c0f0dc0875

581
samples/Cpp/TestCpp/Resources/armature/Dragon.xml
View File

@ -1,347 +1,236 @@
<skeleton name="Dragon" frameRate="24" version="2.1"> <skeleton name="Dragon" frameRate="24" version="2.0">
<armatures> <armatures>
<armature name="Dragon"> <armature name="Dragon">
<b name="tailTip" parent="tail" x="169.9" y="-106.15" kX="30" kY="30" cX="1" cY="1" pX="23.25" pY="93.05" z="0"> <b name="tailTip" x="169.9" y="-106.15" kX="30" kY="30" cX="1" cY="1" pX="23" pY="93" z="0">
<d name="parts-tailTip" pX="0" pY="0"/> <d name="parts-tailTip"/>
</b> </b>
<b name="armUpperL" parent="body" x="-43.95" y="-159.15" kX="-60" kY="-60" cX="1" cY="1" pX="0" pY="0" z="1"> <b name="armUpperL" x="-43.95" y="-159.15" kX="-60" kY="-60" cX="1" cY="1" pX="0" pY="0" z="1">
<d name="parts-armUpperL" pX="41" pY="16"/> <d name="parts-armUpperL"/>
</b> </b>
<b name="armL" parent="armUpperL" x="-44.05" y="-125.75" kX="-142.73" kY="-142.73" cX="1" cY="1" pX="15.35" pY="33" z="2"> <b name="armL" x="-44.05" y="-125.75" kX="-142.73" kY="-142.73" cX="1" cY="1" pX="15" pY="33" z="2">
<d name="parts-armL" pX="0" pY="0"/> <d name="parts-armL"/>
</b> </b>
<b name="handL" parent="armL" x="-60" y="-96.5" kX="-90" kY="-90" cX="1" cY="1" pX="38.9" pY="28.45" z="3"> <b name="handL" x="-60" y="-96.5" kX="-90" kY="-90" cX="1" cY="1" pX="39" pY="28" z="3">
<d name="parts-handL" pX="0" pY="0"/> <d name="parts-handL"/>
</b> </b>
<b name="legL" parent="body" x="-21.05" y="-88.1" kX="-36.21" kY="-36.21" cX="1" cY="1" pX="91.6" pY="14.7" z="4"> <b name="legL" x="-21.05" y="-88.1" kX="-36.21" kY="-36.21" cX="1" cY="1" pX="92" pY="15" z="4">
<d name="parts-legL" pX="0" pY="0"/> <d name="parts-legL"/>
</b> </b>
<b name="body" x="5.9" y="-126.1" kX="0" kY="0" cX="1" cY="1" pX="58.65" pY="86.55" z="5"> <b name="body" x="5.9" y="-126.1" kX="0" kY="0" cX="1" cY="1" pX="59" pY="87" z="5">
<d name="parts-body" pX="0" pY="0"/> <d name="parts-body"/>
</b> </b>
<b name="hair" parent="head" x="44.4" y="-252.1" kX="0" kY="0" cX="1" cY="1" pX="31" pY="70.3" z="6"> <b name="hair" x="44.4" y="-252.1" kX="0" kY="0" cX="1" cY="1" pX="31" pY="70" z="6">
<d name="parts-hair" pX="0" pY="0"/> <d name="parts-hair"/>
</b> </b>
<b name="head" parent="body" x="111.35" y="-50.2" kX="0" kY="0" cX="1" cY="1" pX="115.4" pY="156.9" z="7"> <b name="head" x="111.35" y="-50.2" kX="0" kY="0" cX="1" cY="1" pX="115" pY="157" z="7">
<d name="parts-head" pX="79.5" pY="160"/> <d name="parts-head"/>
</b> </b>
<b name="eyeL" parent="head" x="-42.85" y="-281.45" kX="0" kY="0" cX="1" cY="1" pX="6.85" pY="11.3" z="8"> <b name="eyeL" x="-42.85" y="-281.45" kX="0" kY="0" cX="1" cY="1" pX="7" pY="11" z="8">
<d name="parts-eyeL" pX="0" pY="0"/> <d name="parts-eyeL"/>
</b> </b>
<b name="eyeR" parent="head" x="4.1" y="-263.6" kX="0" kY="0" cX="1" cY="1" pX="9.1" pY="14.4" z="9"> <b name="eyeR" x="4.1" y="-263.6" kX="0" kY="0" cX="1" cY="1" pX="9" pY="14" z="9">
<d name="parts-eyeR" pX="8" pY="15"/> <d name="parts-eyeR"/>
</b> </b>
<b name="tail" parent="body" x="45.9" y="-70.8" kX="30" kY="30" cX="1" cY="1" pX="11.5" pY="176.35" z="10"> <b name="tail" x="45.9" y="-70.8" kX="30" kY="30" cX="1" cY="1" pX="12" pY="176" z="10">
<d name="parts-tail" pX="0" pY="-63.8"/> <d name="parts-tail"/>
</b> </b>
<b name="legR" parent="body" x="33.4" y="-80.5" kX="15" kY="15" cX="1" cY="1" pX="44.9" pY="16.6" z="11"> <b name="legR" x="33.4" y="-80.5" kX="15" kY="15" cX="1" cY="1" pX="45" pY="17" z="11">
<d name="parts-legR" pX="0" pY="0"/> <d name="parts-legR"/>
</b> </b>
<b name="armUpperR" parent="body" x="18.05" y="-167.6" kX="78.95" kY="78.95" cX="1" cY="1" pX="0" pY="0" z="12"> <b name="armUpperR" x="18.05" y="-167.6" kX="78.95" kY="78.95" cX="1" cY="1" pX="0" pY="0" z="12">
<d name="parts-armUpperR" pX="12" pY="28"/> <d name="parts-armUpperR"/>
</b> </b>
<b name="armR" parent="armUpperR" x="47.1" y="-104.6" kX="15" kY="15" cX="1" cY="1" pX="12.3" pY="12.3" z="13"> <b name="armR" x="47.1" y="-104.6" kX="15" kY="15" cX="1" cY="1" pX="12" pY="12" z="13">
<d name="parts-armR" pX="0" pY="0"/> <d name="parts-armR"/>
</b> </b>
<b name="handR" parent="armR" x="42.7" y="-83.35" kX="30" kY="30" cX="1" cY="1" pX="26.65" pY="2.9" z="14"> <b name="handR" x="42.7" y="-83.35" kX="30" kY="30" cX="1" cY="1" pX="27" pY="3" z="14">
<d name="parts-handR" pX="0" pY="0"/> <d name="parts-handR"/>
</b> </b>
<b name="beardL" parent="head" x="-14" y="-217.35" kX="0" kY="0" cX="1" cY="1" pX="55.95" pY="4.75" z="15"> <b name="beardL" x="-14" y="-217.35" kX="0" kY="0" cX="1" cY="1" pX="56" pY="5" z="15">
<d name="parts-beardL" pX="54" pY="4"/> <d name="parts-beardL"/>
</b> </b>
<b name="beardR" parent="head" x="-19.8" y="-221.55" kX="0" kY="0" cX="1" cY="1" pX="3.2" pY="8.9" z="16"> <b name="beardR" x="-19.8" y="-221.55" kX="0" kY="0" cX="1" cY="1" pX="3" pY="9" z="16">
<d name="parts-beardR" pX="0" pY="0"/> <d name="parts-beardR"/>
</b> </b>
</armature> </armature>
</armatures> </armatures>
<animations> <animations>
<animation name="Dragon"> <animation name="Dragon">
<mov name="stand" dr="7" to="6" drTW="30" lp="1" twE="0"> <mov name="stand" dr="7" to="6" drTW="30" lp="1" twE="0">
<b name="tailTip" sc="1" dl="0"> <b name="tailTip" sc="1" dl="0">
<f x="169.9" y="-106.15" cocos2d_x="196.35" cocos2d_y="-198.4" kX="30" kY="30" cX="1" cY="1" pX="23.25" pY="93.05" z="0" dI="0" dr="2"/> <f x="169.9" y="-106.15" cocos2d_x="196.35" cocos2d_y="-198.4" kX="30" kY="30" cX="1" cY="1" pX="23" pY="93" z="0" dI="0" dr="2"/>
<f x="174.9" y="-97.15" cocos2d_x="188.8" cocos2d_y="-192.1" kX="22.31" kY="22.31" cX="1" cY="1" pX="23.2" pY="93.1" z="0" dI="0" dr="3"/> <f x="174.9" y="-97.15" cocos2d_x="188.8" cocos2d_y="-192.1" kX="22.31" kY="22.31" cX="1" cY="1" pX="23" pY="93" z="0" dI="0" dr="3"/>
<f x="169.9" y="-106.15" cocos2d_x="196.35" cocos2d_y="-198.4" kX="30" kY="30" cX="1" cY="1" pX="23.25" pY="93.05" z="0" dI="0" dr="2"/> <f x="169.9" y="-106.15" cocos2d_x="196.35" cocos2d_y="-198.4" kX="30" kY="30" cX="1" cY="1" pX="23" pY="93" z="0" dI="0" dr="2"/>
</b> </b>
<b name="armUpperL" sc="1" dl="0"> <b name="armUpperL" sc="1" dl="0">
<f x="-43.95" y="-159.15" cocos2d_x="-43.95" cocos2d_y="-159.15" kX="-60" kY="-60" cX="1" cY="1" pX="0" pY="0" z="1" dI="0" dr="7"/> <f x="-43.95" y="-159.15" cocos2d_x="-43.95" cocos2d_y="-159.15" kX="-60" kY="-60" cX="1" cY="1" pX="0" pY="0" z="1" dI="0" dr="7"/>
</b> </b>
<b name="armL" sc="1" dl="0"> <b name="armL" sc="1" dl="0">
<f x="-44.05" y="-125.75" cocos2d_x="-51.85" cocos2d_y="-90.2" kX="-142.73" kY="-142.73" cX="1" cY="1" pX="15.35" pY="33" z="2" dI="0" dr="7"/> <f x="-44.05" y="-125.75" cocos2d_x="-51.85" cocos2d_y="-90.2" kX="-142.73" kY="-142.73" cX="1" cY="1" pX="15" pY="33" z="2" dI="0" dr="7"/>
</b> </b>
<b name="handL" sc="1" dl="0"> <b name="handL" sc="1" dl="0">
<f x="-60" y="-96.5" cocos2d_x="-88.45" cocos2d_y="-57.6" kX="-90" kY="-90" cX="1" cY="1" pX="38.9" pY="28.45" z="3" dI="0" dr="7"/> <f x="-60" y="-96.5" cocos2d_x="-88.45" cocos2d_y="-57.6" kX="-90" kY="-90" cX="1" cY="1" pX="39" pY="28" z="3" dI="0" dr="7"/>
</b> </b>
<b name="legL" sc="1" dl="0"> <b name="legL" sc="1" dl="0">
<f x="-21.05" y="-88.1" cocos2d_x="-103.7" cocos2d_y="-45.85" kX="-36.21" kY="-36.21" cX="1" cY="1" pX="91.6" pY="14.7" z="4" dI="0" dr="7"/> <f x="-21.05" y="-88.1" cocos2d_x="-103.7" cocos2d_y="-45.85" kX="-36.21" kY="-36.21" cX="1" cY="1" pX="92" pY="15" z="4" dI="0" dr="7"/>
</b> </b>
<b name="body" sc="1" dl="0"> <b name="body" sc="1" dl="0">
<f x="5.9" y="-126.1" cocos2d_x="-52.75" cocos2d_y="-212.65" kX="0" kY="0" cX="1" cY="1" pX="58.65" pY="86.55" z="5" dI="0" dr="2"/> <f x="5.9" y="-126.1" cocos2d_x="-52.75" cocos2d_y="-212.65" kX="0" kY="0" cX="1" cY="1" pX="59" pY="87" z="5" dI="0" dr="2"/>
<f x="5.9" y="-126.1" cocos2d_x="-52.75" cocos2d_y="-212.65" kX="0" kY="0" cX="1" cY="1" pX="58.65" pY="86.55" z="5" dI="0" dr="3"/> <f x="5.9" y="-126.1" cocos2d_x="-52.75" cocos2d_y="-212.65" kX="0" kY="0" cX="1" cY="1" pX="59" pY="87" z="5" dI="0" dr="3"/>
<f x="5.9" y="-126.1" cocos2d_x="-52.75" cocos2d_y="-212.65" kX="0" kY="0" cX="1" cY="1" pX="58.65" pY="86.55" z="5" dI="0" dr="2"/> <f x="5.9" y="-126.1" cocos2d_x="-52.75" cocos2d_y="-212.65" kX="0" kY="0" cX="1" cY="1" pX="59" pY="87" z="5" dI="0" dr="2"/>
</b> </b>
<b name="hair" sc="1" dl="0"> <b name="hair" sc="1" dl="0">
<f x="44.4" y="-252.1" cocos2d_x="13.4" cocos2d_y="-322.4" kX="0" kY="0" cX="1" cY="1" pX="31" pY="70.3" z="6" dI="0" dr="3"/> <f x="44.4" y="-252.1" cocos2d_x="13.4" cocos2d_y="-322.4" kX="0" kY="0" cX="1" cY="1" pX="31" pY="70" z="6" dI="0" dr="3"/>
<f x="45.4" y="-254.1" cocos2d_x="14.4" cocos2d_y="-324.4" kX="0" kY="0" cX="1" cY="1" pX="31" pY="70.3" z="6" dI="0" dr="2"/> <f x="45.4" y="-254.1" cocos2d_x="14.4" cocos2d_y="-324.4" kX="0" kY="0" cX="1" cY="1" pX="31" pY="70" z="6" dI="0" dr="2"/>
<f x="44.4" y="-252.1" cocos2d_x="13.4" cocos2d_y="-322.4" kX="0" kY="0" cX="1" cY="1" pX="31" pY="70.3" z="6" dI="0" dr="2"/> <f x="44.4" y="-252.1" cocos2d_x="13.4" cocos2d_y="-322.4" kX="0" kY="0" cX="1" cY="1" pX="31" pY="70" z="6" dI="0" dr="2"/>
</b> </b>
<b name="head" sc="1" dl="0"> <b name="head" sc="1" dl="0">
<f x="111.35" y="-50.2" cocos2d_x="-4.05" cocos2d_y="-207.1" kX="0" kY="0" cX="1" cY="1" pX="115.4" pY="156.9" z="7" dI="0" dr="7"/> <f x="111.35" y="-50.2" cocos2d_x="-4.05" cocos2d_y="-207.1" kX="0" kY="0" cX="1" cY="1" pX="115" pY="157" z="7" dI="0" dr="7"/>
</b> </b>
<b name="eyeL" sc="1" dl="0"> <b name="eyeL" sc="1" dl="0">
<f x="-42.85" y="-281.45" cocos2d_x="-49.7" cocos2d_y="-292.75" kX="0" kY="0" cX="1" cY="1" pX="6.85" pY="11.3" z="8" dI="0" dr="2"/> <f x="-42.85" y="-281.45" cocos2d_x="-49.7" cocos2d_y="-292.75" kX="0" kY="0" cX="1" cY="1" pX="7" pY="11" z="8" dI="0" dr="2"/>
<f x="-42.85" y="-283.45" cocos2d_x="-49.7" cocos2d_y="-294.75" kX="0" kY="0" cX="1" cY="1" pX="6.85" pY="11.3" z="8" dI="0" dr="3"/> <f x="-42.85" y="-283.45" cocos2d_x="-49.7" cocos2d_y="-294.75" kX="0" kY="0" cX="1" cY="1" pX="7" pY="11" z="8" dI="0" dr="3"/>
<f x="-42.85" y="-281.45" cocos2d_x="-49.7" cocos2d_y="-292.75" kX="0" kY="0" cX="1" cY="1" pX="6.85" pY="11.3" z="8" dI="0" dr="2"/> <f x="-42.85" y="-281.45" cocos2d_x="-49.7" cocos2d_y="-292.75" kX="0" kY="0" cX="1" cY="1" pX="7" pY="11" z="8" dI="0" dr="2"/>
</b> </b>
<b name="eyeR" sc="1" dl="0"> <b name="eyeR" sc="1" dl="0">
<f x="4.1" y="-263.6" cocos2d_x="-5" cocos2d_y="-278" kX="0" kY="0" cX="1" cY="1" pX="9.1" pY="14.4" z="9" dI="0" dr="2"/> <f x="4.1" y="-263.6" cocos2d_x="-5" cocos2d_y="-278" kX="0" kY="0" cX="1" cY="1" pX="9" pY="14" z="9" dI="0" dr="2"/>
<f x="4.1" y="-264.6" cocos2d_x="-5" cocos2d_y="-279" kX="0" kY="0" cX="1" cY="1" pX="9.1" pY="14.4" z="9" dI="0" dr="3"/> <f x="4.1" y="-264.6" cocos2d_x="-5" cocos2d_y="-279" kX="0" kY="0" cX="1" cY="1" pX="9" pY="14" z="9" dI="0" dr="3"/>
<f x="4.1" y="-263.6" cocos2d_x="-5" cocos2d_y="-278" kX="0" kY="0" cX="1" cY="1" pX="9.1" pY="14.4" z="9" dI="0" dr="2"/> <f x="4.1" y="-263.6" cocos2d_x="-5" cocos2d_y="-278" kX="0" kY="0" cX="1" cY="1" pX="9" pY="14" z="9" dI="0" dr="2"/>
</b> </b>
<b name="tail" sc="1" dl="0"> <b name="tail" sc="1" dl="0">
<f x="45.9" y="-70.8" cocos2d_x="124.1" cocos2d_y="-229.25" kX="30" kY="30" cX="1" cY="1" pX="11.5" pY="176.35" z="10" dI="0" dr="2"/> <f x="45.9" y="-70.8" cocos2d_x="124.1" cocos2d_y="-229.25" kX="30" kY="30" cX="1" cY="1" pX="12" pY="176" z="10" dI="0" dr="2"/>
<f x="43.9" y="-70.8" cocos2d_x="135.5" cocos2d_y="-221.95" kX="34.95" kY="34.95" cX="1" cY="1" pX="11.55" pY="176.35" z="10" dI="0" dr="3"/> <f x="43.9" y="-70.8" cocos2d_x="135.5" cocos2d_y="-221.95" kX="34.95" kY="34.95" cX="1" cY="1" pX="12" pY="176" z="10" dI="0" dr="3"/>
<f x="45.9" y="-70.8" cocos2d_x="124.1" cocos2d_y="-229.25" kX="30" kY="30" cX="1" cY="1" pX="11.5" pY="176.35" z="10" dI="0" dr="2"/> <f x="45.9" y="-70.8" cocos2d_x="124.1" cocos2d_y="-229.25" kX="30" kY="30" cX="1" cY="1" pX="12" pY="176" z="10" dI="0" dr="2"/>
</b> </b>
<b name="legR" sc="1" dl="0"> <b name="legR" sc="1" dl="0">
<f x="33.4" y="-80.5" cocos2d_x="-5.7" cocos2d_y="-108.2" kX="15" kY="15" cX="1" cY="1" pX="44.9" pY="16.6" z="11" dI="0" dr="7"/> <f x="33.4" y="-80.5" cocos2d_x="-5.7" cocos2d_y="-108.2" kX="15" kY="15" cX="1" cY="1" pX="45" pY="17" z="11" dI="0" dr="7"/>
</b> </b>
<b name="armUpperR" sc="1" dl="0"> <b name="armUpperR" sc="1" dl="0">
<f x="18.05" y="-167.6" cocos2d_x="18.05" cocos2d_y="-167.6" kX="78.95" kY="78.95" cX="1" cY="1" pX="0" pY="0" z="12" dI="0" dr="7"/> <f x="18.05" y="-167.6" cocos2d_x="18.05" cocos2d_y="-167.6" kX="78.95" kY="78.95" cX="1" cY="1" pX="0" pY="0" z="12" dI="0" dr="7"/>
</b> </b>
<b name="armR" sc="1" dl="0"> <b name="armR" sc="1" dl="0">
<f x="47.1" y="-104.6" cocos2d_x="38.45" cocos2d_y="-119.7" kX="15" kY="15" cX="1" cY="1" pX="12.3" pY="12.3" z="13" dI="0" dr="7"/> <f x="47.1" y="-104.6" cocos2d_x="38.45" cocos2d_y="-119.7" kX="15" kY="15" cX="1" cY="1" pX="12" pY="12" z="13" dI="0" dr="7"/>
</b> </b>
<b name="handR" sc="1" dl="0"> <b name="handR" sc="1" dl="0">
<f x="42.7" y="-83.35" cocos2d_x="21.15" cocos2d_y="-99.2" kX="30" kY="30" cX="1" cY="1" pX="26.65" pY="2.9" z="14" dI="0" dr="7"/> <f x="42.7" y="-83.35" cocos2d_x="21.15" cocos2d_y="-99.2" kX="30" kY="30" cX="1" cY="1" pX="27" pY="3" z="14" dI="0" dr="7"/>
</b> </b>
<b name="beardL" sc="2" dl="0.3"> <b name="beardL" sc="2" dl="0.3">
<f x="-14" y="-217.35" cocos2d_x="-69.95" cocos2d_y="-222.1" kX="0" kY="0" cX="1" cY="1" pX="55.95" pY="4.75" z="15" dI="0" dr="2"/> <f x="-14" y="-217.35" cocos2d_x="-69.95" cocos2d_y="-222.1" kX="0" kY="0" cX="1" cY="1" pX="56" pY="5" z="15" dI="0" dr="2"/>
<f x="-70.1" y="-221.8" cocos2d_x="-70.1" cocos2d_y="-221.8" kX="-6.47" kY="-6.47" cX="1" cY="1" pX="0" pY="0" z="15" dI="0" dr="3"/> <f x="-70.1" y="-221.8" cocos2d_x="-70.1" cocos2d_y="-221.8" kX="-6.47" kY="-6.47" cX="1" cY="1" pX="0" pY="0" z="15" dI="0" dr="3"/>
<f x="-14" y="-217.35" cocos2d_x="-69.95" cocos2d_y="-222.1" kX="0" kY="0" cX="1" cY="1" pX="55.95" pY="4.75" z="15" dI="0" dr="2"/> <f x="-14" y="-217.35" cocos2d_x="-69.95" cocos2d_y="-222.1" kX="0" kY="0" cX="1" cY="1" pX="56" pY="5" z="15" dI="0" dr="2"/>
</b> </b>
<b name="beardR" sc="2" dl="0.3"> <b name="beardR" sc="2" dl="0.3">
<f x="-19.8" y="-221.55" cocos2d_x="-23" cocos2d_y="-230.45" kX="0" kY="0" cX="1" cY="1" pX="3.2" pY="8.9" z="16" dI="0" dr="2"/> <f x="-19.8" y="-221.55" cocos2d_x="-23" cocos2d_y="-230.45" kX="0" kY="0" cX="1" cY="1" pX="3" pY="9" z="16" dI="0" dr="2"/>
<f x="-19.8" y="-221.55" cocos2d_x="-22.15" cocos2d_y="-230.75" kX="5.44" kY="5.44" cX="1" cY="1" pX="3.2" pY="8.95" z="16" dI="0" dr="3"/> <f x="-19.8" y="-221.55" cocos2d_x="-22.15" cocos2d_y="-230.75" kX="5.44" kY="5.44" cX="1" cY="1" pX="3" pY="9" z="16" dI="0" dr="3"/>
<f x="-19.8" y="-221.55" cocos2d_x="-23" cocos2d_y="-230.45" kX="0" kY="0" cX="1" cY="1" pX="3.2" pY="8.9" z="16" dI="0" dr="2"/> <f x="-19.8" y="-221.55" cocos2d_x="-23" cocos2d_y="-230.45" kX="0" kY="0" cX="1" cY="1" pX="3" pY="9" z="16" dI="0" dr="2"/>
</b> </b>
</mov> </mov>
<mov name="walk" dr="8" to="5" drTW="20" lp="1" twE="0"> <mov name="walk" dr="8" to="5" drTW="20" lp="1" twE="0">
<b name="tailTip" sc="1.5" dl="0"> <b name="tailTip" sc="1.5" dl="0">
<f x="169.9" y="-106.15" cocos2d_x="196.35" cocos2d_y="-198.4" kX="30" kY="30" cX="1" cY="1" pX="23.25" pY="93.05" z="0" dI="0" dr="4"/> <f x="169.9" y="-106.15" cocos2d_x="196.35" cocos2d_y="-198.4" kX="30" kY="30" cX="1" cY="1" pX="23" pY="93" z="0" dI="0" dr="4"/>
<f x="153.9" y="-124.35" cocos2d_x="194.85" cocos2d_y="-211.2" kX="39.23" kY="39.23" cX="1" cY="1" pX="23.15" pY="93.15" z="0" dI="0" dr="4"/> <f x="153.9" y="-124.35" cocos2d_x="194.85" cocos2d_y="-211.2" kX="39.23" kY="39.23" cX="1" cY="1" pX="23" pY="93" z="0" dI="0" dr="3"/>
</b> <f x="169.9" y="-106.15" cocos2d_x="196.35" cocos2d_y="-198.4" kX="30" kY="30" cX="1" cY="1" pX="23" pY="93" z="0" dI="0" dr="1"/>
<b name="armUpperL" sc="1" dl="0"> </b>
<f x="-43.95" y="-159.15" cocos2d_x="-43.95" cocos2d_y="-159.15" kX="-81.2" kY="-81.2" cX="1" cY="1" pX="0" pY="0" z="1" dI="0" dr="4"/> <b name="armUpperL" sc="1" dl="0">
<f x="-43.95" y="-159.15" cocos2d_x="-43.95" cocos2d_y="-159.15" kX="-30" kY="-30" cX="1" cY="1" pX="0" pY="0" z="1" dI="0" dr="4"/> <f x="-43.95" y="-159.15" cocos2d_x="-43.95" cocos2d_y="-159.15" kX="-81.2" kY="-81.2" cX="1" cY="1" pX="0" pY="0" z="1" dI="0" dr="4"/>
</b> <f x="-43.95" y="-159.15" cocos2d_x="-43.95" cocos2d_y="-159.15" kX="-30" kY="-30" cX="1" cY="1" pX="0" pY="0" z="1" dI="0" dr="3"/>
<b name="armL" sc="1" dl="0"> <f x="-43.95" y="-159.15" cocos2d_x="-43.95" cocos2d_y="-159.15" kX="-81.2" kY="-81.2" cX="1" cY="1" pX="0" pY="0" z="1" dI="0" dr="1"/>
<f x="-34.05" y="-121.7" cocos2d_x="-7.2" cocos2d_y="-97.2" kX="157.27" kY="157.27" cX="1" cY="1" pX="15.25" pY="32.95" z="2" dI="0" dr="4"/> </b>
<f x="-64.05" y="-126.75" cocos2d_x="-99.85" cocos2d_y="-121" kX="-74.18" kY="-74.18" cX="1" cY="1" pX="15.35" pY="32.9" z="2" dI="0" dr="4"/> <b name="armL" sc="1" dl="0">
</b> <f x="-34.05" y="-121.7" cocos2d_x="-7.2" cocos2d_y="-97.2" kX="157.27" kY="157.27" cX="1" cY="1" pX="15" pY="33" z="2" dI="0" dr="4"/>
<b name="handL" sc="1" dl="0"> <f x="-64.05" y="-126.75" cocos2d_x="-99.85" cocos2d_y="-121" kX="-74.18" kY="-74.18" cX="1" cY="1" pX="15" pY="33" z="2" dI="0" dr="3"/>
<f x="-16.1" y="-94" cocos2d_x="-8.75" cocos2d_y="-46.35" kX="-135" kY="-135" cX="1" cY="1" pX="38.85" pY="28.45" z="3" dI="0" dr="4"/> <f x="-34.05" y="-121.7" cocos2d_x="-7.2" cocos2d_y="-97.2" kX="157.27" kY="157.27" cX="1" cY="1" pX="15" pY="33" z="2" dI="0" dr="1"/>
<f x="-95.85" y="-129.1" cocos2d_x="-140.8" cocos2d_y="-146.55" kX="-15" kY="-15" cX="1" cY="1" pX="38.85" pY="28.5" z="3" dI="0" dr="4"/> </b>
</b> <b name="handL" sc="1" dl="0">
<b name="legL" sc="1" dl="0"> <f x="-16.1" y="-94" cocos2d_x="-8.75" cocos2d_y="-46.35" kX="-135" kY="-135" cX="1" cY="1" pX="39" pY="28" z="3" dI="0" dr="4"/>
<f x="-9" y="-73.1" cocos2d_x="-94.7" cocos2d_y="-108.7" kX="13.46" kY="13.46" cX="1" cY="1" pX="91.65" pY="14.65" z="4" dI="0" dr="4"/> <f x="-95.85" y="-129.1" cocos2d_x="-140.8" cocos2d_y="-146.55" kX="-15" kY="-15" cX="1" cY="1" pX="39" pY="29" z="3" dI="0" dr="3"/>
<f x="-3.95" y="-91.1" cocos2d_x="-68.1" cocos2d_y="-24" kX="-55.44" kY="-55.44" cX="1" cY="1" pX="91.7" pY="14.75" z="4" dI="0" dr="4"/> <f x="-16.1" y="-94" cocos2d_x="-8.75" cocos2d_y="-46.35" kX="-135" kY="-135" cX="1" cY="1" pX="39" pY="28" z="3" dI="0" dr="1"/>
</b> </b>
<b name="body" sc="1" dl="0"> <b name="legL" sc="1" dl="0">
<f x="5.9" y="-128.1" cocos2d_x="-52.75" cocos2d_y="-214.65" kX="0" kY="0" cX="1" cY="1" pX="58.65" pY="86.55" z="5" dI="0" dr="4"/> <f x="-9" y="-73.1" cocos2d_x="-94.7" cocos2d_y="-108.7" kX="13.46" kY="13.46" cX="1" cY="1" pX="92" pY="15" z="4" dI="0" dr="4"/>
<f x="5.9" y="-127.1" cocos2d_x="-52.75" cocos2d_y="-213.65" kX="0" kY="0" cX="1" cY="1" pX="58.65" pY="86.55" z="5" dI="0" dr="4"/> <f x="-3.95" y="-91.1" cocos2d_x="-68.1" cocos2d_y="-24" kX="-55.44" kY="-55.44" cX="1" cY="1" pX="92" pY="15" z="4" dI="0" dr="3"/>
</b> <f x="-9" y="-73.1" cocos2d_x="-94.7" cocos2d_y="-108.7" kX="13.46" kY="13.46" cX="1" cY="1" pX="92" pY="15" z="4" dI="0" dr="1"/>
<b name="hair" sc="1" dl="0"> </b>
<f x="44.4" y="-252.1" cocos2d_x="13.4" cocos2d_y="-322.4" kX="0" kY="0" cX="1" cY="1" pX="31" pY="70.3" z="6" dI="0" dr="4"/> <b name="body" sc="1" dl="0">
<f x="47.4" y="-253.1" cocos2d_x="16.4" cocos2d_y="-323.4" kX="0" kY="0" cX="1" cY="1" pX="31" pY="70.3" z="6" dI="0" dr="4"/> <f x="5.9" y="-128.1" cocos2d_x="-52.75" cocos2d_y="-214.65" kX="0" kY="0" cX="1" cY="1" pX="59" pY="87" z="5" dI="0" dr="4"/>
</b> <f x="5.9" y="-127.1" cocos2d_x="-52.75" cocos2d_y="-213.65" kX="0" kY="0" cX="1" cY="1" pX="59" pY="87" z="5" dI="0" dr="3"/>
<b name="head" sc="1" dl="0"> <f x="5.9" y="-128.1" cocos2d_x="-52.75" cocos2d_y="-214.65" kX="0" kY="0" cX="1" cY="1" pX="59" pY="87" z="5" dI="0" dr="1"/>
<f x="111.35" y="-50.2" cocos2d_x="-4.05" cocos2d_y="-207.1" kX="0" kY="0" cX="1" cY="1" pX="115.4" pY="156.9" z="7" dI="0" dr="4"/> </b>
<f x="-4.05" y="-207.1" cocos2d_x="-4.05" cocos2d_y="-207.1" kX="2.95" kY="2.95" cX="1" cY="1" pX="0" pY="0" z="7" dI="0" dr="4"/> <b name="hair" sc="1" dl="0">
</b> <f x="44.4" y="-252.1" cocos2d_x="13.4" cocos2d_y="-322.4" kX="0" kY="0" cX="1" cY="1" pX="31" pY="70" z="6" dI="0" dr="4"/>
<b name="eyeL" sc="1" dl="0"> <f x="47.4" y="-253.1" cocos2d_x="16.4" cocos2d_y="-323.4" kX="0" kY="0" cX="1" cY="1" pX="31" pY="70" z="6" dI="0" dr="3"/>
<f x="-42.85" y="-281.45" cocos2d_x="-49.7" cocos2d_y="-292.75" kX="0" kY="0" cX="1" cY="1" pX="6.85" pY="11.3" z="8" dI="0" dr="4"/> <f x="44.4" y="-252.1" cocos2d_x="13.4" cocos2d_y="-322.4" kX="0" kY="0" cX="1" cY="1" pX="31" pY="70" z="6" dI="0" dr="1"/>
<f x="-42.85" y="-281.45" cocos2d_x="-49.7" cocos2d_y="-292.75" kX="0" kY="0" cX="1" cY="1" pX="6.85" pY="11.3" z="8" dI="0" dr="4"/> </b>
</b> <b name="head" sc="1" dl="0">
<b name="eyeR" sc="1" dl="0"> <f x="111.35" y="-50.2" cocos2d_x="-4.05" cocos2d_y="-207.1" kX="0" kY="0" cX="1" cY="1" pX="115" pY="157" z="7" dI="0" dr="4"/>
<f x="4.95" y="-263.35" cocos2d_x="-4.15" cocos2d_y="-277.75" kX="0" kY="0" cX="1" cY="1" pX="9.1" pY="14.4" z="9" dI="0" dr="4"/> <f x="-4.05" y="-207.1" cocos2d_x="-4.05" cocos2d_y="-207.1" kX="2.95" kY="2.95" cX="1" cY="1" pX="0" pY="0" z="7" dI="0" dr="3"/>
<f x="4.95" y="-263.35" cocos2d_x="-4.15" cocos2d_y="-277.75" kX="0" kY="0" cX="1" cY="1" pX="9.1" pY="14.4" z="9" dI="0" dr="4"/> <f x="111.35" y="-50.2" cocos2d_x="-4.05" cocos2d_y="-207.1" kX="0" kY="0" cX="1" cY="1" pX="115" pY="157" z="7" dI="0" dr="1"/>
</b> </b>
<b name="tail" sc="1.1" dl="0"> <b name="eyeL" sc="1" dl="0">
<f x="41.9" y="-72.8" cocos2d_x="120.1" cocos2d_y="-231.25" kX="30" kY="30" cX="1" cY="1" pX="11.5" pY="176.3" z="10" dI="0" dr="4"/> <f x="-42.85" y="-281.45" cocos2d_x="-49.7" cocos2d_y="-292.75" kX="0" kY="0" cX="1" cY="1" pX="7" pY="11" z="8" dI="0" dr="4"/>
<f x="39.9" y="-74.8" cocos2d_x="93.2" cocos2d_y="-243.3" kX="21.29" kY="21.29" cX="1" cY="1" pX="11.55" pY="176.35" z="10" dI="0" dr="4"/> <f x="-42.85" y="-281.45" cocos2d_x="-49.7" cocos2d_y="-292.75" kX="0" kY="0" cX="1" cY="1" pX="7" pY="11" z="8" dI="0" dr="3"/>
</b> <f x="-42.85" y="-281.45" cocos2d_x="-49.7" cocos2d_y="-292.75" kX="0" kY="0" cX="1" cY="1" pX="7" pY="11" z="8" dI="0" dr="1"/>
<b name="legR" sc="1" dl="0"> </b>
<f x="30.4" y="-89.5" cocos2d_x="-17.3" cocos2d_y="-93.95" kX="-15" kY="-15" cX="1" cY="1" pX="44.9" pY="16.65" z="11" dI="0" dr="4"/> <b name="eyeR" sc="1" dl="0">
<f x="31.45" y="-82.5" cocos2d_x="11.45" cocos2d_y="-126" kX="45" kY="45" cX="1" cY="1" pX="44.9" pY="16.6" z="11" dI="0" dr="4"/> <f x="4.95" y="-263.35" cocos2d_x="-4.15" cocos2d_y="-277.75" kX="0" kY="0" cX="1" cY="1" pX="9" pY="14" z="9" dI="0" dr="4"/>
</b> <f x="4.95" y="-263.35" cocos2d_x="-4.15" cocos2d_y="-277.75" kX="0" kY="0" cX="1" cY="1" pX="9" pY="14" z="9" dI="0" dr="3"/>
<b name="armUpperR" sc="1" dl="0"> <f x="4.95" y="-263.35" cocos2d_x="-4.15" cocos2d_y="-277.75" kX="0" kY="0" cX="1" cY="1" pX="9" pY="14" z="9" dI="0" dr="1"/>
<f x="15.05" y="-162.6" cocos2d_x="15.05" cocos2d_y="-162.6" kX="124.45" kY="124.45" cX="1" cY="1" pX="0" pY="0" z="12" dI="0" dr="4"/> </b>
<f x="18.05" y="-167.6" cocos2d_x="18.05" cocos2d_y="-167.6" kX="56.8" kY="56.8" cX="1" cY="1" pX="0" pY="0" z="12" dI="0" dr="4"/> <b name="tail" sc="1.1" dl="0">
</b> <f x="41.9" y="-72.8" cocos2d_x="120.1" cocos2d_y="-231.25" kX="30" kY="30" cX="1" cY="1" pX="12" pY="176" z="10" dI="0" dr="4"/>
<b name="armR" sc="1" dl="0"> <f x="39.9" y="-74.8" cocos2d_x="93.2" cocos2d_y="-243.3" kX="21.29" kY="21.29" cX="1" cY="1" pX="12" pY="176" z="10" dI="0" dr="3"/>
<f x="-12.9" y="-101.6" cocos2d_x="-2.3" cocos2d_y="-115.35" kX="82.22" kY="82.22" cX="1" cY="1" pX="12.2" pY="12.35" z="13" dI="0" dr="4"/> <f x="41.9" y="-72.8" cocos2d_x="120.1" cocos2d_y="-231.25" kX="30" kY="30" cX="1" cY="1" pX="12" pY="176" z="10" dI="0" dr="1"/>
<f x="67.9" y="-121.4" cocos2d_x="51.85" cocos2d_y="-128.1" kX="-22.78" kY="-22.78" cX="1" cY="1" pX="12.2" pY="12.35" z="13" dI="0" dr="4"/> </b>
</b> <b name="legR" sc="1" dl="0">
<b name="handR" sc="1" dl="0"> <f x="30.4" y="-89.5" cocos2d_x="-17.3" cocos2d_y="-93.95" kX="-15" kY="-15" cX="1" cY="1" pX="45" pY="17" z="11" dI="0" dr="4"/>
<f x="-36.3" y="-105.35" cocos2d_x="-50.4" cocos2d_y="-128.1" kX="51.74" kY="51.74" cX="1" cY="1" pX="26.6" pY="3" z="14" dI="0" dr="4"/> <f x="31.45" y="-82.5" cocos2d_x="11.45" cocos2d_y="-126" kX="45" kY="45" cX="1" cY="1" pX="45" pY="17" z="11" dI="0" dr="3"/>
<f x="78.55" y="-101.2" cocos2d_x="51.8" cocos2d_y="-100.4" kX="-8.26" kY="-8.26" cX="1" cY="1" pX="26.6" pY="3.05" z="14" dI="0" dr="4"/> <f x="30.4" y="-89.5" cocos2d_x="-17.3" cocos2d_y="-93.95" kX="-15" kY="-15" cX="1" cY="1" pX="45" pY="17" z="11" dI="0" dr="1"/>
</b> </b>
<b name="beardL" sc="1" dl="0"> <b name="armUpperR" sc="1" dl="0">
<f x="-14" y="-217.35" cocos2d_x="-69.95" cocos2d_y="-222.1" kX="0" kY="0" cX="1" cY="1" pX="55.95" pY="4.75" z="15" dI="0" dr="4"/> <f x="15.05" y="-162.6" cocos2d_x="15.05" cocos2d_y="-162.6" kX="124.45" kY="124.45" cX="1" cY="1" pX="0" pY="0" z="12" dI="0" dr="4"/>
<f x="-68.95" y="-225.1" cocos2d_x="-68.95" cocos2d_y="-225.1" kX="8.99" kY="8.99" cX="1" cY="1" pX="0" pY="0" z="15" dI="0" dr="4"/> <f x="18.05" y="-167.6" cocos2d_x="18.05" cocos2d_y="-167.6" kX="56.8" kY="56.8" cX="1" cY="1" pX="0" pY="0" z="12" dI="0" dr="3"/>
</b> <f x="15.05" y="-162.6" cocos2d_x="15.05" cocos2d_y="-162.6" kX="124.45" kY="124.45" cX="1" cY="1" pX="0" pY="0" z="12" dI="0" dr="1"/>
<b name="beardR" sc="1" dl="0"> </b>
<f x="-19.8" y="-221.55" cocos2d_x="-23" cocos2d_y="-230.45" kX="0" kY="0" cX="1" cY="1" pX="3.2" pY="8.9" z="16" dI="0" dr="4"/> <b name="armR" sc="1" dl="0">
<f x="-19.8" y="-221.55" cocos2d_x="-24.1" cocos2d_y="-230" kX="-7.5" kY="-7.5" cX="1" cY="1" pX="3.1" pY="8.95" z="16" dI="0" evt="walk_middle" dr="4"/> <f x="-12.9" y="-101.6" cocos2d_x="-2.3" cocos2d_y="-115.35" kX="82.22" kY="82.22" cX="1" cY="1" pX="12" pY="12" z="13" dI="0" dr="4"/>
</b> <f x="67.9" y="-121.4" cocos2d_x="51.85" cocos2d_y="-128.1" kX="-22.78" kY="-22.78" cX="1" cY="1" pX="12" pY="12" z="13" dI="0" dr="3"/>
</mov> <f x="-12.9" y="-101.6" cocos2d_x="-2.3" cocos2d_y="-115.35" kX="82.22" kY="82.22" cX="1" cY="1" pX="12" pY="12" z="13" dI="0" dr="1"/>
<mov name="jump" dr="5" to="3" drTW="5" lp="1" twE="NaN"> </b>
<b name="tailTip" sc="1" dl="0"> <b name="handR" sc="1" dl="0">
<f x="156.9" y="-75.35" cocos2d_x="229" cocos2d_y="-138.75" kX="62.68" kY="62.68" cX="1" cY="1" pX="23.2" pY="93.15" z="0" dI="0" dr="2"/> <f x="-36.3" y="-105.35" cocos2d_x="-50.4" cocos2d_y="-128.1" kX="51.74" kY="51.74" cX="1" cY="1" pX="27" pY="3" z="14" dI="0" dr="4"/>
<f x="157.85" y="-71.35" cocos2d_x="239.05" cocos2d_y="-122.7" kX="71.67" kY="71.67" cX="1" cY="1" pX="23.15" pY="93.2" z="0" dI="0" dr="3"/> <f x="78.55" y="-101.2" cocos2d_x="51.8" cocos2d_y="-100.4" kX="-8.26" kY="-8.26" cX="1" cY="1" pX="27" pY="3" z="14" dI="0" dr="3"/>
</b> <f x="-36.3" y="-105.35" cocos2d_x="-50.4" cocos2d_y="-128.1" kX="51.74" kY="51.74" cX="1" cY="1" pX="27" pY="3" z="14" dI="0" dr="1"/>
<b name="armUpperL" sc="1" dl="0"> </b>
<f x="-43.95" y="-190.15" cocos2d_x="-43.95" cocos2d_y="-190.15" kX="-45" kY="-45" cX="1" cY="1" pX="0" pY="0" z="1" dI="0" dr="2"/> <b name="beardL" sc="1" dl="0">
<f x="-43.95" y="-189.15" cocos2d_x="-43.95" cocos2d_y="-189.15" kX="-45" kY="-45" cX="1" cY="1" pX="0" pY="0" z="1" dI="0" dr="3"/> <f x="-14" y="-217.35" cocos2d_x="-69.95" cocos2d_y="-222.1" kX="0" kY="0" cX="1" cY="1" pX="56" pY="5" z="15" dI="0" dr="4"/>
</b> <f x="-68.95" y="-225.1" cocos2d_x="-68.95" cocos2d_y="-225.1" kX="8.99" kY="8.99" cX="1" cY="1" pX="0" pY="0" z="15" dI="0" dr="3"/>
<b name="armL" sc="1" dl="0"> <f x="-14" y="-217.35" cocos2d_x="-69.95" cocos2d_y="-222.1" kX="0" kY="0" cX="1" cY="1" pX="56" pY="5" z="15" dI="0" dr="1"/>
<f x="-52" y="-156.8" cocos2d_x="-73.25" cocos2d_y="-127.35" kX="-119.18" kY="-119.18" cX="1" cY="1" pX="15.35" pY="32.9" z="2" dI="0" dr="5"/> </b>
</b> <b name="beardR" sc="1" dl="0">
<b name="handL" sc="1" dl="0"> <f x="-19.8" y="-221.55" cocos2d_x="-23" cocos2d_y="-230.45" kX="0" kY="0" cX="1" cY="1" pX="3" pY="9" z="16" dI="0" dr="4"/>
<f x="-73.9" y="-137.75" cocos2d_x="-111.45" cocos2d_y="-107.55" kX="-75" kY="-75" cX="1" cY="1" pX="38.85" pY="28.45" z="3" dI="0" dr="5"/> <f x="-19.8" y="-221.55" cocos2d_x="-24.1" cocos2d_y="-230" kX="-7.5" kY="-7.5" cX="1" cY="1" pX="3" pY="9" z="16" dI="0" dr="3"/>
</b> <f x="-19.8" y="-221.55" cocos2d_x="-23" cocos2d_y="-230.45" kX="0" kY="0" cX="1" cY="1" pX="3" pY="9" z="16" dI="0" dr="1"/>
<b name="legL" sc="1" dl="0"> </b>
<f x="12.25" y="-118.05" cocos2d_x="-62.45" cocos2d_y="-63.05" kX="-45.47" kY="-45.47" cX="1" cY="1" pX="91.6" pY="14.7" z="4" dI="0" dr="2"/> </mov>
<f x="12.25" y="-117.05" cocos2d_x="-62.45" cocos2d_y="-62.05" kX="-45.47" kY="-45.47" cX="1" cY="1" pX="91.6" pY="14.7" z="4" dI="0" dr="3"/> </animation>
</b> </animations>
<b name="body" sc="1" dl="0"> <TextureAtlas name="Dragon" width="512" height="512">
<f x="5.9" y="-159.1" cocos2d_x="-52.75" cocos2d_y="-245.65" kX="0" kY="0" cX="1" cY="1" pX="58.65" pY="86.55" z="5" dI="0" dr="5"/> <SubTexture name="parts-beardR" width="68" height="18" cocos2d_pX="0" cocos2d_pY="0" x="291" y="233"/>
</b> <SubTexture name="parts-beardL" width="60" height="18" cocos2d_pX="54" cocos2d_pY="4" x="229" y="221"/>
<b name="hair" sc="1" dl="0"> <SubTexture name="parts-handR" width="49" height="29" cocos2d_pX="0" cocos2d_pY="0" x="82" y="240"/>
<f x="53.4" y="-278.1" cocos2d_x="22.4" cocos2d_y="-348.4" kX="0" kY="0" cX="1" cY="1" pX="31" pY="70.3" z="6" dI="0" dr="2"/> <SubTexture name="parts-armR" width="23" height="39" cocos2d_pX="0" cocos2d_pY="0" x="465" y="160"/>
<f x="55.4" y="-276.1" cocos2d_x="24.4" cocos2d_y="-346.4" kX="0" kY="0" cX="1" cY="1" pX="31" pY="70.3" z="6" dI="0" dr="3"/> <SubTexture name="parts-armUpperR" width="80" height="47" cocos2d_pX="12" cocos2d_pY="28" x="0" y="199"/>
</b> <SubTexture name="parts-legR" width="90" height="116" cocos2d_pX="0" cocos2d_pY="0" x="401" y="0"/>
<b name="head" sc="1" dl="0"> <SubTexture name="parts-tail" width="108" height="139" cocos2d_pX="0" cocos2d_pY="-63.8" x="291" y="0"/>
<f x="-2.25" y="-239.15" cocos2d_x="-2.25" cocos2d_y="-239.15" kX="10" kY="10" cX="1" cY="1" pX="0" pY="0" z="7" dI="0" dr="5"/> <SubTexture name="parts-eyeR" width="19" height="29" cocos2d_pX="8" cocos2d_pY="15" x="491" y="118"/>
</b> <SubTexture name="parts-eyeL" width="14" height="23" cocos2d_pX="0" cocos2d_pY="0" x="493" y="0"/>
<b name="eyeL" sc="1" dl="0"> <SubTexture name="parts-head" width="169" height="197" cocos2d_pX="79.5" cocos2d_pY="160" x="0" y="0"/>
<f x="-32.85" y="-325.45" cocos2d_x="-39.7" cocos2d_y="-336.75" kX="0" kY="0" cX="1" cY="1" pX="6.85" pY="11.3" z="8" dI="0" dr="2"/> <SubTexture name="parts-hair" width="62" height="141" cocos2d_pX="0" cocos2d_pY="0" x="401" y="118"/>
<f x="-32.35" y="-325.95" cocos2d_x="-39.2" cocos2d_y="-337.25" kX="0" kY="0" cX="1" cY="1" pX="6.85" pY="11.3" z="8" dI="0" dr="3"/> <SubTexture name="parts-body" width="118" height="174" cocos2d_pX="0" cocos2d_pY="0" x="171" y="0"/>
</b> <SubTexture name="parts-legL" width="102" height="90" cocos2d_pX="0" cocos2d_pY="0" x="291" y="141"/>
<b name="eyeR" sc="1" dl="0"> <SubTexture name="parts-handL" width="48" height="39" cocos2d_pX="0" cocos2d_pY="0" x="82" y="199"/>
<f x="14.95" y="-300.35" cocos2d_x="5.85" cocos2d_y="-314.75" kX="0" kY="0" cX="1" cY="1" pX="9.1" pY="14.4" z="9" dI="0" dr="2"/> <SubTexture name="parts-armL" width="24" height="40" cocos2d_pX="0" cocos2d_pY="0" x="465" y="118"/>
<f x="15.95" y="-301.35" cocos2d_x="6.85" cocos2d_y="-315.75" kX="0" kY="0" cX="1" cY="1" pX="9.1" pY="14.4" z="9" dI="0" dr="3"/> <SubTexture name="parts-armUpperL" width="56" height="43" cocos2d_pX="41" cocos2d_pY="16" x="229" y="176"/>
</b> <SubTexture name="parts-tailTip" width="56" height="105" cocos2d_pX="0" cocos2d_pY="0" x="171" y="176"/>
<b name="tail" sc="1" dl="0"> </TextureAtlas>
<f x="33.9" y="-108.8" cocos2d_x="180.6" cocos2d_y="-207.5" kX="59.79" kY="59.79" cX="1" cY="1" pX="11.5" pY="176.45" z="10" dI="0" dr="2"/>
<f x="33.9" y="-108.8" cocos2d_x="185.5" cocos2d_y="-199.8" kX="62.76" kY="62.76" cX="1" cY="1" pX="11.5" pY="176.45" z="10" dI="0" dr="3"/>
</b>
<b name="legR" sc="1" dl="0">
<f x="41.45" y="-107.5" cocos2d_x="-6" cocos2d_y="-113.8" kX="-12.69" kY="-12.69" cX="1" cY="1" pX="44.9" pY="16.55" z="11" dI="0" dr="2"/>
<f x="41.45" y="-106.5" cocos2d_x="-6" cocos2d_y="-112.8" kX="-12.69" kY="-12.69" cX="1" cY="1" pX="44.9" pY="16.55" z="11" dI="0" dr="3"/>
</b>
<b name="armUpperR" sc="1" dl="0">
<f x="18.05" y="-195.6" cocos2d_x="18.05" cocos2d_y="-195.6" kX="54.3" kY="54.3" cX="1" cY="1" pX="0" pY="0" z="12" dI="0" dr="2"/>
<f x="18.05" y="-194.6" cocos2d_x="18.05" cocos2d_y="-194.6" kX="54.3" kY="54.3" cX="1" cY="1" pX="0" pY="0" z="12" dI="0" dr="3"/>
</b>
<b name="armR" sc="1" dl="0">
<f x="67.9" y="-153.4" cocos2d_x="51.85" cocos2d_y="-160.1" kX="-22.78" kY="-22.78" cX="1" cY="1" pX="12.2" pY="12.35" z="13" dI="0" dr="5"/>
</b>
<b name="handR" sc="1" dl="0">
<f x="78.55" y="-133.2" cocos2d_x="51.8" cocos2d_y="-132.4" kX="-8.26" kY="-8.26" cX="1" cY="1" pX="26.65" pY="3.1" z="14" dI="0" dr="5"/>
</b>
<b name="beardL" sc="1" dl="0">
<f x="-63.8" y="-263.7" cocos2d_x="-63.8" cocos2d_y="-263.7" kX="-40.29" kY="-40.29" cX="1" cY="1" pX="0" pY="0" z="15" dI="0" dr="2"/>
<f x="-63.8" y="-263.7" cocos2d_x="-63.8" cocos2d_y="-263.7" kX="-46.79" kY="-46.79" cX="1" cY="1" pX="0" pY="0" z="15" dI="0" dr="3"/>
</b>
<b name="beardR" sc="1" dl="0">
<f x="-19.85" y="-253.5" cocos2d_x="-14.65" cocos2d_y="-261.45" kX="52.5" kY="52.5" cX="1" cY="1" pX="3.1" pY="8.95" z="16" dI="0" dr="2"/>
<f x="-19.8" y="-253.45" cocos2d_x="-13.6" cocos2d_y="-260.65" kX="60.23" kY="60.23" cX="1" cY="1" pX="3.15" pY="8.95" z="16" dI="0" dr="3"/>
</b>
</mov>
<mov name="fall" dr="5" to="6" drTW="5" lp="1" twE="NaN">
<b name="tailTip" sc="1" dl="0">
<f x="151.85" y="-179.95" cocos2d_x="148" cocos2d_y="-275.95" kX="11.67" kY="11.67" cX="1" cY="1" pX="23.15" pY="93.25" z="0" dI="0" dr="2"/>
<f x="145.85" y="-185.85" cocos2d_x="133.75" cocos2d_y="-281.25" kX="6.73" kY="6.73" cX="1" cY="1" pX="23.2" pY="93.3" z="0" dI="0" dr="3"/>
</b>
<b name="armUpperL" sc="1" dl="0">
<f x="-43.95" y="-190.15" cocos2d_x="-43.95" cocos2d_y="-190.15" kX="32.45" kY="32.45" cX="1" cY="1" pX="0" pY="0" z="1" dI="0" dr="2"/>
<f x="-43.95" y="-191.15" cocos2d_x="-43.95" cocos2d_y="-191.15" kX="32.45" kY="32.45" cX="1" cY="1" pX="0" pY="0" z="1" dI="0" dr="3"/>
</b>
<b name="armL" sc="1" dl="0">
<f x="-74.55" y="-193" cocos2d_x="-102.7" cocos2d_y="-170.05" kX="-104.18" kY="-104.18" cX="1" cY="1" pX="15.35" pY="32.9" z="2" dI="0" dr="5"/>
</b>
<b name="handL" sc="1" dl="0">
<f x="-104.1" y="-178.5" cocos2d_x="-152" cocos2d_y="-183.65" kX="-30" kY="-30" cX="1" cY="1" pX="38.9" pY="28.4" z="3" dI="0" dr="5"/>
</b>
<b name="legL" sc="1" dl="0">
<f x="-9.75" y="-117.15" cocos2d_x="-94.65" cocos2d_y="-154.3" kX="14.52" kY="14.52" cX="1" cY="1" pX="91.5" pY="14.7" z="4" dI="0" dr="2"/>
<f x="-9.75" y="-118.15" cocos2d_x="-94.65" cocos2d_y="-155.3" kX="14.52" kY="14.52" cX="1" cY="1" pX="91.5" pY="14.65" z="4" dI="0" dr="3"/>
</b>
<b name="body" sc="1" dl="0">
<f x="5.9" y="-159.1" cocos2d_x="-52.75" cocos2d_y="-245.65" kX="0" kY="0" cX="1" cY="1" pX="58.65" pY="86.55" z="5" dI="0" dr="5"/>
</b>
<b name="hair" sc="1" dl="0">
<f x="43.35" y="-290.1" cocos2d_x="-4.75" cocos2d_y="-349.95" kX="-15" kY="-15" cX="1" cY="1" pX="30.95" pY="70.3" z="6" dI="0" dr="2"/>
<f x="39.4" y="-293.05" cocos2d_x="-9.6" cocos2d_y="-352.25" kX="-15.82" kY="-15.82" cX="1" cY="1" pX="31" pY="70.3" z="6" dI="0" dr="3"/>
</b>
<b name="head" sc="1" dl="0">
<f x="1.45" y="-241.8" cocos2d_x="1.45" cocos2d_y="-241.8" kX="-8.73" kY="-8.73" cX="1" cY="1" pX="0" pY="0" z="7" dI="0" dr="5"/>
</b>
<b name="eyeL" sc="1" dl="0">
<f x="-49.35" y="-301.95" cocos2d_x="-56.2" cocos2d_y="-313.25" kX="0" kY="0" cX="1" cY="1" pX="6.85" pY="11.3" z="8" dI="0" dr="2"/>
<f x="-49.35" y="-300.95" cocos2d_x="-56.2" cocos2d_y="-312.25" kX="0" kY="0" cX="1" cY="1" pX="6.85" pY="11.3" z="8" dI="0" dr="3"/>
</b>
<b name="eyeR" sc="1" dl="0">
<f x="-13.15" y="-304.75" cocos2d_x="-13.15" cocos2d_y="-304.75" kX="0" kY="0" cX="1" cY="1" pX="0" pY="0" z="9" dI="0" dr="2"/>
<f x="-13.15" y="-303.75" cocos2d_x="-13.15" cocos2d_y="-303.75" kX="0" kY="0" cX="1" cY="1" pX="0" pY="0" z="9" dI="0" dr="3"/>
</b>
<b name="tail" sc="1" dl="0">
<f x="43.95" y="-106.85" cocos2d_x="67.9" cocos2d_y="-281.95" kX="11.53" kY="11.53" cX="1" cY="1" pX="11.5" pY="176.3" z="10" dI="0" dr="2"/>
<f x="43.95" y="-106.85" cocos2d_x="55.75" cocos2d_y="-283.15" kX="7.56" kY="7.56" cX="1" cY="1" pX="11.5" pY="176.35" z="10" dI="0" dr="3"/>
</b>
<b name="legR" sc="1" dl="0">
<f x="42.45" y="-108.5" cocos2d_x="20.8" cocos2d_y="-151.15" kX="42.76" kY="42.76" cX="1" cY="1" pX="44.9" pY="16.6" z="11" dI="0" dr="2"/>
<f x="42.45" y="-109.5" cocos2d_x="20.8" cocos2d_y="-152.15" kX="42.76" kY="42.76" cX="1" cY="1" pX="44.85" pY="16.6" z="11" dI="0" dr="3"/>
</b>
<b name="armUpperR" sc="1" dl="0">
<f x="18.05" y="-195.6" cocos2d_x="18.05" cocos2d_y="-195.6" kX="9.3" kY="9.3" cX="1" cY="1" pX="0" pY="0" z="12" dI="0" dr="2"/>
<f x="18.05" y="-196.6" cocos2d_x="18.05" cocos2d_y="-196.6" kX="9.3" kY="9.3" cX="1" cY="1" pX="0" pY="0" z="12" dI="0" dr="3"/>
</b>
<b name="armR" sc="1" dl="0">
<f x="81.95" y="-203.4" cocos2d_x="65.85" cocos2d_y="-196.8" kX="-67.78" kY="-67.78" cX="1" cY="1" pX="12.2" pY="12.4" z="13" dI="0" dr="5"/>
</b>
<b name="handR" sc="1" dl="0">
<f x="101.1" y="-194.8" cocos2d_x="75.45" cocos2d_y="-187.15" kX="-23.26" kY="-23.26" cX="1" cY="1" pX="26.65" pY="3.1" z="14" dI="0" dr="5"/>
</b>
<b name="beardL" sc="1" dl="0">
<f x="-64.85" y="-246.25" cocos2d_x="-64.85" cocos2d_y="-246.25" kX="-11.27" kY="-11.27" cX="1" cY="1" pX="0" pY="0" z="15" dI="0" dr="2"/>
<f x="-64.85" y="-246.25" cocos2d_x="-64.85" cocos2d_y="-246.25" kX="-2.57" kY="-2.57" cX="1" cY="1" pX="0" pY="0" z="15" dI="0" dr="3"/>
</b>
<b name="beardR" sc="1" dl="0">
<f x="-19.8" y="-250.5" cocos2d_x="-22.9" cocos2d_y="-259.4" kX="0.23" kY="0.23" cX="1" cY="1" pX="3.15" pY="8.9" z="16" dI="0" dr="2"/>
<f x="-19.8" y="-250.5" cocos2d_x="-25.05" cocos2d_y="-258.25" kX="-14.77" kY="-14.77" cX="1" cY="1" pX="3.05" pY="8.85" z="16" dI="0" dr="3"/>
</b>
</mov>
</animation>
</animations>
<TextureAtlas name="Dragon" width="512" height="512">
<SubTexture name="parts-beardR" width="68" height="18" cocos2d_pX="0" cocos2d_pY="0" x="291" y="233"/>
<SubTexture name="parts-beardL" width="60" height="18" cocos2d_pX="54" cocos2d_pY="4" x="229" y="221"/>
<SubTexture name="parts-handR" width="49" height="29" cocos2d_pX="0" cocos2d_pY="0" x="82" y="240"/>
<SubTexture name="parts-armR" width="23" height="39" cocos2d_pX="0" cocos2d_pY="0" x="465" y="160"/>
<SubTexture name="parts-armUpperR" width="80" height="47" cocos2d_pX="12" cocos2d_pY="28" x="0" y="199"/>
<SubTexture name="parts-legR" width="90" height="116" cocos2d_pX="0" cocos2d_pY="0" x="401" y="0"/>
<SubTexture name="parts-tail" width="108" height="139" cocos2d_pX="0" cocos2d_pY="-63.8" x="291" y="0"/>
<SubTexture name="parts-eyeR" width="19" height="29" cocos2d_pX="8" cocos2d_pY="15" x="491" y="118"/>
<SubTexture name="parts-eyeL" width="14" height="23" cocos2d_pX="0" cocos2d_pY="0" x="493" y="0"/>
<SubTexture name="parts-head" width="169" height="197" cocos2d_pX="79.5" cocos2d_pY="160" x="0" y="0"/>
<SubTexture name="parts-hair" width="62" height="141" cocos2d_pX="0" cocos2d_pY="0" x="401" y="118"/>
<SubTexture name="parts-body" width="118" height="174" cocos2d_pX="0" cocos2d_pY="0" x="171" y="0"/>
<SubTexture name="parts-legL" width="102" height="90" cocos2d_pX="0" cocos2d_pY="0" x="291" y="141"/>
<SubTexture name="parts-handL" width="48" height="39" cocos2d_pX="0" cocos2d_pY="0" x="82" y="199"/>
<SubTexture name="parts-armL" width="24" height="40" cocos2d_pX="0" cocos2d_pY="0" x="465" y="118"/>
<SubTexture name="parts-armUpperL" width="56" height="43" cocos2d_pX="41" cocos2d_pY="16" x="229" y="176"/>
<SubTexture name="parts-tailTip" width="56" height="105" cocos2d_pX="0" cocos2d_pY="0" x="171" y="176"/>
</TextureAtlas>
</skeleton> </skeleton>

280
samples/Cpp/TestCpp/Resources/armature/cyborg.xml
View File

@ -167,281 +167,181 @@
</mov> </mov>
</animation> </animation>
<animation name="cyborg"> <animation name="cyborg">
<mov name="stand" dr="2" to="6" drTW="25" lp="1" twE="2"> <mov name="stand" dr="20" to="6" drTW="20" lp="1" twE="2">
<b name="armInside" sc="1" dl="0"> <b name="armInside" sc="1" dl="0">
<f x="5.6" y="-13.8" cocos2d_x="5.6" cocos2d_y="-13.8" kX="0" kY="0" cX="1" cY="1" pX="0" pY="0" z="0" dI="0" dr="1"/> <f x="5.6" y="-13.8" cocos2d_x="5.6" cocos2d_y="-13.8" kX="0" kY="0" cX="1" cY="1" pX="0" pY="0" z="0" dI="0" twE="0" dr="10"/>
<f x="6.6" y="-10.8" cocos2d_x="6.6" cocos2d_y="-10.8" kX="0" kY="0" cX="1" cY="1" pX="0" pY="0" z="0" dI="0" dr="1"/> <f x="6.6" y="-10.8" cocos2d_x="6.6" cocos2d_y="-10.8" kX="0" kY="0" cX="1" cY="1" pX="0" pY="0" z="0" dI="0" twE="0" dr="9"/>
<f x="5.6" y="-13.8" cocos2d_x="5.6" cocos2d_y="-13.8" kX="0" kY="0" cX="1" cY="1" pX="0" pY="0" z="0" dI="0" twE="0" dr="1"/>
</b> </b>
<b name="legL" sc="1" dl="0"> <b name="legL" sc="1" dl="0">
<f x="3" y="0" cocos2d_x="3" cocos2d_y="0" kX="-35.09" kY="-35.12" cX="1" cY="1" pX="0" pY="0" z="1" dI="0" dr="1"/> <f x="3" y="0" cocos2d_x="3" cocos2d_y="0" kX="-35.09" kY="-35.12" cX="1" cY="1" pX="0" pY="0" z="1" dI="0" twE="0" dr="10"/>
<f x="3" y="2" cocos2d_x="3" cocos2d_y="2" kX="-45.25" kY="-45.25" cX="1" cY="1" pX="0" pY="0" z="1" dI="0" dr="1"/> <f x="3" y="2" cocos2d_x="3" cocos2d_y="2" kX="-45.25" kY="-45.25" cX="1" cY="1" pX="0" pY="0" z="1" dI="0" twE="0" dr="9"/>
<f x="3" y="0" cocos2d_x="3" cocos2d_y="0" kX="-35.09" kY="-35.12" cX="1" cY="1" pX="0" pY="0" z="1" dI="0" twE="0" dr="1"/>
</b> </b>
<b name="crusL" sc="1" dl="0"> <b name="crusL" sc="1" dl="0">
<f x="14.5" y="18" cocos2d_x="14.5" cocos2d_y="18" kX="0.25" kY="0.25" cX="1" cY="1" pX="0" pY="0" z="2" dI="0" dr="1"/> <f x="14.5" y="18" cocos2d_x="14.5" cocos2d_y="18" kX="0.25" kY="0.25" cX="1" cY="1" pX="0" pY="0" z="2" dI="0" twE="0" dr="10"/>
<f x="17.5" y="17.6" cocos2d_x="17.5" cocos2d_y="17.6" kX="4.29" kY="4.29" cX="1" cY="1" pX="0" pY="0" z="2" dI="0" dr="1"/> <f x="17.5" y="17.6" cocos2d_x="17.5" cocos2d_y="17.6" kX="4.29" kY="4.29" cX="1" cY="1" pX="0" pY="0" z="2" dI="0" twE="0" dr="9"/>
<f x="14.5" y="18" cocos2d_x="14.5" cocos2d_y="18" kX="0.25" kY="0.25" cX="1" cY="1" pX="0" pY="0" z="2" dI="0" twE="0" dr="1"/>
</b> </b>
<b name="body" sc="1" dl="0.05"> <b name="body" sc="1" dl="0.05">
<f x="0" y="0" cocos2d_x="0" cocos2d_y="0" kX="9.77" kY="9.82" cX="1" cY="1" pX="0" pY="0" z="3" dI="0" dr="1"/> <f x="0" y="0" cocos2d_x="0" cocos2d_y="0" kX="9.77" kY="9.82" cX="1" cY="1" pX="0" pY="0" z="3" dI="0" twE="0" dr="10"/>
<f x="0" y="2" cocos2d_x="0" cocos2d_y="2" kX="16" kY="16" cX="1" cY="1" pX="0" pY="0" z="3" dI="0" dr="1"/> <f x="0" y="2" cocos2d_x="0" cocos2d_y="2" kX="16" kY="16" cX="1" cY="1" pX="0" pY="0" z="3" dI="0" twE="0" dr="9"/>
<f x="0" y="0" cocos2d_x="0" cocos2d_y="0" kX="9.77" kY="9.82" cX="1" cY="1" pX="0" pY="0" z="3" dI="0" twE="0" dr="1"/>
</b> </b>
<b name="crotch" sc="1" dl="0"> <b name="crotch" sc="1" dl="0">
<f x="0" y="0" cocos2d_x="0" cocos2d_y="0" kX="0" kY="0" cX="1" cY="1" pX="0" pY="0" z="4" dI="0" dr="1"/> <f x="0" y="0" cocos2d_x="0" cocos2d_y="0" kX="0" kY="0" cX="1" cY="1" pX="0" pY="0" z="4" dI="0" twE="0" dr="10"/>
<f x="0" y="2" cocos2d_x="0" cocos2d_y="2" kX="0" kY="0" cX="1" cY="1" pX="0" pY="0" z="4" dI="0" dr="1"/> <f x="0" y="2" cocos2d_x="0" cocos2d_y="2" kX="0" kY="0" cX="1" cY="1" pX="0" pY="0" z="4" dI="0" twE="0" dr="9"/>
<f x="0" y="0" cocos2d_x="0" cocos2d_y="0" kX="0" kY="0" cX="1" cY="1" pX="0" pY="0" z="4" dI="0" twE="0" dr="1"/>
</b> </b>
<b name="chest" sc="1" dl="0.1"> <b name="chest" sc="1" dl="0.1">
<f x="2.6" y="-13" cocos2d_x="2.6" cocos2d_y="-13" kX="4.77" kY="4.81" cX="1" cY="1" pX="0" pY="0" z="5" dI="0" dr="1"/> <f x="2.6" y="-13" cocos2d_x="2.6" cocos2d_y="-13" kX="4.77" kY="4.81" cX="1" cY="1" pX="0" pY="0" z="5" dI="0" twE="0" dr="10"/>
<f x="3.6" y="-11" cocos2d_x="3.6" cocos2d_y="-11" kX="6" kY="6" cX="1" cY="1" pX="0" pY="0" z="5" dI="0" dr="1"/> <f x="3.6" y="-11" cocos2d_x="3.6" cocos2d_y="-11" kX="6" kY="6" cX="1" cY="1" pX="0" pY="0" z="5" dI="0" twE="0" dr="9"/>
<f x="2.6" y="-13" cocos2d_x="2.6" cocos2d_y="-13" kX="4.77" kY="4.81" cX="1" cY="1" pX="0" pY="0" z="5" dI="0" twE="0" dr="1"/>
</b> </b>
<b name="head" sc="1" dl="0.2"> <b name="head" sc="1" dl="0.2">
<f x="4" y="-19" cocos2d_x="4" cocos2d_y="-19" kX="0" kY="0" cX="1" cY="1" pX="0" pY="0" z="6" dI="0" dr="1"/> <f x="4" y="-19" cocos2d_x="4" cocos2d_y="-19" kX="0" kY="0" cX="1" cY="1" pX="0" pY="0" z="6" dI="0" twE="0" dr="10"/>
<f x="5" y="-17" cocos2d_x="5" cocos2d_y="-17" kX="0" kY="0" cX="1" cY="1" pX="0" pY="0" z="6" dI="0" dr="1"/> <f x="5" y="-17" cocos2d_x="5" cocos2d_y="-17" kX="0" kY="0" cX="1" cY="1" pX="0" pY="0" z="6" dI="0" twE="0" dr="9"/>
<f x="4" y="-19" cocos2d_x="4" cocos2d_y="-19" kX="0" kY="0" cX="1" cY="1" pX="0" pY="0" z="6" dI="0" twE="0" dr="1"/>
</b> </b>
<b name="legR" sc="1" dl="0"> <b name="legR" sc="1" dl="0">
<f x="-3" y="0" cocos2d_x="-3" cocos2d_y="0" kX="-7" kY="-7" cX="1" cY="1" pX="0" pY="0" z="7" dI="0" dr="1"/> <f x="-3" y="0" cocos2d_x="-3" cocos2d_y="0" kX="-7" kY="-7" cX="1" cY="1" pX="0" pY="0" z="7" dI="0" twE="0" dr="10"/>
<f x="-3" y="2" cocos2d_x="-3" cocos2d_y="2" kX="-12" kY="-12" cX="1" cY="1" pX="0" pY="0" z="7" dI="0" dr="1"/> <f x="-3" y="2" cocos2d_x="-3" cocos2d_y="2" kX="-12" kY="-12" cX="1" cY="1" pX="0" pY="0" z="7" dI="0" twE="0" dr="9"/>
<f x="-3" y="0" cocos2d_x="-3" cocos2d_y="0" kX="-7" kY="-7" cX="1" cY="1" pX="0" pY="0" z="7" dI="0" twE="0" dr="1"/>
</b> </b>
<b name="crusR" sc="1" dl="0"> <b name="crusR" sc="1" dl="0">
<f x="-0.95" y="21.85" cocos2d_x="-0.95" cocos2d_y="21.85" kX="33" kY="33" cX="1" cY="1" pX="0" pY="0" z="8" dI="0" dr="1"/> <f x="-0.95" y="21.85" cocos2d_x="-0.95" cocos2d_y="21.85" kX="33" kY="33" cX="1" cY="1" pX="0" pY="0" z="8" dI="0" twE="0" dr="10"/>
<f x="1.05" y="22.85" cocos2d_x="1.05" cocos2d_y="22.85" kX="36" kY="36" cX="1" cY="1" pX="0" pY="0" z="8" dI="0" dr="1"/> <f x="1.05" y="22.85" cocos2d_x="1.05" cocos2d_y="22.85" kX="36" kY="36" cX="1" cY="1" pX="0" pY="0" z="8" dI="0" twE="0" dr="9"/>
<f x="-0.95" y="21.85" cocos2d_x="-0.95" cocos2d_y="21.85" kX="33" kY="33" cX="1" cY="1" pX="0" pY="0" z="8" dI="0" twE="0" dr="1"/>
</b> </b>
<b name="armOutside" sc="1" dl="0"> <b name="armOutside" sc="1" dl="0">
<f x="-2.4" y="-14.8" cocos2d_x="-2.4" cocos2d_y="-14.8" kX="0" kY="0" cX="1" cY="1" pX="0" pY="0" z="9" dI="0" dr="1"/> <f x="-2.4" y="-14.8" cocos2d_x="-2.4" cocos2d_y="-14.8" kX="0" kY="0" cX="1" cY="1" pX="0" pY="0" z="9" dI="0" twE="0" dr="10"/>
<f x="-1.4" y="-11.8" cocos2d_x="-1.4" cocos2d_y="-11.8" kX="0" kY="0" cX="1" cY="1" pX="0" pY="0" z="9" dI="0" dr="1"/> <f x="-1.4" y="-11.8" cocos2d_x="-1.4" cocos2d_y="-11.8" kX="0" kY="0" cX="1" cY="1" pX="0" pY="0" z="9" dI="0" twE="0" dr="9"/>
<f x="-2.4" y="-14.8" cocos2d_x="-2.4" cocos2d_y="-14.8" kX="0" kY="0" cX="1" cY="1" pX="0" pY="0" z="9" dI="0" twE="0" dr="1"/>
</b> </b>
</mov> </mov>
<mov name="run" dr="2" to="6" drTW="24" lp="1" twE="2"> <mov name="run" dr="20" to="6" drTW="20" lp="1" twE="2">
<b name="armInside" sc="1" dl="0"> <b name="armInside" sc="1" dl="0">
<f x="5.6" y="-21.8" cocos2d_x="5.6" cocos2d_y="-21.8" kX="0" kY="0" cX="1" cY="1" pX="0" pY="0" z="0" dI="0" dr="1"/> <f x="5.6" y="-21.8" cocos2d_x="5.6" cocos2d_y="-21.8" kX="0" kY="0" cX="1" cY="1" pX="0" pY="0" z="0" dI="0" twE="0" dr="10"/>
<f x="3.6" y="-11.8" cocos2d_x="3.6" cocos2d_y="-11.8" kX="0" kY="0" cX="1" cY="1" pX="0" pY="0" z="0" dI="0" dr="1"/> <f x="3.6" y="-11.8" cocos2d_x="3.6" cocos2d_y="-11.8" kX="0" kY="0" cX="1" cY="1" pX="0" pY="0" z="0" dI="0" twE="0" dr="9"/>
<f x="5.6" y="-21.8" cocos2d_x="5.6" cocos2d_y="-21.8" kX="0" kY="0" cX="1" cY="1" pX="0" pY="0" z="0" dI="0" twE="0" dr="1"/>
</b> </b>
<b name="legL" sc="1" dl="0"> <b name="legL" sc="1" dl="0">
<f x="-2" y="-4" cocos2d_x="-2" cocos2d_y="-4" kX="35" kY="35" cX="1" cY="1" pX="0" pY="0" z="1" dI="0" dr="1"/> <f x="-2" y="-4" cocos2d_x="-2" cocos2d_y="-4" kX="35" kY="35" cX="1" cY="1" pX="0" pY="0" z="1" dI="0" twE="0" dr="10"/>
<f x="2" y="4" cocos2d_x="2" cocos2d_y="4" kX="-70" kY="-70" cX="1" cY="1" pX="0" pY="0" z="1" dI="0" dr="1"/> <f x="2" y="4" cocos2d_x="2" cocos2d_y="4" kX="-70" kY="-70" cX="1" cY="1" pX="0" pY="0" z="1" dI="0" twE="0" dr="9"/>
<f x="-2" y="-4" cocos2d_x="-2" cocos2d_y="-4" kX="35" kY="35" cX="1" cY="1" pX="0" pY="0" z="1" dI="0" twE="0" dr="1"/>
</b> </b>
<b name="crusL" sc="1" dl="-0.15"> <b name="crusL" sc="1" dl="-0.15">
<f x="-16.35" y="16.55" cocos2d_x="-16.35" cocos2d_y="16.55" kX="50" kY="50" cX="1" cY="1" pX="0" pY="0" z="2" dI="0" dr="1"/> <f x="-16.35" y="16.55" cocos2d_x="-16.35" cocos2d_y="16.55" kX="50" kY="50" cX="1" cY="1" pX="0" pY="0" z="2" dI="0" twE="0" dr="10"/>
<f x="25.55" y="12.55" cocos2d_x="25.55" cocos2d_y="12.55" kX="25" kY="25" cX="1" cY="1" pX="0" pY="0" z="2" dI="0" dr="1"/> <f x="25.55" y="12.55" cocos2d_x="25.55" cocos2d_y="12.55" kX="25" kY="25" cX="1" cY="1" pX="0" pY="0" z="2" dI="0" twE="0" dr="9"/>
<f x="-16.35" y="16.55" cocos2d_x="-16.35" cocos2d_y="16.55" kX="50" kY="50" cX="1" cY="1" pX="0" pY="0" z="2" dI="0" twE="0" dr="1"/>
</b> </b>
<b name="body" sc="0.5" dl="0"> <b name="body" sc="0.5" dl="0">
<f x="0" y="-5" cocos2d_x="0" cocos2d_y="-5" kX="10" kY="10" cX="1" cY="1" pX="0" pY="0" z="3" dI="0" dr="1"/> <f x="0" y="-5" cocos2d_x="0" cocos2d_y="-5" kX="10" kY="10" cX="1" cY="1" pX="0" pY="0" z="3" dI="0" twE="0" dr="10"/>
<f x="0" y="5" cocos2d_x="0" cocos2d_y="5" kX="12" kY="12" cX="1" cY="1" pX="0" pY="0" z="3" dI="0" dr="1"/> <f x="0" y="5" cocos2d_x="0" cocos2d_y="5" kX="12" kY="12" cX="1" cY="1" pX="0" pY="0" z="3" dI="0" twE="0" dr="9"/>
<f x="0" y="-5" cocos2d_x="0" cocos2d_y="-5" kX="10" kY="10" cX="1" cY="1" pX="0" pY="0" z="3" dI="0" twE="0" dr="1"/>
</b> </b>
<b name="crotch" sc="0.5" dl="0"> <b name="crotch" sc="0.5" dl="0">
<f x="0" y="-5" cocos2d_x="0" cocos2d_y="-5" kX="0" kY="0" cX="1" cY="1" pX="0" pY="0" z="4" dI="0" dr="1"/> <f x="0" y="-5" cocos2d_x="0" cocos2d_y="-5" kX="0" kY="0" cX="1" cY="1" pX="0" pY="0" z="4" dI="0" twE="0" dr="10"/>
<f x="0" y="5" cocos2d_x="0" cocos2d_y="5" kX="0" kY="0" cX="1" cY="1" pX="0" pY="0" z="4" dI="0" dr="1"/> <f x="0" y="5" cocos2d_x="0" cocos2d_y="5" kX="0" kY="0" cX="1" cY="1" pX="0" pY="0" z="4" dI="0" twE="0" dr="9"/>
<f x="0" y="-5" cocos2d_x="0" cocos2d_y="-5" kX="0" kY="0" cX="1" cY="1" pX="0" pY="0" z="4" dI="0" twE="0" dr="1"/>
</b> </b>
<b name="chest" sc="0.5" dl="0"> <b name="chest" sc="0.5" dl="0">
<f x="2.65" y="-19.75" cocos2d_x="2.65" cocos2d_y="-19.75" kX="5" kY="5" cX="1" cY="1" pX="0" pY="0" z="5" dI="0" dr="1"/> <f x="2.65" y="-19.75" cocos2d_x="2.65" cocos2d_y="-19.75" kX="5" kY="5" cX="1" cY="1" pX="0" pY="0" z="5" dI="0" twE="0" dr="10"/>
<f x="3.85" y="-9.5" cocos2d_x="3.85" cocos2d_y="-9.5" kX="6" kY="6" cX="1" cY="1" pX="0" pY="0" z="5" dI="0" dr="1"/> <f x="3.85" y="-9.5" cocos2d_x="3.85" cocos2d_y="-9.5" kX="6" kY="6" cX="1" cY="1" pX="0" pY="0" z="5" dI="0" twE="0" dr="9"/>
<f x="2.65" y="-19.75" cocos2d_x="2.65" cocos2d_y="-19.75" kX="5" kY="5" cX="1" cY="1" pX="0" pY="0" z="5" dI="0" twE="0" dr="1"/>
</b> </b>
<b name="head" sc="0.5" dl="0"> <b name="head" sc="0.5" dl="0">
<f x="4" y="-25" cocos2d_x="4" cocos2d_y="-25" kX="0" kY="0" cX="1" cY="1" pX="0" pY="0" z="6" dI="0" dr="1"/> <f x="4" y="-25" cocos2d_x="4" cocos2d_y="-25" kX="0" kY="0" cX="1" cY="1" pX="0" pY="0" z="6" dI="0" twE="0" dr="10"/>
<f x="5" y="-15" cocos2d_x="5" cocos2d_y="-15" kX="0" kY="0" cX="1" cY="1" pX="0" pY="0" z="6" dI="0" dr="1"/> <f x="5" y="-15" cocos2d_x="5" cocos2d_y="-15" kX="0" kY="0" cX="1" cY="1" pX="0" pY="0" z="6" dI="0" twE="0" dr="9"/>
<f x="4" y="-25" cocos2d_x="4" cocos2d_y="-25" kX="0" kY="0" cX="1" cY="1" pX="0" pY="0" z="6" dI="0" twE="0" dr="1"/>
</b> </b>
<b name="legR" sc="1" dl="0"> <b name="legR" sc="1" dl="0">
<f x="2" y="-6" cocos2d_x="2" cocos2d_y="-6" kX="-70" kY="-70" cX="1" cY="1" pX="0" pY="0" z="7" dI="0" dr="1"/> <f x="2" y="-6" cocos2d_x="2" cocos2d_y="-6" kX="-70" kY="-70" cX="1" cY="1" pX="0" pY="0" z="7" dI="0" twE="0" dr="10"/>
<f x="-2" y="6" cocos2d_x="-2" cocos2d_y="6" kX="35" kY="35" cX="1" cY="1" pX="0" pY="0" z="7" dI="0" dr="1"/> <f x="-2" y="6" cocos2d_x="-2" cocos2d_y="6" kX="35" kY="35" cX="1" cY="1" pX="0" pY="0" z="7" dI="0" twE="0" dr="9"/>
<f x="2" y="-6" cocos2d_x="2" cocos2d_y="-6" kX="-70" kY="-70" cX="1" cY="1" pX="0" pY="0" z="7" dI="0" twE="0" dr="1"/>
</b> </b>
<b name="crusR" sc="1" dl="-0.15"> <b name="crusR" sc="1" dl="-0.15">
<f x="25.55" y="2.55" cocos2d_x="25.55" cocos2d_y="2.55" kX="25" kY="25" cX="1" cY="1" pX="0" pY="0" z="8" dI="0" dr="1"/> <f x="25.55" y="2.55" cocos2d_x="25.55" cocos2d_y="2.55" kX="25" kY="25" cX="1" cY="1" pX="0" pY="0" z="8" dI="0" twE="0" dr="10"/>
<f x="-16.35" y="26.55" cocos2d_x="-16.35" cocos2d_y="26.55" kX="50" kY="50" cX="1" cY="1" pX="0" pY="0" z="8" dI="0" dr="1"/> <f x="-16.35" y="26.55" cocos2d_x="-16.35" cocos2d_y="26.55" kX="50" kY="50" cX="1" cY="1" pX="0" pY="0" z="8" dI="0" twE="0" dr="9"/>
<f x="25.55" y="2.55" cocos2d_x="25.55" cocos2d_y="2.55" kX="25" kY="25" cX="1" cY="1" pX="0" pY="0" z="8" dI="0" twE="0" dr="1"/>
</b> </b>
<b name="armOutside" sc="1" dl="0"> <b name="armOutside" sc="1" dl="0">
<f x="-2.4" y="-22.8" cocos2d_x="-2.4" cocos2d_y="-22.8" kX="0" kY="0" cX="1" cY="1" pX="0" pY="0" z="9" dI="0" dr="1"/> <f x="-2.4" y="-22.8" cocos2d_x="-2.4" cocos2d_y="-22.8" kX="0" kY="0" cX="1" cY="1" pX="0" pY="0" z="9" dI="0" twE="0" dr="10"/>
<f x="5.6" y="-12.8" cocos2d_x="5.6" cocos2d_y="-12.8" kX="0" kY="0" cX="1" cY="1" pX="0" pY="0" z="9" dI="0" dr="1"/> <f x="5.6" y="-12.8" cocos2d_x="5.6" cocos2d_y="-12.8" kX="0" kY="0" cX="1" cY="1" pX="0" pY="0" z="9" dI="0" twE="0" dr="9"/>
<f x="-2.4" y="-22.8" cocos2d_x="-2.4" cocos2d_y="-22.8" kX="0" kY="0" cX="1" cY="1" pX="0" pY="0" z="9" dI="0" twE="0" dr="1"/>
</b> </b>
</mov> </mov>
<mov name="runBack" dr="2" to="4" drTW="30" lp="1" twE="2"> <mov name="runBack" dr="20" to="4" drTW="20" lp="1" twE="2">
<b name="armInside" sc="1" dl="0"> <b name="armInside" sc="1" dl="0">
<f x="-2.4" y="-21.8" cocos2d_x="-2.4" cocos2d_y="-21.8" kX="0" kY="0" cX="1" cY="1" pX="0" pY="0" z="0" dI="0" twE="0" dr="10"/>
<f x="-2.4" y="-17.8" cocos2d_x="-2.4" cocos2d_y="-17.8" kX="0" kY="0" cX="1" cY="1" pX="0" pY="0" z="0" dI="0" twE="0" dr="9"/>
<f x="-2.4" y="-21.8" cocos2d_x="-2.4" cocos2d_y="-21.8" kX="0" kY="0" cX="1" cY="1" pX="0" pY="0" z="0" dI="0" dr="1"/> <f x="-2.4" y="-21.8" cocos2d_x="-2.4" cocos2d_y="-21.8" kX="0" kY="0" cX="1" cY="1" pX="0" pY="0" z="0" dI="0" dr="1"/>
<f x="-2.4" y="-17.8" cocos2d_x="-2.4" cocos2d_y="-17.8" kX="0" kY="0" cX="1" cY="1" pX="0" pY="0" z="0" dI="0" dr="1"/>
</b> </b>
<b name="legL" sc="1" dl="0"> <b name="legL" sc="1" dl="0">
<f x="3" y="-6" cocos2d_x="3" cocos2d_y="-6" kX="-45" kY="-45" cX="1" cY="1" pX="0" pY="0" z="1" dI="0" twE="0" dr="10"/>
<f x="-2.95" y="0" cocos2d_x="-2.95" cocos2d_y="0" kX="15" kY="15" cX="1" cY="1" pX="0" pY="0" z="1" dI="0" twE="0" dr="9"/>
<f x="3" y="-6" cocos2d_x="3" cocos2d_y="-6" kX="-45" kY="-45" cX="1" cY="1" pX="0" pY="0" z="1" dI="0" dr="1"/> <f x="3" y="-6" cocos2d_x="3" cocos2d_y="-6" kX="-45" kY="-45" cX="1" cY="1" pX="0" pY="0" z="1" dI="0" dr="1"/>
<f x="-2.95" y="0" cocos2d_x="-2.95" cocos2d_y="0" kX="15" kY="15" cX="1" cY="1" pX="0" pY="0" z="1" dI="0" dr="1"/>
</b> </b>
<b name="crusL" sc="1" dl="-0.85"> <b name="crusL" sc="1" dl="-0.85">
<f x="17.9" y="9.3" cocos2d_x="17.9" cocos2d_y="9.3" kX="45" kY="45" cX="1" cY="1" pX="0" pY="0" z="2" dI="0" twE="0" dr="10"/>
<f x="-8.3" y="21.55" cocos2d_x="-8.3" cocos2d_y="21.55" kX="9" kY="9" cX="1" cY="1" pX="0" pY="0" z="2" dI="0" twE="0" dr="9"/>
<f x="17.9" y="9.3" cocos2d_x="17.9" cocos2d_y="9.3" kX="45" kY="45" cX="1" cY="1" pX="0" pY="0" z="2" dI="0" dr="1"/> <f x="17.9" y="9.3" cocos2d_x="17.9" cocos2d_y="9.3" kX="45" kY="45" cX="1" cY="1" pX="0" pY="0" z="2" dI="0" dr="1"/>
<f x="-8.3" y="21.55" cocos2d_x="-8.3" cocos2d_y="21.55" kX="9" kY="9" cX="1" cY="1" pX="0" pY="0" z="2" dI="0" dr="1"/>
</b> </b>
<b name="body" sc="0.5" dl="0"> <b name="body" sc="0.5" dl="0">
<f x="0" y="-5" cocos2d_x="0" cocos2d_y="-5" kX="-6" kY="-6" cX="1" cY="1" pX="0" pY="0" z="3" dI="0" twE="0" dr="10"/>
<f x="0" y="-1" cocos2d_x="0" cocos2d_y="-1" kX="-6" kY="-6" cX="1" cY="1" pX="0" pY="0" z="3" dI="0" twE="0" dr="9"/>
<f x="0" y="-5" cocos2d_x="0" cocos2d_y="-5" kX="-6" kY="-6" cX="1" cY="1" pX="0" pY="0" z="3" dI="0" dr="1"/> <f x="0" y="-5" cocos2d_x="0" cocos2d_y="-5" kX="-6" kY="-6" cX="1" cY="1" pX="0" pY="0" z="3" dI="0" dr="1"/>
<f x="0" y="-1" cocos2d_x="0" cocos2d_y="-1" kX="-6" kY="-6" cX="1" cY="1" pX="0" pY="0" z="3" dI="0" dr="1"/>
</b> </b>
<b name="crotch" sc="0.5" dl="0.5"> <b name="crotch" sc="0.5" dl="0.5">
<f x="0" y="-5" cocos2d_x="0" cocos2d_y="-5" kX="0" kY="0" cX="1" cY="1" pX="0" pY="0" z="4" dI="0" twE="0" dr="10"/>
<f x="0" y="-1" cocos2d_x="0" cocos2d_y="-1" kX="0" kY="0" cX="1" cY="1" pX="0" pY="0" z="4" dI="0" twE="0" dr="9"/>
<f x="0" y="-5" cocos2d_x="0" cocos2d_y="-5" kX="0" kY="0" cX="1" cY="1" pX="0" pY="0" z="4" dI="0" dr="1"/> <f x="0" y="-5" cocos2d_x="0" cocos2d_y="-5" kX="0" kY="0" cX="1" cY="1" pX="0" pY="0" z="4" dI="0" dr="1"/>
<f x="0" y="-1" cocos2d_x="0" cocos2d_y="-1" kX="0" kY="0" cX="1" cY="1" pX="0" pY="0" z="4" dI="0" dr="1"/>
</b> </b>
<b name="chest" sc="0.5" dl="0"> <b name="chest" sc="0.5" dl="0">
<f x="-2.15" y="-18.5" cocos2d_x="-2.15" cocos2d_y="-18.5" kX="-3" kY="-3" cX="1" cY="1" pX="0" pY="0" z="5" dI="0" twE="0" dr="10"/>
<f x="-2.15" y="-14.5" cocos2d_x="-2.15" cocos2d_y="-14.5" kX="-3" kY="-3" cX="1" cY="1" pX="0" pY="0" z="5" dI="0" twE="0" dr="9"/>
<f x="-2.15" y="-18.5" cocos2d_x="-2.15" cocos2d_y="-18.5" kX="-3" kY="-3" cX="1" cY="1" pX="0" pY="0" z="5" dI="0" dr="1"/> <f x="-2.15" y="-18.5" cocos2d_x="-2.15" cocos2d_y="-18.5" kX="-3" kY="-3" cX="1" cY="1" pX="0" pY="0" z="5" dI="0" dr="1"/>
<f x="-2.15" y="-14.5" cocos2d_x="-2.15" cocos2d_y="-14.5" kX="-3" kY="-3" cX="1" cY="1" pX="0" pY="0" z="5" dI="0" dr="1"/>
</b> </b>
<b name="head" sc="0.5" dl="0"> <b name="head" sc="0.5" dl="0">
<f x="-3" y="-25" cocos2d_x="-3" cocos2d_y="-25" kX="0" kY="0" cX="1" cY="1" pX="0" pY="0" z="6" dI="0" twE="0" dr="10"/>
<f x="-3" y="-21" cocos2d_x="-3" cocos2d_y="-21" kX="0" kY="0" cX="1" cY="1" pX="0" pY="0" z="6" dI="0" twE="0" dr="9"/>
<f x="-3" y="-25" cocos2d_x="-3" cocos2d_y="-25" kX="0" kY="0" cX="1" cY="1" pX="0" pY="0" z="6" dI="0" dr="1"/> <f x="-3" y="-25" cocos2d_x="-3" cocos2d_y="-25" kX="0" kY="0" cX="1" cY="1" pX="0" pY="0" z="6" dI="0" dr="1"/>
<f x="-3" y="-21" cocos2d_x="-3" cocos2d_y="-21" kX="0" kY="0" cX="1" cY="1" pX="0" pY="0" z="6" dI="0" dr="1"/>
</b> </b>
<b name="legR" sc="1" dl="0"> <b name="legR" sc="1" dl="0">
<f x="-3" y="-4" cocos2d_x="-3" cocos2d_y="-4" kX="15" kY="15" cX="1" cY="1" pX="0" pY="0" z="7" dI="0" twE="0" dr="10"/>
<f x="3" y="-1.95" cocos2d_x="3" cocos2d_y="-1.95" kX="-45" kY="-45" cX="1" cY="1" pX="0" pY="0" z="7" dI="0" twE="0" dr="9"/>
<f x="-3" y="-4" cocos2d_x="-3" cocos2d_y="-4" kX="15" kY="15" cX="1" cY="1" pX="0" pY="0" z="7" dI="0" dr="1"/> <f x="-3" y="-4" cocos2d_x="-3" cocos2d_y="-4" kX="15" kY="15" cX="1" cY="1" pX="0" pY="0" z="7" dI="0" dr="1"/>
<f x="3" y="-1.95" cocos2d_x="3" cocos2d_y="-1.95" kX="-45" kY="-45" cX="1" cY="1" pX="0" pY="0" z="7" dI="0" dr="1"/>
</b> </b>
<b name="crusR" sc="1" dl="-0.85"> <b name="crusR" sc="1" dl="-0.85">
<f x="-8.35" y="17.55" cocos2d_x="-8.35" cocos2d_y="17.55" kX="9" kY="9" cX="1" cY="1" pX="0" pY="0" z="8" dI="0" twE="0" dr="10"/>
<f x="17.9" y="13.3" cocos2d_x="17.9" cocos2d_y="13.3" kX="45" kY="45" cX="1" cY="1" pX="0" pY="0" z="8" dI="0" twE="0" dr="9"/>
<f x="-8.35" y="17.55" cocos2d_x="-8.35" cocos2d_y="17.55" kX="9" kY="9" cX="1" cY="1" pX="0" pY="0" z="8" dI="0" dr="1"/> <f x="-8.35" y="17.55" cocos2d_x="-8.35" cocos2d_y="17.55" kX="9" kY="9" cX="1" cY="1" pX="0" pY="0" z="8" dI="0" dr="1"/>
<f x="17.9" y="13.3" cocos2d_x="17.9" cocos2d_y="13.3" kX="45" kY="45" cX="1" cY="1" pX="0" pY="0" z="8" dI="0" dr="1"/>
</b> </b>
<b name="armOutside" sc="1" dl="0"> <b name="armOutside" sc="1" dl="0">
<f x="-3.4" y="-20.8" cocos2d_x="-3.4" cocos2d_y="-20.8" kX="0" kY="0" cX="1" cY="1" pX="0" pY="0" z="9" dI="0" twE="0" dr="10"/>
<f x="-4.4" y="-17.8" cocos2d_x="-4.4" cocos2d_y="-17.8" kX="0" kY="0" cX="1" cY="1" pX="0" pY="0" z="9" dI="0" twE="0" dr="9"/>
<f x="-3.4" y="-20.8" cocos2d_x="-3.4" cocos2d_y="-20.8" kX="0" kY="0" cX="1" cY="1" pX="0" pY="0" z="9" dI="0" dr="1"/> <f x="-3.4" y="-20.8" cocos2d_x="-3.4" cocos2d_y="-20.8" kX="0" kY="0" cX="1" cY="1" pX="0" pY="0" z="9" dI="0" dr="1"/>
<f x="-4.4" y="-17.8" cocos2d_x="-4.4" cocos2d_y="-17.8" kX="0" kY="0" cX="1" cY="1" pX="0" pY="0" z="9" dI="0" dr="1"/>
</b> </b>
</mov> </mov>
<mov name="squat" dr="1" to="6">
<b name="armInside" sc="1" dl="0">
<f x="5.6" y="16.2" cocos2d_x="5.6" cocos2d_y="16.2" kX="0" kY="0" cX="1" cY="1" pX="0" pY="0" z="0" dI="0" dr="1"/>
</b>
<b name="legL" sc="1" dl="0">
<f x="2" y="31" cocos2d_x="2" cocos2d_y="31" kX="-120" kY="-120" cX="1" cY="1" pX="0" pY="0" z="1" dI="0" dr="1"/>
</b>
<b name="crusL" sc="1" dl="0">
<f x="21.1" y="21.2" cocos2d_x="21.1" cocos2d_y="21.2" kX="-13.5" kY="-13.5" cX="1" cY="1" pX="0" pY="0" z="2" dI="0" dr="1"/>
</b>
<b name="body" sc="1" dl="0">
<f x="0" y="32" cocos2d_x="0" cocos2d_y="32" kX="9" kY="9" cX="1" cY="1" pX="0" pY="0" z="3" dI="0" dr="1"/>
</b>
<b name="crotch" sc="1" dl="0">
<f x="0" y="32" cocos2d_x="0" cocos2d_y="32" kX="0" kY="0" cX="1" cY="1" pX="0" pY="0" z="4" dI="0" dr="1"/>
</b>
<b name="chest" sc="1" dl="0">
<f x="1.6" y="18" cocos2d_x="1.6" cocos2d_y="18" kX="6" kY="6" cX="1" cY="1" pX="0" pY="0" z="5" dI="0" dr="1"/>
</b>
<b name="head" sc="1" dl="0">
<f x="4" y="13" cocos2d_x="4" cocos2d_y="13" kX="0" kY="0" cX="1" cY="1" pX="0" pY="0" z="6" dI="0" dr="1"/>
</b>
<b name="legR" sc="1" dl="0">
<f x="-2" y="31" cocos2d_x="-2" cocos2d_y="31" kX="-30" kY="-30" cX="1" cY="1" pX="0" pY="0" z="7" dI="0" dr="1"/>
</b>
<b name="crusR" sc="1" dl="0">
<f x="7.85" y="49.45" cocos2d_x="7.85" cocos2d_y="49.45" kX="89.99" kY="89.99" cX="1" cY="1" pX="0" pY="0" z="8" dI="0" dr="1"/>
</b>
<b name="armOutside" sc="1" dl="0">
<f x="-2.4" y="15.2" cocos2d_x="-2.4" cocos2d_y="15.2" kX="0" kY="0" cX="1" cY="1" pX="0" pY="0" z="9" dI="0" dr="1"/>
</b>
</mov>
<mov name="jump" dr="1" to="6">
<b name="armInside" sc="1" dl="0">
<f x="7.6" y="-15.8" cocos2d_x="7.6" cocos2d_y="-15.8" kX="0" kY="0" cX="1" cY="1" pX="0" pY="0" z="0" dI="0" dr="1"/>
</b>
<b name="legL" sc="1" dl="0">
<f x="-2" y="1" cocos2d_x="-2" cocos2d_y="1" kX="30" kY="30" cX="1" cY="1" pX="0" pY="0" z="1" dI="0" dr="1"/>
</b>
<b name="crusL" sc="1" dl="0">
<f x="-12.9" y="20.2" cocos2d_x="-12.9" cocos2d_y="20.2" kX="30" kY="30" cX="1" cY="1" pX="0" pY="0" z="2" dI="0" dr="1"/>
</b>
<b name="body" sc="1" dl="0">
<f x="0" y="0" cocos2d_x="0" cocos2d_y="0" kX="15" kY="15" cX="1" cY="1" pX="0" pY="0" z="3" dI="0" dr="1"/>
</b>
<b name="crotch" sc="1" dl="0">
<f x="0" y="0" cocos2d_x="0" cocos2d_y="0" kX="0" kY="0" cX="1" cY="1" pX="0" pY="0" z="4" dI="0" dr="1"/>
</b>
<b name="chest" sc="1" dl="0">
<f x="3.6" y="-14" cocos2d_x="3.6" cocos2d_y="-14" kX="10" kY="10" cX="1" cY="1" pX="0" pY="0" z="5" dI="0" dr="1"/>
</b>
<b name="head" sc="1" dl="0">
<f x="5" y="-20" cocos2d_x="5" cocos2d_y="-20" kX="0" kY="0" cX="1" cY="1" pX="0" pY="0" z="6" dI="0" dr="1"/>
</b>
<b name="legR" sc="1" dl="0">
<f x="2" y="-1" cocos2d_x="2" cocos2d_y="-1" kX="-60" kY="-60" cX="1" cY="1" pX="0" pY="0" z="7" dI="0" dr="1"/>
</b>
<b name="crusR" sc="1" dl="0">
<f x="20.85" y="10.45" cocos2d_x="20.85" cocos2d_y="10.45" kX="60" kY="60" cX="1" cY="1" pX="0" pY="0" z="8" dI="0" dr="1"/>
</b>
<b name="armOutside" sc="1" dl="0">
<f x="-0.4" y="-16.8" cocos2d_x="-0.4" cocos2d_y="-16.8" kX="0" kY="0" cX="1" cY="1" pX="0" pY="0" z="9" dI="0" dr="1"/>
</b>
</mov>
<mov name="fall" dr="1" to="6">
<b name="armInside" sc="1" dl="0">
<f x="-1.4" y="-14.8" cocos2d_x="-1.4" cocos2d_y="-14.8" kX="0" kY="0" cX="1" cY="1" pX="0" pY="0" z="0" dI="0" dr="1"/>
</b>
<b name="legL" sc="1" dl="0">
<f x="2" y="0" cocos2d_x="2" cocos2d_y="0" kX="-55" kY="-55" cX="1" cY="1" pX="0" pY="0" z="1" dI="0" dr="1"/>
</b>
<b name="crusL" sc="1" dl="0">
<f x="20.1" y="13.2" cocos2d_x="20.1" cocos2d_y="13.2" kX="36" kY="36" cX="1" cY="1" pX="0" pY="0" z="2" dI="0" dr="1"/>
</b>
<b name="body" sc="1" dl="0">
<f x="0" y="0" cocos2d_x="0" cocos2d_y="0" kX="-9" kY="-9" cX="1" cY="1" pX="0" pY="0" z="3" dI="0" dr="1"/>
</b>
<b name="crotch" sc="1" dl="0">
<f x="0" y="0" cocos2d_x="0" cocos2d_y="0" kX="0" kY="0" cX="1" cY="1" pX="0" pY="0" z="4" dI="0" dr="1"/>
</b>
<b name="chest" sc="1" dl="0">
<f x="-3.4" y="-14" cocos2d_x="-3.4" cocos2d_y="-14" kX="-6" kY="-6" cX="1" cY="1" pX="0" pY="0" z="5" dI="0" dr="1"/>
</b>
<b name="head" sc="1" dl="0">
<f x="-5" y="-20" cocos2d_x="-5" cocos2d_y="-20" kX="0" kY="0" cX="1" cY="1" pX="0" pY="0" z="6" dI="0" dr="1"/>
</b>
<b name="legR" sc="1" dl="0">
<f x="-2" y="0" cocos2d_x="-2" cocos2d_y="0" kX="-15" kY="-15" cX="1" cY="1" pX="0" pY="0" z="7" dI="0" dr="1"/>
</b>
<b name="crusR" sc="1" dl="0">
<f x="3.85" y="21.45" cocos2d_x="3.85" cocos2d_y="21.45" kX="-15" kY="-15" cX="1" cY="1" pX="0" pY="0" z="8" dI="0" dr="1"/>
</b>
<b name="armOutside" sc="1" dl="0">
<f x="-9.4" y="-15.8" cocos2d_x="-9.4" cocos2d_y="-15.8" kX="0" kY="0" cX="1" cY="1" pX="0" pY="0" z="9" dI="0" dr="1"/>
</b>
</mov>
<mov name="fallEnd" dr="4" to="4" drTW="4" lp="0" twE="NaN">
<b name="armInside" sc="1" dl="0">
<f x="9.6" y="-4.8" cocos2d_x="9.6" cocos2d_y="-4.8" kX="0" kY="0" cX="1" cY="1" pX="0" pY="0" z="0" dI="0" dr="4"/>
</b>
<b name="legL" sc="1" dl="0">
<f x="4" y="7" cocos2d_x="4" cocos2d_y="7" kX="-60" kY="-60" cX="1" cY="1" pX="0" pY="0" z="1" dI="0" dr="4"/>
</b>
<b name="crusL" sc="1" dl="0">
<f x="22.5" y="18" cocos2d_x="22.5" cocos2d_y="18" kX="0" kY="0" cX="1" cY="1" pX="0" pY="0" z="2" dI="0" dr="4"/>
</b>
<b name="body" sc="1" dl="0">
<f x="0" y="7" cocos2d_x="0" cocos2d_y="7" kX="23.52" kY="23.57" cX="1" cY="1" pX="0" pY="0" z="3" dI="0" dr="4"/>
</b>
<b name="crotch" sc="1" dl="0">
<f x="0" y="7" cocos2d_x="0" cocos2d_y="7" kX="0" kY="0" cX="1" cY="1" pX="0" pY="0" z="4" dI="0" dr="4"/>
</b>
<b name="chest" sc="1" dl="0">
<f x="6.6" y="-4" cocos2d_x="6.6" cocos2d_y="-4" kX="4.77" kY="4.81" cX="1" cY="1" pX="0" pY="0" z="5" dI="0" dr="4"/>
</b>
<b name="head" sc="1" dl="0">
<f x="8" y="-10" cocos2d_x="8" cocos2d_y="-10" kX="0" kY="0" cX="1" cY="1" pX="0" pY="0" z="6" dI="0" dr="4"/>
</b>
<b name="legR" sc="1" dl="0">
<f x="-4" y="7" cocos2d_x="-4" cocos2d_y="7" kX="-30" kY="-30" cX="1" cY="1" pX="0" pY="0" z="7" dI="0" dr="4"/>
</b>
<b name="crusR" sc="1" dl="0">
<f x="6" y="26" cocos2d_x="6" cocos2d_y="26" kX="45" kY="45" cX="1" cY="1" pX="0" pY="0" z="8" dI="0" dr="4"/>
</b>
<b name="armOutside" sc="1" dl="0">
<f x="1.6" y="-5.8" cocos2d_x="1.6" cocos2d_y="-5.8" kX="0" kY="0" cX="1" cY="1" pX="0" pY="0" z="9" dI="0" dr="4"/>
</b>
<f st="0" dr="3"/>
<f st="3" dr="1" mov="stand"/>
</mov>
</animation> </animation>
</animations> </animations>
<TextureAtlas name="Cyborg" width="128" height="128"> <TextureAtlas name="Cyborg" width="128" height="128">
<SubTexture name="CyborgFolder-RightArm" width="10" height="19" cocos2d_pX="5" cocos2d_pY="4" x="28" y="89"/> <SubTexture name="CyborgFolder-LeftShoulder" width="14" height="19" cocos2d_pX="7" cocos2d_pY="5" x="0" y="89"/>
<SubTexture name="CyborgFolder-LeftArm" width="10" height="19" cocos2d_pX="5" cocos2d_pY="4" x="28" y="89"/>
<SubTexture name="CyborgFolder-LeftHand" width="7" height="9" cocos2d_pX="3" cocos2d_pY="0" x="119" y="11"/>
<SubTexture name="CyborgFolder-RightArm" width="10" height="19" cocos2d_pX="5" cocos2d_pY="4" x="16" y="89"/>
<SubTexture name="CyborgFolder-RightHand" width="7" height="9" cocos2d_pX="3" cocos2d_pY="0" x="119" y="0"/> <SubTexture name="CyborgFolder-RightHand" width="7" height="9" cocos2d_pX="3" cocos2d_pY="0" x="119" y="0"/>
<SubTexture name="CyborgFolder-RightShoulder" width="14" height="19" cocos2d_pX="7" cocos2d_pY="5" x="0" y="89"/> <SubTexture name="CyborgFolder-RightShoulder" width="14" height="19" cocos2d_pX="7" cocos2d_pY="5" x="72" y="71"/>
<SubTexture name="CyborgFolder-weapon4" width="101" height="23" cocos2d_pX="28" cocos2d_pY="13" x="0" y="0"/> <SubTexture name="CyborgFolder-weapon4" width="101" height="23" cocos2d_pX="28" cocos2d_pY="13" x="0" y="0"/>
<SubTexture name="CyborgFolder-weapon3" width="92" height="22" cocos2d_pX="23" cocos2d_pY="0" x="0" y="25"/> <SubTexture name="CyborgFolder-weapon3" width="92" height="22" cocos2d_pX="23" cocos2d_pY="0" x="0" y="25"/>
<SubTexture name="CyborgFolder-weapon2" width="91" height="20" cocos2d_pX="20" cocos2d_pY="14" x="0" y="49"/> <SubTexture name="CyborgFolder-weapon2" width="91" height="20" cocos2d_pX="20" cocos2d_pY="14" x="0" y="49"/>
<SubTexture name="CyborgFolder-weapon1" width="70" height="16" cocos2d_pX="27" cocos2d_pY="14" x="0" y="71"/> <SubTexture name="CyborgFolder-weapon1" width="70" height="16" cocos2d_pX="27" cocos2d_pY="14" x="0" y="71"/>
<SubTexture name="CyborgFolder-LeftShoulder" width="14" height="19" cocos2d_pX="7" cocos2d_pY="5" x="72" y="71"/> <SubTexture name="CyborgFolder-RightThigh" width="14" height="28" cocos2d_pX="7" cocos2d_pY="5" x="93" y="64"/>
<SubTexture name="CyborgFolder-LeftArm" width="10" height="19" cocos2d_pX="5" cocos2d_pY="4" x="16" y="89"/>
<SubTexture name="CyborgFolder-LeftHand" width="7" height="9" cocos2d_pX="3" cocos2d_pY="0" x="119" y="11"/>
<SubTexture name="CyborgFolder-RightThigh" width="14" height="28" cocos2d_pX="7" cocos2d_pY="5" x="109" y="64"/>
<SubTexture name="CyborgFolder-Head" width="32" height="18" cocos2d_pX="20" cocos2d_pY="18" x="94" y="44"/> <SubTexture name="CyborgFolder-Head" width="32" height="18" cocos2d_pX="20" cocos2d_pY="18" x="94" y="44"/>
<SubTexture name="CyborgFolder-Chest" width="18" height="9" cocos2d_pX="6" cocos2d_pY="7" x="40" y="89"/> <SubTexture name="CyborgFolder-Chest" width="18" height="9" cocos2d_pX="6" cocos2d_pY="7" x="40" y="89"/>
<SubTexture name="CyborgFolder-Hip" width="4" height="4" cocos2d_pX="2" cocos2d_pY="2" x="119" y="22"/> <SubTexture name="CyborgFolder-Hip" width="4" height="4" cocos2d_pX="2" cocos2d_pY="2" x="119" y="22"/>
<SubTexture name="CyborgFolder-Trunk" width="10" height="16" cocos2d_pX="3" cocos2d_pY="14" x="60" y="89"/> <SubTexture name="CyborgFolder-Trunk" width="10" height="16" cocos2d_pX="3" cocos2d_pY="14" x="60" y="89"/>
<SubTexture name="CyborgFolder-Leg" width="14" height="42" cocos2d_pX="7" cocos2d_pY="6" x="103" y="0"/> <SubTexture name="CyborgFolder-Leg" width="14" height="42" cocos2d_pX="7" cocos2d_pY="6" x="103" y="0"/>
<SubTexture name="CyborgFolder-LeftThigh" width="14" height="28" cocos2d_pX="7" cocos2d_pY="5" x="93" y="64"/> <SubTexture name="CyborgFolder-LeftThigh" width="14" height="28" cocos2d_pX="7" cocos2d_pY="5" x="109" y="64"/>
</TextureAtlas> </TextureAtlas>
</skeleton> </skeleton>

301
samples/Cpp/TestCpp/Resources/armature/knight.xml
View File

@ -1,287 +1,194 @@
<skeleton name="Example03" frameRate="30" version="1.4"> <skeleton name="Example03" frameRate="30" version="2.0">
<armatures> <armatures>
<armature name="Knight_f/Knight"> <armature name="Knight_f/Knight">
<b name="horseLegL2" parent="horseBody" x="-8" y="18" kX="0" kY="0" cX="1" cY="1" z="0"> <b name="horseLegL2" parent="horseBody" x="-8" y="18" kX="0" kY="0" cX="1" cY="1" pX="0" pY="0" z="0">
<d name="Knight_f-horse_leg"/> <d name="Knight_f-horse_leg"/>
</b> </b>
<b name="horseLegL1" parent="horseBody" x="13" y="18" kX="0" kY="0" cX="1" cY="1" z="1"> <b name="horseLegL1" parent="horseBody" x="13" y="18" kX="0" kY="0" cX="1" cY="1" pX="0" pY="0" z="1">
<d name="Knight_f-horse_leg"/> <d name="Knight_f-horse_leg"/>
</b> </b>
<b name="horseLegR2" parent="horseBody" x="-14" y="18" kX="0" kY="0" cX="1" cY="1" z="2"> <b name="horseLegR2" parent="horseBody" x="-14" y="18" kX="0" kY="0" cX="1" cY="1" pX="0" pY="0" z="2">
<d name="Knight_f-horse_leg"/> <d name="Knight_f-horse_leg"/>
</b> </b>
<b name="horseLegR1" parent="horseBody" x="7" y="18" kX="0" kY="0" cX="1" cY="1" z="3"> <b name="horseLegR1" parent="horseBody" x="7" y="18" kX="0" kY="0" cX="1" cY="1" pX="0" pY="0" z="3">
<d name="Knight_f-horse_leg"/> <d name="Knight_f-horse_leg"/>
</b> </b>
<b name="horseBody" x="0" y="2" kX="0" kY="0" cX="1" cY="1" z="4"> <b name="horseBody" x="0" y="2" kX="0" kY="0" cX="1" cY="1" pX="0" pY="0" z="4">
<d name="Knight_f-horse_body"/> <d name="Knight_f-horse_body"/>
</b> </b>
<b name="horseTail" parent="horseBody" x="-20" y="4" kX="0" kY="0" cX="1" cY="1" z="5"> <b name="horseTail" parent="horseBody" x="-20" y="4" kX="0" kY="0" cX="1" cY="1" pX="0" pY="0" z="5">
<d name="Knight_f-horse_tail"/> <d name="Knight_f-horse_tail"/>
</b> </b>
<b name="horseHead" parent="horseBody" x="20" y="2" kX="0" kY="0" cX="1" cY="1" z="6"> <b name="horseHead" parent="horseBody" x="20" y="2" kX="0" kY="0" cX="1" cY="1" pX="0" pY="0" z="6">
<d name="Knight_f-horse_head"/> <d name="Knight_f-horse_head"/>
</b> </b>
<b name="armL" parent="body" x="4.1" y="-12" kX="15" kY="15" cX="1" cY="1" z="7"> <b name="armL" parent="body" x="4.1" y="-12" kX="15" kY="15" cX="1" cY="1" pX="0" pY="0" z="7">
<d name="Knight_f-hero_arm"/> <d name="Knight_f-hero_arm"/>
</b> </b>
<b name="body" parent="horseBody" x="0" y="0" kX="0" kY="0" cX="1" cY="1" z="8"> <b name="body" parent="horseBody" x="0" y="0" kX="0" kY="0" cX="1" cY="1" pX="0" pY="0" z="8">
<d name="Knight_f-hero_body"/> <d name="Knight_f-hero_body"/>
</b> </b>
<b name="leg" parent="body" x="-2" y="0" kX="-45" kY="-45" cX="1" cY="1" z="9"> <b name="leg" parent="body" x="-2" y="0" kX="-45" kY="-45" cX="1" cY="1" pX="0" pY="0" z="9">
<d name="Knight_f-hero_leg"/> <d name="Knight_f-hero_leg"/>
</b> </b>
<b name="head" parent="body" x="0" y="-14" kX="0" kY="0" cX="1" cY="1" z="10"> <b name="head" parent="body" x="0" y="-14" kX="0" kY="0" cX="1" cY="1" pX="0" pY="0" z="10">
<d name="Knight_f-hero_head"/> <d name="Knight_f-hero_head"/>
</b> </b>
<b name="weapon" parent="armR" x="-10.05" y="3" kX="20" kY="20" cX="1" cY="1" z="11"> <b name="weapon" parent="armR" x="-10.05" y="3" kX="20" kY="20" cX="1" cY="1" pX="0" pY="0" z="11">
<d name="Knight_f-hero_sword"/> <d name="Knight_f-hero_sword"/>
</b> </b>
<b name="armR" parent="body" x="-4" y="-12" kX="120" kY="120" cX="1" cY="1" z="12"> <b name="armR" parent="body" x="-4" y="-12" kX="120" kY="120" cX="1" cY="1" pX="0" pY="0" z="12">
<d name="Knight_f-hero_arm"/> <d name="Knight_f-hero_arm"/>
</b> </b>
</armature> </armature>
</armatures> </armatures>
<animations> <animations>
<animation name="Knight_f/Knight"> <animation name="Knight_f/Knight">
<mov name="stand" dr="2" to="6" drTW="49" lp="1" twE="2"> <mov name="stand" dr="21" to="6" drTW="54" lp="1" twE="2">
<b name="horseLegL2" sc="1" dl="0"> <b name="horseLegL2" sc="1" dl="0">
<f x="-8" y="18" kX="0" kY="0" cX="1" cY="1" z="0" pX="4" pY="0" width="8" height="14" dI="0" dr="1"/> <f x="-8" y="18" cocos2d_x="-8" cocos2d_y="18" kX="0" kY="0" cX="1" cY="1" pX="0" pY="0" z="0" dI="0" twE="0" dr="10"/>
<f x="-8" y="18" kX="0" kY="0" cX="1" cY="1" z="0" pX="4" pY="0" width="8" height="14" dI="0" dr="1"/> <f x="-8" y="18" cocos2d_x="-8" cocos2d_y="18" kX="0" kY="0" cX="1" cY="1" pX="0" pY="0" z="0" dI="0" twE="0" dr="10"/>
<f x="-8" y="18" cocos2d_x="-8" cocos2d_y="18" kX="0" kY="0" cX="1" cY="1" pX="0" pY="0" z="0" dI="0" twE="0" dr="1"/>
</b> </b>
<b name="horseLegL1" sc="1" dl="0"> <b name="horseLegL1" sc="1" dl="0">
<f x="13" y="18" kX="0" kY="0" cX="1" cY="1" z="1" pX="4" pY="0" width="8" height="14" dI="0" dr="1"/> <f x="13" y="18" cocos2d_x="13" cocos2d_y="18" kX="0" kY="0" cX="1" cY="1" pX="0" pY="0" z="1" dI="0" twE="0" dr="10"/>
<f x="13" y="18" kX="0" kY="0" cX="1" cY="1" z="1" pX="4" pY="0" width="8" height="14" dI="0" dr="1"/> <f x="13" y="18" cocos2d_x="13" cocos2d_y="18" kX="0" kY="0" cX="1" cY="1" pX="0" pY="0" z="1" dI="0" twE="0" dr="10"/>
<f x="13" y="18" cocos2d_x="13" cocos2d_y="18" kX="0" kY="0" cX="1" cY="1" pX="0" pY="0" z="1" dI="0" twE="0" dr="1"/>
</b> </b>
<b name="horseLegR2" sc="1" dl="0"> <b name="horseLegR2" sc="1" dl="0">
<f x="-14" y="18" kX="0" kY="0" cX="1" cY="1" z="2" pX="4" pY="0" width="8" height="14" dI="0" dr="1"/> <f x="-14" y="18" cocos2d_x="-14" cocos2d_y="18" kX="0" kY="0" cX="1" cY="1" pX="0" pY="0" z="2" dI="0" twE="0" dr="10"/>
<f x="-14" y="18" kX="0" kY="0" cX="1" cY="1" z="2" pX="4" pY="0" width="8" height="14" dI="0" dr="1"/> <f x="-14" y="18" cocos2d_x="-14" cocos2d_y="18" kX="0" kY="0" cX="1" cY="1" pX="0" pY="0" z="2" dI="0" twE="0" dr="10"/>
<f x="-14" y="18" cocos2d_x="-14" cocos2d_y="18" kX="0" kY="0" cX="1" cY="1" pX="0" pY="0" z="2" dI="0" twE="0" dr="1"/>
</b> </b>
<b name="horseLegR1" sc="1" dl="0"> <b name="horseLegR1" sc="1" dl="0">
<f x="7" y="18" kX="0" kY="0" cX="1" cY="1" z="3" pX="4" pY="0" width="8" height="14" dI="0" dr="1"/> <f x="7" y="18" cocos2d_x="7" cocos2d_y="18" kX="0" kY="0" cX="1" cY="1" pX="0" pY="0" z="3" dI="0" twE="0" dr="10"/>
<f x="7" y="18" kX="0" kY="0" cX="1" cY="1" z="3" pX="4" pY="0" width="8" height="14" dI="0" dr="1"/> <f x="7" y="18" cocos2d_x="7" cocos2d_y="18" kX="0" kY="0" cX="1" cY="1" pX="0" pY="0" z="3" dI="0" twE="0" dr="10"/>
<f x="7" y="18" cocos2d_x="7" cocos2d_y="18" kX="0" kY="0" cX="1" cY="1" pX="0" pY="0" z="3" dI="0" twE="0" dr="1"/>
</b> </b>
<b name="horseBody" sc="1" dl="0"> <b name="horseBody" sc="1" dl="0">
<f x="0" y="2" kX="0" kY="0" cX="1" cY="1" z="4" pX="20" pY="2" width="40" height="20" dI="0" dr="1"/> <f x="0" y="2" cocos2d_x="0" cocos2d_y="2" kX="0" kY="0" cX="1" cY="1" pX="0" pY="0" z="4" dI="0" twE="0" dr="10"/>
<f x="0" y="3" kX="0" kY="0" cX="1" cY="1" z="4" pX="20" pY="2" width="40" height="20" dI="0" dr="1"/> <f x="0" y="3" cocos2d_x="0" cocos2d_y="3" kX="0" kY="0" cX="1" cY="1" pX="0" pY="0" z="4" dI="0" twE="0" dr="10"/>
<f x="0" y="2" cocos2d_x="0" cocos2d_y="2" kX="0" kY="0" cX="1" cY="1" pX="0" pY="0" z="4" dI="0" twE="0" dr="1"/>
</b> </b>
<b name="horseTail" sc="1" dl="0"> <b name="horseTail" sc="1" dl="0">
<f x="-20" y="4" kX="0" kY="0" cX="1" cY="1" z="5" pX="6" pY="2" width="8" height="12" dI="0" dr="1"/> <f x="-20" y="4" cocos2d_x="-20" cocos2d_y="4" kX="0" kY="0" cX="1" cY="1" pX="0" pY="0" z="5" dI="0" twE="0" dr="10"/>
<f x="-20" y="4.95" kX="15" kY="15" cX="1" cY="1" z="5" pX="8.4" pY="3.5" width="11" height="14" dI="0" dr="1"/> <f x="-20" y="4.95" cocos2d_x="-20" cocos2d_y="4.95" kX="15" kY="15" cX="1" cY="1" pX="0" pY="0" z="5" dI="0" twE="0" dr="10"/>
<f x="-20" y="4" cocos2d_x="-20" cocos2d_y="4" kX="0" kY="0" cX="1" cY="1" pX="0" pY="0" z="5" dI="0" twE="0" dr="1"/>
</b> </b>
<b name="horseHead" sc="1" dl="0"> <b name="horseHead" sc="1" dl="0">
<f x="20" y="2" kX="0" kY="0" cX="1" cY="1" z="6" pX="2" pY="46" width="40" height="48" dI="0" dr="1"/> <f x="20" y="2" cocos2d_x="20" cocos2d_y="2" kX="0" kY="0" cX="1" cY="1" pX="0" pY="0" z="6" dI="0" twE="0" dr="10"/>
<f x="20.1" y="3" kX="5" kY="5" cX="1" cY="1" z="6" pX="2.15" pY="46" width="44" height="52" dI="0" dr="1"/> <f x="20.1" y="3" cocos2d_x="20.1" cocos2d_y="3" kX="5" kY="5" cX="1" cY="1" pX="0" pY="0" z="6" dI="0" twE="0" dr="10"/>
<f x="20" y="2" cocos2d_x="20" cocos2d_y="2" kX="0" kY="0" cX="1" cY="1" pX="0" pY="0" z="6" dI="0" twE="0" dr="1"/>
</b> </b>
<b name="armL" sc="1" dl="0"> <b name="armL" sc="1" dl="0">
<f x="4.1" y="-12" kX="15" kY="15" cX="1" cY="1" z="7" pX="3.5" pY="4.35" width="22" height="15" dI="0" dr="1"/> <f x="4.1" y="-12" cocos2d_x="4.1" cocos2d_y="-12" kX="15" kY="15" cX="1" cY="1" pX="0" pY="0" z="7" dI="0" twE="0" dr="10"/>
<f x="4" y="-10.95" kX="24" kY="24" cX="1" cY="1" z="7" pX="4.3" pY="4.45" width="23" height="18" dI="0" dr="1"/> <f x="4" y="-10.95" cocos2d_x="4" cocos2d_y="-10.95" kX="24" kY="24" cX="1" cY="1" pX="0" pY="0" z="7" dI="0" twE="0" dr="10"/>
<f x="4.1" y="-12" cocos2d_x="4.1" cocos2d_y="-12" kX="15" kY="15" cX="1" cY="1" pX="0" pY="0" z="7" dI="0" twE="0" dr="1"/>
</b> </b>
<b name="body" sc="1" dl="0"> <b name="body" sc="1" dl="0">
<f x="0" y="0" kX="0" kY="0" cX="1" cY="1" z="8" pX="7" pY="14" width="14" height="16" dI="0" dr="1"/> <f x="0" y="0" cocos2d_x="0" cocos2d_y="0" kX="0" kY="0" cX="1" cY="1" pX="0" pY="0" z="8" dI="0" twE="0" dr="10"/>
<f x="0" y="1" kX="0" kY="0" cX="1" cY="1" z="8" pX="7" pY="14" width="14" height="16" dI="0" dr="1"/> <f x="0" y="1" cocos2d_x="0" cocos2d_y="1" kX="0" kY="0" cX="1" cY="1" pX="0" pY="0" z="8" dI="0" twE="0" dr="10"/>
<f x="0" y="0" cocos2d_x="0" cocos2d_y="0" kX="0" kY="0" cX="1" cY="1" pX="0" pY="0" z="8" dI="0" twE="0" dr="1"/>
</b> </b>
<b name="leg" sc="1" dl="0"> <b name="leg" sc="1" dl="0">
<f x="-2" y="0" kX="-45" kY="-45" cX="1" cY="1" z="9" pX="2.85" pY="2.85" width="17" height="17" dI="0" dr="1"/> <f x="-2" y="0" cocos2d_x="-2" cocos2d_y="0" kX="-45" kY="-45" cX="1" cY="1" pX="0" pY="0" z="9" dI="0" twE="0" dr="10"/>
<f x="-2" y="1" kX="-45" kY="-45" cX="1" cY="1" z="9" pX="2.85" pY="2.85" width="17" height="17" dI="0" dr="1"/> <f x="-2" y="1" cocos2d_x="-2" cocos2d_y="1" kX="-45" kY="-45" cX="1" cY="1" pX="0" pY="0" z="9" dI="0" twE="0" dr="10"/>
<f x="-2" y="0" cocos2d_x="-2" cocos2d_y="0" kX="-45" kY="-45" cX="1" cY="1" pX="0" pY="0" z="9" dI="0" twE="0" dr="1"/>
</b> </b>
<b name="head" sc="1" dl="0"> <b name="head" sc="1" dl="0">
<f x="0" y="-14" kX="0" kY="0" cX="1" cY="1" z="10" pX="22" pY="37.95" width="44" height="40" dI="0" dr="1"/> <f x="0" y="-14" cocos2d_x="0" cocos2d_y="-14" kX="0" kY="0" cX="1" cY="1" pX="0" pY="0" z="10" dI="0" twE="0" dr="10"/>
<f x="0" y="-11" kX="6" kY="6" cX="1" cY="1" z="10" pX="22.05" pY="40.05" width="48" height="44" dI="0" dr="1"/> <f x="0" y="-11" cocos2d_x="0" cocos2d_y="-11" kX="6" kY="6" cX="1" cY="1" pX="0" pY="0" z="10" dI="0" twE="0" dr="10"/>
<f x="0" y="-14" cocos2d_x="0" cocos2d_y="-14" kX="0" kY="0" cX="1" cY="1" pX="0" pY="0" z="10" dI="0" twE="0" dr="1"/>
</b> </b>
<b name="weapon" sc="1" dl="0"> <b name="weapon" sc="1" dl="0">
<f x="-10.05" y="3" kX="20" kY="20" cX="1" cY="1" z="11" pX="14.55" pY="17.5" width="95" height="59" dI="0" dr="1"/> <f x="-10.05" y="3" cocos2d_x="-10.05" cocos2d_y="3" kX="20" kY="20" cX="1" cY="1" pX="0" pY="0" z="11" dI="0" twE="0" dr="10"/>
<f x="-14.1" y="1.05" kX="16" kY="16" cX="1" cY="1" z="11" pX="13.75" pY="17.15" width="95" height="54" dI="0" dr="1"/> <f x="-14.1" y="1.05" cocos2d_x="-14.1" cocos2d_y="1.05" kX="16" kY="16" cX="1" cY="1" pX="0" pY="0" z="11" dI="0" twE="0" dr="10"/>
<f x="-10.05" y="3" cocos2d_x="-10.05" cocos2d_y="3" kX="20" kY="20" cX="1" cY="1" pX="0" pY="0" z="11" dI="0" twE="0" dr="1"/>
</b> </b>
<b name="armR" sc="1" dl="0"> <b name="armR" sc="1" dl="0">
<f x="-4" y="-12" kX="120" kY="120" cX="1" cY="1" z="12" pX="14.2" pY="4.75" width="19" height="23" dI="0" dr="1"/> <f x="-4" y="-12" cocos2d_x="-4" cocos2d_y="-12" kX="120" kY="120" cX="1" cY="1" pX="0" pY="0" z="12" dI="0" twE="0" dr="10"/>
<f x="-3.95" y="-11" kX="135" kY="135" cX="1" cY="1" z="12" pX="17" pY="5.65" width="22" height="22" dI="0" dr="1"/> <f x="-3.95" y="-11" cocos2d_x="-3.95" cocos2d_y="-11" kX="135" kY="135" cX="1" cY="1" pX="0" pY="0" z="12" dI="0" twE="0" dr="10"/>
<f x="-4" y="-12" cocos2d_x="-4" cocos2d_y="-12" kX="120" kY="120" cX="1" cY="1" pX="0" pY="0" z="12" dI="0" twE="0" dr="1"/>
</b> </b>
</mov> </mov>
<mov name="run" dr="2" to="6" drTW="81" lp="1" twE="2"> <mov name="run" dr="21" to="6" drTW="49" lp="1" twE="2">
<b name="horseLegL2" sc="1" dl="0.1"> <b name="horseLegL2" sc="1" dl="0.1">
<f x="-4.85" y="13.2" kX="64.3" kY="64.3" cX="1" cY="1" z="0" pX="14.35" pY="3.6" width="17" height="14" dI="0" dr="1"/> <f x="-4.85" y="13.2" cocos2d_x="-4.85" cocos2d_y="13.2" kX="64.3" kY="64.3" cX="1" cY="1" pX="0" pY="0" z="0" dI="0" twE="0" dr="10"/>
<f x="-8" y="18" kX="-45" kY="-45" cX="1" cY="1" z="0" pX="2.85" pY="2.85" width="16" height="16" dI="0" dr="1"/> <f x="-8" y="18" cocos2d_x="-8" cocos2d_y="18" kX="-45" kY="-45" cX="1" cY="1" pX="0" pY="0" z="0" dI="0" twE="0" dr="10"/>
<f x="-4.85" y="13.2" cocos2d_x="-4.85" cocos2d_y="13.2" kX="64.3" kY="64.3" cX="1" cY="1" pX="0" pY="0" z="0" dI="0" twE="0" dr="1"/>
</b> </b>
<b name="horseLegL1" sc="1" dl="0.1"> <b name="horseLegL1" sc="1" dl="0.1">
<f x="15.75" y="9.3" kX="-70.7" kY="-70.7" cX="1" cY="1" z="1" pX="1.3" pY="3.8" width="16" height="13" dI="0" dr="1"/> <f x="15.75" y="9.3" cocos2d_x="15.75" cocos2d_y="9.3" kX="-70.7" kY="-70.7" cX="1" cY="1" pX="0" pY="0" z="1" dI="0" twE="0" dr="10"/>
<f x="10.95" y="19.5" kX="52" kY="52" cX="1" cY="1" z="1" pX="13.5" pY="3.15" width="16" height="15" dI="0" dr="1"/> <f x="10.95" y="19.5" cocos2d_x="10.95" cocos2d_y="19.5" kX="52" kY="52" cX="1" cY="1" pX="0" pY="0" z="1" dI="0" twE="0" dr="10"/>
<f x="15.75" y="9.3" cocos2d_x="15.75" cocos2d_y="9.3" kX="-70.7" kY="-70.7" cX="1" cY="1" pX="0" pY="0" z="1" dI="0" twE="0" dr="1"/>
</b> </b>
<b name="horseLegR2" sc="1" dl="0"> <b name="horseLegR2" sc="1" dl="0">
<f x="-10.7" y="14.35" kX="64.3" kY="64.3" cX="1" cY="1" z="2" pX="14.35" pY="3.6" width="17" height="14" dI="0" dr="1"/> <f x="-10.7" y="14.35" cocos2d_x="-10.7" cocos2d_y="14.35" kX="64.3" kY="64.3" cX="1" cY="1" pX="0" pY="0" z="2" dI="0" twE="0" dr="10"/>
<f x="-15.85" y="16.2" kX="-38" kY="-38" cX="1" cY="1" z="2" pX="3.15" pY="2.45" width="15" height="16" dI="0" dr="1"/> <f x="-15.85" y="16.2" cocos2d_x="-15.85" cocos2d_y="16.2" kX="-38" kY="-38" cX="1" cY="1" pX="0" pY="0" z="2" dI="0" twE="0" dr="10"/>
<f x="-10.7" y="14.35" cocos2d_x="-10.7" cocos2d_y="14.35" kX="64.3" kY="64.3" cX="1" cY="1" pX="0" pY="0" z="2" dI="0" twE="0" dr="1"/>
</b> </b>
<b name="horseLegR1" sc="1" dl="0"> <b name="horseLegR1" sc="1" dl="0">
<f x="9.9" y="10.45" kX="-70.7" kY="-70.7" cX="1" cY="1" z="3" pX="1.3" pY="3.8" width="16" height="13" dI="0" dr="1"/> <f x="9.9" y="10.45" cocos2d_x="9.9" cocos2d_y="10.45" kX="-70.7" kY="-70.7" cX="1" cY="1" pX="0" pY="0" z="3" dI="0" twE="0" dr="10"/>
<f x="5" y="18.75" kX="52" kY="52" cX="1" cY="1" z="3" pX="13.5" pY="3.15" width="16" height="15" dI="0" dr="1"/> <f x="5" y="18.75" cocos2d_x="5" cocos2d_y="18.75" kX="52" kY="52" cX="1" cY="1" pX="0" pY="0" z="3" dI="0" twE="0" dr="10"/>
<f x="9.9" y="10.45" cocos2d_x="9.9" cocos2d_y="10.45" kX="-70.7" kY="-70.7" cX="1" cY="1" pX="0" pY="0" z="3" dI="0" twE="0" dr="1"/>
</b> </b>
<b name="horseBody" sc="1" dl="0"> <b name="horseBody" sc="1" dl="0">
<f x="0" y="-4" kX="-10.7" kY="-10.7" cX="1" cY="1" z="4" pX="20" pY="5.65" width="43" height="28" dI="0" dr="1"/> <f x="0" y="-4" cocos2d_x="0" cocos2d_y="-4" kX="-10.7" kY="-10.7" cX="1" cY="1" pX="0" pY="0" z="4" dI="0" twE="0" dr="10"/>
<f x="0" y="2" kX="6.99" kY="6.99" cX="1" cY="1" z="4" pX="22.05" pY="4.45" width="43" height="25" dI="0" dr="1"/> <f x="0" y="2" cocos2d_x="0" cocos2d_y="2" kX="6.99" kY="6.99" cX="1" cY="1" pX="0" pY="0" z="4" dI="0" twE="0" dr="10"/>
<f x="0" y="-4" cocos2d_x="0" cocos2d_y="-4" kX="-10.7" kY="-10.7" cX="1" cY="1" pX="0" pY="0" z="4" dI="0" twE="0" dr="1"/>
</b> </b>
<b name="horseTail" sc="1" dl="0"> <b name="horseTail" sc="1" dl="0">
<f x="-19.25" y="1.7" kX="64.3" kY="64.3" cX="1" cY="1" z="5" pX="11.6" pY="6.25" width="15" height="13" dI="0" dr="1"/> <f x="-19.25" y="1.7" cocos2d_x="-19.25" cocos2d_y="1.7" kX="64.3" kY="64.3" cX="1" cY="1" pX="0" pY="0" z="5" dI="0" twE="0" dr="10"/>
<f x="-20.1" y="1.55" kX="0" kY="0" cX="1" cY="1" z="5" pX="6" pY="2" width="8" height="12" dI="0" dr="1"/> <f x="-20.1" y="1.55" cocos2d_x="-20.1" cocos2d_y="1.55" kX="0" kY="0" cX="1" cY="1" pX="0" pY="0" z="5" dI="0" twE="0" dr="10"/>
<f x="-19.25" y="1.7" cocos2d_x="-19.25" cocos2d_y="1.7" kX="64.3" kY="64.3" cX="1" cY="1" pX="0" pY="0" z="5" dI="0" twE="0" dr="1"/>
</b> </b>
<b name="horseHead" sc="1" dl="0.15"> <b name="horseHead" sc="1" dl="0.15">
<f x="19.65" y="-7.75" kX="-20" kY="-20" cX="1" cY="1" z="6" pX="17.65" pY="56.2" width="55" height="59" dI="0" dr="1"/> <f x="19.65" y="-7.75" cocos2d_x="19.65" cocos2d_y="-7.75" kX="-20" kY="-20" cX="1" cY="1" pX="0" pY="0" z="6" dI="0" twE="0" dr="10"/>
<f x="19.85" y="4.45" kX="27" kY="27" cX="1" cY="1" z="6" pX="2.7" pY="41.9" width="58" height="61" dI="0" dr="1"/> <f x="19.85" y="4.45" cocos2d_x="19.85" cocos2d_y="4.45" kX="27" kY="27" cX="1" cY="1" pX="0" pY="0" z="6" dI="0" twE="0" dr="10"/>
<f x="19.65" y="-7.75" cocos2d_x="19.65" cocos2d_y="-7.75" kX="-20" kY="-20" cX="1" cY="1" pX="0" pY="0" z="6" dI="0" twE="0" dr="1"/>
</b> </b>
<b name="armL" sc="1" dl="0"> <b name="armL" sc="1" dl="0">
<f x="4.1" y="-18" kX="0" kY="0" cX="1" cY="1" z="7" pX="2" pY="4" width="20" height="10" dI="0" dr="1"/> <f x="4.1" y="-18" cocos2d_x="4.1" cocos2d_y="-18" kX="0" kY="0" cX="1" cY="1" pX="0" pY="0" z="7" dI="0" twE="0" dr="10"/>
<f x="4.1" y="-12" kX="30" kY="30" cX="1" cY="1" z="7" pX="4.75" pY="4.45" width="23" height="19" dI="0" dr="1"/> <f x="4.1" y="-12" cocos2d_x="4.1" cocos2d_y="-12" kX="30" kY="30" cX="1" cY="1" pX="0" pY="0" z="7" dI="0" twE="0" dr="10"/>
<f x="4.1" y="-18" cocos2d_x="4.1" cocos2d_y="-18" kX="0" kY="0" cX="1" cY="1" pX="0" pY="0" z="7" dI="0" twE="0" dr="1"/>
</b> </b>
<b name="body" sc="1" dl="0"> <b name="body" sc="1" dl="0">
<f x="0" y="-6" kX="0" kY="0" cX="1" cY="1" z="8" pX="7" pY="14" width="14" height="16" dI="0" dr="1"/> <f x="0" y="-6" cocos2d_x="0" cocos2d_y="-6" kX="0" kY="0" cX="1" cY="1" pX="0" pY="0" z="8" dI="0" twE="0" dr="10"/>
<f x="0" y="0" kX="0" kY="0" cX="1" cY="1" z="8" pX="7" pY="14" width="14" height="16" dI="0" dr="1"/> <f x="0" y="0" cocos2d_x="0" cocos2d_y="0" kX="0" kY="0" cX="1" cY="1" pX="0" pY="0" z="8" dI="0" twE="0" dr="10"/>
<f x="0" y="-6" cocos2d_x="0" cocos2d_y="-6" kX="0" kY="0" cX="1" cY="1" pX="0" pY="0" z="8" dI="0" twE="0" dr="1"/>
</b> </b>
<b name="leg" sc="1" dl="0"> <b name="leg" sc="1" dl="0">
<f x="-2" y="-6" kX="-45" kY="-45" cX="1" cY="1" z="9" pX="2.85" pY="2.85" width="17" height="17" dI="0" dr="1"/> <f x="-2" y="-6" cocos2d_x="-2" cocos2d_y="-6" kX="-45" kY="-45" cX="1" cY="1" pX="0" pY="0" z="9" dI="0" twE="0" dr="10"/>
<f x="-2" y="0" kX="-45" kY="-45" cX="1" cY="1" z="9" pX="2.85" pY="2.85" width="17" height="17" dI="0" dr="1"/> <f x="-2" y="0" cocos2d_x="-2" cocos2d_y="0" kX="-45" kY="-45" cX="1" cY="1" pX="0" pY="0" z="9" dI="0" twE="0" dr="10"/>
<f x="-2" y="-6" cocos2d_x="-2" cocos2d_y="-6" kX="-45" kY="-45" cX="1" cY="1" pX="0" pY="0" z="9" dI="0" twE="0" dr="1"/>
</b> </b>
<b name="head" sc="1" dl="0"> <b name="head" sc="1" dl="0">
<f x="0" y="-20" kX="-10" kY="-10" cX="1" cY="1" z="10" pX="28.25" pY="41.15" width="51" height="47" dI="0" dr="1"/> <f x="0" y="-20" cocos2d_x="0" cocos2d_y="-20" kX="-10" kY="-10" cX="1" cY="1" pX="0" pY="0" z="10" dI="0" twE="0" dr="10"/>
<f x="0" y="-12" kX="10" kY="10" cX="1" cY="1" z="10" pX="21.9" pY="41.15" width="51" height="47" dI="0" dr="1"/> <f x="0" y="-12" cocos2d_x="0" cocos2d_y="-12" kX="10" kY="10" cX="1" cY="1" pX="0" pY="0" z="10" dI="0" twE="0" dr="10"/>
<f x="0" y="-20" cocos2d_x="0" cocos2d_y="-20" kX="-10" kY="-10" cX="1" cY="1" pX="0" pY="0" z="10" dI="0" twE="0" dr="1"/>
</b> </b>
<b name="weapon" sc="1" dl="0.4"> <b name="weapon" sc="1" dl="0.4">
<f x="-5.05" y="-2" kX="10" kY="10" cX="1" cY="1" z="11" pX="12.45" pY="16.5" width="94" height="46" dI="0" dr="1"/> <f x="-5.05" y="-2" cocos2d_x="-5.05" cocos2d_y="-2" kX="10" kY="10" cX="1" cY="1" pX="0" pY="0" z="11" dI="0" twE="0" dr="10"/>
<f x="-10.85" y="2.05" kX="20" kY="20" cX="1" cY="1" z="11" pX="14.55" pY="17.5" width="95" height="59" dI="0" dr="1"/> <f x="-10.85" y="2.05" cocos2d_x="-10.85" cocos2d_y="2.05" kX="20" kY="20" cX="1" cY="1" pX="0" pY="0" z="11" dI="0" twE="0" dr="10"/>
<f x="-5.05" y="-2" cocos2d_x="-5.05" cocos2d_y="-2" kX="10" kY="10" cX="1" cY="1" pX="0" pY="0" z="11" dI="0" twE="0" dr="1"/>
</b> </b>
<b name="armR" sc="1" dl="0"> <b name="armR" sc="1" dl="0">
<f x="-4" y="-18" kX="100" kY="100" cX="1" cY="1" z="12" pX="9.05" pY="3" width="14" height="22" dI="0" dr="1"/> <f x="-4" y="-18" cocos2d_x="-4" cocos2d_y="-18" kX="100" kY="100" cX="1" cY="1" pX="0" pY="0" z="12" dI="0" twE="0" dr="10"/>
<f x="-4" y="-12" kX="119.86" kY="119.85" cX="1" cY="1" z="12" pX="14.15" pY="4.75" width="19" height="23" dI="0" dr="1"/> <f x="-4" y="-12" cocos2d_x="-4" cocos2d_y="-12" kX="119.86" kY="119.85" cX="1" cY="1" pX="0" pY="0" z="12" dI="0" twE="0" dr="10"/>
</b> <f x="-4" y="-18" cocos2d_x="-4" cocos2d_y="-18" kX="100" kY="100" cX="1" cY="1" pX="0" pY="0" z="12" dI="0" twE="0" dr="1"/>
</mov>
<mov name="attack" dr="29" to="6" drTW="50" lp="1" twE="NaN">
<b name="horseLegL2" sc="1" dl="0">
<f x="-13.6" y="19.5" kX="-45" kY="-45" cX="1" cY="1" z="0" pX="2.85" pY="2.85" width="16" height="16" dI="0" dr="5"/>
<f x="-5" y="18" kX="30" kY="30" cX="1" cY="1" z="0" pX="10.45" pY="2" width="14" height="17" dI="0" dr="2"/>
<f x="-9" y="18" kX="-15" kY="-15" cX="1" cY="1" z="0" pX="3.85" pY="1.05" width="12" height="16" dI="0" dr="5"/>
<f x="-5" y="18" kX="30" kY="30" cX="1" cY="1" z="0" pX="10.45" pY="2" width="14" height="17" dI="0" dr="2"/>
<f x="-8" y="18" kX="0" kY="0" cX="1" cY="1" z="0" pX="4" pY="0" width="8" height="14" dI="0" dr="6"/>
<f x="-8" y="18" kX="30" kY="30" cX="1" cY="1" z="0" pX="10.45" pY="2" width="14" height="17" dI="0" dr="3"/>
<f x="-10" y="18" kX="0" kY="0" cX="1" cY="1" z="0" pX="4" pY="0" width="8" height="14" dI="0" dr="6"/>
</b>
<b name="horseLegL1" sc="1" dl="0">
<f x="6.7" y="14.1" kX="-60" kY="-60" cX="1" cY="1" z="1" pX="2" pY="3.45" width="17" height="14" dI="0" dr="5"/>
<f x="16" y="18" kX="30" kY="30" cX="1" cY="1" z="1" pX="10.45" pY="2" width="14" height="17" dI="0" dr="2"/>
<f x="12" y="18" kX="-15" kY="-15" cX="1" cY="1" z="1" pX="3.85" pY="1.05" width="12" height="16" dI="0" dr="5"/>
<f x="16" y="18" kX="30" kY="30" cX="1" cY="1" z="1" pX="10.45" pY="2" width="14" height="17" dI="0" dr="2"/>
<f x="13" y="18" kX="0" kY="0" cX="1" cY="1" z="1" pX="4" pY="0" width="8" height="14" dI="0" dr="6"/>
<f x="13" y="18" kX="30" kY="30" cX="1" cY="1" z="1" pX="10.45" pY="2" width="14" height="17" dI="0" dr="3"/>
<f x="11" y="18" kX="-15" kY="-15" cX="1" cY="1" z="1" pX="3.85" pY="1.05" width="12" height="16" dI="0" dr="6"/>
</b>
<b name="horseLegR2" sc="1" dl="0">
<f x="-19.35" y="21.05" kX="-45" kY="-45" cX="1" cY="1" z="2" pX="2.85" pY="2.85" width="16" height="16" dI="0" dr="5"/>
<f x="-11" y="18" kX="30" kY="30" cX="1" cY="1" z="2" pX="10.45" pY="2" width="14" height="17" dI="0" dr="2"/>
<f x="-15" y="18" kX="-15" kY="-15" cX="1" cY="1" z="2" pX="3.85" pY="1.05" width="12" height="16" dI="0" dr="5"/>
<f x="-11" y="18" kX="30" kY="30" cX="1" cY="1" z="2" pX="10.45" pY="2" width="14" height="17" dI="0" dr="2"/>
<f x="-14" y="18" kX="15" kY="15" cX="1" cY="1" z="2" pX="7.45" pY="1.05" width="12" height="16" dI="0" dr="6"/>
<f x="-14" y="18" kX="15" kY="15" cX="1" cY="1" z="2" pX="7.45" pY="1.05" width="12" height="16" dI="0" dr="3"/>
<f x="-16" y="18" kX="-15" kY="-15" cX="1" cY="1" z="2" pX="3.85" pY="1.05" width="12" height="16" dI="0" dr="6"/>
</b>
<b name="horseLegR1" sc="1" dl="0">
<f x="0.9" y="15.65" kX="-45" kY="-45" cX="1" cY="1" z="3" pX="2.85" pY="2.85" width="16" height="16" dI="0" dr="5"/>
<f x="10" y="18" kX="15" kY="15" cX="1" cY="1" z="3" pX="7.45" pY="1.05" width="12" height="16" dI="0" dr="2"/>
<f x="6" y="18" kX="-15" kY="-15" cX="1" cY="1" z="3" pX="3.85" pY="1.05" width="12" height="16" dI="0" dr="5"/>
<f x="10" y="18" kX="15" kY="15" cX="1" cY="1" z="3" pX="7.45" pY="1.05" width="12" height="16" dI="0" dr="2"/>
<f x="7" y="18" kX="15" kY="15" cX="1" cY="1" z="3" pX="7.45" pY="1.05" width="12" height="16" dI="0" dr="6"/>
<f x="7" y="18" kX="15" kY="15" cX="1" cY="1" z="3" pX="7.45" pY="1.05" width="12" height="16" dI="0" dr="3"/>
<f x="5" y="18" kX="-30" kY="-30" cX="1" cY="1" z="3" pX="3.45" pY="2" width="14" height="17" dI="0" dr="6"/>
</b>
<b name="horseBody" sc="1" dl="0">
<f x="-10" y="2" kX="-15" kY="-15" cX="1" cY="1" z="4" pX="19.8" pY="7.15" width="44" height="30" dI="0" dr="5"/>
<f x="3" y="2" kX="0" kY="0" cX="1" cY="1" z="4" pX="20" pY="2" width="40" height="20" dI="0" dr="2"/>
<f x="-1" y="2" kX="0" kY="0" cX="1" cY="1" z="4" pX="20" pY="2" width="40" height="20" dI="0" dr="5"/>
<f x="3" y="2" kX="0" kY="0" cX="1" cY="1" z="4" pX="20" pY="2" width="40" height="20" dI="0" dr="2"/>
<f x="0" y="2" kX="0" kY="0" cX="1" cY="1" z="4" pX="20" pY="2" width="40" height="20" dI="0" dr="6"/>
<f x="0" y="2" kX="0" kY="0" cX="1" cY="1" z="4" pX="20" pY="2" width="40" height="20" dI="0" dr="3"/>
<f x="-2" y="2" kX="0" kY="0" cX="1" cY="1" z="4" pX="20" pY="2" width="40" height="20" dI="0" dr="6"/>
</b>
<b name="horseTail" sc="1" dl="0">
<f x="-28.75" y="9.1" kX="15" kY="15" cX="1" cY="1" z="5" pX="8.4" pY="3.5" width="11" height="14" dI="0" dr="5"/>
<f x="-17" y="4" kX="0" kY="0" cX="1" cY="1" z="5" pX="6" pY="2" width="8" height="12" dI="0" dr="2"/>
<f x="-21" y="4" kX="30" kY="30" cX="1" cY="1" z="5" pX="10.2" pY="4.75" width="13" height="15" dI="0" dr="5"/>
<f x="-17" y="4" kX="0" kY="0" cX="1" cY="1" z="5" pX="6" pY="2" width="8" height="12" dI="0" dr="2"/>
<f x="-20" y="4" kX="15" kY="15" cX="1" cY="1" z="5" pX="8.4" pY="3.5" width="11" height="14" dI="0" dr="6"/>
<f x="-20" y="4" kX="0" kY="0" cX="1" cY="1" z="5" pX="6" pY="2" width="8" height="12" dI="0" dr="3"/>
<f x="-22" y="4" kX="-30" kY="-30" cX="1" cY="1" z="5" pX="6.2" pY="2.75" width="13" height="15" dI="0" dr="6"/>
</b>
<b name="horseHead" sc="1" dl="0">
<f x="9.3" y="-3.2" kX="0" kY="0" cX="1" cY="1" z="6" pX="2" pY="46" width="40" height="48" dI="0" dr="5"/>
<f x="23" y="2" kX="15" kY="15" cX="1" cY="1" z="6" pX="2.45" pY="44.95" width="52" height="57" dI="0" dr="2"/>
<f x="19" y="2" kX="10.7" kY="10.7" cX="1" cY="1" z="6" pX="2.3" pY="45.55" width="49" height="55" dI="0" dr="5"/>
<f x="23" y="2" kX="4.31" kY="4.31" cX="1" cY="1" z="6" pX="2.15" pY="46" width="44" height="51" dI="0" dr="2"/>
<f x="20" y="2" kX="13.79" kY="13.79" cX="1" cY="1" z="6" pX="2.45" pY="45.2" width="51" height="57" dI="0" dr="6"/>
<f x="20" y="2" kX="-4.69" kY="-4.69" cX="1" cY="1" z="6" pX="5.75" pY="48.95" width="44" height="52" dI="0" dr="3"/>
<f x="18" y="2" kX="10.31" kY="10.31" cX="1" cY="1" z="6" pX="2.3" pY="45.6" width="48" height="55" dI="0" dr="6"/>
</b>
<b name="armL" sc="1" dl="0">
<f x="-9.65" y="-12.6" kX="0" kY="0" cX="1" cY="1" z="7" pX="2" pY="4" width="20" height="10" dI="0" dr="5"/>
<f x="7.1" y="-12" kX="30" kY="30" cX="1" cY="1" z="7" pX="4.75" pY="4.45" width="23" height="19" dI="0" dr="2"/>
<f x="5.45" y="-10.9" kX="26.72" kY="26.72" cX="1" cY="1" z="7" pX="4.5" pY="4.45" width="23" height="18" dI="0" dr="5"/>
<f x="7.1" y="-12" kX="15" kY="15" cX="1" cY="1" z="7" pX="3.5" pY="4.35" width="22" height="15" dI="0" dr="2"/>
<f x="4.1" y="-12" kX="-60" kY="-60" cX="1" cY="1" z="7" pX="4.45" pY="17.6" width="19" height="23" dI="0" dr="6"/>
<f x="4.1" y="-12" kX="30" kY="30" cX="1" cY="1" z="7" pX="4.75" pY="4.45" width="23" height="19" dI="0" dr="3"/>
<f x="2.1" y="-12" kX="30" kY="30" cX="1" cY="1" z="7" pX="4.75" pY="4.45" width="23" height="19" dI="0" dr="6"/>
</b>
<b name="body" sc="1" dl="0">
<f x="-10.5" y="0.05" kX="-15" kY="-15" cX="1" cY="1" z="8" pX="10.35" pY="15.3" width="18" height="20" dI="0" dr="5"/>
<f x="3" y="0" kX="0" kY="0" cX="1" cY="1" z="8" pX="7" pY="14" width="14" height="16" dI="0" dr="2"/>
<f x="-1" y="0" kX="11.72" kY="11.72" cX="1" cY="1" z="8" pX="7.25" pY="15.1" width="17" height="19" dI="0" dr="5"/>
<f x="3" y="0" kX="0" kY="0" cX="1" cY="1" z="8" pX="7" pY="14" width="14" height="16" dI="0" dr="2"/>
<f x="0" y="0" kX="0" kY="0" cX="1" cY="1" z="8" pX="7" pY="14" width="14" height="16" dI="0" dr="6"/>
<f x="0" y="0" kX="0" kY="0" cX="1" cY="1" z="8" pX="7" pY="14" width="14" height="16" dI="0" dr="3"/>
<f x="-2" y="0" kX="0" kY="0" cX="1" cY="1" z="8" pX="7" pY="14" width="14" height="16" dI="0" dr="6"/>
</b>
<b name="leg" sc="1" dl="0">
<f x="-12.45" y="0.55" kX="-60" kY="-60" cX="1" cY="1" z="9" pX="2" pY="3.45" width="18" height="15" dI="0" dr="5"/>
<f x="1" y="0" kX="-45" kY="-45" cX="1" cY="1" z="9" pX="2.85" pY="2.85" width="17" height="17" dI="0" dr="2"/>
<f x="-3" y="0" kX="-45" kY="-45" cX="1" cY="1" z="9" pX="2.85" pY="2.85" width="17" height="17" dI="0" dr="5"/>
<f x="1" y="0" kX="-45" kY="-45" cX="1" cY="1" z="9" pX="2.85" pY="2.85" width="17" height="17" dI="0" dr="2"/>
<f x="-2" y="0" kX="-45" kY="-45" cX="1" cY="1" z="9" pX="2.85" pY="2.85" width="17" height="17" dI="0" dr="6"/>
<f x="-2" y="0" kX="-15" kY="-15" cX="1" cY="1" z="9" pX="3.85" pY="1.05" width="12" height="18" dI="0" dr="3"/>
<f x="-4" y="0" kX="-15" kY="-15" cX="1" cY="1" z="9" pX="3.85" pY="1.05" width="12" height="18" dI="0" dr="6"/>
</b>
<b name="head" sc="1" dl="0">
<f x="-14.1" y="-13.45" kX="0" kY="0" cX="1" cY="1" z="10" pX="22" pY="37.95" width="44" height="40" dI="0" dr="5"/>
<f x="3" y="-14" kX="15" kY="15" cX="1" cY="1" z="10" pX="21.65" pY="42.35" width="53" height="50" dI="0" dr="2"/>
<f x="1.85" y="-13.7" kX="3.99" kY="3.99" cX="1" cY="1" z="10" pX="22.05" pY="39.4" width="47" height="43" dI="0" dr="5"/>
<f x="3" y="-14" kX="-15" kY="-15" cX="1" cY="1" z="10" pX="31.05" pY="42.35" width="53" height="50" dI="0" dr="2"/>
<f x="0" y="-14" kX="0" kY="0" cX="1" cY="1" z="10" pX="22" pY="37.95" width="44" height="40" dI="0" dr="6"/>
<f x="0" y="-14" kX="9.25" kY="9.25" cX="1" cY="1" z="10" pX="21.95" pY="41" width="50" height="47" dI="0" dr="3"/>
<f x="-2" y="-14" kX="-5.75" kY="-5.75" cX="1" cY="1" z="10" pX="25.7" pY="39.95" width="48" height="44" dI="0" dr="6"/>
</b>
<b name="weapon" sc="1" dl="0">
<f x="-13.3" y="-25.9" kX="-145" kY="-145" cX="1" cY="1" z="11" pX="74.15" pY="58.2" width="91" height="77" dI="0" dr="5"/>
<f x="-14" y="-2" kX="80" kY="80" cX="1" cY="1" z="11" pX="16.5" pY="12.45" width="46" height="94" dI="0" dr="2"/>
<f x="-0.05" y="3" kX="105" kY="105" cX="1" cY="1" z="11" pX="35.2" pY="13.55" width="53" height="95" dI="0" dr="5"/>
<f x="13.75" y="-17" kX="-60" kY="-60" cX="1" cY="1" z="11" pX="18" pY="76.8" width="71" height="93" dI="0" dr="2"/>
<f x="8.75" y="-21" kX="-91.03" kY="-91.03" cX="1" cY="1" z="11" pX="16.45" pY="80.25" width="32" height="91" dI="0" dr="6"/>
<f x="-17.65" y="-5.5" kX="150" kY="150" cX="1" cY="1" z="11" pX="76.8" pY="18" width="93" height="71" dI="0" dr="3"/>
<f x="-20.65" y="-5.5" kX="159.23" kY="159.23" cX="1" cY="1" z="11" pX="80.1" pY="17.55" width="95" height="60" dI="0" dr="6"/>
</b>
<b name="armR" sc="1" dl="0">
<f x="-17.45" y="-10.5" kX="-66.27" kY="-66.27" cX="1" cY="1" z="12" pX="4.45" pY="18.1" width="18" height="23" dI="0" dr="5"/>
<f x="-1" y="-12" kX="150" kY="150" cX="1" cY="1" z="12" pX="18.6" pY="6.2" width="23" height="19" dI="0" dr="2"/>
<f x="-2.45" y="-12.55" kX="86.72" kY="86.72" cX="1" cY="1" z="12" pX="6.1" pY="2.25" width="12" height="21" dI="0" dr="5"/>
<f x="-1" y="-12" kX="-12" kY="-12" cX="1" cY="1" z="12" pX="2.8" pY="7.65" width="22" height="14" dI="0" dr="2"/>
<f x="-4" y="-12" kX="-27" kY="-27" cX="1" cY="1" z="12" pX="3.6" pY="11.7" width="23" height="18" dI="0" dr="6"/>
<f x="-4" y="-12" kX="160" kY="160" cX="1" cY="1" z="12" pX="18.95" pY="6.35" width="23" height="17" dI="0" dr="3"/>
<f x="-7" y="-12" kX="160" kY="160" cX="1" cY="1" z="12" pX="18.95" pY="6.35" width="23" height="17" dI="0" dr="6"/>
</b> </b>
</mov> </mov>
</animation> </animation>
</animations> </animations>
<TextureAtlas name="Example03" width="512" height="64"> <TextureAtlas name="Example03" width="128" height="128">
<SubTexture name="Knight_f-hero_sword" pX="10" pY="15" width="90" height="30" x="0" y="0"/> <SubTexture name="Knight_f-hero_sword" width="90" height="30" cocos2d_pX="10" cocos2d_pY="15" x="0" y="0"/>
<SubTexture name="Knight_f-hero_head" pX="22" pY="37.95" width="44" height="40" x="134" y="0"/> <SubTexture name="Knight_f-hero_head" width="44" height="40" cocos2d_pX="22.25" cocos2d_pY="39.05" x="42" y="32"/>
<SubTexture name="Knight_f-hero_leg" pX="4" pY="0" width="8" height="16" x="260" y="0"/> <SubTexture name="Knight_f-hero_leg" width="8" height="16" cocos2d_pX="4" cocos2d_pY="0" x="114" y="0"/>
<SubTexture name="Knight_f-hero_body" pX="7" pY="14" width="14" height="16" x="244" y="0"/> <SubTexture name="Knight_f-hero_body" width="14" height="16" cocos2d_pX="7" cocos2d_pY="14" x="92" y="12"/>
<SubTexture name="Knight_f-hero_arm" pX="2" pY="4" width="20" height="10" x="222" y="0"/> <SubTexture name="Knight_f-hero_arm" width="20" height="10" cocos2d_pX="2" cocos2d_pY="4" x="92" y="0"/>
<SubTexture name="Knight_f-horse_head" pX="2" pY="46" width="40" height="48" x="92" y="0"/> <SubTexture name="Knight_f-horse_head" width="40" height="45" cocos2d_pX="1.95" cocos2d_pY="45.95" x="0" y="32"/>
<SubTexture name="Knight_f-horse_tail" pX="6" pY="2" width="8" height="12" x="280" y="0"/> <SubTexture name="Knight_f-horse_tail" width="8" height="12" cocos2d_pX="6" cocos2d_pY="2" x="118" y="18"/>
<SubTexture name="Knight_f-horse_body" pX="20" pY="2" width="40" height="20" x="180" y="0"/> <SubTexture name="Knight_f-horse_body" width="40" height="20" cocos2d_pX="20" cocos2d_pY="2" x="42" y="74"/>
<SubTexture name="Knight_f-horse_leg" pX="4" pY="0" width="8" height="14" x="270" y="0"/> <SubTexture name="Knight_f-horse_leg" width="8" height="14" cocos2d_pX="4" cocos2d_pY="0" x="108" y="18"/>
</TextureAtlas> </TextureAtlas>
</skeleton> </skeleton>

1242
samples/Cpp/TestCpp/Resources/armature/robot.xml
View File

File diff suppressed because it is too large Load Diff