mirror of
https://github.com/cocos/cocos4.git
synced 2026-11-20 23:52:40 +08:00
486 lines
20 KiB
JavaScript
486 lines
20 KiB
JavaScript
/****************************************************************************
|
|
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.ProgressTimer's rendering objects of WebGL
|
|
*/
|
|
(function(){
|
|
cc.ProgressTimer.WebGLRenderCmd = function(renderableObject){
|
|
_ccsg.Node.WebGLRenderCmd.call(this, renderableObject);
|
|
this._needDraw = true;
|
|
|
|
this._vertexWebGLBuffer = cc._renderContext.createBuffer();
|
|
this._vertexDataCount = 0;
|
|
this._vertexData = null;
|
|
this._vertexArrayBuffer = null;
|
|
this._vertexDataDirty = false;
|
|
};
|
|
|
|
var proto = cc.ProgressTimer.WebGLRenderCmd.prototype = Object.create(_ccsg.Node.WebGLRenderCmd.prototype);
|
|
proto.constructor = cc.ProgressTimer.WebGLRenderCmd;
|
|
|
|
proto.rendering = function (ctx) {
|
|
var node = this._node;
|
|
var context = ctx || cc._renderContext;
|
|
if (!this._vertexData || !node._sprite)
|
|
return;
|
|
|
|
this._shaderProgram.use();
|
|
this._shaderProgram._setUniformForMVPMatrixWithMat4(this._stackMatrix);
|
|
|
|
var blendFunc = node._sprite._blendFunc;
|
|
cc.gl.blendFunc(blendFunc.src, blendFunc.dst);
|
|
cc.gl.enableVertexAttribs(cc.macro.VERTEX_ATTRIB_FLAG_POS_COLOR_TEX);
|
|
|
|
cc.gl.bindTexture2D(node._sprite.texture);
|
|
|
|
context.bindBuffer(context.ARRAY_BUFFER, this._vertexWebGLBuffer);
|
|
if (this._vertexDataDirty) {
|
|
context.bufferData(context.ARRAY_BUFFER, this._vertexArrayBuffer, context.DYNAMIC_DRAW);
|
|
this._vertexDataDirty = false;
|
|
}
|
|
var locVertexDataLen = cc.V2F_C4B_T2F.BYTES_PER_ELEMENT;
|
|
context.vertexAttribPointer(cc.macro.VERTEX_ATTRIB_POSITION, 2, context.FLOAT, false, locVertexDataLen, 0);
|
|
context.vertexAttribPointer(cc.macro.VERTEX_ATTRIB_COLOR, 4, context.UNSIGNED_BYTE, true, locVertexDataLen, 8);
|
|
context.vertexAttribPointer(cc.macro.VERTEX_ATTRIB_TEX_COORDS, 2, context.FLOAT, false, locVertexDataLen, 12);
|
|
|
|
if (node._type === cc.ProgressTimer.Type.RADIAL)
|
|
context.drawArrays(context.TRIANGLE_FAN, 0, this._vertexDataCount);
|
|
else if (node._type === cc.ProgressTimer.Type.BAR) {
|
|
if (!node._reverseDirection)
|
|
context.drawArrays(context.TRIANGLE_STRIP, 0, this._vertexDataCount);
|
|
else {
|
|
context.drawArrays(context.TRIANGLE_STRIP, 0, this._vertexDataCount / 2);
|
|
context.drawArrays(context.TRIANGLE_STRIP, 4, this._vertexDataCount / 2);
|
|
// 2 draw calls
|
|
cc.g_NumberOfDraws++;
|
|
}
|
|
}
|
|
cc.g_NumberOfDraws++;
|
|
};
|
|
|
|
proto._syncStatus = function (parentCmd) {
|
|
var node = this._node;
|
|
if(!node._sprite)
|
|
return;
|
|
var flags = _ccsg.Node._dirtyFlags, locFlag = this._dirtyFlag;
|
|
var parentNode = parentCmd ? parentCmd._node : null;
|
|
|
|
if(parentNode && parentNode._cascadeColorEnabled && (parentCmd._dirtyFlag & flags.colorDirty))
|
|
locFlag |= flags.colorDirty;
|
|
if(parentNode && parentNode._cascadeOpacityEnabled && (parentCmd._dirtyFlag & flags.opacityDirty))
|
|
locFlag |= flags.opacityDirty;
|
|
if(parentCmd && (parentCmd._dirtyFlag & flags.transformDirty))
|
|
locFlag |= flags.transformDirty;
|
|
this._dirtyFlag = locFlag;
|
|
|
|
var spriteCmd = node._sprite._renderCmd;
|
|
var spriteFlag = spriteCmd._dirtyFlag;
|
|
|
|
var colorDirty = spriteFlag & flags.colorDirty,
|
|
opacityDirty = spriteFlag & flags.opacityDirty;
|
|
|
|
if (colorDirty){
|
|
spriteCmd._syncDisplayColor();
|
|
}
|
|
|
|
if (opacityDirty){
|
|
spriteCmd._syncDisplayOpacity();
|
|
}
|
|
|
|
if(colorDirty || opacityDirty){
|
|
spriteCmd._updateColor();
|
|
this._updateColor();
|
|
}
|
|
|
|
//if (locFlag & flags.transformDirty) {
|
|
//update the transform
|
|
this.transform(parentCmd);
|
|
//}
|
|
|
|
spriteCmd._dirtyFlag = 0;
|
|
};
|
|
|
|
proto.updateStatus = function () {
|
|
var node = this._node;
|
|
if(!node._sprite)
|
|
return;
|
|
var flags = _ccsg.Node._dirtyFlags, locFlag = this._dirtyFlag;
|
|
var spriteCmd = node._sprite._renderCmd;
|
|
var spriteFlag = spriteCmd._dirtyFlag;
|
|
|
|
var colorDirty = spriteFlag & flags.colorDirty,
|
|
opacityDirty = spriteFlag & flags.opacityDirty;
|
|
|
|
if(colorDirty){
|
|
spriteCmd._updateDisplayColor();
|
|
this._dirtyFlag = this._dirtyFlag & flags.colorDirty ^ this._dirtyFlag;
|
|
}
|
|
|
|
if(opacityDirty){
|
|
spriteCmd._updateDisplayOpacity();
|
|
this._dirtyFlag = this._dirtyFlag & flags.opacityDirty ^ this._dirtyFlag;
|
|
}
|
|
|
|
if(colorDirty || opacityDirty){
|
|
spriteCmd._updateColor();
|
|
this._updateColor();
|
|
}
|
|
|
|
if(locFlag & flags.transformDirty){
|
|
//update the transform
|
|
this.transform(this.getParentRenderCmd(), true);
|
|
}
|
|
};
|
|
|
|
proto.releaseData = function(){
|
|
if (this._vertexData) {
|
|
//release all previous information
|
|
this._vertexData = null;
|
|
this._vertexArrayBuffer = null;
|
|
this._vertexDataCount = 0;
|
|
}
|
|
};
|
|
|
|
proto.initCmd = function(){
|
|
this._vertexData = null;
|
|
this._vertexArrayBuffer = null;
|
|
this._vertexDataCount = 0;
|
|
|
|
//shader program
|
|
this._shaderProgram = cc.shaderCache.programForKey(cc.macro.SHADER_POSITION_TEXTURECOLOR);
|
|
};
|
|
|
|
proto._updateProgress = function(){
|
|
var node = this._node;
|
|
var locType = node._type;
|
|
if(locType === cc.ProgressTimer.Type.RADIAL)
|
|
this._updateRadial();
|
|
else if(locType === cc.ProgressTimer.Type.BAR)
|
|
this._updateBar();
|
|
this._vertexDataDirty = true;
|
|
};
|
|
|
|
/**
|
|
* <p>
|
|
* Update does the work of mapping the texture onto the triangles for the bar <br/>
|
|
* It now doesn't occur the cost of free/alloc data every update cycle. <br/>
|
|
* It also only changes the percentage point but no other points if they have not been modified. <br/>
|
|
* <br/>
|
|
* It now deals with flipped texture. If you run into this problem, just use the <br/>
|
|
* sprite property and enable the methods flipX, flipY. <br/>
|
|
* </p>
|
|
* @private
|
|
*/
|
|
proto._updateBar = function(){
|
|
var node = this._node;
|
|
if (!node._sprite)
|
|
return;
|
|
|
|
var i, alpha = node._percentage / 100.0;
|
|
var locBarChangeRate = node._barChangeRate;
|
|
var alphaOffset = cc.pMult(cc.p((1.0 - locBarChangeRate.x) + alpha * locBarChangeRate.x,
|
|
(1.0 - locBarChangeRate.y) + alpha * locBarChangeRate.y), 0.5);
|
|
var min = cc.pSub(node._midPoint, alphaOffset), max = cc.pAdd(node._midPoint, alphaOffset);
|
|
|
|
if (min.x < 0) {
|
|
max.x += -min.x;
|
|
min.x = 0;
|
|
}
|
|
|
|
if (max.x > 1) {
|
|
min.x -= max.x - 1;
|
|
max.x = 1;
|
|
}
|
|
|
|
if (min.y < 0) {
|
|
max.y += -min.y;
|
|
min.y = 0;
|
|
}
|
|
|
|
if (max.y > 1) {
|
|
min.y -= max.y - 1;
|
|
max.y = 1;
|
|
}
|
|
|
|
var locVertexData;
|
|
if (!this._reverseDirection) {
|
|
if (!this._vertexData) {
|
|
this._vertexDataCount = 4;
|
|
var vertexDataLen = cc.V2F_C4B_T2F.BYTES_PER_ELEMENT, locCount = 4;
|
|
this._vertexArrayBuffer = new ArrayBuffer(locCount * vertexDataLen);
|
|
this._vertexData = [];
|
|
for (i = 0; i < locCount; i++)
|
|
this._vertexData[i] = new cc.V2F_C4B_T2F(null, null, null, this._vertexArrayBuffer, i * vertexDataLen);
|
|
}
|
|
|
|
locVertexData = this._vertexData;
|
|
// TOPLEFT
|
|
locVertexData[0].texCoords = this._textureCoordFromAlphaPoint(cc.p(min.x, max.y));
|
|
locVertexData[0].vertices = this._vertexFromAlphaPoint(cc.p(min.x, max.y));
|
|
|
|
// BOTLEFT
|
|
locVertexData[1].texCoords = this._textureCoordFromAlphaPoint(cc.p(min.x, min.y));
|
|
locVertexData[1].vertices = this._vertexFromAlphaPoint(cc.p(min.x, min.y));
|
|
|
|
// TOPRIGHT
|
|
locVertexData[2].texCoords = this._textureCoordFromAlphaPoint(cc.p(max.x, max.y));
|
|
locVertexData[2].vertices = this._vertexFromAlphaPoint(cc.p(max.x, max.y));
|
|
|
|
// BOTRIGHT
|
|
locVertexData[3].texCoords = this._textureCoordFromAlphaPoint(cc.p(max.x, min.y));
|
|
locVertexData[3].vertices = this._vertexFromAlphaPoint(cc.p(max.x, min.y));
|
|
} else {
|
|
if (!this._vertexData) {
|
|
this._vertexDataCount = 8;
|
|
var rVertexDataLen = cc.V2F_C4B_T2F.BYTES_PER_ELEMENT, rLocCount = 8;
|
|
this._vertexArrayBuffer = new ArrayBuffer(rLocCount * rVertexDataLen);
|
|
var rTempData = [];
|
|
for (i = 0; i < rLocCount; i++)
|
|
rTempData[i] = new cc.V2F_C4B_T2F(null, null, null, this._vertexArrayBuffer, i * rVertexDataLen);
|
|
// TOPLEFT 1
|
|
rTempData[0].texCoords = this._textureCoordFromAlphaPoint(cc.p(0, 1));
|
|
rTempData[0].vertices = this._vertexFromAlphaPoint(cc.p(0, 1));
|
|
|
|
// BOTLEFT 1
|
|
rTempData[1].texCoords = this._textureCoordFromAlphaPoint(cc.p(0, 0));
|
|
rTempData[1].vertices = this._vertexFromAlphaPoint(cc.p(0, 0));
|
|
|
|
// TOPRIGHT 2
|
|
rTempData[6].texCoords = this._textureCoordFromAlphaPoint(cc.p(1, 1));
|
|
rTempData[6].vertices = this._vertexFromAlphaPoint(cc.p(1, 1));
|
|
|
|
// BOTRIGHT 2
|
|
rTempData[7].texCoords = this._textureCoordFromAlphaPoint(cc.p(1, 0));
|
|
rTempData[7].vertices = this._vertexFromAlphaPoint(cc.p(1, 0));
|
|
|
|
this._vertexData = rTempData;
|
|
}
|
|
|
|
locVertexData = this._vertexData;
|
|
// TOPRIGHT 1
|
|
locVertexData[2].texCoords = this._textureCoordFromAlphaPoint(cc.p(min.x, max.y));
|
|
locVertexData[2].vertices = this._vertexFromAlphaPoint(cc.p(min.x, max.y));
|
|
|
|
// BOTRIGHT 1
|
|
locVertexData[3].texCoords = this._textureCoordFromAlphaPoint(cc.p(min.x, min.y));
|
|
locVertexData[3].vertices = this._vertexFromAlphaPoint(cc.p(min.x, min.y));
|
|
|
|
// TOPLEFT 2
|
|
locVertexData[4].texCoords = this._textureCoordFromAlphaPoint(cc.p(max.x, max.y));
|
|
locVertexData[4].vertices = this._vertexFromAlphaPoint(cc.p(max.x, max.y));
|
|
|
|
// BOTLEFT 2
|
|
locVertexData[5].texCoords = this._textureCoordFromAlphaPoint(cc.p(max.x, min.y));
|
|
locVertexData[5].vertices = this._vertexFromAlphaPoint(cc.p(max.x, min.y));
|
|
}
|
|
this._updateColor();
|
|
};
|
|
|
|
/**
|
|
* <p>
|
|
* Update does the work of mapping the texture onto the triangles <br/>
|
|
* It now doesn't occur the cost of free/alloc data every update cycle. <br/>
|
|
* It also only changes the percentage point but no other points if they have not been modified. <br/>
|
|
* <br/>
|
|
* It now deals with flipped texture. If you run into this problem, just use the <br/>
|
|
* sprite property and enable the methods flipX, flipY. <br/>
|
|
* </p>
|
|
* @private
|
|
*/
|
|
proto._updateRadial = function () {
|
|
var node = this._node;
|
|
if (!node._sprite)
|
|
return;
|
|
|
|
var i, locMidPoint = node._midPoint;
|
|
var alpha = node._percentage / 100;
|
|
var angle = 2 * (Math.PI) * ( node._reverseDirection ? alpha : 1.0 - alpha);
|
|
|
|
// We find the vector to do a hit detection based on the percentage
|
|
// We know the first vector is the one @ 12 o'clock (top,mid) so we rotate
|
|
// from that by the progress angle around the m_tMidpoint pivot
|
|
var topMid = cc.p(locMidPoint.x, 1);
|
|
var percentagePt = cc.pRotateByAngle(topMid, locMidPoint, angle);
|
|
|
|
var index = 0;
|
|
var hit;
|
|
|
|
if (alpha === 0) {
|
|
// More efficient since we don't always need to check intersection
|
|
// If the alpha is zero then the hit point is top mid and the index is 0.
|
|
hit = topMid;
|
|
index = 0;
|
|
} else if (alpha === 1) {
|
|
// More efficient since we don't always need to check intersection
|
|
// If the alpha is one then the hit point is top mid and the index is 4.
|
|
hit = topMid;
|
|
index = 4;
|
|
} else {
|
|
// We run a for loop checking the edges of the texture to find the
|
|
// intersection point
|
|
// We loop through five points since the top is split in half
|
|
|
|
var min_t = cc.macro.FLT_MAX;
|
|
var locProTextCoordsCount = cc.ProgressTimer.TEXTURE_COORDS_COUNT;
|
|
for (i = 0; i <= locProTextCoordsCount; ++i) {
|
|
var pIndex = (i + (locProTextCoordsCount - 1)) % locProTextCoordsCount;
|
|
|
|
var edgePtA = this._boundaryTexCoord(i % locProTextCoordsCount);
|
|
var edgePtB = this._boundaryTexCoord(pIndex);
|
|
|
|
// Remember that the top edge is split in half for the 12 o'clock position
|
|
// Let's deal with that here by finding the correct endpoints
|
|
if (i === 0)
|
|
edgePtB = cc.pLerp(edgePtA, edgePtB, 1 - locMidPoint.x);
|
|
else if (i === 4)
|
|
edgePtA = cc.pLerp(edgePtA, edgePtB, 1 - locMidPoint.x);
|
|
|
|
// retPoint are returned by ccpLineIntersect
|
|
var retPoint = cc.p(0, 0);
|
|
if (cc.pLineIntersect(edgePtA, edgePtB, locMidPoint, percentagePt, retPoint)) {
|
|
// Since our hit test is on rays we have to deal with the top edge
|
|
// being in split in half so we have to test as a segment
|
|
if ((i === 0 || i === 4)) {
|
|
// s represents the point between edgePtA--edgePtB
|
|
if (!(0 <= retPoint.x && retPoint.x <= 1))
|
|
continue;
|
|
}
|
|
// As long as our t isn't negative we are at least finding a
|
|
// correct hitpoint from m_tMidpoint to percentagePt.
|
|
if (retPoint.y >= 0) {
|
|
// Because the percentage line and all the texture edges are
|
|
// rays we should only account for the shortest intersection
|
|
if (retPoint.y < min_t) {
|
|
min_t = retPoint.y;
|
|
index = i;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Now that we have the minimum magnitude we can use that to find our intersection
|
|
hit = cc.pAdd(locMidPoint, cc.pMult(cc.pSub(percentagePt, locMidPoint), min_t));
|
|
}
|
|
|
|
// The size of the vertex data is the index from the hitpoint
|
|
// the 3 is for the m_tMidpoint, 12 o'clock point and hitpoint position.
|
|
var sameIndexCount = true;
|
|
if (this._vertexDataCount !== index + 3) {
|
|
sameIndexCount = false;
|
|
this._vertexData = null;
|
|
this._vertexArrayBuffer = null;
|
|
this._vertexDataCount = 0;
|
|
}
|
|
|
|
if (!this._vertexData) {
|
|
this._vertexDataCount = index + 3;
|
|
var locCount = this._vertexDataCount, vertexDataLen = cc.V2F_C4B_T2F.BYTES_PER_ELEMENT;
|
|
this._vertexArrayBuffer = new ArrayBuffer(locCount * vertexDataLen);
|
|
var locData = [];
|
|
for (i = 0; i < locCount; i++)
|
|
locData[i] = new cc.V2F_C4B_T2F(null, null, null, this._vertexArrayBuffer, i * vertexDataLen);
|
|
|
|
this._vertexData = locData;
|
|
if(!this._vertexData){
|
|
cc.log( "cc.ProgressTimer._updateRadial() : Not enough memory");
|
|
return;
|
|
}
|
|
}
|
|
this._updateColor();
|
|
|
|
var locVertexData = this._vertexData;
|
|
if (!sameIndexCount) {
|
|
// First we populate the array with the m_tMidpoint, then all
|
|
// vertices/texcoords/colors of the 12 'o clock start and edges and the hitpoint
|
|
locVertexData[0].texCoords = this._textureCoordFromAlphaPoint(locMidPoint);
|
|
locVertexData[0].vertices = this._vertexFromAlphaPoint(locMidPoint);
|
|
|
|
locVertexData[1].texCoords = this._textureCoordFromAlphaPoint(topMid);
|
|
locVertexData[1].vertices = this._vertexFromAlphaPoint(topMid);
|
|
|
|
for (i = 0; i < index; i++) {
|
|
var alphaPoint = this._boundaryTexCoord(i);
|
|
locVertexData[i + 2].texCoords = this._textureCoordFromAlphaPoint(alphaPoint);
|
|
locVertexData[i + 2].vertices = this._vertexFromAlphaPoint(alphaPoint);
|
|
}
|
|
}
|
|
|
|
// hitpoint will go last
|
|
locVertexData[this._vertexDataCount - 1].texCoords = this._textureCoordFromAlphaPoint(hit);
|
|
locVertexData[this._vertexDataCount - 1].vertices = this._vertexFromAlphaPoint(hit);
|
|
};
|
|
|
|
proto._boundaryTexCoord = function (index) {
|
|
if (index < cc.ProgressTimer.TEXTURE_COORDS_COUNT) {
|
|
var locProTextCoords = cc.ProgressTimer.TEXTURE_COORDS;
|
|
if (this._node._reverseDirection)
|
|
return cc.p((locProTextCoords >> (7 - (index << 1))) & 1, (locProTextCoords >> (7 - ((index << 1) + 1))) & 1);
|
|
else
|
|
return cc.p((locProTextCoords >> ((index << 1) + 1)) & 1, (locProTextCoords >> (index << 1)) & 1);
|
|
}
|
|
return cc.p(0,0);
|
|
};
|
|
|
|
proto._textureCoordFromAlphaPoint = function (alpha) {
|
|
var locSprite = this._node._sprite;
|
|
if (!locSprite) {
|
|
return {u:0, v:0}; //new cc.Tex2F(0, 0);
|
|
}
|
|
var quad = locSprite.quad;
|
|
var min = cc.p(quad.bl.texCoords.u, quad.bl.texCoords.v);
|
|
var max = cc.p(quad.tr.texCoords.u, quad.tr.texCoords.v);
|
|
|
|
// Fix bug #1303 so that progress timer handles sprite frame texture rotation
|
|
if (locSprite.textureRectRotated) {
|
|
var temp = alpha.x;
|
|
alpha.x = alpha.y;
|
|
alpha.y = temp;
|
|
}
|
|
return {u: min.x * (1 - alpha.x) + max.x * alpha.x, v: min.y * (1 - alpha.y) + max.y * alpha.y};
|
|
};
|
|
|
|
proto._vertexFromAlphaPoint = function (alpha) {
|
|
var locSprite = this._node._sprite;
|
|
if (!locSprite) {
|
|
return {x: 0, y: 0};
|
|
}
|
|
var quad = locSprite.quad;
|
|
var min = cc.p(quad.bl.vertices.x, quad.bl.vertices.y);
|
|
var max = cc.p(quad.tr.vertices.x, quad.tr.vertices.y);
|
|
return {x: min.x * (1 - alpha.x) + max.x * alpha.x, y: min.y * (1 - alpha.y) + max.y * alpha.y};
|
|
};
|
|
|
|
proto._updateColor = function(){
|
|
var node = this._node;
|
|
if (!node._sprite || !this._vertexData)
|
|
return;
|
|
|
|
var sc = node._sprite.quad.tl.colors;
|
|
var locVertexData = this._vertexData;
|
|
for (var i = 0, len = this._vertexDataCount; i < len; ++i)
|
|
locVertexData[i].colors = sc;
|
|
this._vertexDataDirty = true;
|
|
};
|
|
})(); |