api cocos
cocos API
2018-07-01 23:03:49 weixin_39276942 阅读数 173


--node
一个节点的主要特点:
    > 他们可以包含其他的节点对象(addChild, getChildByTag, removeChild, etc)
    > 他们可以安排定期的回调(schedule, unschedule, etc)
    > 他们可以执行一些动作(runAction, stopAction, etc)
    > 子类节点通常意味着(单一的/所有的):
        > 重写初始化资源并且可以安排回调
        > 创建回调来操作进行的时间
        > 重写“draw”来渲染节点
    > 节点的属性有:位置、缩放、旋转、倾斜、锚点、内容大小、可见性

    下面将介绍一下节点主要常用的一些操作函数,以及新的功能特性。
    (1)节点的属性
    (2)节点的操作
    (3)动作相关Action
    (4)定时器相关schedule
    (5)整合NodeRBGA类
    (6)查找子节点enumerateChildren
    (7)渲染顺序zOrder
    (8)坐标转换


 1、节点的属性
 节点的属性有:位置、缩放、旋转、倾斜、锚点、内容大小、可见性。
  位置Position
 *     设置节点的坐标(x,y).在OpenGL中的坐标
 *     增加3D坐标
 *     增加标准化坐标设置
 */
    virtual void setPosition(const Vec2 &position); //Vec2坐标
    virtual void setPosition(float x, float y);     //(x,y),比Vec2更有效率
    virtual void setPositionX(float x);
    virtual void setPositionY(float y);
    virtual const Vec2& getPosition() const;
    virtual void  getPosition(float* x, float* y) const;
    virtual float getPositionX(void) const;
    virtual float getPositionY(void) const;

//增加3D坐标
    virtual void setPosition3D(const Vec3& position); //Vec3坐标
    virtual Vec3 getPosition3D() const;
    virtual void setPositionZ(float positionZ);
    virtual float getPositionZ() const;

//增加标准化坐标设置
    //Node的位置像素会根据它的父节点的尺寸大小计算
    //Size s = getParent()->getContentSize();
    //_position = pos * s;
    virtual void setNormalizedPosition(const Vec2 &position);
    virtual const Vec2& getNormalizedPosition() const;


/**
 * 放缩Scale
 *     设置节点的放缩比例. 对XYZ轴进行放缩
 *     例如一张图片. 放缩它的宽X,高Y,深Z
 */
    virtual void setScaleX(float scaleX);              //放缩宽X
    virtual void setScaleY(float scaleY);              //放缩高Y
    virtual void setScaleZ(float scaleZ);              //放缩深Z
    virtual void setScale(float scaleX, float scaleY); //X放缩fScaleX倍,Y放缩fScaleY倍
    virtual void setScale(float scale);                //XYZ同时放缩scale倍
    virtual float getScaleX() const;
    virtual float getScaleY() const;
    virtual float getScaleZ() const;
    virtual float getScale()  const;                   //当x,y放缩因子相同时,得到该节点的缩放因子


/**
 * 旋转Rotation
 *     设置节点的旋转角度. 负顺,正逆时针旋转
 *     增加3D旋转
 */
    virtual void setRotation(float rotation);
    virtual float getRotation() const;

//增加3D旋转
    virtual void setRotation3D(const Vec3& rotation); 
    virtual Vec3 getRotation3D() const;


/**
 * 倾斜Skew
 *     设置XY轴的倾斜角度
 *     setRotationalSkew()  模拟Flash的倾斜功能
 *     setSkew()            使用真正的倾斜功能
 */
    virtual void setSkewX(float skewX); //水平旋转倾斜.负顺时针变形
    virtual void setSkewY(float skewY); //垂直旋转倾斜
    virtual void setRotationSkewX(float rotationX);
    virtual void setRotationSkewY(float rotationY);
    virtual float getSkewX() const;
    virtual float getSkewY() const;
    virtual float getRotationSkewX() const;
    virtual float getRotationSkewY() const;


/**
 * 锚点AnchorPoint
 *     锚点就像一枚图钉,将图片钉在屏幕上.而锚点就是图片的坐标.
 *     当然图钉可以钉在图片的左下角,右上角,或者中心都可以.
 *     (0,0)表示左下角,(1,1)表示右上角
 *     默认的锚点是(0.5,0.5),即节点的正中心
 */
    virtual void setAnchorPoint(const Vec2& anchorPoint); //标准化的锚点
    virtual const Vec2& getAnchorPoint() const;           //标准化的锚点
    virtual const Vec2& getAnchorPointInPoints() const;   //返回绝对像素的锚点,即屏幕坐标

//是否忽略锚点的设置
    //若忽略锚点设置,锚点永远为(0,0)
    //默认值是false, 但是在Layer和Scene中是true
    //这是一个内部方法,仅仅被Layer和Scene使用,不要自行调用!
    virtual void ignoreAnchorPointForPosition(bool ignore);
    virtual bool isIgnoreAnchorPointForPosition() const;


/**
 * 内容大小ContentSize
 *     contentSize依然是相同的,无论节点是缩放或者旋转 
 *     所有的节点都有大小,图层和场景有相同的屏幕大小
 */
    virtual void setContentSize(const Size& contentSize);
    virtual const Size& getContentSize() const;

/**
 * 可见性Visible
 */
    virtual void setVisible(bool visible);
    virtual bool isVisible() const;


2、节点的操作
    节点的操作有:标记、名字、自定义数据、父节点管理、子节点管理、其他操作管理。

//
/**
 * 标记与名字 Tag and Name
 *     setTag  : 给节点设置一个编号
 *     setName : 给节点设置一个名字
 */
    virtual void setTag(int tag);
    virtual void setName(const std::string& name);
    virtual int getTag() const;
    virtual std::string getName() const;


/**
 * 自定义数据UserData/Object
 *     setUserData   : 设置一个用户自定义的数据. 可以为一个数据块, 结构体或者一个对象.
 *     setUserObject : 设置一个用户自定义的对象. 和userData类似, 但它是一个对象而不是void*
 */
    virtual void setUserData(void *userData);
    virtual void setUserObject(Ref *userObject);
    virtual void* getUserData();
    virtual Ref* getUserObject();


/**
 * 设置父节点Parent
 *     setParent , removeFromParent
 */
    virtual void setParent(Node* parent);
    virtual Node* getParent();
    virtual void removeFromParent();
    virtual void removeFromParentAndCleanup(bool cleanup); //true则删除该节点的所有动作及回调函数.


/**
 * 管理子节点Child
 *     addChild , 
 *     getChildBy** , getChildren       , getChildrenCount
 *     removeChild  , removeAllChildren
 *     reorderChild , sortAllChildren
 */
    //添加子节点
    //localZOrder   Z轴顺序为了绘画的优先权
    //tag           节点编号,可通过tag获取子节点
    //name        节点名字,可通过name获取子节点
    virtual void addChild(Node * child);
    virtual void addChild(Node * child, int localZOrder);
    virtual void addChild(Node* child, int localZOrder, int tag);
    virtual void addChild(Node* child, int localZOrder, const std::string &name);

    //获取子节点
    virtual Node* getChildByTag(int tag) const;
    virtual Node* getChildByName(const std::string& name) const;
    virtual Vector<Node*>& getChildren();     //获得所有子节点,并以Vector数组返回
    virtual ssize_t getChildrenCount() const; //子节点总数

    //删除子节点
    virtual void removeChild(Node* child, bool cleanup = true);
    virtual void removeChildByTag(int tag, bool cleanup = true);
    virtual void removeChildByName(const std::string &name, bool cleanup = true);
    virtual void removeAllChildren();                        //删除所有节点
    virtual void removeAllChildrenWithCleanup(bool cleanup); //cleanup为true则删除子节点的所有动作

    //重排子节点
    //重新排序一个子节点,设定一个新的z轴的值
    //child         它必须是已经添加的
    //localZOrder   Z轴顺序为了绘画优先级
    virtual void reorderChild(Node * child, int localZOrder);
    virtual void sortAllChildren(); //重新排序所有子节点


/**
 * 其他操作管理
 */
    virtual void onEnter();                    //节点开始进入舞台时调用.即创建时调用.
    virtual void onEnterTransitionDidFinish(); //节点进入舞台后调用.即创建完后调用.
    virtual void onExit();                     //节点离开舞台时调用.即移除时调用
    virtual void onExitTransitionDidStart();   //节点离开舞台前调用.

    virtual void visit() final;

    //返回包含Node(节点)的Scene(场景). 
    //若不属于任何的场景,它将返回nullptr
    virtual Scene* getScene() const;

    //返回节点在父节点坐标中的矩形边界框
    virtual Rect getBoundingBox() const;

    //暂停所有的活动着的动作和调度器
    virtual void cleanup();
//
//
//
3、动作相关Action
    动作管理:运行、暂停、取消等操作。
    //
/**
 * 动作管理Action
 *     setActionManager
 *     runAction , stopAction , getActionByTag , getNumberOfRunningActions
 */
    //设置被所有动作使用的ActionManager对象
    //如果你设置了一个新的ActionManager, 那么之前创建的动作将会被删除
    virtual void setActionManager(ActionManager* actionManager);
    virtual ActionManager* getActionManager();

    Action* runAction(Action* action);          //执行一个动作
    Action* getActionByTag(int tag);            //获取动作, 根据tag标记
    void stopAllActions();                      //暂停动作
    void stopAction(Action* action);            //暂停动作
    void stopActionByTag(int tag);              //暂停动作
    ssize_t getNumberOfRunningActions() const;  //获取正在运行的动作数量


4、定时器相关schedule
    定时器管理,默认定时器、自定义定时器、一次性定时器。
    //
/**
 * 定时器管理schedule
 *     setScheduler
 *     scheduleUpdate : 默认定时器
 *     schedule       : 自定义定时器
 *     scheduleOnce   : 一次性定时器
 */
    //设置一个调度器对象,来调度所有的“update”和定时器
    //如果你设置了一个新的调度器,那么之前创建的timers/update将会被删除。
    virtual void setScheduler(Scheduler* scheduler);
    virtual Scheduler* getScheduler(); //得到调度器对象

    //开启默认定时器.刷新次数为60次/秒.即每秒60帧.
    //与update(float delta)回调函数相对应.
    //给予定时器优先级priority.其中priority越小,优先级越高
    void scheduleUpdate(void);
    void scheduleUpdateWithPriority(int priority);
    void unscheduleUpdate(void);      //取消默认定时器
    virtual void update(float delta); //update为scheduleUpdate定时器的回调函数.

    //设置自定义定时器.默认为每秒60帧.
    //interval  :   每隔interval秒,执行一次.
    //repeat    :   重复次数.
    //delay     :   延迟时间,即创建定时器delay后开始执行.
    void schedule(SEL_SCHEDULE selector, float interval, unsigned int repeat, float delay);
    void schedule(SEL_SCHEDULE selector, float interval);
    void schedule(SEL_SCHEDULE selector);                  //默认为每秒60帧
    void scheduleOnce(SEL_SCHEDULE selector, float delay); //只执行一次,delay秒后执行

    void unschedule(SEL_SCHEDULE selector);                //取消一个自定义定时器
    void unscheduleAllSelectors(void);                     //取消所有定时器
    void resume(void);                                     //恢复所有定时器和动作
    void pause(void);                                      //暂停所有定时器和动作
//
//
5、整合NodeRGBA类
    整合NodeRGBA类,增加颜色、透明度的设置。
    //
/**
 * 整合NodeRGBA类
 *     setOpacity : 透明度
 *     setColor   : 颜色
 */
    virtual GLubyte getOpacity() const;
    virtual GLubyte getDisplayedOpacity() const;
    virtual void setOpacity(GLubyte opacity);

    virtual const Color3B& getColor() const;
    virtual const Color3B& getDisplayedColor() const;
    virtual void setColor(const Color3B& color);
//
//
6、enumerateChildren
    新增的Node::enumerateChildren方法,且支持C++ 11的正则表达式。
    用于枚举某个Node节点的子节点,并让名字符合"name通配符"的子节点执行callback函数。
    且callback函数返回类型应该为一个bool值,并且返回为true时,结束查找。

    virtual void enumerateChildren(const std::string &name, std::function<bool(Node* node)> callback) const;

    使用举例:
    //Find nodes whose name is 'nameToFind' and end with digits. 
    node->enumerateChildren("nameToFind[[:digit:]]+", 
        [](Node* node) -> bool { ... return false; // return true to stop at first match });
    //Find nodes whose name is 'nameToFind' and end with digits recursively. 
    node->enumerateChildren("nameToFind[[:digit:]]+", 
        [](Node* node) -> bool { ... return false; // return true to stop at first match });

    通配符匹配举例:
        //搜索语法选项
        '//' : 递归访问所有子节点,   只能放在搜索串的开头位置
        '..' : 搜索移至node的父节点, 只能放在某个字符串的结束位置
        '/'  : 搜索移至node的子节点, 可以放在任何位置,除了搜索串的开头位置

        //代码举例
        enumerateChildren("//MyName", ...)     : 递归访问Node的所有子节点。查找匹配 "MyName" 的子节点
        enumerateChildren("[[:alnum:]]+", ...) : 在Node的儿子节点中查找。  所有项
        enumerateChildren("A[[:digit:]]", ...) : 在Node的儿子节点中查找。  名字为 "A0","A1",...,"A9" 的子节点
        enumerateChildren("Abby/Normal", ...)  : 在Node的孙子节点中查找。  其节点为"Normal",且父节点为"Abby"
        enumerateChildren("//Abby/Normal", ...): 递归访问Node的所有子节点。其节点为"Normal",且父节点为"Abby"

7、渲染顺序
    在2.x中是使用Zorder来控制节点渲染的先后顺序的。而在3.x中渲染的顺序则是由两个因素决定。
        > 全局Z顺序:GlobalZOrder。所有节点之间对比。
        > 局部Z顺序:LocalZOrder。 兄弟节点之间对比。
    且Z顺序越小,最先渲染。

    7.1、全局Z顺序
        > 定义渲染节点的顺序,拥有全局Z顺序越小的节点,最先渲染。
        > 假设:两个或者更多的节点拥有相同的全局Z顺序,那么渲染顺序无法保证。唯一的例外是如果节点的全局Z顺序为零,那么场景图顺序是可以使用的。
        > 默认的,所有的节点全局Z顺序都是零。这就是说,默认使用场景图顺序来渲染节点。
        > 全局Z顺序是非常有用的当你需要渲染节点按照不同的顺序而不是场景图顺序。
        > 局限性: 全局Z顺序不能够被拥有继承“SpriteBatchNode”的节点使用。
        virtual void setGlobalZOrder(float globalZOrder);
        virtual float getGlobalZOrder() const;

    7.2、局部Z顺序
    > LocalZOrder是“key”(关键)来分辨节点和它兄弟节点的相关性。
    > 父节点将会通过LocalZOrder的值来分辨所有的子节点。如果两个节点有同样的LocalZOrder,那么先加入子节点数组的节点将会比后加入的节点先得到渲染,
      那么先加入的节点会被后加入的节点遮盖[update 20140927]。
    > 同样的,场景图使用“In-Order(按顺序)”遍历数算法来遍历。并且拥有小于0的LocalZOrder的值的节点是“left”子树(左子树) 
      所以拥有大于0的LocalZOrder的值得节点是“right”子树(右子树)。
       //设置这个节点的局部Z顺序((相对于兄弟节点))
      virtual void setLocalZOrder(int localZOrder);
      virtual int getLocalZOrder() const;



8、坐标转换

坐标分为两种坐标:
        > 世界坐标:就是相对节点的世界坐标。
        > 局部坐标:就是相对节点的坐标。

    8.1
    /**
     * 坐标转换convertTo
     *     WorldSpace :   世界坐标
     *     NodeSpace  :  局部坐标
     *
     */
        //把世界坐标, 转换到当前节点的本地坐标系中
        //基于Anchor Point, 把基于当前节点的本地坐标系下的坐标, 转换到世界坐标系中
        Vec2 convertToNodeSpace(const Vec2& worldPoint) const;
        Vec2 convertToNodeSpaceAR(const Vec2& worldPoint) const;


        //把基于当前节点的本地坐标系下的坐标, 转换到世界坐标系中
        //基于Anchor Point. 把世界坐标, 转换到当前节点的本地坐标系中
        Vec2 convertToWorldSpace(const Vec2& nodePoint) const;
        Vec2 convertToWorldSpaceAR(const Vec2& nodePoint) const;


        //把触点坐标, 转换到当前节点的本地坐标系中
        Vec2 convertTouchToNodeSpace(Touch * touch) const;
        Vec2 convertTouchToNodeSpaceAR(Touch * touch) const;
    8.2
        > node1坐标为:(20,40), 锚点(0,0)。
        > node2坐标为:(-5,-20),锚点(1,1)。
        > Vec2 point1 = node1->convertToNodeSpace(node2->getPosition());
            结果为:(-25,-60)。(即:相对node1节点坐标位置,的,相对坐标)
            分析  :node2相对node1节点的坐标为:(-5,-20) - (20,40) 。
                    也就是说:node2相对node1的坐标位置。
        > Vec2 point2 = node1->convertToWorldSpace(node2->getPosition());
            结果为:(15,20)。(即:相对node1的世界坐标系统下,的,世界坐标)
            分析  :将node1作为参照,转换到世界坐标为:(20,40) + (-5,-20) 。
                    也就是说:node2的坐标现在被看做是相对node1的坐标位置,然后转换到世界坐标。
    8.3
        判断触摸点是否触摸到某个精灵图片sp的内部区域
        bool HelloWorld::onTouchBegan(Touch *touch, Event *unused_event)
        {
            //将触点坐标, 转换为相对节点sp的, 相对坐标
            Vec2 point = sp->convertTouchToNodeSpace(touch);

            //构造sp的尺寸矩形
            Size size = sp->getContentSize();
            Rect rect = Rect(0, 0, size.width, size.height);

            //判断触点是否触摸到sp内部
            if (rect.containsPoint(point)) {
                CCLog("点中");
                return true;
            }    
            return false;
        }


--------------------------------Director

    导演Director
    就和现实中的导演一样,这里的导演也是起到指导的作用的。导演在这里负责的就是让不同的场景切换,控制整个游戏的流程,包括开始,继续,暂停等。以及设置、获取系统信息,比如调整OpenGL相关的设置,获取屏幕的大小等。
    和Scene、Layer、Sprite等不同的是,导演类Director是直接继承Ref类的,而不是Node类。

        //
    /** 
        导演类Director主要是用来:
            - 创建一个主窗口
            - 管理场景Scene
        Director 也负责以下: 
            - 初始化 OpenGL 内容
            - 设置 OpenGL 像素格式 (默认值时 RGB565) 
            - 设置 OpenGL 缓存大小 (默认是 0-bit) 
            - 设置 投影 (默认是一个 3D) 
            - 设置 方向 (默认是竖屏Portrait)

        Director 是一个单例对象, 标准的调用方法是:
            - Director::getInstance()->methodName(); 
    */

    class CC_DLL Director : public Ref
    {
    /**
     * 获取单例对象
     */
        //获取全局唯一的Director实例 , 替代 sharedDirector
        //使用方法:Director::getInstance()->replaceScene(scene);
        static Director* getInstance();


    /**
     * 场景管理相关
     *     - runWithScene
     *     - pushScene
     *     - popScene , popToRootScene , popToSceneStackLevel
     *     - replaceScene
     *     - pause , resume , end
     *     - getRunningScene , isPaused
     */
        //指定进入Director的主循环运行的场景.
        //ps:仅在运行第一个场景时调用,如果已经存在运行中的场景,不能调用本方法.
        //本方法调用后将调用pushScene方法,然后调用startAnimation.
        void runWithScene(Scene *scene);

        //将运行中的场景暂停,并push到场景堆栈中,运行新的场景.
        void pushScene(Scene *scene);

        //从场景堆栈中pop出一个场景,替换现在正运行的场景,而运行中的场景将被删除.
        void popScene();

        //从场景堆栈中pop出所有场景,最后一个栈底的场景将替换现在正运行的场景,而运行中的场景将被删除.
        void popToRootScene();

        //弹出从队列中的所有场景,直到它到达 level.
        //如果 level 是 0,它将结束 director. 
        //如果 level 是 1, 从队列中弹出所有的场景,直到只有根场景在队列中. 
        //如果 level <= 当前的堆栈水平,它不会做任何事情。
       void popToSceneStackLevel(int level);

        //使用新场景替换当前场景,而运行中的场景将被删除.
        //PS:旧场景不压入堆栈,而是直接删除.
        void replaceScene(Scene *scene);

        void pause(void);                //暂停场景
        void resume(void);               //恢复被暂停的场景
        void end(void);                  //终止执行,释放运行中的场景. GL view需手动移除.

        inline Scene* getRunningScene(); //获取当前运行的场景
        inline bool isPaused();          //Director 是否被暂停


    /**
     * 刷新帧数FPS相关
     *     - setAnimationInterval
     *     - setDisplayStats
     *     - getSecondsPerFrame , getTotalFrames
     */
        //设置程序的FPS值. 即刷新频率,相连两帧的时间间隔.
        //如dValue = 1.0/60.0 表示每秒60帧.
        virtual void setAnimationInterval(double interval) = 0;
        inline double getAnimationInterval();

        //是否在左下角显示 FPS
        inline void setDisplayStats(bool displayStats);
        inline bool isDisplayStats();

        //获取每秒执行帧数
        inline float getSecondsPerFrame()

        //从 Director 开机后,总共已经渲染了多少帧
        inline unsigned int getTotalFrames();


    /**
     * OpenGL图形渲染相关
     *     - setOpenGLView
     *     - setProjection
     *     - getTextureCache
     *     - setViewport , setGLDefaultValues , setAlphaBlending , setDepthTest
     */
        //获取渲染所有东西的GLView
        void setOpenGLView(GLView *openGLView);
        inline GLView* getOpenGLView();

        //设置一个 OpenGL 投影
        //  Projection::_2D           : 设定的二维投影(正投影)
        //  Projection::_3D           : 使用 fovy=60, znear=0.5f and zfar=1500 设置一个3D投影
        //  Projection::CUSTOM        : 投影委托里面它调用 "updateProjection".
        //  Projection::DEFAULT = _3D : 默认投影是 3D 投影
        void setProjection(Projection projection);
        inline Projection getProjection();

        TextureCache* getTextureCache() const; //获取纹理缓冲
        void setViewport();                    //设置glViewport
        void setGLDefaultValues();             //设置 OpenGL 默认值
        void setAlphaBlending(bool on);        //启用/禁用 OpenGL alpha 混合
        void setDepthTest(bool on);            //启用/禁用 OpenGL 深度测试


    /**
     * OpenGL View视图相关
     *     - getWinSize
     *     - getVisibleSize , getVisibleOrigin
     *     - convertToGL , convertToUI
     */
        //类似手机屏幕的大小
        const Size& getWinSize() const;      //获取OpenGL view大小,单位点.
        Size getWinSizeInPixels() const;     //获取OpenGL view大小,单位像素.

        //类似程序的游戏区域
        //如果不调用GLView::setDesignResolutionSize(), 值等于getWinSize
        Size getVisibleSize() const;         //获取OpenGL View可视区域大小,单位点.
        Vec2 getVisibleOrigin() const;       //获取可视区域的原点坐标.

        //将UIKit坐标与OpenGL坐标的相互转换
        //UIKit坐标 :原点在屏幕的左上角. 从左到右,从上到下.
        //OpenGL坐标:原点在屏幕的左下角. 从左到右,从下到上.
        Vec2 convertToGL(const Vec2& point); //转为GL坐标
        Vec2 convertToUI(const Vec2& point); //转为UI坐标


    /**
     * 其他操作
     *     - purgeCachedData
     *     - getRenderer
     *     - setDefaultValues
     *     - setScheduler , setActionManager , setEventDispatcher
     */
        void purgeCachedData();                               //移除所有 cocos2d 缓存数据.
        Renderer* getRenderer() const;                        //获取渲染器(Renderer). v3.0
        void setDefaultValues();                              //设置配置信息的默认值

        void setScheduler(Scheduler* scheduler);              //设置与director关联的调度器
        void setActionManager(ActionManager* actionManager);  //设置与director关联的ActionManager
        void setEventDispatcher(EventDispatcher* dispatcher); //设置与director关联的EventDispatcher. v3.0
        Scheduler* getScheduler() const;
        ActionManager* getActionManager() const;
        EventDispatcher* getEventDispatcher() const;
    }
    //
    //



精灵Sprite
    精灵说简单一点,其实就是一个2D的图片。并赋予图片各种属性以及特性。如大小、颜色、放缩、旋转、动作等。精灵一般都是放在布景层(Layer)上面的,
    即一个布景层(Layer)应当有许多的精灵存在。精灵可以用来当做背景、人物、鸟、白云等内容。
    Sprite不仅继承了Node,还继承了纹理协议接口TextureProtocol。
    TextureProtocol纹理协议接口主要是负责纹理图片的管理。
    注意:精灵的锚点默认为(0.5,0.5),即中心点。

    //
/**
    Sprite定义为二维图像, 可以通过一个图像或一个图像的矩形裁剪部分创建Sprite.

        - 为了优化Sprite渲染,请遵循以下最佳用法:
            - 所有Sprite放入同一个SpriteSheet
            - 所有Sprite使用相同的渲染混合函数(BlendFunc)
            - 使得渲染器(Renderer)自动批量处理("batch")Sprite (将会在一次OpenGL调用内绘制完成)

        - 为了获得额外5%~10的渲染优化效果,你可以把Sprite作为子节点加入到SpriteBatchNode中, 
        - 但这么做有以下限制:
            - Alias/Antialias属性属于SpriteBatchNode,不能单独设置Sprite的Alias属性。
            - 渲染混合函数(BlendFunc)属于SpriteBatchNode,不能单独设置Sprite的渲染混合函数(BlendFunc)。
            - 不支持ParallaxNode,不过可以使用代理("proxy")Sprite模拟实现。

        - Sprite的子节点只能是其它Sprite(或Sprite的子类)
        - Sprite的默认锚点(anchorPoint)为(0.5, 0.5)。
 */

    class CC_DLL Sprite : public Node, public TextureProtocol
    {
    /**
     * 创建方法
     *     - create
     *     - createWithTexture
     *     - createWithSpriteFrame
     */
        static Sprite* create();                                                                    //默认创建空精灵对象
        static Sprite* create(const std::string& filename);                                         //图片文件(*.png)
        static Sprite* create(const std::string& filename, const Rect& rect);                       //截取图片文件中某一区域图片
        static Sprite* createWithTexture(Texture2D *texture);                                       //纹理图片
        static Sprite* createWithTexture(Texture2D *texture, const Rect& rect, bool rotated=false); //截取纹理图片中某一区域图片,是否旋转
        static Sprite* createWithSpriteFrame(SpriteFrame *spriteFrame);                             //精灵帧. 精灵帧一般从plist中读取的
        static Sprite* createWithSpriteFrameName(const std::string& spriteFrameName);               //精灵帧的名字



    /**
     * 批处理节点BatchNode
     *     - updateTransform
     *     - setBatchNode
     *     - getBatchNode
     */
        virtual void updateTransform(void);                          //更新四个值:position(x,y), rotation, scale
        virtual void setBatchNode(SpriteBatchNode *spriteBatchNode); //设置批节点,不推荐手工调用
        virtual SpriteBatchNode* getBatchNode(void);                 //如果精灵是由批节点渲染,则返回批节点


    /**
     * 纹理Texture
     *     - setTexture
     *     - setTextureRect
     */
        //设置精灵的纹理图片.
        virtual void setTexture(const std::string &filename ); //调用setTextureRect设置Sprite尺寸
        virtual void setTexture(Texture2D *texture) override;  //纹理的矩形尺寸大小不会改变
        virtual Texture2D* getTexture() const override;

        //设置Sprite纹理(texture)的Rect尺寸(rect)、是否旋转(rotated)、裁剪尺寸(untrimmedSize)。 
        //调用此方法会修改纹理(texture)的坐标和顶点位置
        virtual void setTextureRect(const Rect& rect, bool rotated = false, const Size& untrimmedSize = rect.size); 


    /**
     * 精灵帧SpriteFrames & 动画Animation
     *     - setSpriteFrame
     *     - isFrameDisplayed
     *     - getSpriteFrame
     *     - setDisplayFrameWithAnimationName
     */   
        //设置新的显示精灵帧. 替代setDisplayFrame
        virtual void setSpriteFrame(const std::string &spriteFrameName);
        virtual void setSpriteFrame(SpriteFrame* newFrame);

        //返回精灵帧是否正在显示
        virtual bool isFrameDisplayed(SpriteFrame *pFrame) const;

        //返回当前显示的精灵帧. 替代 getDisplayFrame
        virtual SpriteFrame* getSpriteFrame() const;

        //通过动画帧的第frameIndex那一帧来设置显示精灵帧
        //动画帧是从CCAnimationCache中读取的
        virtual void setDisplayFrameWithAnimationName(const std::string& animationName, ssize_t frameIndex);


    /**
     * 精灵属性相关
     *     - setDirty
     *     - getQuad
     *     - isTextureRectRotated
     *     - setAtlasIndex
     *     - getTextureRect
     *     - setTextureAtlas
     *     - getOffsetPosition
     *     - setFlippedX , setFlippedY
     */
        //设置Sprite在纹理集Atlas中是否需要更新
        virtual void setDirty(bool dirty);
        virtual bool isDirty(void) const;

        //返回四个值的信息:坐标(x,y),顶点,颜色
        inline V3F_C4B_T2F_Quad getQuad(void) const;

        //判断纹理是否被旋转
        inline bool isTextureRectRotated(void) const;

        //设置纹理集(TextureAtlas)的当前使用索引
        //警告: 除非你了解调用此方法的影响,否则不要改变此值
        inline void setAtlasIndex(ssize_t atlasIndex);
        inline ssize_t getAtlasIndex(void) const;

        //返回Sprite的Rect区域信息,单位点
        inline const Rect& getTextureRect(void);

        //如果采用批渲染,设置纹理地图集
        inline void setTextureAtlas(TextureAtlas *pobTextureAtlas);
        inline TextureAtlas* getTextureAtlas(void);

        //获取偏移值
        inline const Vec2& getOffsetPosition(void) const;

        //设置是否翻转。
        void setFlippedX(bool flippedX); //设置Sprite是否水平翻转。替代 setFlipX
        bool isFlippedX(void) const;
        void setFlippedY(bool flippedY); //设置Sprite是否垂直翻转。替代 setFlipY
        bool isFlippedY(void) const;


    /**
     * 继承于TextureProtocol
     *     - setBlendFunc
     */
        //设置颜色混合模式
        inline void setBlendFunc(const BlendFunc &blendFunc) override;
        inline const BlendFunc& getBlendFunc() const override;


    /**
     * 继承于Node
     *     - Scale , Position , Skew , AnchorPoint , Visible
     *     - addChild , removeChild , reorderChild , sortAllChildren
     *     - draw , setOpacityModifyRGB , isOpacityModifyRGB
     */
        virtual void setScaleX(float scaleX) override;
        virtual void setScaleY(float scaleY) override;
        virtual void setScale(float scaleX, float scaleY) override;
        virtual void setScale(float scale) override;

        virtual void setPosition(const Vec2& pos) override;
        virtual void setPosition(float x, float y) override;
        virtual void setRotation(float rotation) override;
        virtual void setPositionZ(float positionZ) override;

        virtual void setSkewX(float sx) override;
        virtual void setSkewY(float sy) override;
        virtual void setRotationSkewX(float rotationX) override;
        virtual void setRotationSkewY(float rotationY) override;

        virtual void setAnchorPoint(const Vec2& anchor) override;
        virtual void ignoreAnchorPointForPosition(bool value) override;

        virtual void setVisible(bool bVisible) override;

        virtual void addChild(Node *child, int zOrder, int tag) override;
        virtual void addChild(Node *child, int zOrder, const std::string &name) override;
        virtual void removeChild(Node* child, bool cleanup) override;
        virtual void removeAllChildrenWithCleanup(bool cleanup) override;
        virtual void reorderChild(Node *child, int zOrder) override;
        virtual void sortAllChildren() override;

        virtual void draw(Renderer *renderer, const Mat4 &transform, uint32_t flags) override;
        virtual void setOpacityModifyRGB(bool modify) override;
        virtual bool isOpacityModifyRGB(void) const override;
    };
    //
2012-05-08 11:09:09 wzq9706 阅读数 447

修发支持:横屏/竖屏

UIInterfaceOrientationIsLandscape(interfaceOrientation)

支持高清模式,去掉以下的注释

// // Enables High Res mode (Retina Display) on iPhone 4 and maintains low res on all other devices
// if( ! [director enableRetinaDisplay:YES] )
// CCLOG(@"Retina Display Not supported");


跟据给定的函数名称得到SEL:

NSSelectorFromString


概率

if(arc4random() % 100 > 50){

    // TODO

} else {

    // TODO

}


2018-03-09 11:23:43 a_aibushishuo 阅读数 867

本文来自http://blog.csdn.net/runaying ,引用必须注明出处!

COcos2d-X 中文API

温馨提醒:使用二维码扫描软件,就可以在手机上访问我的博客啦!另外大家可以访问另一个博客 http://blog.csdn.net/u012972188

写在前面:千呼万唤始出来,我想大家一定对这篇文章期待已久了吧!今天小编,就把前面发表的文档整理了一下,方便大家在使用的时候快速索引,大家如果觉得还不错就赞一下!或许你觉得鼠标滚轮没滚动几下就到结尾了,可这些文档都是小编辛辛苦苦整理出来的。小编都记不清了,在这些稳定整理的过程中,小编究竟失眠了多少个日日夜夜。还是那句话大家觉得不错的话就赞一下,您的支持是小编不懈的动力,反正动动鼠标也不用花费你太多的时间。有关 CocoStudio 的文档大家可以点击这里 CocoStudio,最后祝大家学习愉快!

Box2D

 1.cocos2d-x节点(Box2D.h)API

Collision

 1.cocos2d-x节点(b2BroadPhase.h)API
Box2d中broad-phase用于计算pairs【相交记录】,执行容量查询和光线投射。主要还是调用动态树进行数据方面的管理。
 2.cocos2d-x节点(b2Collision.h)API
用于计算接触点,距离查询和TOI查询的结构和功能
 3.cocos2d-x节点(b2Distance.h)API
在Box2d最终调用b2Ditance方法来求得两个形状最近点之间的距离,主要用于形状的碰撞检测。使用此方法需要将两个形状转换成一个b2DistanceProxy。为了提供高内部调用的效率,在外部开始调用b2Distance方法时,内部做了一个缓冲,用来提高计算距离的效率。
 4.cocos2d-x节点(b2DynamicTree.h)API
//用来提高系统的碰撞检测的速度。
//它主要是通过用户数据来操作轴对齐包围盒(axis-alignedbounding boxes,AABBs)来完成树的各种操作。同时动态树继承自AABB树,树上的每一个节点都有两个孩子。叶节点是一个单独的用户AABB。即便是惰性输入,整个数也可以使用旋转保持平衡。
 5.cocos2d-x节点(b2TimeOfImpact.h)API
b2TimeOfImpact来确定两个形状运动时的撞击时间(TOI)。同时b2TimeOfImpact也主要防止两个形状快速移动时可能在一个时间步内彼此穿越对方的情况,也就是我们经常所说的隧道效应。

Shapes

 1.cocos2d-x节点(b2ChainShape.h)API
  链形状,链形状是一个自由形式的序列的线段,链具有双面碰撞,故你可以使用内部或者外部碰撞。
// 链形状提供了一种高效的方法来同时连接多条边,为你的游戏创造静态的游戏世界。链形状同时提供了创建链和环的方法,
// 以便为大家提供想要的形状。链形状不能自身交叉,那样它有可能不能正常的工作。在Box2d中,链形状是通过b2ChainShape实现的。
 2.cocos2d-x节点(b2CircleShape.h)API
圆形不能是空心的
 3.cocos2d-x节点(b2EdgeShape.h)API
一个线段(边缘)形状。这些可以连接在链或者环其他边缘形状。
 4.cocos2d-x节点(b2PolygonShape.h)API
我们这里说的多边形是凸多边形,所谓凸多边形就是一条直线与该类多边形相交交点最多不超过两个。同时还是实心的,不能是空心。多边形的顶点范围应该在[3,b2_maxPolygonVertices]内,box2d中定义为8个,你也可以在公共模块的b2Settings.h文件中修改它的值,不过一般不建议那么做。
 5.cocos2d-x节点(b2Shape.h)API
// shape中基本上都是虚函数,是没有实现的。shape中定义了以下几个函数:
// 1、克隆一个形状
// 2、获取孩子形状类型
// 3、获取形状的孩子元素的数量
// 4、投射一束光到一个孩子形状中
// 5、计算一个孩子形状的轴对齐包围盒(aabb)
// 7、测试形状中点的密封性。
// 6、计算形状的质量

Common

 1.cocos2d-x节点(b2BlockAllocator.h)API
b2BlockAllocator进行内存管理,使得分配和使内存变得更加高效、快速。内存管理之SOA的实现
 2.cocos2d-x节点(b2Draw.h)API
调试辅助类主要辅助box2d中物体的调试,通过绘制不同的调试辅助的形状,来监控并改正物体行为的正确性
 3.cocos2d-x节点(b2GrowableStack.h)API
可增长的协议栈,和出栈入栈操作
 4.cocos2d-x节点(b2Math.h)API
//Box2d的公共模块中,包含的一个小巧而简便的向量矩阵的数学库。
//主要由以下内容:
//a)、向量,包括二维列向量和三维列向量
//b)、矩阵,包括2X2矩阵和3X3矩阵
//c)、旋度、扫描、和变换的实现
//d)、其他部分的实现
 5.cocos2d-x节点(b2Settings.h)API
设置中主要定义了宏、常量、和一些辅助的公共函数。
 6.cocos2d-x节点(b2StackAllocator.h)API
B2StackAllocator主要是为了运行一个步长时满足box2d需要的临时内存空间,作为栈分配器来防止单步堆分配。
 7.cocos2d-x节点(b2Timer.h)API

计时器主要是用来计算一段时间内的时间,通过对某个函数执行计时,可用来查看相关函数的效率和性能。

Dynamics

 1.cocos2d-x节点(b2Body.h)API
模拟现实世界中的静态物体,动态物体,匀速直线运动的物体,并返回它们的各种状态
 2.cocos2d-x节点(b2ContactManager.h)API
b2Contact对象包含了碰撞的信息。从对象中可以得知哪两个定制器发生了碰撞,以及碰撞的位置和碰撞之后的反作用方向。在Box2D中有两个方法可以获取b2Contact对象,一个是遍历接触(contacts)链表每一个物体,另外一种方法是用接触监听器(contact listener)。
 3.cocos2d-x节点(b2Fixture.h)API
对物理世界中的对象进行详细定制例如: 密度,摩擦细数,恢复系数、过滤,投射光线
 4.cocos2d-x节点(b2Island.h)API
添加 body,content、joints 令物体失重
定义了一些数据结构,位置、向量、分析数据等
 6.cocos2d-x节点(b2World.h)API
/// world 类管理所有的物理实体,动态仿真,异步查询
/// World 也包含也包含高效的内存管理设施。
 7.cocos2d-x节点(b2WorldCallbacks.h)API
/// 当 body 被破坏时,与他们关联的 joints(接头)、 fixture(定制器)也会被破坏
//实现这个监听,这样你就可以抵消这个 joints(接头)和形状的引用

Contacts

其它的只有创建和计算方法,你可以自己查看
 1.cocos2d-x节点(b2Contact.h)API
//这个类管理两个形状之间的接触。
/// broad-phase (除了filtered(过滤)) 里面每个AABB 存在的接触重叠.
/// 因此,接触的对象可能存在,有没有接触点的情况。

Joints

 1.cocos2d-x节点(b2DistanceJoint.h)API
//距离joints(接头)的定义,用来约束两个 body 上的两个点,以保证彼此保持在一个固定的距离
 2.cocos2d-x节点(b2FrictionJoint.h)API
//摩擦joints(接头)的定义.可以设置最大摩擦力,最大力矩
 3.cocos2d-x节点(b2GearJoint.h)API
//齿轮joints(接头),这个定义需要两个现有的 旋转/移动 joints(接头)
 4.cocos2d-x节点(b2Joint.h)API
// joints(接头)的基类.joints(接头)用来约束两个不同类型的 body .
 5.cocos2d-x节点(b2MouseJoint.h)API
/// 这是一个使用最大力的软约束,这个约束允许在不施加巨大力的情况下伸展
 6.cocos2d-x节点(b2PrismaticJoint.h)API
//一个移动的joints(接头). 这个 joints(接头)沿 body 上面的一个轴运动
 7.cocos2d-x节点(b2PulleyJoint.h)API
//pulley(带轮) joints(接头)用于使用 两个固定的环绕点,连接两个 bodies
 8.cocos2d-x节点(CCClippingNode.h)API
// Revolute(旋转)joints(接头)需要一个共同点来约束它们的 bodies,它们可以围绕这个点自由旋转
 9.cocos2d-x节点(b2RopeJoint.h)API
//Rope(绳) joints(接头)两个 bodies 之间的最大距离,它没有其他作用。
10.cocos2d-x节点(b2WeldJoint.h)API
/// Weld(焊接)joints(接头)可以把两个 bodies 粘贴在一起. Weld(焊接)joints(接头)可能有些歪曲
/// 因为 island 约束求解器是近似的
11.cocos2d-x节点(b2WheelJoint.h)API
/// 一个Wheel(车轮)joints(接头)这个 joints(接头)提供了两个自由度:沿固定在 bodyA上的轴和平面旋转

Rope

 1.cocos2d-x节点(b2Rope.h)API
//绳索

cocos2dx

CCCamera.h 简单来将就是视角(比如你看到了一栋房子,你站在不同的角度看到的房子是不一样的,他就相当于你的眼睛所处的位置,他对于你创建 3d 效果是很有用的)
CCConfiguration可以用来存储配置信息,并通过 键/值 的对应关系来获取
导演类,创建一个主窗口来管理所有的场景,(通常一个游戏里面只有一个导演)
    3.1获取当前正在运行的场景、获取每秒帧数、是否要切换场景、获取视图尺寸、切换/停止 场景、清楚缓存、设置配置信息
4.COcos2d-X 节点(ccFPSImages)API
没有实质性的内容,仅仅定义了两个变量而已,这里就不再列出了
这是一个轻量级的定时期,但是,你不可以使用 timer 来代替。它是 timer 的扩展,有许多地方比 timer 更方便

action

1.cocos2d-X 节点(CCAction.h)API

动作必须依赖于 CCNode 的子类才能发挥作用,

 1. 1.CCAction 的子类 FiniteTimeAction 可以做瞬时动作和延时动作
    1.2.CCAction 的子类 Speed 可以模拟慢动作,快进动作
    1.3.CCAction 的子类 Follow Action 执行往后紧随其后的节点cocos2d-x节点(CCActionCamera.h)API
Camera 助手类,设置camera 在球面坐标系中的运动范围

 2.cocos2d-x节点(CCActionCamera.h)API

Camera 助手类,设置camera在球面坐标系中的运动范围
 3.cocos2d-x节点(CCActionCatmullRom.h)API

CatmullRom(卡特莫尔罗)action
 4.cocos2d-x节点(CCActionEase.h)API

放缓(Easing)action 相关的类 
 5.cocos2d-x节点(CCActionGrid.h)API

各种网格 action 效果
 6.cocos2d-x节点(CCActionGrid3D.h)API

透视、震动、水波、波纹....3D效果
 7.cocos2d-x节点(CCActionInstant.h)API

action 的显示、隐藏、翻转、定位
 8.cocos2d-x节点(CCActionInterval.h)API

有时间间隔的 action,使用动画、闪烁、重复次数、按次序 创建 action,贝塞尔曲线移动
 9.cocos2d-X 节点(CCActionManager.h)API

ActionManager 是一个管理所有 actions 的单例.
 正常情况下你不直接使用这个单例,99% 的情况是你希望使用这个节点的接口,
    1.但是有一些情况你或许需要使用这个单例
    你希望你的 action 运行在不同的不同的节点
    你希望 pause / resume  actions



10.cocos2d-x节点(CCActionPageTurn3D)API

在屏幕的右下角模拟翻页
11.cocos2d-x节点(CCActionProgressTimer.h)API

进度条
12.cocos2d-x节点(CCActionTiledGrid.h)API

拆分、淡出、波形、震动 action
13.cocos2d-x节点(CCActionTween.h)API

补间动画

base_nodes

AtlasNode 是 Node 的子类,实现了 RGBAProtocol 、 TextureProtocol 协议
节点的所有功能都有效,再加上以下功能:
- opacity and RGB colors        //不透明度和RGB颜色
从 GL的缓冲区加载数据
这个类是一个基础类,最常用的 Node 有: Scene, Layer, Sprite, Menu
    1.1图形getter、setter 属性 (z 顺序、OpenGL 顶点、位置、缩放、旋转、倾斜角、锚点、尺寸、是否可见......)
    1.2children 和 parent 之间的关系(添加/删除 children、为children 添加识别码、获取 children 总数、获取 children 的parent......)
    1.3设置对象效果、为对象设置 schedule、各种坐标的相互转换、添加移除组件

cocoa

 1.cocos2d-x节点(CCAffineTransform.h)API
仿射变换方法的定义
 2.cocos2d-x节点(CCArray.h)API
这个类非常常用,可以存储任何对象,它可以模拟 C 的指针,
 3.cocos2d-x节点(CCAutoreleasePool.h)API
如果你希望使用自动释放池,那么你就可以参考他了
 4.cocos2d-x节点(CCBool.h)API
boolean 简单的覆盖了一些方法没有太多内容
 5.cocos2d-x节点(CCData.h)API
Data 简单的覆盖了一些方法没有太多内容
 6.cocos2d-x节点(CCDataVisitor.h)API
根据你的多态对象类型帮助你执行动作
7.cocos2d-X 节点(CCDictionary)API
使用它可以保存一些数据,他和 java 里面的 hashmap 对象类似,通过  键/值 对来存储索引对象,它的关键字(key) 可以是 String/Integer 类型
 8.cocos2d-x节点(CCDouble.h)API
double 简单的覆盖了一些方法没有太多内容
 9.cocos2d-x节点(CCFloat.h)API
float 简单的覆盖了一些方法没有太多内容
10.cocos2d-x节点(CCGeometry.h)API
这个类主要是讲点和点之间的关系、线和线之间的关系、点和坐标轴之间的关系,这个类涉及了许多数学的知识,另外有一个类似的类,参考(///cocos2d-x-3.0alpha0/cocos2dx/include/CCDeprecated.h)
11.cocos2d-x节点(CCInteger.h)API
integer 简单的覆盖了一些方法没有太多内容
12.cocos2d-x节点(CCNS.h)API
返回给定字符串的结构样式
13.cocos2d-x节点(CCObject.h)API
对象引用计数器的使用和比较
14.cocos2d-x节点( CCSet.h)API
set 的基本使用
15.cocos2d-x节点(CCString.h)API
CCString 很强大,各种数据类型的转换(把字符串转化为 double、float、integer......)。字符串的分割和比较

draw_nodes

1.cocos2d-x节点(CCDrawingPrimitives.h)API
绘制基本图元(矩形,多边形,点线)
2.cocos2d-x节点(CCDrawNode.h)API
// 在同一个批处理节点里面绘制 点、线段、多边形

effects

1.cocos2d-x节点(CCGrabber.h)API
FBO 类抓取屏幕上的内容 
2.cocos2d-x节点(CCGrid.h)API
基础类,Grid 的各种状态

event_dispatcher

1.cocos2d-x节点(CCEventAcceleration.h)API
促进事件
2.cocos2d-x节点(CCEventCustom.h)API
简单的覆盖了一些方法没有太多内容
3.cocos2d-x节点(CCEventKeyboard.h)API
键盘事件
4.cocos2d-x节点(CCEventListenerAcceleration.h)API
监听加速
5.cocos2d-x节点(CCEventListenerCustom.h)API
自定义监听事件
6.cocos2d-x节点(CCEventListenerKeyboard.h)API
键盘事件监听
7.cocos2d-x节点(CCEventListenerTouch.h)API
触摸事件监听
8.cocos2d-x节点(CCEventTouch.h)API
触摸事件
9.cocos2d-x节点(CCEvent.h)API
一个基类,事件状态的判断
10.cocos2d-x节点(CCEventDispatcher.h)API
事件调度
11.cocos2d-x节点(CCEventListener.h)API
监听器的基类
12.cocos2d-X 节点(CCTouch.h)API
一般把触点信息放入 CCTouch 类里面,CCTouch 类封装了触摸点的信息,包括触摸点的横纵坐标值,

include

1.cocos2d-x节点(ccConfig.h)API
//一些配置项可以很方便的调试
2.cocos2d-x节点(CCEventType.h)API
定义应用进入 前台/后台 的通知类型
3.cocos2d-x节点(ccMacros.h)API
一些预处理宏
4.cocos2d-x节点(CCProtocols.h)API
投影协议、标签接口、texture协议、RGBA协议、混合协议;涉及了透明度,透明度/颜色 在 children 和parent 之间的传递
5.cocos2d-x节点(ccTypes.h)API
字体属性、texture属性、RGB组成......
6.cocos2d-x节点(cocos2d.h)API
cocosd 所包含的类文件
7.cocos2d-x节点(CCDeprecated.h)API
这个类主要是讲点和点之间的关系、线和线之间的关系,另外有一个相似的类,(\cocos2d-x-3.0alpha0\cocos2dx\cocoa\CCGeometry.h)

label_nodes

NewLabel_Experimental
新的 label 实验,没有太多的注释,如果有需要自己阅读api
1.cocos2d-X 节点(CCLabelAtlas.h)API
LabelAtlas 是 AtlasNode 的子类.
他的速度很快可以替代标签.
LabelAtlas 相对于 Label:
- LabelAtlas 比 Label 要快
- LabelAtlas "characters" 有一个固定的宽度和高度       //字符
- LabelAtlas "characters" 可以是任何你想要的,因为它们是从一个文件演变过来的
2.cocos2d-X 节点(CCLabelBMFont.h)API
CCLabelBMFont.h 是文字渲染标签类,CCLabelBMFont 类中的每个字都是一个 Sprite 类,这意味着每个字都可以自己的旋转等其它动作
3.cocos2d-X 节点(CCLabelTTF.h)API
abelTTF 是 TextureNode 的子类,它可以渲染 labels 的标签(label上面显示的文字)。 TextureNode 的所有功能在 LabelTTF 里面都是有效的。 LabelTTF 对象非常缓慢. 可以考虑使用 LabelAtlas 、 LabelBMFont 代替.

layers_scenes_transitions_nodes

1.cocos2d-x节点(CCLayer.h)API

 Layer 是 Node 的子类,它实现 TouchEventsDelegate 协议.节点的所有功能都有效,加上以下新的特点:它可以接收手机的触摸、它可以接收输入加速度

    1.1启用/禁用 触摸事件/传感器事件/小键盘事件
    1.2 LayerRGBA、LayerColor、LayerGradient、MultipleLayer 是 Layer 的子类,它们扩展了 layer 拥有layer 的所有功能

2.cocos2d-x节点(CCScene.h)API
把 Scene 作为所有 node 的parent 是一个很好的做法,基本的 Scene 方法
3.cocos2d-x节点(CCTransition.h)API
各种场景切换过渡效果
4.cocos2d-x节点(CCTransitionPageTurn.h)API
scene 过渡
5.cocos2d-x节点(CCTransitionProgress.h)API
放射状过渡到下一个场景

menu_nodes

 1.cocos2d-x节点(CCMenu.h)API
创建菜单,添加 items、设置 items 的对其方式
 2.cocos2d-x节点(CCMenuItem.h)API
为菜单项创建各种类型的 item 
    1.启用/禁用 item,是否选择 item 
    2.MenuItemLabel、MenuItemAtlasFont、MenuItemFont、MenuItemSprite、MenuItemImage、MenuItemToggle 和 CCMenuItem 相关的类

misc_nodes

1.cocos2d-x节点(CCClippingNode.h)API
裁剪节点
2.cocos2d-x节点(CCMotionStreak.h)API
在游戏的实现过程中,有时会需要在某个 游戏对象上的运动轨迹上实现渐隐效果。这种 感觉就好像是类似飞机拉线的拖尾巴,在视觉 上感觉很好,比如子弹的运动轨迹等,如果不 借助引擎的帮助,这种效果往往需要通过大量 的图片来实现。而 Cocos2D-x 提供了一种内置 的拖动渐隐效果类 CCMotionStreak 来帮助我们 实现这个效果。
3.cocos2d-x节点(CCProgressTimer.h)API
进度条定时器
4.cocos2d-x节点(CCRenderTexture.h)API
渲染纹理,把渲染 texture 存储为 PNG或JPG格式,捕获 android 设备的 come to background/foreground 消息 ,来 存储/恢复 缓存对象

particle_nodes

 1.cocos2d-x节点(CCParticleBatchNode.h)API
批量绘制粒子
 2.cocos2d-x节点(CCParticleExamples.h)API
许多个粒子系统的 examples ,下雪,太阳,火焰,烟雾,流行,星系......
 3.cocos2d-x节点(CCParticleSystem.h)API
//粒子系统的基类,重力模式、半径模式     备注:变动 是,每一次 增减/减少 的固定值
 4.cocos2d-x节点(CCParticleSystemQuad.h)API
ParticleSystemQuad 是 ParticleSystem 的子类,它包含 ParticleSystem 的所有功能, 增加了,缩放、旋转、批处理
 5.cocos2d-x节点(firePngData.h)API
这个类只有一个很难懂的char数组

physics

Box2D、chipmunk只是包含了一些构造函数,析构函数,没有太多有价值的信息,感兴趣的人,可以自己取看看

 1.cocos2d-x节点(CCPhysicsSetting.h)API

都是一些物理引擎设置的定义
 2.cocos2d-x节点(CCPhysicsBody.h)API
物体之间的作用力,把 shape 链接到 body
 3.cocos2d-x节点(CCPhysicsContact.h)API
两个物体接触的监听和处理
 4.cocos2d-x节点(CCPhysicsShape.h)API
模拟现实世界的形状,圆形,链形,段状,对变形.....
 5.cocos2d-x节点(CCPhysicsJoint.h)API
各种无力物理联合,别针、限制、联动、弹簧....等联合
 6.cocos2d-x节点(CCPhysicsWorld.h)API
添加移除物理世界关联

platform

apple、mac、third_party、ios 需要的话自己看吧
 1.cocos2d-x节点(CCApplicationProtocol.h)API
应用程序的初始化,以及加载语言文件
 2.cocos2d-x节点(CCCommon.h)API
调试的日志信息
 3.cocos2d-x节点(CCDevice.h)API
设备的 DPI 启用/禁用 加速度传感器,设置加速的时间间隔
 4.cocos2d-x节点(CCEGLViewProtocol.h)API
应用全屏参数,拉伸全屏,裁剪全屏,有黑色边框全屏
 5.cocos2d-x节点(CCFileUtils.h)API
辅助类来处理文件操作,各种平台文件的搜索
 6.cocos2d-x节点(CCImage.h)API
加载图片,储存图片,例如,从 stream buffer 里面加载图片,从指定路径加载图片,把文本初始化为图片
 7.cocos2d-x节点(CCImageCommon_cpp.h)API
初始化各种类型的图片,储存图片
 8.cocos2d-x节点(CCPlatformConfig.h)API
 为每一个平台,配置 cocos2d-x 项目
 9.cocos2d-x节点(CCPlatformMacros.h)API
定义一些特定于平台的宏
10.cocos2d-x节点(CCSAXParser.h)API
SAX解析器
11.cocos2d-x节点(CCThread.h)API
在 ios 设备上创建线程释放池对象

script_support

 1.cocos2d-x节点(CCScriptSupport.h)API
调度器脚本处理程序入口、触摸脚本处理程序入口、脚本处理程序入口

shaders

 1.cocos2d-x节点(CCGLProgram.h)API
顶点着色器 相关操作
 2.cocos2d-x节点(ccGLStateCache.h)API
绑定/删除 texure ,启用/禁用 gl功能
 3.cocos2d-x节点(CCShaderCache.h)API
获取/重新加载 ShaderCache 实例

sprite_nodes m

 1.cocos2d-x节点(CCAnimation.h)API
创建帧动画
 2.cocos2d-x节点(CCAnimationCache.h)API
管理 Animations 的 Singleton(单例).
他把 animations 存储到 cache 里. 如果你希望在 cache 里面存储你的 animations(cocos2d 把所有的动画统称为 animatiosns),你可以使用这个类
 3.cocos2d-x节点(CCSprite.h)API
Sprite 是一个 2d 图片
    1.更新 Sprite 的 texture、设置 sprite 的批处理节点、设置 sprite 在 TextureAtlas 里面的索引…
 4.cocos2d-x节点(CCSpriteBatchNode.h)API
SpriteBatchNode 就是一个批处理节点:如果它包含孩子,他会一次性绘制所有孩子(通常叫做"批绘制”).如果要绘制的对象较多,使用 SpriteBatchNode 可以提升游戏性能
 5.cocos2d-x节点(CCSpriteFrame.h)API
和 sprite 类似
 6.cocos2d-x节点(CCSpriteFrameCache.h)API
从 .list/字典 文件 初始化/删除 sprite Frame

support

component、data_support、image_support、tinyxml2、user_default、zip_support 需要的话自己看吧
 1.cocos2d-x节点(base64.h)API
解码/编码 base64的内存
 2.cocos2d-x节点(CCNotificationCenter.h)API
通知中心管理通知
 3.cocos2d-x节点(CCProfiling.h)API
cocos2d内置分析器
 4.cocos2d-x节点(ccUTF8.h)API
UTF-16 转换为 UTF-8,统计 写入/读取 的字节数
 5.cocos2d-x节点(ccUtils.h)API
获取下一个二进制数据
 6.cocos2d-x节点(CCVertex.h)API
顶点
 7.cocos2d-x节点(TransformUtils.h)API
改造后的 util

text_input_node m

 1.cocos2d-x节点(CCIMEDelegate.h)API
在游戏中,有时需要用户输入用户名,密码等,这时需要调用虚拟键盘来实现。在 Cocos2D-x中,通过使用继承输入法代理类 CCIMEDelegate 和其字体标签类 CCLableTTF的字体的输入框类 CCTextFieldTTF 来实现这一功能
 2.cocos2d-x节点(CCIMEDispatcher.h)API

IME调度
 3.cocos2d-x节点(CCTextFieldTTF.h)API
在游戏中,有时需要用户输入用户名,密码等,这时需要调用虚拟键盘来实现。在 Cocos2D-x中,通过使用继承输入法代理类 CCIMEDelegate 和其字体标签类 CCLableTTF的字体的输入框类 CCTextFieldTTF 来实现这一功能

textures

 1.cocos2d-x节点(CCTexture2D.h)API
贴图类 CCTexture2D 是关于 OpenGL 的概念。在 OpenGL 中称图片为贴图,在 Cocos2D-x 中 CCTexture2D 就是图片对象的意思,可以通过它创建精灵等对象 .CCTexture2D 类是精灵类和其相关类的基础。以下会看到很多类都可以用 CCTexture2D类定义。 
 2.cocos2d-x节点(CCTextureAtlas.h)API

一个类实现了Texture Atlas. 对 Quads 进行操作
 3.cocos2d-x节点(CCTextureCache.h)API
在 cache 里面存取 texture 

tilemap_parallax_nodes

 1.cocos2d-x节点(CCParallaxNode.h)API
Parallax(视差) 类似滚动条
 2.cocos2d-x节点(CCTileMapAtlas.h)API
可以使用 CCTileMapAtlas 创建地图
 3.cocos2d-x节点(CCTMXLayer.h)API
他是 SpriteBatchNode 的子类.默认情况下 tiles (瓷砖)使用TextureAtlas 呈现。 
如果你在运行时修改了 tile ,tile 将变成一个 sprite
 4.cocos2d-x节点(CCTMXObjectGroup.h)API
地图精灵组类,CCTMXObjectGroup 用于代表地图中的精灵组
 5.cocos2d-x节点(CCTMXTiledMap.h)API

和 CCTMXXMLParser(//cocos2d-x-3.0alpha0/cocos2dx/tilemap_parallax_nodes/CCTMXXMLParser.h) 类差不多都是解析地图
 6.cocos2d-x节点(CCTMXXMLParser.h)API
TMX/XML 地图解析 和CCTMXTiledMap 差不多(//cocos2d-x-3.0alpha0/cocos2dx/tilemap_parallax_nodes/CCTMXTiledMap.h)

2016-06-22 09:45:13 lizitian007 阅读数 94
//------------------------------------------
var label = new cc.LabelBMFont("sth","res/title.fnt")

用title艺术字体显示sth字样(需要addChild,可以setPosition)

//-----------------------------------------------------------------------
sth.visible=true/false(显示/不显示)
//-----------------------------------------------------------------------
lable.setString(string) 修改显示内容
lable.getString() 获得显示内容
//-----------------------------------------------------------------------
var listener = cc.EventListener.create({
            event:cc.EventListener.TOUCH_ONE_BY_ONE,
            swallowTouches:true,    //吞没事件   穿透
            onTouchBegan:function(touch, event){
                var target = event.getCurrentTarget();  //取得持有侦听事件的对象
                var locationInNode = target.convertToNodeSpace(touch.getLocation());    //取得点击位置touch.getLocation()
                                                                                        //将点击位置坐标转换为node节点坐标

                var s = target.getContentSize();                                        //获得图片大小
                                                                                           
                var rect = cc.rect(0,0, s.width, s.height);                             保存图片大小

                if(cc.rectContainsPoint(rect, locationInNode)){                         点击在图片内返回true不在返回false
                    return true;
                }
                return false;
            },
            onTouchEnded:function(touch, event)
            {

             }
            onTouchEnded:function(touch, event)
            {  
               
            }

        })

cc.eventManager.removeListeners(target);删除侦听
cc.eventManager.addTouchListeners(target);添加侦听

//-----------------------------------------------------------------------
 getNameFromPar(UI信息,  按钮名).addTouchEventListener(回调函数名(无括号).bind(this), UI信息);

为按钮添加点击事件点击则调用回调函数

回调函数:function(sender,type)
    { }
其中sender为按钮名,type为点击类型(ccui.Widget.TOUCH_ENDED等)


//-----------------------------------------------------------------------
getNameFromPar = function(par,name)
{
    return ccui.helper.seekWidgetByName(par,name);
};

从节点找原件
//-----------------------------------------------------------------------
cc.director.popScene();回退场景
cc.director.pushScene(new A);切换到A场景

//-----------------------------------------------------------------------
getWidgetFromJsonFile = function(source)
{
    return ccs.load(source).node;
};
从json文件获得信息,source传入json地址
//-----------------------------------------------------------------------
var gradient = new cc.LayerGradient(cc.color(0, 0, 0, 255), cc.color(0x46, 0x82, 0xB4, 255), cc.p(1, 1));
this.addChild(gradient);
创建背景(黑色到蓝色渐变)

------------------------------------------------------------------------

        var sp1 = new cc.Sprite(res.left1)
        var sp4 = new cc.Sprite(res.left1)
        var sp2 = new cc.Sprite(res.left2)
        var sp3 = new cc.Sprite(res.right1)


        var menuSprite = new cc.MenuItemSprite(sp1, sp4, sp3, this.onClick)

        var imgSprite = new cc.MenuItemImage(res.left1,res.right2,res.left2,this.onClick,this)
        imgSprite.enabled=false


        var txtFone = new cc.MenuItemFont("CLICK", this.onClick, this)


        var label = new cc.LabelBMFont("CLICK","res/mikado_outline_shadow.fnt")
        var bmFontBtn = new cc.MenuItemLabel(label,this.onClick, this)

        var labe2 = new cc.LabelBMFont("CLICK22","res/mikado_outline_shadow.fnt")
        var bmFontBtn1 = new cc.MenuItemLabel(labe2,this.onClick, this)
        var labe3 = new cc.LabelBMFont("CLICK33","res/mikado_outline_shadow.fnt")
        var bmFontBtn2 = new cc.MenuItemLabel(labe3,this.onClick, this)
        var labe4 = new cc.LabelBMFont("CLICK44","res/mikado_outline_shadow.fnt")
        var bmFontBtn3 = new cc.MenuItemLabel(labe4,this.onClick, this)
        var tog = new cc.MenuItemToggle(bmFontBtn1,bmFontBtn2,bmFontBtn3,this.onTogChange,this)

        var menu = new cc.Menu(menuSprite, imgSprite,txtFone, bmFontBtn,tog)
        //menu.alignItemsHorizontally()
        menu.alignItemsHorizontallyWithPadding(20)
        this.addChild(menu)

各种添加按钮

-----------------------------------------------------------------
2019-02-25 18:21:13 magic_code_ 阅读数 427

// 记一下cocos API,官方文档虽然全,但是没有整合,所以记录一下,方便后续查找
// 以下全部都是从官网文档里面找到的,大部分都做了一下实验,动作系统大部分没有
// 实验使用最新2.0 cocos

Cocos Creator Shader Github -> 	https://github.com/pandamicro/heartfelt
 
// 我想,大部分人应该和我一样,摸索一个引擎的时候最先的就是看看渲染流程是什么
// 不过在测试的时候,查到最新的cocos已经丢弃了sgNode,于是从官方哪里找到一个
// shader流程,真的牛皮,代码太长,看的一头懵逼,
 
cocos 官方教程 				->	http://www.cocoachina.com/bbs/read.php?tid=458895&page=1&toread=1#tpc
 
cocos 全局事件派送 			->	https://forum.cocos.com/t/7-15/37857
 
API 查询 					->	https://docs.cocos.com/creator/api/zh/classes/Event.html
 
:::::::::::::::::::API:::::::::::::::::::::::
 
window.Global = {};						// 公共参数
 
cc.find('Canvas/New Sprite');			// 根据名字查找节点,只会返回第一个
cc.director.getScene();					// 获取当前场景
cc.game.addPersistRootNode(myNode); 	// 常驻挂载点,不会因为切换场景被destroy
cc.game.removePersistRootNode(myNode); 	// 取消常驻属性
// 加载场景,最后是加载完成的函数回调
cc.director.loadScene("MyScene", onSceneLaunched);
// 异步加载场景,手动切换需要再次调用 loadScene
cc.director.preloadScene("table", function () {});
 
this.node.active = bool;			// 隐藏一个节点,会调用 onDisable
this.node.parent = parentNode;		// 设置父节点
this.node.children;					// 返回下一层子节点
this.node.childrenCount;			// 返回下一层子节点数量
this.node.getChildByName('Name')	// 返回下一子层找到的第一个节点
 
cc.isChildClassOf(Texture2D, Texture)	// 判断继承关系,返回bool	
var m = new Method();
if(m instanceof Method)					// 判断类型
 
类的方法 = {
	extends: 基类 // 继承
	// 如果重写父类方法,并且希望调用
	// 则子类使用 this._super();
	{
		// 例
		r_str :function(){
			// 假设父类有这个方法,返回一个字符串为 'world' 则 
			var baseValue = this._super();
			return 'hello ' + baseValue;
		};
	}
	属性定义 = {
		properties : 
		{
			value : 
			{
				default		: null,	  // 变量默认值
				type		: cc.Node // 类型
				displayName : '鼠标放上的注释显示',
				tooltip 	: 'inspactor显示变量名',
			},
			v2 : cc.v2(1,1),
		}
		
		// 第二种方式
		properties: () => ({
			text: ""
		}),
	}
	
	ctor:function() // __ctor__  == ctor
	{
		// 构造函数
	},
	// 如果静态方法写在类中,则会被继承,外部不会
	// 静态成员,必须写在 statics 之中
	statics: {
        _count: 0,
        getCount: function () {}
    },
	// 静态类->例:
	{
        // 这个类名为 c_testClass.js
		var c_testClass = cc.Class({
			extends:cc.Component,
			properties:{},
			onLoad:function(){},
			statics : 
			{
				count:0,
				print:function()
				{
					cc.log('class static method test');
				}
			}
		});
		// 也可以写在外部
		c_testClass.count_01 = 0;	//	声明静态参数
		c_testClass.print_01 : function(){
			cc.log('static method test');
		};
		module.export = c_testClass;	// 其他类使用时必须 require('文件名')
        // 假设我又一个需要使用这个类的类 文件名名为 test.js
        var c_t_class = require('c_testClass');
        cc.Class({
            extends : cc.Component,
            properties : {},
            start:function()
            {
                c_t_class.print();
                c_t_class.print_01();
            }
        });
	}
}
 
获取属性 = {
	this.node.position = cc.v2(100, 50);
	this.node.rotation = 90;
	this.node.setScale(2, 2); OR .scaleX -- .scaleY
---------------------------------------------------
	// 更改节点尺寸,inspactor size
	this.node.setContentSize(100, 100); 
	this.node.setContentSize(cc.size(100, 100));
	// or
	this.node.width = 100;
	this.node.height = 100;
---------------------------------------------------
---------------------------------------------------
	// 修改锚点
	this.node.anchorX = 1;
	this.node.anchorY = 0;
	// or
	this.node.setAnchorPoint(1, 0);
---------------------------------------------------
	
	
};
 
生成物体 = {
    // 不知道为什么,这段代码写在onLoad里面会报错,可能是节点还没初始化???
	var s_scene = cc.director.getScene();
    var t = cc.instantiate(this.node);
	// 必须指定一个根节点才会显示
    t.parent = s_scene;					
    t.position = cc.v2(100,300);
	
	t.destroy();
	setTimeout(function()
    {
		destroy(t);
    },bind(this), 5000); // 毫秒
};
 
// 全局事件,类似 SendMessage cocos 全局事件派送  https://forum.cocos.com/t/7-15/37857
cocos 系统事件监听 = {
	// 第三个参数为 -> 响应函数的调用者
	this.node.on('event name',callback event,this);	// 只能发送本脚本事件
	
	{
		// Windows
		{
			cc.Node.EventType.MOUSE_DOWN	'mousedown'		当鼠标在目标节点区域按下时触发一次
			cc.Node.EventType.MOUSE_ENTER	'mouseenter'	当鼠标移入目标节点区域时,不论是否按下
			cc.Node.EventType.MOUSE_MOVE	'mousemove'		当鼠标在目标节点在目标节点区域中移动时,不论是否按下
			cc.Node.EventType.MOUSE_LEAVE	'mouseleave'	当鼠标移出目标节点区域时,不论是否按下
			cc.Node.EventType.MOUSE_UP		'mouseup'		当鼠标从按下状态松开时触发一次
			cc.Node.EventType.MOUSE_WHEEL	'mousewheel'	当鼠标滚轮滚动时
			
			// 鼠标事件(cc.Event.EventMouse)
		    ->函数名<-		->返回值类型<-		->意义<-
			getScrollY			Number			获取滚轮滚动的 Y 轴距离,只有滚动时才有效
			getLocation			Object			获取鼠标位置对象,对象包含 x 和 y 属性
			getLocationX		Number			获取鼠标的 X 轴位置
			getLocationY		Number			获取鼠标的 Y 轴位置
			getPreviousLocation	Object			获取鼠标事件上次触发时的位置对象,对象包含 x 和 y 属性
			getDelta			Object			获取鼠标距离上一次事件移动的距离对象,对象包含 x 和 y 属性
			getButton			Number	++ 
			cc.Event.EventMouse.BUTTON_LEFT 
			或 cc.Event.EventMouse.BUTTON_RIGHT 
			或 cc.Event.EventMouse.BUTTON_MIDDLE
		}
		
		// Android
		{
			cc.Node.EventType.TOUCH_START	'touchstart'	当手指触点落在目标节点区域内时
			cc.Node.EventType.TOUCH_MOVE	'touchmove'	当手指在屏幕上目标节点区域内移动时
			cc.Node.EventType.TOUCH_END		'touchend'	当手指在目标节点区域内离开屏幕时
			cc.Node.EventType.TOUCH_CANCEL	'touchcancel'	当手指在目标节点区域外离开屏幕时
			
			// 触摸事件(cc.Event.EventTouch)
			->API名<-			->类型<-	->意义<-
			touch				cc.Touch	与当前事件关联的触点对象
			getID				Number		获取触点的 ID,用于多点触摸的逻辑判断
			getLocation			Object		获取触点位置对象,对象包含 x 和 y 属性
			getLocationX		Number		获取触点的 X 轴位置
			getLocationY		Number		获取触点的 Y 轴位置
			getPreviousLocation	Object		获取触点上一次触发事件时的位置对象,对象包含 x 和 y 属性
			getStartLocation	Object		获取触点初始时的位置对象,对象包含 x 和 y 属性
			getDelta			Object		获取触点距离上一次事件移动的距离对象,对象包含 x 和 y 属性
		}
		
		// cc.Node Event
		{
			->对应的事件名<-   ->事件触发的时机<-
			'position-changed'	当位置属性修改时
			'rotation-changed'	当旋转属性修改时
			'scale-changed'		当缩放属性修改时
			'size-changed'		当宽高属性修改时
			'anchor-changed'	当锚点属性修改时
		}
		
	};
	
	// 向上级派送事件,冒泡,会忽略父级同级节点脚本
	this.node.dispatchEvent( new cc.Event.EventCustom('_say',true));
	// 父级脚本里面需要用on监听
	this.node.on('_say',function(){cc.log('hello')});
	event.stopPropagation(); // 中断派送冒泡
};
 
// 官方API实例 		https://docs.cocos.com/creator/api/zh/modules/cc.html#方法名
// 如->sequence	 	https://docs.cocos.com/creator/api/zh/modules/cc.html#sequence
动画系统 = {
	
	
	// 执行API
	{
		cc.sequence			顺序执行动作
		cc.spawn			同步执行动作
		cc.repeat			重复执行动作
		cc.repeatForever	        永远重复动作
		cc.speed			修改动作速率
		/*
		// 例 :
		/// parameter callback  = method name
		/// parameter context   = this		// 指定谁调用,设置上下文
		/// parameter parameter = parameter // 参数列表
		var finished = cc.callFunc(callback, context, parameter); // 设置动作回调
		
		this.jumpAction = cc.sequence(		// 顺序执行动作,下面的API会按照顺序执行
		
			cc.spawn(						// 同步执行动作,下面两个动作会同步进行。
			
				cc.scaleTo(0.1, 0.8, 1.2),	// 缩放系数 -> 将节点大小缩放到指定的倍数
				cc.moveTo(0.1, 0, 10)		// 移动坐标 -> 移动到目标位置
				
			),
			cc.spawn(
				cc.scaleTo(0.2, 1, 1),
				cc.moveTo(0.2, 0, 0)
			),
			
			cc.delayTime(0.5),				// 延时动作, 秒
			
			cc.spawn(
				cc.scaleTo(0.1, 1.2, 0.8),
				cc.moveTo(0.1, 0, -10)
			),
			cc.spawn(
				cc.scaleTo(0.2, 1, 1),
				cc.moveTo(0.2, 0, 0)
			),
			
			finished // 执行完完毕的回调方法
			
		).speed(2).repeat(5);				// 以1/2的速度慢放动画,并重复5次
		*/
	}
 
	动作API
	{
		cc.show 				立即显示。
		cc.hide 				立即隐藏。
		cc.toggleVisibility 	显隐状态切换。
		cc.removeSelf 			从父节点移除自身。
		cc.flipX 				X轴翻转。
		cc.flipY 				Y轴翻转。
		cc.place 				放置在目标位置。
		cc.callFunc 			执行回调函数。
		cc.sequence 			顺序执行动作,创建的动作将按顺序依次运行。
		cc.repeat 				重复动作,可以按一定次数重复一个动,如果想永远重复一个动作请使用 repeatForever 动作来完成。
		cc.repeatForever 		永远地重复一个动作,有限次数内重复一个动作请使用 repeat 动作,由于这个动作不会停止,所以不能被添加到 cc.sequence 或 cc.spawn 中。
		cc.spawn 				同步执行动作,同步执行一组动作。
		cc.rotateTo 			旋转到目标角度,通过逐帧修改它的 rotation 属性,旋转方向将由最短的角度决定。
		cc.rotateBy 			旋转指定的角度。
		cc.moveBy 				移动指定的距离。
		cc.moveTo 				移动到目标位置。
		cc.skewTo 				偏斜到目标角度。
		cc.skewBy 				偏斜指定的角度。
		cc.jumpBy 				用跳跃的方式移动指定的距离。
		cc.jumpTo 				用跳跃的方式移动到目标位置。
		cc.bezierBy 			按贝赛尔曲线轨迹移动指定的距离。
		cc.bezierTo 			按贝赛尔曲线轨迹移动到目标位置。
		cc.scaleTo 			    将节点大小缩放到指定的倍数。
		cc.scaleBy 			    按指定的倍数缩放节点大小。
		cc.blink  				闪烁(基于透明度)。
		cc.fadeTo 				修改透明度到指定值。
		cc.fadeIn 				渐显效果。
		cc.fadeOut 			    渐隐效果。
		cc.tintTo 				修改颜色到指定值。
		cc.tintBy 				按照指定的增量修改颜色。
		cc.delayTime 			延迟指定的时间量。
		cc.reverseTime 		    反转目标动作的时间轴。
		cc.targetedAction 		用已有动作和一个新的目标节点创建动作
		
		
		cc.easeIn 						创建 easeIn 缓动对象,由慢到快。
		cc.easeOut 					    创建 easeOut 缓动对象,由快到慢。
		cc.easeInOut 					创建 easeInOut 缓动对象,慢到快,然后慢。
		cc.easeSineIn 					按正弦函数缓动进入的动作。
	}
	
};
 
计时器 = {
	{
		this.schedule				开始一个计时器
		this.scheduleOnce			开始一个只执行一次的计时器
		this.unschedule				取消一个计时器
		this.unscheduleAllCallbacks 取消这个组件的所有计时器
	}
	
	this.schedule(function() {
        // 这里的 this 指向 component
        this._say();
    }, 5);
	
	OR
	
	var interval = 5;	// 时间间隔,秒
	var repeat = 3;		// 重复次数
	var delay = 10;		// 延时
	this.schedule(function() {
		this._say();
	}, interval, repeat, delay);
	
	_say:function(){
        cc.log('我好烦弱类型');
    },
	
	this.unschedule(this.callback);	// 取消计时器
};

cocos creator 1.10 节点API

阅读数 113

节点默认是激活的。除了在编辑器中切换节点的激活、关闭状态,也可以通过以下代码:this.node.active=true;假设父节点为 parentNode,子节点为 this.nodethis.node.parent=parentNode;或this.node.removeFromParent(false);parentNode.addChild(this.nod...

博文 来自: qq_40565669

cocos creator 强大的audioEngine API

阅读数 7393

        简直了,感觉自己还是知道的太少,在过程中最后发现creatoraudioEngine提供了所需要的基本的API。这个感觉还是蛮重要的。(摘自官方文档)。播放音频varid=cc.audioEngine.play(path,loop,volume);//参数path代表音频路径,loop代表是否循环,volume代表音量范围0~1.0设置音频是否循环cc.aud...

博文 来自: qq_34501940

Cocos Creactor 1.9.3 常用api

阅读数 28

CocosCreactor1.9.3常用apiCocos引擎的主要类、函数、属性或常量加载或切换场景资源加载资源释放加载远程资源和设备资源事件系统动作系统组件计时器Cocos引擎的主要类、函数、属性或常量cc.sys系统变量(Systemvariables)cc.game是Game的实例,用来驱动整个游戏。cc.director一个管理你的游戏的逻辑流程的单例对象。cc...

博文 来自: yulin009

cocos js api的一些好用的方法

阅读数 246

1.拖尾效果,和运动轨迹为圆的方法!onEnter:function(){this._super();//askdirectorthethewindowsizevarsize=cc.director.getWinSize();this._streak=newcc.MotionStreak(2.0

博文 来自: u014454791

Cocos Creator 音频API控制调频

阅读数 23

*****音频的一些控制*****cc.audioEngine.playMusic(this.BGAudio,true);//播放音乐(true代表循环)cc.audioEngine.stopMusic()//停止播放背景音乐cc.audioEngine.playEffect(this.ClickAudio,false);//播放音效(false代表只播放一次)cc.audioEng...

博文 来自: weixin_34075268
没有更多推荐了,返回首页