@pirireis/webglobeplugins 0.9.8 → 0.9.9

package/dist/Math/juction/line-sphere.js

@@ -1,25 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.lineSphereIntersection = lineSphereIntersection;
-const vec3_1 = require("../vec3");
-const line_1 = require("../line");
-const _0vector = /*@__PURE__*/ vec3_1.vec3.create(0, 0, 0);
-function lineSphereIntersection(out, inLine, inSphere) {
-    vec3_1.vec3.subtract(_0vector, inLine.origin, inSphere.center);
-    const distanceSquared = vec3_1.vec3.lengthSquared(_0vector);
-    const radiusSquared = inSphere.radius * inSphere.radius;
-    const dot = vec3_1.vec3.dot(_0vector, inLine.direction);
-    const dotSquared = dot * dot;
-    const _a = dotSquared + radiusSquared - distanceSquared;
-    if (_a < 0) {
-        return false; // no intersection
-    }
-    else {
-        const a = Math.sqrt(_a);
-        const t1 = dot - a;
-        const t2 = dot + a;
-        line_1.line.at(out[0], inLine, t1);
-        line_1.line.at(out[1], inLine, t2);
-        return true;
-    }
-}

package/dist/Math/juction/plane-plane.js

@@ -1,58 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.planePlaneJuction = planePlaneJuction;
-const constants_1 = require("../constants");
-const vec3_1 = require("../vec3");
-const _normal1 = vec3_1.vec3.create();
-const _normal2 = vec3_1.vec3.create();
-function planePlaneJuction(out, plane1, plane2) {
-    vec3_1.vec3.copy(_normal1, plane1.normal);
-    vec3_1.vec3.copy(_normal2, plane2.normal);
-    const distance1 = plane1.distance;
-    const distance2 = plane2.distance;
-    const { origin, direction } = out;
-    const dot = vec3_1.vec3.dot(_normal1, _normal2);
-    if (Math.abs(dot) > 1 - constants_1.EPSILON) {
-        return false; // Planes are parallel, no intersection
-    }
-    vec3_1.vec3.cross(direction, _normal1, _normal2);
-    const magnitudeSquired = vec3_1.vec3.lengthSquared(out.direction);
-    if (magnitudeSquired < constants_1.EPSILON) {
-        return false; // No valid intersection line
-    }
-    const magnitude = Math.sqrt(magnitudeSquired);
-    direction[0] /= magnitude;
-    direction[1] /= magnitude;
-    direction[2] /= magnitude;
-    let determinant;
-    // Calculate the intersection point
-    // set z = 0
-    determinant = _normal1[0] * _normal2[1] - _normal1[1] * _normal2[0];
-    if (Math.abs(determinant) > constants_1.EPSILON) {
-        origin[0] = (distance1 * _normal2[1] - distance2 * _normal1[1]) / determinant;
-        origin[1] = (distance2 * _normal1[0] - distance1 * _normal2[0]) / determinant;
-        origin[2] = 0;
-    }
-    else {
-        // set y = 0
-        determinant = _normal1[0] * _normal2[2] - _normal1[2] * _normal2[0];
-        if (Math.abs(determinant) > constants_1.EPSILON) {
-            origin[0] = (distance1 * _normal2[2] - distance2 * _normal1[2]) / determinant;
-            origin[1] = 0;
-            origin[2] = (distance2 * _normal1[0] - distance1 * _normal2[0]) / determinant;
-        }
-        else {
-            // set x = 0
-            determinant = _normal1[1] * _normal2[2] - _normal1[2] * _normal2[1];
-            if (Math.abs(determinant) > constants_1.EPSILON) {
-                origin[0] = 0;
-                origin[1] = (distance1 * _normal2[2] - distance2 * _normal1[2]) / determinant;
-                origin[2] = (distance2 * _normal1[1] - distance1 * _normal2[1]) / determinant;
-            }
-            else {
-                return false; // No valid intersection point
-            }
-        }
-    }
-    return true;
-}

package/dist/Math/line.js

@@ -1,56 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.line = void 0;
-const constants_1 = require("./constants");
-const vec3_1 = require("./vec3");
-const _0vector = /*@__PURE__*/ vec3_1.vec3.create(0, 0, 0);
-exports.line = Object.freeze({
-    create(origin = vec3_1.vec3.create(), direction = vec3_1.vec3.create()) {
-        const direction_ = vec3_1.vec3.clone(direction);
-        vec3_1.vec3.normalize(direction_, direction_);
-        return {
-            origin: vec3_1.vec3.clone(origin),
-            direction: direction_
-        };
-    },
-    set(out, origin, direction) {
-        vec3_1.vec3.copy(out.origin, origin);
-        vec3_1.vec3.copy(out.direction, direction);
-    },
-    copy(out, a) {
-        out.origin = vec3_1.vec3.copy(out.origin, a.origin);
-        out.direction = vec3_1.vec3.copy(out.direction, a.direction);
-    },
-    clone(a) {
-        return {
-            origin: vec3_1.vec3.clone(a.origin),
-            direction: vec3_1.vec3.clone(a.direction)
-        };
-    },
-    fromTwoPoints(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(out, line, distance) {
-        vec3_1.vec3.multiplyScalar(_0vector, line.direction, distance);
-        vec3_1.vec3.add(out, _0vector, line.origin);
-    },
-    closestPoint(out, line, point) {
-        vec3_1.vec3.subtract(_0vector, point, line.origin);
-        const 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(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(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/dist/Math/matrix4.js

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

package/dist/Math/methods.js

@@ -1,201 +0,0 @@
-"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;
-const constants_ts_1 = require("./constants.ts");
-/**
- * @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 **********************
-// *********************************************************
-const RADIANS = Math.PI / 180;
-exports.RADIANS = RADIANS;
-/**
- * @param {vec3} a
- * @returns {vec3}
- */
-const normalize3 = (a) => {
-    const len = length3(a);
-    return [a[0] / len, a[1] / len, a[2] / len];
-};
-exports.normalize3 = normalize3;
-/**
- * @param {vec3} a
- * @param {vec3} b
- * @returns {number}
- */
-const dot3 = (a, b) => {
-    return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
-};
-exports.dot3 = dot3;
-/**
- * @param {vec3} a
- * @returns {number}
- */
-const length3 = (a) => {
-    return Math.sqrt(dot3(a, a));
-};
-exports.length3 = length3;
-// *********************************************************
-// **************** TRANSFORMATIONS ************************
-// *********************************************************
-/**
- * @param {vec3} cartesian
- * @returns {vec2} long lat in radians
- */
-const cartesian3dToRadian = (cartesian) => {
-    const x = cartesian[0];
-    const y = cartesian[1];
-    const z = cartesian[2];
-    // const length = Math.sqrt(x * x + y * y + z * z);
-    const long = Math.atan2(y, x);
-    const 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
- */
-const radianToMercator = (xy) => {
-    return [constants_ts_1.WORLD_RADIUS_MERCATOR * xy[0], constants_ts_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
- */
-const radianToCartesian3d = (xy) => {
-    const x = Math.cos(xy[1]) * Math.cos(xy[0]);
-    const y = Math.cos(xy[1]) * Math.sin(xy[0]);
-    const z = -Math.sin(xy[1]);
-    return [x, y, z];
-};
-exports.radianToCartesian3d = radianToCartesian3d;
-// *********************************************************
-// ***************** INTERPOLATIONS ************************
-// *********************************************************
-/**
- * @param {vec3} normalizedA
- * @param {vec3} normalizedB
- * @param {fraction} ratio
- * @returns {vec3}
- */
-const sphericalLinearInterpolation_UnitVector = (normalizedA, normalizedB, ratio) => {
-    const theta = Math.acos(dot3(normalizedA, normalizedB));
-    if (theta < 0.000001)
-        return normalizedA; // CALIBRATE?
-    const sinTheta = Math.sin(theta);
-    const 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
- */
-const sphericalLinearInterpolation_Mercator = (normalizedA, normalizedB, ratio) => {
-    const unitVector = sphericalLinearInterpolation_UnitVector(normalizedA, normalizedB, ratio);
-    const 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
- */
-const sphericalLinearInterpolation_Cartesian3d = (a, b, ratio) => {
-    const unitVector = sphericalLinearInterpolation_UnitVector(a, b, ratio);
-    const 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}
- */
-const wgs84ToUnitVector = (coordinates) => {
-    const long = coordinates[0] * RADIANS;
-    const lat = coordinates[1] * RADIANS;
-    const x = Math.cos(lat) * Math.cos(long);
-    const y = Math.cos(lat) * Math.sin(long);
-    const 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
- */
-const wgs84ToCartesian3d = (long, lat, height) => {
-    const longRad = long * RADIANS;
-    const latRad = lat * RADIANS;
-    const x = Math.cos(latRad) * Math.cos(longRad);
-    const y = Math.cos(latRad) * Math.sin(longRad);
-    const z = Math.sin(latRad);
-    const radius = constants_ts_1.WORLD_RADIUS_3D + height;
-    return [x * radius, y * radius, z * radius];
-};
-exports.wgs84ToCartesian3d = wgs84ToCartesian3d;
-/**
- * @param {number} long
- * @param {number} lat
- * @returns {vec2} mercator
- */
-const wgs84ToMercator = (long, lat) => {
-    return [constants_ts_1.WORLD_RADIUS_MERCATOR * long * RADIANS, constants_ts_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
- */
-const pixelXYToRadians = (pixelXY) => {
-    const long = (2.0 * pixelXY[0] - 1.0) * Math.PI;
-    const lat = (2.0 * pixelXY[1] - 1.0) * Math.PI / 2.0;
-    return [long, lat];
-};
-const pixelXYLenghtToUnitVectorWithHeight = (pixelXYHeight) => {
-    const [long, lat] = pixelXYToRadians(pixelXYHeight);
-    const radius = constants_ts_1.WORLD_RADIUS_3D + pixelXYHeight[2];
-    return radianToCartesian3d([long, lat]).concat(radius);
-};
-exports.pixelXYLenghtToUnitVectorWithHeight = pixelXYLenghtToUnitVectorWithHeight;
-const globe3Dcoordinates = (globe, height = 0) => (longlats, { paddingCount = 0, paddingValue = NaN }) => {
-    const len = longlats.length / 2;
-    const result = new Float32Array(len * 3 + paddingCount * 3).fill(paddingValue);
-    for (let i = 0; i < len; i++) {
-        const long = longlats[i * 2];
-        const lat = longlats[i * 2 + 1];
-        const xyz = globe.api_GetCartesian3DPoint(long, lat, height, 0);
-        result.set(xyz, i * 3);
-    }
-    return result;
-};
-exports.globe3Dcoordinates = globe3Dcoordinates;
-const globe2Dcoordinates = (globe) => (longlats, { paddingCount = 0, paddingValue = NaN }) => {
-    const len = longlats.length / 2;
-    const result = new Float32Array(len * 2 + paddingCount * 2).fill(paddingValue);
-    for (let i = 0; i < len; i++) {
-        const long = longlats[i * 2];
-        const lat = longlats[i * 2 + 1];
-        const xyz = globe.api_GetMercator2DPoint(long, lat);
-        result.set(xyz, i * 2);
-    }
-    return result;
-};
-exports.globe2Dcoordinates = globe2Dcoordinates;

package/dist/Math/plane.js

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

package/dist/Math/quaternion.js

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

package/dist/Math/types.js

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

package/dist/Math/utils.js

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

package/dist/Math/vec3.js

@@ -1,126 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.vec3 = void 0;
-const constants_1 = require("./constants");
-exports.vec3 = Object.freeze({
-    create(x = 0, y = 0, z = 1) {
-        return [x, y, z];
-    },
-    set(out, x, y, z) {
-        out[0] = x;
-        out[1] = y;
-        out[2] = z;
-    },
-    clone(a) {
-        return [a[0], a[1], a[2]];
-    },
-    copy(out, a) {
-        out[0] = a[0];
-        out[1] = a[1];
-        out[2] = a[2];
-        return out;
-    },
-    add(out, a, b) {
-        out[0] = a[0] + b[0];
-        out[1] = a[1] + b[1];
-        out[2] = a[2] + b[2];
-        return out;
-    },
-    subtract(out, a, b) {
-        out[0] = a[0] - b[0];
-        out[1] = a[1] - b[1];
-        out[2] = a[2] - b[2];
-    },
-    dot(a, b) {
-        return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
-    },
-    cross(out, a, b) {
-        const x = a[1] * b[2] - a[2] * b[1];
-        const y = a[2] * b[0] - a[0] * b[2];
-        const z = a[0] * b[1] - a[1] * b[0];
-        out[0] = x;
-        out[1] = y;
-        out[2] = z;
-    },
-    multiplyScalar(out, a, b) {
-        out[0] = a[0] * b;
-        out[1] = a[1] * b;
-        out[2] = a[2] * b;
-    },
-    divideScalar(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(a) {
-        return a[0] * a[0] + a[1] * a[1] + a[2] * a[2];
-    },
-    length(a) {
-        return Math.sqrt(this.lengthSquared(a));
-    },
-    normalize(outVec, inVec) {
-        const 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(a, b) {
-        const dx = a[0] - b[0];
-        const dy = a[1] - b[1];
-        const dz = a[2] - b[2];
-        return dx * dx + dy * dy + dz * dz;
-    },
-    distance(a, b) {
-        return Math.sqrt(this.distanceSquared(a, b));
-    },
-    equals(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(out, a) {
-        const 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(out, longLat) {
-        const longitude = longLat[0];
-        const latitude = longLat[1];
-        const cosLat = Math.cos(latitude);
-        out[0] = cosLat * Math.cos(longitude);
-        out[1] = cosLat * Math.sin(longitude);
-        out[2] = Math.sin(latitude);
-    },
-    applyQuaternion(out, a, q) {
-        const x = a[0], y = a[1], z = a[2];
-        const qx = q[0], qy = q[1], qz = q[2], qw = q[3];
-        // Calculate the quaternion multiplication
-        const ix = qw * x + qy * z - qz * y;
-        const iy = qw * y + qz * x - qx * z;
-        const iz = qw * z + qx * y - qy * x;
-        const 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(out) {
-        const theta = Math.random() * 2 * Math.PI;
-        const 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(a) {
-        return `Vec3(${a[0].toFixed(2)}, ${a[1].toFixed(2)}, ${a[2].toFixed(2)})`;
-    }
-});

package/dist/algorithms/search-binary.js

@@ -1,19 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.findFirstIndexInRange = void 0;
-const findFirstIndexInRange = (container, value) => {
-    let start = 0;
-    let end = container.length - 1;
-    let 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/dist/altitude-locator/adaptors.js

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

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

@@ -1,18 +0,0 @@
-"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.
-class DrawSubsetOptionRegistry {
-    constructor() {
-        this._drawSubsetOptions = new Map();
-    }
-    register(key, drawSubsetOptions) {
-        this._drawSubsetOptions.set(key, drawSubsetOptions);
-    }
-    unregister(key) {
-        this._drawSubsetOptions.delete(key);
-    }
-}