@pirireis/webglobeplugins 0.17.0 → 1.0.2

package/Math/{arc.js → arc.ts}

@@ -1,292 +1,421 @@
-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];
-// Normalize angles to [0, 2π)
-function normalizeLon(angle) {
-    while (angle < 0)
-        angle += 2 * Math.PI;
-    while (angle >= 2 * Math.PI)
-        angle -= 2 * Math.PI;
-    return angle;
-}
-;
-function create(p0, p1) {
-    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;
-    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);
-        distance = tempPlane.distance;
-    }
-    return {
-        p0: vec3clone(p0),
-        p1: vec3clone(p1),
-        normal: vec3clone(normal),
-        coverPlane: {
-            normal: coverPlaneNormal,
-            distance: distance
-        },
-        coverAngle: Math.acos(dot(p0, p1))
-    };
-}
-function set(out, p0, p1) {
-    vec3copy(out.p0, p0);
-    vec3copy(out.p1, p1);
-    cross(out.normal, p0, p1);
-    normalize(out.normal, out.normal); // ← ADD THIS LINE - normalize the normal vector!
-    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);
-    }
-    // Also update coverAngle to match what create() does
-    out.coverAngle = Math.acos(dot(p0, p1));
-}
-function copy(out, a) {
-    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) {
-    return {
-        p0: vec3clone(a.p0),
-        p1: vec3clone(a.p1),
-        normal: vec3clone(a.normal),
-        coverPlane: {
-            normal: vec3clone(a.coverPlane.normal),
-            distance: a.coverPlane.distance
-        },
-        coverAngle: a.coverAngle // Clone coverAngle if it exists
-    };
-}
-function isPointOn(arc, point) {
-    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, b) {
-    return (vec3equals(a.p0, b.p0) && vec3equals(a.p1, b.p1))
-        || (vec3equals(a.p0, b.p1) && vec3equals(a.p1, b.p0));
-}
-function closestPoint(out, inArc, point) {
-    // 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, arc, count, pointOfProjection = undefined) {
-    // rotate p0 around normal vector with a quaternion
-    // calculate angle
-    _distanceSampling(out, count, arc, pointOfProjection || [0, 0, 0], 1);
-}
-function _oppositePointsHandle(p0, p1, outNormal, outCoverPlane) {
-    // first choice pass through Anitkabir 
-    const radians = Math.PI / 180;
-    fromLongLatToUnitVector(_0vector, [39.9334 * radians, 32.8597 * radians]); // 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]); // Selanic
-    }
-    planeFromPoints({ normal: outNormal, distance: 0 }, p0, _0vector, p1);
-    cross(outCoverPlane.normal, outNormal, p0);
-    normalize(outCoverPlane.normal, outCoverPlane.normal);
-}
-function _populatePointsWithClosestPointInsideArc(out, arc, count, closestPoint) {
-    // 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, count, inArc, cameraPosition = vec3create(0, 0, 0), quaternionReuseCount = 1) {
-    if (count === 0) {
-        return;
-    }
-    const _0vector = vec3.create();
-    const _longLat = [0, 0];
-    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];
-    }
-}
-function calculateZLimitPoint(inArc, out) {
-    // The arc's plane is perpendicular to the equator, so the arc is on the equator.
-    // All points have z=0, so there's no unique z-limit point.
-    if (Math.abs(inArc.normal[2]) > 1 - EPSILON) {
-        return false;
-    }
-    // The Z-limit points of a great circle are the two points on it that are
-    // closest to the North and South poles. Their 3D coordinates can be
-    // calculated from the normal vector of the great circle's plane.
-    const nz = inArc.normal[2];
-    const n_xy_len = Math.sqrt(inArc.normal[0] * inArc.normal[0] + inArc.normal[1] * inArc.normal[1]);
-    // Candidate 1: Highest Z value (closest to North Pole)
-    const p_max_z = vec3.create(-inArc.normal[0] * nz / n_xy_len, -inArc.normal[1] * nz / n_xy_len, n_xy_len);
-    // Candidate 2: Lowest Z value (closest to South Pole)
-    const p_min_z = vec3.create(inArc.normal[0] * nz / n_xy_len, inArc.normal[1] * nz / n_xy_len, -n_xy_len);
-    // Now, we check if either of these points lie on the given arc segment.
-    // A point is on the shorter arc if its projection onto the cover plane's
-    // normal is on the positive side.
-    const d_max = dot(p_max_z, inArc.coverPlane.normal);
-    const d_min = dot(p_min_z, inArc.coverPlane.normal);
-    if (d_max >= inArc.coverPlane.distance - EPSILON) {
-        vec3.copy(out, p_max_z);
-        return true;
-    }
-    if (d_min >= inArc.coverPlane.distance - EPSILON) {
-        vec3.copy(out, p_min_z);
-        return true;
-    }
-    return false;
-}
-function doesArcPassThroughMeridian(inArc, meridians) {
-    const result = new Array(meridians.length).fill(false);
-    // Get longitude angles for p0 and p1
-    const p0Lon = Math.atan2(inArc.p0[1], inArc.p0[0]);
-    const p1Lon = Math.atan2(inArc.p1[1], inArc.p1[0]);
-    if (inArc.p0[2] >= 1 - EPSILON || inArc.p1[2] >= 1 - EPSILON) {
-        return result;
-    }
-    const p0LonNorm = normalizeLon(p0Lon);
-    const p1LonNorm = normalizeLon(p1Lon);
-    // Determine if we're taking the shorter or longer arc
-    let startLon = p0LonNorm;
-    let endLon = p1LonNorm;
-    // Calculate the angular difference both ways
-    const diff1 = normalizeLon(endLon - startLon);
-    // Take the shorter path (great circle property)
-    const takeShorterPath = diff1 <= Math.PI;
-    if (!takeShorterPath) {
-        // Swap start and end for the shorter path
-        [startLon, endLon] = [endLon, startLon];
-    }
-    for (let i = 0; i < meridians.length; i++) {
-        const meridian = normalizeLon(meridians[i]);
-        // Check if meridian is between start and end longitudes
-        if (takeShorterPath) {
-            if (startLon <= endLon) {
-                // Normal case: no wraparound
-                result[i] = meridian >= startLon && meridian <= endLon;
-            }
-            else {
-                // Wraparound case: arc crosses 0°/360°
-                result[i] = meridian >= startLon || meridian <= endLon;
-            }
-        }
-        else {
-            // Taking the longer path
-            if (startLon <= endLon) {
-                // Arc goes the long way around
-                result[i] = meridian <= startLon || meridian >= endLon;
-            }
-            else {
-                // Normal case for long path
-                result[i] = meridian >= endLon && meridian <= startLon;
-            }
-        }
-    }
-    return result;
-}
-export { create, set, copy, clone, isPointOn, equals, closestPoint, populatePoints, calculateZLimitPoint, doesArcPassThroughMeridian };
+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";
+import { Radian } from "../types";
+
+
+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;
+
+
+
+// Normalize angles to [0, 2π)
+function normalizeLon(angle: number): number {
+    while (angle < 0) angle += 2 * Math.PI;
+    while (angle >= 2 * Math.PI) angle -= 2 * Math.PI;
+    return angle;
+};
+
+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);
+        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);
+    normalize(out.normal, out.normal); // ← ADD THIS LINE - normalize the normal vector!
+
+    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);
+    }
+
+    // Also update coverAngle to match what create() does
+    out.coverAngle = Math.acos(dot(p0, p1)) as Radians;
+}
+
+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);
+    normalize(outCoverPlane.normal, outCoverPlane.normal);
+
+}
+
+
+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];
+    }
+}
+
+
+function calculateZLimitPoint(inArc: Arc, out: Vec3): boolean {
+    // The arc's plane is perpendicular to the equator, so the arc is on the equator.
+    // All points have z=0, so there's no unique z-limit point.
+    if (Math.abs(inArc.normal[2]) > 1 - EPSILON) {
+        return false;
+    }
+
+    // The Z-limit points of a great circle are the two points on it that are
+    // closest to the North and South poles. Their 3D coordinates can be
+    // calculated from the normal vector of the great circle's plane.
+    const nz = inArc.normal[2];
+    const n_xy_len = Math.sqrt(inArc.normal[0] * inArc.normal[0] + inArc.normal[1] * inArc.normal[1]);
+
+    // Candidate 1: Highest Z value (closest to North Pole)
+    const p_max_z = vec3.create(
+        -inArc.normal[0] * nz / n_xy_len,
+        -inArc.normal[1] * nz / n_xy_len,
+        n_xy_len
+    );
+
+    // Candidate 2: Lowest Z value (closest to South Pole)
+    const p_min_z = vec3.create(
+        inArc.normal[0] * nz / n_xy_len,
+        inArc.normal[1] * nz / n_xy_len,
+        -n_xy_len
+    );
+
+    // Now, we check if either of these points lie on the given arc segment.
+    // A point is on the shorter arc if its projection onto the cover plane's
+    // normal is on the positive side.
+    const d_max = dot(p_max_z, inArc.coverPlane.normal);
+    const d_min = dot(p_min_z, inArc.coverPlane.normal);
+
+    if (d_max >= inArc.coverPlane.distance - EPSILON) {
+        vec3.copy(out, p_max_z);
+        return true;
+    }
+
+    if (d_min >= inArc.coverPlane.distance - EPSILON) {
+        vec3.copy(out, p_min_z);
+        return true;
+    }
+
+    return false;
+}
+
+
+
+function doesArcPassThroughMeridian(inArc: Arc, meridians: Radians[]): boolean[] {
+    const result = new Array<boolean>(meridians.length).fill(false);
+
+    // Get longitude angles for p0 and p1
+    const p0Lon = Math.atan2(inArc.p0[1], inArc.p0[0]);
+    const p1Lon = Math.atan2(inArc.p1[1], inArc.p1[0]);
+
+    if (inArc.p0[2] >= 1 - EPSILON || inArc.p1[2] >= 1 - EPSILON) {
+        return result
+    }
+
+    const p0LonNorm = normalizeLon(p0Lon);
+    const p1LonNorm = normalizeLon(p1Lon);
+
+    // Determine if we're taking the shorter or longer arc
+    let startLon = p0LonNorm;
+    let endLon = p1LonNorm;
+
+    // Calculate the angular difference both ways
+    const diff1 = normalizeLon(endLon - startLon);
+
+    // Take the shorter path (great circle property)
+    const takeShorterPath = diff1 <= Math.PI;
+
+    if (!takeShorterPath) {
+        // Swap start and end for the shorter path
+        [startLon, endLon] = [endLon, startLon];
+    }
+
+    for (let i = 0; i < meridians.length; i++) {
+        const meridian = normalizeLon(meridians[i]);
+
+        // Check if meridian is between start and end longitudes
+        if (takeShorterPath) {
+            if (startLon <= endLon) {
+                // Normal case: no wraparound
+                result[i] = meridian >= startLon && meridian <= endLon;
+            } else {
+                // Wraparound case: arc crosses 0°/360°
+                result[i] = meridian >= startLon || meridian <= endLon;
+            }
+        } else {
+            // Taking the longer path
+            if (startLon <= endLon) {
+                // Arc goes the long way around
+                result[i] = meridian <= startLon || meridian >= endLon;
+            } else {
+                // Normal case for long path
+                result[i] = meridian >= endLon && meridian <= startLon;
+            }
+        }
+    }
+
+    return result;
+}
+
+
+export { create, set, copy, clone, isPointOn, equals, closestPoint, populatePoints, calculateZLimitPoint, doesArcPassThroughMeridian };