@pirireis/webglobeplugins 0.15.35 → 0.16.0

package/Math/arc.ts

@@ -0,0 +1,299 @@
+import { Vec3, Plane, Arc, LongLat, Radians } from "./types";
+
+import {
+    create as vec3create,
+    set as vec3set,
+    cross,
+    dot,
+    normalize,
+    clone as vec3clone,
+    copy as vec3copy,
+    equals as vec3equals,
+    lengthSquared,
+    fromLongLatToUnitVector,
+    subtract,
+    applyQuaternion,
+    fromUnitVectorToLongLat
+} from "./vec3";
+
+import {
+    create as planeCreate,
+    fromPoints as planeFromPoints,
+    distanceToPoint as planeDistanceToPoint,
+    projectPoint as planeProjectPoint
+} from "./plane";
+
+import { create as quaternionCreate, fromAxisAngle } from "./quaternion";
+
+import { EPSILON } from "./constants";
+
+import * as vec3 from "./vec3";
+import * as quat from "./quaternion";
+
+
+const _0vector = /*@__PURE__*/ vec3create(0, 0, 0);
+const _closestPoint = /*@__PURE__*/ vec3create();
+
+const _originPlane = /*@__PURE__*/ planeCreate(vec3create(0, 0, 1), 0);
+// dont change distance of _originPlane
+const _rotationQuaternion = /*@__PURE__*/ quaternionCreate();
+const _longLat = /*@__PURE__*/[0, 0] as LongLat;
+
+function create(p0: Vec3, p1: Vec3): Arc {
+    const normal = vec3create(0, 0, 0);
+    cross(normal, p0, p1);
+    normalize(normal, normal);
+    const coverPlaneNormal = vec3create(p0[0] + p1[0], p0[1] + p1[1], p0[2] + p1[2]);
+
+    let distance: number;
+    const ls = lengthSquared(coverPlaneNormal);
+
+    if (ls > EPSILON) {
+        normalize(coverPlaneNormal, coverPlaneNormal);
+        distance = dot(coverPlaneNormal, p0);
+    } else {
+        // Handle opposite points case
+        const tempPlane = planeCreate(vec3create(), 0);
+        _oppositePointsHandle(p0, p1, normal, tempPlane);
+        vec3copy(coverPlaneNormal, tempPlane.normal);
+        distance = tempPlane.distance;
+    }
+
+    return {
+        p0: vec3clone(p0),
+        p1: vec3clone(p1),
+        normal: vec3clone(normal),
+        coverPlane: {
+            normal: coverPlaneNormal,
+            distance: distance
+        } as Plane,
+        coverAngle: Math.acos(dot(p0, p1)) as Radians
+    }
+}
+
+function set(out: Arc, p0: Vec3, p1: Vec3) {
+    vec3copy(out.p0, p0);
+    vec3copy(out.p1, p1);
+    cross(out.normal, p0, p1);
+    vec3set(_0vector, p0[0] + p1[0], p0[1] + p1[1], p0[2] + p1[2]);
+    const ls = lengthSquared(_0vector);
+    if (ls > EPSILON) {
+        normalize(out.coverPlane.normal, _0vector);
+        out.coverPlane.distance = dot(out.coverPlane.normal, p0);
+    } else {
+        _oppositePointsHandle(p0, p1, out.normal, out.coverPlane);
+    }
+}
+
+function copy(out: Arc, a: Arc) {
+    vec3copy(out.p0, a.p0);
+    vec3copy(out.p1, a.p1);
+    vec3copy(out.normal, a.normal);
+    out.coverPlane.normal = vec3clone(a.coverPlane.normal);
+    out.coverPlane.distance = a.coverPlane.distance;
+    out.coverAngle = a.coverAngle; // Copy coverAngle if it exists
+}
+
+function clone(a: Arc): Arc {
+    return {
+        p0: vec3clone(a.p0),
+        p1: vec3clone(a.p1),
+        normal: vec3clone(a.normal),
+        coverPlane: {
+            normal: vec3clone(a.coverPlane.normal),
+            distance: a.coverPlane.distance
+        } as Plane,
+        coverAngle: a.coverAngle // Clone coverAngle if it exists
+    };
+}
+
+
+
+function isPointOn(arc: Arc, point: Vec3): boolean {
+    const alignment = Math.abs(dot(point, arc.normal)) < EPSILON;
+    const distance = Math.abs(lengthSquared(point) - 1) < EPSILON;
+    const cover = dot(arc.coverPlane.normal, point) >= arc.coverPlane.distance;
+    return alignment || distance || cover;
+}
+
+
+function equals(a: Arc, b: Arc): boolean {
+    return (vec3equals(a.p0, b.p0) && vec3equals(a.p1, b.p1))
+        || (vec3equals(a.p0, b.p1) && vec3equals(a.p1, b.p0))
+}
+
+
+
+function closestPoint(out: Vec3, inArc: Arc, point: Vec3): boolean {
+    // 1. calculate the projection of the point onto the plane definned by the arc.normal, distance 0
+    // 2. calculate projection distance to the arc.coverPlane. 
+    //  * if the distance is negative, the point is outside the arc
+    //   * copy (the closest of [inArc.p0, inArc.p1] to the point) to the output
+    //   * return false that indicates the point is outside the arc
+    //  * if the distance is positive, the point is inside the arc 
+    //   * normalize the projection and copy it to out
+    //   * return true that indicates the point is inside the arc
+    const distance = planeDistanceToPoint(inArc.coverPlane, point);
+    if (distance < -EPSILON) {
+        // point is outside the arc
+        // this case also covers point is on center shaft line of the arc 
+        return false;
+    }
+
+    vec3copy(_originPlane.normal, inArc.normal);
+    planeProjectPoint(_0vector, _originPlane, point);
+    // point is inside the arc
+    normalize(out, _0vector);
+    return true;
+}
+
+
+function populatePoints(out: Float32Array, arc: Arc, count: number, pointOfProjection: Vec3 | void = undefined): void {
+    // rotate p0 around normal vector with a quaternion
+    // calculate angle
+    _distanceSampling(out, count, arc, pointOfProjection || [0, 0, 0] as Vec3, 1);
+
+}
+
+
+
+
+function _oppositePointsHandle(p0: Vec3, p1: Vec3, outNormal: Vec3, outCoverPlane: Plane) {
+    // first choice pass through Anitkabir 
+    const radians = Math.PI / 180;
+    fromLongLatToUnitVector(_0vector, [39.9334 * radians, 32.8597 * radians] as LongLat); // Anitkabir
+    if (vec3equals(p0, _0vector) || vec3equals(p1, _0vector)) {
+        // if Anitkabir is too close to p0 or p1, use Selanic
+        fromLongLatToUnitVector(_0vector, [37.0016 * radians, 35.3213 * radians] as LongLat); // Selanic
+    }
+    planeFromPoints({ normal: outNormal, distance: 0 } as Plane, p0, _0vector, p1);
+
+    cross(outCoverPlane.normal, outNormal, p0);
+
+
+}
+
+
+function _populatePointsWithClosestPointInsideArc(
+    out: Float32Array,
+    arc: Arc,
+    count: number,
+    closestPoint: Vec3
+): void {
+
+    // two parts divided by closest point will be populated seperately
+    // pop1 + pop2 = count
+
+    // angular distance between [arc.p0, closestPoint] and [arc.p1, closestPoint]
+    // will be used to decide ratio between pop1 and pop2
+    const angleP0 = Math.acos(dot(arc.p0, closestPoint));
+    const angleP1 = Math.acos(dot(arc.p1, closestPoint));
+
+    const pop1 = Math.floor(count * (angleP0 / (angleP0 + angleP1)));
+    const pop2 = count - pop1;
+
+
+    const angleStep1 = angleP0 / pop1;
+    const angleStep2 = angleP1 / pop2;
+
+    fromAxisAngle(_rotationQuaternion, arc.normal, angleStep1);
+
+
+
+}
+
+
+
+/**
+ * Samples points along an arc with density biased by the camera's distance,
+ * reusing the rotation quaternion to improve performance.
+ *
+ * @param {Float32Array} out - The output array to store longitude and latitude pairs.
+ * @param {number} count - The total number of points to sample.
+ * @param {Arc} inArc - The arc to sample from, containing p0, p1, and normal.
+ * @param {Vec3} cameraPosition - The position of the camera.
+ * @param {number} quaternionReuseCount - The number of times to apply the same rotation before recalculating. Higher is faster but less accurate.
+ */
+
+
+
+
+function _distanceSampling(
+    out: Float32Array,
+    count: number,
+    inArc: Arc,
+    cameraPosition: Vec3 = vec3create(0, 0, 0),
+    quaternionReuseCount: number = 1,
+): void {
+    if (count === 0) {
+        return;
+    }
+
+    const _0vector = vec3.create();
+    const _longLat = [0, 0] as LongLat;
+    const _rotationQuaternion = quat.create();
+
+    // Ensure reuse count is at least 1 to prevent division by zero or infinite loops.
+    const reuseCount = Math.max(1, quaternionReuseCount);
+
+    subtract(_0vector, inArc.p0, cameraPosition);
+    const d2_0 = lengthSquared(_0vector);
+    subtract(_0vector, inArc.p1, cameraPosition);
+    const d2_1 = lengthSquared(_0vector);
+
+    const total = d2_0 + d2_1;
+    const ratio0 = Math.min(0.995, Math.max(0.005, d2_0 / total));
+
+    const is0Closer = d2_0 < d2_1;
+
+    const totalAngle = Math.acos(dot(inArc.p0, inArc.p1));
+    let accumulatedAngle = 0;
+
+    // This variable will hold the step angle for the current "chunk" of reused rotations.
+    let chunkStepAngle = 0;
+
+    let currentPoint = vec3.clone(is0Closer ? inArc.p0 : inArc.p1);
+    const angleSign = is0Closer ? 1 : -1;
+
+    // The loop generates all points *except* the very last one.
+    for (let i = 0; i < count - 1; i++) {
+        // First, store the longitude/latitude of the current point.
+        fromUnitVectorToLongLat(_longLat, currentPoint);
+        out[i * 2] = _longLat[0];
+        out[i * 2 + 1] = _longLat[1];
+
+        // --- OPTIMIZATION LOGIC ---
+        // We only update the quaternion and step angle periodically.
+        if (i % reuseCount === 0) {
+            // This is the start of a new chunk. Calculate the step angle that will be
+            // reused for the next `reuseCount` iterations.
+            const t = (i + 1) / (count - 1);
+            const biasedT = Math.sin(t * Math.PI / 2);
+            const targetAngleForNextStep = (is0Closer ? biasedT : 1.0 - biasedT) * totalAngle;
+
+            // Calculate the single step angle based on the progress at the start of the chunk.
+            chunkStepAngle = targetAngleForNextStep - accumulatedAngle;
+
+            // Update the quaternion. This expensive call now runs much less frequently.
+            fromAxisAngle(_rotationQuaternion, inArc.normal, chunkStepAngle * angleSign);
+        }
+
+        // Apply the rotation. This happens on every iteration, but uses the
+        // same quaternion for `reuseCount` steps.
+        applyQuaternion(currentPoint, currentPoint, _rotationQuaternion);
+
+        // We must still update the accumulated angle on every step to track our progress.
+        accumulatedAngle += chunkStepAngle;
+    }
+
+    // Set the final point directly to the endpoint to guarantee precision.
+    if (count > 0) {
+        const finalIndex = count - 1;
+        const endPoint = is0Closer ? inArc.p1 : inArc.p0;
+        fromUnitVectorToLongLat(_longLat, endPoint);
+        out[finalIndex * 2] = _longLat[0];
+        out[finalIndex * 2 + 1] = _longLat[1];
+    }
+}
+
+export { create, set, copy, clone, isPointOn, equals, closestPoint, populatePoints };