You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
244 lines
6.8 KiB
244 lines
6.8 KiB
// TODO(kjlubick)
|
|
// The remaining functions here are deprecated and should be removed eventually.
|
|
|
|
// Caching the Float32Arrays can save having to reallocate them
|
|
// over and over again.
|
|
var Float32ArrayCache = {};
|
|
|
|
// Takes a 2D array of commands and puts them into the WASM heap
|
|
// as a 1D array. This allows them to referenced from the C++ code.
|
|
// Returns a 2 element array, with the first item being essentially a
|
|
// pointer to the array and the second item being the length of
|
|
// the new 1D array.
|
|
//
|
|
// Example usage:
|
|
// let cmds = [
|
|
// [CanvasKit.MOVE_VERB, 0, 10],
|
|
// [CanvasKit.LINE_VERB, 30, 40],
|
|
// [CanvasKit.QUAD_VERB, 20, 50, 45, 60],
|
|
// ];
|
|
// TODO(kjlubick) remove this and Float32ArrayCache (superceded by Malloc).
|
|
function loadCmdsTypedArray(arr) {
|
|
var len = 0;
|
|
for (var r = 0; r < arr.length; r++) {
|
|
len += arr[r].length;
|
|
}
|
|
|
|
var ta;
|
|
if (Float32ArrayCache[len]) {
|
|
ta = Float32ArrayCache[len];
|
|
} else {
|
|
ta = new Float32Array(len);
|
|
Float32ArrayCache[len] = ta;
|
|
}
|
|
// Flatten into a 1d array
|
|
var i = 0;
|
|
for (var r = 0; r < arr.length; r++) {
|
|
for (var c = 0; c < arr[r].length; c++) {
|
|
var item = arr[r][c];
|
|
ta[i] = item;
|
|
i++;
|
|
}
|
|
}
|
|
|
|
var ptr = copy1dArray(ta, 'HEAPF32');
|
|
return [ptr, len];
|
|
}
|
|
|
|
// TODO(kjlubick) remove Builders - no longer needed now that Malloc is a thing.
|
|
/**
|
|
* Generic helper for dealing with an array of four floats.
|
|
*/
|
|
CanvasKit.FourFloatArrayHelper = function() {
|
|
this._floats = [];
|
|
this._ptr = null;
|
|
|
|
Object.defineProperty(this, 'length', {
|
|
enumerable: true,
|
|
get: function() {
|
|
return this._floats.length / 4;
|
|
},
|
|
});
|
|
};
|
|
|
|
/**
|
|
* push the four floats onto the end of the array - if build() has already
|
|
* been called, the call will return without modifying anything.
|
|
*/
|
|
CanvasKit.FourFloatArrayHelper.prototype.push = function(f1, f2, f3, f4) {
|
|
if (this._ptr) {
|
|
Debug('Cannot push more points - already built');
|
|
return;
|
|
}
|
|
this._floats.push(f1, f2, f3, f4);
|
|
};
|
|
|
|
/**
|
|
* Set the four floats at a given index - if build() has already
|
|
* been called, the WASM memory will be written to directly.
|
|
*/
|
|
CanvasKit.FourFloatArrayHelper.prototype.set = function(idx, f1, f2, f3, f4) {
|
|
if (idx < 0 || idx >= this._floats.length/4) {
|
|
Debug('Cannot set index ' + idx + ', it is out of range', this._floats.length/4);
|
|
return;
|
|
}
|
|
idx *= 4;
|
|
var BYTES_PER_ELEMENT = 4;
|
|
if (this._ptr) {
|
|
// convert this._ptr from uint8_t* to SkScalar* by dividing by 4
|
|
var floatPtr = (this._ptr / BYTES_PER_ELEMENT) + idx;
|
|
CanvasKit.HEAPF32[floatPtr] = f1;
|
|
CanvasKit.HEAPF32[floatPtr + 1] = f2;
|
|
CanvasKit.HEAPF32[floatPtr + 2] = f3;
|
|
CanvasKit.HEAPF32[floatPtr + 3] = f4;
|
|
return;
|
|
}
|
|
this._floats[idx] = f1;
|
|
this._floats[idx + 1] = f2;
|
|
this._floats[idx + 2] = f3;
|
|
this._floats[idx + 3] = f4;
|
|
};
|
|
|
|
/**
|
|
* Copies the float data to the WASM memory and returns a pointer
|
|
* to that allocated memory. Once build has been called, this
|
|
* float array cannot be made bigger.
|
|
*/
|
|
CanvasKit.FourFloatArrayHelper.prototype.build = function() {
|
|
if (this._ptr) {
|
|
return this._ptr;
|
|
}
|
|
this._ptr = copy1dArray(this._floats, 'HEAPF32');
|
|
return this._ptr;
|
|
};
|
|
|
|
/**
|
|
* Frees the wasm memory associated with this array. Of note,
|
|
* the points are not removed, so push/set/build can all
|
|
* be called to make a newly allocated (possibly bigger)
|
|
* float array.
|
|
*/
|
|
CanvasKit.FourFloatArrayHelper.prototype.delete = function() {
|
|
if (this._ptr) {
|
|
CanvasKit._free(this._ptr);
|
|
this._ptr = null;
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Generic helper for dealing with an array of unsigned ints.
|
|
*/
|
|
CanvasKit.OneUIntArrayHelper = function() {
|
|
this._uints = [];
|
|
this._ptr = null;
|
|
|
|
Object.defineProperty(this, 'length', {
|
|
enumerable: true,
|
|
get: function() {
|
|
return this._uints.length;
|
|
},
|
|
});
|
|
};
|
|
|
|
/**
|
|
* push the unsigned int onto the end of the array - if build() has already
|
|
* been called, the call will return without modifying anything.
|
|
*/
|
|
CanvasKit.OneUIntArrayHelper.prototype.push = function(u) {
|
|
if (this._ptr) {
|
|
Debug('Cannot push more points - already built');
|
|
return;
|
|
}
|
|
this._uints.push(u);
|
|
};
|
|
|
|
/**
|
|
* Set the uint at a given index - if build() has already
|
|
* been called, the WASM memory will be written to directly.
|
|
*/
|
|
CanvasKit.OneUIntArrayHelper.prototype.set = function(idx, u) {
|
|
if (idx < 0 || idx >= this._uints.length) {
|
|
Debug('Cannot set index ' + idx + ', it is out of range', this._uints.length);
|
|
return;
|
|
}
|
|
idx *= 4;
|
|
var BYTES_PER_ELEMENT = 4;
|
|
if (this._ptr) {
|
|
// convert this._ptr from uint8_t* to SkScalar* by dividing by 4
|
|
var uintPtr = (this._ptr / BYTES_PER_ELEMENT) + idx;
|
|
CanvasKit.HEAPU32[uintPtr] = u;
|
|
return;
|
|
}
|
|
this._uints[idx] = u;
|
|
};
|
|
|
|
/**
|
|
* Copies the uint data to the WASM memory and returns a pointer
|
|
* to that allocated memory. Once build has been called, this
|
|
* unit array cannot be made bigger.
|
|
*/
|
|
CanvasKit.OneUIntArrayHelper.prototype.build = function() {
|
|
if (this._ptr) {
|
|
return this._ptr;
|
|
}
|
|
this._ptr = copy1dArray(this._uints, 'HEAPU32');
|
|
return this._ptr;
|
|
};
|
|
|
|
/**
|
|
* Frees the wasm memory associated with this array. Of note,
|
|
* the points are not removed, so push/set/build can all
|
|
* be called to make a newly allocated (possibly bigger)
|
|
* uint array.
|
|
*/
|
|
CanvasKit.OneUIntArrayHelper.prototype.delete = function() {
|
|
if (this._ptr) {
|
|
CanvasKit._free(this._ptr);
|
|
this._ptr = null;
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Helper for building an array of Rects (which are just structs
|
|
* of 4 floats).
|
|
*
|
|
* It can be more performant to use this helper, as
|
|
* the C++-side array is only allocated once (on the first call)
|
|
* to build. Subsequent set() operations operate directly on
|
|
* the C++-side array, avoiding having to re-allocate (and free)
|
|
* the array every time.
|
|
*
|
|
* Input points are taken as left, top, right, bottom
|
|
*/
|
|
CanvasKit.RectBuilder = CanvasKit.FourFloatArrayHelper;
|
|
/**
|
|
* Helper for building an array of RSXForms (which are just structs
|
|
* of 4 floats).
|
|
*
|
|
* It can be more performant to use this helper, as
|
|
* the C++-side array is only allocated once (on the first call)
|
|
* to build. Subsequent set() operations operate directly on
|
|
* the C++-side array, avoiding having to re-allocate (and free)
|
|
* the array every time.
|
|
*
|
|
* An RSXForm is a compressed form of a rotation+scale matrix.
|
|
*
|
|
* [ scos -ssin tx ]
|
|
* [ ssin scos ty ]
|
|
* [ 0 0 1 ]
|
|
*
|
|
* Input points are taken as scos, ssin, tx, ty
|
|
*/
|
|
CanvasKit.RSXFormBuilder = CanvasKit.FourFloatArrayHelper;
|
|
|
|
/**
|
|
* Helper for building an array of Color
|
|
*
|
|
* It can be more performant to use this helper, as
|
|
* the C++-side array is only allocated once (on the first call)
|
|
* to build. Subsequent set() operations operate directly on
|
|
* the C++-side array, avoiding having to re-allocate (and free)
|
|
* the array every time.
|
|
*/
|
|
CanvasKit.ColorBuilder = CanvasKit.OneUIntArrayHelper;
|