@pirireis/webglobeplugins 0.8.15-alpha → 0.8.18

package/Math/plane.ts

@@ -0,0 +1,167 @@
+import { Vector3D } from './vector3d';
+import { WORLD_RADIUS_MERCATOR } from "./constants";
+import { Radians, Meter } from './types';
+import { Ray } from './ray';
+
+
+const VEC_EPSILON = 1e-8;
+
+const _0vector = /*@__PURE__*/ new Vector3D(0, 0, 0);
+
+
+
+export class Plane {
+    public normal: Vector3D;
+    public constant: number; // negative distance from the origin to the plane along the normal vector
+
+
+
+
+    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(plane: Plane): Plane {
+        this.normal.copy(plane.normal);
+        this.constant = plane.constant;
+        return this;
+    }
+
+
+
+    clone(): Plane {
+        return new Plane(this.normal.clone(), this.constant);
+    }
+
+
+
+    distanceToPoint(point: Vector3D): number {
+        return this.normal.dot(point) - this.constant;
+    }
+
+
+
+    projectPoint(point: Vector3D): Vector3D {
+        const distance = this.distanceToPoint(point);
+        return point.subtract(_0vector.copy(this.normal).scale(distance));
+    }
+
+
+
+    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;
+    }
+
+
+
+
+    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
+    }
+
+}

package/Math/quaternion.ts

@@ -0,0 +1,159 @@
+import { Radians, Vector3D } from './types'
+
+
+export class Quaternion {
+    x: number;
+    y: number;
+    z: number;
+    w: number;
+
+
+
+    constructor(x: number = 0, y: number = 0, z: number = 0, w: number = 1) {
+        this.x = x;
+        this.y = y;
+        this.z = z;
+        this.w = w;
+    }
+
+
+
+    set(x: number, y: number, z: number, w: number): Quaternion {
+        this.x = x;
+        this.y = y;
+        this.z = z;
+        this.w = w;
+        return this;
+    }
+
+
+
+    multiply(other: Quaternion): Quaternion {
+        const x = this.x * other.w + this.w * other.x + this.y * other.z - this.z * other.y;
+        const y = this.y * other.w + this.w * other.y + this.z * other.x - this.x * other.z;
+        const z = this.z * other.w + this.w * other.z + this.x * other.y - this.y * other.x;
+        const w = this.w * other.w - this.x * other.x - this.y * other.y - this.z * other.z;
+        return this.set(x, y, z, w);
+    }
+
+
+
+    length(): number {
+        return Math.sqrt(this.x ** 2 + this.y ** 2 + this.z ** 2 + this.w ** 2);
+    }
+
+
+
+    normalize(): Quaternion {
+        const len = this.length();
+        if (len > 0) {
+            this.x /= len;
+            this.y /= len;
+            this.z /= len;
+            this.w /= len;
+        }
+        return this;
+    }
+
+
+
+    copy(other: Quaternion): Quaternion {
+        this.x = other.x;
+        this.y = other.y;
+        this.z = other.z;
+        this.w = other.w;
+        return this;
+    }
+
+
+
+    clone(): Quaternion {
+        return new Quaternion(this.x, this.y, this.z, this.w);
+    }
+
+
+
+    setFromUnitVectors(vFrom: Vector3D, vTo: Vector3D): Quaternion {
+        const d = vFrom.dot(vTo) + 1;
+        if (d < 0.000001) {
+            if (Math.abs(vFrom.x) > Math.abs(vFrom.z)) {
+                this.set(-vFrom.y, vFrom.x, 0, 0);
+            } else {
+                this.set(0, -vFrom.z, vFrom.y, 0);
+            }
+        }
+        else {
+            this.set(
+                vFrom.y * vTo.z - vFrom.z * vTo.y,
+                vFrom.z * vTo.x - vFrom.x * vTo.z,
+                vFrom.x * vTo.y - vFrom.y * vTo.x,
+                d
+            )
+        }
+        return this;
+    }
+
+
+
+    static fromUnitVectors(vFrom: Vector3D, vTo: Vector3D): Quaternion {
+        return new Quaternion().setFromUnitVectors(vFrom, vTo);
+    }
+
+
+
+    setFromAxisAngle(axis: Vector3D, angle: Radians): Quaternion {
+        const halfAngle = angle / 2;
+        const s = Math.sin(halfAngle);
+        const len = axis.length() || 1;
+        this.x = axis.x * s / len;
+        this.y = axis.y * s / len;
+        this.z = axis.z * s / len;
+        this.w = Math.cos(halfAngle);
+        return this;
+    }
+
+
+
+    static fromAxisAngle(axis: Vector3D, angle: Radians): Quaternion {
+        return new Quaternion().setFromAxisAngle(axis, angle);
+    }
+
+
+
+    rotatePoint(point: Vector3D, out: Vector3D) {
+        const x = point.x;
+        const y = point.y;
+        const z = point.z;
+
+        const qx = this.x;
+        const qy = this.y;
+        const qz = this.z;
+        const qw = this.w;
+
+        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;
+
+        out.x = ix * qw + iw * -qx + iy * -qz - iz * -qy;
+        out.y = iy * qw + iw * -qy + iz * -qx - ix * -qz;
+        out.z = iz * qw + iw * -qz + ix * -qy - iy * -qx;
+
+        return out;
+
+    }
+
+
+    toMatrix4x4(): number[] {
+        const x = this.x, y = this.y, z = this.z, w = this.w;
+        const xx = x * x, yy = y * y, zz = z * z, xy = x * y, xz = x * z, yz = y * z, wx = w * x, wy = w * y, wz = w * z;
+        return [
+            1 - 2 * (yy + zz), 2 * (xy - wz), 2 * (xz + wy), 0,
+            2 * (xy + wz), 1 - 2 * (xx + zz), 2 * (yz - wx), 0,
+            2 * (xz - wy), 2 * (yz + wx), 1 - 2 * (xx + yy), 0,
+            0, 0, 0, 1
+        ];
+    }
+
+
+}

package/Math/ray.ts

@@ -0,0 +1,101 @@
+import { Vector3D } from './vector3d';
+import { Plane } from './plane';
+
+
+const _0vector = /*@__PURE__*/ new Vector3D(0, 0, 0);
+const _1vector = /*@__PURE__*/ new Vector3D(0, 0, 0);
+const _3vector = /*@__PURE__*/ new Vector3D(0, 0, 0);
+export class Ray {
+
+    origin: Vector3D;
+    direction: Vector3D;
+
+    constructor(origin: Vector3D, direction: Vector3D) {
+        this.origin = origin;
+        this.direction = direction.normalize();
+    }
+
+    copy(ray: Ray): Ray {
+        this.origin.copy(ray.origin);
+        this.direction.copy(ray.direction);
+        return this;
+    }
+
+    clone(): Ray {
+        return new Ray(this.origin.clone(), this.direction.clone());
+    }
+
+
+    at(distance: number, out: Vector3D): Vector3D {
+        return out.copy(this.direction).multiplyByScaler(distance).add(this.origin);
+    }
+
+
+    set(origin: Vector3D, direction: Vector3D): Ray {
+        this.origin.copy(origin);
+        this.direction.copy(direction).normalize();
+        return this;
+    }
+
+    intersectionSphere(sphereOrigin: Vector3D, sphereRadius: number): [Vector3D, Vector3D] | null {
+
+        const l = this.direction.clone().normalize();
+        const s = this.origin.clone().subtract(sphereOrigin);
+        const b = l.dot(s);
+
+        const c = s.dot(s) - sphereRadius * sphereRadius;
+        const d = b * b - c;
+
+        if (d < 0) {
+            return null; // no intersection
+        } else {
+            const x = Math.sqrt(d);
+            const t1 = -b - x;
+            const t2 = -b + x;
+            // l and s are used as output vectors
+            return [this.at(t1, l), this.at(t2, s)];
+        }
+    }
+
+
+    contains(point: Vector3D): boolean {
+        const x = this.origin.x - point.x;
+        const y = this.origin.y - point.y;
+        const z = this.origin.z - point.z;
+        const distance = Math.sqrt(x * x + y * y + z * z);
+        if (distance < 0.0001) {
+            return true; // point is very close to the origin
+        }
+        return Math.abs(_0vector.set(x / distance, y / distance, z / distance).dot(this.direction)) > 0.9999; // point direction  towards origin 
+        // is very close to the ray direction
+    }
+
+    // TODO: Applay this approach to other static methods on other Math classes.
+    static fromTwoPlanes(planeA: Plane, planeB: Plane, target: Ray | null = null): Ray | null {
+        const intersection = planeA.intersectionPlane(planeB);
+        if (intersection === null || intersection instanceof Plane) {
+            return null; // planes are parallel
+        }
+        if (target === null) {
+            target = new Ray(intersection.origin, intersection.direction);
+        }
+        else {
+            target.set(intersection.origin, intersection.direction);
+        }
+        return target;
+    }
+
+
+    static fromTwoPoints(pointA: Vector3D, pointB: Vector3D, target: Ray | null = null): Ray {
+        if (target === null) {
+            target = new Ray(pointA, pointB.clone().subtract(pointA).normalize());
+        } else {
+            target.set(pointA, pointB.clone().subtract(pointA).normalize());
+        }
+        return target;
+    }
+
+}
+
+
+

package/Math/roadmap.md

@@ -0,0 +1,10 @@
+
+There is an arc on a unit sphere. The sphere center is at the origin. The arc is represented with start and points. 
+
+And there is a plane the intersects with the same sphere. Represented with vector and distance from origin.
+
+I want to know the relative position of points to the plane. If they are at the same direction with the plane vector or not. 
+
+If two points are on the same side of the plane. If so, do they closer to origin then plane or not. 
+
+If two points are on different side of the plane, I want to know the intersection point of arc and plane.

package/Math/types.ts

@@ -0,0 +1,36 @@
+export type Radians = number;
+export type Degrees = number;
+export type Meter = number;
+
+interface Vector3D {
+    x: number;
+    y: number;
+    z: number;
+    dot(other: Vector3D): number;
+    cross(other: Vector3D): Vector3D;
+    lerp(other: Vector3D, t: number): Vector3D;
+    scale(scalar: number): Vector3D;
+    applyQuaternion(q: Quaternion): Vector3D;
+    normalize(): Vector3D;
+    clone(): Vector3D;
+    copy(other: Vector3D): Vector3D;
+    set(x: number, y: number, z: number): Vector3D;
+    add(other: Vector3D): Vector3D;
+    subtract(other: Vector3D): Vector3D;
+    negate(): Vector3D;
+    length(): number;
+    multiplyByScaler(scalar: number): Vector3D;
+    divideByScaler(scalar: number): Vector3D;
+}
+
+interface Quaternion {
+    x: number;
+    y: number;
+    z: number;
+    w: number;
+}
+
+export {
+    Vector3D,
+    Quaternion
+}

package/Math/utils.js

@@ -0,0 +1,3 @@
+import { Vector3D } from "./vector3d";
+import { Quaternion } from "./quaternion";
+

package/Math/vector3d.ts

@@ -0,0 +1,230 @@
+import { Vector3D as IVector3D, Radians } from "./types";
+import { Quaternion } from "./quaternion";
+
+
+
+export class Vector3D implements IVector3D {
+    x: number;
+    y: number;
+    z: number;
+
+
+    constructor(x: number = 0, y: number = 0, z: number = 0) {
+        this.x = x;
+        this.y = y;
+        this.z = z;
+    }
+
+
+
+    normalize(): Vector3D {
+        this.divideByScaler(this.length() || 1);
+        return this;
+    }
+
+
+
+    dot(other: Vector3D) {
+        return this.x * other.x + this.y * other.y + this.z * other.z;
+    }
+
+
+
+    equals(other: Vector3D, epsilon: number = 0.0000001): boolean {
+        // TODO: consider coppying other in case is true to avoid difference accumulation. 
+        return Math.abs(this.x - other.x) < epsilon &&
+            Math.abs(this.y - other.y) < epsilon &&
+            Math.abs(this.z - other.z) < epsilon;
+    }
+
+
+
+
+    static crossVectors(a: Vector3D, b: Vector3D, c: Vector3D = new Vector3D): Vector3D {
+        const x = a.y * b.z - a.z * b.y;
+        const y = a.z * b.x - a.x * b.z;
+        const z = a.x * b.y - a.y * b.x;
+
+        c.set(x, y, z);
+
+        return c;
+    }
+
+
+
+    cross(other: Vector3D): Vector3D {
+        return Vector3D.crossVectors(this, other, this);
+    }
+
+
+
+    lerpVectors(a: Vector3D, b: Vector3D, t: number): Vector3D {
+        this.x = a.x + (b.x - a.x) * t;
+        this.y = a.y + (b.y - a.y) * t;
+        this.z = a.z + (b.z - a.z) * t;
+
+        return this;
+    }
+
+
+
+    lerp(other: Vector3D, t: number): Vector3D {
+        return this.lerpVectors(this, other, t);
+    }
+
+
+
+    scale(scalar: number): Vector3D {
+        this.x *= scalar;
+        this.y *= scalar;
+        this.z *= scalar;
+
+        return this;
+    }
+
+    dotProduct(other: Vector3D): number {
+        return this.x * other.x + this.y * other.y + this.z * other.z;
+    }
+
+
+    dotDivide(other: Vector3D): number {
+        return this.x / other.x + this.y / other.y + this.z / other.z;
+    }
+
+
+    add(other: Vector3D): Vector3D {
+        this.x += other.x;
+        this.y += other.y;
+        this.z += other.z;
+
+        return this;
+    }
+
+
+
+    negate(): Vector3D {
+        this.x = -this.x;
+        this.y = -this.y;
+        this.z = -this.z;
+
+        return this;
+    }
+
+
+
+    length(): number {
+        return Math.sqrt(this.x ** 2 + this.y ** 2 + this.z ** 2);
+    }
+
+
+
+    subtract(other: Vector3D): Vector3D {
+        this.x -= other.x;
+        this.y -= other.y;
+        this.z -= other.z;
+
+        return this;
+    }
+
+
+
+    applyQuaternion(q: Quaternion): Vector3D {
+        const x = this.x, y = this.y, z = this.z;
+        const qx = q.x, qy = q.y, qz = q.z, qw = q.w;
+        // calculate quat * vector
+        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;
+        // calculate result * inverse quat
+        this.x = ix * qw + iw * -qx + iy * -qz - iz * -qy;
+        this.y = iy * qw + iw * -qy + iz * -qx - ix * -qz;
+        this.z = iz * qw + iw * -qz + ix * -qy - iy * -qx;
+        return this;
+    }
+
+
+
+    multiplyByScaler(scalar: number): Vector3D {
+        this.x *= scalar;
+        this.y *= scalar;
+        this.z *= scalar;
+
+        return this;
+    };
+
+
+
+    divideByScaler(scalar: number): Vector3D {
+        this.x /= scalar;
+        this.y /= scalar;
+        this.z /= scalar;
+
+        return this;
+    }
+
+
+
+    copy(other: Vector3D): Vector3D {
+        this.x = other.x;
+        this.y = other.y;
+        this.z = other.z;
+
+        return this
+    }
+
+
+
+    set(x: number, y: number, z: number): Vector3D {
+        this.x = x;
+        this.y = y;
+        this.z = z;
+
+        return this
+    }
+
+
+
+    clone(): Vector3D {
+        return new Vector3D(this.x, this.y, this.z);
+    }
+
+
+
+    randomUnit(): Vector3D {
+        const x = Math.random() * 2 - 1;
+        const y = Math.random() * 2 - 1;
+        const z = Math.random() * 2 - 1;
+
+        return this.set(x, y, z).normalize();
+    }
+
+
+
+    setFromLonLat(lon: Radians, lat: Radians): Vector3D {
+        const x = Math.cos(lat) * Math.cos(lon);
+        const y = Math.cos(lat) * Math.sin(lon);
+        const z = Math.sin(lat);
+
+        return this.set(x, y, z);
+    }
+
+
+
+
+    toLonLat(): { lon: Radians, lat: Radians } {
+        const len = this.length();
+        const x = this.x / len;
+        const y = this.y / len;
+        const z = this.z / len;
+        const lon = Math.atan2(y, x);
+        const lat = Math.asin(z);
+
+        return { lon, lat };
+    }
+
+
+    static fromLonLatRadians(lon: Radians, lat: Radians): Vector3D {
+        return new Vector3D().setFromLonLat(lon, lat);
+    }
+}

package/jest.config.js

@@ -0,0 +1,6 @@
+module.exports = {
+    preset: 'ts-jest',
+    testEnvironment: 'node',
+    testMatch: ['**/tests/**/*.test.ts'],
+    moduleFileExtensions: ['ts', 'js'],
+}