mirror of
https://github.com/tiennm99/fbird.git
synced 2026-08-14 08:25:03 +00:00
1257 lines
36 KiB
JavaScript
Vendored
1257 lines
36 KiB
JavaScript
Vendored
/****************************************************************************
|
|
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; |