ccb 0.0.1

data/lib/ccb/builder/templates/project/folder/frameworks/cocos2d-html5/cocos2d/tilemap/CCTMXLayerCanvasRenderCmd.js

@@ -0,0 +1,232 @@
+/****************************************************************************
+ 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.TMXLayer.CanvasRenderCmd = function(renderable){
+        cc.SpriteBatchNode.CanvasRenderCmd.call(this, renderable);
+        this._needDraw = true;
+        this._realWorldTransform = {a: 1, b: 0, c: 0, d: 1, tx: 0, ty: 0};
+        this._childrenRenderCmds = [];
+
+        var locCanvas = cc._canvas;
+        var tmpCanvas = cc.newElement('canvas');
+        tmpCanvas.width = locCanvas.width;
+        tmpCanvas.height = locCanvas.height;
+        this._cacheCanvas = tmpCanvas;
+        this._cacheContext = new cc.CanvasContextWrapper(this._cacheCanvas.getContext('2d'));
+        var tempTexture = new cc.Texture2D();
+        tempTexture.initWithElement(tmpCanvas);
+        tempTexture.handleLoadedTexture();
+        this._cacheTexture = tempTexture;
+        // This class uses cache, so its default cachedParent should be himself
+        this._cacheDirty = false;
+    };
+
+    var proto = cc.TMXLayer.CanvasRenderCmd.prototype = Object.create(cc.SpriteBatchNode.CanvasRenderCmd.prototype);
+    proto.constructor = cc.TMXLayer.CanvasRenderCmd;
+
+    proto._copyRendererCmds = function (rendererCmds) {
+        if (!rendererCmds)
+            return;
+
+        var locCacheCmds = this._childrenRenderCmds;
+        locCacheCmds.length = 0;
+        for (var i = 0, len = rendererCmds.length; i < len; i++) {
+            locCacheCmds[i] = rendererCmds[i];
+        }
+    };
+
+    //set the cache dirty flag for canvas
+    proto._setNodeDirtyForCache = function () {
+        this._cacheDirty  = true;
+    };
+
+    proto._renderingChildToCache = function (scaleX, scaleY) {
+        if (this._cacheDirty) {
+            var locCacheCmds = this._childrenRenderCmds, wrapper = this._cacheContext,
+                context = wrapper.getContext(), locCanvas = this._cacheCanvas;
+
+            //wrapper.save();
+            context.setTransform(1, 0, 0, 1, 0, 0);
+            context.clearRect(0, 0, locCanvas.width, locCanvas.height);
+            //reset the cache context
+
+            for (var i = 0, len = locCacheCmds.length; i < len; i++) {
+                locCacheCmds[i].rendering(wrapper, scaleX, scaleY);
+                locCacheCmds[i]._cacheDirty = false;
+            }
+            //wrapper.restore();
+            this._cacheDirty = false;
+        }
+    };
+
+    proto.rendering = function (ctx, scaleX, scaleY) {
+        var alpha = this._displayedOpacity / 255;
+        if (alpha <= 0)
+            return;
+
+        var node = this._node;
+        this._renderingChildToCache(scaleX, scaleY);
+        var wrapper = ctx || cc._renderContext, context = wrapper.getContext();
+        wrapper.setGlobalAlpha(alpha);
+
+        var posX = 0 | ( -this._anchorPointInPoints.x), posY = 0 | ( -this._anchorPointInPoints.y);
+        var locCacheCanvas = this._cacheCanvas;
+        //direct draw image by canvas drawImage
+        if (locCacheCanvas && locCacheCanvas.width !== 0 && locCacheCanvas.height !== 0) {
+            wrapper.setTransform(this._realWorldTransform, scaleX, scaleY);
+            var locCanvasHeight = locCacheCanvas.height * scaleY;
+            if (node.layerOrientation === cc.TMX_ORIENTATION_HEX) {
+                var halfTileSize = node._mapTileSize.height * 0.5 * scaleY;
+                context.drawImage(locCacheCanvas, 0, 0, locCacheCanvas.width, locCacheCanvas.height,
+                    posX, -(posY + locCanvasHeight) + halfTileSize, locCacheCanvas.width * scaleX, locCanvasHeight);
+            } else {
+                context.drawImage(locCacheCanvas, 0, 0, locCacheCanvas.width, locCacheCanvas.height,
+                    posX, -(posY + locCanvasHeight), locCacheCanvas.width * scaleX, locCanvasHeight);
+            }
+        }
+        cc.g_NumberOfDraws++;
+    };
+
+    proto._updateCacheContext = function(size, height){
+        var node = this._node,
+            locContentSize = node._contentSize,
+            locCanvas = this._cacheCanvas,
+            scaleFactor = cc.contentScaleFactor();
+        locCanvas.width = 0 | (locContentSize.width * 1.5 * scaleFactor);
+        locCanvas.height = 0 | (locContentSize.height * 1.5 * scaleFactor);
+
+        //todo: need change the wrapper's height
+        if(node.layerOrientation === cc.TMX_ORIENTATION_HEX)
+            this._cacheContext.setOffset(0, -node._mapTileSize.height * 0.5);                  //translate for hexagonal
+        else
+            this._cacheContext.setOffset(0, 0);
+        var locTexContentSize = this._cacheTexture._contentSize;
+        locTexContentSize.width = locCanvas.width;
+        locTexContentSize.height = locCanvas.height;
+    };
+
+    proto.getTexture = function(){
+        return this._cacheTexture;
+    };
+
+    proto.visit = function(parentCmd){
+        var node = this._node;
+        //TODO: it will implement dynamic compute child cutting automation.
+        var i, len, locChildren = node._children;
+        // quick return if not visible
+        if (!node._visible || !locChildren || locChildren.length === 0)
+            return;
+
+        parentCmd = parentCmd || this.getParentRenderCmd();
+        if (parentCmd)
+            this._curLevel = parentCmd._curLevel + 1;
+
+        this._syncStatus(parentCmd);
+        if (this._cacheDirty) {
+            var wrapper = this._cacheContext, locCanvas = this._cacheCanvas, context = wrapper.getContext(),
+                instanceID = node.__instanceId, renderer = cc.renderer;
+            //begin cache
+            renderer._turnToCacheMode(instanceID);
+
+           node.sortAllChildren();
+            for (i = 0, len =  locChildren.length; i < len; i++) {
+               if (locChildren[i]){
+                  var selCmd = locChildren[i]._renderCmd;
+                    if(selCmd){
+                        selCmd.visit(this);
+                        selCmd._cacheDirty = false;
+                    }
+                }
+           }
+
+            //copy cached render cmd array to TMXLayer renderer
+            this._copyRendererCmds(renderer._cacheToCanvasCmds[instanceID]);
+
+            //wrapper.save();
+            context.setTransform(1, 0, 0, 1, 0, 0);
+            context.clearRect(0, 0, locCanvas.width, locCanvas.height);
+            //set the wrapper's offset
+
+            //draw to cache canvas
+            renderer._renderingToCacheCanvas(wrapper, instanceID);
+            //wrapper.restore();                           //todo: it can be reserve.
+            this._cacheDirty = false
+        }
+        cc.renderer.pushRenderCommand(this);
+        this._dirtyFlag = 0;
+    };
+
+    proto.transform = function (parentCmd, recursive) {
+        // transform for canvas
+        var t = this.getNodeToParentTransform(),
+            worldT = this._realWorldTransform;         //get the world transform
+
+        if (parentCmd) {
+            var pt = parentCmd._worldTransform;
+            // cc.AffineTransformConcat is incorrect at get world transform
+            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
+
+            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.a = t.a;
+            worldT.b = t.b;
+            worldT.c = t.c;
+            worldT.d = t.d;
+            worldT.tx = t.tx;
+            worldT.ty = t.ty;
+        }
+        if (recursive) {
+            var locChildren = this._node._children;
+            if (!locChildren || locChildren.length === 0)
+                return;
+            var i, len;
+            for (i = 0, len = locChildren.length; i < len; i++) {
+                locChildren[i]._renderCmd.transform(this, recursive);
+            }
+        }
+    };
+
+    proto.initImageSize = function(){
+        var node = this._node;
+        node.tileset.imageSize = this._originalTexture.getContentSizeInPixels();
+    };
+
+    proto._reusedTileWithRect = function(rect){
+        var node = this._node;
+        node._reusedTile = new cc.Sprite();
+        node._reusedTile.initWithTexture(node._renderCmd._texture, rect, false);
+        node._reusedTile.batchNode = node;
+        node._reusedTile.parent = node;
+        node._reusedTile._renderCmd._cachedParent = node._renderCmd;
+        return node._reusedTile;
+    };
+})();

data/lib/ccb/builder/templates/project/folder/frameworks/cocos2d-html5/cocos2d/tilemap/CCTMXLayerWebGLRenderCmd.js

@@ -0,0 +1,67 @@
+/****************************************************************************
+ 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.TMXLayer.WebGLRenderCmd = function(renderableObject){
+        cc.SpriteBatchNode.WebGLRenderCmd.call(this, renderableObject);
+        this._needDraw = true;
+    };
+
+    var proto = cc.TMXLayer.WebGLRenderCmd.prototype = Object.create(cc.SpriteBatchNode.WebGLRenderCmd.prototype);
+    proto.constructor = cc.TMXLayer.WebGLRenderCmd;
+
+    proto._updateCacheContext = function(){};
+
+    proto.initImageSize = function(){
+        var node = this._node;
+        node.tileset.imageSize = this._textureAtlas.texture.getContentSizeInPixels();
+
+        // By default all the tiles are aliased
+        // pros:
+        //  - easier to render
+        // cons:
+        //  - difficult to scale / rotate / etc.
+        this._textureAtlas.texture.setAliasTexParameters();
+    };
+
+    proto._reusedTileWithRect = function(rect){
+        var node = this._node;
+        if (!node._reusedTile) {
+            node._reusedTile = new cc.Sprite();
+            node._reusedTile.initWithTexture(node.texture, rect, false);
+            node._reusedTile.batchNode = node;
+        } else {
+            // XXX HACK: Needed because if "batch node" is nil,
+            // then the Sprite'squad will be reset
+            node._reusedTile.batchNode = null;
+
+            // Re-init the sprite
+            node._reusedTile.setTextureRect(rect, false);
+
+            // restore the batch node
+            node._reusedTile.batchNode = node;
+        }
+        return node._reusedTile;
+    };
+})();

data/lib/ccb/builder/templates/project/folder/frameworks/cocos2d-html5/cocos2d/tilemap/CCTMXObjectGroup.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.
+ ****************************************************************************/
+
+/**
+ * cc.TMXObjectGroup represents the TMX object group.
+ * @class
+ * @extends cc.Class
+ *
+ * @property {Array}    properties  - Properties from the group. They can be added using tilemap editors
+ * @property {String}   groupName   - Name of the group
+ */
+cc.TMXObjectGroup = cc.Class.extend(/** @lends cc.TMXObjectGroup# */{
+	properties: null,
+    groupName: "",
+
+    _positionOffset: null,
+    _objects: null,
+
+    /**
+     * <p>The cc.TMXObjectGroup's constructor. <br/>
+     * This function will automatically be invoked when you create a node using new construction: "var node = new cc.TMXObjectGroup()".<br/>
+     * Override it to extend its behavior, remember to call "this._super()" in the extended "ctor" function.</p>
+     */
+    ctor:function () {
+        this.groupName = "";
+        this._positionOffset = cc.p(0,0);
+        this.properties = [];
+        this._objects = [];
+    },
+
+    /**
+     * Offset position of child objects
+     * @return {cc.Point}
+     */
+    getPositionOffset:function () {
+        return cc.p(this._positionOffset);
+    },
+
+    /**
+     * Offset position of child objects
+     * @param {cc.Point} offset
+     */
+    setPositionOffset:function (offset) {
+        this._positionOffset.x = offset.x;
+        this._positionOffset.y = offset.y;
+    },
+
+    /**
+     * List of properties stored in a dictionary
+     * @return {Array}
+     */
+    getProperties:function () {
+        return this.properties;
+    },
+
+    /**
+     * List of properties stored in a dictionary
+     * @param {object} Var
+     */
+    setProperties:function (Var) {
+        this.properties.push(Var);
+    },
+
+    /**
+     * Gets the Group name.
+     * @return {String}
+     */
+    getGroupName:function () {
+        return this.groupName.toString();
+    },
+
+    /**
+     * Set the Group name
+     * @param {String} groupName
+     */
+    setGroupName:function (groupName) {
+        this.groupName = groupName;
+    },
+
+    /**
+     * Return the value for the specific property name
+     * @param {String} propertyName
+     * @return {object}
+     */
+    propertyNamed:function (propertyName) {
+        return this.properties[propertyName];
+    },
+
+    /**
+     * <p>Return the dictionary for the specific object name. <br />
+     * It will return the 1st object found on the array for the given name.</p>
+     * @param {String} objectName
+     * @return {object|Null}
+     */
+    objectNamed:function (objectName) {
+        if (this._objects && this._objects.length > 0) {
+            var locObjects = this._objects;
+            for (var i = 0, len = locObjects.length; i < len; i++) {
+                var name = locObjects[i]["name"];
+                if (name && name == objectName)
+                    return locObjects[i];
+            }
+        }
+        // object not found
+        return null;
+    },
+
+    /**
+     * Gets the objects.
+     * @return {Array}
+     */
+    getObjects:function () {
+        return this._objects;
+    },
+
+    /**
+     * Set the objects.
+     * @param {object} objects
+     */
+    setObjects:function (objects) {
+        this._objects.push(objects);
+    }
+});