@pirireis/webglobeplugins 0.9.9 → 0.9.11

package/Math/line.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.line = void 0;
+var constants_1 = require("./constants");
+var vec3_1 = require("./vec3");
+var _0vector = /*@__PURE__*/ vec3_1.vec3.create(0, 0, 0);
+exports.line = Object.freeze({
+    create: function (origin, direction) {
+        if (origin === void 0) { origin = vec3_1.vec3.create(); }
+        if (direction === void 0) { direction = vec3_1.vec3.create(); }
+        var direction_ = vec3_1.vec3.clone(direction);
+        vec3_1.vec3.normalize(direction_, direction_);
+        return {
+            origin: vec3_1.vec3.clone(origin),
+            direction: direction_
+        };
+    },
+    set: function (out, origin, direction) {
+        vec3_1.vec3.copy(out.origin, origin);
+        vec3_1.vec3.copy(out.direction, direction);
+    },
+    copy: function (out, a) {
+        out.origin = vec3_1.vec3.copy(out.origin, a.origin);
+        out.direction = vec3_1.vec3.copy(out.direction, a.direction);
+    },
+    clone: function (a) {
+        return {
+            origin: vec3_1.vec3.clone(a.origin),
+            direction: vec3_1.vec3.clone(a.direction)
+        };
+    },
+    fromTwoPoints: function (out, a, b) {
+        vec3_1.vec3.subtract(out.direction, b, a);
+        vec3_1.vec3.normalize(out.direction, out.direction);
+        vec3_1.vec3.copy(out.origin, a);
+    },
+    at: function (out, line, distance) {
+        vec3_1.vec3.multiplyScalar(_0vector, line.direction, distance);
+        vec3_1.vec3.add(out, _0vector, line.origin);
+    },
+    closestPoint: function (out, line, point) {
+        vec3_1.vec3.subtract(_0vector, point, line.origin);
+        var dot = vec3_1.vec3.dot(_0vector, line.direction);
+        vec3_1.vec3.copy(out, line.direction);
+        vec3_1.vec3.multiplyScalar(out, out, dot);
+        vec3_1.vec3.add(out, out, line.origin);
+    },
+    contains: function (line, point) {
+        vec3_1.vec3.subtract(_0vector, point, line.origin);
+        vec3_1.vec3.cross(_0vector, _0vector, line.direction);
+        return vec3_1.vec3.lengthSquared(_0vector) < constants_1.EPSILON;
+    },
+    applyQuaternion: function (out, line, quaternion) {
+        vec3_1.vec3.applyQuaternion(out.origin, line.origin, quaternion);
+        vec3_1.vec3.applyQuaternion(out.direction, line.direction, quaternion);
+        vec3_1.vec3.normalize(out.direction, out.direction);
+    }
+});

package/Math/matrix4.js

@@ -0,0 +1 @@
+"use strict";

package/Math/methods.js

@@ -0,0 +1,206 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.globe2Dcoordinates = exports.globe3Dcoordinates = exports.pixelXYLenghtToUnitVectorWithHeight = exports.wgs84ToMercator = exports.wgs84ToCartesian3d = exports.wgs84ToUnitVector = exports.sphericalLinearInterpolation_Cartesian3d = exports.sphericalLinearInterpolation_Mercator = exports.sphericalLinearInterpolation_UnitVector = exports.radianToCartesian3d = exports.radianToMercator = exports.cartesian3dToRadian = exports.length3 = exports.dot3 = exports.normalize3 = exports.RADIANS = void 0;
+var constants_1 = require("./constants");
+/**
+ * @typedef {Array<number>} vec3 [x, y, z]
+ * @typedef {Array<number>} vec2 [x, y]
+ * @typedef {Array<number>} vec4 [x, y, z, w]
+ * @typedef {number} fraction a number between 0 and 1
+ * @typedef {Array<number>} wgs84 [long, lat]
+ */
+// *********************************************************
+// **************** VECTOR OPERATIONS **********************
+// *********************************************************
+var RADIANS = Math.PI / 180;
+exports.RADIANS = RADIANS;
+/**
+ * @param {vec3} a
+ * @returns {vec3}
+ */
+var normalize3 = function (a) {
+    var len = length3(a);
+    return [a[0] / len, a[1] / len, a[2] / len];
+};
+exports.normalize3 = normalize3;
+/**
+ * @param {vec3} a
+ * @param {vec3} b
+ * @returns {number}
+ */
+var dot3 = function (a, b) {
+    return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+};
+exports.dot3 = dot3;
+/**
+ * @param {vec3} a
+ * @returns {number}
+ */
+var length3 = function (a) {
+    return Math.sqrt(dot3(a, a));
+};
+exports.length3 = length3;
+// *********************************************************
+// **************** TRANSFORMATIONS ************************
+// *********************************************************
+/**
+ * @param {vec3} cartesian
+ * @returns {vec2} long lat in radians
+ */
+var cartesian3dToRadian = function (cartesian) {
+    var x = cartesian[0];
+    var y = cartesian[1];
+    var z = cartesian[2];
+    // const length = Math.sqrt(x * x + y * y + z * z);
+    var long = Math.atan2(y, x);
+    var lat = Math.asin(z); // length);
+    return [long, lat];
+};
+exports.cartesian3dToRadian = cartesian3dToRadian;
+/**
+ * @param {vec2} xy long lat in radians
+ * @returns {vec2} long lat in mercator meters
+ */
+var radianToMercator = function (xy) {
+    return [constants_1.WORLD_RADIUS_MERCATOR * xy[0], constants_1.WORLD_RADIUS_MERCATOR * Math.log(Math.tan(Math.PI / 4 + xy[1] / 2))];
+};
+exports.radianToMercator = radianToMercator;
+/**
+ * @param {vec2} xy long lat radians
+ * @returns {vec3} cartesian
+ */
+var radianToCartesian3d = function (xy) {
+    var x = Math.cos(xy[1]) * Math.cos(xy[0]);
+    var y = Math.cos(xy[1]) * Math.sin(xy[0]);
+    var z = -Math.sin(xy[1]);
+    return [x, y, z];
+};
+exports.radianToCartesian3d = radianToCartesian3d;
+// *********************************************************
+// ***************** INTERPOLATIONS ************************
+// *********************************************************
+/**
+ * @param {vec3} normalizedA
+ * @param {vec3} normalizedB
+ * @param {fraction} ratio
+ * @returns {vec3}
+ */
+var sphericalLinearInterpolation_UnitVector = function (normalizedA, normalizedB, ratio) {
+    var theta = Math.acos(dot3(normalizedA, normalizedB));
+    if (theta < 0.000001)
+        return normalizedA; // CALIBRATE?
+    var sinTheta = Math.sin(theta);
+    var result = [
+        (Math.sin((1.0 - ratio) * theta) * normalizedA[0] + Math.sin(ratio * theta) * normalizedB[0]) / sinTheta,
+        (Math.sin((1.0 - ratio) * theta) * normalizedA[1] + Math.sin(ratio * theta) * normalizedB[1]) / sinTheta,
+        (Math.sin((1.0 - ratio) * theta) * normalizedA[2] + Math.sin(ratio * theta) * normalizedB[2]) / sinTheta
+    ];
+    return result;
+};
+exports.sphericalLinearInterpolation_UnitVector = sphericalLinearInterpolation_UnitVector;
+/**
+ * @param {vec3} normalizedA
+ * @param {vec3} normalizedB
+ * @param {fraction} ratio
+ * @returns
+ */
+var sphericalLinearInterpolation_Mercator = function (normalizedA, normalizedB, ratio) {
+    var unitVector = sphericalLinearInterpolation_UnitVector(normalizedA, normalizedB, ratio);
+    var angles = cartesian3dToRadian(unitVector);
+    return radianToMercator(angles);
+};
+exports.sphericalLinearInterpolation_Mercator = sphericalLinearInterpolation_Mercator;
+/**
+ * @param {vec4} a vec3 unit vector and length
+ * @param {vec4} b vec3 unit vector and length
+ * @param {fraction} ratio
+ */
+var sphericalLinearInterpolation_Cartesian3d = function (a, b, ratio) {
+    var unitVector = sphericalLinearInterpolation_UnitVector(a, b, ratio);
+    var height = a[3] + (b[3] - a[3]) * ratio;
+    return [unitVector[0] * height, unitVector[1] * height, unitVector[2] * height];
+};
+exports.sphericalLinearInterpolation_Cartesian3d = sphericalLinearInterpolation_Cartesian3d;
+/**
+ *
+ * @param {wgs84} coordinates
+ * @returns {vec3}
+ */
+var wgs84ToUnitVector = function (coordinates) {
+    var long = coordinates[0] * RADIANS;
+    var lat = coordinates[1] * RADIANS;
+    var x = Math.cos(lat) * Math.cos(long);
+    var y = Math.cos(lat) * Math.sin(long);
+    var z = Math.sin(lat);
+    return [x, y, z];
+};
+exports.wgs84ToUnitVector = wgs84ToUnitVector;
+/**
+ * @param {number} long wgs84
+ * @param {number} lat wgs84
+ * @param {number} height
+ * @returns {vec3} cartesian3D
+ */
+var wgs84ToCartesian3d = function (long, lat, height) {
+    var longRad = long * RADIANS;
+    var latRad = lat * RADIANS;
+    var x = Math.cos(latRad) * Math.cos(longRad);
+    var y = Math.cos(latRad) * Math.sin(longRad);
+    var z = Math.sin(latRad);
+    var radius = constants_1.WORLD_RADIUS_3D + height;
+    return [x * radius, y * radius, z * radius];
+};
+exports.wgs84ToCartesian3d = wgs84ToCartesian3d;
+/**
+ * @param {number} long
+ * @param {number} lat
+ * @returns {vec2} mercator
+ */
+var wgs84ToMercator = function (long, lat) {
+    return [constants_1.WORLD_RADIUS_MERCATOR * long * RADIANS, constants_1.WORLD_RADIUS_MERCATOR * Math.log(Math.tan(Math.PI / 4 + lat * RADIANS / 2))];
+};
+exports.wgs84ToMercator = wgs84ToMercator;
+/**
+ * @param {vec2} pixelXY
+ * @returns {vec2} long lat in radians
+ */
+var pixelXYToRadians = function (pixelXY) {
+    var long = (2.0 * pixelXY[0] - 1.0) * Math.PI;
+    var lat = (2.0 * pixelXY[1] - 1.0) * Math.PI / 2.0;
+    return [long, lat];
+};
+var pixelXYLenghtToUnitVectorWithHeight = function (pixelXYHeight) {
+    var _a = pixelXYToRadians(pixelXYHeight), long = _a[0], lat = _a[1];
+    var radius = constants_1.WORLD_RADIUS_3D + pixelXYHeight[2];
+    return radianToCartesian3d([long, lat]).concat(radius);
+};
+exports.pixelXYLenghtToUnitVectorWithHeight = pixelXYLenghtToUnitVectorWithHeight;
+var globe3Dcoordinates = function (globe, height) {
+    if (height === void 0) { height = 0; }
+    return function (longlats, _a) {
+        var _b = _a.paddingCount, paddingCount = _b === void 0 ? 0 : _b, _c = _a.paddingValue, paddingValue = _c === void 0 ? NaN : _c;
+        var len = longlats.length / 2;
+        var result = new Float32Array(len * 3 + paddingCount * 3).fill(paddingValue);
+        for (var i = 0; i < len; i++) {
+            var long = longlats[i * 2];
+            var lat = longlats[i * 2 + 1];
+            var xyz = globe.api_GetCartesian3DPoint(long, lat, height, 0);
+            result.set(xyz, i * 3);
+        }
+        return result;
+    };
+};
+exports.globe3Dcoordinates = globe3Dcoordinates;
+var globe2Dcoordinates = function (globe) { return function (longlats, _a) {
+    var _b = _a.paddingCount, paddingCount = _b === void 0 ? 0 : _b, _c = _a.paddingValue, paddingValue = _c === void 0 ? NaN : _c;
+    var len = longlats.length / 2;
+    var result = new Float32Array(len * 2 + paddingCount * 2).fill(paddingValue);
+    for (var i = 0; i < len; i++) {
+        var long = longlats[i * 2];
+        var lat = longlats[i * 2 + 1];
+        var xyz = globe.api_GetMercator2DPoint(long, lat);
+        result.set(xyz, i * 2);
+    }
+    return result;
+}; };
+exports.globe2Dcoordinates = globe2Dcoordinates;

package/Math/plane.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.plane = void 0;
+var constants_1 = require("./constants");
+var vec3_1 = require("./vec3");
+var _0vector = /*@__PURE__*/ vec3_1.vec3.create(0, 0, 0);
+var _1vector = /*@__PURE__*/ vec3_1.vec3.create(1, 1, 1);
+exports.plane = Object.freeze({
+    create: function (normal, distance) {
+        if (normal === void 0) { normal = vec3_1.vec3.create(); }
+        if (distance === void 0) { distance = 0; }
+        return {
+            normal: vec3_1.vec3.clone(normal),
+            distance: distance
+        };
+    },
+    set: function (out, normal, distance) {
+        vec3_1.vec3.copy(out.normal, normal);
+        out.distance = distance;
+        return out;
+    },
+    fromValues: function (out, nx, ny, nz, distance) {
+        vec3_1.vec3.set(out.normal, nx, ny, nz);
+        out.distance = distance;
+    },
+    copy: function (out, a) {
+        vec3_1.vec3.copy(out.normal, a.normal);
+        out.distance = a.distance;
+        return out;
+    },
+    clone: function (a) {
+        return {
+            normal: vec3_1.vec3.clone(a.normal),
+            distance: a.distance
+        };
+    },
+    distanceToPoint: function (plane, point) {
+        return vec3_1.vec3.dot(plane.normal, point) - plane.distance;
+    },
+    projectPoint: function (out, plane, point) {
+        var distance = this.distanceToPoint(plane, point);
+        vec3_1.vec3.multiplyScalar(out, plane.normal, distance);
+        vec3_1.vec3.subtract(out, point, out);
+    },
+    equals: function (plane, other) {
+        return vec3_1.vec3.equals(plane.normal, other.normal) && Math.abs(plane.distance - other.distance) < constants_1.EPSILON;
+    },
+    fromNormalAndCoplanarPoint: function (out, normal, point) {
+        vec3_1.vec3.copy(out.normal, normal);
+        out.distance = vec3_1.vec3.dot(point, normal);
+    },
+    fromPoints: function (out, a, b, c) {
+        vec3_1.vec3.subtract(_0vector, b, a);
+        vec3_1.vec3.subtract(_1vector, c, a);
+        vec3_1.vec3.cross(out.normal, _0vector, _1vector);
+        vec3_1.vec3.normalize(out.normal, out.normal);
+        out.distance = vec3_1.vec3.dot(out.normal, a);
+    },
+    getUnitSphereRadiusAngle: function (plane) {
+        return Math.acos(Math.max(Math.min(plane.distance, 1), -1));
+    }
+});

package/Math/quaternion.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.quaternion = void 0;
+var vec3_1 = require("./vec3");
+var constants_1 = require("./constants");
+exports.quaternion = Object.freeze({
+    create: function (x, y, z, w) {
+        if (x === void 0) { x = 0; }
+        if (y === void 0) { y = 0; }
+        if (z === void 0) { z = 0; }
+        if (w === void 0) { w = 1; }
+        return [x, y, z, w];
+    },
+    set: function (out, x, y, z, w) {
+        out[0] = x;
+        out[1] = y;
+        out[2] = z;
+        out[3] = w;
+    },
+    copy: function (out, a) {
+        out[0] = a[0];
+        out[1] = a[1];
+        out[2] = a[2];
+        out[3] = a[3];
+    },
+    clone: function (a) {
+        return [a[0], a[1], a[2], a[3]];
+    },
+    multiply: function (out, a, b) {
+        var x = a[0] * b[3] + a[3] * b[0] + a[1] * b[2] - a[2] * b[1];
+        var y = a[1] * b[3] + a[3] * b[1] + a[2] * b[0] - a[0] * b[2];
+        var z = a[2] * b[3] + a[3] * b[2] + a[0] * b[1] - a[1] * b[0];
+        var w = a[3] * b[3] - a[0] * b[0] - a[1] * b[1] - a[2] * b[2];
+        this.set(out, x, y, z, w);
+        return out;
+    },
+    randomUnit: function (out) {
+        var u1 = Math.random();
+        var u2 = Math.random();
+        var u3 = Math.random();
+        var sqrt1MinusU1 = Math.sqrt(1 - u1);
+        var sqrtU1 = Math.sqrt(u1);
+        var x = sqrt1MinusU1 * Math.sin(2 * Math.PI * u2);
+        var y = sqrt1MinusU1 * Math.cos(2 * Math.PI * u2);
+        var z = sqrtU1 * Math.sin(2 * Math.PI * u3);
+        var w = sqrtU1 * Math.cos(2 * Math.PI * u3);
+        this.set(out, x, y, z, w);
+        this.normalize(out, out);
+        return out;
+    },
+    rotateQuaternion: function (out, a, b) {
+        var x = a[0] * b[3] + a[3] * b[0] + a[1] * b[2] - a[2] * b[1];
+        var y = a[1] * b[3] + a[3] * b[1] + a[2] * b[0] - a[0] * b[2];
+        var z = a[2] * b[3] + a[3] * b[2] + a[0] * b[1] - a[1] * b[0];
+        var w = a[3] * b[3] - a[0] * b[0] - a[1] * b[1] - a[2] * b[2];
+        this.set(out, x, y, z, w);
+        this.normalize(out, out);
+    },
+    lengthSquared: function (a) {
+        return a[0] * a[0] + a[1] * a[1] + a[2] * a[2] + a[3] * a[3];
+    },
+    length: function (a) {
+        return Math.sqrt(this.lengthSquared(a));
+    },
+    normalize: function (out, input) {
+        var len = Math.sqrt(this.lengthSquared(input));
+        if (len < constants_1.EPSILON) {
+            this.set(out, 0, 0, 0, 1);
+        }
+        else {
+            var invLen = 1 / len;
+            this.set(out, input[0] * invLen, input[1] * invLen, input[2] * invLen, input[3] * invLen);
+        }
+    },
+    fromUnitVectors: function (out, from, to) {
+        var d = vec3_1.vec3.dot(from, to) + 1;
+        if (d < constants_1.EPSILON) {
+            if (Math.abs(from[0]) > Math.abs(from[2])) {
+                this.set(out, -from[1], from[0], 0, 0);
+            }
+            else {
+                this.set(out, 0, -from[2], from[1], 0);
+            }
+        }
+        else {
+            var x = from[1] * to[2] - from[2] * to[1];
+            var y = from[2] * to[0] - from[0] * to[2];
+            var z = from[0] * to[1] - from[1] * to[0];
+            this.set(out, x, y, z, d);
+        }
+    },
+    fromTwoQuaternions: function (out, from, to) {
+        var x = from[0] * to[3] + from[3] * to[0] + from[1] * to[2] - from[2] * to[1];
+        var y = from[1] * to[3] + from[3] * to[1] + from[2] * to[0] - from[0] * to[2];
+        var z = from[2] * to[3] + from[3] * to[2] + from[0] * to[1] - from[1] * to[0];
+        var w = from[3] * to[3] - from[0] * to[0] - from[1] * to[1] - from[2] * to[2];
+        this.set(out, x, y, z, w);
+        this.normalize(out, out);
+    },
+    conjugate: function (out, a) {
+        this.set(out, -a[0], -a[1], -a[2], a[3]);
+    },
+    fromAxisAngle: function (out, axis, angle) {
+        var halfAngle = angle / 2;
+        var s = Math.sin(halfAngle);
+        this.set(out, axis[0] * s, axis[1] * s, axis[2] * s, Math.cos(halfAngle));
+    },
+});

package/Math/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/Math/utils.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var vector3d_1 = require("./vector3d");
+var quaternion_1 = require("./quaternion");

package/Math/vec3.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.vec3 = void 0;
+var constants_1 = require("./constants");
+exports.vec3 = Object.freeze({
+    create: function (x, y, z) {
+        if (x === void 0) { x = 0; }
+        if (y === void 0) { y = 0; }
+        if (z === void 0) { z = 1; }
+        return [x, y, z];
+    },
+    set: function (out, x, y, z) {
+        out[0] = x;
+        out[1] = y;
+        out[2] = z;
+    },
+    clone: function (a) {
+        return [a[0], a[1], a[2]];
+    },
+    copy: function (out, a) {
+        out[0] = a[0];
+        out[1] = a[1];
+        out[2] = a[2];
+        return out;
+    },
+    add: function (out, a, b) {
+        out[0] = a[0] + b[0];
+        out[1] = a[1] + b[1];
+        out[2] = a[2] + b[2];
+        return out;
+    },
+    subtract: function (out, a, b) {
+        out[0] = a[0] - b[0];
+        out[1] = a[1] - b[1];
+        out[2] = a[2] - b[2];
+    },
+    dot: function (a, b) {
+        return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+    },
+    cross: function (out, a, b) {
+        var x = a[1] * b[2] - a[2] * b[1];
+        var y = a[2] * b[0] - a[0] * b[2];
+        var z = a[0] * b[1] - a[1] * b[0];
+        out[0] = x;
+        out[1] = y;
+        out[2] = z;
+    },
+    multiplyScalar: function (out, a, b) {
+        out[0] = a[0] * b;
+        out[1] = a[1] * b;
+        out[2] = a[2] * b;
+    },
+    divideScalar: function (out, a, b) {
+        if (b === 0) {
+            throw new Error('Division by zero');
+        }
+        out[0] = a[0] / b;
+        out[1] = a[1] / b;
+        out[2] = a[2] / b;
+    },
+    lengthSquared: function (a) {
+        return a[0] * a[0] + a[1] * a[1] + a[2] * a[2];
+    },
+    length: function (a) {
+        return Math.sqrt(this.lengthSquared(a));
+    },
+    normalize: function (outVec, inVec) {
+        var len = this.length(inVec);
+        if (len === 0) {
+            throw new Error('Cannot normalize a zero vector');
+        }
+        outVec[0] = inVec[0] / len;
+        outVec[1] = inVec[1] / len;
+        outVec[2] = inVec[2] / len;
+    },
+    distanceSquared: function (a, b) {
+        var dx = a[0] - b[0];
+        var dy = a[1] - b[1];
+        var dz = a[2] - b[2];
+        return dx * dx + dy * dy + dz * dz;
+    },
+    distance: function (a, b) {
+        return Math.sqrt(this.distanceSquared(a, b));
+    },
+    equals: function (a, b) {
+        return (Math.abs(a[0] - b[0]) < constants_1.EPSILON &&
+            Math.abs(a[1] - b[1]) < constants_1.EPSILON &&
+            Math.abs(a[2] - b[2]) < constants_1.EPSILON);
+    },
+    toUnitVectorLongLat: function (out, a) {
+        var len = this.length(a); // TODO Might drop length check 
+        if (len === 0) {
+            throw new Error('Cannot convert a zero vector to unit vector');
+        }
+        out[0] = Math.atan2(a[1], a[0]); // Longitude
+        out[1] = Math.asin(a[2] / len); // Latitude
+    },
+    fromUnitVectorLongLat: function (out, longLat) {
+        var longitude = longLat[0];
+        var latitude = longLat[1];
+        var cosLat = Math.cos(latitude);
+        out[0] = cosLat * Math.cos(longitude);
+        out[1] = cosLat * Math.sin(longitude);
+        out[2] = Math.sin(latitude);
+    },
+    applyQuaternion: function (out, a, q) {
+        var x = a[0], y = a[1], z = a[2];
+        var qx = q[0], qy = q[1], qz = q[2], qw = q[3];
+        // Calculate the quaternion multiplication
+        var ix = qw * x + qy * z - qz * y;
+        var iy = qw * y + qz * x - qx * z;
+        var iz = qw * z + qx * y - qy * x;
+        var iw = -qx * x - qy * y - qz * z;
+        // Apply the quaternion to the vector
+        out[0] = ix * qw + iw * -qx + iy * -qz - iz * -qy;
+        out[1] = iy * qw + iw * -qy + iz * -qx - ix * -qz;
+        out[2] = iz * qw + iw * -qz + ix * -qy - iy * -qx;
+    },
+    randomUnit: function (out) {
+        var theta = Math.random() * 2 * Math.PI;
+        var phi = Math.acos(2 * Math.random() - 1);
+        out[0] = Math.sin(phi) * Math.cos(theta);
+        out[1] = Math.sin(phi) * Math.sin(theta);
+        out[2] = Math.cos(phi);
+    },
+    str: function (a) {
+        return "Vec3(".concat(a[0].toFixed(2), ", ").concat(a[1].toFixed(2), ", ").concat(a[2].toFixed(2), ")");
+    }
+});

package/algorithms/search-binary.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findFirstIndexInRange = void 0;
+var findFirstIndexInRange = function (container, value) {
+    var start = 0;
+    var end = container.length - 1;
+    var mid = 0;
+    while (start <= end) {
+        mid = Math.floor((start + end) / 2);
+        if (container[mid] <= value && value <= container[mid + 1])
+            return mid;
+        if (container[mid] < value)
+            start = mid + 1;
+        else
+            end = mid - 1;
+    }
+    return null;
+};
+exports.findFirstIndexInRange = findFirstIndexInRange;

package/altitude-locator/adaptors.js

@@ -0,0 +1 @@
+"use strict";

package/altitude-locator/draw-subset-obj.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("./types");
+/**
+ * @param {DrawSubsetOptions} drawSubsetOptions
+ */
+// TODO: Draw all is an optional property for the target plugin, with this approach.
+var DrawSubsetOptionRegistry = /** @class */ (function () {
+    function DrawSubsetOptionRegistry() {
+        this._drawSubsetOptions = new Map();
+    }
+    DrawSubsetOptionRegistry.prototype.register = function (key, drawSubsetOptions) {
+        this._drawSubsetOptions.set(key, drawSubsetOptions);
+    };
+    DrawSubsetOptionRegistry.prototype.unregister = function (key) {
+        this._drawSubsetOptions.delete(key);
+    };
+    return DrawSubsetOptionRegistry;
+}());

package/altitude-locator/keymethod.js

@@ -0,0 +1 @@
+"use strict";