npm - @pirireis/webglobeplugins - Versions diffs - 1.0.2 → 1.0.4 - Mend

@pirireis/webglobeplugins 1.0.2 → 1.0.4

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (277) hide show

package/{Math/arc.ts → webglobeplugins/Math/arc.js} RENAMED Viewed

@@ -1,421 +1,292 @@
-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 };
+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 };