ccb 0.0.1

data/lib/ccb/builder/templates/project/folder/frameworks/cocos2d-html5/cocos2d/core/platform/CCVisibleRect.js

@@ -0,0 +1,100 @@
+/****************************************************************************
+ 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.
+ ****************************************************************************/
+
+/**
+ * cc.visibleRect is a singleton object which defines the actual visible rect of the current view,
+ * it should represent the same rect as cc.view.getViewportRect()
+ *
+ * @property {cc.Point}     topLeft         - Top left coordinate of the screen related to the game scene
+ * @property {cc.Point}     topRight        - Top right coordinate of the screen related to the game scene
+ * @property {cc.Point}     top             - Top center coordinate of the screen related to the game scene
+ * @property {cc.Point}     bottomLeft      - Bottom left coordinate of the screen related to the game scene
+ * @property {cc.Point}     bottomRight     - Bottom right coordinate of the screen related to the game scene
+ * @property {cc.Point}     bottom          - Bottom center coordinate of the screen related to the game scene
+ * @property {cc.Point}     center          - Center coordinate of the screen related to the game scene
+ * @property {cc.Point}     left            - Left center coordinate of the screen related to the game scene
+ * @property {cc.Point}     right           - Right center coordinate of the screen related to the game scene
+ * @property {Number}       width           - Width of the screen
+ * @property {Number}       height          - Height of the screen
+ *
+ * @class
+ * @name cc.visibleRect
+ */
+cc.visibleRect = {
+    topLeft:cc.p(0,0),
+    topRight:cc.p(0,0),
+    top:cc.p(0,0),
+    bottomLeft:cc.p(0,0),
+    bottomRight:cc.p(0,0),
+    bottom:cc.p(0,0),
+    center:cc.p(0,0),
+    left:cc.p(0,0),
+    right:cc.p(0,0),
+    width:0,
+    height:0,
+
+    /**
+     * initialize
+     * @param {cc.Rect} visibleRect
+     */
+    init:function(visibleRect){
+
+        var w = this.width = visibleRect.width;
+        var h = this.height = visibleRect.height;
+        var l = visibleRect.x,
+            b = visibleRect.y,
+            t = b + h,
+            r = l + w;
+
+        //top
+        this.topLeft.x = l;
+        this.topLeft.y = t;
+        this.topRight.x = r;
+        this.topRight.y = t;
+        this.top.x = l + w/2;
+        this.top.y = t;
+
+        //bottom
+        this.bottomLeft.x = l;
+        this.bottomLeft.y = b;
+        this.bottomRight.x = r;
+        this.bottomRight.y = b;
+        this.bottom.x = l + w/2;
+        this.bottom.y = b;
+
+        //center
+        this.center.x = l + w/2;
+        this.center.y = b + h/2;
+
+        //left
+        this.left.x = l;
+        this.left.y = b + h/2;
+
+        //right
+        this.right.x = r;
+        this.right.y = b + h/2;
+    }
+};

data/lib/ccb/builder/templates/project/folder/frameworks/cocos2d-html5/cocos2d/core/platform/miniFramework.js

@@ -0,0 +1,264 @@
+/****************************************************************************
+ 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.
+ ****************************************************************************/
+
+/**
+ * the dollar sign, classic like jquery, this selector add extra methods to HTMLElement without touching its prototype</br>
+ * it is also chainable like jquery
+ * @param {HTMLElement|String} x pass in a css selector in string or the whole HTMLElement
+ * @function
+ * @return {cc.$}
+ */
+cc.$ = function (x) {
+    /** @lends cc.$# */
+    var parent = (this == cc) ? document : this;
+
+    var el = (x instanceof HTMLElement) ? x : parent.querySelector(x);
+
+    if (el) {
+        /**
+         * find and return the child wth css selector (same as jquery.find)
+         * @lends cc.$#
+         * @function
+         * @param {HTMLElement|String} x pass in a css selector in string or the whole HTMLElement
+         * @return {cc.$}
+         */
+        el.find = el.find || cc.$;
+        /**
+         * check if a DOMNode has a specific class
+         * @lends cc.$#
+         * @function
+         * @param {String} cls
+         * @return {Boolean}
+         */
+        el.hasClass = el.hasClass || function (cls) {
+            return this.className.match(new RegExp('(\\s|^)' + cls + '(\\s|$)'));
+        };
+        /**
+         * add a class to a DOMNode, returns self to allow chaining
+         * @lends cc.$#
+         * @function
+         * @param {String} cls
+         * @return {cc.$}
+         */
+        el.addClass = el.addClass || function (cls) {
+            if (!this.hasClass(cls)) {
+                if (this.className) {
+                    this.className += " ";
+                }
+                this.className += cls;
+            }
+            return this;
+        };
+        /**
+         * remove a specific class from a DOMNode, returns self to allow chaining
+         * @lends cc.$#
+         * @function
+         * @param {String} cls
+         * @return {cc.$}
+         */
+        el.removeClass = el.removeClass || function (cls) {
+            if (this.hasClass(cls)) {
+                this.className = this.className.replace(cls, '');
+            }
+            return this;
+        };
+        /**
+         * detach it self from parent
+         * @lends cc.$#
+         * @function
+         */
+        el.remove = el.remove || function () {
+            if (this.parentNode)
+                this.parentNode.removeChild(this);
+            return this;
+        };
+
+        /**
+         * add to another element as a child
+         * @lends cc.$#
+         * @function
+         * @param {HTMLElement|cc.$} x
+         * @return {cc.$}
+         */
+        el.appendTo = el.appendTo || function (x) {
+            x.appendChild(this);
+            return this;
+        };
+
+        /**
+         * add to another element as a child and place on the top of the children list
+         * @lends cc.$#
+         * @function
+         * @param {HTMLElement|cc.$} x
+         * @return {cc.$}
+         */
+        el.prependTo = el.prependTo || function (x) {
+            ( x.childNodes[0]) ? x.insertBefore(this, x.childNodes[0]) : x.appendChild(this);
+            return this;
+        };
+
+        /**
+         * helper function for updating the css transform
+         * @lends cc.$#
+         * @function
+         * @return {cc.$}
+         */
+        el.transforms = el.transforms || function () {
+            this.style[cc.$.trans] = cc.$.translate(this.position) + cc.$.rotate(this.rotation) + cc.$.scale(this.scale) + cc.$.skew(this.skew);
+            return this;
+        };
+
+        el.position = el.position || {x: 0, y: 0};
+        el.rotation = el.rotation || 0;
+        el.scale = el.scale || {x: 1, y: 1};
+        el.skew = el.skew || {x: 0, y: 0};
+
+        /**
+         * move the element
+         * @memberOf cc.$#
+         * @name translates
+         * @function
+         * @param {Number} x in pixel
+         * @param {Number} y in pixel
+         * @return {cc.$}
+         */
+        el.translates = function (x, y) {
+            this.position.x = x;
+            this.position.y = y;
+            this.transforms();
+            return this
+        };
+
+        /**
+         * rotate the element
+         * @memberOf cc.$#
+         * @name rotate
+         * @function
+         * @param {Number} x in degrees
+         * @return {cc.$}
+         */
+        el.rotate = function (x) {
+            this.rotation = x;
+            this.transforms();
+            return this
+        };
+
+        /**
+         * resize the element
+         * @memberOf cc.$#
+         * @name resize
+         * @function
+         * @param {Number} x
+         * @param {Number} y
+         * @return {cc.$}
+         */
+        el.resize = function (x, y) {
+            this.scale.x = x;
+            this.scale.y = y;
+            this.transforms();
+            return this
+        };
+
+        /**
+         * skews the element
+         * @memberOf cc.$#
+         * @name setSkew
+         * @function
+         * @param {Number} x in degrees
+         * @param {Number} y
+         * @return {cc.$}
+         */
+        el.setSkew = function (x, y) {
+            this.skew.x = x;
+            this.skew.y = y;
+            this.transforms();
+            return this
+        };
+    }
+    return el;
+};
+//getting the prefix and css3 3d support
+switch (cc.sys.browserType) {
+    case cc.sys.BROWSER_TYPE_FIREFOX:
+        cc.$.pfx = "Moz";
+        cc.$.hd = true;
+        break;
+    case cc.sys.BROWSER_TYPE_CHROME:
+    case cc.sys.BROWSER_TYPE_SAFARI:
+        cc.$.pfx = "webkit";
+        cc.$.hd = true;
+        break;
+    case cc.sys.BROWSER_TYPE_OPERA:
+        cc.$.pfx = "O";
+        cc.$.hd = false;
+        break;
+    case cc.sys.BROWSER_TYPE_IE:
+        cc.$.pfx = "ms";
+        cc.$.hd = false;
+        break;
+    default:
+        cc.$.pfx = "webkit";
+        cc.$.hd = true;
+}
+//cache for prefixed transform
+cc.$.trans = cc.$.pfx + "Transform";
+//helper function for constructing transform strings
+cc.$.translate = (cc.$.hd) ? function (a) {
+    return "translate3d(" + a.x + "px, " + a.y + "px, 0) "
+} : function (a) {
+    return "translate(" + a.x + "px, " + a.y + "px) "
+};
+cc.$.rotate = (cc.$.hd) ? function (a) {
+    return "rotateZ(" + a + "deg) ";
+} : function (a) {
+    return "rotate(" + a + "deg) ";
+};
+cc.$.scale = function (a) {
+    return "scale(" + a.x + ", " + a.y + ") "
+};
+cc.$.skew = function (a) {
+    return "skewX(" + -a.x + "deg) skewY(" + a.y + "deg)";
+};
+
+
+/**
+ * Creates a new element, and adds cc.$ methods
+ * @param {String} x name of the element tag to create
+ * @return {cc.$}
+ */
+cc.$new = function (x) {
+    return cc.$(document.createElement(x))
+};
+cc.$.findpos = function (obj) {
+    var curleft = 0;
+    var curtop = 0;
+    do {
+        curleft += obj.offsetLeft;
+        curtop += obj.offsetTop;
+    } while (obj = obj.offsetParent);
+    return {x: curleft, y: curtop};
+};
+

data/lib/ccb/builder/templates/project/folder/frameworks/cocos2d-html5/cocos2d/core/renderer/RendererCanvas.js

@@ -0,0 +1,274 @@
+/****************************************************************************
+ 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.
+ ****************************************************************************/
+
+//if (cc._renderType === cc._RENDER_TYPE_CANVAS) {
+cc.rendererCanvas = {
+    childrenOrderDirty: true,
+    _transformNodePool: [],                              //save nodes transform dirty
+    _renderCmds: [],                                     //save renderer commands
+
+    _isCacheToCanvasOn: false,                          //a switch that whether cache the rendererCmd to cacheToCanvasCmds
+    _cacheToCanvasCmds: {},                              // an array saves the renderer commands need for cache to other canvas
+    _cacheInstanceIds: [],
+    _currentID: 0,
+
+    getRenderCmd: function (renderableObject) {
+        //TODO Add renderCmd pool here
+        return renderableObject._createRenderCmd();
+    },
+
+    /**
+     * drawing all renderer command to context (default is cc._renderContext)
+     * @param {cc.CanvasContextWrapper} [ctx=cc._renderContext]
+     */
+    rendering: function (ctx) {
+        var locCmds = this._renderCmds, i, len,
+            scaleX = cc.view.getScaleX(),
+            scaleY = cc.view.getScaleY();
+        var context = ctx || cc._renderContext;
+        context.computeRealOffsetY();
+        for (i = 0, len = locCmds.length; i < len; i++) {
+            locCmds[i].rendering(context, scaleX, scaleY);
+        }
+    },
+
+    /**
+     * drawing all renderer command to cache canvas' context
+     * @param {cc.CanvasContextWrapper} ctx
+     * @param {Number} [instanceID]
+     * @param {Number} [scaleX]
+     * @param {Number} [scaleY]
+     */
+    _renderingToCacheCanvas: function (ctx, instanceID, scaleX, scaleY) {
+        if (!ctx)
+            cc.log("The context of RenderTexture is invalid.");
+        scaleX = cc.isUndefined(scaleX) ? 1 : scaleX;
+        scaleY = cc.isUndefined(scaleY) ? 1 : scaleY;
+        instanceID = instanceID || this._currentID;
+        var locCmds = this._cacheToCanvasCmds[instanceID], i, len;
+        ctx.computeRealOffsetY();
+        for (i = 0, len = locCmds.length; i < len; i++) {
+            locCmds[i].rendering(ctx, scaleX, scaleY);
+        }
+        locCmds.length = 0;
+        var locIDs = this._cacheInstanceIds;
+        delete this._cacheToCanvasCmds[instanceID];
+        cc.arrayRemoveObject(locIDs, instanceID);
+
+        if (locIDs.length === 0)
+            this._isCacheToCanvasOn = false;
+        else
+            this._currentID = locIDs[locIDs.length - 1];
+    },
+
+    _turnToCacheMode: function (renderTextureID) {
+        this._isCacheToCanvasOn = true;
+        renderTextureID = renderTextureID || 0;
+        this._cacheToCanvasCmds[renderTextureID] = [];
+        if(this._cacheInstanceIds.indexOf(renderTextureID) === -1)
+            this._cacheInstanceIds.push(renderTextureID);
+        this._currentID = renderTextureID;
+    },
+
+    _turnToNormalMode: function () {
+        this._isCacheToCanvasOn = false;
+    },
+
+    resetFlag: function () {
+        this.childrenOrderDirty = false;
+        this._transformNodePool.length = 0;
+    },
+
+    transform: function () {
+        var locPool = this._transformNodePool;
+        //sort the pool
+        locPool.sort(this._sortNodeByLevelAsc);
+
+        //transform node
+        for (var i = 0, len = locPool.length; i < len; i++) {
+            if (locPool[i]._dirtyFlag !== 0)
+                locPool[i].updateStatus();
+        }
+        locPool.length = 0;
+    },
+
+    transformDirty: function () {
+        return this._transformNodePool.length > 0;
+    },
+
+    _sortNodeByLevelAsc: function (n1, n2) {
+        return n1._curLevel - n2._curLevel;
+    },
+
+    pushDirtyNode: function (node) {
+        this._transformNodePool.push(node);
+    },
+
+    clearRenderCommands: function () {
+        this._renderCmds.length = 0;
+    },
+
+    pushRenderCommand: function (cmd) {
+        if(!cmd._needDraw)
+            return;
+        if (this._isCacheToCanvasOn) {
+            var currentId = this._currentID, locCmdBuffer = this._cacheToCanvasCmds;
+            var cmdList = locCmdBuffer[currentId];
+            if (cmdList.indexOf(cmd) === -1)
+                cmdList.push(cmd);
+        } else {
+            if (this._renderCmds.indexOf(cmd) === -1)
+                this._renderCmds.push(cmd);
+        }
+    }
+};
+
+if (cc._renderType === cc._RENDER_TYPE_CANVAS)
+    cc.renderer = cc.rendererCanvas;
+
+(function () {
+    cc.CanvasContextWrapper = function (context) {
+        this._context = context;
+
+        this._saveCount = 0;
+        this._currentAlpha = context.globalAlpha;
+        this._currentCompositeOperation = context.globalCompositeOperation;
+        this._currentFillStyle = context.fillStyle;
+        this._currentStrokeStyle = context.strokeStyle;
+
+        this._offsetX = 0;
+        this._offsetY = 0;
+        this._realOffsetY = this.height;
+        this._armatureMode = 0;
+    };
+
+    var proto = cc.CanvasContextWrapper.prototype;
+
+    proto.resetCache = function(){
+        var context = this._context;
+        //call it after resize cc._canvas, because context will reset.
+        this._currentAlpha = context.globalAlpha;
+        this._currentCompositeOperation = context.globalCompositeOperation;
+        this._currentFillStyle = context.fillStyle;
+        this._currentStrokeStyle = context.strokeStyle;
+        this._realOffsetY = this._context.canvas.height + this._offsetY;
+    };
+
+    proto.setOffset = function(x, y){
+        this._offsetX = x;
+        this._offsetY = y;
+        this._realOffsetY = this._context.canvas.height + this._offsetY;
+    };
+
+    proto.computeRealOffsetY = function(){
+        this._realOffsetY = this._context.canvas.height + this._offsetY;
+    };
+
+    proto.setViewScale = function(scaleX, scaleY){
+        //call it at cc.renderCanvas.rendering
+        this._scaleX = scaleX;
+        this._scaleY = scaleY;
+    };
+
+    proto.getContext = function(){
+        return this._context;
+    };
+
+    proto.save = function () {
+        this._context.save();
+        this._saveCount++;
+    };
+
+    proto.restore = function () {
+        this._context.restore();
+        this._saveCount--;
+    };
+
+    proto.setGlobalAlpha = function (alpha) {
+        if (this._saveCount > 0) {
+            this._context.globalAlpha = alpha;
+        } else {
+            if (this._currentAlpha !== alpha) {
+                this._currentAlpha = alpha;
+                this._context.globalAlpha = alpha;
+            }
+        }
+    };
+
+    proto.setCompositeOperation = function(compositionOperation){
+        if (this._saveCount > 0) {
+            this._context.globalCompositeOperation = compositionOperation;
+        } else {
+            if (this._currentCompositeOperation !== compositionOperation) {
+                this._currentCompositeOperation = compositionOperation;
+                this._context.globalCompositeOperation = compositionOperation;
+            }
+        }
+    };
+
+    proto.setFillStyle = function(fillStyle){
+        if (this._saveCount > 0) {
+            this._context.fillStyle = fillStyle;
+        } else {
+            if (this._currentFillStyle !== fillStyle) {
+                this._currentFillStyle = fillStyle;
+                this._context.fillStyle = fillStyle;
+            }
+        }
+    };
+
+    proto.setStrokeStyle = function(strokeStyle){
+        if (this._saveCount > 0) {
+            this._context.strokeStyle = strokeStyle;
+        } else {
+            if (this._currentStrokeStyle !== strokeStyle) {
+                this._currentStrokeStyle = strokeStyle;
+                this._context.strokeStyle = strokeStyle;
+            }
+        }
+    };
+
+    proto.setTransform = function(t, scaleX, scaleY){
+        if (this._armatureMode > 0) {
+            //ugly for armature
+            this.restore();
+            this.save();
+            this._context.transform(t.a, t.c, t.b, t.d, t.tx * scaleX, -(t.ty * scaleY));
+        } else {
+            this._context.setTransform(t.a, t.c, t.b, t.d, this._offsetX + t.tx * scaleX, this._realOffsetY - (t.ty * scaleY));
+        }
+    };
+
+    proto._switchToArmatureMode = function(enable, t, scaleX, scaleY){
+        if(enable){
+            this._armatureMode++;
+            this._context.setTransform(t.a, t.c, t.b, t.d, this._offsetX + t.tx * scaleX, this._realOffsetY - (t.ty * scaleY));
+            this.save();
+        }else{
+            this._armatureMode--;
+            this.restore();
+        }
+    };
+})();
+