blob: ad2615e474e643bc24998fdfe5904a4875519d99 [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 Lubicke7c1a732020-12-04 09:10:39 -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 Lubicke7c1a732020-12-04 09:10:39 -050034};
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);
Kevin Lubicke7c1a732020-12-04 09:10:39 -050042};
Nathaniel Nifonge5d32542020-03-26 09:27:48 -040043
44// Color constants use property getters to prevent other code from accidentally
45// changing them.
Kevin Lubickf8823b52020-09-03 10:02:10 -040046Object.defineProperty(CanvasKit, 'TRANSPARENT', {
Nathaniel Nifonge5d32542020-03-26 09:27:48 -040047 get: function() { return CanvasKit.Color4f(0, 0, 0, 0); }
48});
Kevin Lubickf8823b52020-09-03 10:02:10 -040049Object.defineProperty(CanvasKit, 'BLACK', {
Nathaniel Nifonge5d32542020-03-26 09:27:48 -040050 get: function() { return CanvasKit.Color4f(0, 0, 0, 1); }
51});
Kevin Lubickf8823b52020-09-03 10:02:10 -040052Object.defineProperty(CanvasKit, 'WHITE', {
Nathaniel Nifonge5d32542020-03-26 09:27:48 -040053 get: function() { return CanvasKit.Color4f(1, 1, 1, 1); }
54});
Kevin Lubickf8823b52020-09-03 10:02:10 -040055Object.defineProperty(CanvasKit, 'RED', {
Nathaniel Nifonge5d32542020-03-26 09:27:48 -040056 get: function() { return CanvasKit.Color4f(1, 0, 0, 1); }
57});
Kevin Lubickf8823b52020-09-03 10:02:10 -040058Object.defineProperty(CanvasKit, 'GREEN', {
Nathaniel Nifonge5d32542020-03-26 09:27:48 -040059 get: function() { return CanvasKit.Color4f(0, 1, 0, 1); }
60});
Kevin Lubickf8823b52020-09-03 10:02:10 -040061Object.defineProperty(CanvasKit, 'BLUE', {
Nathaniel Nifonge5d32542020-03-26 09:27:48 -040062 get: function() { return CanvasKit.Color4f(0, 0, 1, 1); }
63});
Kevin Lubickf8823b52020-09-03 10:02:10 -040064Object.defineProperty(CanvasKit, 'YELLOW', {
Nathaniel Nifonge5d32542020-03-26 09:27:48 -040065 get: function() { return CanvasKit.Color4f(1, 1, 0, 1); }
66});
Kevin Lubickf8823b52020-09-03 10:02:10 -040067Object.defineProperty(CanvasKit, 'CYAN', {
Nathaniel Nifonge5d32542020-03-26 09:27:48 -040068 get: function() { return CanvasKit.Color4f(0, 1, 1, 1); }
69});
Kevin Lubickf8823b52020-09-03 10:02:10 -040070Object.defineProperty(CanvasKit, 'MAGENTA', {
Nathaniel Nifonge5d32542020-03-26 09:27:48 -040071 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 Lubicke7c1a732020-12-04 09:10:39 -050084};
Kevin Lubickf5ea37f2019-02-28 10:06:18 -050085
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 }
Kevin Lubick54c1b3d2020-10-07 16:09:22 -0400141 Debug('unrecognized color ' + colorStr);
Kevin Lubick39284662020-02-20 10:29:55 -0500142 return CanvasKit.BLACK;
Kevin Lubicke7c1a732020-12-04 09:10:39 -0500143};
Kevin Lubick39284662020-02-20 10:29:55 -0500144
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}
Nathaniel Nifongd05fd0c2020-06-11 08:44:20 -0400156// Accepts various colors representations and converts them to an array of int colors.
157// Does not handle builders.
158function assureIntColors(arr) {
159 if (arr instanceof Float32Array) {
160 var count = Math.floor(arr.length / 4);
161 var result = new Uint32Array(count);
162 for (var i = 0; i < count; i ++) {
163 result[i] = toUint32Color(arr.slice(i*4, (i+1)*4));
164 }
165 return result;
166 } else if (arr instanceof Uint32Array) {
167 return arr;
168 } else if (arr instanceof Array && arr[0] instanceof Float32Array) {
169 return arr.map(toUint32Color);
170 }
Nathaniel Nifongd05fd0c2020-06-11 08:44:20 -0400171}
Kevin Lubickd9b9e5e2020-06-23 16:58:10 -0400172
Nathaniel Nifonge5d32542020-03-26 09:27:48 -0400173function uIntColorToCanvasKitColor(c) {
174 return CanvasKit.Color(
175 (c >> 16) & 0xFF,
176 (c >> 8) & 0xFF,
177 (c >> 0) & 0xFF,
178 ((c >> 24) & 0xFF) / 255
179 );
180}
181
Kevin Lubick39284662020-02-20 10:29:55 -0500182function valueOrPercent(aStr) {
183 if (aStr === undefined) {
184 return 1; // default to opaque.
185 }
186 var a = parseFloat(aStr);
187 if (aStr && aStr.indexOf('%') !== -1) {
188 return a / 100;
189 }
190 return a;
191}
192
Kevin Lubickf5ea37f2019-02-28 10:06:18 -0500193CanvasKit.multiplyByAlpha = function(color, alpha) {
Nathaniel Nifonge5d32542020-03-26 09:27:48 -0400194 // make a copy of the color so the function remains pure.
195 var result = color.slice();
196 result[3] = Math.max(0, Math.min(result[3] * alpha, 1));
197 return result;
Kevin Lubicke7c1a732020-12-04 09:10:39 -0500198};
Kevin Lubick61ef7b22018-11-27 13:26:59 -0500199
Kevin Lubickf5ea37f2019-02-28 10:06:18 -0500200function radiansToDegrees(rad) {
201 return (rad / Math.PI) * 180;
202}
Kevin Lubick12c0e502018-11-28 12:51:56 -0500203
Kevin Lubickf5ea37f2019-02-28 10:06:18 -0500204function degreesToRadians(deg) {
205 return (deg / 180) * Math.PI;
206}
Kevin Lubick12c0e502018-11-28 12:51:56 -0500207
208// See https://stackoverflow.com/a/31090240
209// This contraption keeps closure from minifying away the check
Kevin Lubickf8823b52020-09-03 10:02:10 -0400210// if btoa is defined *and* prevents runtime 'btoa' or 'window' is not defined.
Kevin Lubick12c0e502018-11-28 12:51:56 -0500211// Defined outside any scopes to make it available in all files.
Kevin Lubickf8823b52020-09-03 10:02:10 -0400212var isNode = !(new Function('try {return this===window;}catch(e){ return false;}')());
Kevin Lubick1646e7d2018-12-07 13:03:08 -0500213
214function almostEqual(floata, floatb) {
215 return Math.abs(floata - floatb) < 0.00001;
Kevin Lubickf5ea37f2019-02-28 10:06:18 -0500216}
217
Kevin Lubickf5ea37f2019-02-28 10:06:18 -0500218var nullptr = 0; // emscripten doesn't like to take null as uintptr_t
219
220// arr can be a normal JS array or a TypedArray
Kevin Lubickf8823b52020-09-03 10:02:10 -0400221// dest is a string like 'HEAPU32' that specifies the type the src array
Kevin Lubick9c401e72020-06-09 14:22:20 -0400222// should be copied into.
Kevin Lubickd6ba7252019-06-03 14:38:05 -0400223// ptr can be optionally provided if the memory was already allocated.
224function copy1dArray(arr, dest, ptr) {
Kevin Lubickf5ea37f2019-02-28 10:06:18 -0500225 if (!arr || !arr.length) {
226 return nullptr;
227 }
Kevin Lubicke25df6c2019-10-22 09:04:32 -0400228 // This was created with CanvasKit.Malloc, so it's already been copied.
229 if (arr['_ck']) {
230 return arr.byteOffset;
231 }
Kevin Lubick69e46da2020-06-05 07:13:48 -0400232 var bytesPerElement = CanvasKit[dest].BYTES_PER_ELEMENT;
Kevin Lubickd6ba7252019-06-03 14:38:05 -0400233 if (!ptr) {
Kevin Lubick69e46da2020-06-05 07:13:48 -0400234 ptr = CanvasKit._malloc(arr.length * bytesPerElement);
Kevin Lubickd6ba7252019-06-03 14:38:05 -0400235 }
Kevin Lubickf5ea37f2019-02-28 10:06:18 -0500236 // In c++ terms, the WASM heap is a uint8_t*, a long buffer/array of single
237 // byte elements. When we run _malloc, we always get an offset/pointer into
238 // that block of memory.
239 // CanvasKit exposes some different views to make it easier to work with
240 // different types. HEAPF32 for example, exposes it as a float*
241 // However, to make the ptr line up, we have to do some pointer arithmetic.
242 // Concretely, we need to convert ptr to go from an index into a 1-byte-wide
243 // buffer to an index into a 4-byte-wide buffer (in the case of HEAPF32)
244 // and thus we divide ptr by 4.
Kevin Lubick69e46da2020-06-05 07:13:48 -0400245 // It is important to make sure we are grabbing the freshest view of the
246 // memory possible because if we call _malloc and the heap needs to grow,
247 // the TypedArrayView will no longer be valid.
248 CanvasKit[dest].set(arr, ptr / bytesPerElement);
Kevin Lubickf5ea37f2019-02-28 10:06:18 -0500249 return ptr;
250}
251
Nathaniel Nifongd05fd0c2020-06-11 08:44:20 -0400252// Copies an array of colors to wasm, returning an object with the pointer
253// and info necessary to use the copied colors.
254// Accepts either a flat Float32Array, flat Uint32Array or Array of Float32Arrays.
Kevin Lubick421ba882020-10-15 13:07:33 -0400255// If color is an object that was allocated with CanvasKit.Malloc, its pointer is
Nathaniel Nifongd05fd0c2020-06-11 08:44:20 -0400256// returned and no extra copy is performed.
Nathaniel Nifongd05fd0c2020-06-11 08:44:20 -0400257// TODO(nifong): have this accept color builders.
258function copyFlexibleColorArray(colors) {
259 var result = {
260 colorPtr: nullptr,
261 count: colors.length,
262 colorType: CanvasKit.ColorType.RGBA_F32,
Kevin Lubicke7c1a732020-12-04 09:10:39 -0500263 };
Nathaniel Nifongd05fd0c2020-06-11 08:44:20 -0400264 if (colors instanceof Float32Array) {
Kevin Lubickf8823b52020-09-03 10:02:10 -0400265 result.colorPtr = copy1dArray(colors, 'HEAPF32');
Nathaniel Nifongd05fd0c2020-06-11 08:44:20 -0400266 result.count = colors.length / 4;
267
268 } else if (colors instanceof Uint32Array) {
Kevin Lubickf8823b52020-09-03 10:02:10 -0400269 result.colorPtr = copy1dArray(colors, 'HEAPU32');
Nathaniel Nifongd05fd0c2020-06-11 08:44:20 -0400270 result.colorType = CanvasKit.ColorType.RGBA_8888;
271
Kevin Lubicke7c1a732020-12-04 09:10:39 -0500272 } else if (colors instanceof Array) {
273 result.colorPtr = copyColorArray(colors);
Nathaniel Nifongd05fd0c2020-06-11 08:44:20 -0400274 } else {
275 throw('Invalid argument to copyFlexibleColorArray, Not a color array '+typeof(colors));
276 }
277 return result;
278}
279
Kevin Lubicke7c1a732020-12-04 09:10:39 -0500280function copyColorArray(arr) {
281 if (!arr || !arr.length) {
282 return nullptr;
283 }
284 // 4 floats per color, 4 bytes per float.
285 var ptr = CanvasKit._malloc(arr.length * 4 * 4);
286
287 var idx = 0;
288 var adjustedPtr = ptr / 4; // cast the byte pointer into a float pointer.
289 for (var r = 0; r < arr.length; r++) {
290 for (var c = 0; c < 4; c++) {
291 CanvasKit.HEAPF32[adjustedPtr + idx] = arr[r][c];
292 idx++;
293 }
294 }
295 return ptr;
296}
297
Kevin Lubick6bffe392020-04-02 15:24:15 -0400298var defaultPerspective = Float32Array.of(0, 0, 1);
299
Kevin Lubick6aa38692020-06-01 11:25:47 -0400300var _scratch3x3MatrixPtr = nullptr;
Kevin Lubick462a8602020-06-01 15:43:03 -0400301var _scratch3x3Matrix; // the result from CanvasKit.Malloc
Kevin Lubick6aa38692020-06-01 11:25:47 -0400302
Kevin Lubick6bffe392020-04-02 15:24:15 -0400303// Copies the given DOMMatrix/Array/TypedArray to the CanvasKit heap and
304// returns a pointer to the memory. This memory is a float* of length 9.
305// If the passed in matrix is null/undefined, we return 0 (nullptr). All calls
306// on the C++ side should check for nullptr where appropriate. It is generally
307// the responsibility of the JS side code to call CanvasKit._free on the
308// allocated memory before returning to the user code.
309function copy3x3MatrixToWasm(matr) {
310 if (!matr) {
311 return nullptr;
312 }
Kevin Lubick6aa38692020-06-01 11:25:47 -0400313
Kevin Lubick6bffe392020-04-02 15:24:15 -0400314 if (matr.length) {
315 // TODO(kjlubick): Downsample a 16 length (4x4 matrix)
316 if (matr.length !== 6 && matr.length !== 9) {
317 throw 'invalid matrix size';
318 }
Kevin Lubickf8823b52020-09-03 10:02:10 -0400319 // matr should be an array or typed array.
320 var mPtr = copy1dArray(matr, 'HEAPF32', _scratch3x3MatrixPtr);
Kevin Lubick6bffe392020-04-02 15:24:15 -0400321 if (matr.length === 6) {
Kevin Lubick6aa38692020-06-01 11:25:47 -0400322 // Overwrite the last 3 floats with the default perspective. The divide
323 // by 4 casts the pointer into a float pointer.
324 CanvasKit.HEAPF32.set(defaultPerspective, 6 + mPtr / 4);
Kevin Lubick6bffe392020-04-02 15:24:15 -0400325 }
Kevin Lubick6aa38692020-06-01 11:25:47 -0400326 return mPtr;
Kevin Lubick6bffe392020-04-02 15:24:15 -0400327 }
Kevin Lubick462a8602020-06-01 15:43:03 -0400328 var wasm3x3Matrix = _scratch3x3Matrix['toTypedArray']();
Kevin Lubick6aa38692020-06-01 11:25:47 -0400329 // Try as if it's a DOMMatrix. Reminder that DOMMatrix is column-major.
Kevin Lubick462a8602020-06-01 15:43:03 -0400330 wasm3x3Matrix[0] = matr.m11;
331 wasm3x3Matrix[1] = matr.m21;
332 wasm3x3Matrix[2] = matr.m41;
Kevin Lubick6aa38692020-06-01 11:25:47 -0400333
Kevin Lubick462a8602020-06-01 15:43:03 -0400334 wasm3x3Matrix[3] = matr.m12;
335 wasm3x3Matrix[4] = matr.m22;
336 wasm3x3Matrix[5] = matr.m42;
Kevin Lubick6aa38692020-06-01 11:25:47 -0400337
Kevin Lubick462a8602020-06-01 15:43:03 -0400338 wasm3x3Matrix[6] = matr.m14;
339 wasm3x3Matrix[7] = matr.m24;
340 wasm3x3Matrix[8] = matr.m44;
Kevin Lubick6aa38692020-06-01 11:25:47 -0400341 return _scratch3x3MatrixPtr;
Kevin Lubick6bffe392020-04-02 15:24:15 -0400342}
343
Kevin Lubick6aa38692020-06-01 11:25:47 -0400344var _scratch4x4MatrixPtr = nullptr;
Kevin Lubick462a8602020-06-01 15:43:03 -0400345var _scratch4x4Matrix; // the result from CanvasKit.Malloc
Kevin Lubick6aa38692020-06-01 11:25:47 -0400346
Kevin Lubickc1d08982020-04-06 13:52:15 -0400347function copy4x4MatrixToWasm(matr) {
348 if (!matr) {
349 return nullptr;
350 }
Kevin Lubick462a8602020-06-01 15:43:03 -0400351 var wasm4x4Matrix = _scratch4x4Matrix['toTypedArray']();
Kevin Lubickc1d08982020-04-06 13:52:15 -0400352 if (matr.length) {
353 if (matr.length !== 16 && matr.length !== 6 && matr.length !== 9) {
354 throw 'invalid matrix size';
355 }
356 if (matr.length === 16) {
Kevin Lubickf8823b52020-09-03 10:02:10 -0400357 // matr should be an array or typed array.
358 return copy1dArray(matr, 'HEAPF32', _scratch4x4MatrixPtr);
Kevin Lubickc1d08982020-04-06 13:52:15 -0400359 }
Kevin Lubick6aa38692020-06-01 11:25:47 -0400360 // Upscale the row-major 3x3 or 3x2 matrix into a 4x4 row-major matrix
361 // TODO(skbug.com/10108) This will need to change when we convert our
362 // JS 4x4 to be column-major.
363 // When upscaling, we need to overwrite the 3rd column and the 3rd row with
364 // 0s. It's easiest to just do that with a fill command.
Kevin Lubick462a8602020-06-01 15:43:03 -0400365 wasm4x4Matrix.fill(0);
366 wasm4x4Matrix[0] = matr[0];
367 wasm4x4Matrix[1] = matr[1];
Kevin Lubick6aa38692020-06-01 11:25:47 -0400368 // skip col 2
Kevin Lubick462a8602020-06-01 15:43:03 -0400369 wasm4x4Matrix[3] = matr[2];
Kevin Lubick6aa38692020-06-01 11:25:47 -0400370
Kevin Lubick462a8602020-06-01 15:43:03 -0400371 wasm4x4Matrix[4] = matr[3];
372 wasm4x4Matrix[5] = matr[4];
Kevin Lubick6aa38692020-06-01 11:25:47 -0400373 // skip col 2
Kevin Lubick462a8602020-06-01 15:43:03 -0400374 wasm4x4Matrix[7] = matr[5];
Kevin Lubick6aa38692020-06-01 11:25:47 -0400375
376 // skip row 2
377
Kevin Lubick462a8602020-06-01 15:43:03 -0400378 wasm4x4Matrix[12] = matr[6];
379 wasm4x4Matrix[13] = matr[7];
Kevin Lubick6aa38692020-06-01 11:25:47 -0400380 // skip col 2
Kevin Lubick462a8602020-06-01 15:43:03 -0400381 wasm4x4Matrix[15] = matr[8];
Kevin Lubick6aa38692020-06-01 11:25:47 -0400382
383 if (matr.length === 6) {
384 // fix perspective for the 3x2 case (from above, they will be undefined).
Kevin Lubick462a8602020-06-01 15:43:03 -0400385 wasm4x4Matrix[12]=0;
386 wasm4x4Matrix[13]=0;
387 wasm4x4Matrix[15]=1;
Kevin Lubick6aa38692020-06-01 11:25:47 -0400388 }
389 return _scratch4x4MatrixPtr;
Kevin Lubickc1d08982020-04-06 13:52:15 -0400390 }
Kevin Lubick6aa38692020-06-01 11:25:47 -0400391 // Try as if it's a DOMMatrix. Reminder that DOMMatrix is column-major.
Kevin Lubick462a8602020-06-01 15:43:03 -0400392 wasm4x4Matrix[0] = matr.m11;
393 wasm4x4Matrix[1] = matr.m21;
394 wasm4x4Matrix[2] = matr.m31;
395 wasm4x4Matrix[3] = matr.m41;
Kevin Lubick6aa38692020-06-01 11:25:47 -0400396
Kevin Lubick462a8602020-06-01 15:43:03 -0400397 wasm4x4Matrix[4] = matr.m12;
398 wasm4x4Matrix[5] = matr.m22;
399 wasm4x4Matrix[6] = matr.m32;
400 wasm4x4Matrix[7] = matr.m42;
Kevin Lubick6aa38692020-06-01 11:25:47 -0400401
Kevin Lubick462a8602020-06-01 15:43:03 -0400402 wasm4x4Matrix[8] = matr.m13;
403 wasm4x4Matrix[9] = matr.m23;
404 wasm4x4Matrix[10] = matr.m33;
405 wasm4x4Matrix[11] = matr.m43;
Kevin Lubick6aa38692020-06-01 11:25:47 -0400406
Kevin Lubick462a8602020-06-01 15:43:03 -0400407 wasm4x4Matrix[12] = matr.m14;
408 wasm4x4Matrix[13] = matr.m24;
409 wasm4x4Matrix[14] = matr.m34;
410 wasm4x4Matrix[15] = matr.m44;
Kevin Lubick6aa38692020-06-01 11:25:47 -0400411 return _scratch4x4MatrixPtr;
Kevin Lubickc1d08982020-04-06 13:52:15 -0400412}
413
Kevin Lubick6aa38692020-06-01 11:25:47 -0400414// copies a 4x4 matrix at the given pointer into a JS array. It is the caller's
415// responsibility to free the matrPtr if needed.
Kevin Lubickc1d08982020-04-06 13:52:15 -0400416function copy4x4MatrixFromWasm(matrPtr) {
Kevin Lubick54c1b3d2020-10-07 16:09:22 -0400417 // read them out into an array. TODO(kjlubick): If we change Matrix to be
Kevin Lubickc1d08982020-04-06 13:52:15 -0400418 // typedArrays, then we should return a typed array here too.
419 var rv = new Array(16);
420 for (var i = 0; i < 16; i++) {
Kevin Lubickf8823b52020-09-03 10:02:10 -0400421 rv[i] = CanvasKit.HEAPF32[matrPtr/4 + i]; // divide by 4 to cast to float.
Kevin Lubickc1d08982020-04-06 13:52:15 -0400422 }
Kevin Lubickc1d08982020-04-06 13:52:15 -0400423 return rv;
424}
425
Kevin Lubick6aa38692020-06-01 11:25:47 -0400426var _scratchColorPtr = nullptr;
Kevin Lubick93f1a382020-06-02 16:15:23 -0400427var _scratchColor; // the result from CanvasKit.Malloc
Kevin Lubick6aa38692020-06-01 11:25:47 -0400428
429function copyColorToWasm(color4f, ptr) {
Kevin Lubickf8823b52020-09-03 10:02:10 -0400430 return copy1dArray(color4f, 'HEAPF32', ptr || _scratchColorPtr);
Kevin Lubick6aa38692020-06-01 11:25:47 -0400431}
432
Kevin Lubick93f1a382020-06-02 16:15:23 -0400433function copyColorComponentsToWasm(r, g, b, a) {
434 var colors = _scratchColor['toTypedArray']();
435 colors[0] = r;
436 colors[1] = g;
437 colors[2] = b;
438 colors[3] = a;
439 return _scratchColorPtr;
440}
441
Kevin Lubick6aa38692020-06-01 11:25:47 -0400442function copyColorToWasmNoScratch(color4f) {
443 // TODO(kjlubick): accept 4 floats or int color
Kevin Lubickf8823b52020-09-03 10:02:10 -0400444 return copy1dArray(color4f, 'HEAPF32');
Kevin Lubick6aa38692020-06-01 11:25:47 -0400445}
446
Nathaniel Nifong1bedbeb2020-05-04 16:46:17 -0400447// copies the four floats at the given pointer in a js Float32Array
448function copyColorFromWasm(colorPtr) {
449 var rv = new Float32Array(4);
450 for (var i = 0; i < 4; i++) {
Kevin Lubickf8823b52020-09-03 10:02:10 -0400451 rv[i] = CanvasKit.HEAPF32[colorPtr/4 + i]; // divide by 4 to cast to float.
Nathaniel Nifong1bedbeb2020-05-04 16:46:17 -0400452 }
Nathaniel Nifong1bedbeb2020-05-04 16:46:17 -0400453 return rv;
Kevin Lubickcf118922020-05-28 14:43:38 -0400454}
Nathaniel Nifong1bedbeb2020-05-04 16:46:17 -0400455
Kevin Lubickbe728012020-09-03 11:57:12 +0000456// These will be initialized after loading.
Kevin Lubickf8823b52020-09-03 10:02:10 -0400457var _scratchRect;
458var _scratchRectPtr = nullptr;
459
460var _scratchRect2;
461var _scratchRect2Ptr = nullptr;
462
463function copyRectToWasm(fourFloats, ptr) {
464 return copy1dArray(fourFloats, 'HEAPF32', ptr || _scratchRectPtr);
465}
466
467var _scratchIRect;
468var _scratchIRectPtr = nullptr;
469function copyIRectToWasm(fourInts, ptr) {
470 return copy1dArray(fourInts, 'HEAP32', ptr || _scratchIRectPtr);
471}
472
473// These will be initialized after loading.
Kevin Lubickbe728012020-09-03 11:57:12 +0000474var _scratchRRect;
475var _scratchRRectPtr = nullptr;
476
477var _scratchRRect2;
478var _scratchRRect2Ptr = nullptr;
479
480
481function copyRRectToWasm(twelveFloats, ptr) {
Kevin Lubickf8823b52020-09-03 10:02:10 -0400482 return copy1dArray(twelveFloats, 'HEAPF32', ptr || _scratchRRectPtr);
Kevin Lubickbe728012020-09-03 11:57:12 +0000483}
484
Kevin Lubickf5ea37f2019-02-28 10:06:18 -0500485// Caching the Float32Arrays can save having to reallocate them
486// over and over again.
487var Float32ArrayCache = {};
488
489// Takes a 2D array of commands and puts them into the WASM heap
490// as a 1D array. This allows them to referenced from the C++ code.
491// Returns a 2 element array, with the first item being essentially a
492// pointer to the array and the second item being the length of
493// the new 1D array.
494//
495// Example usage:
496// let cmds = [
497// [CanvasKit.MOVE_VERB, 0, 10],
498// [CanvasKit.LINE_VERB, 30, 40],
499// [CanvasKit.QUAD_VERB, 20, 50, 45, 60],
500// ];
Kevin Lubickd9b9e5e2020-06-23 16:58:10 -0400501// TODO(kjlubick) remove this and Float32ArrayCache (superceded by Malloc).
Kevin Lubickf5ea37f2019-02-28 10:06:18 -0500502function loadCmdsTypedArray(arr) {
503 var len = 0;
504 for (var r = 0; r < arr.length; r++) {
505 len += arr[r].length;
506 }
507
508 var ta;
509 if (Float32ArrayCache[len]) {
510 ta = Float32ArrayCache[len];
511 } else {
512 ta = new Float32Array(len);
513 Float32ArrayCache[len] = ta;
514 }
515 // Flatten into a 1d array
516 var i = 0;
517 for (var r = 0; r < arr.length; r++) {
518 for (var c = 0; c < arr[r].length; c++) {
519 var item = arr[r][c];
520 ta[i] = item;
521 i++;
522 }
523 }
524
Kevin Lubickf8823b52020-09-03 10:02:10 -0400525 var ptr = copy1dArray(ta, 'HEAPF32');
Kevin Lubickf5ea37f2019-02-28 10:06:18 -0500526 return [ptr, len];
527}
Kevin Lubickd3cfbca2019-03-15 15:36:29 -0400528
Kevin Lubickcc13fd32019-04-05 13:00:01 -0400529function saveBytesToFile(bytes, fileName) {
530 if (!isNode) {
531 // https://stackoverflow.com/a/32094834
532 var blob = new Blob([bytes], {type: 'application/octet-stream'});
533 url = window.URL.createObjectURL(blob);
534 var a = document.createElement('a');
535 document.body.appendChild(a);
536 a.href = url;
537 a.download = fileName;
538 a.click();
539 // clean up after because FF might not download it synchronously
540 setTimeout(function() {
541 URL.revokeObjectURL(url);
542 a.remove();
543 }, 50);
544 } else {
545 var fs = require('fs');
546 // https://stackoverflow.com/a/42006750
547 // https://stackoverflow.com/a/47018122
548 fs.writeFile(fileName, new Buffer(bytes), function(err) {
549 if (err) throw err;
550 });
551 }
552}
Kevin Lubick97440de2020-09-29 17:58:21 -0400553
554// TODO(kjlubick) remove Builders - no longer needed now that Malloc is a thing.
Kevin Lubickee91c072019-03-29 10:39:52 -0400555/**
556 * Generic helper for dealing with an array of four floats.
557 */
558CanvasKit.FourFloatArrayHelper = function() {
559 this._floats = [];
Kevin Lubickd3cfbca2019-03-15 15:36:29 -0400560 this._ptr = null;
Kevin Lubickee91c072019-03-29 10:39:52 -0400561
562 Object.defineProperty(this, 'length', {
563 enumerable: true,
564 get: function() {
565 return this._floats.length / 4;
566 },
567 });
Kevin Lubicke7c1a732020-12-04 09:10:39 -0500568};
Kevin Lubickd3cfbca2019-03-15 15:36:29 -0400569
570/**
Kevin Lubickee91c072019-03-29 10:39:52 -0400571 * push the four floats onto the end of the array - if build() has already
572 * been called, the call will return without modifying anything.
Kevin Lubickd3cfbca2019-03-15 15:36:29 -0400573 */
Kevin Lubickee91c072019-03-29 10:39:52 -0400574CanvasKit.FourFloatArrayHelper.prototype.push = function(f1, f2, f3, f4) {
Kevin Lubickd3cfbca2019-03-15 15:36:29 -0400575 if (this._ptr) {
Kevin Lubick54c1b3d2020-10-07 16:09:22 -0400576 Debug('Cannot push more points - already built');
Kevin Lubickd3cfbca2019-03-15 15:36:29 -0400577 return;
578 }
Kevin Lubickee91c072019-03-29 10:39:52 -0400579 this._floats.push(f1, f2, f3, f4);
Kevin Lubicke7c1a732020-12-04 09:10:39 -0500580};
Kevin Lubickd3cfbca2019-03-15 15:36:29 -0400581
Kevin Lubickee91c072019-03-29 10:39:52 -0400582/**
583 * Set the four floats at a given index - if build() has already
584 * been called, the WASM memory will be written to directly.
585 */
586CanvasKit.FourFloatArrayHelper.prototype.set = function(idx, f1, f2, f3, f4) {
587 if (idx < 0 || idx >= this._floats.length/4) {
Kevin Lubick54c1b3d2020-10-07 16:09:22 -0400588 Debug('Cannot set index ' + idx + ', it is out of range', this._floats.length/4);
Kevin Lubickee91c072019-03-29 10:39:52 -0400589 return;
590 }
591 idx *= 4;
592 var BYTES_PER_ELEMENT = 4;
593 if (this._ptr) {
594 // convert this._ptr from uint8_t* to SkScalar* by dividing by 4
595 var floatPtr = (this._ptr / BYTES_PER_ELEMENT) + idx;
596 CanvasKit.HEAPF32[floatPtr] = f1;
597 CanvasKit.HEAPF32[floatPtr + 1] = f2;
598 CanvasKit.HEAPF32[floatPtr + 2] = f3;
599 CanvasKit.HEAPF32[floatPtr + 3] = f4;
600 return;
601 }
602 this._floats[idx] = f1;
603 this._floats[idx + 1] = f2;
604 this._floats[idx + 2] = f3;
605 this._floats[idx + 3] = f4;
Kevin Lubicke7c1a732020-12-04 09:10:39 -0500606};
Kevin Lubickee91c072019-03-29 10:39:52 -0400607
608/**
609 * Copies the float data to the WASM memory and returns a pointer
610 * to that allocated memory. Once build has been called, this
611 * float array cannot be made bigger.
612 */
613CanvasKit.FourFloatArrayHelper.prototype.build = function() {
Kevin Lubickd3cfbca2019-03-15 15:36:29 -0400614 if (this._ptr) {
615 return this._ptr;
616 }
Kevin Lubickf8823b52020-09-03 10:02:10 -0400617 this._ptr = copy1dArray(this._floats, 'HEAPF32');
Kevin Lubickd3cfbca2019-03-15 15:36:29 -0400618 return this._ptr;
Kevin Lubicke7c1a732020-12-04 09:10:39 -0500619};
Kevin Lubickd3cfbca2019-03-15 15:36:29 -0400620
Kevin Lubickee91c072019-03-29 10:39:52 -0400621/**
622 * Frees the wasm memory associated with this array. Of note,
623 * the points are not removed, so push/set/build can all
624 * be called to make a newly allocated (possibly bigger)
625 * float array.
626 */
627CanvasKit.FourFloatArrayHelper.prototype.delete = function() {
Kevin Lubickd3cfbca2019-03-15 15:36:29 -0400628 if (this._ptr) {
629 CanvasKit._free(this._ptr);
630 this._ptr = null;
631 }
Kevin Lubicke7c1a732020-12-04 09:10:39 -0500632};
Kevin Lubickee91c072019-03-29 10:39:52 -0400633
634/**
635 * Generic helper for dealing with an array of unsigned ints.
636 */
637CanvasKit.OneUIntArrayHelper = function() {
638 this._uints = [];
639 this._ptr = null;
640
641 Object.defineProperty(this, 'length', {
642 enumerable: true,
643 get: function() {
644 return this._uints.length;
645 },
646 });
Kevin Lubicke7c1a732020-12-04 09:10:39 -0500647};
Kevin Lubickee91c072019-03-29 10:39:52 -0400648
649/**
650 * push the unsigned int onto the end of the array - if build() has already
651 * been called, the call will return without modifying anything.
652 */
653CanvasKit.OneUIntArrayHelper.prototype.push = function(u) {
654 if (this._ptr) {
Kevin Lubick54c1b3d2020-10-07 16:09:22 -0400655 Debug('Cannot push more points - already built');
Kevin Lubickee91c072019-03-29 10:39:52 -0400656 return;
657 }
658 this._uints.push(u);
Kevin Lubicke7c1a732020-12-04 09:10:39 -0500659};
Kevin Lubickee91c072019-03-29 10:39:52 -0400660
661/**
662 * Set the uint at a given index - if build() has already
663 * been called, the WASM memory will be written to directly.
664 */
665CanvasKit.OneUIntArrayHelper.prototype.set = function(idx, u) {
666 if (idx < 0 || idx >= this._uints.length) {
Kevin Lubick54c1b3d2020-10-07 16:09:22 -0400667 Debug('Cannot set index ' + idx + ', it is out of range', this._uints.length);
Kevin Lubickee91c072019-03-29 10:39:52 -0400668 return;
669 }
670 idx *= 4;
671 var BYTES_PER_ELEMENT = 4;
672 if (this._ptr) {
673 // convert this._ptr from uint8_t* to SkScalar* by dividing by 4
674 var uintPtr = (this._ptr / BYTES_PER_ELEMENT) + idx;
675 CanvasKit.HEAPU32[uintPtr] = u;
676 return;
677 }
678 this._uints[idx] = u;
Kevin Lubicke7c1a732020-12-04 09:10:39 -0500679};
Kevin Lubickee91c072019-03-29 10:39:52 -0400680
681/**
682 * Copies the uint data to the WASM memory and returns a pointer
683 * to that allocated memory. Once build has been called, this
684 * unit array cannot be made bigger.
685 */
686CanvasKit.OneUIntArrayHelper.prototype.build = function() {
687 if (this._ptr) {
688 return this._ptr;
689 }
Kevin Lubickf8823b52020-09-03 10:02:10 -0400690 this._ptr = copy1dArray(this._uints, 'HEAPU32');
Kevin Lubickee91c072019-03-29 10:39:52 -0400691 return this._ptr;
Kevin Lubicke7c1a732020-12-04 09:10:39 -0500692};
Kevin Lubickee91c072019-03-29 10:39:52 -0400693
694/**
695 * Frees the wasm memory associated with this array. Of note,
696 * the points are not removed, so push/set/build can all
697 * be called to make a newly allocated (possibly bigger)
698 * uint array.
699 */
700CanvasKit.OneUIntArrayHelper.prototype.delete = function() {
701 if (this._ptr) {
702 CanvasKit._free(this._ptr);
703 this._ptr = null;
704 }
Kevin Lubicke7c1a732020-12-04 09:10:39 -0500705};
Kevin Lubickee91c072019-03-29 10:39:52 -0400706
707/**
Kevin Lubick54c1b3d2020-10-07 16:09:22 -0400708 * Helper for building an array of Rects (which are just structs
Kevin Lubickee91c072019-03-29 10:39:52 -0400709 * of 4 floats).
710 *
711 * It can be more performant to use this helper, as
712 * the C++-side array is only allocated once (on the first call)
713 * to build. Subsequent set() operations operate directly on
714 * the C++-side array, avoiding having to re-allocate (and free)
715 * the array every time.
716 *
717 * Input points are taken as left, top, right, bottom
718 */
Kevin Lubick54c1b3d2020-10-07 16:09:22 -0400719CanvasKit.RectBuilder = CanvasKit.FourFloatArrayHelper;
Kevin Lubickee91c072019-03-29 10:39:52 -0400720/**
721 * Helper for building an array of RSXForms (which are just structs
722 * of 4 floats).
723 *
724 * It can be more performant to use this helper, as
725 * the C++-side array is only allocated once (on the first call)
726 * to build. Subsequent set() operations operate directly on
727 * the C++-side array, avoiding having to re-allocate (and free)
728 * the array every time.
729 *
730 * An RSXForm is a compressed form of a rotation+scale matrix.
731 *
732 * [ scos -ssin tx ]
733 * [ ssin scos ty ]
734 * [ 0 0 1 ]
735 *
736 * Input points are taken as scos, ssin, tx, ty
737 */
738CanvasKit.RSXFormBuilder = CanvasKit.FourFloatArrayHelper;
739
740/**
Kevin Lubick54c1b3d2020-10-07 16:09:22 -0400741 * Helper for building an array of Color
Kevin Lubickee91c072019-03-29 10:39:52 -0400742 *
743 * It can be more performant to use this helper, as
744 * the C++-side array is only allocated once (on the first call)
745 * to build. Subsequent set() operations operate directly on
746 * the C++-side array, avoiding having to re-allocate (and free)
747 * the array every time.
748 */
Kevin Lubick54c1b3d2020-10-07 16:09:22 -0400749CanvasKit.ColorBuilder = CanvasKit.OneUIntArrayHelper;
Kevin Lubicke25df6c2019-10-22 09:04:32 -0400750
751/**
752 * Malloc returns a TypedArray backed by the C++ memory of the
753 * given length. It should only be used by advanced users who
754 * can manage memory and initialize values properly. When used
755 * correctly, it can save copying of data between JS and C++.
756 * When used incorrectly, it can lead to memory leaks.
Kevin Lubickcf118922020-05-28 14:43:38 -0400757 * Any memory allocated by CanvasKit.Malloc needs to be released with CanvasKit.Free.
Kevin Lubicke25df6c2019-10-22 09:04:32 -0400758 *
Kevin Lubick462a8602020-06-01 15:43:03 -0400759 * const mObj = CanvasKit.Malloc(Float32Array, 20);
Kevin Lubick93f1a382020-06-02 16:15:23 -0400760 * Get a TypedArray view around the malloc'd memory (this does not copy anything).
Kevin Lubick462a8602020-06-01 15:43:03 -0400761 * const ta = mObj.toTypedArray();
Kevin Lubicke25df6c2019-10-22 09:04:32 -0400762 * // store data into ta
Kevin Lubick54c1b3d2020-10-07 16:09:22 -0400763 * const cf = CanvasKit.ColorFilter.MakeMatrix(ta); // mObj could also be used.
Kevin Lubick462a8602020-06-01 15:43:03 -0400764 *
765 * // eventually...
766 * CanvasKit.Free(mObj);
Kevin Lubicke25df6c2019-10-22 09:04:32 -0400767 *
768 * @param {TypedArray} typedArray - constructor for the typedArray.
Kevin Lubick6aa38692020-06-01 11:25:47 -0400769 * @param {number} len - number of *elements* to store.
Kevin Lubicke25df6c2019-10-22 09:04:32 -0400770 */
771CanvasKit.Malloc = function(typedArray, len) {
772 var byteLen = len * typedArray.BYTES_PER_ELEMENT;
773 var ptr = CanvasKit._malloc(byteLen);
Kevin Lubick462a8602020-06-01 15:43:03 -0400774 return {
775 '_ck': true,
776 'length': len,
777 'byteOffset': ptr,
778 typedArray: null,
Kevin Lubickd9b9e5e2020-06-23 16:58:10 -0400779 'subarray': function(start, end) {
780 var sa = this['toTypedArray']().subarray(start, end);
781 sa['_ck'] = true;
782 return sa;
783 },
Kevin Lubick462a8602020-06-01 15:43:03 -0400784 'toTypedArray': function() {
785 // Check if the previously allocated array is still usable.
786 // If it's falsey, then we haven't created an array yet.
787 // If it's empty, then WASM resized memory and emptied the array.
788 if (this.typedArray && this.typedArray.length) {
789 return this.typedArray;
790 }
791 this.typedArray = new typedArray(CanvasKit.HEAPU8.buffer, ptr, len);
792 // add a marker that this was allocated in C++ land
793 this.typedArray['_ck'] = true;
794 return this.typedArray;
795 },
796 };
Kevin Lubick26133322020-06-11 13:48:16 -0400797};
Kevin Lubickcf118922020-05-28 14:43:38 -0400798
799/**
800 * Free frees the memory returned by Malloc.
801 * Any memory allocated by CanvasKit.Malloc needs to be released with CanvasKit.Free.
802 */
Kevin Lubick462a8602020-06-01 15:43:03 -0400803CanvasKit.Free = function(mallocObj) {
804 CanvasKit._free(mallocObj['byteOffset']);
805 mallocObj['byteOffset'] = nullptr;
806 // Set these to null to make sure the TypedArrays can be garbage collected.
807 mallocObj['toTypedArray'] = null;
808 mallocObj.typedArray = null;
Kevin Lubick26133322020-06-11 13:48:16 -0400809};
Kevin Lubickcf118922020-05-28 14:43:38 -0400810
811// This helper will free the given pointer unless the provided array is one
812// that was returned by CanvasKit.Malloc.
813function freeArraysThatAreNotMallocedByUsers(ptr, arr) {
Kevin Lubickd9b9e5e2020-06-23 16:58:10 -0400814 if (arr && !arr['_ck']) {
Kevin Lubickcf118922020-05-28 14:43:38 -0400815 CanvasKit._free(ptr);
816 }
Kevin Lubick6aa38692020-06-01 11:25:47 -0400817}