@pirireis/webglobeplugins 0.9.1 → 0.9.3

package/Math/juction/line-sphere.ts

@@ -0,0 +1,30 @@
+import { Vec3, Line, Sphere } from "../types";
+
+import { vec3 } from "../vec3";
+import { line } from "../line";
+
+const _0vector = /*@__PURE__*/ vec3.create(0, 0, 0);
+
+
+export function lineSphereIntersection(out: [Vec3, Vec3], inLine: Line, inSphere: Sphere): boolean {
+
+    vec3.subtract(_0vector, inLine.origin, inSphere.center);
+    const distanceSquared = vec3.lengthSquared(_0vector);
+    const radiusSquared = inSphere.radius * inSphere.radius;
+    const dot = 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.at(out[0], inLine, t1);
+        line.at(out[1], inLine, t2);
+
+        return true;
+    }
+}

package/Math/juction/plane-plane.ts

@@ -0,0 +1,66 @@
+import { Plane, Line, Vec3 } from "../types";
+import { EPSILON } from "../constants";
+import { plane } from "../plane";
+import { line } from "../line";
+import { vec3 } from "../vec3";
+
+const _normal1 = vec3.create();
+const _normal2 = vec3.create();
+
+export function planePlaneJuction(out: Line, plane1: Plane, plane2: Plane): boolean {
+    vec3.copy(_normal1, plane1.normal);
+    vec3.copy(_normal2, plane2.normal);
+    const distance1 = plane1.distance;
+    const distance2 = plane2.distance;
+
+    const { origin, direction } = out;
+
+    const dot = vec3.dot(_normal1, _normal2);
+
+    if (Math.abs(dot) > 1 - EPSILON) {
+        return false; // Planes are parallel, no intersection
+    }
+
+    vec3.cross(direction, _normal1, _normal2);
+
+    const magnitudeSquired = vec3.lengthSquared(out.direction);
+    if (magnitudeSquired < EPSILON) {
+        return false; // No valid intersection line
+    }
+
+    const magnitude = Math.sqrt(magnitudeSquired);
+    direction[0] /= magnitude;
+    direction[1] /= magnitude;
+    direction[2] /= magnitude;
+
+
+
+    let determinant: number;
+    // Calculate the intersection point
+    // set z = 0
+    determinant = _normal1[0] * _normal2[1] - _normal1[1] * _normal2[0];
+    if (Math.abs(determinant) > 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) > 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) > 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/Math/line.ts

@@ -0,0 +1,70 @@
+import { EPSILON } from './constants';
+import { Vec3, Line, Quaternion } from './types';
+import { vec3 } from './vec3';
+
+
+const _0vector = /*@__PURE__*/ vec3.create(0, 0, 0);
+
+
+export const line = Object.freeze({
+    create(origin = vec3.create(), direction = vec3.create()): Line {
+        const direction_ = vec3.clone(direction);
+        vec3.normalize(direction_, direction_);
+        return {
+            origin: vec3.clone(origin),
+            direction: direction_
+        };
+    },
+
+    set(out: Line, origin: Vec3, direction: Vec3) {
+        vec3.copy(out.origin, origin);
+        vec3.copy(out.direction, direction);
+    },
+
+    copy(out: Line, a: Line) {
+        out.origin = vec3.copy(out.origin, a.origin);
+        out.direction = vec3.copy(out.direction, a.direction);
+    },
+
+    clone(a: Line): Line {
+        return {
+            origin: vec3.clone(a.origin),
+            direction: vec3.clone(a.direction)
+        }
+    },
+
+    fromTwoPoints(out: Line, a: Vec3, b: Vec3) {
+        vec3.subtract(out.direction, b, a);
+        vec3.normalize(out.direction, out.direction);
+        vec3.copy(out.origin, a);
+    },
+
+    at(out: Vec3, line: Line, distance: number) {
+        vec3.multiplyScalar(_0vector, line.direction, distance);
+        vec3.add(out, _0vector, line.origin);
+    },
+
+
+    closestPoint(out: Vec3, line: Line, point: Vec3) {
+        vec3.subtract(_0vector, point, line.origin);
+        const dot = vec3.dot(_0vector, line.direction);
+        vec3.copy(out, line.direction);
+        vec3.multiplyScalar(out, out, dot);
+        vec3.add(out, out, line.origin);
+    },
+
+
+    contains(line: Line, point: Vec3): boolean {
+        vec3.subtract(_0vector, point, line.origin);
+        vec3.cross(_0vector, _0vector, line.direction);
+        return vec3.lengthSquared(_0vector) < EPSILON;
+    },
+
+    applyQuaternion(out: Line, line: Line, quaternion: Quaternion) {
+        vec3.applyQuaternion(out.origin, line.origin, quaternion);
+        vec3.applyQuaternion(out.direction, line.direction, quaternion);
+        vec3.normalize(out.direction, out.direction);
+    }
+
+
+})

package/Math/methods.js

@@ -190,6 +190,32 @@ const pixelXYLenghtToUnitVectorWithHeight = (pixelXYHeight) => {
     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,
@@ -204,6 +230,8 @@ export {
     wgs84ToUnitVector,
     wgs84ToCartesian3d,
     wgs84ToMercator,
-    pixelXYLenghtToUnitVectorWithHeight
+    pixelXYLenghtToUnitVectorWithHeight,
+    globe3Dcoordinates,
+    globe2Dcoordinates,
 }
 

package/Math/plane.ts

@@ -1,167 +1,86 @@
-import { Vector3D } from './vector3d';
-import { WORLD_RADIUS_MERCATOR } from "./constants";
-import { Radians, Meter } from './types';
-import { Ray } from './ray';
+import { Vec3, Plane } from "./types";
 
+import { EPSILON } from "./constants";
+import { vec3 } from "./vec3";
 
-const VEC_EPSILON = 1e-8;
+const _0vector = /*@__PURE__*/ vec3.create(0, 0, 0);
+const _1vector = /*@__PURE__*/ vec3.create(1, 1, 1);
 
-const _0vector = /*@__PURE__*/ new Vector3D(0, 0, 0);
 
+export const plane = Object.freeze({
+    create(normal = vec3.create(), distance = 0): Plane {
+        return {
+            normal: vec3.clone(normal),
+            distance: distance
+        };
+    },
 
 
-export class Plane {
-    public normal: Vector3D;
-    public constant: number; // negative distance from the origin to the plane along the normal vector
+    set(out: Plane, normal: Vec3, distance: number): Plane {
+        vec3.copy(out.normal, normal);
+        out.distance = distance;
+        return out;
+    },
 
 
+    fromValues(out: Plane, nx: number, ny: number, nz: number, distance: number) {
+        vec3.set(out.normal, nx, ny, nz);
+        out.distance = distance;
+    },
 
 
-    constructor(normal: Vector3D, constant: number) {
-        this.normal = normal.normalize();
-        this.constant = constant;
-    }
-
-
-    set(normal: Vector3D, constant: number): Plane {
-        this.normal.copy(normal);
-        this.constant = constant;
-        return this;
-    }
-
+    copy(out: Plane, a: Plane): Plane {
+        vec3.copy(out.normal, a.normal);
+        out.distance = a.distance;
+        return out;
+    },
 
 
-    copy(plane: Plane): Plane {
-        this.normal.copy(plane.normal);
-        this.constant = plane.constant;
-        return this;
-    }
+    clone(a: Plane): Plane {
+        return {
+            normal: vec3.clone(a.normal),
+            distance: a.distance
+        };
+    },
 
 
+    distanceToPoint(plane: Plane, point: Vec3): number {
+        return vec3.dot(plane.normal, point) - plane.distance;
+    },
 
-    clone(): Plane {
-        return new Plane(this.normal.clone(), this.constant);
-    }
 
+    projectPoint(out: Vec3, plane: Plane, point: Vec3) {
+        const distance = this.distanceToPoint(plane, point);
+        vec3.multiplyScalar(out, plane.normal, distance);
+        vec3.subtract(out, point, out);
+    },
 
 
-    distanceToPoint(point: Vector3D): number {
-        return this.normal.dot(point) - this.constant;
-    }
+    equals(plane: Plane, other: Plane): boolean {
+        return vec3.equals(plane.normal, other.normal) && Math.abs(plane.distance - other.distance) < EPSILON;
+    },
 
 
 
-    projectPoint(point: Vector3D): Vector3D {
-        const distance = this.distanceToPoint(point);
-        return point.subtract(_0vector.copy(this.normal).scale(distance));
-    }
-
+    fromNormalAndCoplanarPoint(out: Plane, normal: Vec3, point: Vec3) {
+        vec3.copy(out.normal, normal);
+        out.distance = vec3.dot(point, normal);
+    },
 
 
-    equals(other: Plane): boolean { // assumes normals are normalized 
-        return this.normal.equals(other.normal) && Math.abs(this.constant - other.constant) < VEC_EPSILON;
-    }
-
-
-    equalsReverseOriantation(other: Plane): boolean { // assumes normals are normalized 
-        _0vector.copy(this.normal).negate();
-        return _0vector.equals(other.normal) && Math.abs(this.constant + other.constant) < VEC_EPSILON;
-    }
-
-
-
-
-    setFromNormalAndPoint(normal: Vector3D, point: Vector3D): Plane {
-        this.normal.copy(normal);
-        this.constant = point.dot(normal);
-        return this;
-    }
 
+    fromPoints(out: Plane, a: Vec3, b: Vec3, c: Vec3) {
+        vec3.subtract(_0vector, b, a);
+        vec3.subtract(_1vector, c, a);
+        vec3.cross(out.normal, _0vector, _1vector);
+        vec3.normalize(out.normal, out.normal);
+        out.distance = vec3.dot(out.normal, a);
+    },
 
 
 
-    static fromNormalAndCoplanarPoint(normal: Vector3D, point: Vector3D): Plane {
-        return new Plane(normal, -point.dot(normal));
-    }
-
-
-
-    setFromPoints(p1: Vector3D, p2: Vector3D, p3: Vector3D): Plane {
-        this.normal = p2.clone().subtract(p1).cross(p3.subtract(p1)).normalize();
-        this.constant = p1.dot(this.normal);
-        return this;
-    }
-
-
-
-
-    static fromPoints(p1: Vector3D, p2: Vector3D, p3: Vector3D): Plane {
-        const normal = p2.subtract(p1).cross(p3.subtract(p1)).normalize();
-        const constant = p1.dot(normal);
-        return new Plane(normal, constant);
-    }
-
-
-
-
-    static fromGlobeLookInfo(centerLongitude: Radians, centerLatitude: Radians, distance: Meter, target: Plane): boolean {
-        const radiansAngle = Math.PI * distance / WORLD_RADIUS_MERCATOR;
-        target.normal.setFromLonLat(centerLongitude, centerLatitude).normalize();
-        target.constant = Math.cos(radiansAngle);
-        return true;
-    }
-
-
-
-    intersectionPlane(other: Plane): { origin: Vector3D, direction: Vector3D } | Plane | null {
-        if (this.normal.equals(other.normal)) {
-            if (Math.abs(this.constant - other.constant) < VEC_EPSILON) {
-                console.log('same orientation', this, other);
-                return this.clone(); // planes are equal
-            }
-            console.log('same orientation null', this, other);
-            return null; // planes are parallel and not equal
-        }
-        // opposite orientation
-        if (_0vector.copy(this.normal).negate().equals(other.normal)) {
-            if (Math.abs(this.constant + other.constant) < VEC_EPSILON) {
-                console.log('opposite orientation', this, other);
-                return this.clone(); // planes are equal
-            }
-            console.log('opposite orientation null', this, other);
-            return null; // planes are parallel and not equal
-        }
-
-
-        const nA = this.normal;
-        const nB = other.normal;
-        const dA = this.constant;
-        const dB = other.constant;
-
-        const direction = nA.clone().cross(nB).normalize();
-
-        // find a point on the line of intersection
-        const denomXY = nA.x * nB.y - nA.y * nB.x;
-
-        if (Math.abs(denomXY) > VEC_EPSILON) {
-            const x = (dA * nB.y - dB * nA.y) / denomXY;
-            const y = (dB * nA.x - dA * nB.x) / denomXY;
-            return { origin: new Vector3D(x, y, 0), direction };
-        }
-        const denomXZ = nA.x * nB.z - nA.z * nB.x;
-        if (Math.abs(denomXZ) > VEC_EPSILON) {
-            const x = (dA * nB.z - dB * nA.z) / denomXZ;
-            const z = (dB * nA.x - dA * nB.x) / denomXZ;
-            return { origin: new Vector3D(x, 0, z), direction };
-        }
-        const denomYZ = nA.y * nB.z - nA.z * nB.y;
-        if (Math.abs(denomYZ) > VEC_EPSILON) {
-            const y = (dA * nB.z - dB * nA.z) / denomYZ;
-            const z = (dB * nA.y - dA * nB.y) / denomYZ;
-            return { origin: new Vector3D(0, y, z), direction };
-        }
-        console.log('intersectionPlane null', this, other);
-        return null; // planes are parallel and not equal
+    getUnitSphereRadiusAngle(plane: Plane): number {
+        return Math.acos(Math.max(Math.min(plane.distance, 1), -1));
     }
 
-}
+});