Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

fixed mesh sprite #5190

Closed
wants to merge 1 commit into from
Closed

fixed mesh sprite #5190

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Jump to
Jump to file
Failed to load files.
Diff view
Diff view
124 changes: 53 additions & 71 deletions cocos2d/core/renderer/webgl/assemblers/sprite/2d/mesh.js
View file
Open in desktop
Expand Up @@ -23,31 +23,32 @@
THE SOFTWARE.
****************************************************************************/

const spriteAssembler = require('../sprite');
const fillVerticesWithoutCalc = require('../../utils').fillVerticesWithoutCalc;

module.exports = spriteAssembler.mesh = {
createData (sprite) {
return sprite.requestRenderData();
},

import Assembler2D from '../../../../assembler-2d';

export default class MeshSpriteAssembler extends Assembler2D {
initData (sprite) {
this._local = [];
this._renderData.createFlexData(0, 4, 6, this.getVfmt());
}
updateRenderData (sprite) {
this.packToDynamicAtlas(sprite, sprite._spriteFrame);

let renderData = sprite._renderData;
let frame = sprite.spriteFrame;
if (renderData && frame) {
if (frame) {
let vertices = frame.vertices;
if (vertices) {
if (renderData.vertexCount !== vertices.x.length) {
renderData.vertexCount = vertices.x.length;
renderData.indiceCount = vertices.triangles.length;

// 1 for world vertices, 2 for local vertices
renderData.dataLength = renderData.vertexCount * 2;

this.verticesCount = vertices.x.length;
this.indicesCount = vertices.triangles.length;

let renderData = this._renderData;
let flexBuffer = renderData._flexBuffer;
if (flexBuffer.reserve(this.verticesCount, this.indicesCount)) {
this.updateIndices(vertices.triangles);
this.updateColor(sprite);
sprite._vertsDirty = true;
}
flexBuffer.used(this.verticesCount, this.indicesCount);

if (sprite._vertsDirty) {
this.updateUVs(sprite);
Expand All @@ -57,21 +58,29 @@ module.exports = spriteAssembler.mesh = {
}
}
}
},
}

updateIndices (triangles) {
let iData = this._renderData.iDatas[0];
for (let i = 0; i < triangles.length; i++) {
iData[i] = triangles[i];
}
}

updateUVs (sprite) {
let vertices = sprite.spriteFrame.vertices,
u = vertices.nu,
v = vertices.nv;

let renderData = sprite._renderData;
let verts = renderData.vertices;
for (let i = 0, l = u.length; i < l; i++) {
let vertice = verts[i];
vertice.u = u[i];
vertice.v = v[i];
let uvOffset = this.uvOffset;
let floatsPerVert = this.floatsPerVert;
let verts = this._renderData.vDatas[0];
for (let i = 0; i < u.length; i++) {
let dstOffset = floatsPerVert * i + uvOffset;
verts[dstOffset] = u[i];
verts[dstOffset + 1] = v[i];
}
},
}

updateVerts (sprite) {
let node = sprite.node,
Expand All @@ -96,64 +105,37 @@ module.exports = spriteAssembler.mesh = {
let scaleX = contentWidth / (sprite.trim ? rectWidth : originalWidth),
scaleY = contentHeight / (sprite.trim ? rectHeight : originalHeight);

let renderData = sprite._renderData;
let verts = renderData.vertices;

let local = this._local;
if (!sprite.trim) {
for (let i = 0, l = x.length; i < l; i++) {
let vertice = verts[i + l];
vertice.x = (x[i]) * scaleX - appx;
vertice.y = (originalHeight - y[i]) * scaleY - appy;
let offset = i * 2;
local[offset] = (x[i]) * scaleX - appx;
local[offset + 1] = (originalHeight - y[i]) * scaleY - appy;
}
}
else {
for (let i = 0, l = x.length; i < l; i++) {
let vertice = verts[i + l];
vertice.x = (x[i] - trimX) * scaleX - appx;
vertice.y = (originalHeight - y[i] - trimY) * scaleY - appy;
let offset = i * 2;
local[offset] = (x[i] - trimX) * scaleX - appx;
local[offset + 1] = (originalHeight - y[i] - trimY) * scaleY - appy;
}
}
},
}

updateWorldVerts (sprite) {
let node = sprite.node,
renderData = sprite._renderData,
verts = renderData.vertices;
let node = sprite.node;
let matrix = node._worldMatrix;
let matrixm = matrix.m;
let a = matrixm[0], b = matrixm[1], c = matrixm[4], d = matrixm[5],
tx = matrixm[12], ty = matrixm[13];
for (let i = 0, l = renderData.vertexCount; i < l; i++) {
let local = verts[i + l];
let world = verts[i];
world.x = local.x * a + local.y * c + tx;
world.y = local.x * b + local.y * d + ty;
}
},

fillBuffers (sprite, renderer) {
let vertices = sprite.spriteFrame.vertices;
if (!vertices) {
return;
}

// update world verts
if (renderer.worldMatDirty) {
this.updateWorldVerts(sprite);
}

// buffer
let buffer = renderer._meshBuffer;
let node = sprite.node;
let offsetInfo = fillVerticesWithoutCalc(node, buffer, sprite._renderData, node._color._val);

let ibuf = buffer._iData,
indiceOffset = offsetInfo.indiceOffset,
vertexId = offsetInfo.vertexOffset;

let triangles = vertices.triangles;
for (let i = 0, l = triangles.length; i < l; i++) {
ibuf[indiceOffset++] = vertexId + triangles[i];
let local = this._local;
let world = this._renderData.vDatas[0];
let floatsPerVert = this.floatsPerVert;
for (let i = 0, l = this.verticesCount; i < l; i++) {
let lx = local[i*2];
let ly = local[i*2 + 1];
world[floatsPerVert * i] = lx * a + ly * c + tx;
world[floatsPerVert * i + 1] = lx * b + ly * d + ty;
}
},
};
}
}
75 changes: 27 additions & 48 deletions cocos2d/core/renderer/webgl/assemblers/sprite/3d/mesh.js
View file
Open in desktop
Expand Up @@ -23,52 +23,31 @@
THE SOFTWARE.
****************************************************************************/

const spriteAssembler = require('../sprite');
const js = require('../../../../../platform/js');
const assembler2D = require('../2d/mesh');
const fillVerticesWithoutCalc3D = require('../../utils').fillVerticesWithoutCalc3D;

const vec3 = cc.vmath.vec3;
let vec3_temp = vec3.create();

module.exports = spriteAssembler.mesh3D = js.addon({
updateWorldVerts (sprite) {
let node = sprite.node,
renderData = sprite._renderData,
verts = renderData.vertices;

let matrix = node._worldMatrix;
for (let i = 0, l = renderData.vertexCount; i < l; i++) {
let local = verts[i + l];
let world = verts[i];
vec3.set(vec3_temp, local.x, local.y, 0);
vec3.transformMat4(world, vec3_temp, matrix);
}
},

fillBuffers (sprite, renderer) {
let vertices = sprite.spriteFrame.vertices;
if (!vertices) {
return;
}

// update world verts
if (renderer.worldMatDirty) {
this.updateWorldVerts(sprite);
}

// buffer
let buffer = renderer._meshBuffer3D;
let node = sprite.node;
let offsetInfo = fillVerticesWithoutCalc3D(node, buffer, sprite._renderData, node._color._val);

let ibuf = buffer._iData,
indiceOffset = offsetInfo.indiceOffset,
vertexId = offsetInfo.vertexOffset;

let triangles = vertices.triangles;
for (let i = 0, l = triangles.length; i < l; i++) {
ibuf[indiceOffset++] = vertexId + triangles[i];
const Assembler3D = require('../../../../assembler-3d');
const MeshAssembler = require('../2d/mesh');

let vec3 = cc.vmath.vec3;
let vec3_temp = cc.v3();

export default class MeshAssembler3D extends MeshAssembler {

}

cc.js.mixin(MeshAssembler3D.prototype, Assembler3D, {
updateWorldVerts (comp) {
let matrix = comp.node._worldMatrix;
let local = this._local;
let world = this._renderData.vDatas[0];

let floatsPerVert = this.floatsPerVert;
for (let i = 0, l = local.length/2; i < l; i++) {
vec3.set(vec3_temp, local[i*2], local[i*2+1], 0);
vec3.transformMat4(vec3_temp, vec3_temp, matrix);

let dstOffset = floatsPerVert * i;
world[dstOffset] = vec3_temp.x;
world[dstOffset+1] = vec3_temp.y;
world[dstOffset+2] = vec3_temp.z;
}
},
}, assembler2D);
}
});
8 changes: 7 additions & 1 deletion cocos2d/core/renderer/webgl/assemblers/sprite/index.js
View file
Open in desktop
Expand Up @@ -6,12 +6,14 @@ import Sliced from "./2d/sliced";
import Tiled from "./2d/tiled";
import RadialFilled from "./2d/radial-filled";
import BarFilled from "./2d/bar-filled";
import Mesh from './2d/mesh';

import Simple3D from "./3d/simple";
import Sliced3D from "./3d/sliced";
import Tiled3D from "./3d/tiled";
import RadialFilled3D from "./3d/radial-filled";
import BarFilled3D from "./3d/bar-filled";
import Mesh3D from './3d/mesh';

let ctor = {
getConstructor(sprite) {
Expand All @@ -31,6 +33,8 @@ let ctor = {
} else {
ctor = is3DNode ? BarFilled3D : BarFilled;
}
case Type.MESH:
ctor = is3DNode ? Mesh3D : Mesh;
break;
}

Expand All @@ -42,12 +46,14 @@ let ctor = {
Tiled,
RadialFilled,
BarFilled,
Mesh,

Simple3D,
Sliced3D,
Tiled3D,
RadialFilled3D,
BarFilled3D
BarFilled3D,
Mesh3D,
};

Asembler.register(cc.Sprite, ctor);