mirror of
https://github.com/cocos/cocos4.git
synced 2026-11-21 16:12:40 +08:00
628 lines
20 KiB
JavaScript
628 lines
20 KiB
JavaScript
/****************************************************************************
|
|
Copyright (c) 2017-2018 Xiamen Yaji Software Co., Ltd.
|
|
|
|
http://www.cocos.com
|
|
|
|
Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
of this software and associated engine source code (the "Software"), a limited,
|
|
worldwide, royalty-free, non-assignable, revocable and non-exclusive license
|
|
to use Cocos Creator solely to develop games on your target platforms. You shall
|
|
not use Cocos Creator software for developing other software or tools that's
|
|
used for developing games. You are not granted to publish, distribute,
|
|
sublicense, and/or sell copies of Cocos Creator.
|
|
|
|
The software or tools in this License Agreement are licensed, not sold.
|
|
Xiamen Yaji Software Co., Ltd. reserves all rights not expressly granted to you.
|
|
|
|
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.
|
|
****************************************************************************/
|
|
|
|
const Graphics = require('../../../graphics/graphics');
|
|
const PointFlags = require('../../../graphics/types').PointFlags;
|
|
const LineJoin = Graphics.LineJoin;
|
|
const LineCap = Graphics.LineCap;
|
|
const Earcut = require('./earcut');
|
|
|
|
const macro = require('../../../platform/CCMacro');
|
|
const MAX_VERTEX = macro.BATCH_VERTEX_COUNT;
|
|
const MAX_INDICE = MAX_VERTEX * 2;
|
|
|
|
const js = require('../../../platform/js');
|
|
const assembler = require('../assembler');
|
|
const renderEngine = require('../../render-engine');
|
|
const math = renderEngine.math;
|
|
|
|
const PI = Math.PI;
|
|
const min = Math.min;
|
|
const max = Math.max;
|
|
const ceil = Math.ceil;
|
|
const acos = Math.acos;
|
|
const cos = Math.cos;
|
|
const sin = Math.sin;
|
|
const atan2 = Math.atan2;
|
|
const abs = Math.abs;
|
|
|
|
let _matrix = math.mat4.create();
|
|
let _renderData = null;
|
|
let _curColor = 0;
|
|
|
|
function curveDivs (r, arc, tol) {
|
|
let da = acos(r / (r + tol)) * 2.0;
|
|
return max(2, ceil(arc / da));
|
|
}
|
|
|
|
function clamp (v, min, max) {
|
|
if (v < min) {
|
|
return min;
|
|
}
|
|
else if (v > max) {
|
|
return max;
|
|
}
|
|
return v;
|
|
}
|
|
|
|
let graphicsAssembler = js.addon({
|
|
updateRenderData (graphics) {
|
|
let datas = graphics._renderDatas;
|
|
if (datas.length === 0) {
|
|
datas.push(graphics.requestRenderData());
|
|
}
|
|
|
|
for (let i = 0, l = datas.length; i < l; i++) {
|
|
datas[i].effect = graphics.getEffect();
|
|
}
|
|
|
|
return datas;
|
|
},
|
|
|
|
fillBuffers (graphics, batchData, vertexId, vbuf, uintbuf, ibuf) {
|
|
let offset = batchData.byteOffset / 4,
|
|
node = graphics.node,
|
|
renderData = batchData.data,
|
|
data = renderData._data,
|
|
z = node._position.z;
|
|
|
|
// vertex buffer
|
|
node.getWorldMatrix(_matrix);
|
|
let a = _matrix.m00, b = _matrix.m01, c = _matrix.m04, d = _matrix.m05,
|
|
tx = _matrix.m12, ty = _matrix.m13;
|
|
|
|
let nodeColor = node.color,
|
|
nodeR = nodeColor.r / 255,
|
|
nodeG = nodeColor.g / 255,
|
|
nodeB = nodeColor.b / 255,
|
|
nodeA = nodeColor.a / 255;
|
|
for (let i = 0, l = data.length; i < l; i++) {
|
|
vbuf[offset++] = data[i].x * a + data[i].y * c + tx;
|
|
vbuf[offset++] = data[i].x * b + data[i].y * d + ty;
|
|
vbuf[offset++] = z;
|
|
|
|
let color = data[i].color;
|
|
let cr = (color & 0x000000ff) * nodeR;
|
|
let cg = ((color & 0x0000ff00) >> 8) * nodeG;
|
|
let cb = ((color & 0x00ff0000) >> 16) * nodeB;
|
|
let ca = ((color & 0xff000000) >>> 24) * nodeA;
|
|
color = ((ca<<24) >>> 0) + (cb<<16) + (cg<<8) + cr;
|
|
uintbuf[offset++] = color;
|
|
offset+=2;
|
|
}
|
|
|
|
// index buffer
|
|
let indicesBuffer = renderData._indices;
|
|
offset = batchData.indiceOffset;
|
|
for (let i = 0, l = indicesBuffer.length; i < l; i++) {
|
|
ibuf[offset + i] = vertexId + indicesBuffer[i];
|
|
}
|
|
},
|
|
|
|
genRenderData (graphics, cverts) {
|
|
let renderDatas = graphics._renderDatas;
|
|
let renderData = renderDatas[renderDatas.length - 1];
|
|
let maxVertsCount = renderData.dataLength + cverts;
|
|
if (maxVertsCount > MAX_VERTEX ||
|
|
maxVertsCount * 3 > MAX_INDICE) {
|
|
renderData = graphics.requestRenderData();
|
|
}
|
|
return renderData;
|
|
},
|
|
|
|
stroke (graphics) {
|
|
if (graphics._renderDatas.length === 0) {
|
|
graphics._renderDatas.push(graphics.requestRenderData());
|
|
}
|
|
|
|
_curColor = graphics._strokeColor._val;
|
|
|
|
this._flattenPaths(graphics);
|
|
this._expandStroke(graphics);
|
|
|
|
graphics._updatePathOffset = true;
|
|
},
|
|
|
|
fill (graphics) {
|
|
if (graphics._renderDatas.length === 0) {
|
|
graphics._renderDatas.push(graphics.requestRenderData());
|
|
}
|
|
|
|
_curColor = graphics._fillColor._val;
|
|
|
|
this._expandFill(graphics);
|
|
this._updatePathOffset = true;
|
|
},
|
|
|
|
_expandStroke (graphics) {
|
|
let w = graphics.lineWidth * 0.5,
|
|
lineCap = graphics.lineCap,
|
|
lineJoin = graphics.lineJoin,
|
|
miterLimit = graphics.miterLimit;
|
|
|
|
let ncap = curveDivs(w, PI, graphics._tessTol);
|
|
|
|
this._calculateJoins(graphics, w, lineJoin, miterLimit);
|
|
|
|
let paths = graphics._paths;
|
|
|
|
// Calculate max vertex usage.
|
|
let cverts = 0;
|
|
for (let i = graphics._pathOffset, l = graphics._pathLength; i < l; i++) {
|
|
let path = paths[i];
|
|
let pointsLength = path.points.length;
|
|
|
|
if (lineJoin === LineJoin.ROUND) cverts += (pointsLength + path.nbevel * (ncap + 2) + 1) * 2; // plus one for loop
|
|
else cverts += (pointsLength + path.nbevel * 5 + 1) * 2; // plus one for loop
|
|
|
|
if (!path.closed) {
|
|
// space for caps
|
|
if (lineCap === LineCap.ROUND) {
|
|
cverts += (ncap * 2 + 2) * 2;
|
|
} else {
|
|
cverts += (3 + 3) * 2;
|
|
}
|
|
}
|
|
}
|
|
|
|
let renderData = _renderData = this.genRenderData(graphics, cverts),
|
|
data = renderData._data,
|
|
indicesBuffer = renderData._indices;
|
|
|
|
for (let i = graphics._pathOffset, l = graphics._pathLength; i < l; i++) {
|
|
let path = paths[i];
|
|
let pts = path.points;
|
|
let pointsLength = pts.length;
|
|
let offset = data.length;
|
|
|
|
let p0, p1;
|
|
let start, end, loop;
|
|
loop = path.closed;
|
|
if (loop) {
|
|
// Looping
|
|
p0 = pts[pointsLength - 1];
|
|
p1 = pts[0];
|
|
start = 0;
|
|
end = pointsLength;
|
|
} else {
|
|
// Add cap
|
|
p0 = pts[0];
|
|
p1 = pts[1];
|
|
start = 1;
|
|
end = pointsLength - 1;
|
|
}
|
|
|
|
if (!loop) {
|
|
// Add cap
|
|
let dPos = p1.sub(p0);
|
|
dPos.normalizeSelf();
|
|
|
|
let dx = dPos.x;
|
|
let dy = dPos.y;
|
|
|
|
if (lineCap === LineCap.BUTT)
|
|
this._buttCap(p0, dx, dy, w, 0);
|
|
else if (lineCap === LineCap.SQUARE)
|
|
this._buttCap(p0, dx, dy, w, w);
|
|
else if (lineCap === LineCap.ROUND)
|
|
this._roundCapStart(p0, dx, dy, w, ncap);
|
|
}
|
|
|
|
for (let j = start; j < end; ++j) {
|
|
if (lineJoin === LineJoin.ROUND) {
|
|
this._roundJoin(p0, p1, w, w, ncap);
|
|
}
|
|
else if ((p1.flags & (PointFlags.PT_BEVEL | PointFlags.PT_INNERBEVEL)) !== 0) {
|
|
this._bevelJoin(p0, p1, w, w);
|
|
}
|
|
else {
|
|
this._vset(p1.x + p1.dmx * w, p1.y + p1.dmy * w);
|
|
this._vset(p1.x - p1.dmx * w, p1.y - p1.dmy * w);
|
|
}
|
|
|
|
p0 = p1;
|
|
p1 = pts[j + 1];
|
|
}
|
|
|
|
if (loop) {
|
|
// Loop it
|
|
this._vset(data[offset].x, data[offset].y);
|
|
this._vset(data[offset+1].x, data[offset+1].y);
|
|
} else {
|
|
// Add cap
|
|
let dPos = p1.sub(p0);
|
|
dPos.normalizeSelf();
|
|
|
|
let dx = dPos.x;
|
|
let dy = dPos.y;
|
|
|
|
if (lineCap === LineCap.BUTT)
|
|
this._buttCap(p1, dx, dy, w, 0);
|
|
else if (lineCap === LineCap.BUTT || lineCap === LineCap.SQUARE)
|
|
this._buttCap(p1, dx, dy, w, w);
|
|
else if (lineCap === LineCap.ROUND)
|
|
this._roundCapEnd(p1, dx, dy, w, ncap);
|
|
}
|
|
|
|
// stroke indices
|
|
let indicesOffset = indicesBuffer.length;
|
|
for (let start = offset+2, end = data.length; start < end; start++) {
|
|
indicesBuffer[indicesOffset++] = start - 2;
|
|
indicesBuffer[indicesOffset++] = start - 1;
|
|
indicesBuffer[indicesOffset++] = start;
|
|
}
|
|
}
|
|
|
|
renderData.vertexCount = data.length;
|
|
renderData.indiceCount = indicesBuffer.length;
|
|
|
|
_renderData = null;
|
|
},
|
|
|
|
_expandFill (graphics) {
|
|
let paths = graphics._paths;
|
|
|
|
// Calculate max vertex usage.
|
|
let cverts = 0;
|
|
for (let i = graphics._pathOffset, l = graphics._pathLength; i < l; i++) {
|
|
let path = paths[i];
|
|
let pointsLength = path.points.length;
|
|
|
|
cverts += pointsLength;
|
|
}
|
|
|
|
let renderData = _renderData = this.genRenderData(graphics, cverts),
|
|
data = renderData._data,
|
|
indicesBuffer = renderData._indices;
|
|
|
|
for (let i = graphics._pathOffset, l = graphics._pathLength; i < l; i++) {
|
|
let path = paths[i];
|
|
let pts = path.points;
|
|
let pointsLength = pts.length;
|
|
|
|
if (pointsLength === 0) {
|
|
continue;
|
|
}
|
|
|
|
// Calculate shape vertices.
|
|
let offset = data.length;
|
|
|
|
for (let j = 0; j < pointsLength; ++j) {
|
|
this._vset(pts[j].x, pts[j].y);
|
|
}
|
|
|
|
let indicesOffset = indicesBuffer.length;
|
|
|
|
if (path.complex) {
|
|
let earcutData = [];
|
|
for (let j = offset, end = data.length; j < end; j++) {
|
|
earcutData.push(data[j].x);
|
|
earcutData.push(data[j].y);
|
|
}
|
|
|
|
let newIndices = Earcut(earcutData, null, 2);
|
|
|
|
if (!newIndices || newIndices.length === 0) {
|
|
continue;
|
|
}
|
|
|
|
for (let j = 0, nIndices = newIndices.length; j < nIndices; j++) {
|
|
indicesBuffer[indicesOffset + j] = newIndices[j] + offset;
|
|
}
|
|
}
|
|
else {
|
|
let first = offset;
|
|
for (let start = offset+2, end = data.length; start < end; start++) {
|
|
indicesBuffer[indicesOffset++] = first;
|
|
indicesBuffer[indicesOffset++] = start - 1;
|
|
indicesBuffer[indicesOffset++] = start;
|
|
}
|
|
}
|
|
}
|
|
|
|
renderData.vertexCount = data.length;
|
|
renderData.indiceCount = indicesBuffer.length;
|
|
|
|
_renderData = null;
|
|
},
|
|
|
|
_calculateJoins (graphics, w, lineJoin, miterLimit) {
|
|
let iw = 0.0;
|
|
|
|
if (w > 0.0) {
|
|
iw = 1 / w;
|
|
}
|
|
|
|
// Calculate which joins needs extra vertices to append, and gather vertex count.
|
|
let paths = graphics._paths;
|
|
for (let i = graphics._pathOffset, l = graphics._pathLength; i < l; i++) {
|
|
let path = paths[i];
|
|
|
|
let pts = path.points;
|
|
let ptsLength = pts.length;
|
|
let p0 = pts[ptsLength - 1];
|
|
let p1 = pts[0];
|
|
let nleft = 0;
|
|
|
|
path.nbevel = 0;
|
|
|
|
for (let j = 0; j < ptsLength; j++) {
|
|
let dmr2, cross, limit;
|
|
|
|
// perp normals
|
|
let dlx0 = p0.dy;
|
|
let dly0 = -p0.dx;
|
|
let dlx1 = p1.dy;
|
|
let dly1 = -p1.dx;
|
|
|
|
// Calculate extrusions
|
|
p1.dmx = (dlx0 + dlx1) * 0.5;
|
|
p1.dmy = (dly0 + dly1) * 0.5;
|
|
dmr2 = p1.dmx * p1.dmx + p1.dmy * p1.dmy;
|
|
if (dmr2 > 0.000001) {
|
|
let scale = 1 / dmr2;
|
|
if (scale > 600) {
|
|
scale = 600;
|
|
}
|
|
p1.dmx *= scale;
|
|
p1.dmy *= scale;
|
|
}
|
|
|
|
// Keep track of left turns.
|
|
cross = p1.dx * p0.dy - p0.dx * p1.dy;
|
|
if (cross > 0) {
|
|
nleft++;
|
|
p1.flags |= PointFlags.PT_LEFT;
|
|
}
|
|
|
|
// Calculate if we should use bevel or miter for inner join.
|
|
limit = max(11, min(p0.len, p1.len) * iw);
|
|
if (dmr2 * limit * limit < 1) {
|
|
p1.flags |= PointFlags.PT_INNERBEVEL;
|
|
}
|
|
|
|
// Check to see if the corner needs to be beveled.
|
|
if (p1.flags & PointFlags.PT_CORNER) {
|
|
if (dmr2 * miterLimit * miterLimit < 1 || lineJoin === LineJoin.BEVEL || lineJoin === LineJoin.ROUND) {
|
|
p1.flags |= PointFlags.PT_BEVEL;
|
|
}
|
|
}
|
|
|
|
if ((p1.flags & (PointFlags.PT_BEVEL | PointFlags.PT_INNERBEVEL)) !== 0) {
|
|
path.nbevel++;
|
|
}
|
|
|
|
p0 = p1;
|
|
p1 = pts[j + 1];
|
|
}
|
|
}
|
|
},
|
|
|
|
_flattenPaths (graphics) {
|
|
let paths = graphics._paths;
|
|
for (let i = graphics._pathOffset, l = graphics._pathLength; i < l; i++) {
|
|
let path = paths[i];
|
|
let pts = path.points;
|
|
|
|
let p0 = pts[pts.length - 1];
|
|
let p1 = pts[0];
|
|
|
|
if (p0.equals(p1)) {
|
|
path.closed = true;
|
|
pts.pop();
|
|
p0 = pts[pts.length - 1];
|
|
}
|
|
|
|
for (let j = 0, size = pts.length; j < size; j++) {
|
|
// Calculate segment direction and length
|
|
let dPos = p1.sub(p0);
|
|
p0.len = dPos.mag();
|
|
if (dPos.x || dPos.y)
|
|
dPos.normalizeSelf();
|
|
p0.dx = dPos.x;
|
|
p0.dy = dPos.y;
|
|
// Advance
|
|
p0 = p1;
|
|
p1 = pts[j + 1];
|
|
}
|
|
}
|
|
},
|
|
|
|
_chooseBevel (bevel, p0, p1, w) {
|
|
let x = p1.x;
|
|
let y = p1.y;
|
|
let x0, y0, x1, y1;
|
|
|
|
if (bevel !== 0) {
|
|
x0 = x + p0.dy * w;
|
|
y0 = y - p0.dx * w;
|
|
x1 = x + p1.dy * w;
|
|
y1 = y - p1.dx * w;
|
|
} else {
|
|
x0 = x1 = x + p1.dmx * w;
|
|
y0 = y1 = y + p1.dmy * w;
|
|
}
|
|
|
|
return [x0, y0, x1, y1];
|
|
},
|
|
|
|
_buttCap (p, dx, dy, w, d) {
|
|
let px = p.x - dx * d;
|
|
let py = p.y - dy * d;
|
|
let dlx = dy;
|
|
let dly = -dx;
|
|
|
|
this._vset(px + dlx * w, py + dly * w);
|
|
this._vset(px - dlx * w, py - dly * w);
|
|
},
|
|
|
|
_roundCapStart (p, dx, dy, w, ncap) {
|
|
let px = p.x;
|
|
let py = p.y;
|
|
let dlx = dy;
|
|
let dly = -dx;
|
|
|
|
for (let i = 0; i < ncap; i++) {
|
|
let a = i / (ncap - 1) * PI;
|
|
let ax = cos(a) * w,
|
|
ay = sin(a) * w;
|
|
this._vset(px - dlx * ax - dx * ay, py - dly * ax - dy * ay);
|
|
this._vset(px, py);
|
|
}
|
|
this._vset(px + dlx * w, py + dly * w);
|
|
this._vset(px - dlx * w, py - dly * w);
|
|
},
|
|
|
|
_roundCapEnd (p, dx, dy, w, ncap) {
|
|
let px = p.x;
|
|
let py = p.y;
|
|
let dlx = dy;
|
|
let dly = -dx;
|
|
|
|
this._vset(px + dlx * w, py + dly * w);
|
|
this._vset(px - dlx * w, py - dly * w);
|
|
for (let i = 0; i < ncap; i++) {
|
|
let a = i / (ncap - 1) * PI;
|
|
let ax = cos(a) * w,
|
|
ay = sin(a) * w;
|
|
this._vset(px, py);
|
|
this._vset(px - dlx * ax + dx * ay, py - dly * ax + dy * ay);
|
|
}
|
|
},
|
|
|
|
_roundJoin (p0, p1, lw, rw, ncap) {
|
|
let dlx0 = p0.dy;
|
|
let dly0 = -p0.dx;
|
|
let dlx1 = p1.dy;
|
|
let dly1 = -p1.dx;
|
|
|
|
let p1x = p1.x;
|
|
let p1y = p1.y;
|
|
|
|
if ((p1.flags & PointFlags.PT_LEFT) !== 0) {
|
|
let out = this._chooseBevel(p1.flags & PointFlags.PT_INNERBEVEL, p0, p1, lw);
|
|
let lx0 = out[0];
|
|
let ly0 = out[1];
|
|
let lx1 = out[2];
|
|
let ly1 = out[3];
|
|
|
|
let a0 = atan2(-dly0, -dlx0);
|
|
let a1 = atan2(-dly1, -dlx1);
|
|
if (a1 > a0) a1 -= PI * 2;
|
|
|
|
this._vset(lx0, ly0);
|
|
this._vset(p1x - dlx0 * rw, p1.y - dly0 * rw);
|
|
|
|
let n = clamp(ceil((a0 - a1) / PI) * ncap, 2, ncap);
|
|
for (let i = 0; i < n; i++) {
|
|
let u = i / (n - 1);
|
|
let a = a0 + u * (a1 - a0);
|
|
let rx = p1x + cos(a) * rw;
|
|
let ry = p1y + sin(a) * rw;
|
|
this._vset(p1x, p1y);
|
|
this._vset(rx, ry);
|
|
}
|
|
|
|
this._vset(lx1, ly1);
|
|
this._vset(p1x - dlx1 * rw, p1y - dly1 * rw);
|
|
} else {
|
|
let out = this._chooseBevel(p1.flags & PointFlags.PT_INNERBEVEL, p0, p1, -rw);
|
|
let rx0 = out[0];
|
|
let ry0 = out[1];
|
|
let rx1 = out[2];
|
|
let ry1 = out[3];
|
|
|
|
let a0 = atan2(dly0, dlx0);
|
|
let a1 = atan2(dly1, dlx1);
|
|
if (a1 < a0) a1 += PI * 2;
|
|
|
|
this._vset(p1x + dlx0 * rw, p1y + dly0 * rw);
|
|
this._vset(rx0, ry0);
|
|
|
|
let n = clamp(ceil((a1 - a0) / PI) * ncap, 2, ncap);
|
|
for (let i = 0; i < n; i++) {
|
|
let u = i / (n - 1);
|
|
let a = a0 + u * (a1 - a0);
|
|
let lx = p1x + cos(a) * lw;
|
|
let ly = p1y + sin(a) * lw;
|
|
this._vset(lx, ly);
|
|
this._vset(p1x, p1y);
|
|
}
|
|
|
|
this._vset(p1x + dlx1 * rw, p1y + dly1 * rw);
|
|
this._vset(rx1, ry1);
|
|
}
|
|
},
|
|
|
|
_bevelJoin (p0, p1, lw, rw) {
|
|
let rx0, ry0, rx1, ry1;
|
|
let lx0, ly0, lx1, ly1;
|
|
let dlx0 = p0.dy;
|
|
let dly0 = -p0.dx;
|
|
let dlx1 = p1.dy;
|
|
let dly1 = -p1.dx;
|
|
|
|
if (p1.flags & PointFlags.PT_LEFT) {
|
|
let out = this._chooseBevel(p1.flags & PointFlags.PT_INNERBEVEL, p0, p1, lw);
|
|
lx0 = out[0];
|
|
ly0 = out[1];
|
|
lx1 = out[2];
|
|
ly1 = out[3];
|
|
|
|
this._vset(lx0, ly0);
|
|
this._vset(p1.x - dlx0 * rw, p1.y - dly0 * rw);
|
|
|
|
this._vset(lx1, ly1);
|
|
this._vset(p1.x - dlx1 * rw, p1.y - dly1 * rw);
|
|
} else {
|
|
let out = this._chooseBevel(p1.flags & PointFlags.PT_INNERBEVEL, p0, p1, -rw);
|
|
rx0 = out[0];
|
|
ry0 = out[1];
|
|
rx1 = out[2];
|
|
ry1 = out[3];
|
|
|
|
this._vset(p1.x + dlx0 * lw, p1.y + dly0 * lw);
|
|
this._vset(rx0, ry0);
|
|
|
|
this._vset(p1.x + dlx1 * lw, p1.y + dly1 * lw);
|
|
this._vset(rx1, ry1);
|
|
}
|
|
},
|
|
|
|
_vset (x, y) {
|
|
let data = _renderData._data;
|
|
|
|
let offset = data.length;
|
|
_renderData.dataLength = offset + 1;
|
|
|
|
data[offset].x = x;
|
|
data[offset].y = y;
|
|
data[offset].color = _curColor;
|
|
}
|
|
}, assembler);
|
|
|
|
Graphics._assembler = graphicsAssembler;
|
|
|
|
module.exports = graphicsAssembler; |