mirror of
https://github.com/cocos/cocos4.git
synced 2026-11-21 16:12:40 +08:00
Merge pull request #2468 from 2youyou2/next-performance
refactor sprite assembler to optimize performance
This commit is contained in:
@@ -1974,6 +1974,7 @@ var Node = cc.Class({
|
||||
if (this._localMatDirty) {
|
||||
this._updateLocalMatrix();
|
||||
}
|
||||
|
||||
// Assume parent world matrix is correct
|
||||
if (this._parent) {
|
||||
let parentMat = this._parent._worldMatrix;
|
||||
@@ -1982,9 +1983,10 @@ var Node = cc.Class({
|
||||
else {
|
||||
math.mat4.copy(this._worldMatrix, this._matrix);
|
||||
}
|
||||
this.emit(WORLD_MATRIX_CHANGED);
|
||||
this._worldMatDirty = false;
|
||||
|
||||
this.emit(WORLD_MATRIX_CHANGED);
|
||||
|
||||
for (let i = 0, len = this._children.length; i < len; ++i) {
|
||||
let child = this._children[i];
|
||||
child._calculWorldMatrix();
|
||||
|
||||
@@ -154,6 +154,10 @@ var Sprite = cc.Class({
|
||||
name: 'cc.Sprite',
|
||||
extends: RenderComponent,
|
||||
|
||||
ctor () {
|
||||
this._assembler = null;
|
||||
},
|
||||
|
||||
editor: CC_EDITOR && {
|
||||
menu: 'i18n:MAIN_MENU.component.renderers/Sprite',
|
||||
help: 'i18n:COMPONENT.help_url.sprite',
|
||||
@@ -214,6 +218,7 @@ var Sprite = cc.Class({
|
||||
this._material = null;
|
||||
}
|
||||
this._applySpriteFrame(lastSprite);
|
||||
this._checkDirtyState(value, lastSprite);
|
||||
if (CC_EDITOR) {
|
||||
this.node.emit('spriteframe-changed', this);
|
||||
}
|
||||
@@ -238,6 +243,7 @@ var Sprite = cc.Class({
|
||||
this.destroyRenderData(this._renderData);
|
||||
this._renderData = null;
|
||||
this._type = value;
|
||||
this._updateAssembler();
|
||||
}
|
||||
},
|
||||
type: SpriteType,
|
||||
@@ -270,6 +276,7 @@ var Sprite = cc.Class({
|
||||
this._renderData.vertDirty = true;
|
||||
}
|
||||
this._fillType = value;
|
||||
this._updateAssembler();
|
||||
}
|
||||
},
|
||||
type: FillType,
|
||||
@@ -471,7 +478,44 @@ var Sprite = cc.Class({
|
||||
|
||||
onEnable: function () {
|
||||
this._super();
|
||||
|
||||
this._updateAssembler();
|
||||
|
||||
let renderData = this._renderData;
|
||||
if (!renderData) {
|
||||
renderData = this._renderData = Sprite._assembler.createData(this);
|
||||
renderData.worldMatDirty = true;
|
||||
}
|
||||
|
||||
this._activateMaterial();
|
||||
|
||||
this.node.on('size-changed', this._onNodeSizeDirty, this);
|
||||
this.node.on('anchor-changed', this._onNodeSizeDirty, this);
|
||||
this.node.on('world-matrix-changed', this._onNodeMatrixDirty, this);
|
||||
},
|
||||
|
||||
onDisable: function () {
|
||||
this._super();
|
||||
|
||||
this.node.off('size-changed', this._onNodeSizeDirty, this);
|
||||
this.node.off('anchor-changed', this._onNodeSizeDirty, this);
|
||||
this.node.off('world-matrix-changed', this._onNodeMatrixDirty, this);
|
||||
},
|
||||
|
||||
_onNodeSizeDirty () {
|
||||
if (this._renderData) {
|
||||
this._renderData.vertDirty = true;
|
||||
}
|
||||
},
|
||||
|
||||
_onNodeMatrixDirty () {
|
||||
if (this._renderData) {
|
||||
this._renderData.worldMatDirty = true;
|
||||
}
|
||||
},
|
||||
|
||||
_updateAssembler: function () {
|
||||
this._assembler = Sprite._assembler.getAssembler(this);
|
||||
},
|
||||
|
||||
_activateMaterial: function () {
|
||||
@@ -505,6 +549,10 @@ var Sprite = cc.Class({
|
||||
else {
|
||||
this._material.updateHash();
|
||||
}
|
||||
|
||||
if (this._renderData) {
|
||||
this._renderData.material = this._material;
|
||||
}
|
||||
},
|
||||
|
||||
_updateBlendFunc: function () {
|
||||
@@ -534,6 +582,42 @@ var Sprite = cc.Class({
|
||||
}
|
||||
},
|
||||
|
||||
_checkDirtyState (spriteFrame, oldSpriteFrame) {
|
||||
let renderData = this._renderData;
|
||||
if (!renderData) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (!spriteFrame || !oldSpriteFrame) {
|
||||
renderData.uvDirty = true;
|
||||
renderData.vertDirty = true;
|
||||
return;
|
||||
}
|
||||
|
||||
let rect = spriteFrame._rect,
|
||||
oldRect = oldSpriteFrame._rect;
|
||||
let rectSizeChanged = rect.width !== oldRect.width || rect.height !== oldRect.height;
|
||||
if (rect.x !== oldRect.x ||
|
||||
rect.y !== oldRect.y ||
|
||||
rectSizeChanged ||
|
||||
spriteFrame._rotated !== oldSpriteFrame._rotated ||
|
||||
spriteFrame._texture.width !== oldSpriteFrame._texture.width) {
|
||||
renderData.uvDirty = true;
|
||||
}
|
||||
|
||||
let originalSize = spriteFrame._originalSize,
|
||||
oldOriginalSize = oldSpriteFrame._originalSize,
|
||||
offset = spriteFrame._offset,
|
||||
oldOffset = oldSpriteFrame._offset;
|
||||
if (rectSizeChanged ||
|
||||
originalSize.width !== oldOriginalSize.width ||
|
||||
originalSize.height !== oldOriginalSize.height ||
|
||||
offset.x !== oldOffset.x ||
|
||||
offset.y !== oldOffset.y) {
|
||||
renderData.vertDirty = true;
|
||||
}
|
||||
},
|
||||
|
||||
_applySpriteSize: function () {
|
||||
if (this._spriteFrame) {
|
||||
if (SizeMode.RAW === this._sizeMode) {
|
||||
@@ -550,11 +634,6 @@ var Sprite = cc.Class({
|
||||
if (!this.isValid) {
|
||||
return;
|
||||
}
|
||||
// Mark render data dirty
|
||||
if (this._renderData) {
|
||||
this._renderData.uvDirty = true;
|
||||
this._renderData.vertDirty = true;
|
||||
}
|
||||
// Reactivate material
|
||||
if (this.enabledInHierarchy) {
|
||||
this._activateMaterial();
|
||||
@@ -568,7 +647,7 @@ var Sprite = cc.Class({
|
||||
}
|
||||
|
||||
var spriteFrame = this._spriteFrame;
|
||||
if (spriteFrame) {
|
||||
if (spriteFrame && (!oldFrame || spriteFrame._texture !== oldFrame._texture)) {
|
||||
if (spriteFrame.textureLoaded()) {
|
||||
this._onTextureLoaded(null);
|
||||
}
|
||||
|
||||
@@ -31,7 +31,7 @@ const Overflow = Label.Overflow;
|
||||
|
||||
const TextUtils = require('../../../utils/text-utils').TextUtils;
|
||||
|
||||
const spriteAssembler = require('../sprite/simple');
|
||||
const ttf = require('./ttf-assembler');
|
||||
|
||||
let FontLetterDefinition = function() {
|
||||
this._u = 0;
|
||||
@@ -158,7 +158,7 @@ module.exports = {
|
||||
this._resetProperties();
|
||||
},
|
||||
|
||||
fillVertexBuffer: spriteAssembler.fillVertexBuffer,
|
||||
fillVertexBuffer: ttf.fillVertexBuffer,
|
||||
|
||||
fillIndexBuffer (comp, offset, vertexId, ibuf) {
|
||||
let renderData = comp._renderData;
|
||||
|
||||
@@ -124,8 +124,7 @@ let maskFrontAssembler = js.addon({
|
||||
|
||||
// vertex buffer
|
||||
if (mask._type === Mask.Type.IMAGE_STENCIL) {
|
||||
spriteAssembler.fillVertexBuffer(mask, batchData.byteOffset / 4, vbuf, uintbuf);
|
||||
spriteAssembler.fillIndexBuffer(mask, batchData.indiceOffset, vertexId, ibuf);
|
||||
spriteAssembler.fillBuffers(mask, batchData, vertexId, vbuf, uintbuf, ibuf);
|
||||
}
|
||||
else {
|
||||
// Share node for correct global matrix
|
||||
|
||||
@@ -29,14 +29,6 @@ const FillType = Sprite.FillType;
|
||||
const simpleRenderUtil = require('./simple');
|
||||
|
||||
module.exports = {
|
||||
createData (sprite) {
|
||||
let renderData = sprite.requestRenderData();
|
||||
renderData.dataLength = 4;
|
||||
renderData.vertexCount = 4;
|
||||
renderData.indiceCount = 6;
|
||||
return renderData;
|
||||
},
|
||||
|
||||
update (sprite) {
|
||||
let renderData = sprite._renderData;
|
||||
let uvDirty = renderData.uvDirty,
|
||||
@@ -71,6 +63,9 @@ module.exports = {
|
||||
if (vertDirty) {
|
||||
this.updateVerts(sprite, fillStart, fillEnd);
|
||||
}
|
||||
if (renderData.worldMatDirty) {
|
||||
this.updateWorldVerts(sprite);
|
||||
}
|
||||
},
|
||||
|
||||
updateUVs (sprite, fillStart, fillEnd) {
|
||||
@@ -136,13 +131,13 @@ module.exports = {
|
||||
|
||||
renderData.uvDirty = false;
|
||||
},
|
||||
|
||||
updateVerts (sprite, fillStart, fillEnd) {
|
||||
let renderData = sprite._renderData,
|
||||
data = renderData._data,
|
||||
width = renderData._width,
|
||||
height = renderData._height,
|
||||
appx = renderData._pivotX * width,
|
||||
appy = renderData._pivotY * height;
|
||||
node = sprite.node,
|
||||
width = node.width, height = node.height,
|
||||
appx = node.anchorX * width, appy = node.anchorY * height;
|
||||
|
||||
let l = -appx, b = -appy,
|
||||
r = width-appx, t = height-appy;
|
||||
@@ -168,18 +163,19 @@ module.exports = {
|
||||
break;
|
||||
}
|
||||
|
||||
data[0].x = l;
|
||||
data[0].y = b;
|
||||
data[1].x = r;
|
||||
data[1].y = b;
|
||||
data[2].x = l;
|
||||
data[2].y = t;
|
||||
data[3].x = r;
|
||||
data[3].y = t;
|
||||
data[4].x = l;
|
||||
data[4].y = b;
|
||||
data[5].x = r;
|
||||
data[5].y = b;
|
||||
data[6].x = l;
|
||||
data[6].y = t;
|
||||
data[7].x = r;
|
||||
data[7].y = t;
|
||||
|
||||
renderData.vertDirty = false;
|
||||
},
|
||||
|
||||
fillVertexBuffer: simpleRenderUtil.fillVertexBuffer,
|
||||
fillIndexBuffer: simpleRenderUtil.fillIndexBuffer
|
||||
updateWorldVerts: simpleRenderUtil.updateWorldVerts,
|
||||
createData: simpleRenderUtil.createData,
|
||||
fillBuffers: simpleRenderUtil.fillBuffers
|
||||
};
|
||||
|
||||
@@ -239,11 +239,9 @@ module.exports = {
|
||||
},
|
||||
|
||||
_calculateVertices : function (sprite) {
|
||||
let renderData = sprite._renderData,
|
||||
width = renderData._width,
|
||||
height = renderData._height,
|
||||
appx = renderData._pivotX * width,
|
||||
appy = renderData._pivotY * height;
|
||||
let node = sprite.node,
|
||||
width = node.width, height = node.height,
|
||||
appx = node.anchorX * width, appy = node.anchorY * height;
|
||||
|
||||
let l = -appx, b = -appy,
|
||||
r = width-appx, t = height-appy;
|
||||
@@ -315,12 +313,32 @@ module.exports = {
|
||||
}
|
||||
},
|
||||
|
||||
fillVertexBuffer: simpleRenderUtil.fillVertexBuffer,
|
||||
fillBuffers (sprite, batchData, vertexId, vbuf, uintbuf, ibuf) {
|
||||
let vertexOffset = batchData.byteOffset / 4,
|
||||
indiceOffset = batchData.indiceOffset;
|
||||
|
||||
fillIndexBuffer (sprite, offset, vertexId, ibuf) {
|
||||
let renderData = sprite._renderData;
|
||||
for (let i = 0, l = renderData.vertexCount; i < l; i++) {
|
||||
ibuf[offset+i] = vertexId+i;
|
||||
let data = sprite._renderData._data;
|
||||
let node = sprite.node;
|
||||
let z = node._position.z;
|
||||
let color = node._color._val;
|
||||
|
||||
let matrix = node._worldMatrix;
|
||||
a = matrix.m00, b = matrix.m01, c = matrix.m04, d = matrix.m05,
|
||||
tx = matrix.m12, ty = matrix.m13;
|
||||
|
||||
let count = data.length;
|
||||
for (let i = 0; i < count; i++) {
|
||||
let vert = data[i];
|
||||
vbuf[vertexOffset ++] = vert.x * a + vert.y * c + tx;
|
||||
vbuf[vertexOffset ++] = vert.x * b + vert.y * d + ty;
|
||||
vbuf[vertexOffset ++] = z;
|
||||
uintbuf[vertexOffset ++] = color;
|
||||
vbuf[vertexOffset ++] = vert.u;
|
||||
vbuf[vertexOffset ++] = vert.v;
|
||||
}
|
||||
|
||||
for (let i = 0; i < count; i++) {
|
||||
ibuf[indiceOffset+i] = vertexId+i;
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
@@ -25,23 +25,63 @@
|
||||
|
||||
const Sprite = require('../../../components/CCSprite');
|
||||
|
||||
module.exports = {
|
||||
createData (sprite) {
|
||||
let renderData = sprite.requestRenderData();
|
||||
renderData.dataLength = 4;
|
||||
renderData.vertexCount = 4;
|
||||
renderData.indiceCount = 6;
|
||||
return renderData;
|
||||
},
|
||||
const js = require('../../../platform/js');
|
||||
const assembler = require('../assembler');
|
||||
|
||||
module.exports = js.addon({
|
||||
useModel: false,
|
||||
|
||||
update (sprite) {
|
||||
let renderData = sprite._renderData;
|
||||
|
||||
if (renderData.uvDirty) {
|
||||
this.updateUVs(sprite);
|
||||
}
|
||||
if (renderData.vertDirty) {
|
||||
|
||||
let vertDirty = renderData.vertDirty;
|
||||
if (vertDirty) {
|
||||
this.updateVerts(sprite);
|
||||
}
|
||||
if (vertDirty || renderData.worldMatDirty) {
|
||||
this.updateWorldVerts(sprite);
|
||||
}
|
||||
},
|
||||
|
||||
fillBuffers (sprite, batchData, vertexId, vbuf, uintbuf, ibuf) {
|
||||
let vertexOffset = batchData.byteOffset / 4,
|
||||
indiceOffset = batchData.indiceOffset;
|
||||
|
||||
let data = sprite._renderData._data;
|
||||
let node = sprite.node;
|
||||
let z = node._position.z;
|
||||
let color = node._color._val;
|
||||
|
||||
for (let i = 0; i < 4; i++) {
|
||||
let vert = data[i];
|
||||
vbuf[vertexOffset ++] = vert.x;
|
||||
vbuf[vertexOffset ++] = vert.y;
|
||||
vbuf[vertexOffset ++] = z;
|
||||
uintbuf[vertexOffset ++] = color;
|
||||
vbuf[vertexOffset ++] = vert.u;
|
||||
vbuf[vertexOffset ++] = vert.v;
|
||||
}
|
||||
|
||||
ibuf[indiceOffset ++] = vertexId;
|
||||
ibuf[indiceOffset ++] = vertexId + 1;
|
||||
ibuf[indiceOffset ++] = vertexId + 2;
|
||||
ibuf[indiceOffset ++] = vertexId + 1;
|
||||
ibuf[indiceOffset ++] = vertexId + 3;
|
||||
ibuf[indiceOffset ++] = vertexId + 2;
|
||||
},
|
||||
|
||||
createData (sprite) {
|
||||
let renderData = sprite.requestRenderData();
|
||||
// 0-4 for world verts
|
||||
// 5-8 for local verts
|
||||
renderData.dataLength = 8;
|
||||
renderData.vertexCount = 4;
|
||||
renderData.indiceCount = 6;
|
||||
return renderData;
|
||||
},
|
||||
|
||||
updateUVs (sprite) {
|
||||
@@ -88,13 +128,30 @@ module.exports = {
|
||||
}
|
||||
},
|
||||
|
||||
updateWorldVerts (sprite) {
|
||||
let node = sprite.node,
|
||||
renderData = sprite._renderData,
|
||||
data = renderData._data,
|
||||
matrix = node._worldMatrix;
|
||||
let a = matrix.m00, b = matrix.m01, c = matrix.m04, d = matrix.m05,
|
||||
tx = matrix.m12, ty = matrix.m13;
|
||||
|
||||
for (let i = 0; i < 4; i++) {
|
||||
let local = data[i+4];
|
||||
let world = data[i];
|
||||
world.x = local.x * a + local.y * c + tx;
|
||||
world.y = local.x * b + local.y * d + ty;
|
||||
}
|
||||
|
||||
renderData.worldMatDirty = false;
|
||||
},
|
||||
|
||||
updateVerts (sprite) {
|
||||
let renderData = sprite._renderData,
|
||||
node = sprite.node,
|
||||
data = renderData._data,
|
||||
cw = renderData._width,
|
||||
ch = renderData._height,
|
||||
appx = renderData._pivotX * cw,
|
||||
appy = renderData._pivotY * ch,
|
||||
cw = node.width, ch = node.height,
|
||||
appx = node.anchorX * cw, appy = node.anchorY * ch,
|
||||
l, b, r, t;
|
||||
if (sprite.trim) {
|
||||
l = -appx;
|
||||
@@ -104,13 +161,10 @@ module.exports = {
|
||||
}
|
||||
else {
|
||||
let frame = sprite.spriteFrame,
|
||||
ow = frame._originalSize.width,
|
||||
oh = frame._originalSize.height,
|
||||
rw = frame._rect.width,
|
||||
rh = frame._rect.height,
|
||||
ow = frame._originalSize.width, oh = frame._originalSize.height,
|
||||
rw = frame._rect.width, rh = frame._rect.height,
|
||||
offset = frame._offset,
|
||||
scaleX = cw / ow,
|
||||
scaleY = ch / oh;
|
||||
scaleX = cw / ow, scaleY = ch / oh;
|
||||
let trimLeft = offset.x + (ow - rw) / 2;
|
||||
let trimRight = offset.x - (ow - rw) / 2;
|
||||
let trimBottom = offset.y + (oh - rh) / 2;
|
||||
@@ -121,54 +175,15 @@ module.exports = {
|
||||
t = ch + trimTop * scaleY - appy;
|
||||
}
|
||||
|
||||
data[0].x = l;
|
||||
data[0].y = b;
|
||||
data[1].x = r;
|
||||
data[1].y = b;
|
||||
data[2].x = l;
|
||||
data[2].y = t;
|
||||
data[3].x = r;
|
||||
data[3].y = t;
|
||||
data[4].x = l;
|
||||
data[4].y = b;
|
||||
data[5].x = r;
|
||||
data[5].y = b;
|
||||
data[6].x = l;
|
||||
data[6].y = t;
|
||||
data[7].x = r;
|
||||
data[7].y = t;
|
||||
|
||||
renderData.vertDirty = false;
|
||||
},
|
||||
|
||||
fillVertexBuffer (sprite, index, vbuf, uintbuf) {
|
||||
let node = sprite.node;
|
||||
let renderData = sprite._renderData;
|
||||
let data = renderData._data;
|
||||
let z = node._position.z;
|
||||
let color = node._color._val;
|
||||
|
||||
node._updateWorldMatrix();
|
||||
let matrix = node._worldMatrix;
|
||||
let a = matrix.m00,
|
||||
b = matrix.m01,
|
||||
c = matrix.m04,
|
||||
d = matrix.m05,
|
||||
tx = matrix.m12,
|
||||
ty = matrix.m13;
|
||||
|
||||
let vert;
|
||||
let length = renderData.dataLength;
|
||||
for (let i = 0; i < length; i++) {
|
||||
vert = data[i];
|
||||
vbuf[index + 0] = vert.x * a + vert.y * c + tx;
|
||||
vbuf[index + 1] = vert.x * b + vert.y * d + ty;
|
||||
vbuf[index + 2] = z;
|
||||
vbuf[index + 4] = vert.u;
|
||||
vbuf[index + 5] = vert.v;
|
||||
uintbuf[index + 3] = color;
|
||||
index += 6;
|
||||
}
|
||||
},
|
||||
|
||||
fillIndexBuffer (sprite, offset, vertexId, ibuf) {
|
||||
ibuf[offset + 0] = vertexId;
|
||||
ibuf[offset + 1] = vertexId + 1;
|
||||
ibuf[offset + 2] = vertexId + 2;
|
||||
ibuf[offset + 3] = vertexId + 1;
|
||||
ibuf[offset + 4] = vertexId + 3;
|
||||
ibuf[offset + 5] = vertexId + 2;
|
||||
}
|
||||
};
|
||||
}, assembler);
|
||||
|
||||
@@ -26,25 +26,20 @@
|
||||
const Sprite = require('../../../components/CCSprite');
|
||||
const FillType = Sprite.FillType;
|
||||
|
||||
const simpleRenderUtil = require('./simple');
|
||||
|
||||
module.exports = {
|
||||
createData (sprite) {
|
||||
let renderData = sprite.requestRenderData();
|
||||
renderData.dataLength = 4;
|
||||
// 0-4 for local verts
|
||||
// 5-20 for world verts
|
||||
renderData.dataLength = 20;
|
||||
|
||||
renderData.vertexCount = 16;
|
||||
renderData.indiceCount = 54;
|
||||
return renderData;
|
||||
},
|
||||
|
||||
update (sprite) {
|
||||
let renderData = sprite._renderData;
|
||||
if (renderData.uvDirty) {
|
||||
this.updateUVs(sprite);
|
||||
}
|
||||
if (renderData.vertDirty) {
|
||||
this.updateVerts(sprite);
|
||||
}
|
||||
},
|
||||
|
||||
updateUVs (sprite) {
|
||||
let material = sprite.getMaterial();
|
||||
let renderData = sprite._renderData;
|
||||
@@ -92,10 +87,9 @@ module.exports = {
|
||||
updateVerts (sprite) {
|
||||
let renderData = sprite._renderData,
|
||||
data = renderData._data,
|
||||
width = renderData._width,
|
||||
height = renderData._height,
|
||||
appx = renderData._pivotX * width,
|
||||
appy = renderData._pivotY * height;
|
||||
node = sprite.node,
|
||||
width = node.width, height = node.height,
|
||||
appx = node.anchorX * width, appy = node.anchorY * height;
|
||||
|
||||
let frame = sprite.spriteFrame;
|
||||
let rect = frame._rect;
|
||||
@@ -112,6 +106,7 @@ module.exports = {
|
||||
yScale = (isNaN(yScale) || yScale > 1) ? 1 : yScale;
|
||||
sizableWidth = sizableWidth < 0 ? 0 : sizableWidth;
|
||||
sizableHeight = sizableHeight < 0 ? 0 : sizableHeight;
|
||||
|
||||
data[0].x = -appx;
|
||||
data[0].y = -appy;
|
||||
data[1].x = leftWidth * xScale - appx;
|
||||
@@ -123,51 +118,63 @@ module.exports = {
|
||||
|
||||
renderData.vertDirty = false;
|
||||
},
|
||||
|
||||
fillVertexBuffer (sprite, index, vbuf, uintbuf) {
|
||||
let node = sprite.node;
|
||||
let renderData = sprite._renderData;
|
||||
let data = renderData._data;
|
||||
let z = node._position.z;
|
||||
|
||||
let color = node._color._val;
|
||||
|
||||
node._updateWorldMatrix();
|
||||
let matrix = node._worldMatrix;
|
||||
let a = matrix.m00,
|
||||
b = matrix.m01,
|
||||
c = matrix.m04,
|
||||
d = matrix.m05,
|
||||
tx = matrix.m12,
|
||||
ty = matrix.m13;
|
||||
|
||||
let colD, rowD;
|
||||
for (let row = 0; row < 4; ++row) {
|
||||
rowD = data[row];
|
||||
for (let col = 0; col < 4; ++col) {
|
||||
colD = data[col];
|
||||
vbuf[index] = colD.x*a + rowD.y*c + tx;
|
||||
vbuf[index + 1] = colD.x*b + rowD.y*d + ty;
|
||||
vbuf[index + 2] = z;
|
||||
vbuf[index + 4] = colD.u;
|
||||
vbuf[index + 5] = rowD.v;
|
||||
uintbuf[index + 3] = color;
|
||||
index += 6;
|
||||
}
|
||||
fillBuffers (sprite, batchData, vertexId, vbuf, uintbuf, ibuf) {
|
||||
let vertexOffset = batchData.byteOffset / 4,
|
||||
indiceOffset = batchData.indiceOffset;
|
||||
|
||||
let node = sprite.node;
|
||||
let z = node._position.z;
|
||||
let color = node._color._val;
|
||||
|
||||
let data = sprite._renderData._data;
|
||||
for (let i = 4; i < 20; ++i) {
|
||||
let vert = data[i];
|
||||
|
||||
vbuf[vertexOffset] = vert.x;
|
||||
vbuf[vertexOffset + 1] = vert.y;
|
||||
vbuf[vertexOffset + 2] = z;
|
||||
vbuf[vertexOffset + 4] = vert.u;
|
||||
vbuf[vertexOffset + 5] = vert.v;
|
||||
uintbuf[vertexOffset + 3] = color;
|
||||
vertexOffset += 6;
|
||||
}
|
||||
},
|
||||
|
||||
fillIndexBuffer (sprite, offset, vertexId, ibuf) {
|
||||
|
||||
for (let r = 0; r < 3; ++r) {
|
||||
for (let c = 0; c < 3; ++c) {
|
||||
let start = vertexId + r*4 + c;
|
||||
ibuf[offset++] = start;
|
||||
ibuf[offset++] = start + 1;
|
||||
ibuf[offset++] = start + 4;
|
||||
ibuf[offset++] = start + 1;
|
||||
ibuf[offset++] = start + 5;
|
||||
ibuf[offset++] = start + 4;
|
||||
ibuf[indiceOffset++] = start;
|
||||
ibuf[indiceOffset++] = start + 1;
|
||||
ibuf[indiceOffset++] = start + 4;
|
||||
ibuf[indiceOffset++] = start + 1;
|
||||
ibuf[indiceOffset++] = start + 5;
|
||||
ibuf[indiceOffset++] = start + 4;
|
||||
}
|
||||
}
|
||||
}
|
||||
},
|
||||
|
||||
updateWorldVerts (sprite) {
|
||||
let node = sprite.node,
|
||||
renderData = sprite._renderData,
|
||||
data = renderData._data,
|
||||
matrix = node._worldMatrix;
|
||||
let a = matrix.m00, b = matrix.m01, c = matrix.m04, d = matrix.m05,
|
||||
tx = matrix.m12, ty = matrix.m13;
|
||||
|
||||
for (let row = 0; row < 4; ++row) {
|
||||
let rowD = data[row];
|
||||
for (let col = 0; col < 4; ++col) {
|
||||
let colD = data[col];
|
||||
let world = data[4 + row*4 + col];
|
||||
world.x = colD.x*a + rowD.y*c + tx;
|
||||
world.y = colD.x*b + rowD.y*d + ty;
|
||||
world.u = colD.u;
|
||||
world.v = rowD.v;
|
||||
}
|
||||
}
|
||||
|
||||
renderData.worldMatDirty = false;
|
||||
},
|
||||
|
||||
update: simpleRenderUtil.update
|
||||
};
|
||||
|
||||
@@ -36,123 +36,53 @@ const tiledRenderUtil = require('./tiled');
|
||||
const radialFilledRenderUtil = require('./radial-filled');
|
||||
const barFilledRenderUtil = require('./bar-filled');
|
||||
|
||||
let filledRenderUtil = {
|
||||
createData (sprite) {
|
||||
if (sprite._fillType === FillType.RADIAL) {
|
||||
return radialFilledRenderUtil.createData(sprite);
|
||||
}
|
||||
return barFilledRenderUtil.createData(sprite);
|
||||
},
|
||||
update (sprite) {
|
||||
if (sprite._fillType === FillType.RADIAL) {
|
||||
return radialFilledRenderUtil.update(sprite);
|
||||
}
|
||||
return barFilledRenderUtil.update(sprite);
|
||||
},
|
||||
fillVertexBuffer (sprite, index, vbuf, uintbuf) {
|
||||
if (sprite._fillType === FillType.RADIAL) {
|
||||
radialFilledRenderUtil.fillVertexBuffer(sprite, index, vbuf, uintbuf);
|
||||
}
|
||||
else {
|
||||
barFilledRenderUtil.fillVertexBuffer(sprite, index, vbuf, uintbuf);
|
||||
}
|
||||
},
|
||||
fillIndexBuffer (sprite, offset, vertexId, ibuf) {
|
||||
if (sprite._fillType === FillType.RADIAL) {
|
||||
radialFilledRenderUtil.fillIndexBuffer(sprite, offset, vertexId, ibuf);
|
||||
}
|
||||
else {
|
||||
barFilledRenderUtil.fillIndexBuffer(sprite, offset, vertexId, ibuf);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
// Inline all type switch to avoid jit deoptimization during inlined function change
|
||||
let spriteAssembler = js.addon({
|
||||
useModel: false,
|
||||
|
||||
updateRenderData (sprite) {
|
||||
// Create render data if needed
|
||||
if (!sprite._renderData) {
|
||||
switch (sprite.type) {
|
||||
case SpriteType.SIMPLE:
|
||||
sprite._renderData = simpleRenderUtil.createData(sprite);
|
||||
break;
|
||||
case SpriteType.SLICED:
|
||||
sprite._renderData = slicedRenderUtil.createData(sprite);
|
||||
break;
|
||||
case SpriteType.TILED:
|
||||
sprite._renderData = tiledRenderUtil.createData(sprite);
|
||||
break;
|
||||
case SpriteType.FILLED:
|
||||
sprite._renderData = filledRenderUtil.createData(sprite);
|
||||
break;
|
||||
}
|
||||
getAssembler (sprite) {
|
||||
let util = simpleRenderUtil;
|
||||
|
||||
switch (sprite.type) {
|
||||
case SpriteType.SLICED:
|
||||
util = slicedRenderUtil;
|
||||
break;
|
||||
case SpriteType.TILED:
|
||||
util = tiledRenderUtil;
|
||||
break;
|
||||
case SpriteType.FILLED:
|
||||
if (sprite._fillType === FillType.RADIAL) {
|
||||
util = radialFilledRenderUtil;
|
||||
}
|
||||
else {
|
||||
util = barFilledRenderUtil;
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
let renderData = sprite._renderData;
|
||||
let size = sprite.node._contentSize;
|
||||
let anchor = sprite.node._anchorPoint;
|
||||
renderData.updateSizeNPivot(size.width, size.height, anchor.x, anchor.y);
|
||||
|
||||
if (sprite.spriteFrame) {
|
||||
switch (sprite.type) {
|
||||
case SpriteType.SIMPLE:
|
||||
simpleRenderUtil.update(sprite);
|
||||
break;
|
||||
case SpriteType.SLICED:
|
||||
slicedRenderUtil.update(sprite);
|
||||
break;
|
||||
case SpriteType.TILED:
|
||||
tiledRenderUtil.update(sprite);
|
||||
break;
|
||||
case SpriteType.FILLED:
|
||||
filledRenderUtil.update(sprite);
|
||||
break;
|
||||
}
|
||||
return util;
|
||||
},
|
||||
|
||||
createData (sprite) {
|
||||
return sprite._assembler.createData(sprite);
|
||||
},
|
||||
|
||||
updateRenderData (sprite) {
|
||||
let datas = sprite.__allocedDatas;
|
||||
if (!sprite.spriteFrame) {
|
||||
return datas;
|
||||
}
|
||||
renderData.material = sprite.getMaterial();
|
||||
this.datas.length = 0;
|
||||
this.datas.push(renderData);
|
||||
return this.datas;
|
||||
|
||||
sprite._assembler.update(sprite);
|
||||
|
||||
return datas;
|
||||
},
|
||||
|
||||
fillBuffers (sprite, batchData, vertexId, vbuf, uintbuf, ibuf) {
|
||||
let vertexOffset = batchData.byteOffset / 4,
|
||||
indiceOffset = batchData.indiceOffset;
|
||||
|
||||
// vertex buffer
|
||||
switch (sprite.type) {
|
||||
case SpriteType.SIMPLE:
|
||||
simpleRenderUtil.fillVertexBuffer(sprite, vertexOffset, vbuf, uintbuf);
|
||||
break;
|
||||
case SpriteType.SLICED:
|
||||
slicedRenderUtil.fillVertexBuffer(sprite, vertexOffset, vbuf, uintbuf);
|
||||
break;
|
||||
case SpriteType.TILED:
|
||||
tiledRenderUtil.fillVertexBuffer(sprite, vertexOffset, vbuf, uintbuf);
|
||||
break;
|
||||
case SpriteType.FILLED:
|
||||
filledRenderUtil.fillVertexBuffer(sprite, vertexOffset, vbuf, uintbuf);
|
||||
break;
|
||||
}
|
||||
|
||||
// index buffer
|
||||
switch (sprite.type) {
|
||||
case SpriteType.SIMPLE:
|
||||
simpleRenderUtil.fillIndexBuffer(sprite, indiceOffset, vertexId, ibuf);
|
||||
break;
|
||||
case SpriteType.SLICED:
|
||||
slicedRenderUtil.fillIndexBuffer(sprite, indiceOffset, vertexId, ibuf);
|
||||
break;
|
||||
case SpriteType.TILED:
|
||||
tiledRenderUtil.fillIndexBuffer(sprite, indiceOffset, vertexId, ibuf);
|
||||
break;
|
||||
case SpriteType.FILLED:
|
||||
filledRenderUtil.fillIndexBuffer(sprite, indiceOffset, vertexId, ibuf);
|
||||
break;
|
||||
}
|
||||
sprite._assembler.fillBuffers(sprite, batchData, vertexId, vbuf, uintbuf, ibuf);
|
||||
}
|
||||
}, assembler);
|
||||
|
||||
module.exports = Sprite._assembler = spriteAssembler;
|
||||
Sprite._assembler = spriteAssembler;
|
||||
|
||||
module.exports = spriteAssembler;
|
||||
|
||||
@@ -42,8 +42,12 @@ module.exports = {
|
||||
texh = texture._height;
|
||||
let frame = sprite.spriteFrame;
|
||||
let rect = frame._rect;
|
||||
let contentWidth = Math.abs(renderData._width);
|
||||
let contentHeight = Math.abs(renderData._height);
|
||||
|
||||
let node = sprite.node,
|
||||
contentWidth = Math.abs(node.width),
|
||||
contentHeight = Math.abs(node.height),
|
||||
appx = node.anchorX * contentWidth,
|
||||
appy = node.anchorY * contentHeight;
|
||||
|
||||
let rectWidth = rect.width;
|
||||
let rectHeight = rect.height;
|
||||
@@ -104,9 +108,6 @@ module.exports = {
|
||||
data[7].v = data[6].v;
|
||||
}
|
||||
|
||||
let appx = renderData._pivotX * contentWidth,
|
||||
appy = renderData._pivotY * contentHeight;
|
||||
|
||||
for (let i = 0; i <= col; ++i) {
|
||||
data[i].x = Math.min(rectWidth * i, contentWidth) - appx;
|
||||
}
|
||||
@@ -122,7 +123,11 @@ module.exports = {
|
||||
renderData.vertDirty = false;
|
||||
},
|
||||
|
||||
fillVertexBuffer (sprite, index, vbuf, uintbuf) {
|
||||
fillBuffers (sprite, batchData, vertexId, vbuf, uintbuf, ibuf) {
|
||||
let vertexOffset = batchData.byteOffset / 4,
|
||||
indiceOffset = batchData.indiceOffset;
|
||||
|
||||
// update verts
|
||||
let node = sprite.node;
|
||||
let renderData = sprite._renderData;
|
||||
let data = renderData._data;
|
||||
@@ -130,8 +135,8 @@ module.exports = {
|
||||
let color = node._color._val;
|
||||
|
||||
let rect = sprite.spriteFrame._rect;
|
||||
let contentWidth = Math.abs(renderData._width);
|
||||
let contentHeight = Math.abs(renderData._height);
|
||||
let contentWidth = Math.abs(node.width);
|
||||
let contentHeight = Math.abs(node.height);
|
||||
let hRepeat = contentWidth / rect.width;
|
||||
let vRepeat = contentHeight / rect.height;
|
||||
let row = Math.ceil(vRepeat),
|
||||
@@ -157,50 +162,48 @@ module.exports = {
|
||||
x1 = data[xindex+1].x;
|
||||
|
||||
// lb
|
||||
vbuf[index++] = x * a + y * c + tx;
|
||||
vbuf[index++] = x * b + y * d + ty;
|
||||
vbuf[index++] = z;
|
||||
uintbuf[index++] = color;
|
||||
vbuf[index++] = lastx ? data[4].u : data[0].u;
|
||||
vbuf[index++] = lasty ? data[4].v : data[0].v;
|
||||
vbuf[vertexOffset++] = x * a + y * c + tx;
|
||||
vbuf[vertexOffset++] = x * b + y * d + ty;
|
||||
vbuf[vertexOffset++] = z;
|
||||
uintbuf[vertexOffset++] = color;
|
||||
vbuf[vertexOffset++] = lastx ? data[4].u : data[0].u;
|
||||
vbuf[vertexOffset++] = lasty ? data[4].v : data[0].v;
|
||||
|
||||
// rb
|
||||
vbuf[index++] = x1 * a + y * c + tx;
|
||||
vbuf[index++] = x1 * b + y * d + ty;
|
||||
vbuf[index++] = z;
|
||||
uintbuf[index++] = color;
|
||||
vbuf[index++] = lastx ? data[5].u : data[1].u;
|
||||
vbuf[index++] = lasty ? data[5].v : data[1].v;
|
||||
vbuf[vertexOffset++] = x1 * a + y * c + tx;
|
||||
vbuf[vertexOffset++] = x1 * b + y * d + ty;
|
||||
vbuf[vertexOffset++] = z;
|
||||
uintbuf[vertexOffset++] = color;
|
||||
vbuf[vertexOffset++] = lastx ? data[5].u : data[1].u;
|
||||
vbuf[vertexOffset++] = lasty ? data[5].v : data[1].v;
|
||||
|
||||
// lt
|
||||
vbuf[index++] = x * a + y1 * c + tx;
|
||||
vbuf[index++] = x * b + y1 * d + ty;
|
||||
vbuf[index++] = z;
|
||||
uintbuf[index++] = color;
|
||||
vbuf[index++] = lastx ? data[6].u : data[2].u;
|
||||
vbuf[index++] = lasty ? data[6].v : data[2].v;
|
||||
vbuf[vertexOffset++] = x * a + y1 * c + tx;
|
||||
vbuf[vertexOffset++] = x * b + y1 * d + ty;
|
||||
vbuf[vertexOffset++] = z;
|
||||
uintbuf[vertexOffset++] = color;
|
||||
vbuf[vertexOffset++] = lastx ? data[6].u : data[2].u;
|
||||
vbuf[vertexOffset++] = lasty ? data[6].v : data[2].v;
|
||||
|
||||
// rt
|
||||
vbuf[index++] = x1 * a + y1 * c + tx;
|
||||
vbuf[index++] = x1 * b + y1 * d + ty;
|
||||
vbuf[index++] = z;
|
||||
uintbuf[index++] = color;
|
||||
vbuf[index++] = lastx ? data[7].u : data[3].u;
|
||||
vbuf[index++] = lasty ? data[7].v : data[3].v;
|
||||
vbuf[vertexOffset++] = x1 * a + y1 * c + tx;
|
||||
vbuf[vertexOffset++] = x1 * b + y1 * d + ty;
|
||||
vbuf[vertexOffset++] = z;
|
||||
uintbuf[vertexOffset++] = color;
|
||||
vbuf[vertexOffset++] = lastx ? data[7].u : data[3].u;
|
||||
vbuf[vertexOffset++] = lasty ? data[7].v : data[3].v;
|
||||
}
|
||||
}
|
||||
},
|
||||
|
||||
fillIndexBuffer (sprite, offset, vertexId, ibuf) {
|
||||
let renderData = sprite._renderData;
|
||||
|
||||
// update indices
|
||||
let length = renderData.indiceCount;
|
||||
for (let i = 0; i < length; i+=6) {
|
||||
ibuf[offset++] = vertexId;
|
||||
ibuf[offset++] = vertexId+1;
|
||||
ibuf[offset++] = vertexId+2;
|
||||
ibuf[offset++] = vertexId+1;
|
||||
ibuf[offset++] = vertexId+3;
|
||||
ibuf[offset++] = vertexId+2;
|
||||
ibuf[indiceOffset++] = vertexId;
|
||||
ibuf[indiceOffset++] = vertexId+1;
|
||||
ibuf[indiceOffset++] = vertexId+2;
|
||||
ibuf[indiceOffset++] = vertexId+1;
|
||||
ibuf[indiceOffset++] = vertexId+3;
|
||||
ibuf[indiceOffset++] = vertexId+2;
|
||||
vertexId += 4;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -40,7 +40,6 @@ const MAX_VERTEX_BYTES = MAX_VERTEX * defaultVertexFormat._bytes;
|
||||
const MAX_INDICE = MAX_VERTEX * BYTE_PER_INDEX;
|
||||
const MAX_INDICE_BYTES = MAX_INDICE * 2;
|
||||
|
||||
var _queue = null;
|
||||
var _batchData = {
|
||||
node: null,
|
||||
vfmt: null,
|
||||
@@ -93,7 +92,6 @@ var RenderComponentWalker = function (device, renderScene) {
|
||||
return new renderEngine.Model();
|
||||
}, 16);
|
||||
|
||||
this._queue = [];
|
||||
this._batchedModels = [];
|
||||
this._dummyNode = new cc.Node();
|
||||
this._sortKey = 0;
|
||||
@@ -141,6 +139,10 @@ RenderComponentWalker.prototype = {
|
||||
},
|
||||
|
||||
_handleRender (node) {
|
||||
if (node._localMatDirty) {
|
||||
node._calculWorldMatrix();
|
||||
}
|
||||
|
||||
if (node.groupIndex !== 0) {
|
||||
this._curCameraNode = node;
|
||||
}
|
||||
@@ -150,14 +152,14 @@ RenderComponentWalker.prototype = {
|
||||
|
||||
let comp = node._renderComponent;
|
||||
if (comp) {
|
||||
_queue.push(comp);
|
||||
this.renderComp(comp, comp.constructor._assembler);
|
||||
}
|
||||
},
|
||||
|
||||
_postHandleRender (node) {
|
||||
let comp = node._renderComponent;
|
||||
if (comp && comp.constructor._postAssembler) {
|
||||
_queue.push(comp);
|
||||
this.renderComp(comp, comp.constructor._postAssembler);
|
||||
}
|
||||
|
||||
if (this._curCameraNode === node) {
|
||||
@@ -249,92 +251,71 @@ RenderComponentWalker.prototype = {
|
||||
this._renderScene.addModel(model);
|
||||
},
|
||||
|
||||
batchQueue () {
|
||||
let vertexId = 0,
|
||||
comp = this._queue[0],
|
||||
material = null,
|
||||
assembler = null,
|
||||
renderComp (comp, assembler) {
|
||||
if (!assembler) {
|
||||
return;
|
||||
}
|
||||
|
||||
let material = null,
|
||||
datas = null,
|
||||
data = null,
|
||||
cullingMask = 1,
|
||||
broken = false,
|
||||
iaData = false;
|
||||
|
||||
for (let i = 0, len = this._queue.length; i < len; i++) {
|
||||
comp = this._queue[i];
|
||||
if (comp._toPostHandle) {
|
||||
assembler = comp.constructor._postAssembler;
|
||||
comp._toPostHandle = false;
|
||||
}
|
||||
else {
|
||||
assembler = comp.constructor._assembler;
|
||||
if (comp.constructor._postAssembler) {
|
||||
comp._toPostHandle = true;
|
||||
}
|
||||
}
|
||||
if (!assembler) {
|
||||
// Update render data
|
||||
datas = assembler.updateRenderData(comp, _batchData);
|
||||
|
||||
cullingMask = comp.node._cullingMask;
|
||||
|
||||
for (let id = 0; id < datas.length; id ++) {
|
||||
data = datas[id];
|
||||
material = data.material;
|
||||
// Nothing can be rendered without material
|
||||
if (!material) {
|
||||
continue;
|
||||
}
|
||||
|
||||
// Update render data
|
||||
datas = assembler.updateRenderData(comp, _batchData);
|
||||
|
||||
cullingMask = comp.node._cullingMask;
|
||||
// Check ia data, each ia data should be packed into a separated model
|
||||
iaData = data.type === IARenderData.type;
|
||||
|
||||
for (let id = 0; id < datas.length; id ++) {
|
||||
data = datas[id];
|
||||
material = data.material;
|
||||
// Nothing can be rendered without material
|
||||
if (!material) {
|
||||
continue;
|
||||
}
|
||||
// breaking batch
|
||||
broken = iaData ||
|
||||
!_batchData.material || _batchData.material._hash != material._hash ||
|
||||
_batchData.cullingMask !== cullingMask ||
|
||||
(_batchData.vertexOffset + data.vertexCount > MAX_VERTEX) ||
|
||||
(_batchData.indiceOffset + data.indiceCount > MAX_INDICE);
|
||||
if (broken) {
|
||||
this._flush(_batchData);
|
||||
_batchData.node = assembler.useModel ? comp.node : this._dummyNode;
|
||||
_batchData.material = material;
|
||||
_batchData.vfmt = comp._vertexFormat;
|
||||
_batchData.vertexOffset = 0;
|
||||
_batchData.byteOffset = 0;
|
||||
_batchData.indiceOffset = 0;
|
||||
_batchData.cullingMask = cullingMask;
|
||||
}
|
||||
|
||||
// Check ia data, each ia data should be packed into a separated model
|
||||
iaData = data.type === IARenderData.type;
|
||||
|
||||
// breaking batch
|
||||
broken = iaData ||
|
||||
!_batchData.material || _batchData.material._hash != material._hash ||
|
||||
_batchData.cullingMask !== cullingMask ||
|
||||
(_batchData.vertexOffset + data.vertexCount > MAX_VERTEX) ||
|
||||
(_batchData.indiceOffset + data.indiceCount > MAX_INDICE);
|
||||
if (broken) {
|
||||
this._flush(_batchData);
|
||||
_batchData.node = assembler.useModel ? comp.node : this._dummyNode;
|
||||
_batchData.material = material;
|
||||
_batchData.vfmt = comp._vertexFormat;
|
||||
_batchData.vertexOffset = 0;
|
||||
_batchData.byteOffset = 0;
|
||||
_batchData.indiceOffset = 0;
|
||||
_batchData.cullingMask = cullingMask;
|
||||
}
|
||||
|
||||
_batchData.data = data;
|
||||
if (iaData) {
|
||||
this._flushIA(_batchData);
|
||||
}
|
||||
else {
|
||||
assembler.fillBuffers(comp, _batchData, _batchData.vertexOffset, this._vData, this._uintVData, this._iData);
|
||||
_batchData.vertexOffset += data.vertexCount;
|
||||
_batchData.byteOffset += data.vertexCount * comp._vertexFormat._bytes;
|
||||
_batchData.indiceOffset += data.indiceCount;
|
||||
}
|
||||
_batchData.data = data;
|
||||
if (iaData) {
|
||||
this._flushIA(_batchData);
|
||||
}
|
||||
else {
|
||||
assembler.fillBuffers(comp, _batchData, _batchData.vertexOffset, this._vData, this._uintVData, this._iData);
|
||||
_batchData.vertexOffset += data.vertexCount;
|
||||
_batchData.byteOffset += data.vertexCount * comp._vertexFormat._bytes;
|
||||
_batchData.indiceOffset += data.indiceCount;
|
||||
}
|
||||
}
|
||||
|
||||
// last batch
|
||||
this._flush(_batchData);
|
||||
this._queue.length = 0;
|
||||
},
|
||||
|
||||
visit (scene) {
|
||||
this.reset();
|
||||
|
||||
// Store all render components to _queue
|
||||
_queue = this._queue;
|
||||
scene.walk(this._handleRender, this._postHandleRender);
|
||||
|
||||
this.batchQueue();
|
||||
// Store all render components to _queue
|
||||
scene.walk(this._handleRender, this._postHandleRender);
|
||||
|
||||
this._flush(_batchData);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
Reference in New Issue
Block a user