blob: 7123c10230b13c631dd15b9818377321ed0f22a7 [file] [log] [blame]
Kevin Lubickf5ea37f2019-02-28 10:06:18 -05001// helper JS that could be used anywhere in the glue code
Kevin Lubick217056c2018-09-20 17:39:31 -04002
Kevin Lubickf5ea37f2019-02-28 10:06:18 -05003function clamp(c) {
4 return Math.round(Math.max(0, Math.min(c || 0, 255)));
5}
Kevin Lubick217056c2018-09-20 17:39:31 -04006
Nathaniel Nifonge5d32542020-03-26 09:27:48 -04007// Constructs a Color with the same API as CSS's rgba(), that is
Kevin Lubickf5ea37f2019-02-28 10:06:18 -05008// r,g,b are 0-255, and a is 0.0 to 1.0.
9// if a is omitted, it will be assumed to be 1.0
Nathaniel Nifonge5d32542020-03-26 09:27:48 -040010// Internally, Colors are a TypedArray of four unpremultiplied 32-bit floats: a, r, g, b
11// In order to construct one with more precision or in a wider gamut, use
12// CanvasKit.Color4f
Kevin Lubickf5ea37f2019-02-28 10:06:18 -050013CanvasKit.Color = function(r, g, b, a) {
14 if (a === undefined) {
15 a = 1;
Kevin Lubick217056c2018-09-20 17:39:31 -040016 }
Nathaniel Nifonge5d32542020-03-26 09:27:48 -040017 return CanvasKit.Color4f(clamp(r)/255, clamp(g)/255, clamp(b)/255, a);
Kevin Lubickf5ea37f2019-02-28 10:06:18 -050018}
Kevin Lubick217056c2018-09-20 17:39:31 -040019
Kevin Lubick9adc1d42020-06-04 08:25:16 -040020// Constructs a Color as a 32 bit unsigned integer, with 8 bits assigned to each channel.
Kevin Lubick93f1a382020-06-02 16:15:23 -040021// Channels are expected to be between 0 and 255 and will be clamped as such.
22CanvasKit.ColorAsInt = function(r, g, b, a) {
23 // default to opaque
24 if (a === undefined) {
25 a = 255;
26 }
Kevin Lubick9adc1d42020-06-04 08:25:16 -040027 // This is consistent with how Skia represents colors in C++, as an unsigned int.
Kevin Lubick59e087e2020-06-03 12:24:07 -040028 // This is also consistent with how Flutter represents colors:
29 // https://github.com/flutter/engine/blob/243bb59c7179a7e701ce478080d6ce990710ae73/lib/web_ui/lib/src/ui/painting.dart#L50
Kevin Lubick9adc1d42020-06-04 08:25:16 -040030 return (((clamp(a) << 24) | (clamp(r) << 16) | (clamp(g) << 8) | (clamp(b) << 0)
31 & 0xFFFFFFF) // This truncates the unsigned to 32 bits and signals to JS engines they can
32 // represent the number with an int instead of a double.
33 >>> 0); // This makes the value an unsigned int.
Kevin Lubick93f1a382020-06-02 16:15:23 -040034}
Nathaniel Nifonge5d32542020-03-26 09:27:48 -040035// Construct a 4-float color.
36// Opaque if opacity is omitted.
37CanvasKit.Color4f = function(r, g, b, a) {
38 if (a === undefined) {
39 a = 1;
40 }
41 return Float32Array.of(r, g, b, a);
42}
43
44// Color constants use property getters to prevent other code from accidentally
45// changing them.
46Object.defineProperty(CanvasKit, "TRANSPARENT", {
47 get: function() { return CanvasKit.Color4f(0, 0, 0, 0); }
48});
49Object.defineProperty(CanvasKit, "BLACK", {
50 get: function() { return CanvasKit.Color4f(0, 0, 0, 1); }
51});
52Object.defineProperty(CanvasKit, "WHITE", {
53 get: function() { return CanvasKit.Color4f(1, 1, 1, 1); }
54});
55Object.defineProperty(CanvasKit, "RED", {
56 get: function() { return CanvasKit.Color4f(1, 0, 0, 1); }
57});
58Object.defineProperty(CanvasKit, "GREEN", {
59 get: function() { return CanvasKit.Color4f(0, 1, 0, 1); }
60});
61Object.defineProperty(CanvasKit, "BLUE", {
62 get: function() { return CanvasKit.Color4f(0, 0, 1, 1); }
63});
64Object.defineProperty(CanvasKit, "YELLOW", {
65 get: function() { return CanvasKit.Color4f(1, 1, 0, 1); }
66});
67Object.defineProperty(CanvasKit, "CYAN", {
68 get: function() { return CanvasKit.Color4f(0, 1, 1, 1); }
69});
70Object.defineProperty(CanvasKit, "MAGENTA", {
71 get: function() { return CanvasKit.Color4f(1, 0, 1, 1); }
72});
73
74// returns a css style [r, g, b, a] from a CanvasKit.Color
75// where r, g, b are returned as ints in the range [0, 255]
Kevin Lubickf5ea37f2019-02-28 10:06:18 -050076// where a is scaled between 0 and 1.0
77CanvasKit.getColorComponents = function(color) {
78 return [
Nathaniel Nifonge5d32542020-03-26 09:27:48 -040079 Math.floor(color[0]*255),
80 Math.floor(color[1]*255),
81 Math.floor(color[2]*255),
82 color[3]
83 ];
Kevin Lubickf5ea37f2019-02-28 10:06:18 -050084}
85
Kevin Lubick39284662020-02-20 10:29:55 -050086// parseColorString takes in a CSS color value and returns a CanvasKit.Color
Nathaniel Nifonge5d32542020-03-26 09:27:48 -040087// (which is an array of 4 floats in RGBA order). An optional colorMap
88// may be provided which maps custom strings to values.
Kevin Lubick39284662020-02-20 10:29:55 -050089// In the CanvasKit canvas2d shim layer, we provide this map for processing
90// canvas2d calls, but not here for code size reasons.
91CanvasKit.parseColorString = function(colorStr, colorMap) {
92 colorStr = colorStr.toLowerCase();
93 // See https://drafts.csswg.org/css-color/#typedef-hex-color
94 if (colorStr.startsWith('#')) {
95 var r, g, b, a = 255;
96 switch (colorStr.length) {
97 case 9: // 8 hex chars #RRGGBBAA
98 a = parseInt(colorStr.slice(7, 9), 16);
99 case 7: // 6 hex chars #RRGGBB
100 r = parseInt(colorStr.slice(1, 3), 16);
101 g = parseInt(colorStr.slice(3, 5), 16);
102 b = parseInt(colorStr.slice(5, 7), 16);
103 break;
104 case 5: // 4 hex chars #RGBA
105 // multiplying by 17 is the same effect as
106 // appending another character of the same value
107 // e.g. e => ee == 14 => 238
108 a = parseInt(colorStr.slice(4, 5), 16) * 17;
109 case 4: // 6 hex chars #RGB
110 r = parseInt(colorStr.slice(1, 2), 16) * 17;
111 g = parseInt(colorStr.slice(2, 3), 16) * 17;
112 b = parseInt(colorStr.slice(3, 4), 16) * 17;
113 break;
114 }
115 return CanvasKit.Color(r, g, b, a/255);
116
117 } else if (colorStr.startsWith('rgba')) {
118 // Trim off rgba( and the closing )
119 colorStr = colorStr.slice(5, -1);
120 var nums = colorStr.split(',');
121 return CanvasKit.Color(+nums[0], +nums[1], +nums[2],
122 valueOrPercent(nums[3]));
123 } else if (colorStr.startsWith('rgb')) {
124 // Trim off rgba( and the closing )
125 colorStr = colorStr.slice(4, -1);
126 var nums = colorStr.split(',');
127 // rgb can take 3 or 4 arguments
128 return CanvasKit.Color(+nums[0], +nums[1], +nums[2],
129 valueOrPercent(nums[3]));
130 } else if (colorStr.startsWith('gray(')) {
131 // TODO
132 } else if (colorStr.startsWith('hsl')) {
133 // TODO
134 } else if (colorMap) {
135 // Try for named color
136 var nc = colorMap[colorStr];
137 if (nc !== undefined) {
138 return nc;
139 }
140 }
141 SkDebug('unrecognized color ' + colorStr);
142 return CanvasKit.BLACK;
143}
144
Nathaniel Nifonge5d32542020-03-26 09:27:48 -0400145function isCanvasKitColor(ob) {
146 if (!ob) {
147 return false;
148 }
149 return (ob.constructor === Float32Array && ob.length === 4);
150}
151
152// Warning information is lost by this conversion
153function toUint32Color(c) {
154 return ((clamp(c[3]*255) << 24) | (clamp(c[0]*255) << 16) | (clamp(c[1]*255) << 8) | (clamp(c[2]*255) << 0)) >>> 0;
155}
156function uIntColorToCanvasKitColor(c) {
157 return CanvasKit.Color(
158 (c >> 16) & 0xFF,
159 (c >> 8) & 0xFF,
160 (c >> 0) & 0xFF,
161 ((c >> 24) & 0xFF) / 255
162 );
163}
164
Kevin Lubick39284662020-02-20 10:29:55 -0500165function valueOrPercent(aStr) {
166 if (aStr === undefined) {
167 return 1; // default to opaque.
168 }
169 var a = parseFloat(aStr);
170 if (aStr && aStr.indexOf('%') !== -1) {
171 return a / 100;
172 }
173 return a;
174}
175
Kevin Lubickf5ea37f2019-02-28 10:06:18 -0500176CanvasKit.multiplyByAlpha = function(color, alpha) {
Nathaniel Nifonge5d32542020-03-26 09:27:48 -0400177 // make a copy of the color so the function remains pure.
178 var result = color.slice();
179 result[3] = Math.max(0, Math.min(result[3] * alpha, 1));
180 return result;
Kevin Lubickf5ea37f2019-02-28 10:06:18 -0500181}
Kevin Lubick61ef7b22018-11-27 13:26:59 -0500182
Kevin Lubickf5ea37f2019-02-28 10:06:18 -0500183function radiansToDegrees(rad) {
184 return (rad / Math.PI) * 180;
185}
Kevin Lubick12c0e502018-11-28 12:51:56 -0500186
Kevin Lubickf5ea37f2019-02-28 10:06:18 -0500187function degreesToRadians(deg) {
188 return (deg / 180) * Math.PI;
189}
Kevin Lubick12c0e502018-11-28 12:51:56 -0500190
191// See https://stackoverflow.com/a/31090240
192// This contraption keeps closure from minifying away the check
193// if btoa is defined *and* prevents runtime "btoa" or "window" is not defined.
194// Defined outside any scopes to make it available in all files.
195var isNode = !(new Function("try {return this===window;}catch(e){ return false;}")());
Kevin Lubick1646e7d2018-12-07 13:03:08 -0500196
197function almostEqual(floata, floatb) {
198 return Math.abs(floata - floatb) < 0.00001;
Kevin Lubickf5ea37f2019-02-28 10:06:18 -0500199}
200
201
202var nullptr = 0; // emscripten doesn't like to take null as uintptr_t
203
204// arr can be a normal JS array or a TypedArray
Kevin Lubick69e46da2020-06-05 07:13:48 -0400205// dest is a string like "HEAPU32" that specifies the type that the src array is.
Kevin Lubickd6ba7252019-06-03 14:38:05 -0400206// ptr can be optionally provided if the memory was already allocated.
207function copy1dArray(arr, dest, ptr) {
Kevin Lubickf5ea37f2019-02-28 10:06:18 -0500208 if (!arr || !arr.length) {
209 return nullptr;
210 }
Kevin Lubicke25df6c2019-10-22 09:04:32 -0400211 // This was created with CanvasKit.Malloc, so it's already been copied.
212 if (arr['_ck']) {
213 return arr.byteOffset;
214 }
Kevin Lubick69e46da2020-06-05 07:13:48 -0400215 var bytesPerElement = CanvasKit[dest].BYTES_PER_ELEMENT;
Kevin Lubickd6ba7252019-06-03 14:38:05 -0400216 if (!ptr) {
Kevin Lubick69e46da2020-06-05 07:13:48 -0400217 ptr = CanvasKit._malloc(arr.length * bytesPerElement);
Kevin Lubickd6ba7252019-06-03 14:38:05 -0400218 }
Kevin Lubickf5ea37f2019-02-28 10:06:18 -0500219 // In c++ terms, the WASM heap is a uint8_t*, a long buffer/array of single
220 // byte elements. When we run _malloc, we always get an offset/pointer into
221 // that block of memory.
222 // CanvasKit exposes some different views to make it easier to work with
223 // different types. HEAPF32 for example, exposes it as a float*
224 // However, to make the ptr line up, we have to do some pointer arithmetic.
225 // Concretely, we need to convert ptr to go from an index into a 1-byte-wide
226 // buffer to an index into a 4-byte-wide buffer (in the case of HEAPF32)
227 // and thus we divide ptr by 4.
Kevin Lubick69e46da2020-06-05 07:13:48 -0400228 // It is important to make sure we are grabbing the freshest view of the
229 // memory possible because if we call _malloc and the heap needs to grow,
230 // the TypedArrayView will no longer be valid.
231 CanvasKit[dest].set(arr, ptr / bytesPerElement);
Kevin Lubickf5ea37f2019-02-28 10:06:18 -0500232 return ptr;
233}
234
235// arr should be a non-jagged 2d JS array (TypedArrays can't be nested
Kevin Lubick37ab53e2019-11-11 10:06:08 -0500236// inside themselves). A common use case is points.
Kevin Lubickf5ea37f2019-02-28 10:06:18 -0500237// dest is something like CanvasKit.HEAPF32
Kevin Lubickd6ba7252019-06-03 14:38:05 -0400238// ptr can be optionally provided if the memory was already allocated.
Kevin Lubick69e46da2020-06-05 07:13:48 -0400239// TODO(kjlubick): Remove 2d arrays - everything should be flat.
Kevin Lubickd6ba7252019-06-03 14:38:05 -0400240function copy2dArray(arr, dest, ptr) {
Kevin Lubickf5ea37f2019-02-28 10:06:18 -0500241 if (!arr || !arr.length) {
242 return nullptr;
243 }
Kevin Lubick69e46da2020-06-05 07:13:48 -0400244 var bytesPerElement = CanvasKit[dest].BYTES_PER_ELEMENT;
Kevin Lubickd6ba7252019-06-03 14:38:05 -0400245 if (!ptr) {
Kevin Lubick69e46da2020-06-05 07:13:48 -0400246 ptr = CanvasKit._malloc(arr.length * arr[0].length * bytesPerElement);
Kevin Lubickd6ba7252019-06-03 14:38:05 -0400247 }
Kevin Lubick69e46da2020-06-05 07:13:48 -0400248 // Make sure we have a fresh view of the heap after we malloc.
249 dest = CanvasKit[dest];
Kevin Lubickf5ea37f2019-02-28 10:06:18 -0500250 var idx = 0;
Kevin Lubick69e46da2020-06-05 07:13:48 -0400251 var adjustedPtr = ptr / bytesPerElement;
Kevin Lubickf5ea37f2019-02-28 10:06:18 -0500252 for (var r = 0; r < arr.length; r++) {
253 for (var c = 0; c < arr[0].length; c++) {
254 dest[adjustedPtr + idx] = arr[r][c];
255 idx++;
256 }
257 }
258 return ptr;
259}
260
Kevin Lubick6bffe392020-04-02 15:24:15 -0400261var defaultPerspective = Float32Array.of(0, 0, 1);
262
Kevin Lubick6aa38692020-06-01 11:25:47 -0400263var _scratch3x3MatrixPtr = nullptr;
Kevin Lubick462a8602020-06-01 15:43:03 -0400264var _scratch3x3Matrix; // the result from CanvasKit.Malloc
Kevin Lubick6aa38692020-06-01 11:25:47 -0400265
Kevin Lubick6bffe392020-04-02 15:24:15 -0400266// Copies the given DOMMatrix/Array/TypedArray to the CanvasKit heap and
267// returns a pointer to the memory. This memory is a float* of length 9.
268// If the passed in matrix is null/undefined, we return 0 (nullptr). All calls
269// on the C++ side should check for nullptr where appropriate. It is generally
270// the responsibility of the JS side code to call CanvasKit._free on the
271// allocated memory before returning to the user code.
272function copy3x3MatrixToWasm(matr) {
273 if (!matr) {
274 return nullptr;
275 }
Kevin Lubick6aa38692020-06-01 11:25:47 -0400276
Kevin Lubick6bffe392020-04-02 15:24:15 -0400277 if (matr.length) {
278 // TODO(kjlubick): Downsample a 16 length (4x4 matrix)
279 if (matr.length !== 6 && matr.length !== 9) {
280 throw 'invalid matrix size';
281 }
282 // This should be an array or typed array.
283 // have to divide the pointer by 4 to "cast" it from bytes to float.
Kevin Lubick69e46da2020-06-05 07:13:48 -0400284 var mPtr = copy1dArray(matr, "HEAPF32", _scratch3x3MatrixPtr);
Kevin Lubick6bffe392020-04-02 15:24:15 -0400285 if (matr.length === 6) {
Kevin Lubick6aa38692020-06-01 11:25:47 -0400286 // Overwrite the last 3 floats with the default perspective. The divide
287 // by 4 casts the pointer into a float pointer.
288 CanvasKit.HEAPF32.set(defaultPerspective, 6 + mPtr / 4);
Kevin Lubick6bffe392020-04-02 15:24:15 -0400289 }
Kevin Lubick6aa38692020-06-01 11:25:47 -0400290 return mPtr;
Kevin Lubick6bffe392020-04-02 15:24:15 -0400291 }
Kevin Lubick462a8602020-06-01 15:43:03 -0400292 var wasm3x3Matrix = _scratch3x3Matrix['toTypedArray']();
Kevin Lubick6aa38692020-06-01 11:25:47 -0400293 // Try as if it's a DOMMatrix. Reminder that DOMMatrix is column-major.
Kevin Lubick462a8602020-06-01 15:43:03 -0400294 wasm3x3Matrix[0] = matr.m11;
295 wasm3x3Matrix[1] = matr.m21;
296 wasm3x3Matrix[2] = matr.m41;
Kevin Lubick6aa38692020-06-01 11:25:47 -0400297
Kevin Lubick462a8602020-06-01 15:43:03 -0400298 wasm3x3Matrix[3] = matr.m12;
299 wasm3x3Matrix[4] = matr.m22;
300 wasm3x3Matrix[5] = matr.m42;
Kevin Lubick6aa38692020-06-01 11:25:47 -0400301
Kevin Lubick462a8602020-06-01 15:43:03 -0400302 wasm3x3Matrix[6] = matr.m14;
303 wasm3x3Matrix[7] = matr.m24;
304 wasm3x3Matrix[8] = matr.m44;
Kevin Lubick6aa38692020-06-01 11:25:47 -0400305 return _scratch3x3MatrixPtr;
Kevin Lubick6bffe392020-04-02 15:24:15 -0400306}
307
Kevin Lubick6aa38692020-06-01 11:25:47 -0400308var _scratch4x4MatrixPtr = nullptr;
Kevin Lubick462a8602020-06-01 15:43:03 -0400309var _scratch4x4Matrix; // the result from CanvasKit.Malloc
Kevin Lubick6aa38692020-06-01 11:25:47 -0400310
Kevin Lubickc1d08982020-04-06 13:52:15 -0400311function copy4x4MatrixToWasm(matr) {
312 if (!matr) {
313 return nullptr;
314 }
Kevin Lubick462a8602020-06-01 15:43:03 -0400315 var wasm4x4Matrix = _scratch4x4Matrix['toTypedArray']();
Kevin Lubickc1d08982020-04-06 13:52:15 -0400316 if (matr.length) {
317 if (matr.length !== 16 && matr.length !== 6 && matr.length !== 9) {
318 throw 'invalid matrix size';
319 }
320 if (matr.length === 16) {
321 // This should be an array or typed array.
322 // have to divide the pointer by 4 to "cast" it from bytes to float.
Kevin Lubick69e46da2020-06-05 07:13:48 -0400323 return copy1dArray(matr, "HEAPF32", _scratch4x4MatrixPtr);
Kevin Lubickc1d08982020-04-06 13:52:15 -0400324 }
Kevin Lubick6aa38692020-06-01 11:25:47 -0400325 // Upscale the row-major 3x3 or 3x2 matrix into a 4x4 row-major matrix
326 // TODO(skbug.com/10108) This will need to change when we convert our
327 // JS 4x4 to be column-major.
328 // When upscaling, we need to overwrite the 3rd column and the 3rd row with
329 // 0s. It's easiest to just do that with a fill command.
Kevin Lubick462a8602020-06-01 15:43:03 -0400330 wasm4x4Matrix.fill(0);
331 wasm4x4Matrix[0] = matr[0];
332 wasm4x4Matrix[1] = matr[1];
Kevin Lubick6aa38692020-06-01 11:25:47 -0400333 // skip col 2
Kevin Lubick462a8602020-06-01 15:43:03 -0400334 wasm4x4Matrix[3] = matr[2];
Kevin Lubick6aa38692020-06-01 11:25:47 -0400335
Kevin Lubick462a8602020-06-01 15:43:03 -0400336 wasm4x4Matrix[4] = matr[3];
337 wasm4x4Matrix[5] = matr[4];
Kevin Lubick6aa38692020-06-01 11:25:47 -0400338 // skip col 2
Kevin Lubick462a8602020-06-01 15:43:03 -0400339 wasm4x4Matrix[7] = matr[5];
Kevin Lubick6aa38692020-06-01 11:25:47 -0400340
341 // skip row 2
342
Kevin Lubick462a8602020-06-01 15:43:03 -0400343 wasm4x4Matrix[12] = matr[6];
344 wasm4x4Matrix[13] = matr[7];
Kevin Lubick6aa38692020-06-01 11:25:47 -0400345 // skip col 2
Kevin Lubick462a8602020-06-01 15:43:03 -0400346 wasm4x4Matrix[15] = matr[8];
Kevin Lubick6aa38692020-06-01 11:25:47 -0400347
348 if (matr.length === 6) {
349 // fix perspective for the 3x2 case (from above, they will be undefined).
Kevin Lubick462a8602020-06-01 15:43:03 -0400350 wasm4x4Matrix[12]=0;
351 wasm4x4Matrix[13]=0;
352 wasm4x4Matrix[15]=1;
Kevin Lubick6aa38692020-06-01 11:25:47 -0400353 }
354 return _scratch4x4MatrixPtr;
Kevin Lubickc1d08982020-04-06 13:52:15 -0400355 }
Kevin Lubick6aa38692020-06-01 11:25:47 -0400356 // Try as if it's a DOMMatrix. Reminder that DOMMatrix is column-major.
Kevin Lubick462a8602020-06-01 15:43:03 -0400357 wasm4x4Matrix[0] = matr.m11;
358 wasm4x4Matrix[1] = matr.m21;
359 wasm4x4Matrix[2] = matr.m31;
360 wasm4x4Matrix[3] = matr.m41;
Kevin Lubick6aa38692020-06-01 11:25:47 -0400361
Kevin Lubick462a8602020-06-01 15:43:03 -0400362 wasm4x4Matrix[4] = matr.m12;
363 wasm4x4Matrix[5] = matr.m22;
364 wasm4x4Matrix[6] = matr.m32;
365 wasm4x4Matrix[7] = matr.m42;
Kevin Lubick6aa38692020-06-01 11:25:47 -0400366
Kevin Lubick462a8602020-06-01 15:43:03 -0400367 wasm4x4Matrix[8] = matr.m13;
368 wasm4x4Matrix[9] = matr.m23;
369 wasm4x4Matrix[10] = matr.m33;
370 wasm4x4Matrix[11] = matr.m43;
Kevin Lubick6aa38692020-06-01 11:25:47 -0400371
Kevin Lubick462a8602020-06-01 15:43:03 -0400372 wasm4x4Matrix[12] = matr.m14;
373 wasm4x4Matrix[13] = matr.m24;
374 wasm4x4Matrix[14] = matr.m34;
375 wasm4x4Matrix[15] = matr.m44;
Kevin Lubick6aa38692020-06-01 11:25:47 -0400376 return _scratch4x4MatrixPtr;
Kevin Lubickc1d08982020-04-06 13:52:15 -0400377}
378
Kevin Lubick6aa38692020-06-01 11:25:47 -0400379// copies a 4x4 matrix at the given pointer into a JS array. It is the caller's
380// responsibility to free the matrPtr if needed.
Kevin Lubickc1d08982020-04-06 13:52:15 -0400381function copy4x4MatrixFromWasm(matrPtr) {
382 // read them out into an array. TODO(kjlubick): If we change SkMatrix to be
383 // typedArrays, then we should return a typed array here too.
384 var rv = new Array(16);
385 for (var i = 0; i < 16; i++) {
386 rv[i] = CanvasKit.HEAPF32[matrPtr/4 + i]; // divide by 4 to "cast" to float.
387 }
Kevin Lubickc1d08982020-04-06 13:52:15 -0400388 return rv;
389}
390
Kevin Lubick6aa38692020-06-01 11:25:47 -0400391var _scratchColorPtr = nullptr;
Kevin Lubick93f1a382020-06-02 16:15:23 -0400392var _scratchColor; // the result from CanvasKit.Malloc
Kevin Lubick6aa38692020-06-01 11:25:47 -0400393
394function copyColorToWasm(color4f, ptr) {
Kevin Lubick69e46da2020-06-05 07:13:48 -0400395 return copy1dArray(color4f, "HEAPF32", ptr || _scratchColorPtr);
Kevin Lubick6aa38692020-06-01 11:25:47 -0400396}
397
Kevin Lubick93f1a382020-06-02 16:15:23 -0400398function copyColorComponentsToWasm(r, g, b, a) {
399 var colors = _scratchColor['toTypedArray']();
400 colors[0] = r;
401 colors[1] = g;
402 colors[2] = b;
403 colors[3] = a;
404 return _scratchColorPtr;
405}
406
Kevin Lubick6aa38692020-06-01 11:25:47 -0400407function copyColorToWasmNoScratch(color4f) {
408 // TODO(kjlubick): accept 4 floats or int color
Kevin Lubick69e46da2020-06-05 07:13:48 -0400409 return copy1dArray(color4f, "HEAPF32");
Kevin Lubick6aa38692020-06-01 11:25:47 -0400410}
411
Nathaniel Nifong1bedbeb2020-05-04 16:46:17 -0400412// copies the four floats at the given pointer in a js Float32Array
413function copyColorFromWasm(colorPtr) {
414 var rv = new Float32Array(4);
415 for (var i = 0; i < 4; i++) {
416 rv[i] = CanvasKit.HEAPF32[colorPtr/4 + i]; // divide by 4 to "cast" to float.
417 }
Nathaniel Nifong1bedbeb2020-05-04 16:46:17 -0400418 return rv;
Kevin Lubickcf118922020-05-28 14:43:38 -0400419}
Nathaniel Nifong1bedbeb2020-05-04 16:46:17 -0400420
Kevin Lubickf5ea37f2019-02-28 10:06:18 -0500421// Caching the Float32Arrays can save having to reallocate them
422// over and over again.
423var Float32ArrayCache = {};
424
425// Takes a 2D array of commands and puts them into the WASM heap
426// as a 1D array. This allows them to referenced from the C++ code.
427// Returns a 2 element array, with the first item being essentially a
428// pointer to the array and the second item being the length of
429// the new 1D array.
430//
431// Example usage:
432// let cmds = [
433// [CanvasKit.MOVE_VERB, 0, 10],
434// [CanvasKit.LINE_VERB, 30, 40],
435// [CanvasKit.QUAD_VERB, 20, 50, 45, 60],
436// ];
437function loadCmdsTypedArray(arr) {
438 var len = 0;
439 for (var r = 0; r < arr.length; r++) {
440 len += arr[r].length;
441 }
442
443 var ta;
444 if (Float32ArrayCache[len]) {
445 ta = Float32ArrayCache[len];
446 } else {
447 ta = new Float32Array(len);
448 Float32ArrayCache[len] = ta;
449 }
450 // Flatten into a 1d array
451 var i = 0;
452 for (var r = 0; r < arr.length; r++) {
453 for (var c = 0; c < arr[r].length; c++) {
454 var item = arr[r][c];
455 ta[i] = item;
456 i++;
457 }
458 }
459
Kevin Lubick69e46da2020-06-05 07:13:48 -0400460 var ptr = copy1dArray(ta, "HEAPF32");
Kevin Lubickf5ea37f2019-02-28 10:06:18 -0500461 return [ptr, len];
462}
Kevin Lubickd3cfbca2019-03-15 15:36:29 -0400463
Kevin Lubickcc13fd32019-04-05 13:00:01 -0400464function saveBytesToFile(bytes, fileName) {
465 if (!isNode) {
466 // https://stackoverflow.com/a/32094834
467 var blob = new Blob([bytes], {type: 'application/octet-stream'});
468 url = window.URL.createObjectURL(blob);
469 var a = document.createElement('a');
470 document.body.appendChild(a);
471 a.href = url;
472 a.download = fileName;
473 a.click();
474 // clean up after because FF might not download it synchronously
475 setTimeout(function() {
476 URL.revokeObjectURL(url);
477 a.remove();
478 }, 50);
479 } else {
480 var fs = require('fs');
481 // https://stackoverflow.com/a/42006750
482 // https://stackoverflow.com/a/47018122
483 fs.writeFile(fileName, new Buffer(bytes), function(err) {
484 if (err) throw err;
485 });
486 }
487}
Kevin Lubickee91c072019-03-29 10:39:52 -0400488/**
489 * Generic helper for dealing with an array of four floats.
490 */
491CanvasKit.FourFloatArrayHelper = function() {
492 this._floats = [];
Kevin Lubickd3cfbca2019-03-15 15:36:29 -0400493 this._ptr = null;
Kevin Lubickee91c072019-03-29 10:39:52 -0400494
495 Object.defineProperty(this, 'length', {
496 enumerable: true,
497 get: function() {
498 return this._floats.length / 4;
499 },
500 });
Kevin Lubickd3cfbca2019-03-15 15:36:29 -0400501}
502
503/**
Kevin Lubickee91c072019-03-29 10:39:52 -0400504 * push the four floats onto the end of the array - if build() has already
505 * been called, the call will return without modifying anything.
Kevin Lubickd3cfbca2019-03-15 15:36:29 -0400506 */
Kevin Lubickee91c072019-03-29 10:39:52 -0400507CanvasKit.FourFloatArrayHelper.prototype.push = function(f1, f2, f3, f4) {
Kevin Lubickd3cfbca2019-03-15 15:36:29 -0400508 if (this._ptr) {
509 SkDebug('Cannot push more points - already built');
510 return;
511 }
Kevin Lubickee91c072019-03-29 10:39:52 -0400512 this._floats.push(f1, f2, f3, f4);
Kevin Lubickd3cfbca2019-03-15 15:36:29 -0400513}
514
Kevin Lubickee91c072019-03-29 10:39:52 -0400515/**
516 * Set the four floats at a given index - if build() has already
517 * been called, the WASM memory will be written to directly.
518 */
519CanvasKit.FourFloatArrayHelper.prototype.set = function(idx, f1, f2, f3, f4) {
520 if (idx < 0 || idx >= this._floats.length/4) {
521 SkDebug('Cannot set index ' + idx + ', it is out of range', this._floats.length/4);
522 return;
523 }
524 idx *= 4;
525 var BYTES_PER_ELEMENT = 4;
526 if (this._ptr) {
527 // convert this._ptr from uint8_t* to SkScalar* by dividing by 4
528 var floatPtr = (this._ptr / BYTES_PER_ELEMENT) + idx;
529 CanvasKit.HEAPF32[floatPtr] = f1;
530 CanvasKit.HEAPF32[floatPtr + 1] = f2;
531 CanvasKit.HEAPF32[floatPtr + 2] = f3;
532 CanvasKit.HEAPF32[floatPtr + 3] = f4;
533 return;
534 }
535 this._floats[idx] = f1;
536 this._floats[idx + 1] = f2;
537 this._floats[idx + 2] = f3;
538 this._floats[idx + 3] = f4;
539}
540
541/**
542 * Copies the float data to the WASM memory and returns a pointer
543 * to that allocated memory. Once build has been called, this
544 * float array cannot be made bigger.
545 */
546CanvasKit.FourFloatArrayHelper.prototype.build = function() {
Kevin Lubickd3cfbca2019-03-15 15:36:29 -0400547 if (this._ptr) {
548 return this._ptr;
549 }
Kevin Lubick69e46da2020-06-05 07:13:48 -0400550 this._ptr = copy1dArray(this._floats, "HEAPF32");
Kevin Lubickd3cfbca2019-03-15 15:36:29 -0400551 return this._ptr;
552}
553
Kevin Lubickee91c072019-03-29 10:39:52 -0400554/**
555 * Frees the wasm memory associated with this array. Of note,
556 * the points are not removed, so push/set/build can all
557 * be called to make a newly allocated (possibly bigger)
558 * float array.
559 */
560CanvasKit.FourFloatArrayHelper.prototype.delete = function() {
Kevin Lubickd3cfbca2019-03-15 15:36:29 -0400561 if (this._ptr) {
562 CanvasKit._free(this._ptr);
563 this._ptr = null;
564 }
565}
Kevin Lubickee91c072019-03-29 10:39:52 -0400566
567/**
568 * Generic helper for dealing with an array of unsigned ints.
569 */
570CanvasKit.OneUIntArrayHelper = function() {
571 this._uints = [];
572 this._ptr = null;
573
574 Object.defineProperty(this, 'length', {
575 enumerable: true,
576 get: function() {
577 return this._uints.length;
578 },
579 });
580}
581
582/**
583 * push the unsigned int onto the end of the array - if build() has already
584 * been called, the call will return without modifying anything.
585 */
586CanvasKit.OneUIntArrayHelper.prototype.push = function(u) {
587 if (this._ptr) {
588 SkDebug('Cannot push more points - already built');
589 return;
590 }
591 this._uints.push(u);
592}
593
594/**
595 * Set the uint at a given index - if build() has already
596 * been called, the WASM memory will be written to directly.
597 */
598CanvasKit.OneUIntArrayHelper.prototype.set = function(idx, u) {
599 if (idx < 0 || idx >= this._uints.length) {
600 SkDebug('Cannot set index ' + idx + ', it is out of range', this._uints.length);
601 return;
602 }
603 idx *= 4;
604 var BYTES_PER_ELEMENT = 4;
605 if (this._ptr) {
606 // convert this._ptr from uint8_t* to SkScalar* by dividing by 4
607 var uintPtr = (this._ptr / BYTES_PER_ELEMENT) + idx;
608 CanvasKit.HEAPU32[uintPtr] = u;
609 return;
610 }
611 this._uints[idx] = u;
612}
613
614/**
615 * Copies the uint data to the WASM memory and returns a pointer
616 * to that allocated memory. Once build has been called, this
617 * unit array cannot be made bigger.
618 */
619CanvasKit.OneUIntArrayHelper.prototype.build = function() {
620 if (this._ptr) {
621 return this._ptr;
622 }
Kevin Lubick69e46da2020-06-05 07:13:48 -0400623 this._ptr = copy1dArray(this._uints, "HEAPU32");
Kevin Lubickee91c072019-03-29 10:39:52 -0400624 return this._ptr;
625}
626
627/**
628 * Frees the wasm memory associated with this array. Of note,
629 * the points are not removed, so push/set/build can all
630 * be called to make a newly allocated (possibly bigger)
631 * uint array.
632 */
633CanvasKit.OneUIntArrayHelper.prototype.delete = function() {
634 if (this._ptr) {
635 CanvasKit._free(this._ptr);
636 this._ptr = null;
637 }
638}
639
640/**
641 * Helper for building an array of SkRects (which are just structs
642 * of 4 floats).
643 *
644 * It can be more performant to use this helper, as
645 * the C++-side array is only allocated once (on the first call)
646 * to build. Subsequent set() operations operate directly on
647 * the C++-side array, avoiding having to re-allocate (and free)
648 * the array every time.
649 *
650 * Input points are taken as left, top, right, bottom
651 */
652CanvasKit.SkRectBuilder = CanvasKit.FourFloatArrayHelper;
653/**
654 * Helper for building an array of RSXForms (which are just structs
655 * of 4 floats).
656 *
657 * It can be more performant to use this helper, as
658 * the C++-side array is only allocated once (on the first call)
659 * to build. Subsequent set() operations operate directly on
660 * the C++-side array, avoiding having to re-allocate (and free)
661 * the array every time.
662 *
663 * An RSXForm is a compressed form of a rotation+scale matrix.
664 *
665 * [ scos -ssin tx ]
666 * [ ssin scos ty ]
667 * [ 0 0 1 ]
668 *
669 * Input points are taken as scos, ssin, tx, ty
670 */
671CanvasKit.RSXFormBuilder = CanvasKit.FourFloatArrayHelper;
672
673/**
674 * Helper for building an array of SkColor
675 *
676 * It can be more performant to use this helper, as
677 * the C++-side array is only allocated once (on the first call)
678 * to build. Subsequent set() operations operate directly on
679 * the C++-side array, avoiding having to re-allocate (and free)
680 * the array every time.
681 */
682CanvasKit.SkColorBuilder = CanvasKit.OneUIntArrayHelper;
Kevin Lubicke25df6c2019-10-22 09:04:32 -0400683
684/**
685 * Malloc returns a TypedArray backed by the C++ memory of the
686 * given length. It should only be used by advanced users who
687 * can manage memory and initialize values properly. When used
688 * correctly, it can save copying of data between JS and C++.
689 * When used incorrectly, it can lead to memory leaks.
Kevin Lubickcf118922020-05-28 14:43:38 -0400690 * Any memory allocated by CanvasKit.Malloc needs to be released with CanvasKit.Free.
Kevin Lubicke25df6c2019-10-22 09:04:32 -0400691 *
Kevin Lubick462a8602020-06-01 15:43:03 -0400692 * const mObj = CanvasKit.Malloc(Float32Array, 20);
Kevin Lubick93f1a382020-06-02 16:15:23 -0400693 * Get a TypedArray view around the malloc'd memory (this does not copy anything).
Kevin Lubick462a8602020-06-01 15:43:03 -0400694 * const ta = mObj.toTypedArray();
Kevin Lubicke25df6c2019-10-22 09:04:32 -0400695 * // store data into ta
Kevin Lubick93f1a382020-06-02 16:15:23 -0400696 * const cf = CanvasKit.SkColorFilter.MakeMatrix(ta); // mObj could also be used.
Kevin Lubick462a8602020-06-01 15:43:03 -0400697 *
698 * // eventually...
699 * CanvasKit.Free(mObj);
Kevin Lubicke25df6c2019-10-22 09:04:32 -0400700 *
701 * @param {TypedArray} typedArray - constructor for the typedArray.
Kevin Lubick6aa38692020-06-01 11:25:47 -0400702 * @param {number} len - number of *elements* to store.
Kevin Lubicke25df6c2019-10-22 09:04:32 -0400703 */
704CanvasKit.Malloc = function(typedArray, len) {
705 var byteLen = len * typedArray.BYTES_PER_ELEMENT;
706 var ptr = CanvasKit._malloc(byteLen);
Kevin Lubick462a8602020-06-01 15:43:03 -0400707 return {
708 '_ck': true,
709 'length': len,
710 'byteOffset': ptr,
711 typedArray: null,
712 'toTypedArray': function() {
713 // Check if the previously allocated array is still usable.
714 // If it's falsey, then we haven't created an array yet.
715 // If it's empty, then WASM resized memory and emptied the array.
716 if (this.typedArray && this.typedArray.length) {
717 return this.typedArray;
718 }
719 this.typedArray = new typedArray(CanvasKit.HEAPU8.buffer, ptr, len);
720 // add a marker that this was allocated in C++ land
721 this.typedArray['_ck'] = true;
722 return this.typedArray;
723 },
724 };
Kevin Lubicke25df6c2019-10-22 09:04:32 -0400725}
Kevin Lubickcf118922020-05-28 14:43:38 -0400726
727/**
728 * Free frees the memory returned by Malloc.
729 * Any memory allocated by CanvasKit.Malloc needs to be released with CanvasKit.Free.
730 */
Kevin Lubick462a8602020-06-01 15:43:03 -0400731CanvasKit.Free = function(mallocObj) {
732 CanvasKit._free(mallocObj['byteOffset']);
733 mallocObj['byteOffset'] = nullptr;
734 // Set these to null to make sure the TypedArrays can be garbage collected.
735 mallocObj['toTypedArray'] = null;
736 mallocObj.typedArray = null;
Kevin Lubickcf118922020-05-28 14:43:38 -0400737}
738
739// This helper will free the given pointer unless the provided array is one
740// that was returned by CanvasKit.Malloc.
741function freeArraysThatAreNotMallocedByUsers(ptr, arr) {
Kevin Lubicke7b329e2020-06-05 15:58:01 -0400742 if (!arr['_ck']) {
Kevin Lubickcf118922020-05-28 14:43:38 -0400743 CanvasKit._free(ptr);
744 }
Kevin Lubick6aa38692020-06-01 11:25:47 -0400745}