@pirireis/webglobeplugins 0.17.0 → 1.0.2

package/Math/{finite-line-2d.js → finite-line-2d.ts}

@@ -1,58 +1,68 @@
-function junctionPoint(out, inLine, origin, slope) {
-    const x0 = inLine[0];
-    const y0 = inLine[1];
-    const x1 = inLine[0];
-    const y1 = inLine[1];
-    const m1 = (y1 - y0) / (x1 - x0); // slope of line
-    const b1 = y0 - m1 * x0; // y-intercept of line
-    const m2 = slope;
-    const b2 = origin[1] - m2 * origin[0]; // y-intercept of line
-    if (m1 === m2) {
-        return 0; // parallel lines
-    }
-    const x = (b2 - b1) / (m1 - m2);
-    const y = m1 * x + b1;
-    // check if point is within line segment
-    if (x < Math.min(x0, x1) || x > Math.max(x0, x1) ||
-        y < Math.min(y0, y1) || y > Math.max(y0, y1)) {
-        return 0;
-    }
-    out[0] = x;
-    out[1] = y;
-    return 1;
-}
-export function junctionVerticalOrHorizontalLines(out, inLine1, value, isVertical) {
-    const x0 = inLine1[0];
-    const y0 = inLine1[1];
-    const x1 = inLine1[0];
-    const y1 = inLine1[1];
-    if (isVertical) {
-        // vertical line x = value
-        const m1 = (y1 - y0) / (x1 - x0);
-        const b1 = y0 - m1 * x0;
-        const y = m1 * value + b1;
-        // check if point is within line segment
-        if (y < Math.min(y0, y1) || y > Math.max(y0, y1)) {
-            return 0;
-        }
-        out[0] = value;
-        out[1] = y;
-        return 1;
-    }
-    else {
-        // horizontal line y = value
-        const m1 = (y1 - y0) / (x1 - x0);
-        const b1 = y0 - m1 * x0;
-        if (m1 === 0) {
-            return 0; // parallel lines
-        }
-        const x = (value - b1) / m1;
-        // check if point is within line segment
-        if (x < Math.min(x0, x1) || x > Math.max(x0, x1)) {
-            return 0;
-        }
-        out[0] = x;
-        out[1] = value;
-        return 1;
-    }
-}
+import { FiniteLine2D, Vec2 } from "./types";
+
+
+function junctionPoint(out: Vec2, inLine: FiniteLine2D, origin: Vec2, slope: number): number {
+    const x0 = inLine[0];
+    const y0 = inLine[1];
+    const x1 = inLine[0];
+    const y1 = inLine[1];
+    const m1 = (y1 - y0) / (x1 - x0); // slope of line
+    const b1 = y0 - m1 * x0; // y-intercept of line
+
+    const m2 = slope;
+    const b2 = origin[1] - m2 * origin[0]; // y-intercept of line
+    if (m1 === m2) {
+        return 0; // parallel lines
+    }
+    const x = (b2 - b1) / (m1 - m2);
+    const y = m1 * x + b1;
+    // check if point is within line segment
+
+    if (x < Math.min(x0, x1) || x > Math.max(x0, x1) ||
+        y < Math.min(y0, y1) || y > Math.max(y0, y1)) {
+        return 0;
+    }
+    out[0] = x;
+    out[1] = y;
+    return 1;
+}
+
+
+
+export function junctionVerticalOrHorizontalLines(out: Vec2, inLine1: FiniteLine2D, value: number, isVertical: boolean): number {
+    const x0 = inLine1[0];
+    const y0 = inLine1[1];
+    const x1 = inLine1[0];
+    const y1 = inLine1[1];
+
+    if (isVertical) {
+        // vertical line x = value
+        const m1 = (y1 - y0) / (x1 - x0);
+        const b1 = y0 - m1 * x0;
+        const y = m1 * value + b1;
+        // check if point is within line segment
+        if (y < Math.min(y0, y1) || y > Math.max(y0, y1)) {
+            return 0;
+        }
+        out[0] = value;
+        out[1] = y;
+        return 1;
+    } else {
+        // horizontal line y = value
+
+        const m1 = (y1 - y0) / (x1 - x0);
+        const b1 = y0 - m1 * x0;
+        if (m1 === 0) {
+            return 0; // parallel lines
+        }
+
+        const x = (value - b1) / m1;
+        // check if point is within line segment
+        if (x < Math.min(x0, x1) || x > Math.max(x0, x1)) {
+            return 0;
+        }
+        out[0] = x;
+        out[1] = value;
+        return 1;
+    }
+}

package/Math/haversine.ts

@@ -0,0 +1,33 @@
+import { Radian } from "../types";
+
+/**
+ * Calculate great-circle distance (arc length) between two lat/lon points
+ * @param lat1 Latitude of point 1 (Radian)
+ * @param lon1 Longitude of point 1 (Radian)
+ * @param lat2 Latitude of point 2 (Radian)
+ * @param lon2 Longitude of point 2 (Radian)
+ * @returns Distance in unit sphere radius
+*/
+export function haversine(
+    lat1: Radian,
+    lon1: Radian,
+    lat2: Radian,
+    lon2: Radian,
+): number {
+    // Convert to radians in-place (minimal allocations)
+
+    const φ1 = lat1;
+    const φ2 = lat2;
+    const Δφ = lat2 - lat1;
+    const Δλ = lon2 - lon1;
+
+    // Haversine: a = sin²(Δφ/2) + cos(φ1)cos(φ2)sin²(Δλ/2)
+    const a =
+        Math.sin(Δφ * 0.5) ** 2 +
+        Math.cos(φ1) * Math.cos(φ2) * Math.sin(Δλ * 0.5) ** 2;
+
+    // c = 2 * atan2(√a, √(1−a))
+    const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
+
+    return c; // arc length
+};

package/Math/index.js

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

package/Math/juction/{arc-plane.js → arc-plane.ts}

@@ -1,143 +1,203 @@
-import { EPSILON } from "../constants";
-import { create as vec3create, copy as vec3copy, dot, distanceSquared, copy, normalize } from "../vec3";
-import { create as lineCreate } from "../line";
-import { create as planeCreate, distanceToPoint, getUnitSphereRadiusAngle } from "../plane";
-import { copy as arcCopy, set as arcSet } from "../arc";
-import { planePlaneJunction } from "./plane-plane";
-import { lineSphereIntersection } from "./line-sphere";
-const _intersectionLine = /*@__PURE__*/ lineCreate();
-const _originPlane = /*@__PURE__*/ planeCreate();
-_originPlane.distance = 0;
-const _originSphere = /*@__PURE__*/ { center: vec3create(0, 0, 0), radius: 1 };
-const _intersectionPoints = /*@__PURE__*/ [vec3create(), vec3create()];
-// 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 junctionPlane
- * @returns number of arcs segments in the junction divided by the junction plane.
- */
-export function arcSlice(out, inArc, junctionPlane) {
-    if (junctionPlane.distance < -1 + EPSILON) {
-        arcCopy(out[0], inArc);
-        return 1;
-    }
-    // arc coverPlane and junctionPlane intersection exist in the range of unit sphere
-    const coverRadiusAngle = getUnitSphereRadiusAngle(inArc.coverPlane);
-    const visibleRadiusAngle = getUnitSphereRadiusAngle(junctionPlane);
-    // TODO: RESEARCH efficient approach --
-    const angleBetween_Cover_Visible = Math.acos(dot(inArc.coverPlane.normal, junctionPlane.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
-        arcCopy(out[0], inArc);
-        return 1;
-    }
-    // plane-plane intersection line should be calculated for the rest of the calculations
-    vec3copy(_originPlane.normal, inArc.normal);
-    const isPlaneJunctions = planePlaneJunction(_intersectionLine, _originPlane, junctionPlane);
-    if (!isPlaneJunctions) { // case C: planes are parallel. 
-        if (junctionPlane.distance <= 0) { // same direction
-            arcCopy(out[0], inArc);
-            return 1; // No intersection
-        }
-        else {
-            return 0; // No intersection
-        }
-    }
-    // --- read until here ---
-    // calculate the intersection points
-    const isSphereIntersection = lineSphereIntersection(_intersectionPoints, _intersectionLine, _originSphere);
-    if (!isSphereIntersection) {
-        return 0; // No intersection
-    }
-    // ← ADD NORMALIZATION HERE
-    normalize(_intersectionPoints[0], _intersectionPoints[0]);
-    normalize(_intersectionPoints[1], _intersectionPoints[1]);
-    const i0IsCovered = distanceToPoint(inArc.coverPlane, _intersectionPoints[0]) > EPSILON;
-    const i1IsCovered = distanceToPoint(inArc.coverPlane, _intersectionPoints[1]) > EPSILON;
-    const p0IsVisible = distanceToPoint(junctionPlane, inArc.p0) > EPSILON;
-    const p1IsVisible = distanceToPoint(junctionPlane, inArc.p1) > EPSILON;
-    if (!p0IsVisible && !p1IsVisible && !i0IsCovered && !i1IsCovered) {
-        return 0; // No intersection
-    }
-    if (i0IsCovered && i1IsCovered && p0IsVisible && p1IsVisible) {
-        // calculate which points are closer
-        if (dot(inArc.coverPlane.normal, junctionPlane.normal) > 1 - EPSILON) {
-            arcCopy(out[0], inArc);
-            return 1;
-        }
-        else if (dot(inArc.coverPlane.normal, junctionPlane.normal) < -1 + EPSILON) {
-            return 0;
-        }
-        // Determine which intersection point is closer to p0
-        const p0i0DistanceSquared = distanceSquared(inArc.p0, _intersectionPoints[0]);
-        const p0i1DistanceSquared = distanceSquared(inArc.p0, _intersectionPoints[1]);
-        const closerToP0 = p0i0DistanceSquared < p0i1DistanceSquared ? 0 : 1;
-        // The visible portion is from p0 to the closer intersection point
-        arcSet(out[0], inArc.p0, _intersectionPoints[closerToP0]);
-        // The second arc goes from the farther point to p1
-        arcSet(out[1], _intersectionPoints[1 - closerToP0], inArc.p1);
-        return 2;
-    }
-    if (i0IsCovered && i1IsCovered) {
-        arcSet(out[0], _intersectionPoints[0], _intersectionPoints[1]);
-        return 1;
-    }
-    if (p0IsVisible && p1IsVisible) {
-        arcCopy(out[0], inArc);
-        return 1;
-    }
-    if ((p0IsVisible || p1IsVisible) !== (i0IsCovered || i1IsCovered)) {
-        throw new Error("Unexpected case: one covered and one visible point must be present");
-    }
-    arcSet(out[0], p0IsVisible ? inArc.p0 : inArc.p1, i0IsCovered ? _intersectionPoints[0] : _intersectionPoints[1]);
-    return 1;
-}
-function showArc(arc) {
-    return `Arc: p0(${arc.p0[0].toFixed(2)}, ${arc.p0[1].toFixed(2)}, ${arc.p0[2]}) - p1(${arc.p1[0]}, ${arc.p1[1].toFixed(2)}, ${arc.p1[2].toFixed(2)})`;
-}
-function showPlane(plane) {
-    return `Plane: n(${plane.normal[0].toFixed(2)}, ${plane.normal[1].toFixed(2)}, ${plane.normal[2].toFixed(2)}) d(${plane.distance.toFixed(2)})`;
-}
-export function pointsOnArc(inArc, junctionPlane, out) {
-    // case A: junction plane is too far
-    if (Math.abs(junctionPlane.distance) > 1) {
-        return 0;
-    }
-    // Calculate plane-plane intersection
-    vec3copy(_originPlane.normal, inArc.normal);
-    const isPlaneJunctions = planePlaneJunction(_intersectionLine, _originPlane, junctionPlane);
-    // case B: planes are parallel
-    if (!isPlaneJunctions) {
-        return 0;
-    }
-    // Calculate intersection points with unit sphere
-    const isSphereIntersection = lineSphereIntersection(_intersectionPoints, _intersectionLine, _originSphere);
-    // case C: intersection line does not intersect the unit sphere
-    if (!isSphereIntersection) {
-        return 0;
-    }
-    // Check which intersection points are covered by the arc
-    const i0IsCovered = distanceToPoint(inArc.coverPlane, _intersectionPoints[0]) > -EPSILON;
-    const i1IsCovered = distanceToPoint(inArc.coverPlane, _intersectionPoints[1]) > -EPSILON;
-    // Check which endpoints are visible
-    let count = 0;
-    // Add covered intersection points
-    if (i0IsCovered) {
-        copy(out[count], _intersectionPoints[0]);
-        count++;
-    }
-    if (Math.abs(Math.abs(junctionPlane.distance) - 1) < EPSILON) {
-        return count; // Tangent case, only one intersection point
-    }
-    if (i1IsCovered) {
-        copy(out[count], _intersectionPoints[1]);
-        count++;
-    }
-    return count;
-}
+import { Vec3, Plane, Line, Sphere, Arc } from "../types";
+import { EPSILON } from "../constants";
+import {
+    create as vec3create,
+    copy as vec3copy,
+    dot,
+    distanceSquared,
+    copy,
+    normalize, // ← ADD THIS
+    length
+} from "../vec3";
+import { create as lineCreate, at as lineAt } from "../line";
+import {
+    create as planeCreate,
+    distanceToPoint,
+    getUnitSphereRadiusAngle
+} from "../plane";
+import { copy as arcCopy, set as arcSet } from "../arc"
+import { planePlaneJunction } from "./plane-plane";
+import { lineSphereIntersection } from "./line-sphere";
+
+const _intersectionLine = /*@__PURE__*/ lineCreate();
+const _originPlane = /*@__PURE__*/ planeCreate();
+_originPlane.distance = 0;
+const _originSphere = /*@__PURE__*/ { center: vec3create(0, 0, 0), radius: 1 } as Sphere;
+
+const _intersectionPoints: [Vec3, Vec3] = /*@__PURE__*/[vec3create(), vec3create()];
+
+// 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 junctionPlane 
+ * @returns number of arcs segments in the junction divided by the junction plane.
+ */
+export function arcSlice(out: [Arc, Arc], inArc: Arc, junctionPlane: Plane): number {
+
+    if (junctionPlane.distance < -1 + EPSILON) {
+        arcCopy(out[0], inArc);
+        return 1;
+    }
+    // arc coverPlane and junctionPlane intersection exist in the range of unit sphere
+    const coverRadiusAngle = getUnitSphereRadiusAngle(inArc.coverPlane);
+    const visibleRadiusAngle = getUnitSphereRadiusAngle(junctionPlane);
+    // TODO: RESEARCH efficient approach --
+    const angleBetween_Cover_Visible = Math.acos(dot(inArc.coverPlane.normal, junctionPlane.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
+        arcCopy(out[0], inArc);
+        return 1;
+    }
+    // plane-plane intersection line should be calculated for the rest of the calculations
+
+    vec3copy(_originPlane.normal, inArc.normal);
+    const isPlaneJunctions = planePlaneJunction(_intersectionLine, _originPlane, junctionPlane);
+
+    if (!isPlaneJunctions) { // case C: planes are parallel. 
+        if (junctionPlane.distance <= 0) { // same direction
+            arcCopy(out[0], inArc);
+            return 1; // No intersection
+        } else {
+            return 0; // No intersection
+        }
+    }
+    // --- read until here ---
+
+    // calculate the intersection points
+
+    const isSphereIntersection = lineSphereIntersection(_intersectionPoints, _intersectionLine, _originSphere);
+    if (!isSphereIntersection) {
+        return 0; // No intersection
+    }
+
+    // ← ADD NORMALIZATION HERE
+    normalize(_intersectionPoints[0], _intersectionPoints[0]);
+    normalize(_intersectionPoints[1], _intersectionPoints[1]);
+
+    const i0IsCovered = distanceToPoint(inArc.coverPlane, _intersectionPoints[0]) > EPSILON;
+    const i1IsCovered = distanceToPoint(inArc.coverPlane, _intersectionPoints[1]) > EPSILON;
+
+
+    const p0IsVisible = distanceToPoint(junctionPlane, inArc.p0) > EPSILON;
+    const p1IsVisible = distanceToPoint(junctionPlane, inArc.p1) > EPSILON;
+
+    if (!p0IsVisible && !p1IsVisible && !i0IsCovered && !i1IsCovered) {
+        return 0; // No intersection
+    }
+
+    if (i0IsCovered && i1IsCovered && p0IsVisible && p1IsVisible) {
+        // calculate which points are closer
+        if (dot(inArc.coverPlane.normal, junctionPlane.normal) > 1 - EPSILON) {
+            arcCopy(out[0], inArc);
+            return 1;
+        } else if (dot(inArc.coverPlane.normal, junctionPlane.normal) < -1 + EPSILON) {
+            return 0;
+        }
+
+        // Determine which intersection point is closer to p0
+        const p0i0DistanceSquared = distanceSquared(inArc.p0, _intersectionPoints[0]);
+        const p0i1DistanceSquared = distanceSquared(inArc.p0, _intersectionPoints[1]);
+        const closerToP0 = p0i0DistanceSquared < p0i1DistanceSquared ? 0 : 1;
+
+        // The visible portion is from p0 to the closer intersection point
+        arcSet(out[0], inArc.p0, _intersectionPoints[closerToP0]);
+        // The second arc goes from the farther point to p1
+        arcSet(out[1], _intersectionPoints[1 - closerToP0], inArc.p1);
+
+        return 2;
+    }
+
+
+    if (i0IsCovered && i1IsCovered) {
+        arcSet(out[0], _intersectionPoints[0], _intersectionPoints[1]);
+        return 1;
+    }
+
+
+    if (p0IsVisible && p1IsVisible) {
+        arcCopy(out[0], inArc);
+        return 1;
+    }
+
+    if ((p0IsVisible || p1IsVisible) !== (i0IsCovered || i1IsCovered)) {
+        throw new Error("Unexpected case: one covered and one visible point must be present");
+    }
+
+    arcSet(
+        out[0],
+        p0IsVisible ? inArc.p0 : inArc.p1,
+        i0IsCovered ? _intersectionPoints[0] : _intersectionPoints[1]
+    );
+
+    return 1;
+}
+
+
+
+function showArc(arc: Arc): string {
+    return `Arc: p0(${arc.p0[0].toFixed(2)}, ${arc.p0[1].toFixed(2)}, ${arc.p0[2]}) - p1(${arc.p1[0]}, ${arc.p1[1].toFixed(2)}, ${arc.p1[2].toFixed(2)})`
+}
+
+function showPlane(plane: Plane): string {
+    return `Plane: n(${plane.normal[0].toFixed(2)}, ${plane.normal[1].toFixed(2)}, ${plane.normal[2].toFixed(2)}) d(${plane.distance.toFixed(2)})`
+}
+
+export function pointsOnArc(inArc: Arc, junctionPlane: Plane, out: [Vec3, Vec3]): number /*count*/ {
+    // case A: junction plane is too far
+    if (Math.abs(junctionPlane.distance) > 1) {
+        return 0;
+    }
+
+    // Calculate plane-plane intersection
+    vec3copy(_originPlane.normal, inArc.normal);
+    const isPlaneJunctions = planePlaneJunction(_intersectionLine, _originPlane, junctionPlane);
+
+    // case B: planes are parallel
+    if (!isPlaneJunctions) {
+        return 0;
+    }
+
+    // Calculate intersection points with unit sphere
+    const isSphereIntersection = lineSphereIntersection(_intersectionPoints, _intersectionLine, _originSphere);
+    // case C: intersection line does not intersect the unit sphere
+    if (!isSphereIntersection) {
+        return 0;
+    }
+
+    // Check which intersection points are covered by the arc
+    const i0IsCovered = distanceToPoint(inArc.coverPlane, _intersectionPoints[0]) > -EPSILON;
+    const i1IsCovered = distanceToPoint(inArc.coverPlane, _intersectionPoints[1]) > -EPSILON;
+
+    // Check which endpoints are visible
+
+    let count = 0;
+
+    // Add covered intersection points
+    if (i0IsCovered) {
+        copy(out[count], _intersectionPoints[0]);
+        count++;
+    }
+    if (Math.abs(Math.abs(junctionPlane.distance) - 1) < EPSILON) {
+        return count; // Tangent case, only one intersection point
+    }
+
+    if (i1IsCovered) {
+        copy(out[count], _intersectionPoints[1]);
+        count++;
+    }
+
+
+    return count;
+}

package/Math/juction/{line-sphere.js → line-sphere.ts}

@@ -1,22 +1,32 @@
-import { create, dot, lengthSquared, subtract } from "../vec3";
-import { at } from "../line";
-const _0vector = /*@__PURE__*/ create(0, 0, 0);
-export function lineSphereIntersection(out, inLine, inSphere) {
-    subtract(_0vector, inLine.origin, inSphere.center);
-    const dirLengthSq = lengthSquared(inLine.direction);
-    const dot_ = dot(_0vector, inLine.direction);
-    const distanceSquared = lengthSquared(_0vector);
-    const radiusSquared = inSphere.radius * inSphere.radius;
-    const discriminant = dot_ * dot_ - dirLengthSq * (distanceSquared - radiusSquared);
-    if (discriminant < 0) {
-        return false; // no intersection
-    }
-    else {
-        const sqrtDiscriminant = Math.sqrt(discriminant);
-        const t1 = (-dot_ - sqrtDiscriminant) / dirLengthSq;
-        const t2 = (-dot_ + sqrtDiscriminant) / dirLengthSq;
-        at(out[0], inLine, t1);
-        at(out[1], inLine, t2);
-        return true;
-    }
-}
+import { Vec3, Line, Sphere } from "../types";
+
+import { create, dot, lengthSquared, normalize, subtract } from "../vec3";
+import { at } from "../line";
+
+const _0vector = /*@__PURE__*/ create(0, 0, 0);
+
+
+export function lineSphereIntersection(out: [Vec3, Vec3], inLine: Line, inSphere: Sphere): boolean {
+
+    subtract(_0vector, inLine.origin, inSphere.center);
+    
+    const dirLengthSq = lengthSquared(inLine.direction);
+    const dot_ = dot(_0vector, inLine.direction);
+    const distanceSquared = lengthSquared(_0vector);
+    const radiusSquared = inSphere.radius * inSphere.radius;
+    
+    const discriminant = dot_ * dot_ - dirLengthSq * (distanceSquared - radiusSquared);
+    
+    if (discriminant < 0) {
+        return false; // no intersection
+    } else {
+        const sqrtDiscriminant = Math.sqrt(discriminant);
+        const t1 = (-dot_ - sqrtDiscriminant) / dirLengthSq;
+        const t2 = (-dot_ + sqrtDiscriminant) / dirLengthSq;
+
+        at(out[0], inLine, t1);
+        at(out[1], inLine, t2);
+
+        return true;
+    }
+}