@pirireis/webglobeplugins 0.9.6 → 0.9.8

package/dist/Math/line.js

@@ -0,0 +1,56 @@
+"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

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

package/{Math → dist/Math}/methods.js

@@ -1,237 +1,201 @@
-
-import { WORLD_RADIUS_3D, WORLD_RADIUS_MERCATOR } from './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;
-
-
-/** 
- * @param {vec3} a 
- * @returns {vec3}
- */
-const normalize3 = (a) => {
-    const len = length3(a);
-    return [a[0] / len, a[1] / len, a[2] / len];
-}
-
-
-/**
- * @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];
-}
-
-
-/**
- * @param {vec3} a 
- * @returns {number}
- */
-const length3 = (a) => {
-    return Math.sqrt(dot3(a, a));
-}
-
-
-// *********************************************************
-// **************** 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];
-}
-
-
-/**
- * @param {vec2} xy long lat in radians
- * @returns {vec2} long lat in mercator meters
- */
-const radianToMercator = (xy) => {
-    return [WORLD_RADIUS_MERCATOR * xy[0], WORLD_RADIUS_MERCATOR * Math.log(Math.tan(Math.PI / 4 + xy[1] / 2))];
-}
-
-/**
- * @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];
-}
-
-
-// *********************************************************
-// ***************** 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;
-}
-
-
-/**
- * @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);
-}
-
-/**
- * @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];
-}
-
-
-/**
- * 
- * @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];
-}
-
-/**
- * @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 = WORLD_RADIUS_3D + height;
-    return [x * radius, y * radius, z * radius];
-}
-
-/**
- * @param {number} long
- * @param {number} lat
- * @returns {vec2} mercator
- */
-const wgs84ToMercator = (long, lat) => {
-    return [WORLD_RADIUS_MERCATOR * long * RADIANS, WORLD_RADIUS_MERCATOR * Math.log(Math.tan(Math.PI / 4 + lat * RADIANS / 2))];
-}
-
-
-
-/**
- * @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 = WORLD_RADIUS_3D + pixelXYHeight[2];
-    return radianToCartesian3d([long, lat]).concat(radius);
-}
-
-
-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;
-}
-
-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;
-}
-
-
-export {
-    RADIANS,
-    normalize3,
-    dot3,
-    length3,
-    cartesian3dToRadian,
-    radianToMercator,
-    radianToCartesian3d,
-    sphericalLinearInterpolation_UnitVector,
-    sphericalLinearInterpolation_Mercator,
-    sphericalLinearInterpolation_Cartesian3d,
-    wgs84ToUnitVector,
-    wgs84ToCartesian3d,
-    wgs84ToMercator,
-    pixelXYLenghtToUnitVectorWithHeight,
-    globe3Dcoordinates,
-    globe2Dcoordinates,
-}
-
+"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

@@ -0,0 +1,60 @@
+"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));
+    }
+});