本文源自官方直播，以文字形式记录绑定过程。

使用的Unity版本：2019.2.0f1



 

 

一、技术简介

基于Animation C# Job构建的程序化动画绑定系统。特点：高质量、高性能、可扩展

该资源包位于Unity Packages，记得勾选预览。

如果加载不出资源包看这篇文章。



 

二、基本组件介绍

在人物（带有状态机）物体上添加Rigbuilder、BoneRenderer。

Rigbuilder：与Animator位于同一物体上，利用Animator中的动画生成PlayableGraph并添加到现有的动画状态机上，支持同时添加多个Rigs。能够对所有的Playable动画进行混合，混合树也是利用PlayableGraph实现动画混合。

BoneRenderer：是一个工具，骨骼信息可视化，方便你绑定、编辑

Rigs：自己建立的物体rig，添加Rig组件，与骨骼的根节点位于同一层级。收集子节点的约束组件，并按照顺序（深度优先）生成AnimationJob的列表，交给Rigbuilder来进行执行。



 

三、预定义约束介绍

RigConstraints。

这里面包含了很多预定义约束。



 

四、Demo阶段

1、导入Unity商城里免费的Post apocalyptic survival character模型，调整shader

2、找到模型fbx文件，调整Humanoid，拖到场景。

3、骨骼初始设置：

      a、人物模型Animator位置添加Rigbuilder、BoneRenderer，

      b、在与骨骼同级别的位置新建rig物体，添加Rig组件，Rig控制下方物体运动。

      c、将骨骼下方所有父节点（除了最末尾的物体），全选添加进BoneRenderer的Transform里面，渲染出骨骼。





 4、添加脚步IK动画

1）程序配置：

a、在rig下新建ik物体，ik下新建两个空物体lfik、rgik，位置分别在模型脚踝的位置，给lfik、rgik分别添加两个骨头之间的约束：TwoBoneIKConstraint


接着来解决一个坑：无法添加TwoBoneIKConstraint脚本

Q1：这时，我们AddComponent，是搜不到TwoBoneIKConstraint的。

A1：我们要先导入约束案例，这里面有该脚本（视频怎么不讲-_-||）



 

20191121更新：

注意，下面展示的bug，是由于Unity版本不是2019.2.0f1导致的，Unity版本必须在2019.2.0f1及以上！

因此暂停更新，Unity原视频链接：https://www.bilibili.com/video/av61671904

想继续学习的同学可以根据视频继续往下学习。

且还有一个bug，在最下方说明。

 

Q2：我们导入约束案例了，仍无法添加该脚本。即使看他们的案例，物体上的该脚本仍是报错状态。

A2：打开该脚本时，我们发现提示该脚本是只读状态。将脚本属性只读取消不管用。正确办法：

将TwoBoneIKConstraint脚本从packages里另存到你的项目Assets里去，现在即可进行添加。




b、将骨骼及控制器配置到TwoBoneIKConstraint里面

视频上说点击骨骼，将骨骼对应的物体这样配置，Tip是Mid的子物体。但没有说为什么这样选。猜测是IK控制脚步移动，脚步涉及到大腿、小腿、

Target就是控制器了，自身。



2）、K动画

即制作动画。

a、先给Animator的物体创建Animation

b、把IK的属性添加进Animation

      就是在创建的Animtion里，AddProperty，找到你创建的rig，把你创建的lfik、rgik两个控制器的Position和Rotation添加进去。

该地方Preview有预览动画功能，点击后可在不运行状态下，调整lfik、rgik属性即可实时预览动作变化。

Preview不运行预览仅在2019.2.0f1及以上支持，我测试了一下2019.1，发现不运行开启Perview，调整lfik、rgik属性并没有什么动作变化。运行后这两个属性还锁定不能改了。。



 

暂停更新，因为该版本Unity切换到安卓平台时，不能设置API Levels，不知道如何解决。

 

五、自定义渲染管线

六、LWRP中的Shader

这次做了一个Unity的2D动画，记录一下，怕下次忘了怎么做。
首先是先决条件，推荐使用Unity2019.2或更高版本，安装 2D Animation 和 2D PSD Importer 包。
官方文档：
https://docs.unity3d.com/Packages/com.unity.2d.animation@3.0/manual/index.html

https://docs.unity3d.com/Packages/com.unity.2d.psdimporter@2.0/manual/index.html
资源文件需要 PSB 格式，直接使用PS另存为PSB格式就可以了。
我是线在手机上随便画了一个，然后传到电脑上，用PS另存为PSB格式。
直接把PSB文件拖进Unity里就可以了。
打开骨骼编辑系统。
如果使用自动处理会简单一些，先创建骨骼，然后绑定，使用 Auto Geometry 绑定，并自动创建权重。这个时候会发现网格分好了，但是这些东西全都是连成一片的，动手臂身子也会跟着动。
这里身子部分是不需要动画的，所以直接把身体部分的网格删掉就可以了。
也可以先选定图层，然后再自动创建网格。
如果是手动处理的话，会麻烦一点，但是很多情况下更需要手动去处理。我这里只演示一部分。
转载于：http://www.googln.net/

    

			
原文地址：[转载]maya 履带动画绑定插件 api 源码分享。作者：TianCG_VFX_TD
[转载] maya 履带动画绑定插件 api 源码分享
原地址:http://blog.sina.com.cn/s/blog_67e626560100mrzc.html
 
代码包下载地址：链接：http://pan.baidu.com/s/1OLCYE
密码：pj6k
 
下面的maya api源码，需要大家自己在vs里编译。



//首先是头文件代码:

//头文件名称:glideDeformer.h

 

#ifndef glideDeformer_h

#define glideDeformer_h

#include

#include

#include

#include

#include

#include

#include

#include

#include

#include

#include

#include

#include

#include

#include

#include

#include

#include

#include

class glideDeformer:public MPxDeformerNode

{

public:

    glideDeformer(){};


    virtual
~glideDeformer(){};

    static
void * creator(){return new glideDeformer;};

    static
MStatus initializeAttr();

    virtual
MStatus  deform(MDataBlock
&block, MItGeometry &iter, const MMatrix &mat, unsigned
int multiIndex);

    bool
getClosestUVParam(MPoint & point,MFnNurbsSurface &
surfaceFn,MObject surfaceData,double & paramU,double &
paramV);

    bool
getPointFroamSurfacePoint(MPoint & point,MFnNurbsSurface
& surfaceFn,MObject surfaceData,double & paramU,double
& paramV,MPoint & outPoint);

    bool
getPointAfterDeformed(MPoint &
pointInSurfaceMatrix,MFnNurbsSurface & surfaceFn,MObject
surfaceData,double & paramU,double & paramV,MPoint &
pointAffterDeformed);

    static
MString nodeName;

    static
MTypeId nodeId;

    static
MObject glide;

    static
MObject fixedBase;

    static
MObject aimDirection;

    static
MObject drivenSurface;

    static
MObject baseSurface;

};

#endif


 

//CPP文件

#include "glideDeformer.h"

MString glideDeformer::nodeName=MString("glideDeformer");

MTypeId glideDeformer::nodeId=MTypeId(0x87031);

MObject glideDeformer::glide;

MObject glideDeformer::fixedBase;

MObject glideDeformer::aimDirection;

MObject glideDeformer::drivenSurface;

MObject glideDeformer::baseSurface;

using std::cout;

using std::endl;

MStatus glideDeformer::initializeAttr()

{

    MFnNumericAttribute
numattr;

    MFnTypedAttribute
typedattr;

    MFnEnumAttribute
enumattr;

    glide=numattr.create("glide","gld",MFnNumericData::kFloat,0.0);


    numattr.setKeyable(true);


    numattr.setStorable(true);

    fixedBase=numattr.create("fixedBase","fxb",MFnNumericData::kBoolean,0);


    numattr.setKeyable(true);


    numattr.setStorable(true);

    aimDirection=enumattr.create("aimDirection","adr",0);


    enumattr.addField("directionU",0);


    enumattr.addField("directionV",1);


    enumattr.setKeyable(true);


    enumattr.setStorable(true);

    drivenSurface=typedattr.create("drivenSurface","dsf",MFnData::kNurbsSurface);


    typedattr.setStorable(false);

    baseSurface=typedattr.create("baseSurface","bsf",MFnData::kNurbsSurface);


    typedattr.setStorable(false);

    //addAttribtue


    addAttribute(glide);


    addAttribute(fixedBase);


    addAttribute(drivenSurface);


    addAttribute(baseSurface);


    addAttribute(aimDirection);

    attributeAffects(glide,outputGeom);


    attributeAffects(fixedBase,outputGeom);


    attributeAffects(aimDirection,outputGeom);


    attributeAffects(drivenSurface,outputGeom);


    attributeAffects(baseSurface,outputGeom);

    return
MS::kSuccess;

};



bool glideDeformer::getClosestUVParam(MPoint &
point,MFnNurbsSurface & surfaceFn,MObject surfaceData,double
& paramU,double & paramV)

{

    surfaceFn.setObject(surfaceData);


    MPoint
tmpPoint=surfaceFn.closestPoint(point,0,0,false,0.001,MSpace::kWorld);


    MStatus
stat=surfaceFn.getParamAtPoint(tmpPoint,paramU,paramV,true,MSpace::kWorld,0.001);


    return
true;

};



bool glideDeformer::getPointFroamSurfacePoint(MPoint &
point,MFnNurbsSurface & surfaceFn,MObject surfaceData,double
& paramU,double & paramV,MPoint & outPoint)

{

    surfaceFn.setObject(surfaceData);


    MVector
tangentU;

    MVector
tangentV;

    MVector
normal;

    MPoint
surfacePoint;

    surfaceFn.getPointAtParam(paramU,paramV,surfacePoint,MSpace::kWorld);


    normal=surfaceFn.normal(paramU,paramV,MSpace::kWorld);


    surfaceFn.getTangents(paramU,paramV,tangentU,tangentV,MSpace::kWorld);

    tangentU.normalize();


    tangentV.normalize();


    normal.normalize();

    double
matrix[4][4]={{tangentU.x,tangentU.y,tangentU.z,0.0},{normal.x,normal.y,normal.z,0.0},{tangentV.x,tangentV.y,tangentV.z,0.0},{surfacePoint.x,surfacePoint.y,surfacePoint.z,1.0}};


    MMatrix
surfacePointMatrix=MMatrix(matrix);

    //cout<<"baseSurfacePointMatrix:"<<surfacePointMatrix<<endl;


   


    outPoint=point*surfacePointMatrix.inverse();


    //cout<<"pointInSurfaceMatrixPosition:"<<outPoint<<endl;


    return
true;

};



bool glideDeformer::getPointAfterDeformed(MPoint &
pointInSurfaceMatrix,MFnNurbsSurface & surfaceFn,MObject
surfaceData,double & paramU,double & paramV,MPoint &
pointAffterDeformed)

{

    surfaceFn.setObject(surfaceData);

    MVector
tangentU;

    MVector
tangentV;

    MVector
normal;

    MPoint
surfacePoint;

    surfaceFn.getPointAtParam(paramU,paramV,surfacePoint,MSpace::kWorld);


    normal=surfaceFn.normal(paramU,paramV,MSpace::kWorld);


    surfaceFn.getTangents(paramU,paramV,tangentU,tangentV,MSpace::kWorld);

    tangentU.normalize();


    tangentV.normalize();


    normal.normalize();

    double
matrix[4][4]={{tangentU.x,tangentU.y,tangentU.z,0.0},{normal.x,normal.y,normal.z,0.0},{tangentV.x,tangentV.y,tangentV.z,0.0},{surfacePoint.x,surfacePoint.y,surfacePoint.z,1.0}};


    MMatrix
surfacePointMatrix=MMatrix(matrix);

    //cout<<"drivenSurfacePointMatrix:"<<surfacePointMatrix<<endl;

    pointAffterDeformed=pointInSurfaceMatrix*surfacePointMatrix;


    //cout<<"pointAffterDeformedPosition:"<<pointAffterDeformed<<endl;

    return
true;

};



MStatus  glideDeformer::deform(MDataBlock
&block, MItGeometry & iter, const MMatrix &mat,
unsigned int multiIndex)

{

    //cout<<"deform()方法调用..."<<endl;


    MDataHandle
envelopehandle=block.inputValue(envelope);

    MDataHandle
glidehandle=block.inputValue(glide);

    MDataHandle
fixedBasehandle=block.inputValue(fixedBase);

    MDataHandle
aimDirectionhandle=block.inputValue(aimDirection);

   


    float
envelopevalue=envelopehandle.asFloat();

    float
glidevalue=glidehandle.asFloat();

    short
aimDirectionvalue=aimDirectionhandle.asShort();

    bool
fixedBasevalue=fixedBasehandle.asBool();

    if
(envelopevalue==0.0)

    {


        //cout<<"envelope值为0,跳过deform方法..."<<endl;


        return
MS::kSuccess;

    };

    MDataHandle
drivenSurfacehandle=block.inputValue(drivenSurface);

    MDataHandle
baseSurfacehandle=block.inputValue(baseSurface);



    MFnNurbsSurfaceData
surfaceDataFn;

    MFnNurbsSurface
surfaceFn;

    MObject
drivenSurfaceData=drivenSurfacehandle.asNurbsSurface();

    MObject
baseSurfaceData=baseSurfacehandle.asNurbsSurface();

    MObject
drivenSurfaceObj=surfaceDataFn.create();

    MObject
baseSurfaceObj=surfaceDataFn.create();

    surfaceFn.setObject(drivenSurfaceData);


    surfaceFn.copy(drivenSurfaceObj);


    int
drivenSurfaceCvU=surfaceFn.numCVsInU();

    int
drivenSurfaceCvV=surfaceFn.numCVsInV();

   


    surfaceFn.setObject(baseSurfaceData);


    surfaceFn.copy(baseSurfaceObj);


    int
baseSurfaceCvU=surfaceFn.numCVsInU();

    int
baseSurfaceCvV=surfaceFn.numCVsInV();

    cout<<drivenSurfaceCvU<<"  "<<drivenSurfaceCvV<<"  "<<baseSurfaceCvU<<"  "<<baseSurfaceCvV<<" "<<endl;


    if
(drivenSurfaceCvU==0||drivenSurfaceCvV==0||drivenSurfaceCvU==0||baseSurfaceCvU==0||baseSurfaceCvV==0)


    {


        //cout<<"drivenSurface或baseSurface不正确，变形不产生..."<<endl;


        MGlobal::displayWarning("drivenSurface或baseSurface不正确，变形不产生...");


        return
MS::kSuccess;

    };

 if
(drivenSurfaceCvU!=baseSurfaceCvU||drivenSurfaceCvV!=baseSurfaceCvV)


 {

        //cout<<"drivenSurface与baseSurface不匹配，变形不产生..."<<endl;


        MGlobal::displayWarning("drivenSurface与baseSurface不匹配，变形不产生...");


        return
MS::kSuccess;

 };

   


    MPoint
pt;

    MPoint
ptAfterDeformed;

    MPoint
pointInSurfacePointMatrix;

    double
paramU;

    double
paramV;

    double
newParamU;

    double
newParamV;

    int
index;

    float
weight;

    bool
test;

    if
(fixedBasevalue==false)

    {


        //cout<<"履带模式..."<<endl;


        for(iter.reset();!iter.isDone();iter.next())


        {


            index=iter.index();


            //cout<<"index:"<<index<<endl;


            weight=weightValue(block,multiIndex,index);


            //cout<<"weight:"<<weight<<endl;


            if
(weight==0)

            {


                //cout<<"权重为0,此点变形不产生..."<<endl;


                continue;


            };


            pt=iter.position(MSpace::kObject);


            pt=pt*mat;


            //cout<<"position:"<<pt<<endl;


           


      
  

//碰撞框
class ColliderBody : public cocos2d::Ref
{
public:
    ColliderBody(ContourData *contourData);
    ~ColliderBody();

    inline ContourData *getContourData() { return _contourData; }

#if ENABLE_PHYSICS_BOX2D_DETECT || ENABLE_PHYSICS_CHIPMUNK_DETECT 
    void setColliderFilter(ColliderFilter *filter);
    ColliderFilter *getColliderFilter();
#endif

#if ENABLE_PHYSICS_BOX2D_DETECT
    virtual void setB2Fixture(b2Fixture *fixture) { _fixture = fixture; }
    virtual b2Fixture *getB2Fixture() const { return _fixture; }
#elif ENABLE_PHYSICS_CHIPMUNK_DETECT
    virtual void setShape(cpShape *shape) { _shape = shape; }
    virtual cpShape *getShape() const { return _shape; }
#elif ENABLE_PHYSICS_SAVE_CALCULATED_VERTEX
    virtual const std::vector<cocos2d::Point> &getCalculatedVertexList() const { return _calculatedVertexList; }
#endif

private:

#if ENABLE_PHYSICS_BOX2D_DETECT
    b2Fixture *_fixture;
    ColliderFilter *_filter;
#elif ENABLE_PHYSICS_CHIPMUNK_DETECT
    cpShape *_shape;
    ColliderFilter *_filter;
#elif ENABLE_PHYSICS_SAVE_CALCULATED_VERTEX
    std::vector<cocos2d::Point> _calculatedVertexList;//所有顶点
#endif

    ContourData *_contourData;//轮廓数据

    friend class ColliderDetector;
};

/*
 *  @brief  ContourSprite used to draw the contour of the display
 *  @js NA
 *  @lua NA
 */
class ColliderDetector : public cocos2d::Ref
{
public:
    static ColliderDetector *create();
    static ColliderDetector *create(Bone *bone);
public:
	/**
     * @js ctor
     */
    ColliderDetector();
    /**
     * @js NA
     * @lua NA
     */
    ~ColliderDetector(void);

    virtual bool init();
    virtual bool init(Bone *bone);

    void addContourData(ContourData *contourData);//手动添加 一个 轮廓顶点信息数据
    void addContourDataList(cocos2d::Vector<ContourData*> &contourDataList);//手动添加 一组 轮廓顶点信息数据

    void removeContourData(ContourData *contourData);//手动移除 一个 轮廓顶点信息数据
    void removeAll();//手动添加 所有 轮廓顶点信息数据

    void updateTransform(kmMat4 &t);//旋转更新

    void setActive(bool active);//设置激活状态
    bool getActive();

    const cocos2d::Vector<ColliderBody*>& getColliderBodyList();//得到所有轮廓框信息

#if ENABLE_PHYSICS_BOX2D_DETECT || ENABLE_PHYSICS_CHIPMUNK_DETECT 
    virtual void setColliderFilter(ColliderFilter *filter);
    virtual ColliderFilter *getColliderFilter();
#endif

    virtual void setBone(Bone *bone) { _bone = bone; }
    virtual Bone *getBone() const { return _bone; }

#if ENABLE_PHYSICS_BOX2D_DETECT
    virtual void setBody(b2Body *body);
    virtual b2Body *getBody() const;
#elif ENABLE_PHYSICS_CHIPMUNK_DETECT
    virtual void setBody(cpBody *body);
    virtual cpBody *getBody() const;
#endif
 protected:
    cocos2d::Vector<ColliderBody*> _colliderBodyList;//碰撞body

    Bone *_bone;//骨骼

#if ENABLE_PHYSICS_BOX2D_DETECT
    b2Body *_body;
    ColliderFilter *_filter;
#elif ENABLE_PHYSICS_CHIPMUNK_DETECT
    cpBody *_body;
    ColliderFilter *_filter;
#endif

protected:
    bool _active;//是否激活
};

}

#endif /*__CCCOLLIDERDETECTOR_H__*/



class TestColliderDetector : public ArmatureTestLayer
{
public:
    ~TestColliderDetector();
    
    virtual void onEnter() override;
    virtual std::string title() const override;
    virtual void update(float delta);
    virtual void draw(Renderer *renderer, const kmMat4 &transform, bool transformUpdated) override;
    void onDraw(const kmMat4 &transform, bool transformUpdated);
    
    void onFrameEvent(cocostudio::Bone *bone, const std::string& evt, int originFrameIndex, int currentFrameIndex);
    
    void initWorld() {};
    cocostudio::Armature *armature;
    cocostudio::Armature *armature2;
    
    CustomCommand _customCommand; //new render needed this for drawing primitives
    cocos2d::Sprite *bullet;
};
void TestColliderDetector::update(float delta)
{
    armature2->setVisible(true);
//
//    CCNode中两个个方法方法：
//    getContentSize用来获得节点原始大小。返回CGSize类型
//    getBoundingBox获得节点当前大小，即如果经过缩放那么就是缩放后的大小。返回CGRect类型。
//    有个问题最近才遇到，父精灵进行缩放处理，会对子精灵进行标记（boolean值），在实际绘制过程中会影响子精灵显示大小，但并不改变子精灵的getBoundingBox所获得的值，也就是只有直接setscale才会影响getBoundingBox数值。
//    CCSprite中有个方法：
//    getTextureRect返回精灵纹理大小，返回CGRect类型，并且是原始纹理大小，无关缩放。在一般情况下和getContentSize作用一样，但如果用TP处理过，还回值是实际纹理大小，留白部分会去除。这个在碰撞检测过程中经常用到。
    Rect rect = bullet->getBoundingBox();

    // This code is just telling how to get the vertex.
    // For a more accurate collider detection, you need to implemente yourself.
    const Map<std::string, Bone*>& map = armature2->getBoneDic();//得到骨骼字典
    for(const auto& element : map)//遍历字典
    {
        Bone *bone = element.second;
        ColliderDetector *detector = bone->getColliderDetector();

        if (!detector)//如否没有碰撞 跳过 继续遍历
            continue;
        //得到碰撞框列表
        const cocos2d::Vector<ColliderBody*>& bodyList = detector->getColliderBodyList();

        for (const auto& object : bodyList)
        {
            //得到一个碰撞框
            ColliderBody *body = static_cast<ColliderBody*>(object);
            //一个碰撞框包含的所有顶点
            const std::vector<Point> &vertexList = body->getCalculatedVertexList();

            float minx = 0, miny = 0, maxx = 0, maxy = 0;
             int length = (int)vertexList.size();//顶点个数
            for (int i = 0; i<length; i++)
            {
                Point vertex = vertexList.at(i);
                if (i == 0)
                {
                    minx = maxx = vertex.x;//起点和终点 是 第一个点
                    miny = maxy = vertex.y;
                }
                else//遍历所有点 得到4个最值
                {
                    minx = vertex.x < minx ? vertex.x : minx;
                    miny = vertex.y < miny ? vertex.y : miny;
                    maxx = vertex.x > maxx ? vertex.x : maxx;
                    maxy = vertex.y > maxy ? vertex.y : maxy;
                }
            }
            Rect temp = Rect(minx, miny, maxx - minx, maxy - miny);//组成一个包含所有顶点的矩形

            if (temp.intersectsRect(rect))
            {
                //子弹矩形在碰撞区域内 碰撞框不可见
                armature2->setVisible(false);
            }
        }
    }
}
void TestColliderDetector::draw(Renderer *renderer, const kmMat4 &transform, bool transformUpdated)
{
    _customCommand.init(_globalZOrder);
    _customCommand.func = CC_CALLBACK_0(TestColliderDetector::onDraw, this, transform, transformUpdated);
    renderer->addCommand(&_customCommand);
}

void TestColliderDetector::onDraw(const kmMat4 &transform, bool transformUpdated)
{
    kmGLPushMatrix();
    kmGLLoadMatrix(&transform);
    
    armature2->drawContour();
    
    kmGLPopMatrix();
}

TestColliderDetector::~TestColliderDetector()
{
}
void TestColliderDetector::onEnter()
{
    ArmatureTestLayer::onEnter();

    scheduleUpdate();

    armature = Armature::create("Cowboy");
    armature->getAnimation()->play("FireWithoutBullet");
    armature->getAnimation()->setSpeedScale(0.2f);
    armature->setScaleX(-0.2f);
    armature->setScaleY(0.2f);
    armature->setPosition(Point(VisibleRect::left().x + 70, VisibleRect::left().y));

    /*
    * Set armature's frame event callback function
    * To disconnect this event, just setFrameEventCallFunc(nullptr);
    */
    armature->getAnimation()->setFrameEventCallFunc(CC_CALLBACK_0(TestColliderDetector::onFrameEvent, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, std::placeholders::_4));
    addChild(armature);

    armature2 = Armature::create("Cowboy");
    armature2->getAnimation()->play("Walk");
    armature2->setScaleX(-0.2f);
    armature2->setScaleY(0.2f);
    armature2->setPosition(Point(VisibleRect::right().x - 60, VisibleRect::left().y));
    addChild(armature2);

#if ENABLE_PHYSICS_BOX2D_DETECT || ENABLE_PHYSICS_CHIPMUNK_DETECT
    bullet = cocos2d::extension::PhysicsSprite::createWithSpriteFrameName("25.png");
#elif ENABLE_PHYSICS_SAVE_CALCULATED_VERTEX
    bullet = Sprite::createWithSpriteFrameName("25.png");
#endif
    addChild(bullet);

    initWorld();
}
std::string TestColliderDetector::title() const
{
    return "Test Collider Detector";
}
void TestColliderDetector::onFrameEvent(Bone *bone, const std::string& evt, int originFrameIndex, int currentFrameIndex)
{
    CCLOG("(%s) emit a frame event (%s) at frame index (%d).", bone->getName().c_str(), evt.c_str(), currentFrameIndex);

    /*
    * originFrameIndex is the frame index editted in Action Editor
    * currentFrameIndex is the current index animation played to
    * frame event may be delay emit, so originFrameIndex may be different from currentFrameIndex.
    */

    Point p = armature->getBone("Layer126")->getDisplayRenderNode()->convertToWorldSpaceAR(Point(0, 0));
    bullet->setPosition(Point(p.x + 60, p.y));

    bullet->stopAllActions();
    bullet->runAction(CCMoveBy::create(1.5f, Point(350, 0)));
}