@loaders.gl/tiles
Version:
Common components for different tiles loaders.
1,873 lines (1,856 loc) • 259 kB
JavaScript
(function webpackUniversalModuleDefinition(root, factory) {
if (typeof exports === 'object' && typeof module === 'object')
module.exports = factory();
else if (typeof define === 'function' && define.amd) define([], factory);
else if (typeof exports === 'object') exports['loaders'] = factory();
else root['loaders'] = factory();})(globalThis, function () {
"use strict";
var __exports__ = (() => {
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __commonJS = (cb, mod) => function __require() {
return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
};
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
// If the importer is in node compatibility mode or this is not an ESM
// file that has been converted to a CommonJS file using a Babel-
// compatible transform (i.e. "__esModule" has not been set), then set
// "default" to the CommonJS "module.exports" for node compatibility.
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
// external-global-plugin:@loaders.gl/core
var require_core = __commonJS({
"external-global-plugin:@loaders.gl/core"(exports, module) {
module.exports = globalThis.loaders;
}
});
// bundle.ts
var bundle_exports = {};
__export(bundle_exports, {
LOD_METRIC_TYPE: () => LOD_METRIC_TYPE,
TILESET_TYPE: () => TILESET_TYPE,
TILE_CONTENT_STATE: () => TILE_CONTENT_STATE,
TILE_REFINEMENT: () => TILE_REFINEMENT,
TILE_TYPE: () => TILE_TYPE,
Tile3D: () => Tile3D,
Tileset3D: () => Tileset3D,
TilesetCache: () => TilesetCache,
TilesetTraverser: () => TilesetTraverser,
calculateTransformProps: () => calculateTransformProps,
createBoundingVolume: () => createBoundingVolume,
getFrameState: () => getFrameState,
getLodStatus: () => getLodStatus
});
__reExport(bundle_exports, __toESM(require_core(), 1));
// ../../node_modules/@math.gl/core/dist/lib/common.js
var RADIANS_TO_DEGREES = 1 / Math.PI * 180;
var DEGREES_TO_RADIANS = 1 / 180 * Math.PI;
var DEFAULT_CONFIG = {
EPSILON: 1e-12,
debug: false,
precision: 4,
printTypes: false,
printDegrees: false,
printRowMajor: true,
_cartographicRadians: false
};
globalThis.mathgl = globalThis.mathgl || { config: { ...DEFAULT_CONFIG } };
var config = globalThis.mathgl.config;
function formatValue(value, { precision = config.precision } = {}) {
value = round(value);
return `${parseFloat(value.toPrecision(precision))}`;
}
function isArray(value) {
return Array.isArray(value) || ArrayBuffer.isView(value) && !(value instanceof DataView);
}
function toRadians(degrees2) {
return radians(degrees2);
}
function toDegrees(radians2) {
return degrees(radians2);
}
function radians(degrees2, result) {
return map(degrees2, (degrees3) => degrees3 * DEGREES_TO_RADIANS, result);
}
function degrees(radians2, result) {
return map(radians2, (radians3) => radians3 * RADIANS_TO_DEGREES, result);
}
function equals(a, b, epsilon) {
const oldEpsilon = config.EPSILON;
if (epsilon) {
config.EPSILON = epsilon;
}
try {
if (a === b) {
return true;
}
if (isArray(a) && isArray(b)) {
if (a.length !== b.length) {
return false;
}
for (let i = 0; i < a.length; ++i) {
if (!equals(a[i], b[i])) {
return false;
}
}
return true;
}
if (a && a.equals) {
return a.equals(b);
}
if (b && b.equals) {
return b.equals(a);
}
if (typeof a === "number" && typeof b === "number") {
return Math.abs(a - b) <= config.EPSILON * Math.max(1, Math.abs(a), Math.abs(b));
}
return false;
} finally {
config.EPSILON = oldEpsilon;
}
}
function round(value) {
return Math.round(value / config.EPSILON) * config.EPSILON;
}
function duplicateArray(array) {
return array.clone ? array.clone() : new Array(array.length);
}
function map(value, func, result) {
if (isArray(value)) {
const array = value;
result = result || duplicateArray(array);
for (let i = 0; i < result.length && i < array.length; ++i) {
const val = typeof value === "number" ? value : value[i];
result[i] = func(val, i, result);
}
return result;
}
return func(value);
}
// ../../node_modules/@math.gl/core/dist/classes/base/math-array.js
var MathArray = class extends Array {
// Common methods
/**
* Clone the current object
* @returns a new copy of this object
*/
clone() {
return new this.constructor().copy(this);
}
fromArray(array, offset = 0) {
for (let i = 0; i < this.ELEMENTS; ++i) {
this[i] = array[i + offset];
}
return this.check();
}
toArray(targetArray = [], offset = 0) {
for (let i = 0; i < this.ELEMENTS; ++i) {
targetArray[offset + i] = this[i];
}
return targetArray;
}
toObject(targetObject) {
return targetObject;
}
from(arrayOrObject) {
return Array.isArray(arrayOrObject) ? this.copy(arrayOrObject) : (
// @ts-ignore
this.fromObject(arrayOrObject)
);
}
to(arrayOrObject) {
if (arrayOrObject === this) {
return this;
}
return isArray(arrayOrObject) ? this.toArray(arrayOrObject) : this.toObject(arrayOrObject);
}
toTarget(target) {
return target ? this.to(target) : this;
}
/** @deprecated */
toFloat32Array() {
return new Float32Array(this);
}
toString() {
return this.formatString(config);
}
/** Formats string according to options */
formatString(opts) {
let string = "";
for (let i = 0; i < this.ELEMENTS; ++i) {
string += (i > 0 ? ", " : "") + formatValue(this[i], opts);
}
return `${opts.printTypes ? this.constructor.name : ""}[${string}]`;
}
equals(array) {
if (!array || this.length !== array.length) {
return false;
}
for (let i = 0; i < this.ELEMENTS; ++i) {
if (!equals(this[i], array[i])) {
return false;
}
}
return true;
}
exactEquals(array) {
if (!array || this.length !== array.length) {
return false;
}
for (let i = 0; i < this.ELEMENTS; ++i) {
if (this[i] !== array[i]) {
return false;
}
}
return true;
}
// Modifiers
/** Negates all values in this object */
negate() {
for (let i = 0; i < this.ELEMENTS; ++i) {
this[i] = -this[i];
}
return this.check();
}
lerp(a, b, t) {
if (t === void 0) {
return this.lerp(this, a, b);
}
for (let i = 0; i < this.ELEMENTS; ++i) {
const ai = a[i];
const endValue = typeof b === "number" ? b : b[i];
this[i] = ai + t * (endValue - ai);
}
return this.check();
}
/** Minimal */
min(vector) {
for (let i = 0; i < this.ELEMENTS; ++i) {
this[i] = Math.min(vector[i], this[i]);
}
return this.check();
}
/** Maximal */
max(vector) {
for (let i = 0; i < this.ELEMENTS; ++i) {
this[i] = Math.max(vector[i], this[i]);
}
return this.check();
}
clamp(minVector, maxVector) {
for (let i = 0; i < this.ELEMENTS; ++i) {
this[i] = Math.min(Math.max(this[i], minVector[i]), maxVector[i]);
}
return this.check();
}
add(...vectors) {
for (const vector of vectors) {
for (let i = 0; i < this.ELEMENTS; ++i) {
this[i] += vector[i];
}
}
return this.check();
}
subtract(...vectors) {
for (const vector of vectors) {
for (let i = 0; i < this.ELEMENTS; ++i) {
this[i] -= vector[i];
}
}
return this.check();
}
scale(scale6) {
if (typeof scale6 === "number") {
for (let i = 0; i < this.ELEMENTS; ++i) {
this[i] *= scale6;
}
} else {
for (let i = 0; i < this.ELEMENTS && i < scale6.length; ++i) {
this[i] *= scale6[i];
}
}
return this.check();
}
/**
* Multiplies all elements by `scale`
* Note: `Matrix4.multiplyByScalar` only scales its 3x3 "minor"
*/
multiplyByScalar(scalar) {
for (let i = 0; i < this.ELEMENTS; ++i) {
this[i] *= scalar;
}
return this.check();
}
// Debug checks
/** Throws an error if array length is incorrect or contains illegal values */
check() {
if (config.debug && !this.validate()) {
throw new Error(`math.gl: ${this.constructor.name} some fields set to invalid numbers'`);
}
return this;
}
/** Returns false if the array length is incorrect or contains illegal values */
validate() {
let valid = this.length === this.ELEMENTS;
for (let i = 0; i < this.ELEMENTS; ++i) {
valid = valid && Number.isFinite(this[i]);
}
return valid;
}
// three.js compatibility
/** @deprecated */
sub(a) {
return this.subtract(a);
}
/** @deprecated */
setScalar(a) {
for (let i = 0; i < this.ELEMENTS; ++i) {
this[i] = a;
}
return this.check();
}
/** @deprecated */
addScalar(a) {
for (let i = 0; i < this.ELEMENTS; ++i) {
this[i] += a;
}
return this.check();
}
/** @deprecated */
subScalar(a) {
return this.addScalar(-a);
}
/** @deprecated */
multiplyScalar(scalar) {
for (let i = 0; i < this.ELEMENTS; ++i) {
this[i] *= scalar;
}
return this.check();
}
/** @deprecated */
divideScalar(a) {
return this.multiplyByScalar(1 / a);
}
/** @deprecated */
clampScalar(min2, max2) {
for (let i = 0; i < this.ELEMENTS; ++i) {
this[i] = Math.min(Math.max(this[i], min2), max2);
}
return this.check();
}
/** @deprecated */
get elements() {
return this;
}
};
// ../../node_modules/@math.gl/core/dist/lib/validators.js
function validateVector(v, length4) {
if (v.length !== length4) {
return false;
}
for (let i = 0; i < v.length; ++i) {
if (!Number.isFinite(v[i])) {
return false;
}
}
return true;
}
function checkNumber(value) {
if (!Number.isFinite(value)) {
throw new Error(`Invalid number ${JSON.stringify(value)}`);
}
return value;
}
function checkVector(v, length4, callerName = "") {
if (config.debug && !validateVector(v, length4)) {
throw new Error(`math.gl: ${callerName} some fields set to invalid numbers'`);
}
return v;
}
// ../../node_modules/@math.gl/core/dist/lib/assert.js
function assert(condition, message) {
if (!condition) {
throw new Error(`math.gl assertion ${message}`);
}
}
// ../../node_modules/@math.gl/core/dist/classes/base/vector.js
var Vector = class extends MathArray {
// ACCESSORS
get x() {
return this[0];
}
set x(value) {
this[0] = checkNumber(value);
}
get y() {
return this[1];
}
set y(value) {
this[1] = checkNumber(value);
}
/**
* Returns the length of the vector from the origin to the point described by this vector
*
* @note `length` is a reserved word for Arrays, so `v.length()` will return number of elements
* Instead we provide `len` and `magnitude`
*/
len() {
return Math.sqrt(this.lengthSquared());
}
/**
* Returns the length of the vector from the origin to the point described by this vector
*/
magnitude() {
return this.len();
}
/**
* Returns the squared length of the vector from the origin to the point described by this vector
*/
lengthSquared() {
let length4 = 0;
for (let i = 0; i < this.ELEMENTS; ++i) {
length4 += this[i] * this[i];
}
return length4;
}
/**
* Returns the squared length of the vector from the origin to the point described by this vector
*/
magnitudeSquared() {
return this.lengthSquared();
}
distance(mathArray) {
return Math.sqrt(this.distanceSquared(mathArray));
}
distanceSquared(mathArray) {
let length4 = 0;
for (let i = 0; i < this.ELEMENTS; ++i) {
const dist2 = this[i] - mathArray[i];
length4 += dist2 * dist2;
}
return checkNumber(length4);
}
dot(mathArray) {
let product = 0;
for (let i = 0; i < this.ELEMENTS; ++i) {
product += this[i] * mathArray[i];
}
return checkNumber(product);
}
// MODIFIERS
normalize() {
const length4 = this.magnitude();
if (length4 !== 0) {
for (let i = 0; i < this.ELEMENTS; ++i) {
this[i] /= length4;
}
}
return this.check();
}
multiply(...vectors) {
for (const vector of vectors) {
for (let i = 0; i < this.ELEMENTS; ++i) {
this[i] *= vector[i];
}
}
return this.check();
}
divide(...vectors) {
for (const vector of vectors) {
for (let i = 0; i < this.ELEMENTS; ++i) {
this[i] /= vector[i];
}
}
return this.check();
}
// THREE.js compatibility
lengthSq() {
return this.lengthSquared();
}
distanceTo(vector) {
return this.distance(vector);
}
distanceToSquared(vector) {
return this.distanceSquared(vector);
}
getComponent(i) {
assert(i >= 0 && i < this.ELEMENTS, "index is out of range");
return checkNumber(this[i]);
}
setComponent(i, value) {
assert(i >= 0 && i < this.ELEMENTS, "index is out of range");
this[i] = value;
return this.check();
}
addVectors(a, b) {
return this.copy(a).add(b);
}
subVectors(a, b) {
return this.copy(a).subtract(b);
}
multiplyVectors(a, b) {
return this.copy(a).multiply(b);
}
addScaledVector(a, b) {
return this.add(new this.constructor(a).multiplyScalar(b));
}
};
// ../../node_modules/@math.gl/core/dist/gl-matrix/common.js
var EPSILON = 1e-6;
var ARRAY_TYPE = typeof Float32Array !== "undefined" ? Float32Array : Array;
var RANDOM = Math.random;
function round2(a) {
if (a >= 0)
return Math.round(a);
return a % 0.5 === 0 ? Math.floor(a) : Math.round(a);
}
var degree = Math.PI / 180;
// ../../node_modules/@math.gl/core/dist/gl-matrix/vec2.js
function create() {
const out = new ARRAY_TYPE(2);
if (ARRAY_TYPE != Float32Array) {
out[0] = 0;
out[1] = 0;
}
return out;
}
function transformMat3(out, a, m) {
const x = a[0];
const y = a[1];
out[0] = m[0] * x + m[3] * y + m[6];
out[1] = m[1] * x + m[4] * y + m[7];
return out;
}
function transformMat4(out, a, m) {
const x = a[0];
const y = a[1];
out[0] = m[0] * x + m[4] * y + m[12];
out[1] = m[1] * x + m[5] * y + m[13];
return out;
}
var forEach = function() {
const vec = create();
return function(a, stride, offset, count, fn, arg) {
let i;
let l;
if (!stride) {
stride = 2;
}
if (!offset) {
offset = 0;
}
if (count) {
l = Math.min(count * stride + offset, a.length);
} else {
l = a.length;
}
for (i = offset; i < l; i += stride) {
vec[0] = a[i];
vec[1] = a[i + 1];
fn(vec, vec, arg);
a[i] = vec[0];
a[i + 1] = vec[1];
}
return a;
};
}();
// ../../node_modules/@math.gl/core/dist/lib/gl-matrix-extras.js
function vec2_transformMat4AsVector(out, a, m) {
const x = a[0];
const y = a[1];
const w = m[3] * x + m[7] * y || 1;
out[0] = (m[0] * x + m[4] * y) / w;
out[1] = (m[1] * x + m[5] * y) / w;
return out;
}
function vec3_transformMat4AsVector(out, a, m) {
const x = a[0];
const y = a[1];
const z = a[2];
const w = m[3] * x + m[7] * y + m[11] * z || 1;
out[0] = (m[0] * x + m[4] * y + m[8] * z) / w;
out[1] = (m[1] * x + m[5] * y + m[9] * z) / w;
out[2] = (m[2] * x + m[6] * y + m[10] * z) / w;
return out;
}
function vec3_transformMat2(out, a, m) {
const x = a[0];
const y = a[1];
out[0] = m[0] * x + m[2] * y;
out[1] = m[1] * x + m[3] * y;
out[2] = a[2];
return out;
}
function vec4_transformMat2(out, a, m) {
const x = a[0];
const y = a[1];
out[0] = m[0] * x + m[2] * y;
out[1] = m[1] * x + m[3] * y;
out[2] = a[2];
out[3] = a[3];
return out;
}
function vec4_transformMat3(out, a, m) {
const x = a[0];
const y = a[1];
const z = a[2];
out[0] = m[0] * x + m[3] * y + m[6] * z;
out[1] = m[1] * x + m[4] * y + m[7] * z;
out[2] = m[2] * x + m[5] * y + m[8] * z;
out[3] = a[3];
return out;
}
// ../../node_modules/@math.gl/core/dist/gl-matrix/vec3.js
var vec3_exports = {};
__export(vec3_exports, {
add: () => add,
angle: () => angle,
bezier: () => bezier,
ceil: () => ceil,
clone: () => clone,
copy: () => copy,
create: () => create2,
cross: () => cross,
dist: () => dist,
distance: () => distance,
div: () => div,
divide: () => divide,
dot: () => dot,
equals: () => equals2,
exactEquals: () => exactEquals,
floor: () => floor,
forEach: () => forEach2,
fromValues: () => fromValues,
hermite: () => hermite,
inverse: () => inverse,
len: () => len,
length: () => length,
lerp: () => lerp,
max: () => max,
min: () => min,
mul: () => mul,
multiply: () => multiply,
negate: () => negate,
normalize: () => normalize,
random: () => random,
rotateX: () => rotateX,
rotateY: () => rotateY,
rotateZ: () => rotateZ,
round: () => round3,
scale: () => scale,
scaleAndAdd: () => scaleAndAdd,
set: () => set,
slerp: () => slerp,
sqrDist: () => sqrDist,
sqrLen: () => sqrLen,
squaredDistance: () => squaredDistance,
squaredLength: () => squaredLength,
str: () => str,
sub: () => sub,
subtract: () => subtract,
transformMat3: () => transformMat32,
transformMat4: () => transformMat42,
transformQuat: () => transformQuat,
zero: () => zero
});
function create2() {
const out = new ARRAY_TYPE(3);
if (ARRAY_TYPE != Float32Array) {
out[0] = 0;
out[1] = 0;
out[2] = 0;
}
return out;
}
function clone(a) {
const out = new ARRAY_TYPE(3);
out[0] = a[0];
out[1] = a[1];
out[2] = a[2];
return out;
}
function length(a) {
const x = a[0];
const y = a[1];
const z = a[2];
return Math.sqrt(x * x + y * y + z * z);
}
function fromValues(x, y, z) {
const out = new ARRAY_TYPE(3);
out[0] = x;
out[1] = y;
out[2] = z;
return out;
}
function copy(out, a) {
out[0] = a[0];
out[1] = a[1];
out[2] = a[2];
return out;
}
function set(out, x, y, z) {
out[0] = x;
out[1] = y;
out[2] = z;
return out;
}
function add(out, a, b) {
out[0] = a[0] + b[0];
out[1] = a[1] + b[1];
out[2] = a[2] + b[2];
return out;
}
function subtract(out, a, b) {
out[0] = a[0] - b[0];
out[1] = a[1] - b[1];
out[2] = a[2] - b[2];
return out;
}
function multiply(out, a, b) {
out[0] = a[0] * b[0];
out[1] = a[1] * b[1];
out[2] = a[2] * b[2];
return out;
}
function divide(out, a, b) {
out[0] = a[0] / b[0];
out[1] = a[1] / b[1];
out[2] = a[2] / b[2];
return out;
}
function ceil(out, a) {
out[0] = Math.ceil(a[0]);
out[1] = Math.ceil(a[1]);
out[2] = Math.ceil(a[2]);
return out;
}
function floor(out, a) {
out[0] = Math.floor(a[0]);
out[1] = Math.floor(a[1]);
out[2] = Math.floor(a[2]);
return out;
}
function min(out, a, b) {
out[0] = Math.min(a[0], b[0]);
out[1] = Math.min(a[1], b[1]);
out[2] = Math.min(a[2], b[2]);
return out;
}
function max(out, a, b) {
out[0] = Math.max(a[0], b[0]);
out[1] = Math.max(a[1], b[1]);
out[2] = Math.max(a[2], b[2]);
return out;
}
function round3(out, a) {
out[0] = round2(a[0]);
out[1] = round2(a[1]);
out[2] = round2(a[2]);
return out;
}
function scale(out, a, b) {
out[0] = a[0] * b;
out[1] = a[1] * b;
out[2] = a[2] * b;
return out;
}
function scaleAndAdd(out, a, b, scale6) {
out[0] = a[0] + b[0] * scale6;
out[1] = a[1] + b[1] * scale6;
out[2] = a[2] + b[2] * scale6;
return out;
}
function distance(a, b) {
const x = b[0] - a[0];
const y = b[1] - a[1];
const z = b[2] - a[2];
return Math.sqrt(x * x + y * y + z * z);
}
function squaredDistance(a, b) {
const x = b[0] - a[0];
const y = b[1] - a[1];
const z = b[2] - a[2];
return x * x + y * y + z * z;
}
function squaredLength(a) {
const x = a[0];
const y = a[1];
const z = a[2];
return x * x + y * y + z * z;
}
function negate(out, a) {
out[0] = -a[0];
out[1] = -a[1];
out[2] = -a[2];
return out;
}
function inverse(out, a) {
out[0] = 1 / a[0];
out[1] = 1 / a[1];
out[2] = 1 / a[2];
return out;
}
function normalize(out, a) {
const x = a[0];
const y = a[1];
const z = a[2];
let len2 = x * x + y * y + z * z;
if (len2 > 0) {
len2 = 1 / Math.sqrt(len2);
}
out[0] = a[0] * len2;
out[1] = a[1] * len2;
out[2] = a[2] * len2;
return out;
}
function dot(a, b) {
return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
}
function cross(out, a, b) {
const ax = a[0];
const ay = a[1];
const az = a[2];
const bx = b[0];
const by = b[1];
const bz = b[2];
out[0] = ay * bz - az * by;
out[1] = az * bx - ax * bz;
out[2] = ax * by - ay * bx;
return out;
}
function lerp(out, a, b, t) {
const ax = a[0];
const ay = a[1];
const az = a[2];
out[0] = ax + t * (b[0] - ax);
out[1] = ay + t * (b[1] - ay);
out[2] = az + t * (b[2] - az);
return out;
}
function slerp(out, a, b, t) {
const angle2 = Math.acos(Math.min(Math.max(dot(a, b), -1), 1));
const sinTotal = Math.sin(angle2);
const ratioA = Math.sin((1 - t) * angle2) / sinTotal;
const ratioB = Math.sin(t * angle2) / sinTotal;
out[0] = ratioA * a[0] + ratioB * b[0];
out[1] = ratioA * a[1] + ratioB * b[1];
out[2] = ratioA * a[2] + ratioB * b[2];
return out;
}
function hermite(out, a, b, c, d, t) {
const factorTimes2 = t * t;
const factor1 = factorTimes2 * (2 * t - 3) + 1;
const factor2 = factorTimes2 * (t - 2) + t;
const factor3 = factorTimes2 * (t - 1);
const factor4 = factorTimes2 * (3 - 2 * t);
out[0] = a[0] * factor1 + b[0] * factor2 + c[0] * factor3 + d[0] * factor4;
out[1] = a[1] * factor1 + b[1] * factor2 + c[1] * factor3 + d[1] * factor4;
out[2] = a[2] * factor1 + b[2] * factor2 + c[2] * factor3 + d[2] * factor4;
return out;
}
function bezier(out, a, b, c, d, t) {
const inverseFactor = 1 - t;
const inverseFactorTimesTwo = inverseFactor * inverseFactor;
const factorTimes2 = t * t;
const factor1 = inverseFactorTimesTwo * inverseFactor;
const factor2 = 3 * t * inverseFactorTimesTwo;
const factor3 = 3 * factorTimes2 * inverseFactor;
const factor4 = factorTimes2 * t;
out[0] = a[0] * factor1 + b[0] * factor2 + c[0] * factor3 + d[0] * factor4;
out[1] = a[1] * factor1 + b[1] * factor2 + c[1] * factor3 + d[1] * factor4;
out[2] = a[2] * factor1 + b[2] * factor2 + c[2] * factor3 + d[2] * factor4;
return out;
}
function random(out, scale6) {
scale6 = scale6 === void 0 ? 1 : scale6;
const r = RANDOM() * 2 * Math.PI;
const z = RANDOM() * 2 - 1;
const zScale = Math.sqrt(1 - z * z) * scale6;
out[0] = Math.cos(r) * zScale;
out[1] = Math.sin(r) * zScale;
out[2] = z * scale6;
return out;
}
function transformMat42(out, a, m) {
const x = a[0];
const y = a[1];
const z = a[2];
let w = m[3] * x + m[7] * y + m[11] * z + m[15];
w = w || 1;
out[0] = (m[0] * x + m[4] * y + m[8] * z + m[12]) / w;
out[1] = (m[1] * x + m[5] * y + m[9] * z + m[13]) / w;
out[2] = (m[2] * x + m[6] * y + m[10] * z + m[14]) / w;
return out;
}
function transformMat32(out, a, m) {
const x = a[0];
const y = a[1];
const z = a[2];
out[0] = x * m[0] + y * m[3] + z * m[6];
out[1] = x * m[1] + y * m[4] + z * m[7];
out[2] = x * m[2] + y * m[5] + z * m[8];
return out;
}
function transformQuat(out, a, q) {
const qx = q[0];
const qy = q[1];
const qz = q[2];
const qw = q[3];
const x = a[0];
const y = a[1];
const z = a[2];
let uvx = qy * z - qz * y;
let uvy = qz * x - qx * z;
let uvz = qx * y - qy * x;
let uuvx = qy * uvz - qz * uvy;
let uuvy = qz * uvx - qx * uvz;
let uuvz = qx * uvy - qy * uvx;
const w2 = qw * 2;
uvx *= w2;
uvy *= w2;
uvz *= w2;
uuvx *= 2;
uuvy *= 2;
uuvz *= 2;
out[0] = x + uvx + uuvx;
out[1] = y + uvy + uuvy;
out[2] = z + uvz + uuvz;
return out;
}
function rotateX(out, a, b, rad) {
const p = [];
const r = [];
p[0] = a[0] - b[0];
p[1] = a[1] - b[1];
p[2] = a[2] - b[2];
r[0] = p[0];
r[1] = p[1] * Math.cos(rad) - p[2] * Math.sin(rad);
r[2] = p[1] * Math.sin(rad) + p[2] * Math.cos(rad);
out[0] = r[0] + b[0];
out[1] = r[1] + b[1];
out[2] = r[2] + b[2];
return out;
}
function rotateY(out, a, b, rad) {
const p = [];
const r = [];
p[0] = a[0] - b[0];
p[1] = a[1] - b[1];
p[2] = a[2] - b[2];
r[0] = p[2] * Math.sin(rad) + p[0] * Math.cos(rad);
r[1] = p[1];
r[2] = p[2] * Math.cos(rad) - p[0] * Math.sin(rad);
out[0] = r[0] + b[0];
out[1] = r[1] + b[1];
out[2] = r[2] + b[2];
return out;
}
function rotateZ(out, a, b, rad) {
const p = [];
const r = [];
p[0] = a[0] - b[0];
p[1] = a[1] - b[1];
p[2] = a[2] - b[2];
r[0] = p[0] * Math.cos(rad) - p[1] * Math.sin(rad);
r[1] = p[0] * Math.sin(rad) + p[1] * Math.cos(rad);
r[2] = p[2];
out[0] = r[0] + b[0];
out[1] = r[1] + b[1];
out[2] = r[2] + b[2];
return out;
}
function angle(a, b) {
const ax = a[0];
const ay = a[1];
const az = a[2];
const bx = b[0];
const by = b[1];
const bz = b[2];
const mag = Math.sqrt((ax * ax + ay * ay + az * az) * (bx * bx + by * by + bz * bz));
const cosine = mag && dot(a, b) / mag;
return Math.acos(Math.min(Math.max(cosine, -1), 1));
}
function zero(out) {
out[0] = 0;
out[1] = 0;
out[2] = 0;
return out;
}
function str(a) {
return `vec3(${a[0]}, ${a[1]}, ${a[2]})`;
}
function exactEquals(a, b) {
return a[0] === b[0] && a[1] === b[1] && a[2] === b[2];
}
function equals2(a, b) {
const a0 = a[0];
const a1 = a[1];
const a2 = a[2];
const b0 = b[0];
const b1 = b[1];
const b2 = b[2];
return Math.abs(a0 - b0) <= EPSILON * Math.max(1, Math.abs(a0), Math.abs(b0)) && Math.abs(a1 - b1) <= EPSILON * Math.max(1, Math.abs(a1), Math.abs(b1)) && Math.abs(a2 - b2) <= EPSILON * Math.max(1, Math.abs(a2), Math.abs(b2));
}
var sub = subtract;
var mul = multiply;
var div = divide;
var dist = distance;
var sqrDist = squaredDistance;
var len = length;
var sqrLen = squaredLength;
var forEach2 = function() {
const vec = create2();
return function(a, stride, offset, count, fn, arg) {
let i;
let l;
if (!stride) {
stride = 3;
}
if (!offset) {
offset = 0;
}
if (count) {
l = Math.min(count * stride + offset, a.length);
} else {
l = a.length;
}
for (i = offset; i < l; i += stride) {
vec[0] = a[i];
vec[1] = a[i + 1];
vec[2] = a[i + 2];
fn(vec, vec, arg);
a[i] = vec[0];
a[i + 1] = vec[1];
a[i + 2] = vec[2];
}
return a;
};
}();
// ../../node_modules/@math.gl/core/dist/classes/vector3.js
var ORIGIN = [0, 0, 0];
var ZERO;
var Vector3 = class extends Vector {
static get ZERO() {
if (!ZERO) {
ZERO = new Vector3(0, 0, 0);
Object.freeze(ZERO);
}
return ZERO;
}
/**
* @class
* @param x
* @param y
* @param z
*/
constructor(x = 0, y = 0, z = 0) {
super(-0, -0, -0);
if (arguments.length === 1 && isArray(x)) {
this.copy(x);
} else {
if (config.debug) {
checkNumber(x);
checkNumber(y);
checkNumber(z);
}
this[0] = x;
this[1] = y;
this[2] = z;
}
}
set(x, y, z) {
this[0] = x;
this[1] = y;
this[2] = z;
return this.check();
}
copy(array) {
this[0] = array[0];
this[1] = array[1];
this[2] = array[2];
return this.check();
}
fromObject(object) {
if (config.debug) {
checkNumber(object.x);
checkNumber(object.y);
checkNumber(object.z);
}
this[0] = object.x;
this[1] = object.y;
this[2] = object.z;
return this.check();
}
toObject(object) {
object.x = this[0];
object.y = this[1];
object.z = this[2];
return object;
}
// Getters/setters
get ELEMENTS() {
return 3;
}
get z() {
return this[2];
}
set z(value) {
this[2] = checkNumber(value);
}
// ACCESSORS
angle(vector) {
return angle(this, vector);
}
// MODIFIERS
cross(vector) {
cross(this, this, vector);
return this.check();
}
rotateX({ radians: radians2, origin = ORIGIN }) {
rotateX(this, this, origin, radians2);
return this.check();
}
rotateY({ radians: radians2, origin = ORIGIN }) {
rotateY(this, this, origin, radians2);
return this.check();
}
rotateZ({ radians: radians2, origin = ORIGIN }) {
rotateZ(this, this, origin, radians2);
return this.check();
}
// Transforms
// transforms as point (4th component is implicitly 1)
transform(matrix4) {
return this.transformAsPoint(matrix4);
}
// transforms as point (4th component is implicitly 1)
transformAsPoint(matrix4) {
transformMat42(this, this, matrix4);
return this.check();
}
// transforms as vector (4th component is implicitly 0, ignores translation. slightly faster)
transformAsVector(matrix4) {
vec3_transformMat4AsVector(this, this, matrix4);
return this.check();
}
transformByMatrix3(matrix3) {
transformMat32(this, this, matrix3);
return this.check();
}
transformByMatrix2(matrix2) {
vec3_transformMat2(this, this, matrix2);
return this.check();
}
transformByQuaternion(quaternion) {
transformQuat(this, this, quaternion);
return this.check();
}
};
// ../../node_modules/@math.gl/core/dist/classes/vector4.js
var ZERO2;
var Vector4 = class extends Vector {
static get ZERO() {
if (!ZERO2) {
ZERO2 = new Vector4(0, 0, 0, 0);
Object.freeze(ZERO2);
}
return ZERO2;
}
constructor(x = 0, y = 0, z = 0, w = 0) {
super(-0, -0, -0, -0);
if (isArray(x) && arguments.length === 1) {
this.copy(x);
} else {
if (config.debug) {
checkNumber(x);
checkNumber(y);
checkNumber(z);
checkNumber(w);
}
this[0] = x;
this[1] = y;
this[2] = z;
this[3] = w;
}
}
set(x, y, z, w) {
this[0] = x;
this[1] = y;
this[2] = z;
this[3] = w;
return this.check();
}
copy(array) {
this[0] = array[0];
this[1] = array[1];
this[2] = array[2];
this[3] = array[3];
return this.check();
}
fromObject(object) {
if (config.debug) {
checkNumber(object.x);
checkNumber(object.y);
checkNumber(object.z);
checkNumber(object.w);
}
this[0] = object.x;
this[1] = object.y;
this[2] = object.z;
this[3] = object.w;
return this;
}
toObject(object) {
object.x = this[0];
object.y = this[1];
object.z = this[2];
object.w = this[3];
return object;
}
// Getters/setters
/* eslint-disable no-multi-spaces, brace-style, no-return-assign */
get ELEMENTS() {
return 4;
}
get z() {
return this[2];
}
set z(value) {
this[2] = checkNumber(value);
}
get w() {
return this[3];
}
set w(value) {
this[3] = checkNumber(value);
}
transform(matrix4) {
transformMat42(this, this, matrix4);
return this.check();
}
transformByMatrix3(matrix3) {
vec4_transformMat3(this, this, matrix3);
return this.check();
}
transformByMatrix2(matrix2) {
vec4_transformMat2(this, this, matrix2);
return this.check();
}
transformByQuaternion(quaternion) {
transformQuat(this, this, quaternion);
return this.check();
}
// three.js compatibility
applyMatrix4(m) {
m.transform(this, this);
return this;
}
};
// ../../node_modules/@math.gl/core/dist/classes/base/matrix.js
var Matrix = class extends MathArray {
// fromObject(object) {
// const array = object.elements;
// return this.fromRowMajor(array);
// }
// toObject(object) {
// const array = object.elements;
// this.toRowMajor(array);
// return object;
// }
// TODO better override formatString?
toString() {
let string = "[";
if (config.printRowMajor) {
string += "row-major:";
for (let row = 0; row < this.RANK; ++row) {
for (let col = 0; col < this.RANK; ++col) {
string += ` ${this[col * this.RANK + row]}`;
}
}
} else {
string += "column-major:";
for (let i = 0; i < this.ELEMENTS; ++i) {
string += ` ${this[i]}`;
}
}
string += "]";
return string;
}
getElementIndex(row, col) {
return col * this.RANK + row;
}
// By default assumes row major indices
getElement(row, col) {
return this[col * this.RANK + row];
}
// By default assumes row major indices
setElement(row, col, value) {
this[col * this.RANK + row] = checkNumber(value);
return this;
}
getColumn(columnIndex, result = new Array(this.RANK).fill(-0)) {
const firstIndex = columnIndex * this.RANK;
for (let i = 0; i < this.RANK; ++i) {
result[i] = this[firstIndex + i];
}
return result;
}
setColumn(columnIndex, columnVector) {
const firstIndex = columnIndex * this.RANK;
for (let i = 0; i < this.RANK; ++i) {
this[firstIndex + i] = columnVector[i];
}
return this;
}
};
// ../../node_modules/@math.gl/core/dist/gl-matrix/mat3.js
function create3() {
const out = new ARRAY_TYPE(9);
if (ARRAY_TYPE != Float32Array) {
out[1] = 0;
out[2] = 0;
out[3] = 0;
out[5] = 0;
out[6] = 0;
out[7] = 0;
}
out[0] = 1;
out[4] = 1;
out[8] = 1;
return out;
}
function transpose(out, a) {
if (out === a) {
const a01 = a[1];
const a02 = a[2];
const a12 = a[5];
out[1] = a[3];
out[2] = a[6];
out[3] = a01;
out[5] = a[7];
out[6] = a02;
out[7] = a12;
} else {
out[0] = a[0];
out[1] = a[3];
out[2] = a[6];
out[3] = a[1];
out[4] = a[4];
out[5] = a[7];
out[6] = a[2];
out[7] = a[5];
out[8] = a[8];
}
return out;
}
function invert(out, a) {
const a00 = a[0];
const a01 = a[1];
const a02 = a[2];
const a10 = a[3];
const a11 = a[4];
const a12 = a[5];
const a20 = a[6];
const a21 = a[7];
const a22 = a[8];
const b01 = a22 * a11 - a12 * a21;
const b11 = -a22 * a10 + a12 * a20;
const b21 = a21 * a10 - a11 * a20;
let det = a00 * b01 + a01 * b11 + a02 * b21;
if (!det) {
return null;
}
det = 1 / det;
out[0] = b01 * det;
out[1] = (-a22 * a01 + a02 * a21) * det;
out[2] = (a12 * a01 - a02 * a11) * det;
out[3] = b11 * det;
out[4] = (a22 * a00 - a02 * a20) * det;
out[5] = (-a12 * a00 + a02 * a10) * det;
out[6] = b21 * det;
out[7] = (-a21 * a00 + a01 * a20) * det;
out[8] = (a11 * a00 - a01 * a10) * det;
return out;
}
function determinant(a) {
const a00 = a[0];
const a01 = a[1];
const a02 = a[2];
const a10 = a[3];
const a11 = a[4];
const a12 = a[5];
const a20 = a[6];
const a21 = a[7];
const a22 = a[8];
return a00 * (a22 * a11 - a12 * a21) + a01 * (-a22 * a10 + a12 * a20) + a02 * (a21 * a10 - a11 * a20);
}
function multiply2(out, a, b) {
const a00 = a[0];
const a01 = a[1];
const a02 = a[2];
const a10 = a[3];
const a11 = a[4];
const a12 = a[5];
const a20 = a[6];
const a21 = a[7];
const a22 = a[8];
const b00 = b[0];
const b01 = b[1];
const b02 = b[2];
const b10 = b[3];
const b11 = b[4];
const b12 = b[5];
const b20 = b[6];
const b21 = b[7];
const b22 = b[8];
out[0] = b00 * a00 + b01 * a10 + b02 * a20;
out[1] = b00 * a01 + b01 * a11 + b02 * a21;
out[2] = b00 * a02 + b01 * a12 + b02 * a22;
out[3] = b10 * a00 + b11 * a10 + b12 * a20;
out[4] = b10 * a01 + b11 * a11 + b12 * a21;
out[5] = b10 * a02 + b11 * a12 + b12 * a22;
out[6] = b20 * a00 + b21 * a10 + b22 * a20;
out[7] = b20 * a01 + b21 * a11 + b22 * a21;
out[8] = b20 * a02 + b21 * a12 + b22 * a22;
return out;
}
function translate(out, a, v) {
const a00 = a[0];
const a01 = a[1];
const a02 = a[2];
const a10 = a[3];
const a11 = a[4];
const a12 = a[5];
const a20 = a[6];
const a21 = a[7];
const a22 = a[8];
const x = v[0];
const y = v[1];
out[0] = a00;
out[1] = a01;
out[2] = a02;
out[3] = a10;
out[4] = a11;
out[5] = a12;
out[6] = x * a00 + y * a10 + a20;
out[7] = x * a01 + y * a11 + a21;
out[8] = x * a02 + y * a12 + a22;
return out;
}
function rotate(out, a, rad) {
const a00 = a[0];
const a01 = a[1];
const a02 = a[2];
const a10 = a[3];
const a11 = a[4];
const a12 = a[5];
const a20 = a[6];
const a21 = a[7];
const a22 = a[8];
const s = Math.sin(rad);
const c = Math.cos(rad);
out[0] = c * a00 + s * a10;
out[1] = c * a01 + s * a11;
out[2] = c * a02 + s * a12;
out[3] = c * a10 - s * a00;
out[4] = c * a11 - s * a01;
out[5] = c * a12 - s * a02;
out[6] = a20;
out[7] = a21;
out[8] = a22;
return out;
}
function scale2(out, a, v) {
const x = v[0];
const y = v[1];
out[0] = x * a[0];
out[1] = x * a[1];
out[2] = x * a[2];
out[3] = y * a[3];
out[4] = y * a[4];
out[5] = y * a[5];
out[6] = a[6];
out[7] = a[7];
out[8] = a[8];
return out;
}
function fromQuat(out, q) {
const x = q[0];
const y = q[1];
const z = q[2];
const w = q[3];
const x2 = x + x;
const y2 = y + y;
const z2 = z + z;
const xx = x * x2;
const yx = y * x2;
const yy = y * y2;
const zx = z * x2;
const zy = z * y2;
const zz = z * z2;
const wx = w * x2;
const wy = w * y2;
const wz = w * z2;
out[0] = 1 - yy - zz;
out[3] = yx - wz;
out[6] = zx + wy;
out[1] = yx + wz;
out[4] = 1 - xx - zz;
out[7] = zy - wx;
out[2] = zx - wy;
out[5] = zy + wx;
out[8] = 1 - xx - yy;
return out;
}
// ../../node_modules/@math.gl/core/dist/classes/matrix3.js
var INDICES;
(function(INDICES3) {
INDICES3[INDICES3["COL0ROW0"] = 0] = "COL0ROW0";
INDICES3[INDICES3["COL0ROW1"] = 1] = "COL0ROW1";
INDICES3[INDICES3["COL0ROW2"] = 2] = "COL0ROW2";
INDICES3[INDICES3["COL1ROW0"] = 3] = "COL1ROW0";
INDICES3[INDICES3["COL1ROW1"] = 4] = "COL1ROW1";
INDICES3[INDICES3["COL1ROW2"] = 5] = "COL1ROW2";
INDICES3[INDICES3["COL2ROW0"] = 6] = "COL2ROW0";
INDICES3[INDICES3["COL2ROW1"] = 7] = "COL2ROW1";
INDICES3[INDICES3["COL2ROW2"] = 8] = "COL2ROW2";
})(INDICES || (INDICES = {}));
var IDENTITY_MATRIX = Object.freeze([1, 0, 0, 0, 1, 0, 0, 0, 1]);
var Matrix3 = class extends Matrix {
static get IDENTITY() {
return getIdentityMatrix();
}
static get ZERO() {
return getZeroMatrix();
}
get ELEMENTS() {
return 9;
}
get RANK() {
return 3;
}
get INDICES() {
return INDICES;
}
constructor(array, ...args) {
super(-0, -0, -0, -0, -0, -0, -0, -0, -0);
if (arguments.length === 1 && Array.isArray(array)) {
this.copy(array);
} else if (args.length > 0) {
this.copy([array, ...args]);
} else {
this.identity();
}
}
copy(array) {
this[0] = array[0];
this[1] = array[1];
this[2] = array[2];
this[3] = array[3];
this[4] = array[4];
this[5] = array[5];
this[6] = array[6];
this[7] = array[7];
this[8] = array[8];
return this.check();
}
// Constructors
identity() {
return this.copy(IDENTITY_MATRIX);
}
/**
*
* @param object
* @returns self
*/
// eslint-disable-next-line @typescript-eslint/no-unused-vars
fromObject(object) {
return this.check();
}
/** Calculates a 3x3 matrix from the given quaternion
* q quat Quaternion to create matrix from
*/
fromQuaternion(q) {
fromQuat(this, q);
return this.check();
}
/**
* accepts column major order, stores in column major order
*/
// eslint-disable-next-line max-params
set(m00, m10, m20, m01, m11, m21, m02, m12, m22) {
this[0] = m00;
this[1] = m10;
this[2] = m20;
this[3] = m01;
this[4] = m11;
this[5] = m21;
this[6] = m02;
this[7] = m12;
this[8] = m22;
return this.check();
}
/**
* accepts row major order, stores as column major
*/
// eslint-disable-next-line max-params
setRowMajor(m00, m01, m02, m10, m11, m12, m20, m21, m22) {
this[0] = m00;
this[1] = m10;
this[2] = m20;
this[3] = m01;
this[4] = m11;
this[5] = m21;
this[6] = m02;
this[7] = m12;
this[8] = m22;
return this.check();
}
// Accessors
determinant() {
return determinant(this);
}
// Modifiers
transpose() {
transpose(this, this);
return this.check();
}
/** Invert a matrix. Note that this can fail if the matrix is not invertible */
invert() {
invert(this, this);
return this.check();
}
// Operations
multiplyLeft(a) {
multiply2(this, a, this);
return this.check();
}
multiplyRight(a) {
multiply2(this, this, a);
return this.check();
}
rotate(radians2) {
rotate(this, this, radians2);
return this.check();
}
scale(factor) {
if (Array.isArray(factor)) {
scale2(this, this, factor);
} else {
scale2(this, this, [factor, factor]);
}
return this.check();
}
translate(vec) {
translate(this, this, vec);
return this.check();
}
// Transforms
transform(vector, result) {
let out;
switch (vector.length) {
case 2:
out = transformMat3(result || [-0, -0], vector, this);
break;
case 3:
out = transformMat32(result || [-0, -0, -0], vector, this);
break;
case 4:
out = vec4_transformMat3(result || [-0, -0, -0, -0], vector, this);
break;
default:
throw new Error("Illegal vector");
}
checkVector(out, vector.length);
return out;
}
/** @deprecated */
transformVector(vector, result) {
return this.transform(vector, result);
}
/** @deprecated */
transformVector2(vector, result) {
return this.transform(vector, result);
}
/** @deprecated */
transformVector3(vector, result) {
return this.transform(vector, result);
}
};
var ZERO_MATRIX3;
var IDENTITY_MATRIX3 = null;
function getZeroMatrix() {
if (!ZERO_MATRIX3) {
ZERO_MATRIX3 = new Matrix3([0, 0, 0, 0, 0, 0, 0, 0, 0]);
Object.freeze(ZERO_MATRIX3);
}
return ZERO_MATRIX3;
}
function getIdentityMatrix() {
if (!IDENTITY_MATRIX3) {
IDENTITY_MATRIX3 = new Matrix3();
Object.freeze(IDENTITY_MATRIX3);
}
return IDENTITY_MATRIX3;
}
// ../../node_modules/@math.gl/core/dist/gl-matrix/mat4.js
var mat4_exports = {};
__export(mat4_exports, {
add: () => add2,
adjoint: () => adjoint,
clone: () => clone2,
copy: () => copy2,
create: () => create4,
decompose: () => decompose,
determinant: () => determinant2,
equals: () => equals3,
exactEquals: () => exactEquals2,
frob: () => frob,
fromQuat: () => fromQuat3,
fromQuat2: () => fromQuat2,
fromRotation: () => fromRotation,
fromRotationTranslation: () => fromRotationTranslation,
fromRotationTranslationScale: () => fromRotationTranslationScale,
fromRotationTranslationScaleOrigin: () => fromRotationTranslationScaleOrigin,
fromScaling: () => fromScaling,
fromTranslation: () => fromTranslation,
fromValues: () => fromValues2,
fromXRotation: () => fromXRotation,
fromYRotation: () => fromYRotation,
fromZRotation: () => fromZRotation,
frustum: () => frustum,
getRotation: () => getRotation,
getScaling: () => getScaling,
getTranslation: () => getTranslation,
identity: () => identity,
invert: () => invert2,
lookAt: () => lookAt,
mul: () => mul2,
multiply: () => multiply3,
multiplyScalar: () => multiplyScalar,
multiplyScalarAndAdd: () => multiplyScalarAndAdd,
ortho: () => ortho,
orthoNO: () => orthoNO,
orthoZO: () => orthoZO,
perspective: () => perspective,
perspectiveFromFieldOfView: () => perspectiveFromFieldOfView,
perspectiveNO: () => perspectiveNO,
perspectiveZO: () => perspectiveZO,
rotate: () => rotate2,
rotateX: () => rotateX2,
rotateY: () => rotateY2,
rotateZ: () => rotateZ2,
scale: () => scale3,
set: () => set2,
str: () => str2,
sub: () => sub2,
subtract: () => subtract2,
targetTo: () => targetTo,
translate: () => translate2,
transpose: () => transpose2
});
function create4() {
const out = new ARRAY_TYPE(16);
if (ARRAY_TYPE != Float32Array) {
out[1] = 0;
out[2] = 0;
out[3] = 0;
out[4] = 0;
out[6] = 0;
out[7] = 0;
out[8] = 0;
out[9] = 0;
out[11] = 0;
out[12] = 0;
out[13] = 0;
out[14] = 0;
}
out[0] = 1;
out[5] = 1;
out[10] = 1;
out[15] = 1;
return out;
}
function clone2(a) {
const out = new ARRAY_TYPE(16);
out[0] = a[0];
out[1] = a[1];
out[2] = a[2];
out[3] = a[3];
out[4] = a[4];
out[5] = a[5];
out[6] = a[6];
out[7] = a[7];
out[8] = a[8];
out[9] = a[9];
out[10] = a[10];
out[11] = a[11];
out[12] = a[12];
out[13] = a[13];
out[14] = a[14];
out[15] = a[15];
return out;
}
function copy2(out, a) {
out[0] = a[0];
out[1] = a[1];
out[2] = a[2];
out[3] = a[3];
out[4] = a[4];
out[5] = a[5];
out[6] = a[6];
out[7] = a[7];
out[8] = a[8];
out[9] = a[9];
out[10] = a[10];
out[11] = a[11];
out[12] = a[12];
out[13] = a[13];
out[14] = a[14];
out[15] = a[15];
return out;
}
function fromValues2(m00, m01, m02, m03, m10, m11, m12, m13, m20, m21, m22, m23, m30, m31, m32, m33) {
const out = new ARRAY_TYPE(16);
out[0] = m00;
out[1] = m01;
out[2] = m02;
out[3] = m03;
out[4] = m10;
out[5] = m11;
out[6] = m12;
out[7] = m13;
out[8] = m20;
out[9] = m21;
out[10] = m22;
out[11] = m23;
out[12] = m30;
out[13] = m31;
out[14] = m32;
out[15] = m33;
return out;
}
function set2(out, m00, m01, m02, m03, m10, m11, m12, m13, m20, m21, m22, m23, m30, m31, m32, m33) {
out[0] = m00;
out[1] = m01;
out[2] = m02;
ou