@pirireis/webglobeplugins 0.9.6 → 0.9.7

package/Math/juction/arc-plane.ts

@@ -1,114 +0,0 @@
-import { Vec3, Plane, Line, Sphere, Arc } from "../types";
-import { EPSILON } from "../constants";
-import { vec3 } from "../vec3";
-import { line } from "../line";
-import { plane } from "../plane";
-import { arc } from "../arc";
-import { planePlaneJuction } from "./plane-plane";
-import { lineSphereIntersection } from "./line-sphere";
-
-const _intersectionLine = /*@__PURE__*/ line.create();
-const _originPlane = /*@__PURE__*/ plane.create();
-_originPlane.distance = 0;
-const _originSphere = /*@__PURE__*/ { center: vec3.create(0, 0, 0), radius: 1 } as Sphere;
-
-const _intersectionPoints: [Vec3, Vec3] = /*@__PURE__*/[vec3.create(), vec3.create()];
-
-// TODO: out must be [Arc, Arc] there is a case where split into three arcs, visible by points or arcs but middle is not visible
-
-
-
-/**
- * 
- * @param out \
- * @param inArc 
- * @param juctionPlane 
- * @returns number of arcs segments in the junction divided by the junction plane.
- */
-export function arcSlice(out: [Arc, Arc], inArc: Arc, juctionPlane: Plane): number {
-
-    // arc coverPlane and junctionPlane intersection exist in the range of unit sphere
-    const coverRadiusAngle = plane.getUnitSphereRadiusAngle(inArc.coverPlane);
-    const visibleRadiusAngle = plane.getUnitSphereRadiusAngle(juctionPlane);
-    // TODO: RESEARCH efficient approach --
-    const angleBetween_Cover_Visible = Math.acos(vec3.dot(inArc.coverPlane.normal, juctionPlane.normal));
-
-    if (coverRadiusAngle + visibleRadiusAngle < angleBetween_Cover_Visible - EPSILON) { // case A: out of range
-        return 0; // No intersection
-    }
-    // ------------------------------------
-
-    // the case when the arc is completely covered by the juction plane
-
-    if (visibleRadiusAngle + EPSILON >= angleBetween_Cover_Visible + coverRadiusAngle) { // case B: fully visible
-        arc.copy(out[0], inArc);
-        return 1;
-    }
-    // plane-plane intersection line should be calculated for the rest of the calculations
-
-    vec3.copy(_originPlane.normal, inArc.normal);
-    const isPlaneJunctions = planePlaneJuction(_intersectionLine, _originPlane, juctionPlane);
-
-    if (!isPlaneJunctions) { // case C: planes are parallel. 
-        // case A covers opposite directions
-        // case B Covers they face each other
-        throw new Error("Unexpected case: planes are parallel, case A and B should Cover it");
-    }
-    // --- read until here ---
-
-    // calculate the intersection points
-
-    const isSphereIntersection = lineSphereIntersection(_intersectionPoints, _intersectionLine, _originSphere);
-
-    if (!isSphereIntersection) {
-        // other edge caes should be covered by now
-        return 0; // No intersection
-    }
-
-
-    const i0IsCovered = plane.distanceToPoint(inArc.coverPlane, _intersectionPoints[0]) > -EPSILON;
-    const i1IsCovered = plane.distanceToPoint(inArc.coverPlane, _intersectionPoints[1]) > -EPSILON;
-
-
-    const p0IsVisible = plane.distanceToPoint(juctionPlane, inArc.p0) > -EPSILON;
-    const p1IsVisible = plane.distanceToPoint(juctionPlane, inArc.p1) > -EPSILON;
-
-    if (!p0IsVisible && !p1IsVisible && !i0IsCovered && !i1IsCovered) {
-        return 0; // No intersection
-    }
-
-    if (i0IsCovered && i1IsCovered && p0IsVisible && p1IsVisible) {
-        // calculate which points are closer
-        const p0i0DistanceSquared = vec3.distanceSquared(inArc.p0, _intersectionPoints[0]);
-        const p0i1DistanceSquared = vec3.distanceSquared(inArc.p0, _intersectionPoints[1]);
-        const case0 = p0i0DistanceSquared < p0i1DistanceSquared;
-        arc.set(out[0], inArc.p0, case0 ? _intersectionPoints[0] : _intersectionPoints[1]);
-        arc.set(out[1], inArc.p1, !case0 ? _intersectionPoints[0] : _intersectionPoints[1]);
-        return 2;
-    }
-
-
-    if (i0IsCovered && i1IsCovered) {
-        arc.set(out[0], _intersectionPoints[0], _intersectionPoints[1]);
-        return 1;
-    }
-
-
-    if (p0IsVisible && p1IsVisible) {
-        arc.copy(out[0], inArc);
-        return 1;
-    }
-
-    if ((p0IsVisible || p1IsVisible) !== (i0IsCovered || i1IsCovered)) {
-        throw new Error("Unexpected case: one covered and one visible point must be present");
-    }
-
-    arc.set(
-        out[0],
-        p0IsVisible ? inArc.p0 : inArc.p1,
-        i0IsCovered ? _intersectionPoints[0] : _intersectionPoints[1]
-    );
-
-    return 1;
-}
-

package/Math/juction/line-sphere.ts

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

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

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

@@ -1,237 +0,0 @@
-
-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,
-}
-

package/Math/plane.ts

@@ -1,86 +0,0 @@
-import { Vec3, Plane } from "./types";
-
-import { EPSILON } from "./constants";
-import { vec3 } from "./vec3";
-
-const _0vector = /*@__PURE__*/ vec3.create(0, 0, 0);
-const _1vector = /*@__PURE__*/ vec3.create(1, 1, 1);
-
-
-export const plane = Object.freeze({
-    create(normal = vec3.create(), distance = 0): Plane {
-        return {
-            normal: vec3.clone(normal),
-            distance: distance
-        };
-    },
-
-
-    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;
-    },
-
-
-    copy(out: Plane, a: Plane): Plane {
-        vec3.copy(out.normal, a.normal);
-        out.distance = a.distance;
-        return out;
-    },
-
-
-    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;
-    },
-
-
-    projectPoint(out: Vec3, plane: Plane, point: Vec3) {
-        const distance = this.distanceToPoint(plane, point);
-        vec3.multiplyScalar(out, plane.normal, distance);
-        vec3.subtract(out, point, out);
-    },
-
-
-    equals(plane: Plane, other: Plane): boolean {
-        return vec3.equals(plane.normal, other.normal) && Math.abs(plane.distance - other.distance) < EPSILON;
-    },
-
-
-
-    fromNormalAndCoplanarPoint(out: Plane, normal: Vec3, point: Vec3) {
-        vec3.copy(out.normal, normal);
-        out.distance = vec3.dot(point, normal);
-    },
-
-
-
-    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);
-    },
-
-
-
-    getUnitSphereRadiusAngle(plane: Plane): number {
-        return Math.acos(Math.max(Math.min(plane.distance, 1), -1));
-    }
-
-});