ccb 0.0.1

data/lib/ccb/builder/templates/project/folder/frameworks/cocos2d-html5/cocos2d/core/base-nodes/CCNodeWebGLRenderCmd.js

@@ -0,0 +1,254 @@
+/****************************************************************************
+ 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 cc.Node's render command for WebGL ----------------------------------
+(function() {
+    cc.Node.WebGLRenderCmd = function (renderable) {
+        cc.Node.RenderCmd.call(this, renderable);
+
+        var mat4 = new cc.kmMat4();
+        mat4.mat[2] = mat4.mat[3] = mat4.mat[6] = mat4.mat[7] = mat4.mat[8] = mat4.mat[9] = mat4.mat[11] = mat4.mat[14] = 0.0;
+        mat4.mat[10] = mat4.mat[15] = 1.0;
+        this._transform4x4 = mat4;
+        this._stackMatrix = new cc.kmMat4();
+        this._shaderProgram = null;
+
+        this._camera = null;
+    };
+
+    var proto = cc.Node.WebGLRenderCmd.prototype = Object.create(cc.Node.RenderCmd.prototype);
+    proto.constructor = cc.Node.WebGLRenderCmd;
+
+    proto.getNodeToParentTransform = function () {
+        var node = this._node;
+        if (node._usingNormalizedPosition && node._parent) {        //TODO need refactor
+            var conSize = node._parent._contentSize;
+            node._position.x = node._normalizedPosition.x * conSize.width;
+            node._position.y = node._normalizedPosition.y * conSize.height;
+            node._normalizedPositionDirty = false;
+        }
+        if (this._dirtyFlag & cc.Node._dirtyFlags.transformDirty) {
+            // Translate values
+            var x = node._position.x, y = node._position.y;
+            var apx = this._anchorPointInPoints.x, napx = -apx;
+            var apy = this._anchorPointInPoints.y, napy = -apy;
+            var scx = node._scaleX, scy = node._scaleY;
+            var rotationRadiansX = node._rotationX * 0.017453292519943295;  //0.017453292519943295 = (Math.PI / 180);   for performance
+            var rotationRadiansY = node._rotationY * 0.017453292519943295;
+
+            if (node._ignoreAnchorPointForPosition) {
+                x += apx;
+                y += apy;
+            }
+
+            // Rotation values
+            // Change rotation code to handle X and Y
+            // If we skew with the exact same value for both x and y then we're simply just rotating
+            var cx = 1, sx = 0, cy = 1, sy = 0;
+            if (node._rotationX !== 0 || node._rotationY !== 0) {
+                cx = Math.cos(-rotationRadiansX);
+                sx = Math.sin(-rotationRadiansX);
+                cy = Math.cos(-rotationRadiansY);
+                sy = Math.sin(-rotationRadiansY);
+            }
+            var needsSkewMatrix = ( node._skewX || node._skewY );
+
+            // optimization:
+            // inline anchor point calculation if skew is not needed
+            // Adjusted transform calculation for rotational skew
+            if (!needsSkewMatrix && (apx !== 0 || apy !== 0)) {
+                x += cy * napx * scx + -sx * napy * scy;
+                y += sy * napx * scx + cx * napy * scy;
+            }
+
+            // Build Transform Matrix
+            // Adjusted transform calculation for rotational skew
+            var t = this._transform;
+            t.a = cy * scx;
+            t.b = sy * scx;
+            t.c = -sx * scy;
+            t.d = cx * scy;
+            t.tx = x;
+            t.ty = y;
+
+            // XXX: Try to inline skew
+            // If skew is needed, apply skew and then anchor point
+            if (needsSkewMatrix) {
+                t = cc.affineTransformConcat({a: 1.0, b: Math.tan(cc.degreesToRadians(node._skewY)),
+                    c: Math.tan(cc.degreesToRadians(node._skewX)), d: 1.0, tx: 0.0, ty: 0.0}, t);
+
+                // adjust anchor point
+                if (apx !== 0 || apy !== 0)
+                    t = cc.affineTransformTranslate(t, napx, napy);
+            }
+
+            if (node._additionalTransformDirty) {
+                t = cc.affineTransformConcat(t, node._additionalTransform);
+                node._additionalTransformDirty = false;
+            }
+            this._transform = t;
+        }
+        return this._transform;
+    };
+
+    proto._syncStatus = function (parentCmd) {
+        var flags = cc.Node._dirtyFlags, locFlag = this._dirtyFlag;
+        var parentNode = parentCmd ? parentCmd._node : null;
+
+        if(parentNode && parentNode._cascadeColorEnabled && (parentCmd._dirtyFlag & flags.colorDirty))
+            locFlag |= flags.colorDirty;
+
+        if(parentNode && parentNode._cascadeOpacityEnabled && (parentCmd._dirtyFlag & flags.opacityDirty))
+            locFlag |= flags.opacityDirty;
+
+        if(parentCmd && (parentCmd._dirtyFlag & flags.transformDirty))
+            locFlag |= flags.transformDirty;
+
+        var colorDirty = locFlag & flags.colorDirty,
+            opacityDirty = locFlag & flags.opacityDirty;
+
+        this._dirtyFlag = locFlag;
+
+        if (colorDirty)
+            this._syncDisplayColor();
+
+        if (opacityDirty)
+            this._syncDisplayOpacity();
+
+        if(colorDirty || opacityDirty)
+            this._updateColor();
+
+        //if (locFlag & flags.transformDirty) {      //need update the stackMatrix every calling visit, because when projection changed, need update all scene graph element.
+            //update the transform
+        this.transform(parentCmd);
+        //}
+    };
+
+    proto._updateColor = function(){};
+
+    proto.visit = function (parentCmd) {
+        var node = this._node;
+        // quick return if not visible
+        if (!node._visible)
+            return;
+
+        parentCmd = parentCmd || this.getParentRenderCmd();
+        if (node._parent && node._parent._renderCmd)
+            this._curLevel = node._parent._renderCmd._curLevel + 1;
+
+        var i, currentStack = cc.current_stack;
+
+        //optimize performance for javascript
+        currentStack.stack.push(currentStack.top);
+        this._syncStatus(parentCmd);
+        currentStack.top = this._stackMatrix;
+
+        var locChildren = node._children;
+        if (locChildren && locChildren.length > 0) {
+            var childLen = locChildren.length;
+            node.sortAllChildren();
+            // draw children zOrder < 0
+            for (i = 0; i < childLen; i++) {
+                if (locChildren[i] && locChildren[i]._localZOrder < 0)
+                    locChildren[i]._renderCmd.visit(this);
+                else
+                    break;
+            }
+
+            cc.renderer.pushRenderCommand(this);
+            // draw children zOrder >= 0
+            for (; i < childLen; i++) {
+                if (locChildren[i])
+                    locChildren[i]._renderCmd.visit(this);
+            }
+        } else
+            cc.renderer.pushRenderCommand(this);
+
+        this._dirtyFlag = 0;
+        //optimize performance for javascript
+        currentStack.top = currentStack.stack.pop();
+    };
+
+    proto.transform = function (parentCmd, recursive) {
+        var t4x4 = this._transform4x4, stackMatrix = this._stackMatrix, node = this._node;
+        parentCmd = parentCmd || this.getParentRenderCmd();
+        var parentMatrix = (parentCmd ? parentCmd._stackMatrix : cc.current_stack.top);
+
+        // Convert 3x3 into 4x4 matrix
+        var trans = this.getNodeToParentTransform();
+
+        this._dirtyFlag = this._dirtyFlag & cc.Node._dirtyFlags.transformDirty ^ this._dirtyFlag;
+
+        var t4x4Mat = t4x4.mat;
+        t4x4Mat[0] = trans.a;
+        t4x4Mat[4] = trans.c;
+        t4x4Mat[12] = trans.tx;
+        t4x4Mat[1] = trans.b;
+        t4x4Mat[5] = trans.d;
+        t4x4Mat[13] = trans.ty;
+
+        // Update Z vertex manually
+        t4x4Mat[14] = node._vertexZ;
+
+        //optimize performance for Javascript
+        cc.kmMat4Multiply(stackMatrix, parentMatrix, t4x4);
+
+        // XXX: Expensive calls. Camera should be integrated into the cached affine matrix
+        if (node._camera != null && !(node.grid != null && node.grid.isActive())) {
+            var apx = this._anchorPointInPoints.x, apy = this._anchorPointInPoints.y;
+            var translate = (apx !== 0.0 || apy !== 0.0);
+            if (translate){
+                if(!cc.SPRITEBATCHNODE_RENDER_SUBPIXEL) {
+                    apx = 0 | apx;
+                    apy = 0 | apy;
+                }
+                //cc.kmGLTranslatef(apx, apy, 0);
+                var translation = new cc.kmMat4();
+                cc.kmMat4Translation(translation, apx, apy, 0);
+                cc.kmMat4Multiply(stackMatrix, stackMatrix, translation);
+
+                node._camera._locateForRenderer(stackMatrix);
+
+                //cc.kmGLTranslatef(-apx, -apy, 0);
+                cc.kmMat4Translation(translation, -apx, -apy, 0);
+                cc.kmMat4Multiply(stackMatrix, stackMatrix, translation);
+            } else {
+                node._camera._locateForRenderer(stackMatrix);
+            }
+        }
+        if(!recursive || !node._children || node._children.length === 0)
+            return;
+        var i, len, locChildren = node._children;
+        for(i = 0, len = locChildren.length; i< len; i++){
+            locChildren[i]._renderCmd.transform(this, recursive);
+        }
+    };
+
+    proto.setShaderProgram = function (shaderProgram) {
+        this._shaderProgram = shaderProgram;
+    };
+
+    proto.getShaderProgram = function () {
+        return this._shaderProgram;
+    };
+})();

data/lib/ccb/builder/templates/project/folder/frameworks/cocos2d-html5/cocos2d/core/cocoa/CCAffineTransform.js

@@ -0,0 +1,259 @@
+/****************************************************************************
+ 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.AffineTransform class represent an affine transform matrix. It's composed basically by translation, rotation, scale transformations.<br/>
+ * Please do not use its constructor directly, use cc.affineTransformMake alias function instead.
+ * </p>
+ * @class cc.AffineTransform
+ * @param {Number} a
+ * @param {Number} b
+ * @param {Number} c
+ * @param {Number} d
+ * @param {Number} tx
+ * @param {Number} ty
+ * @see cc.affineTransformMake
+ */
+cc.AffineTransform = function (a, b, c, d, tx, ty) {
+    this.a = a;
+    this.b = b;
+    this.c = c;
+    this.d = d;
+    this.tx = tx;
+    this.ty = ty;
+};
+
+/**
+ * Create a cc.AffineTransform object with all contents in the matrix
+ * @function
+ * 
+ * @param {Number} a
+ * @param {Number} b
+ * @param {Number} c
+ * @param {Number} d
+ * @param {Number} tx
+ * @param {Number} ty
+ * @return {cc.AffineTransform}
+ */
+cc.affineTransformMake = function (a, b, c, d, tx, ty) {
+    return {a: a, b: b, c: c, d: d, tx: tx, ty: ty};
+};
+
+/**
+ * Apply the affine transformation on a point.
+ * @function
+ * 
+ * @param {cc.Point} point
+ * @param {cc.AffineTransform} t
+ * @return {cc.Point}
+ */
+cc.pointApplyAffineTransform = function (point, t) {
+    return {x: t.a * point.x + t.c * point.y + t.tx, y: t.b * point.x + t.d * point.y + t.ty};
+};
+
+cc._pointApplyAffineTransform = function (x, y, t) {
+    return {x: t.a * x + t.c * y + t.tx,
+        y: t.b * x + t.d * y + t.ty};
+};
+
+/**
+ * Apply the affine transformation on a size.
+ * @function
+ * 
+ * @param {cc.Size} size
+ * @param {cc.AffineTransform} t
+ * @return {cc.Size}
+ */
+cc.sizeApplyAffineTransform = function (size, t) {
+    return {width: t.a * size.width + t.c * size.height, height: t.b * size.width + t.d * size.height};
+};
+
+/**
+ * <p>Create a identity transformation matrix: <br/>
+ * [ 1, 0, 0, <br/>
+ *   0, 1, 0 ]</p>
+ * @function
+ * 
+ * @return {cc.AffineTransform}
+ */
+cc.affineTransformMakeIdentity = function () {
+    return {a: 1.0, b: 0.0, c: 0.0, d: 1.0, tx: 0.0, ty: 0.0};
+};
+
+/**
+ * <p>Create a identity transformation matrix: <br/>
+ * [ 1, 0, 0, <br/>
+ *   0, 1, 0 ]</p>
+ * @function
+ * 
+ * @return {cc.AffineTransform}
+ * @deprecated since v3.0, please use cc.affineTransformMakeIdentity() instead
+ * @see cc.affineTransformMakeIdentity
+ */
+cc.affineTransformIdentity = function () {
+    return {a: 1.0, b: 0.0, c: 0.0, d: 1.0, tx: 0.0, ty: 0.0};
+};
+
+/**
+ * Apply the affine transformation on a rect.
+ * @function
+ * 
+ * @param {cc.Rect} rect
+ * @param {cc.AffineTransform} anAffineTransform
+ * @return {cc.Rect}
+ */
+cc.rectApplyAffineTransform = function (rect, anAffineTransform) {
+    var top = cc.rectGetMinY(rect);
+    var left = cc.rectGetMinX(rect);
+    var right = cc.rectGetMaxX(rect);
+    var bottom = cc.rectGetMaxY(rect);
+
+    var topLeft = cc._pointApplyAffineTransform(left, top, anAffineTransform);
+    var topRight = cc._pointApplyAffineTransform(right, top, anAffineTransform);
+    var bottomLeft = cc._pointApplyAffineTransform(left, bottom, anAffineTransform);
+    var bottomRight = cc._pointApplyAffineTransform(right, bottom, anAffineTransform);
+
+    var minX = Math.min(topLeft.x, topRight.x, bottomLeft.x, bottomRight.x);
+    var maxX = Math.max(topLeft.x, topRight.x, bottomLeft.x, bottomRight.x);
+    var minY = Math.min(topLeft.y, topRight.y, bottomLeft.y, bottomRight.y);
+    var maxY = Math.max(topLeft.y, topRight.y, bottomLeft.y, bottomRight.y);
+
+    return cc.rect(minX, minY, (maxX - minX), (maxY - minY));
+};
+
+cc._rectApplyAffineTransformIn = function(rect, anAffineTransform){
+    var top = cc.rectGetMinY(rect);
+    var left = cc.rectGetMinX(rect);
+    var right = cc.rectGetMaxX(rect);
+    var bottom = cc.rectGetMaxY(rect);
+
+    var topLeft = cc._pointApplyAffineTransform(left, top, anAffineTransform);
+    var topRight = cc._pointApplyAffineTransform(right, top, anAffineTransform);
+    var bottomLeft = cc._pointApplyAffineTransform(left, bottom, anAffineTransform);
+    var bottomRight = cc._pointApplyAffineTransform(right, bottom, anAffineTransform);
+
+    var minX = Math.min(topLeft.x, topRight.x, bottomLeft.x, bottomRight.x);
+    var maxX = Math.max(topLeft.x, topRight.x, bottomLeft.x, bottomRight.x);
+    var minY = Math.min(topLeft.y, topRight.y, bottomLeft.y, bottomRight.y);
+    var maxY = Math.max(topLeft.y, topRight.y, bottomLeft.y, bottomRight.y);
+
+    rect.x = minX;
+    rect.y = minY;
+    rect.width = maxX - minX;
+    rect.height = maxY - minY;
+    return rect;
+};
+
+/**
+ * Create a new affine transformation with a base transformation matrix and a translation based on it.
+ * @function
+ * 
+ * @param {cc.AffineTransform} t The base affine transform object
+ * @param {Number} tx The translation on x axis
+ * @param {Number} ty The translation on y axis
+ * @return {cc.AffineTransform}
+ */
+cc.affineTransformTranslate = function (t, tx, ty) {
+    return {
+        a: t.a,
+        b: t.b,
+        c: t.c,
+        d: t.d,
+        tx: t.tx + t.a * tx + t.c * ty,
+        ty: t.ty + t.b * tx + t.d * ty
+    };
+};
+
+/**
+ * Create a new affine transformation with a base transformation matrix and a scale based on it.
+ * @function
+ * @param {cc.AffineTransform} t The base affine transform object
+ * @param {Number} sx The scale on x axis
+ * @param {Number} sy The scale on y axis
+ * @return {cc.AffineTransform}
+ */
+cc.affineTransformScale = function (t, sx, sy) {
+    return {a: t.a * sx, b: t.b * sx, c: t.c * sy, d: t.d * sy, tx: t.tx, ty: t.ty};
+};
+
+/**
+ * Create a new affine transformation with a base transformation matrix and a rotation based on it.
+ * @function
+ * @param {cc.AffineTransform} aTransform The base affine transform object
+ * @param {Number} anAngle  The angle to rotate
+ * @return {cc.AffineTransform}
+ */
+cc.affineTransformRotate = function (aTransform, anAngle) {
+    var fSin = Math.sin(anAngle);
+    var fCos = Math.cos(anAngle);
+
+    return {a: aTransform.a * fCos + aTransform.c * fSin,
+        b: aTransform.b * fCos + aTransform.d * fSin,
+        c: aTransform.c * fCos - aTransform.a * fSin,
+        d: aTransform.d * fCos - aTransform.b * fSin,
+        tx: aTransform.tx,
+        ty: aTransform.ty};
+};
+
+/**
+ * Concatenate a transform matrix to another and return the result:<br/>
+ * t' = t1 * t2
+ * @function
+ * @param {cc.AffineTransform} t1 The first transform object
+ * @param {cc.AffineTransform} t2 The transform object to concatenate
+ * @return {cc.AffineTransform} The result of concatenation
+ */
+cc.affineTransformConcat = function (t1, t2) {
+    return {a: t1.a * t2.a + t1.b * t2.c,                          //a
+        b: t1.a * t2.b + t1.b * t2.d,                               //b
+        c: t1.c * t2.a + t1.d * t2.c,                               //c
+        d: t1.c * t2.b + t1.d * t2.d,                               //d
+        tx: t1.tx * t2.a + t1.ty * t2.c + t2.tx,                    //tx
+        ty: t1.tx * t2.b + t1.ty * t2.d + t2.ty};				    //ty
+};
+
+/**
+ * Return true if an affine transform equals to another, false otherwise.
+ * @function
+ * @param {cc.AffineTransform} t1
+ * @param {cc.AffineTransform} t2
+ * @return {Boolean}
+ */
+cc.affineTransformEqualToTransform = function (t1, t2) {
+    return ((t1.a === t2.a) && (t1.b === t2.b) && (t1.c === t2.c) && (t1.d === t2.d) && (t1.tx === t2.tx) && (t1.ty === t2.ty));
+};
+
+/**
+ * Get the invert transform of an AffineTransform object
+ * @function
+ * @param {cc.AffineTransform} t
+ * @return {cc.AffineTransform} The inverted transform object
+ */
+cc.affineTransformInvert = function (t) {
+    var determinant = 1 / (t.a * t.d - t.b * t.c);
+    return {a: determinant * t.d, b: -determinant * t.b, c: -determinant * t.c, d: determinant * t.a,
+        tx: determinant * (t.c * t.ty - t.d * t.tx), ty: determinant * (t.b * t.tx - t.a * t.ty)};
+};