ccb 0.0.1

data/lib/ccb/builder/templates/project/folder/frameworks/cocos2d-html5/cocos2d/actions3d/CCActionGrid3D.js

@@ -0,0 +1,1257 @@
+/****************************************************************************
+ 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.Waves3D action. <br />
+ * Reference the test cases (Effects Advanced Test)
+ * @class
+ * @extends cc.Grid3DAction
+ * @param {Number} duration
+ * @param {cc.Size} gridSize
+ * @param {Number} waves
+ * @param {Number} amplitude
+ */
+cc.Waves3D = cc.Grid3DAction.extend(/** @lends cc.Waves3D# */{
+    _waves: 0,
+    _amplitude: 0,
+    _amplitudeRate: 0,
+
+	/**
+     * Constructor function, override it to extend the construction behavior, remember to call "this._super()" in the extended "ctor" function. <br />
+	 * Create a wave 3d action with duration, grid size, waves and amplitude.
+	 * @param {Number} duration
+	 * @param {cc.Size} gridSize
+	 * @param {Number} waves
+	 * @param {Number} amplitude
+	 */
+    ctor:function (duration, gridSize, waves, amplitude) {
+        cc.GridAction.prototype.ctor.call(this);
+		amplitude !== undefined && this.initWithDuration(duration, gridSize, waves, amplitude);
+    },
+
+    /**
+     * get Amplitude
+     * @return {Number}
+     */
+    getAmplitude:function () {
+        return this._amplitude;
+    },
+
+    /**
+     * set Amplitude
+     * @param {Number} amplitude
+     */
+    setAmplitude:function (amplitude) {
+        this._amplitude = amplitude;
+    },
+
+    /**
+     * get Amplitude Rate
+     * @return {Number}
+     */
+    getAmplitudeRate:function () {
+        return this._amplitudeRate;
+    },
+
+    /**
+     * set Amplitude Rate
+     * @param {Number} amplitudeRate
+     */
+    setAmplitudeRate:function (amplitudeRate) {
+        this._amplitudeRate = amplitudeRate;
+    },
+
+    /**
+     * initializes an action with duration, grid size, waves and amplitude
+     * @param {Number} duration
+     * @param {cc.Size} gridSize
+     * @param {Number} waves
+     * @param {Number} amplitude
+     * @return {Boolean}
+     */
+    initWithDuration:function (duration, gridSize, waves, amplitude) {
+        if (cc.Grid3DAction.prototype.initWithDuration.call(this, duration, gridSize)) {
+            this._waves = waves;
+            this._amplitude = amplitude;
+            this._amplitudeRate = 1.0;
+            return true;
+        }
+        return false;
+    },
+
+    /**
+     * Called once per frame. Time is the number of seconds of a frame interval.
+     *
+     * @param {Number}  dt
+     */
+    update:function (dt) {
+        var locGridSize = this._gridSize;
+        var locAmplitude = this._amplitude, locPos = cc.p(0, 0);
+        var locAmplitudeRate = this._amplitudeRate, locWaves = this._waves;
+        for (var i = 0; i < locGridSize.width + 1; ++i) {
+            for (var j = 0; j < locGridSize.height + 1; ++j) {
+                locPos.x = i;
+                locPos.y = j;
+                var v = this.originalVertex(locPos);
+                v.z += (Math.sin(Math.PI * dt * locWaves * 2 + (v.y + v.x) * 0.01) * locAmplitude * locAmplitudeRate);
+                //cc.log("v.z offset is" + (Math.sin(Math.PI * dt * this._waves * 2 + (v.y + v.x) * 0.01) * this._amplitude * this._amplitudeRate));
+                this.setVertex(locPos, v);
+            }
+        }
+    }
+});
+
+/**
+ * Create a wave 3d action with duration, grid size, waves and amplitude.
+ * @function
+ * @param {Number} duration
+ * @param {cc.Size} gridSize
+ * @param {Number} waves
+ * @param {Number} amplitude
+ */
+cc.waves3D = function (duration, gridSize, waves, amplitude) {
+    return new cc.Waves3D(duration, gridSize, waves, amplitude);
+};
+/**
+ * Please use cc.waves3D instead. <br />
+ * Create a wave 3d action with duration, grid size, waves and amplitude.
+ * @param {Number} duration
+ * @param {cc.Size} gridSize
+ * @param {Number} waves
+ * @param {Number} amplitude
+ * @static
+ * @deprecated since v3.0 <br /> Please use cc.waves3D instead.
+ */
+cc.Waves3D.create = cc.waves3D;
+
+/**
+ * cc.FlipX3D action. <br />
+ * Flip around. <br />
+ * Reference the test cases (Effects Test)
+ * @class
+ * @extends cc.Grid3DAction
+ * @param {Number} duration
+ */
+cc.FlipX3D = cc.Grid3DAction.extend(/** @lends cc.FlipX3D# */{
+
+	/**
+     * Constructor function, override it to extend the construction behavior, remember to call "this._super()" in the extended "ctor" function. <br />
+	 * Create a Flip X 3D action with duration.
+	 * @param {Number} duration
+	 */
+	ctor: function(duration) {
+		if (duration !== undefined)
+			cc.GridAction.prototype.ctor.call(this, duration, cc.size(1, 1));
+		else cc.GridAction.prototype.ctor.call(this);
+	},
+
+    /**
+     * initializes the action with duration
+     * @param {Number} duration
+     * @return {Boolean}
+     */
+    initWithDuration:function (duration) {
+        return cc.Grid3DAction.prototype.initWithDuration.call(this, duration, cc.size(1, 1));
+    },
+
+    /**
+     * initializes the action with gridSize and duration
+     * @param {cc.Size} gridSize
+     * @param {Number} duration
+     * @return {Boolean}
+     */
+    initWithSize:function (gridSize, duration) {
+        if (gridSize.width != 1 || gridSize.height != 1) {
+            // Grid size must be (1,1)
+            cc.log("Grid size must be (1,1)");
+            return false;
+        }
+        return  cc.Grid3DAction.prototype.initWithDuration.call(this, duration, gridSize);
+    },
+
+    /**
+     * Called once per frame. Time is the number of seconds of a frame interval.
+     *
+     * @param {Number}  dt
+     */
+    update:function (dt) {
+        var angle = Math.PI * dt; // 180 degrees
+        var mz = Math.sin(angle);
+        angle = angle / 2.0; // x calculates degrees from 0 to 90
+        var mx = Math.cos(angle);
+
+        var diff = new cc.Vertex3F();
+        var tempVer = cc.p(0, 0);
+        tempVer.x = tempVer.y = 1;
+        var v0 = this.originalVertex(tempVer);
+        tempVer.x = tempVer.y = 0;
+        var v1 = this.originalVertex(tempVer);
+
+        var x0 = v0.x;
+        var x1 = v1.x;
+        var x;
+        var a, b, c, d;
+
+        if (x0 > x1) {
+            // Normal Grid
+            a = cc.p(0, 0);
+            b = cc.p(0, 1);
+            c = cc.p(1, 0);
+            d = cc.p(1, 1);
+            x = x0;
+        } else {
+            // Reversed Grid
+            c = cc.p(0, 0);
+            d = cc.p(0, 1);
+            a = cc.p(1, 0);
+            b = cc.p(1, 1);
+            x = x1;
+        }
+
+        diff.x = ( x - x * mx );
+        diff.z = Math.abs(parseFloat((x * mz) / 4.0));
+
+        // bottom-left
+        var v = this.originalVertex(a);
+        v.x = diff.x;
+        v.z += diff.z;
+        this.setVertex(a, v);
+
+        // upper-left
+        v = this.originalVertex(b);
+        v.x = diff.x;
+        v.z += diff.z;
+        this.setVertex(b, v);
+
+        // bottom-right
+        v = this.originalVertex(c);
+        v.x -= diff.x;
+        v.z -= diff.z;
+        this.setVertex(c, v);
+
+        // upper-right
+        v = this.originalVertex(d);
+        v.x -= diff.x;
+        v.z -= diff.z;
+        this.setVertex(d, v);
+    }
+});
+
+/**
+ * Create a Flip X 3D action with duration. <br />
+ * Flip around.
+ * @function
+ * @param {Number} duration
+ * @return {cc.FlipX3D}
+ */
+cc.flipX3D = function (duration) {
+    return new cc.FlipX3D(duration);
+};
+
+/**
+ * Please use cc.flipX3D instead. <br />
+ * Create a Flip X 3D action with duration. <br />
+ * Flip around.
+ * @param {Number} duration
+ * @return {cc.FlipX3D}
+ * @static
+ * @deprecated since v3.0 <br /> Please use cc.flipX3D instead.
+ */
+cc.FlipX3D.create = cc.flipX3D;
+
+/**
+ * cc.FlipY3D action. <br />
+ * Upside down. <br />
+ * Reference the test cases (Effects Test)
+ * @class
+ * @extends cc.FlipX3D
+ * @param {Number} duration
+ */
+cc.FlipY3D = cc.FlipX3D.extend(/** @lends cc.FlipY3D# */{
+
+	/**
+     * Constructor function, override it to extend the construction behavior, remember to call "this._super()" in the extended "ctor" function. <br />
+	 * Create a flip Y 3d action with duration.
+	 * @param {Number} duration
+	 */
+	ctor: function(duration) {
+		if (duration !== undefined)
+			cc.GridAction.prototype.ctor.call(this, duration, cc.size(1, 1));
+		else cc.GridAction.prototype.ctor.call(this);
+	},
+
+    /**
+     * Called once per frame. Time is the number of seconds of a frame interval.
+     *
+     * @param {Number}  dt
+     */
+    update:function (dt) {
+        var angle = Math.PI * dt; // 180 degrees
+        var mz = Math.sin(angle);
+        angle = angle / 2.0;     // x calculates degrees from 0 to 90
+        var my = Math.cos(angle);
+
+        var diff = new cc.Vertex3F();
+
+        var tempP = cc.p(0, 0);
+        tempP.x = tempP.y = 1;
+        var v0 = this.originalVertex(tempP);
+        tempP.x = tempP.y = 0;
+        var v1 = this.originalVertex(tempP);
+
+        var y0 = v0.y;
+        var y1 = v1.y;
+        var y;
+        var a, b, c, d;
+
+        if (y0 > y1) {
+            // Normal Grid
+            a = cc.p(0, 0);
+            b = cc.p(0, 1);
+            c = cc.p(1, 0);
+            d = cc.p(1, 1);
+            y = y0;
+        } else {
+            // Reversed Grid
+            b = cc.p(0, 0);
+            a = cc.p(0, 1);
+            d = cc.p(1, 0);
+            c = cc.p(1, 1);
+            y = y1;
+        }
+
+        diff.y = y - y * my;
+        diff.z = Math.abs(parseFloat(y * mz) / 4.0);
+
+        // bottom-left
+        var v = this.originalVertex(a);
+        v.y = diff.y;
+        v.z += diff.z;
+        this.setVertex(a, v);
+
+        // upper-left
+        v = this.originalVertex(b);
+        v.y -= diff.y;
+        v.z -= diff.z;
+        this.setVertex(b, v);
+
+        // bottom-right
+        v = this.originalVertex(c);
+        v.y = diff.y;
+        v.z += diff.z;
+        this.setVertex(c, v);
+
+        // upper-right
+        v = this.originalVertex(d);
+        v.y -= diff.y;
+        v.z -= diff.z;
+        this.setVertex(d, v);
+    }
+});
+
+/**
+ * Create a flip Y 3d action with duration. <br />
+ * Upside down.
+ * @function
+ * @param {Number} duration
+ * @return {cc.FlipY3D}
+ */
+cc.flipY3D = function (duration) {
+    return new cc.FlipY3D(duration);
+};
+
+/**
+ * Please use cc.flipY3D instead. <br />
+ * Create a flip Y 3d action with duration.
+ * @param {Number} duration
+ * @return {cc.FlipY3D}
+ * @static
+ * @deprecated since v3.0 <br /> Please use cc.flipY3D instead.
+ */
+cc.FlipY3D.create = cc.flipY3D;
+
+/**
+ * cc.Lens3D action. <br />
+ * Upside down. <br />
+ * Reference the test cases (Effects Test)
+ * @class
+ * @extends cc.Grid3DAction
+ * @param {Number} duration
+ * @param {cc.Size} gridSize
+ * @param {cc.Point} position
+ * @param {Number} radius
+ */
+cc.Lens3D = cc.Grid3DAction.extend(/** @lends cc.Lens3D# */{
+    //lens center position
+    _position:null,
+    _radius:0,
+    //lens effect. Defaults to 0.7 - 0 means no effect, 1 is very strong effect
+    _lensEffect:0,
+    //lens is concave. (true = concave, false = convex) default is convex i.e. false
+    _concave:false,
+    _dirty:false,
+
+	/**
+     * Constructor function, override it to extend the construction behavior, remember to call "this._super()" in the extended "ctor" function. <br />
+	 * creates a lens 3d action with center position, radius.
+	 * @param {Number} duration
+	 * @param {cc.Size} gridSize
+	 * @param {cc.Point} position
+	 * @param {Number} radius
+	 */
+    ctor:function (duration, gridSize, position, radius) {
+        cc.GridAction.prototype.ctor.call(this);
+
+        this._position = cc.p(0, 0);
+		radius !== undefined && this.initWithDuration(duration, gridSize, position, radius);
+    },
+
+    /**
+     * Get lens center position
+     * @return {Number}
+     */
+    getLensEffect:function () {
+        return this._lensEffect;
+    },
+
+    /**
+     * Set lens center position
+     * @param {Number} lensEffect
+     */
+    setLensEffect:function (lensEffect) {
+        this._lensEffect = lensEffect;
+    },
+
+    /**
+     * Set whether lens is concave
+     * @param {Boolean} concave
+     */
+    setConcave:function (concave) {
+        this._concave = concave;
+    },
+
+    /**
+     * get Position
+     * @return {cc.Point}
+     */
+    getPosition:function () {
+        return this._position;
+    },
+
+    /**
+     * set Position
+     * @param {cc.Point} position
+     */
+    setPosition:function (position) {
+        if (!cc.pointEqualToPoint(position, this._position)) {
+            this._position.x = position.x;
+            this._position.y = position.y;
+            this._dirty = true;
+        }
+    },
+
+    /**
+     * initializes the action with center position, radius, a grid size and duration
+     * @param {Number} duration
+     * @param {cc.Size} gridSize
+     * @param {cc.Point} position
+     * @param {Number} radius
+     * @return {Boolean}
+     */
+    initWithDuration:function (duration, gridSize, position, radius) {
+        if (cc.Grid3DAction.prototype.initWithDuration.call(this, duration, gridSize)) {
+            this.setPosition(position);
+            this._radius = radius;
+            this._lensEffect = 0.7;
+            this._dirty = true;
+            return true;
+        }
+        return false;
+    },
+
+    /**
+     * Called once per frame. Time is the number of seconds of a frame interval.
+     *
+     * @param {Number}  dt
+     */
+    update:function (dt) {
+        if (this._dirty) {
+            var locGridSizeWidth = this._gridSize.width, locGridSizeHeight = this._gridSize.height;
+            var locRadius = this._radius, locLensEffect = this._lensEffect;
+            var locPos = cc.p(0, 0);
+            var vect = cc.p(0, 0);
+            var v, r, l, new_r, pre_log;
+            for (var i = 0; i < locGridSizeWidth + 1; ++i) {
+                for (var j = 0; j < locGridSizeHeight + 1; ++j) {
+                    locPos.x = i;
+                    locPos.y = j;
+                    v = this.originalVertex(locPos);
+                    vect.x = this._position.x - v.x;
+                    vect.y = this._position.y - v.y;
+                    r = cc.pLength(vect);
+
+                    if (r < locRadius) {
+                        r = locRadius - r;
+                        pre_log = r / locRadius;
+                        if (pre_log == 0)
+                            pre_log = 0.001;
+
+                        l = Math.log(pre_log) * locLensEffect;
+                        new_r = Math.exp(l) * locRadius;
+
+                        r = cc.pLength(vect);
+                        if (r > 0) {
+                            vect.x = vect.x / r;
+                            vect.y = vect.y / r;
+
+                            vect.x = vect.x * new_r;
+                            vect.y = vect.y * new_r;
+                            v.z += cc.pLength(vect) * locLensEffect;
+                        }
+                    }
+                    this.setVertex(locPos, v);
+                }
+            }
+            this._dirty = false;
+        }
+    }
+});
+
+/**
+ * creates a lens 3d action with center position, radius
+ * @function
+ * @param {Number} duration
+ * @param {cc.Size} gridSize
+ * @param {cc.Point} position
+ * @param {Number} radius
+ * @return {cc.Lens3D}
+ */
+cc.lens3D = function (duration, gridSize, position, radius) {
+    return new cc.Lens3D(duration, gridSize, position, radius);
+};
+
+/**
+ * Please use cc.lens3D instead
+ * creates a lens 3d action with center position, radius
+ * @param {Number} duration
+ * @param {cc.Size} gridSize
+ * @param {cc.Point} position
+ * @param {Number} radius
+ * @return {cc.Lens3D}
+ * @static
+ * @deprecated since v3.0 <br /> Please use cc.lens3D instead.
+ */
+cc.Lens3D.create = cc.lens3D;
+
+/**
+ * cc.Ripple3D action. <br />
+ * Reference the test cases (Effects Test)
+ * @class
+ * @extends cc.Grid3DAction
+ * @param {Number} duration
+ * @param {cc.Size} gridSize
+ * @param {cc.Point} position
+ * @param {Number} radius
+ * @param {Number} waves
+ * @param {Number} amplitude
+ */
+cc.Ripple3D = cc.Grid3DAction.extend(/** @lends cc.Ripple3D# */{
+    /* center position */
+    _position: null,
+    _radius: 0,
+    _waves: 0,
+    _amplitude: 0,
+    _amplitudeRate: 0,
+
+	/**
+     * Constructor function, override it to extend the construction behavior, remember to call "this._super()" in the extended "ctor" function. <br />
+	 * creates a ripple 3d action with radius, number of waves, amplitude.
+	 * @param {Number} duration
+	 * @param {cc.Size} gridSize
+	 * @param {cc.Point} position
+	 * @param {Number} radius
+	 * @param {Number} waves
+	 * @param {Number} amplitude
+	 */
+    ctor:function (duration, gridSize, position, radius, waves, amplitude) {
+        cc.GridAction.prototype.ctor.call(this);
+
+        this._position = cc.p(0, 0);
+		amplitude !== undefined && this.initWithDuration(duration, gridSize, position, radius, waves, amplitude);
+    },
+
+    /**
+     * get center position
+     * @return {cc.Point}
+     */
+    getPosition:function () {
+        return this._position;
+    },
+
+    /**
+     * set center position
+     * @param {cc.Point} position
+     */
+    setPosition:function (position) {
+        this._position.x = position.x;
+        this._position.y = position.y;
+    },
+
+    /**
+     * get Amplitude
+     * @return {Number}
+     */
+    getAmplitude:function () {
+        return this._amplitude;
+    },
+
+    /**
+     * set Amplitude
+     * @param {Number} amplitude
+     */
+    setAmplitude:function (amplitude) {
+        this._amplitude = amplitude;
+    },
+
+    /**
+     * get Amplitude rate
+     * @return {*}
+     */
+    getAmplitudeRate:function () {
+        return this._amplitudeRate;
+    },
+
+    /**
+     * get amplitude rate
+     * @param {Number} amplitudeRate
+     */
+    setAmplitudeRate:function (amplitudeRate) {
+        this._amplitudeRate = amplitudeRate;
+    },
+
+    /**
+     * initializes the action with radius, number of waves, amplitude, a grid size and duration
+     * @param {Number} duration
+     * @param {cc.Size} gridSize
+     * @param {cc.Point} position
+     * @param {Number} radius
+     * @param {Number} waves
+     * @param {Number} amplitude
+     * @return {Boolean}
+     */
+    initWithDuration:function (duration, gridSize, position, radius, waves, amplitude) {
+        if (cc.Grid3DAction.prototype.initWithDuration.call(this, duration, gridSize)) {
+            this.setPosition(position);
+            this._radius = radius;
+            this._waves = waves;
+            this._amplitude = amplitude;
+            this._amplitudeRate = 1.0;
+            return true;
+        }
+        return false;
+    },
+
+    /**
+     * Called once per frame. Time is the number of seconds of a frame interval.
+     *
+     * @param {Number}  dt
+     */
+    update:function (dt) {
+        var locGridSizeWidth = this._gridSize.width, locGridSizeHeight = this._gridSize.height;
+        var locPos = cc.p(0, 0), locRadius = this._radius;
+        var locWaves = this._waves, locAmplitude = this._amplitude, locAmplitudeRate = this._amplitudeRate;
+        var v, r, tempPos = cc.p(0, 0);
+        for (var i = 0; i < (locGridSizeWidth + 1); ++i) {
+            for (var j = 0; j < (locGridSizeHeight + 1); ++j) {
+                locPos.x = i;
+                locPos.y = j;
+                v = this.originalVertex(locPos);
+
+                tempPos.x = this._position.x - v.x;
+                tempPos.y = this._position.y - v.y;
+                r = cc.pLength(tempPos);
+
+                if (r < locRadius) {
+                    r = locRadius - r;
+                    var rate = Math.pow(r / locRadius, 2);
+                    v.z += (Math.sin(dt * Math.PI * locWaves * 2 + r * 0.1) * locAmplitude * locAmplitudeRate * rate);
+                }
+                this.setVertex(locPos, v);
+            }
+        }
+    }
+});
+
+/**
+ * creates a ripple 3d action with radius, number of waves, amplitude
+ * @function
+ * @param {Number} duration
+ * @param {cc.Size} gridSize
+ * @param {cc.Point} position
+ * @param {Number} radius
+ * @param {Number} waves
+ * @param {Number} amplitude
+ * @return {cc.Ripple3D}
+ */
+cc.ripple3D = function (duration, gridSize, position, radius, waves, amplitude) {
+    return new cc.Ripple3D(duration, gridSize, position, radius, waves, amplitude);
+};
+
+/**
+ * Please use cc.ripple3D instead
+ * creates a ripple 3d action with radius, number of waves, amplitude
+ * @param {Number} duration
+ * @param {cc.Size} gridSize
+ * @param {cc.Point} position
+ * @param {Number} radius
+ * @param {Number} waves
+ * @param {Number} amplitude
+ * @return {cc.Ripple3D}
+ * @static
+ * @deprecated since v3.0 <br /> Please use cc.ripple3D instead.
+ */
+cc.Ripple3D.create = cc.ripple3D;
+
+/**
+ * cc.Shaky3D action. <br />
+ * Reference the test cases (Effects Test)
+ * @class
+ * @extends cc.Grid3DAction
+ * @param {Number} duration
+ * @param {cc.Size} gridSize
+ * @param {Number} range
+ * @param {Boolean} shakeZ
+ */
+cc.Shaky3D = cc.Grid3DAction.extend(/** @lends cc.Shaky3D# */{
+    _randRange: 0,
+    _shakeZ: false,
+
+	/**
+     * Constructor function, override it to extend the construction behavior, remember to call "this._super()" in the extended "ctor" function. <br />
+	 * Create a shaky3d action with a range, shake Z vertices.
+	 * @param {Number} duration
+	 * @param {cc.Size} gridSize
+	 * @param {Number} range
+	 * @param {Boolean} shakeZ
+	 */
+    ctor:function (duration, gridSize, range, shakeZ) {
+        cc.GridAction.prototype.ctor.call(this);
+		shakeZ !== undefined && this.initWithDuration(duration, gridSize, range, shakeZ);
+    },
+
+    /**
+     * initializes the action with a range, shake Z vertices, a grid and duration
+     * @param {Number} duration
+     * @param {cc.Size} gridSize
+     * @param {Number} range
+     * @param {Boolean} shakeZ
+     * @return {Boolean}
+     */
+    initWithDuration:function (duration, gridSize, range, shakeZ) {
+        if (cc.Grid3DAction.prototype.initWithDuration.call(this, duration, gridSize)) {
+            this._randRange = range;
+            this._shakeZ = shakeZ;
+            return true;
+        }
+        return false;
+    },
+
+    /**
+     * Called once per frame. Time is the number of seconds of a frame interval.
+     *
+     * @param {Number}  dt
+     */
+    update:function (dt) {
+        var locGridSizeWidth = this._gridSize.width, locGridSizeHeight = this._gridSize.height;
+        var locRandRange = this._randRange, locShakeZ = this._shakeZ, locP = cc.p(0, 0);
+        var v;
+        for (var i = 0; i < (locGridSizeWidth + 1); ++i) {
+            for (var j = 0; j < (locGridSizeHeight + 1); ++j) {
+                locP.x = i;
+                locP.y = j;
+                v = this.originalVertex(locP);
+                v.x += (cc.rand() % (locRandRange * 2)) - locRandRange;
+                v.y += (cc.rand() % (locRandRange * 2)) - locRandRange;
+                if (locShakeZ)
+                    v.z += (cc.rand() % (locRandRange * 2)) - locRandRange;
+                this.setVertex(locP, v);
+            }
+        }
+    }
+});
+
+/**
+ * creates the action with a range, shake Z vertices, a grid and duration
+ * @function
+ * @param {Number} duration
+ * @param {cc.Size} gridSize
+ * @param {Number} range
+ * @param {Boolean} shakeZ
+ * @return {cc.Shaky3D}
+ */
+cc.shaky3D = function (duration, gridSize, range, shakeZ) {
+    return new cc.Shaky3D(duration, gridSize, range, shakeZ);
+};
+
+/**
+ * Please use cc.shaky3D instead
+ * creates the action with a range, shake Z vertices, a grid and duration
+ * @param {Number} duration
+ * @param {cc.Size} gridSize
+ * @param {Number} range
+ * @param {Boolean} shakeZ
+ * @return {cc.Shaky3D}
+ * @static
+ * @deprecated since v3.0 <br /> Please use cc.shaky3D instead.
+ */
+cc.Shaky3D.create = cc.shaky3D;
+
+/**
+ * cc.Liquid action. <br />
+ * Reference the test cases (Effects Test)
+ * @class
+ * @extends cc.Grid3DAction
+ * @param {Number} duration
+ * @param {cc.Size} gridSize
+ * @param {Number} waves
+ * @param {Number} amplitude
+ */
+cc.Liquid = cc.Grid3DAction.extend(/** @lends cc.Liquid# */{
+    _waves: 0,
+    _amplitude: 0,
+    _amplitudeRate: 0,
+
+	/**
+     * Constructor function, override it to extend the construction behavior, remember to call "this._super()" in the extended "ctor" function. <br />
+	 * Create a liquid action with amplitude, a grid and duration.
+	 * @param {Number} duration
+	 * @param {cc.Size} gridSize
+	 * @param {Number} waves
+	 * @param {Number} amplitude
+	 */
+    ctor: function (duration, gridSize, waves, amplitude) {
+        cc.GridAction.prototype.ctor.call(this);
+		amplitude !== undefined && this.initWithDuration(duration, gridSize, waves, amplitude);
+    },
+
+    /**
+     * get amplitude
+     * @return {Number}
+     */
+    getAmplitude:function () {
+        return this._amplitude;
+    },
+
+    /**
+     * set amplitude
+     * @param {Number} amplitude
+     */
+    setAmplitude:function (amplitude) {
+        this._amplitude = amplitude;
+    },
+
+    /**
+     * get amplitude rate
+     * @return {Number}
+     */
+    getAmplitudeRate:function () {
+        return this._amplitudeRate;
+    },
+
+    /**
+     * set amplitude rate
+     * @param {Number} amplitudeRate
+     */
+    setAmplitudeRate:function (amplitudeRate) {
+        this._amplitudeRate = amplitudeRate;
+    },
+
+    /**
+     * initializes the action with amplitude, a grid and duration
+     * @param {Number} duration
+     * @param {cc.Size} gridSize
+     * @param {Number} waves
+     * @param {Number} amplitude
+     * @return {Boolean}
+     */
+    initWithDuration:function (duration, gridSize, waves, amplitude) {
+        if (cc.Grid3DAction.prototype.initWithDuration.call(this, duration, gridSize)) {
+            this._waves = waves;
+            this._amplitude = amplitude;
+            this._amplitudeRate = 1.0;
+            return true;
+        }
+        return false;
+    },
+
+    /**
+     * Called once per frame. Time is the number of seconds of a frame interval.
+     *
+     * @param {Number}  dt
+     */
+    update:function (dt) {
+        var locSizeWidth = this._gridSize.width, locSizeHeight = this._gridSize.height, locPos = cc.p(0, 0);
+        var locWaves = this._waves, locAmplitude = this._amplitude, locAmplitudeRate = this._amplitudeRate;
+        var v;
+        for (var i = 1; i < locSizeWidth; ++i) {
+            for (var j = 1; j < locSizeHeight; ++j) {
+                locPos.x = i;
+                locPos.y = j;
+                v = this.originalVertex(locPos);
+                v.x = (v.x + (Math.sin(dt * Math.PI * locWaves * 2 + v.x * .01) * locAmplitude * locAmplitudeRate));
+                v.y = (v.y + (Math.sin(dt * Math.PI * locWaves * 2 + v.y * .01) * locAmplitude * locAmplitudeRate));
+                this.setVertex(locPos, v);
+            }
+        }
+    }
+});
+
+/**
+ * creates the action with amplitude, a grid and duration
+ * @function
+ * @param {Number} duration
+ * @param {cc.Size} gridSize
+ * @param {Number} waves
+ * @param {Number} amplitude
+ * @return {cc.Liquid}
+ */
+cc.liquid = function (duration, gridSize, waves, amplitude) {
+    return new cc.Liquid(duration, gridSize, waves, amplitude);
+};
+
+/**
+ * Please use cc.liquid instead
+ * creates the action with amplitude, a grid and duration
+ * @param {Number} duration
+ * @param {cc.Size} gridSize
+ * @param {Number} waves
+ * @param {Number} amplitude
+ * @return {cc.Liquid}
+ * @static
+ * @deprecated since v3.0 <br /> Please use cc.liquid instead.
+ */
+cc.Liquid.create = cc.liquid;
+
+/**
+ * cc.Waves action. <br />
+ * Reference the test cases (Effects Test)
+ * @class
+ * @extends cc.Grid3DAction
+ * @param {Number} duration
+ * @param {cc.Size} gridSize
+ * @param {Number} waves
+ * @param {Number} amplitude
+ * @param {Boolean} horizontal
+ * @param {Boolean} vertical
+ */
+cc.Waves = cc.Grid3DAction.extend(/** @lends cc.Waves# */{
+    _waves: 0,
+    _amplitude: 0,
+    _amplitudeRate: 0,
+    _vertical: false,
+    _horizontal: false,
+
+	/**
+     * Constructor function, override it to extend the construction behavior, remember to call "this._super()" in the extended "ctor" function. <br />
+	 * Create a wave action with amplitude, horizontal sin, vertical sin, a grid and duration.
+	 * @param {Number} duration
+	 * @param {cc.Size} gridSize
+	 * @param {Number} waves
+	 * @param {Number} amplitude
+	 * @param {Boolean} horizontal
+	 * @param {Boolean} vertical
+	 */
+    ctor: function (duration, gridSize, waves, amplitude, horizontal, vertical) {
+        cc.GridAction.prototype.ctor.call(this);
+		vertical !== undefined && this.initWithDuration(duration, gridSize, waves, amplitude, horizontal, vertical);
+    },
+
+    /**
+     * get amplitude
+     * @return {Number}
+     */
+    getAmplitude:function () {
+        return this._amplitude;
+    },
+
+    /**
+     * set amplitude
+     * @param {Number} amplitude
+     */
+    setAmplitude:function (amplitude) {
+        this._amplitude = amplitude;
+    },
+
+    /**
+     * get amplitude rate
+     * @return {Number}
+     */
+    getAmplitudeRate:function () {
+        return this._amplitudeRate;
+    },
+
+    /**
+     * set amplitude rate
+     * @param {Number} amplitudeRate
+     */
+    setAmplitudeRate:function (amplitudeRate) {
+        this._amplitudeRate = amplitudeRate;
+    },
+
+    /**
+     * initializes the action with amplitude, horizontal sin, vertical sin, a grid and duration
+     * @param {Number} duration
+     * @param {cc.Size} gridSize
+     * @param {Number} waves
+     * @param {Number} amplitude
+     * @param {Boolean} horizontal
+     * @param {Boolean} vertical
+     * @return {Boolean}
+     */
+    initWithDuration:function (duration, gridSize, waves, amplitude, horizontal, vertical) {
+        if (cc.Grid3DAction.prototype.initWithDuration.call(this, duration, gridSize)) {
+            this._waves = waves;
+            this._amplitude = amplitude;
+            this._amplitudeRate = 1.0;
+            this._horizontal = horizontal;
+            this._vertical = vertical;
+            return true;
+        }
+        return false;
+    },
+
+    /**
+     * Called once per frame. Time is the number of seconds of a frame interval.
+     *
+     * @param {Number}  dt
+     */
+    update:function (dt) {
+        var locSizeWidth = this._gridSize.width, locSizeHeight = this._gridSize.height, locPos = cc.p(0, 0);
+        var locVertical = this._vertical, locHorizontal = this._horizontal;
+        var locWaves = this._waves, locAmplitude = this._amplitude, locAmplitudeRate = this._amplitudeRate;
+        var v;
+        for (var i = 0; i < locSizeWidth + 1; ++i) {
+            for (var j = 0; j < locSizeHeight + 1; ++j) {
+                locPos.x = i;
+                locPos.y = j;
+                v = this.originalVertex(locPos);
+                if (locVertical)
+                    v.x = (v.x + (Math.sin(dt * Math.PI * locWaves * 2 + v.y * .01) * locAmplitude * locAmplitudeRate));
+                if (locHorizontal)
+                    v.y = (v.y + (Math.sin(dt * Math.PI * locWaves * 2 + v.x * .01) * locAmplitude * locAmplitudeRate));
+                this.setVertex(locPos, v);
+            }
+        }
+    }
+});
+
+/**
+ * initializes the action with amplitude, horizontal sin, vertical sin, a grid and duration
+ * @function
+ * @param {Number} duration
+ * @param {cc.Size} gridSize
+ * @param {Number} waves
+ * @param {Number} amplitude
+ * @param {Boolean} horizontal
+ * @param {Boolean} vertical
+ * @return {cc.Waves}
+ */
+cc.waves = function (duration, gridSize, waves, amplitude, horizontal, vertical) {
+    return new cc.Waves(duration, gridSize, waves, amplitude, horizontal, vertical);
+};
+
+/**
+ * Please use cc.waves instead
+ * initializes the action with amplitude, horizontal sin, vertical sin, a grid and duration
+ * @param {Number} duration
+ * @param {cc.Size} gridSize
+ * @param {Number} waves
+ * @param {Number} amplitude
+ * @param {Boolean} horizontal
+ * @param {Boolean} vertical
+ * @return {cc.Waves}
+ * @static
+ * @deprecated since v3.0 <br /> Please use cc.waves instead.
+ */
+cc.Waves.create = cc.waves;
+
+/** @brief  */
+/**
+ * cc.Twirl action. <br />
+ * Reference the test cases (Effects Test)
+ * @class
+ * @extends cc.Grid3DAction
+ * @param {Number} duration
+ * @param {cc.Size} gridSize
+ * @param {cc.Point} position
+ * @param {Number} twirls
+ * @param {Number} amplitude
+ */
+cc.Twirl = cc.Grid3DAction.extend(/** @lends cc.Twirl# */{
+    /* twirl center */
+    _position: null,
+    _twirls: 0,
+    _amplitude: 0,
+    _amplitudeRate: 0,
+
+	/**
+     * Constructor function, override it to extend the construction behavior, remember to call "this._super()" in the extended "ctor" function. <br />
+	 * Create a grid 3d action with center position, number of twirls, amplitude, a grid size and duration.
+	 * @param {Number} duration
+	 * @param {cc.Size} gridSize
+	 * @param {cc.Point} position
+	 * @param {Number} twirls
+	 * @param {Number} amplitude
+	 */
+    ctor:function (duration, gridSize, position, twirls, amplitude) {
+        cc.GridAction.prototype.ctor.call(this);
+
+        this._position = cc.p(0, 0);
+		amplitude !== undefined && this.initWithDuration(duration, gridSize, position, twirls, amplitude);
+    },
+
+    /**
+     * get twirl center
+     * @return {cc.Point}
+     */
+    getPosition:function () {
+        return this._position;
+    },
+
+    /**
+     * set twirl center
+     * @param {cc.Point} position
+     */
+    setPosition:function (position) {
+        this._position.x = position.x;
+        this._position.y = position.y;
+    },
+
+    /**
+     * get amplitude
+     * @return {Number}
+     */
+    getAmplitude:function () {
+        return this._amplitude;
+    },
+
+    /**
+     * set amplitude
+     * @param {Number} amplitude
+     */
+    setAmplitude:function (amplitude) {
+        this._amplitude = amplitude;
+    },
+
+    /**
+     * get amplitude rate
+     * @return {Number}
+     */
+    getAmplitudeRate:function () {
+        return this._amplitudeRate;
+    },
+
+    /**
+     * set amplitude rate
+     * @param {Number} amplitudeRate
+     */
+    setAmplitudeRate:function (amplitudeRate) {
+        this._amplitudeRate = amplitudeRate;
+    },
+
+    /** initializes the action with center position, number of twirls, amplitude, a grid size and duration */
+    initWithDuration:function (duration, gridSize, position, twirls, amplitude) {
+        if (cc.Grid3DAction.prototype.initWithDuration.call(this, duration, gridSize)) {
+            this.setPosition(position);
+            this._twirls = twirls;
+            this._amplitude = amplitude;
+            this._amplitudeRate = 1.0;
+            return true;
+        }
+        return false;
+    },
+
+    /**
+     * Called once per frame. Time is the number of seconds of a frame interval.
+     *
+     * @param {Number}  dt
+     */
+    update:function (dt) {
+        var c = this._position;
+        var locSizeWidth = this._gridSize.width, locSizeHeight = this._gridSize.height, locPos = cc.p(0, 0);
+        var amp = 0.1 * this._amplitude * this._amplitudeRate;
+        var locTwirls = this._twirls;
+        var v, a, dX, dY, avg = cc.p(0, 0);
+        for (var i = 0; i < (locSizeWidth + 1); ++i) {
+            for (var j = 0; j < (locSizeHeight + 1); ++j) {
+                locPos.x = i;
+                locPos.y = j;
+                v = this.originalVertex(locPos);
+
+                avg.x = i - (locSizeWidth / 2.0);
+                avg.y = j - (locSizeHeight / 2.0);
+
+                a = cc.pLength(avg) * Math.cos(Math.PI / 2.0 + dt * Math.PI * locTwirls * 2) * amp;
+
+                dX = Math.sin(a) * (v.y - c.y) + Math.cos(a) * (v.x - c.x);
+                dY = Math.cos(a) * (v.y - c.y) - Math.sin(a) * (v.x - c.x);
+
+                v.x = c.x + dX;
+                v.y = c.y + dY;
+
+                this.setVertex(locPos, v);
+            }
+        }
+    }
+});
+
+/**
+ * creates the action with center position, number of twirls, amplitude, a grid size and duration
+ * @function
+ * @param {Number} duration
+ * @param {cc.Size} gridSize
+ * @param {cc.Point} position
+ * @param {Number} twirls
+ * @param {Number} amplitude
+ * @return {cc.Twirl}
+ */
+cc.twirl = function (duration, gridSize, position, twirls, amplitude) {
+    return new cc.Twirl(duration, gridSize, position, twirls, amplitude);
+};
+
+/**
+ * Please use cc.twirl instead
+ * creates the action with center position, number of twirls, amplitude, a grid size and duration
+ * @param {Number} duration
+ * @param {cc.Size} gridSize
+ * @param {cc.Point} position
+ * @param {Number} twirls
+ * @param {Number} amplitude
+ * @return {cc.Twirl}
+ * @static
+ * @deprecated since v3.0 <br /> Please use cc.twirl instead.
+ */
+cc.Twirl.create = cc.twirl;