@pirireis/webglobeplugins 0.15.35 → 0.16.0

package/Math/juction/arc-plane.ts

@@ -0,0 +1,129 @@
+import { Vec3, Plane, Line, Sphere, Arc } from "../types";
+import { EPSILON } from "../constants";
+import {
+    create as vec3create,
+    copy as vec3copy,
+    dot,
+    distanceSquared,
+} 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 { planePlaneJuction } 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 = planePlaneJuction(_intersectionLine, _originPlane, junctionPlane);
+
+    if (!isPlaneJunctions) { // case C: planes are parallel. 
+        if (junctionPlane.distance <= 0) {
+            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) {
+        // other edge caes should be covered by now
+        return 0; // No intersection
+    }
+
+
+    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
+        const p0i0DistanceSquared = distanceSquared(inArc.p0, _intersectionPoints[0]);
+        const p0i1DistanceSquared = distanceSquared(inArc.p0, _intersectionPoints[1]);
+        const case0 = p0i0DistanceSquared < p0i1DistanceSquared;
+        arcSet(out[0], inArc.p0, case0 ? _intersectionPoints[0] : _intersectionPoints[1]);
+        arcSet(out[1], inArc.p1, !case0 ? _intersectionPoints[0] : _intersectionPoints[1]);
+        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;
+}
+

package/Math/juction/line-sphere.ts

@@ -0,0 +1,30 @@
+import { Vec3, Line, Sphere } from "../types";
+
+import { create, dot, lengthSquared, 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 distanceSquared = lengthSquared(_0vector);
+    const radiusSquared = inSphere.radius * inSphere.radius;
+    const dot_ = dot(_0vector, inLine.direction);
+    const dotSquared = dot_ * dot_;
+
+    const discriminant = dotSquared + radiusSquared - distanceSquared;
+    if (discriminant < 0) {
+        return false; // no intersection
+    } else {
+        const a = Math.sqrt(discriminant);
+        const t1 = -dot_ - a;
+        const t2 = -dot_ + a;
+
+        at(out[0], inLine, t1);
+        at(out[1], inLine, t2);
+
+        return true;
+    }
+}

package/Math/juction/plane-plane.ts

@@ -0,0 +1,64 @@
+import { Plane, Line, Vec3 } from "../types";
+import { EPSILON } from "../constants";
+import { copy, create, dot, cross, lengthSquared } from "../vec3";
+
+const _normal1 = create();
+const _normal2 = create();
+
+export function planePlaneJuction(out: Line, plane1: Plane, plane2: Plane): boolean {
+    copy(_normal1, plane1.normal);
+    copy(_normal2, plane2.normal);
+    const distance1 = plane1.distance;
+    const distance2 = plane2.distance;
+
+    const { origin, direction } = out;
+
+    const d = dot(_normal1, _normal2);
+
+    if (Math.abs(d) > 1 - EPSILON) {
+        return false; // Planes are parallel, no intersection
+    }
+
+    cross(direction, _normal1, _normal2);
+
+    const magnitudeSquired = 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,84 @@
+import { EPSILON } from './constants';
+import { Vec3, Line, Quaternion } from './types';
+import {
+    subtract,
+    applyQuaternion as vec3applyQuaternion,
+    add,
+    multiplyScalar,
+    normalize,
+    dot,
+    cross,
+    lengthSquared,
+    clone as vec3clone,
+    create as vec3create,
+    copy as vec3copy
+} from './vec3';
+
+
+const _0vector = /*@__PURE__*/ vec3create(0, 0, 0);
+
+
+function create(origin = vec3create(), direction = vec3create()): Line {
+    const direction_ = vec3clone(direction);
+    normalize(direction_, direction_);
+    return {
+        origin: vec3clone(origin),
+        direction: direction_
+    };
+}
+
+function set(out: Line, origin: Vec3, direction: Vec3) {
+    vec3copy(out.origin, origin);
+    vec3copy(out.direction, direction);
+}
+
+function copy(out: Line, a: Line) {
+    out.origin = vec3copy(out.origin, a.origin);
+    out.direction = vec3copy(out.direction, a.direction);
+}
+
+function clone(a: Line): Line {
+    return {
+        origin: vec3clone(a.origin),
+        direction: vec3clone(a.direction)
+    }
+}
+
+function fromTwoPoints(out: Line, a: Vec3, b: Vec3) {
+    subtract(out.direction, b, a);
+    normalize(out.direction, out.direction);
+    vec3copy(out.origin, a);
+}
+
+function at(out: Vec3, line: Line, distance: number) {
+    multiplyScalar(_0vector, line.direction, distance);
+    add(out, _0vector, line.origin);
+}
+
+
+function closestPoint(out: Vec3, line: Line, point: Vec3) {
+    subtract(_0vector, point, line.origin);
+    const dot_ = dot(_0vector, line.direction);
+    vec3copy(out, line.direction);
+    multiplyScalar(out, out, dot_);
+    add(out, out, line.origin);
+}
+
+
+function contains(line: Line, point: Vec3): boolean {
+    subtract(_0vector, point, line.origin);
+    cross(_0vector, _0vector, line.direction);
+    return lengthSquared(_0vector) < EPSILON;
+}
+
+function applyQuaternion(out: Line, line: Line, quaternion: Quaternion) {
+    vec3applyQuaternion(out.origin, line.origin, quaternion);
+    vec3applyQuaternion(out.direction, line.direction, quaternion);
+    normalize(out.direction, out.direction);
+}
+
+export {
+    create,
+    set,
+    copy, clone, fromTwoPoints, at, closestPoint, contains, applyQuaternion
+}