391429f78b
Bug: skia:11858 Change-Id: Iedbc2333779f2fac5029779bae44da48d8dd7b8f Reviewed-on: https://skia-review.googlesource.com/c/skia/+/430956 Reviewed-by: Ben Wagner <bungeman@google.com>
581 lines
19 KiB
JavaScript
581 lines
19 KiB
JavaScript
describe('Path Behavior', () => {
|
|
let container;
|
|
|
|
beforeEach(async () => {
|
|
await LoadCanvasKit;
|
|
container = document.createElement('div');
|
|
container.innerHTML = `
|
|
<canvas width=600 height=600 id=test></canvas>
|
|
<canvas width=600 height=600 id=report></canvas>`;
|
|
document.body.appendChild(container);
|
|
});
|
|
|
|
afterEach(() => {
|
|
document.body.removeChild(container);
|
|
});
|
|
|
|
gm('path_api_example', (canvas) => {
|
|
const paint = new CanvasKit.Paint();
|
|
paint.setStrokeWidth(1.0);
|
|
paint.setAntiAlias(true);
|
|
paint.setColor(CanvasKit.Color(0, 0, 0, 1.0));
|
|
paint.setStyle(CanvasKit.PaintStyle.Stroke);
|
|
|
|
const path = new CanvasKit.Path();
|
|
path.moveTo(20, 5);
|
|
path.lineTo(30, 20);
|
|
path.lineTo(40, 10);
|
|
path.lineTo(50, 20);
|
|
path.lineTo(60, 0);
|
|
path.lineTo(20, 5);
|
|
|
|
path.moveTo(20, 80);
|
|
path.cubicTo(90, 10, 160, 150, 190, 10);
|
|
|
|
path.moveTo(36, 148);
|
|
path.quadTo(66, 188, 120, 136);
|
|
path.lineTo(36, 148);
|
|
|
|
path.moveTo(150, 180);
|
|
path.arcToTangent(150, 100, 50, 200, 20);
|
|
path.lineTo(160, 160);
|
|
|
|
path.moveTo(20, 120);
|
|
path.lineTo(20, 120);
|
|
|
|
path.transform([2, 0, 0,
|
|
0, 2, 0,
|
|
0, 0, 1 ]);
|
|
|
|
canvas.drawPath(path, paint);
|
|
|
|
const rrect = CanvasKit.RRectXY([100, 10, 140, 62], 10, 4);
|
|
|
|
const rrectPath = new CanvasKit.Path().addRRect(rrect, true);
|
|
|
|
canvas.drawPath(rrectPath, paint);
|
|
|
|
rrectPath.delete();
|
|
path.delete();
|
|
paint.delete();
|
|
// See PathKit for more tests, since they share implementation
|
|
});
|
|
|
|
it('can create a path from an SVG string', () => {
|
|
//.This is a parallelogram from
|
|
// https://upload.wikimedia.org/wikipedia/commons/e/e7/Simple_parallelogram.svg
|
|
const path = CanvasKit.Path.MakeFromSVGString(
|
|
'M 205,5 L 795,5 L 595,295 L 5,295 L 205,5 z');
|
|
|
|
const cmds = path.toCmds();
|
|
expect(cmds).toBeTruthy();
|
|
// 1 move, 4 lines, 1 close
|
|
// each element in cmds is an array, with index 0 being the verb, and the rest being args
|
|
expect(cmds).toEqual(Float32Array.of(
|
|
CanvasKit.MOVE_VERB, 205, 5,
|
|
CanvasKit.LINE_VERB, 795, 5,
|
|
CanvasKit.LINE_VERB, 595, 295,
|
|
CanvasKit.LINE_VERB, 5, 295,
|
|
CanvasKit.LINE_VERB, 205, 5,
|
|
CanvasKit.CLOSE_VERB));
|
|
path.delete();
|
|
});
|
|
|
|
it('can create a path by combining two other paths', () => {
|
|
// Get the intersection of two overlapping squares and verify that it is the smaller square.
|
|
const pathOne = new CanvasKit.Path();
|
|
pathOne.addRect([10, 10, 20, 20]);
|
|
|
|
const pathTwo = new CanvasKit.Path();
|
|
pathTwo.addRect([15, 15, 30, 30]);
|
|
|
|
const path = CanvasKit.Path.MakeFromOp(pathOne, pathTwo, CanvasKit.PathOp.Intersect);
|
|
const cmds = path.toCmds();
|
|
expect(cmds).toBeTruthy();
|
|
expect(cmds).toEqual(Float32Array.of(
|
|
CanvasKit.MOVE_VERB, 15, 15,
|
|
CanvasKit.LINE_VERB, 20, 15,
|
|
CanvasKit.LINE_VERB, 20, 20,
|
|
CanvasKit.LINE_VERB, 15, 20,
|
|
CanvasKit.CLOSE_VERB));
|
|
path.delete();
|
|
pathOne.delete();
|
|
pathTwo.delete();
|
|
});
|
|
|
|
it('can create an SVG string from a path', () => {
|
|
const cmds = [CanvasKit.MOVE_VERB, 205, 5,
|
|
CanvasKit.LINE_VERB, 795, 5,
|
|
CanvasKit.LINE_VERB, 595, 295,
|
|
CanvasKit.LINE_VERB, 5, 295,
|
|
CanvasKit.LINE_VERB, 205, 5,
|
|
CanvasKit.CLOSE_VERB];
|
|
const path = CanvasKit.Path.MakeFromCmds(cmds);
|
|
|
|
const svgStr = path.toSVGString();
|
|
// We output it in terse form, which is different than Wikipedia's version
|
|
expect(svgStr).toEqual('M205 5L795 5L595 295L5 295L205 5Z');
|
|
path.delete();
|
|
});
|
|
|
|
it('can create a path with malloced verbs, points, weights', () => {
|
|
const mVerbs = CanvasKit.Malloc(Uint8Array, 6);
|
|
const mPoints = CanvasKit.Malloc(Float32Array, 18);
|
|
const mWeights = CanvasKit.Malloc(Float32Array, 1);
|
|
mVerbs.toTypedArray().set([CanvasKit.MOVE_VERB, CanvasKit.LINE_VERB,
|
|
CanvasKit.QUAD_VERB, CanvasKit.CONIC_VERB, CanvasKit.CUBIC_VERB, CanvasKit.CLOSE_VERB
|
|
]);
|
|
|
|
mPoints.toTypedArray().set([
|
|
1,2, // moveTo
|
|
3,4, // lineTo
|
|
5,6,7,8, // quadTo
|
|
9,10,11,12, // conicTo
|
|
13,14,15,16,17,18, // cubicTo
|
|
]);
|
|
|
|
mWeights.toTypedArray().set([117]);
|
|
|
|
let path = CanvasKit.Path.MakeFromVerbsPointsWeights(mVerbs, mPoints, mWeights);
|
|
|
|
let cmds = path.toCmds();
|
|
expect(cmds).toEqual(Float32Array.of(
|
|
CanvasKit.MOVE_VERB, 1, 2,
|
|
CanvasKit.LINE_VERB, 3, 4,
|
|
CanvasKit.QUAD_VERB, 5, 6, 7, 8,
|
|
CanvasKit.CONIC_VERB, 9, 10, 11, 12, 117,
|
|
CanvasKit.CUBIC_VERB, 13, 14, 15, 16, 17, 18,
|
|
CanvasKit.CLOSE_VERB,
|
|
));
|
|
path.delete();
|
|
|
|
// If given insufficient points, it stops early (but doesn't read out of bounds).
|
|
path = CanvasKit.Path.MakeFromVerbsPointsWeights(mVerbs, mPoints.subarray(0, 10), mWeights);
|
|
|
|
cmds = path.toCmds();
|
|
expect(cmds).toEqual(Float32Array.of(
|
|
CanvasKit.MOVE_VERB, 1, 2,
|
|
CanvasKit.LINE_VERB, 3, 4,
|
|
CanvasKit.QUAD_VERB, 5, 6, 7, 8,
|
|
));
|
|
path.delete();
|
|
CanvasKit.Free(mVerbs);
|
|
CanvasKit.Free(mPoints);
|
|
CanvasKit.Free(mWeights);
|
|
});
|
|
|
|
it('can create and update a path with verbs and points (no weights)', () => {
|
|
const path = CanvasKit.Path.MakeFromVerbsPointsWeights(
|
|
[CanvasKit.MOVE_VERB, CanvasKit.LINE_VERB],
|
|
[1,2, 3,4]);
|
|
let cmds = path.toCmds();
|
|
expect(cmds).toEqual(Float32Array.of(
|
|
CanvasKit.MOVE_VERB, 1, 2,
|
|
CanvasKit.LINE_VERB, 3, 4
|
|
));
|
|
|
|
path.addVerbsPointsWeights(
|
|
[CanvasKit.QUAD_VERB, CanvasKit.CLOSE_VERB],
|
|
[5,6,7,8],
|
|
);
|
|
|
|
cmds = path.toCmds();
|
|
expect(cmds).toEqual(Float32Array.of(
|
|
CanvasKit.MOVE_VERB, 1, 2,
|
|
CanvasKit.LINE_VERB, 3, 4,
|
|
CanvasKit.QUAD_VERB, 5, 6, 7, 8,
|
|
CanvasKit.CLOSE_VERB
|
|
));
|
|
path.delete();
|
|
});
|
|
|
|
|
|
it('can add points to a path in bulk', () => {
|
|
const mVerbs = CanvasKit.Malloc(Uint8Array, 6);
|
|
const mPoints = CanvasKit.Malloc(Float32Array, 18);
|
|
const mWeights = CanvasKit.Malloc(Float32Array, 1);
|
|
mVerbs.toTypedArray().set([CanvasKit.MOVE_VERB, CanvasKit.LINE_VERB,
|
|
CanvasKit.QUAD_VERB, CanvasKit.CONIC_VERB, CanvasKit.CUBIC_VERB, CanvasKit.CLOSE_VERB
|
|
]);
|
|
|
|
mPoints.toTypedArray().set([
|
|
1,2, // moveTo
|
|
3,4, // lineTo
|
|
5,6,7,8, // quadTo
|
|
9,10,11,12, // conicTo
|
|
13,14,15,16,17,18, // cubicTo
|
|
]);
|
|
|
|
mWeights.toTypedArray().set([117]);
|
|
|
|
const path = new CanvasKit.Path();
|
|
path.lineTo(77, 88);
|
|
path.addVerbsPointsWeights(mVerbs, mPoints, mWeights);
|
|
|
|
let cmds = path.toCmds();
|
|
expect(cmds).toEqual(Float32Array.of(
|
|
CanvasKit.MOVE_VERB, 0, 0,
|
|
CanvasKit.LINE_VERB, 77, 88,
|
|
CanvasKit.MOVE_VERB, 1, 2,
|
|
CanvasKit.LINE_VERB, 3, 4,
|
|
CanvasKit.QUAD_VERB, 5, 6, 7, 8,
|
|
CanvasKit.CONIC_VERB, 9, 10, 11, 12, 117,
|
|
CanvasKit.CUBIC_VERB, 13, 14, 15, 16, 17, 18,
|
|
CanvasKit.CLOSE_VERB,
|
|
));
|
|
|
|
path.rewind();
|
|
cmds = path.toCmds();
|
|
expect(cmds).toEqual(new Float32Array(0));
|
|
|
|
path.delete();
|
|
CanvasKit.Free(mVerbs);
|
|
CanvasKit.Free(mPoints);
|
|
CanvasKit.Free(mWeights);
|
|
});
|
|
|
|
it('can retrieve points from a path', () => {
|
|
const path = new CanvasKit.Path();
|
|
path.addRect([10, 15, 20, 25]);
|
|
|
|
let pt = path.getPoint(0);
|
|
expect(pt[0]).toEqual(10);
|
|
expect(pt[1]).toEqual(15);
|
|
|
|
path.getPoint(2, pt);
|
|
expect(pt[0]).toEqual(20);
|
|
expect(pt[1]).toEqual(25);
|
|
|
|
path.getPoint(1000, pt); // off the end returns (0, 0) as per the docs.
|
|
expect(pt[0]).toEqual(0);
|
|
expect(pt[1]).toEqual(0);
|
|
|
|
path.delete();
|
|
});
|
|
|
|
gm('offset_path', (canvas) => {
|
|
const path = starPath(CanvasKit);
|
|
|
|
const paint = new CanvasKit.Paint();
|
|
paint.setStyle(CanvasKit.PaintStyle.Stroke);
|
|
paint.setStrokeWidth(5.0);
|
|
paint.setAntiAlias(true);
|
|
paint.setColor(CanvasKit.BLACK);
|
|
|
|
canvas.clear(CanvasKit.WHITE);
|
|
|
|
canvas.drawPath(path, paint);
|
|
path.offset(80, 40);
|
|
canvas.drawPath(path, paint);
|
|
|
|
path.delete();
|
|
paint.delete();
|
|
});
|
|
|
|
gm('oval_path', (canvas) => {
|
|
const paint = new CanvasKit.Paint();
|
|
|
|
paint.setStyle(CanvasKit.PaintStyle.Stroke);
|
|
paint.setStrokeWidth(5.0);
|
|
paint.setAntiAlias(true);
|
|
paint.setColor(CanvasKit.BLACK);
|
|
|
|
canvas.clear(CanvasKit.WHITE);
|
|
|
|
const path = new CanvasKit.Path();
|
|
path.moveTo(5, 5);
|
|
path.lineTo(10, 120);
|
|
path.addOval(CanvasKit.LTRBRect(10, 20, 100, 200), false, 3);
|
|
path.lineTo(300, 300);
|
|
|
|
canvas.drawPath(path, paint);
|
|
|
|
path.delete();
|
|
paint.delete();
|
|
});
|
|
|
|
gm('bounds_path', (canvas) => {
|
|
const paint = new CanvasKit.Paint();
|
|
|
|
paint.setStyle(CanvasKit.PaintStyle.Stroke);
|
|
paint.setStrokeWidth(5.0);
|
|
paint.setAntiAlias(true);
|
|
paint.setColor(CanvasKit.BLACK);
|
|
|
|
canvas.clear(CanvasKit.WHITE);
|
|
|
|
const path = new CanvasKit.Path();
|
|
// Arbitrary points to make an interesting curve.
|
|
path.moveTo(97, 225);
|
|
path.cubicTo(20, 400, 404, 75, 243, 271);
|
|
|
|
canvas.drawPath(path, paint);
|
|
|
|
const bounds = new Float32Array(4);
|
|
path.getBounds(bounds);
|
|
|
|
paint.setColor(CanvasKit.BLUE);
|
|
paint.setStrokeWidth(3.0);
|
|
canvas.drawRect(bounds, paint);
|
|
|
|
path.computeTightBounds(bounds);
|
|
paint.setColor(CanvasKit.RED);
|
|
paint.setStrokeWidth(3.0);
|
|
canvas.drawRect(bounds, paint);
|
|
|
|
path.delete();
|
|
paint.delete();
|
|
});
|
|
|
|
gm('arcto_path', (canvas) => {
|
|
const paint = new CanvasKit.Paint();
|
|
|
|
paint.setStyle(CanvasKit.PaintStyle.Stroke);
|
|
paint.setStrokeWidth(5.0);
|
|
paint.setAntiAlias(true);
|
|
paint.setColor(CanvasKit.BLACK);
|
|
|
|
canvas.clear(CanvasKit.WHITE);
|
|
|
|
const path = new CanvasKit.Path();
|
|
|
|
// - x1, y1, x2, y2, radius
|
|
path.arcToTangent(40, 0, 40, 40, 40);
|
|
// - oval (as Rect), startAngle, sweepAngle, forceMoveTo
|
|
path.arcToOval(CanvasKit.LTRBRect(90, 10, 120, 200), 30, 300, true);
|
|
// - rx, ry, xAxisRotate, useSmallArc, isCCW, x, y
|
|
path.moveTo(5, 105);
|
|
path.arcToRotated(24, 24, 45, true, false, 82, 156);
|
|
|
|
canvas.drawPath(path, paint);
|
|
|
|
path.delete();
|
|
paint.delete();
|
|
});
|
|
|
|
gm('path_relative', (canvas) => {
|
|
const paint = new CanvasKit.Paint();
|
|
paint.setStrokeWidth(1.0);
|
|
paint.setAntiAlias(true);
|
|
paint.setColor(CanvasKit.Color(0, 0, 0, 1.0));
|
|
paint.setStyle(CanvasKit.PaintStyle.Stroke);
|
|
|
|
const path = new CanvasKit.Path();
|
|
path.rMoveTo(20, 5)
|
|
.rLineTo(10, 15) // 30, 20
|
|
.rLineTo(10, -5); // 40, 10
|
|
path.rLineTo(10, 10); // 50, 20
|
|
path.rLineTo(10, -20); // 60, 0
|
|
path.rLineTo(-40, 5); // 20, 5
|
|
|
|
path.moveTo(20, 80)
|
|
.rCubicTo(70, -70, 140, 70, 170, -70); // 90, 10, 160, 150, 190, 10
|
|
|
|
path.moveTo(36, 148)
|
|
.rQuadTo(30, 40, 84, -12) // 66, 188, 120, 136
|
|
.lineTo(36, 148);
|
|
|
|
path.moveTo(150, 180)
|
|
.rArcTo(24, 24, 45, true, false, -68, -24); // 82, 156
|
|
path.lineTo(160, 160);
|
|
|
|
canvas.drawPath(path, paint);
|
|
|
|
path.delete();
|
|
paint.delete();
|
|
});
|
|
|
|
it('can measure the contours of a path', () => {
|
|
const path = new CanvasKit.Path();
|
|
path.moveTo(10, 10)
|
|
.lineTo(40, 50); // should be length 50 because of the 3/4/5 triangle rule
|
|
|
|
path.moveTo(80, 0)
|
|
.lineTo(80, 10)
|
|
.lineTo(100, 5)
|
|
.lineTo(80, 0);
|
|
|
|
const meas = new CanvasKit.ContourMeasureIter(path, false, 1);
|
|
let cont = meas.next();
|
|
expect(cont).toBeTruthy();
|
|
|
|
expect(cont.length()).toBeCloseTo(50.0, 3);
|
|
const pt = cont.getPosTan(28.7); // arbitrary point
|
|
expect(pt[0]).toBeCloseTo(27.22, 3); // x
|
|
expect(pt[1]).toBeCloseTo(32.96, 3); // y
|
|
expect(pt[2]).toBeCloseTo(0.6, 3); // dy
|
|
expect(pt[3]).toBeCloseTo(0.8, 3); // dy
|
|
|
|
pt.set([-1, -1, -1, -1]); // fill with sentinel values.
|
|
cont.getPosTan(28.7, pt); // arbitrary point again, passing in an array to copy into.
|
|
expect(pt[0]).toBeCloseTo(27.22, 3); // x
|
|
expect(pt[1]).toBeCloseTo(32.96, 3); // y
|
|
expect(pt[2]).toBeCloseTo(0.6, 3); // dy
|
|
expect(pt[3]).toBeCloseTo(0.8, 3); // dy
|
|
|
|
const subpath = cont.getSegment(20, 40, true); // make sure this doesn't crash
|
|
|
|
cont.delete();
|
|
cont = meas.next();
|
|
expect(cont).toBeTruthy();
|
|
expect(cont.length()).toBeCloseTo(51.231, 3);
|
|
|
|
cont.delete();
|
|
expect(meas.next()).toBeFalsy();
|
|
|
|
meas.delete();
|
|
path.delete();
|
|
});
|
|
|
|
gm('drawpoly_path', (canvas) => {
|
|
const paint = new CanvasKit.Paint();
|
|
paint.setStrokeWidth(1.0);
|
|
paint.setAntiAlias(true);
|
|
paint.setColor(CanvasKit.Color(0, 0, 0, 1.0));
|
|
paint.setStyle(CanvasKit.PaintStyle.Stroke);
|
|
|
|
const points = [5, 5, 30, 20, 55, 5, 55, 50, 30, 30, 5, 50];
|
|
|
|
const pointsObj = CanvasKit.Malloc(Float32Array, 6 * 2);
|
|
const mPoints = pointsObj.toTypedArray();
|
|
mPoints.set([105, 105, 130, 120, 155, 105, 155, 150, 130, 130, 105, 150]);
|
|
|
|
const path = new CanvasKit.Path();
|
|
path.addPoly(points, true)
|
|
.moveTo(100, 0)
|
|
.addPoly(mPoints, true);
|
|
|
|
canvas.drawPath(path, paint);
|
|
CanvasKit.Free(pointsObj);
|
|
|
|
path.delete();
|
|
paint.delete();
|
|
});
|
|
|
|
// Test trim, adding paths to paths, and a bunch of other path methods.
|
|
gm('trim_path', (canvas) => {
|
|
canvas.clear(CanvasKit.WHITE);
|
|
|
|
const paint = new CanvasKit.Paint();
|
|
paint.setStrokeWidth(1.0);
|
|
paint.setAntiAlias(true);
|
|
paint.setColor(CanvasKit.Color(0, 0, 0, 1.0));
|
|
paint.setStyle(CanvasKit.PaintStyle.Stroke);
|
|
|
|
const arcpath = new CanvasKit.Path();
|
|
arcpath.arc(400, 400, 100, 0, -90, false) // x, y, radius, startAngle, endAngle, ccw
|
|
.dash(3, 1, 0)
|
|
.conicTo(10, 20, 30, 40, 5)
|
|
.rConicTo(60, 70, 80, 90, 5)
|
|
.trim(0.2, 1, false);
|
|
|
|
const path = new CanvasKit.Path();
|
|
path.addArc(CanvasKit.LTRBRect(10, 20, 100, 200), 30, 300)
|
|
.addRect(CanvasKit.LTRBRect(200, 200, 300, 300)) // test single arg, default cw
|
|
.addRect(CanvasKit.LTRBRect(240, 240, 260, 260), true) // test two arg, true means ccw
|
|
.addRect([260, 260, 290, 290], true) // test five arg, true means ccw
|
|
.addRRect([300, 10, 500, 290, // Rect in LTRB order
|
|
60, 60, 60, 60, 60, 60, 60, 60], // all radii are the same
|
|
false) // ccw
|
|
.addRRect(CanvasKit.RRectXY([350, 60, 450, 240], 20, 80), true) // Rect, rx, ry, ccw
|
|
.addPath(arcpath)
|
|
.transform(0.54, -0.84, 390.35,
|
|
0.84, 0.54, -114.53,
|
|
0, 0, 1);
|
|
|
|
canvas.drawPath(path, paint);
|
|
|
|
path.delete();
|
|
paint.delete();
|
|
});
|
|
|
|
gm('winding_example', (canvas) => {
|
|
// Inspired by https://fiddle.skia.org/c/@Path_FillType_a
|
|
const path = new CanvasKit.Path();
|
|
// Draw overlapping rects on top
|
|
path.addRect(CanvasKit.LTRBRect(10, 10, 30, 30), false);
|
|
path.addRect(CanvasKit.LTRBRect(20, 20, 40, 40), false);
|
|
// Draw overlapping rects on bottom, with different direction lines.
|
|
path.addRect(CanvasKit.LTRBRect(10, 60, 30, 80), false);
|
|
path.addRect(CanvasKit.LTRBRect(20, 70, 40, 90), true);
|
|
|
|
expect(path.getFillType()).toEqual(CanvasKit.FillType.Winding);
|
|
|
|
// Draw the two rectangles on the left side.
|
|
const paint = new CanvasKit.Paint();
|
|
paint.setStyle(CanvasKit.PaintStyle.Stroke);
|
|
canvas.drawPath(path, paint);
|
|
|
|
const clipRect = CanvasKit.LTRBRect(0, 0, 51, 100);
|
|
paint.setStyle(CanvasKit.PaintStyle.Fill);
|
|
|
|
for (const fillType of [CanvasKit.FillType.Winding, CanvasKit.FillType.EvenOdd]) {
|
|
canvas.translate(51, 0);
|
|
canvas.save();
|
|
canvas.clipRect(clipRect, CanvasKit.ClipOp.Intersect, false);
|
|
path.setFillType(fillType);
|
|
canvas.drawPath(path, paint);
|
|
canvas.restore();
|
|
}
|
|
|
|
path.delete();
|
|
paint.delete();
|
|
});
|
|
|
|
gm('as_winding', (canvas) => {
|
|
const evenOddPath = new CanvasKit.Path();
|
|
// Draw overlapping rects
|
|
evenOddPath.addRect(CanvasKit.LTRBRect(10, 10, 70, 70), false);
|
|
evenOddPath.addRect(CanvasKit.LTRBRect(30, 30, 50, 50), false);
|
|
evenOddPath.setFillType(CanvasKit.FillType.EvenOdd);
|
|
|
|
const evenOddCmds = evenOddPath.toCmds();
|
|
expect(evenOddCmds).toEqual(Float32Array.of(
|
|
CanvasKit.MOVE_VERB, 10, 10,
|
|
CanvasKit.LINE_VERB, 70, 10,
|
|
CanvasKit.LINE_VERB, 70, 70,
|
|
CanvasKit.LINE_VERB, 10, 70,
|
|
CanvasKit.CLOSE_VERB,
|
|
CanvasKit.MOVE_VERB, 30, 30, // This contour is drawn
|
|
CanvasKit.LINE_VERB, 50, 30, // clockwise, as specified.
|
|
CanvasKit.LINE_VERB, 50, 50,
|
|
CanvasKit.LINE_VERB, 30, 50,
|
|
CanvasKit.CLOSE_VERB
|
|
));
|
|
|
|
const windingPath = evenOddPath.makeAsWinding();
|
|
|
|
expect(windingPath.getFillType()).toBe(CanvasKit.FillType.Winding);
|
|
const windingCmds = windingPath.toCmds();
|
|
expect(windingCmds).toEqual(Float32Array.of(
|
|
CanvasKit.MOVE_VERB, 10, 10,
|
|
CanvasKit.LINE_VERB, 70, 10,
|
|
CanvasKit.LINE_VERB, 70, 70,
|
|
CanvasKit.LINE_VERB, 10, 70,
|
|
CanvasKit.CLOSE_VERB,
|
|
CanvasKit.MOVE_VERB, 30, 50, // This contour has been
|
|
CanvasKit.LINE_VERB, 50, 50, // re-drawn counter-clockwise
|
|
CanvasKit.LINE_VERB, 50, 30, // so that it covers the same
|
|
CanvasKit.LINE_VERB, 30, 30, // area, but with the winding fill type.
|
|
CanvasKit.CLOSE_VERB
|
|
));
|
|
|
|
const paint = new CanvasKit.Paint();
|
|
paint.setStyle(CanvasKit.PaintStyle.Fill);
|
|
const font = new CanvasKit.Font(null, 20);
|
|
|
|
canvas.drawText('Original path (even odd)', 5, 20, paint, font);
|
|
canvas.translate(0, 50);
|
|
canvas.drawPath(evenOddPath, paint);
|
|
|
|
canvas.translate(300, 0);
|
|
canvas.drawPath(windingPath, paint);
|
|
|
|
canvas.translate(0, -50);
|
|
canvas.drawText('makeAsWinding path', 5, 20, paint, font);
|
|
|
|
evenOddPath.delete();
|
|
windingPath.delete();
|
|
});
|
|
});
|