ccb 0.0.1

data/lib/ccb/builder/templates/project/folder/frameworks/cocos2d-html5/extensions/ccpool/CCPool.js

@@ -0,0 +1,146 @@
+/****************************************************************************
+ Copyright (c) 2008-2010 Ricardo Quesada
+ Copyright (c) 2011-2012 cocos2d-x.org
+ Copyright (c) 2013-2014 Chukong Technologies Inc.
+
+ 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.
+ ****************************************************************************/
+
+/**
+ * <p>
+ *  cc.pool is a singleton object serves as an object cache pool.<br/>
+ *  It can helps you to improve your game performance for objects which need frequent release and recreate operations<br/>
+ *  Some common use case is :
+ *      1. Bullets in game (die very soon, massive creation and recreation, no side effect on other objects)
+ *      2. Blocks in candy crash (massive creation and recreation)
+ *      etc...
+ * </p>
+ *
+ * @example
+ * var sp = new cc.Sprite("a.png");
+ * this.addChild(sp);
+ * cc.pool.putInPool(sp);
+ *
+ * cc.pool.getFromPool(cc.Sprite, "a.png");
+ * @class
+ * @name cc.pool
+ */
+cc.pool = /** @lends cc.pool# */{
+    _pool: {},
+
+    _releaseCB: function () {
+        this.release();
+    },
+
+    _autoRelease: function (obj) {
+        var running = obj._running === undefined ? false : !obj._running;
+        cc.director.getScheduler().scheduleCallbackForTarget(obj, this._releaseCB, 0, 0, 0, running)
+    },
+
+    /**
+     * Put the obj in pool
+     * @param obj
+     */
+    putInPool: function (obj) {
+        var pid = obj.constructor.prototype.__pid;
+        if (!pid) {
+            var desc = { writable: true, enumerable: false, configurable: true };
+            desc.value = ClassManager.getNewID();
+            Object.defineProperty(obj.constructor.prototype, '__pid', desc);
+        }
+        if (!this._pool[pid]) {
+            this._pool[pid] = [];
+        }
+        // JSB retain to avoid being auto released
+        obj.retain && obj.retain();
+        // User implementation for disable the object
+        obj.unuse && obj.unuse();
+        this._pool[pid].push(obj);
+    },
+
+    /**
+     * Check if this kind of obj has already in pool
+     * @param objClass
+     * @returns {boolean} if this kind of obj is already in pool return true,else return false;
+     */
+    hasObject: function (objClass) {
+        var pid = objClass.prototype.__pid;
+        var list = this._pool[pid];
+        if (!list || list.length == 0) {
+            return false;
+        }
+        return true;
+    },
+
+    /**
+     * Remove the obj if you want to delete it;
+     * @param obj
+     */
+    removeObject: function (obj) {
+        var pid = obj.constructor.prototype.__pid;
+        if (pid) {
+            var list = this._pool[pid];
+            if (list) {
+                for (var i = 0; i < list.length; i++) {
+                    if (obj === list[i]) {
+                        // JSB release to avoid memory leak
+                        obj.release && obj.release();
+                        list.splice(i, 1);
+                    }
+                }
+            }
+        }
+    },
+
+    /**
+     * Get the obj from pool
+     * @param args
+     * @returns {*} call the reuse function an return the obj
+     */
+    getFromPool: function (objClass/*,args*/) {
+        if (this.hasObject(objClass)) {
+            var pid = objClass.prototype.__pid;
+            var list = this._pool[pid];
+            var args = Array.prototype.slice.call(arguments);
+            args.shift();
+            var obj = list.pop();
+            // User implementation for re-enable the object
+            obj.reuse && obj.reuse.apply(obj, args);
+            // JSB release to avoid memory leak
+            cc.sys.isNative && obj.release && this._autoRelease(obj);
+            return obj;
+        }
+    },
+
+    /**
+     *  remove all objs in pool and reset the pool
+     */
+    drainAllPools: function () {
+        for (var i in this._pool) {
+            for (var j = 0; j < this._pool[i].length; j++) {
+                var obj = this._pool[i][j];
+                // JSB release to avoid memory leak
+                obj.release && obj.release();
+            }
+        }
+        this._pool = {};
+    }
+};

data/lib/ccb/builder/templates/project/folder/frameworks/cocos2d-html5/extensions/ccui/base-classes/CCProtectedNode.js

@@ -0,0 +1,305 @@
+/****************************************************************************
+ Copyright (c) 2013-2014 Chukong Technologies Inc.
+
+ 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.
+ ****************************************************************************/
+
+/**
+ * A class inhert from cc.Node, use for saving some protected children in other list.
+ * @class
+ * @extends cc.Node
+ */
+cc.ProtectedNode = cc.Node.extend(/** @lends cc.ProtectedNode# */{
+    _protectedChildren: null,
+    _reorderProtectedChildDirty: false,
+
+    _insertProtectedChild: function(child, z){
+        this._reorderProtectedChildDirty = true;
+        this._protectedChildren.push(child);
+        child._setLocalZOrder(z);
+    },
+
+    /**
+     * Constructor function, override it to extend the construction behavior, remember to call "this._super()" in the extended "ctor" function.
+     * @function
+     */
+    ctor: function(){
+        cc.Node.prototype.ctor.call(this);
+        this._protectedChildren = [];
+    },
+
+    /**
+     * <p>
+     *  Adds a child to the container with z order and tag                                                                         <br/>
+     *  If the child is added to a 'running' node, then 'onEnter' and 'onEnterTransitionDidFinish' will be called immediately.     <br/>
+     *  </p>
+     * @param {cc.Node} child  A child node
+     * @param {Number} [localZOrder]  Z order for drawing priority. Please refer to `setLocalZOrder(int)`
+     * @param {Number} [tag]  An integer to identify the node easily. Please refer to `setTag(int)`
+     */
+    addProtectedChild: function(child, localZOrder, tag){
+         cc.assert(child != null, "child must be non-nil");
+         cc.assert(!child.parent, "child already added. It can't be added again");
+
+        localZOrder = localZOrder || child.getLocalZOrder();
+        if(tag)
+            child.setTag(tag);
+
+        this._insertProtectedChild(child, localZOrder);
+        child.setParent(this);
+        child.setOrderOfArrival(cc.s_globalOrderOfArrival);
+
+        if(this._running){
+            child.onEnter();
+            // prevent onEnterTransitionDidFinish to be called twice when a node is added in onEnter
+            if(this._isTransitionFinished)
+                child.onEnterTransitionDidFinish();
+        }
+        if(this._cascadeColorEnabled)
+            this._renderCmd.setCascadeColorEnabledDirty();
+        if (this._cascadeOpacityEnabled)
+            this._renderCmd.setCascadeOpacityEnabledDirty();
+    },
+
+    /**
+     * Gets a child from the container with its tag
+     * @param {Number} tag An identifier to find the child node.
+     * @return {cc.Node} a Node object whose tag equals to the input parameter
+     */
+    getProtectedChildByTag: function(tag){
+        cc.assert(tag != cc.NODE_TAG_INVALID, "Invalid tag");
+        var locChildren = this._protectedChildren;
+        for(var i = 0, len = locChildren.length; i < len; i++)
+            if(locChildren.getTag() == tag)
+                return locChildren[i];
+        return null;
+    },
+
+    /**
+     * Removes a child from the container. It will also cleanup all running actions depending on the cleanup parameter.
+     * @param {cc.Node} child  The child node which will be removed.
+     * @param {Boolean} [cleanup=true] true if all running actions and callbacks on the child node will be cleanup, false otherwise.
+     */
+    removeProtectedChild: function(child,  cleanup){
+        if(cleanup == null)
+            cleanup = true;
+         var locChildren = this._protectedChildren;
+        if(locChildren.length === 0)
+            return;
+        var idx = locChildren.indexOf(child);
+        if(idx > -1){
+             if(this._running){
+                 child.onExitTransitionDidStart();
+                 child.onExit();
+             }
+
+            // If you don't do cleanup, the child's actions will not get removed and the
+            // its scheduledSelectors_ dict will not get released!
+            if (cleanup)
+                child.cleanup();
+
+            // set parent nil at the end
+            child.setParent(null);
+            locChildren.splice(idx, 1);
+        }
+    },
+
+    /**
+     * Removes a child from the container by tag value.                                    <br/>
+     * It will also cleanup all running actions depending on the cleanup parameter
+     * @param {Number} tag
+     * @param {Boolean} [cleanup=true]
+     */
+    removeProtectedChildByTag: function(tag, cleanup){
+        cc.assert( tag != cc.NODE_TAG_INVALID, "Invalid tag");
+
+        if(cleanup == null)
+            cleanup = true;
+
+        var child = this.getProtectedChildByTag(tag);
+
+        if (child == null)
+            cc.log("cocos2d: removeChildByTag(tag = %d): child not found!", tag);
+        else
+            this.removeProtectedChild(child, cleanup);
+    },
+
+    /**
+     * Removes all children from the container with a cleanup.
+     * @see cc.ProtectedNode#removeAllProtectedChildrenWithCleanup
+     */
+    removeAllProtectedChildren: function(){
+        this.removeAllProtectedChildrenWithCleanup(true);
+    },
+
+    /**
+     * Removes all children from the container, and do a cleanup to all running actions depending on the cleanup parameter.
+     * @param {Boolean} [cleanup=true] true if all running actions on all children nodes should be cleanup, false otherwise.
+     */
+    removeAllProtectedChildrenWithCleanup: function(cleanup){
+        if(cleanup == null)
+            cleanup = true;
+        var locChildren = this._protectedChildren;
+        // not using detachChild improves speed here
+        for (var i = 0, len = locChildren.length; i< len; i++) {
+            var child = locChildren[i];
+            // IMPORTANT:
+            //  -1st do onExit
+            //  -2nd cleanup
+            if(this._running){
+                child.onExitTransitionDidStart();
+                child.onExit();
+            }
+
+            if (cleanup)
+                child.cleanup();
+            // set parent nil at the end
+            child.setParent(null);
+        }
+        locChildren.length = 0;
+    },
+
+    /**
+     * Reorders a child according to a new z value.
+     * @param {cc.Node} child An already added child node. It MUST be already added.
+     * @param {Number} localZOrder Z order for drawing priority. Please refer to setLocalZOrder(int)
+     */
+    reorderProtectedChild: function(child, localZOrder){
+        cc.assert( child != null, "Child must be non-nil");
+        this._reorderProtectedChildDirty = true;
+        child.setOrderOfArrival(cc.s_globalOrderOfArrival++);
+        child._setLocalZOrder(localZOrder);
+    },
+
+    /**
+     * <p>
+     *     Sorts the children array once before drawing, instead of every time when a child is added or reordered.       <br/>
+     *     This approach can improves the performance massively.                                                         <br/>
+     *     @note Don't call this manually unless a child added needs to be removed in the same frame
+     * </p>
+     */
+    sortAllProtectedChildren: function(){
+        if (this._reorderProtectedChildDirty) {
+            var _children = this._protectedChildren;
+
+            // insertion sort
+            var len = _children.length, i, j, tmp;
+            for(i=1; i<len; i++){
+                tmp = _children[i];
+                j = i - 1;
+
+                //continue moving element downwards while zOrder is smaller or when zOrder is the same but mutatedIndex is smaller
+                while(j >= 0){
+                    if(tmp._localZOrder < _children[j]._localZOrder){
+                        _children[j+1] = _children[j];
+                    }else if(tmp._localZOrder === _children[j]._localZOrder && tmp.arrivalOrder < _children[j].arrivalOrder){
+                        _children[j+1] = _children[j];
+                    }else
+                        break;
+                    j--;
+                }
+                _children[j+1] = tmp;
+            }
+
+            //don't need to check children recursively, that's done in visit of each child
+            this._reorderProtectedChildDirty = false;
+        }
+    },
+
+    _changePosition: function(){},
+
+    /**
+     * Stops itself and its children and protected children's all running actions and schedulers
+     * @override
+     */
+    cleanup: function(){
+       cc.Node.prototype.cleanup.call(this);
+       var locChildren = this._protectedChildren;
+        for(var i = 0 , len = locChildren.length; i  < len; i++)
+            locChildren[i].cleanup();
+    },
+
+    /**
+     * Calls its parent's onEnter and calls its protected children's onEnter
+     * @override
+     */
+    onEnter: function(){
+        cc.Node.prototype.onEnter.call(this);
+        var locChildren = this._protectedChildren;
+        for(var i = 0, len = locChildren.length;i< len;i++)
+            locChildren[i].onEnter();
+    },
+
+    /**
+     *  <p>
+     *     Event callback that is invoked when the Node enters in the 'stage'.                                          <br/>
+     *     If the Node enters the 'stage' with a transition, this event is called when the transition finishes.         <br/>
+     *     If you override onEnterTransitionDidFinish, you shall call its parent's one, e.g. Node::onEnterTransitionDidFinish()
+     *  </p>
+     *  @override
+     */
+    onEnterTransitionDidFinish: function(){
+        cc.Node.prototype.onEnterTransitionDidFinish.call(this);
+        var locChildren = this._protectedChildren;
+        for(var i = 0, len = locChildren.length;i< len;i++)
+            locChildren[i].onEnterTransitionDidFinish();
+    },
+
+    /**
+     * Calls its parent's onExit and calls its protected children's onExit
+     * @override
+     */
+    onExit:function(){
+        cc.Node.prototype.onExit.call(this);
+        var locChildren = this._protectedChildren;
+        for(var i = 0, len = locChildren.length;i< len;i++)
+            locChildren[i].onExit();
+    },
+
+    /**
+     * <p>
+     *      Event callback that is called every time the Node leaves the 'stage'.                                      <br/>
+     *      If the Node leaves the 'stage' with a transition, this callback is called when the transition starts.
+     * </p>
+     */
+    onExitTransitionDidStart: function(){
+        cc.Node.prototype.onExitTransitionDidStart.call(this);
+        var locChildren = this._protectedChildren;
+        for(var i = 0, len = locChildren.length;i< len;i++)
+            locChildren[i].onExitTransitionDidStart();
+    },
+
+    _createRenderCmd: function(){
+        if(cc._renderType === cc._RENDER_TYPE_CANVAS)
+            return new cc.ProtectedNode.CanvasRenderCmd(this);
+        else
+            return new cc.ProtectedNode.WebGLRenderCmd(this);
+    }
+});
+
+/**
+ * create a cc.ProtectedNode object;
+ * @deprecated since v3.0, please use new cc.ProtectedNode() instead.
+ * @return cc.ProtectedNode
+ */
+cc.ProtectedNode.create = function(){
+    return new cc.ProtectedNode();
+};

data/lib/ccb/builder/templates/project/folder/frameworks/cocos2d-html5/extensions/ccui/base-classes/CCProtectedNodeCanvasRenderCmd.js

@@ -0,0 +1,246 @@
+/****************************************************************************
+ Copyright (c) 2013-2014 Chukong Technologies Inc.
+
+ 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.
+ ****************************************************************************/
+
+(function(){
+    cc.ProtectedNode.RenderCmd = {
+        _updateDisplayColor: function (parentColor) {
+            var node = this._node;
+            var locDispColor = this._displayedColor, locRealColor = node._realColor;
+            var i, len, selChildren, item;
+            if (this._cascadeColorEnabledDirty && !node._cascadeColorEnabled) {
+                locDispColor.r = locRealColor.r;
+                locDispColor.g = locRealColor.g;
+                locDispColor.b = locRealColor.b;
+                var whiteColor = new cc.Color(255, 255, 255, 255);
+                selChildren = node._children;
+                for (i = 0, len = selChildren.length; i < len; i++) {
+                    item = selChildren[i];
+                    if (item && item._renderCmd)
+                        item._renderCmd._updateDisplayColor(whiteColor);
+                }
+                this._cascadeColorEnabledDirty = false;
+            } else {
+                if (parentColor === undefined) {
+                    var locParent = node._parent;
+                    if (locParent && locParent._cascadeColorEnabled)
+                        parentColor = locParent.getDisplayedColor();
+                    else
+                        parentColor = cc.color.WHITE;
+                }
+                locDispColor.r = 0 | (locRealColor.r * parentColor.r / 255.0);
+                locDispColor.g = 0 | (locRealColor.g * parentColor.g / 255.0);
+                locDispColor.b = 0 | (locRealColor.b * parentColor.b / 255.0);
+                if (node._cascadeColorEnabled) {
+                    selChildren = node._children;
+                    for (i = 0, len = selChildren.length; i < len; i++) {
+                        item = selChildren[i];
+                        if (item && item._renderCmd){
+                            item._renderCmd._updateDisplayColor(locDispColor);
+                            item._renderCmd._updateColor();
+                        }
+                    }
+                }
+                selChildren = node._protectedChildren;
+                for(i = 0, len = selChildren.length;i < len; i++){
+                    item = selChildren[i];
+                    if(item && item._renderCmd){
+                        item._renderCmd._updateDisplayColor(locDispColor);
+                        item._renderCmd._updateColor();
+                    }
+                }
+            }
+            this._dirtyFlag = this._dirtyFlag & cc.Node._dirtyFlags.colorDirty ^ this._dirtyFlag;
+        },
+
+        _updateDisplayOpacity: function (parentOpacity) {
+            var node = this._node;
+            var i, len, selChildren, item;
+            if (this._cascadeOpacityEnabledDirty && !node._cascadeOpacityEnabled) {
+                this._displayedOpacity = node._realOpacity;
+                selChildren = node._children;
+                for (i = 0, len = selChildren.length; i < len; i++) {
+                    item = selChildren[i];
+                    if (item && item._renderCmd)
+                        item._renderCmd._updateDisplayOpacity(255);
+                }
+                this._cascadeOpacityEnabledDirty = false;
+            } else {
+                if (parentOpacity === undefined) {
+                    var locParent = node._parent;
+                    parentOpacity = 255;
+                    if (locParent && locParent._cascadeOpacityEnabled)
+                        parentOpacity = locParent.getDisplayedOpacity();
+                }
+                this._displayedOpacity = node._realOpacity * parentOpacity / 255.0;
+                if (node._cascadeOpacityEnabled) {
+                    selChildren = node._children;
+                    for (i = 0, len = selChildren.length; i < len; i++) {
+                        item = selChildren[i];
+                        if (item && item._renderCmd){
+                            item._renderCmd._updateDisplayOpacity(this._displayedOpacity);
+                            item._renderCmd._updateColor();
+                        }
+                    }
+                }
+                selChildren = node._protectedChildren;
+                for(i = 0, len = selChildren.length;i < len; i++){
+                    item = selChildren[i];
+                    if(item && item._renderCmd){
+                        item._renderCmd._updateDisplayOpacity(this._displayedOpacity);
+                        item._renderCmd._updateColor();
+                    }
+                }
+            }
+            this._dirtyFlag = this._dirtyFlag & cc.Node._dirtyFlags.opacityDirty ^ this._dirtyFlag;
+        },
+
+        _changeProtectedChild: function (child) {
+            var cmd = child._renderCmd,
+                dirty = cmd._dirtyFlag,
+                flags = cc.Node._dirtyFlags;
+
+            if (this._dirtyFlag & flags.colorDirty)
+                dirty |= flags.colorDirty;
+
+            if (this._dirtyFlag & flags.opacityDirty)
+                dirty |= flags.opacityDirty;
+
+            var colorDirty = dirty & flags.colorDirty,
+                opacityDirty = dirty & flags.opacityDirty;
+
+            if (colorDirty)
+                cmd._updateDisplayColor(this._displayedColor);
+            if (opacityDirty)
+                cmd._updateDisplayOpacity(this._displayedOpacity);
+            if (colorDirty || opacityDirty)
+                cmd._updateColor();
+        }
+    };
+
+    cc.ProtectedNode.CanvasRenderCmd = function (renderable) {
+        cc.Node.CanvasRenderCmd.call(this, renderable);
+        this._cachedParent = null;
+        this._cacheDirty = false;
+    };
+
+    var proto = cc.ProtectedNode.CanvasRenderCmd.prototype = Object.create(cc.Node.CanvasRenderCmd.prototype);
+    cc.inject(cc.ProtectedNode.RenderCmd, proto);
+    proto.constructor = cc.ProtectedNode.CanvasRenderCmd;
+
+    proto.visit = function(parentCmd){
+        var node = this._node;
+        // quick return if not visible
+        if (!node._visible)
+            return;
+
+        //visit for canvas
+        var i, j;
+        var children = node._children, child;
+        var locChildren = node._children, locProtectedChildren = node._protectedChildren;
+        var childLen = locChildren.length, pLen = locProtectedChildren.length;
+
+        this._syncStatus(parentCmd);
+
+        node.sortAllChildren();
+        node.sortAllProtectedChildren();
+
+        var pChild;
+        // draw children zOrder < 0
+        for (i = 0; i < childLen; i++) {
+            child = children[i];
+            if (child._localZOrder < 0)
+                child.visit(this);
+            else
+                break;
+        }
+        for (j = 0; j < pLen; j++) {
+            pChild = locProtectedChildren[j];
+            if (pChild && pChild._localZOrder < 0){
+                this._changeProtectedChild(pChild);
+                pChild.visit(this);
+            }
+            else
+                break;
+        }
+
+        cc.renderer.pushRenderCommand(this);
+
+        for (; i < childLen; i++)
+            children[i] && children[i].visit(this);
+        for (; j < pLen; j++){
+            pChild = locProtectedChildren[j];
+            if(!pChild) continue;
+            this._changeProtectedChild(pChild);
+            pChild.visit(this);
+        }
+
+        this._dirtyFlag = 0;
+        this._cacheDirty = false;
+    };
+
+    proto.transform = function(parentCmd, recursive){
+        var node = this._node;
+
+        if(node._changePosition)
+            node._changePosition();
+
+        var t = node.getNodeToParentTransform(), worldT = this._worldTransform;
+        if(parentCmd){
+            var pt = parentCmd._worldTransform;
+            worldT.a = t.a * pt.a + t.b * pt.c;                               //a
+            worldT.b = t.a * pt.b + t.b * pt.d;                               //b
+            worldT.c = t.c * pt.a + t.d * pt.c;                               //c
+            worldT.d = t.c * pt.b + t.d * pt.d;                               //d
+            if(node._skewX || node._skewY){
+                var plt = parentCmd._transform;
+                var xOffset = -(plt.b + plt.c) * t.ty ;
+                var yOffset = -(plt.b + plt.c) * t.tx;
+                worldT.tx = (t.tx * pt.a + t.ty * pt.c + pt.tx + xOffset);        //tx
+                worldT.ty = (t.tx * pt.b + t.ty * pt.d + pt.ty + yOffset);		  //ty
+            }else{
+                worldT.tx = (t.tx * pt.a + t.ty * pt.c + pt.tx);                  //tx
+                worldT.ty = (t.tx * pt.b + t.ty * pt.d + pt.ty);		          //ty
+            }
+        } else {
+            worldT.a = t.a;
+            worldT.b = t.b;
+            worldT.c = t.c;
+            worldT.d = t.d;
+            worldT.tx = t.tx;
+            worldT.ty = t.ty;
+        }
+        var i, len, locChildren = node._children;
+        if(recursive && locChildren && locChildren.length !== 0){
+            for(i = 0, len = locChildren.length; i< len; i++){
+                locChildren[i]._renderCmd.transform(this, recursive);
+            }
+        }
+        locChildren = node._protectedChildren;
+        if(recursive && locChildren && locChildren.length !== 0){
+            for(i = 0, len = locChildren.length; i< len; i++){
+                locChildren[i]._renderCmd.transform(this, recursive);
+            }
+        }
+    };
+})();