@pirireis/webglobeplugins 0.17.1 → 1.0.2

package/Math/{arc-cdf-points.js → arc-cdf-points.ts}

@@ -1,272 +1,329 @@
-import { fromAxisAngle } from './quaternion';
-import { applyQuaternion, clone } from './vec3';
-// --- Utility Functions for 3D Vector Operations --- (Assumed to be the same as provided)
-/**
- * Normalizes a 3D vector to unit length.
- * @param v The input vector.
- * @returns The normalized vector. Returns [0,0,0] if the input vector is a zero vector.
- */
-function vec3Normalize(v) {
-    const len = Math.sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]);
-    if (len < 1e-9) { // Use a small epsilon to handle near-zero vectors
-        return [0, 0, 0];
-    }
-    return [v[0] / len, v[1] / len, v[2] / len];
-}
-/**
- * Calculates the dot product of two 3D vectors.
- * @param v1 The first vector.
- * @param v2 The second vector.
- * @returns The dot product.
- */
-function vec3Dot(v1, v2) {
-    return v1[0] * v2[0] + v1[1] * v2[1] + v1[2] * v2[2];
-}
-/**
- * Calculates the cross product of two 3D vectors.
- * @param v1 The first vector.
- * @param v2 The second vector.
- * @returns The cross product vector.
- */
-function vec3Cross(v1, v2) {
-    return [
-        v1[1] * v2[2] - v1[2] * v2[1],
-        v1[2] * v2[0] - v1[0] * v2[2],
-        v1[0] * v2[1] - v1[1] * v2[0]
-    ];
-}
-/**
- * Scales a 3D vector by a scalar.
- * @param v The input vector.
- * @param s The scalar value.
- * @returns The scaled vector.
- */
-function vec3Scale(v, s) {
-    return [v[0] * s, v[1] * s, v[2] * s];
-}
-/**
- * Adds two 3D vectors.
- * @param v1 The first vector.
- * @param v2 The second vector.
- * @returns The resulting vector.
- */
-function vec3Add(v1, v2) {
-    return [v1[0] + v2[0], v1[1] + v2[1], v1[2] + v2[2]];
-}
-/**
- * Subtracts the second 3D vector from the first.
- * @param v1 The first vector.
- * @param v2 The second vector.
- * @returns The resulting vector.
- */
-function vec3Sub(v1, v2) {
-    return [v1[0] - v2[0], v1[1] - v2[1], v1[2] - v2[2]];
-}
-/**
- * Clamps a numerical value within a specified range.
- * @param value The value to clamp.
- * @param min The minimum allowed value.
- * @param max The maximum allowed value.
- * @returns The clamped value.
- */
-function clamp(value, min, max) {
-    return Math.max(min, Math.min(value, max));
-}
-/**
- * Rotates a vector around a given axis by a specified angle using Rodrigues' rotation formula.
- * The axis must be a unit vector for correct results.
- * @param v The vector to rotate.
- * @param axis The unit axis of rotation.
- * @param angle The angle of rotation in radians.
- * @returns The rotated vector.
- */
-function rotateVector(v, axis, angle) {
-    const cosAngle = Math.cos(angle);
-    const sinAngle = Math.sin(angle);
-    const oneMinusCos = 1.0 - cosAngle;
-    const dotAxisV = vec3Dot(axis, v);
-    const crossAxisV = vec3Cross(axis, v);
-    // Rodrigues' rotation formula:
-    // v' = v * cos(angle) + (axis x v) * sin(angle) + axis * (axis . v) * (1 - cos(angle))
-    const term1 = vec3Scale(v, cosAngle);
-    const term2 = vec3Scale(crossAxisV, sinAngle);
-    const term3 = vec3Scale(axis, dotAxisV * oneMinusCos);
-    return vec3Add(vec3Add(term1, term2), term3);
-}
-// --- Main Function for Arc Point Generation (CORRECTED) ---
-/**
- * Generates points on the shortest arc between p0 and p1 on a unit sphere.
- * The arc is formed by rotating p0 around axisA. The density of points
- * is higher closer to the attractionPoint, controlled by an exponential falloff.
- *
- * @param p0 The starting point of the arc (will be normalized).
- * @param p1 The ending point of the arc (will be normalized).
- * @param axisA The axis of rotation (will be normalized).
- * @param attractionPoint The point on the unit sphere that attracts sampled points (will be normalized).
- * @param pointCount The total number of points to generate on the arc, including p0 and p1. > evenSpacedPointCount.
- * @param attractionStrength Controls the density bias via exponential decay.
- * A value of 0 results in uniform sampling.
- * Higher positive values (e.g., 10, 50, 200) result in exponentially stronger attraction.
- * @returns An array of `Vec3` representing the deterministically sampled points on the arc.
- */
-export function generateArcPoints(p0, p1, axisA, attractionPoint, pointCount, attractionStrength, adaptiveStrength = true, evenSpacedPointCount = null) {
-    // 0. Add evenly distanced points
-    let t_even_index = 0;
-    evenSpacedPointCount = evenSpacedPointCount ?? Math.floor(pointCount / 2.5);
-    const t_event = Array.from({ length: evenSpacedPointCount }, (_, i) => i / (evenSpacedPointCount - 1));
-    const sampledPoints = [];
-    const epsilon = 1e-9;
-    // 1. Normalize all input vectors
-    let nP0 = vec3Normalize(p0);
-    let nP1 = vec3Normalize(p1);
-    let nAxisA = vec3Normalize(axisA);
-    let nAttractionPoint = vec3Normalize(attractionPoint);
-    // Handle edge cases for pointCount
-    if (pointCount < 1)
-        return [];
-    if (pointCount === 1)
-        return [nP0];
-    // 2. Determine the total rotation angle
-    const p0Projected = vec3Sub(nP0, vec3Scale(nAxisA, vec3Dot(nP0, nAxisA)));
-    const p1Projected = vec3Sub(nP1, vec3Scale(nAxisA, vec3Dot(nP1, nAxisA)));
-    if (vec3Dot(p0Projected, p0Projected) < epsilon * epsilon || vec3Dot(p1Projected, p1Projected) < epsilon * epsilon) {
-        console.warn("generateArcPoints: p0 or p1 is colinear with axisA. Cannot form a valid arc. Falling back to linear interpolation.");
-        for (let i = 0; i < pointCount; i++) {
-            const t = i / (pointCount - 1);
-            sampledPoints.push(vec3Normalize(vec3Add(vec3Scale(nP0, 1 - t), vec3Scale(nP1, t))));
-        }
-        return sampledPoints;
-    }
-    const nP0Projected = vec3Normalize(p0Projected);
-    const nP1Projected = vec3Normalize(p1Projected);
-    const crossProj = vec3Cross(nP0Projected, nP1Projected);
-    const totalRotationAngle = Math.atan2(vec3Dot(crossProj, nAxisA), vec3Dot(nP0Projected, nP1Projected));
-    if (adaptiveStrength)
-        attractionStrength *= Math.pow(Math.max(1, (totalRotationAngle + 0.1)), 3); // Scale attraction strength by the arc length
-    if (Math.abs(totalRotationAngle) < epsilon) {
-        for (let i = 0; i < pointCount; i++)
-            sampledPoints.push(nP0);
-        return sampledPoints;
-    }
-    // 3. Find alpha_A: the angle parameter where the arc is closest to the attractionPoint
-    const alpha_A = (() => {
-        const dotProduct = vec3Dot(nP0, nAttractionPoint);
-        return Math.acos(dotProduct);
-    })();
-    // 4. Define the PDF and CDF based on an exponential decay model
-    const t_peak = totalRotationAngle !== 0 ? clamp(alpha_A / totalRotationAngle, 0, 1) : 0;
-    const s = Math.max(0, attractionStrength);
-    const area1 = (1 - Math.exp(-s * t_peak));
-    const area2 = (1 - Math.exp(-s * (1 - t_peak)));
-    const totalIntegratedArea = (area1 + area2) / s;
-    const cdfAtPeak = (area1 / s) / totalIntegratedArea;
-    // 5. Generate deterministic points using inverse transform sampling
-    for (let i = 0; i < pointCount - evenSpacedPointCount; i++) {
-        const u = (pointCount === 1) ? 0.5 : (i + 1) / (pointCount - evenSpacedPointCount + 1);
-        let t_sampled;
-        if (s < epsilon) {
-            t_sampled = u;
-        }
-        else {
-            // Correctly calculate the area under the two parts of the exponential PDF
-            if (totalIntegratedArea < epsilon) {
-                t_sampled = u; // Fallback for extreme strength values
-            }
-            else {
-                if (u <= cdfAtPeak) {
-                    // *** BUG FIX START ***
-                    // Correctly invert the CDF for the first part: [0, t_peak]
-                    const u_prime = u / cdfAtPeak;
-                    t_sampled = t_peak + Math.log(Math.exp(-s * t_peak) + u_prime * (1 - Math.exp(-s * t_peak))) / s;
-                }
-                else {
-                    // Correctly invert the CDF for the second part: [t_peak, 1]
-                    const u_double_prime = (u - cdfAtPeak) / (1 - cdfAtPeak);
-                    t_sampled = t_peak - Math.log(1 - u_double_prime * (1 - Math.exp(-s * (1 - t_peak)))) / s;
-                }
-                // *** BUG FIX END ***
-            }
-        }
-        t_sampled = clamp(t_sampled, 0, 1);
-        while (t_even_index < evenSpacedPointCount && t_sampled > t_event[t_even_index]) {
-            const actualRotationAngle = totalRotationAngle * t_event[t_even_index];
-            const currentPoint = rotateVector(nP0, nAxisA, actualRotationAngle);
-            sampledPoints.push(currentPoint);
-            t_even_index++;
-        }
-        const actualRotationAngle = totalRotationAngle * t_sampled;
-        const currentPoint = rotateVector(nP0, nAxisA, actualRotationAngle);
-        sampledPoints.push(currentPoint);
-    }
-    while (t_even_index < evenSpacedPointCount) {
-        const actualRotationAngle = totalRotationAngle * t_event[t_even_index];
-        const currentPoint = rotateVector(nP0, nAxisA, actualRotationAngle);
-        sampledPoints.push(currentPoint);
-        t_even_index++;
-    }
-    return sampledPoints;
-}
-const _rotationQuaternion = /*@__PURE__*/ [0, 0, 0, 1];
-export function evenlySpacedArcPoints(p0, axisA, coverAngle, pointCount) {
-    if (pointCount < 1)
-        return [];
-    if (pointCount === 1)
-        return [vec3Normalize(p0)];
-    const point = vec3Normalize(p0);
-    const stepAngle = coverAngle / (pointCount - 1);
-    fromAxisAngle(_rotationQuaternion, axisA, stepAngle);
-    const sampledPoints = new Array(pointCount);
-    sampledPoints[0] = clone(point);
-    // Start from index 1 since we already have the first point
-    for (let i = 1; i < pointCount; i++) {
-        applyQuaternion(point, point, _rotationQuaternion);
-        sampledPoints[i] = clone(point);
-    }
-    return sampledPoints;
-}
-// // --- Example Usage (for demonstration and testing) ---
-// // Example 1: Basic arc, very strong attraction point in the middle
-// const p0_ex1: Vec3 = [1, 0, 0];
-// const p1_ex1: Vec3 = [0, 1, 0]; // 90 deg rotation around Z-axis
-// const axisA_ex1: Vec3 = [0, 0, 1];
-// const attractionPoint_ex1: Vec3 = [Math.sqrt(0.5), Math.sqrt(0.5), 0]; // On the arc, middle of P0-P1
-// const numPoints_ex1 = 21;
-// const strength_ex1 = 50.0; // Very strong attraction with the new exponential model
-// console.log("--- Example 1: Attraction point in the middle of the arc (Exponentially Strong) ---");
-// const points1 = generateArcPoints(p0_ex1, p1_ex1, axisA_ex1, attractionPoint_ex1, numPoints_ex1, strength_ex1);
-// console.log(`Generated ${points1.length} points.`);
-// // With high strength, points should be extremely clustered around the attraction point.
-// const sequentialDistances1 = points1.map((p, i) => {
-//     if (i === 0) return 0;
-//     return vec3Distance(points1[i - 1], p);
-// });
-// console.log("Distances near the start:", sequentialDistances1.slice(1, 5).map(d => d.toFixed(5)));
-// console.log("Distances near the middle (attraction point):", sequentialDistances1.slice(9, 13).map(d => d.toFixed(5)));
-// console.log("Distances near the end:", sequentialDistances1.slice(-4).map(d => d.toFixed(5)));
-// // Expected: Distances near the middle should be MUCH smaller than at the ends.
-// // Example 2: Attraction point near p0, very high strength
-// const p0_ex2: Vec3 = [1, 0, 0];
-// const p1_ex2: Vec3 = [0, 1, 0];
-// const axisA_ex2: Vec3 = [0, 0, 1];
-// const attractionPoint_ex2: Vec3 = [0.99, 0.01, 0]; // Very close to P0
-// const numPoints_ex2 = 10;
-// const strength_ex2 = 100.0; // Extremely strong attraction
-// console.log("\n--- Example 2: Attraction point near the start (p0) ---");
-// const points2 = generateArcPoints(p0_ex2, p1_ex2, axisA_ex2, attractionPoint_ex2, numPoints_ex2, strength_ex2);
-// console.log(`Generated ${points2.length} points.`);
-// console.log("First 5 points (should be very close to each other and p0):", points2.slice(0, 5).map(p => p.map(coord => coord.toFixed(5))));
-// console.log("Last 5 points (should be very spread out):", points2.slice(-5).map(p => p.map(coord => coord.toFixed(5))));
-// // Example 4: No attraction (uniform distribution)
-// const p0_ex4: Vec3 = [1, 0, 0];
-// const p1_ex4: Vec3 = [0, 1, 0];
-// const axisA_ex4: Vec3 = [0, 0, 1];
-// const attractionPoint_ex4: Vec3 = [1, 0, 0]; // Irrelevant when strength is 0
-// const numPoints_ex4 = 11;
-// const strength_ex4 = 0.0; // No attraction (uniform)
-// console.log("\n--- Example 4: Uniform distribution (strength = 0) ---");
-// const points4 = generateArcPoints(p0_ex4, p1_ex4, axisA_ex4, attractionPoint_ex4, numPoints_ex4, strength_ex4);
-// const sequentialDistances4 = points4.map((p, i) => {
-//     if (i === 0) return 0;
-//     return vec3Distance(points4[i - 1], p);
-// });
-// console.log("Sequential distances (should be almost identical):", sequentialDistances4.slice(1).map(d => d.toFixed(5)));
+import { Radians, Vec3, Quaternion, } from './types';
+import { fromAxisAngle } from './quaternion';
+import { applyQuaternion, clone } from './vec3';
+// --- Utility Functions for 3D Vector Operations --- (Assumed to be the same as provided)
+
+/**
+ * Normalizes a 3D vector to unit length.
+ * @param v The input vector.
+ * @returns The normalized vector. Returns [0,0,0] if the input vector is a zero vector.
+ */
+function vec3Normalize(v: Vec3): Vec3 {
+    const len = Math.sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]);
+    if (len < 1e-9) { // Use a small epsilon to handle near-zero vectors
+        return [0, 0, 0];
+    }
+    return [v[0] / len, v[1] / len, v[2] / len];
+}
+
+/**
+ * Calculates the dot product of two 3D vectors.
+ * @param v1 The first vector.
+ * @param v2 The second vector.
+ * @returns The dot product.
+ */
+function vec3Dot(v1: Vec3, v2: Vec3): number {
+    return v1[0] * v2[0] + v1[1] * v2[1] + v1[2] * v2[2];
+}
+
+/**
+ * Calculates the cross product of two 3D vectors.
+ * @param v1 The first vector.
+ * @param v2 The second vector.
+ * @returns The cross product vector.
+ */
+function vec3Cross(v1: Vec3, v2: Vec3): Vec3 {
+    return [
+        v1[1] * v2[2] - v1[2] * v2[1],
+        v1[2] * v2[0] - v1[0] * v2[2],
+        v1[0] * v2[1] - v1[1] * v2[0]
+    ];
+}
+
+/**
+ * Scales a 3D vector by a scalar.
+ * @param v The input vector.
+ * @param s The scalar value.
+ * @returns The scaled vector.
+ */
+function vec3Scale(v: Vec3, s: number): Vec3 {
+    return [v[0] * s, v[1] * s, v[2] * s];
+}
+
+/**
+ * Adds two 3D vectors.
+ * @param v1 The first vector.
+ * @param v2 The second vector.
+ * @returns The resulting vector.
+ */
+function vec3Add(v1: Vec3, v2: Vec3): Vec3 {
+    return [v1[0] + v2[0], v1[1] + v2[1], v1[2] + v2[2]];
+}
+
+/**
+ * Subtracts the second 3D vector from the first.
+ * @param v1 The first vector.
+ * @param v2 The second vector.
+ * @returns The resulting vector.
+ */
+function vec3Sub(v1: Vec3, v2: Vec3): Vec3 {
+    return [v1[0] - v2[0], v1[1] - v2[1], v1[2] - v2[2]];
+}
+
+/**
+ * Clamps a numerical value within a specified range.
+ * @param value The value to clamp.
+ * @param min The minimum allowed value.
+ * @param max The maximum allowed value.
+ * @returns The clamped value.
+ */
+function clamp(value: number, min: number, max: number): number {
+    return Math.max(min, Math.min(value, max));
+}
+
+
+
+
+/**
+ * Rotates a vector around a given axis by a specified angle using Rodrigues' rotation formula.
+ * The axis must be a unit vector for correct results.
+ * @param v The vector to rotate.
+ * @param axis The unit axis of rotation.
+ * @param angle The angle of rotation in radians.
+ * @returns The rotated vector.
+ */
+function rotateVector(v: Vec3, axis: Vec3, angle: number): Vec3 {
+    const cosAngle = Math.cos(angle);
+    const sinAngle = Math.sin(angle);
+    const oneMinusCos = 1.0 - cosAngle;
+
+    const dotAxisV = vec3Dot(axis, v);
+    const crossAxisV = vec3Cross(axis, v);
+
+    // Rodrigues' rotation formula:
+    // v' = v * cos(angle) + (axis x v) * sin(angle) + axis * (axis . v) * (1 - cos(angle))
+    const term1 = vec3Scale(v, cosAngle);
+    const term2 = vec3Scale(crossAxisV, sinAngle);
+    const term3 = vec3Scale(axis, dotAxisV * oneMinusCos);
+
+    return vec3Add(vec3Add(term1, term2), term3);
+}
+
+// --- Main Function for Arc Point Generation (CORRECTED) ---
+
+/**
+ * Generates points on the shortest arc between p0 and p1 on a unit sphere.
+ * The arc is formed by rotating p0 around axisA. The density of points
+ * is higher closer to the attractionPoint, controlled by an exponential falloff.
+ *
+ * @param p0 The starting point of the arc (will be normalized).
+ * @param p1 The ending point of the arc (will be normalized).
+ * @param axisA The axis of rotation (will be normalized).
+ * @param attractionPoint The point on the unit sphere that attracts sampled points (will be normalized).
+ * @param pointCount The total number of points to generate on the arc, including p0 and p1. > evenSpacedPointCount.
+ * @param attractionStrength Controls the density bias via exponential decay.
+ * A value of 0 results in uniform sampling.
+ * Higher positive values (e.g., 10, 50, 200) result in exponentially stronger attraction.
+ * @returns An array of `Vec3` representing the deterministically sampled points on the arc.
+ */
+export function generateArcPoints(
+    p0: Vec3,
+    p1: Vec3,
+    axisA: Vec3,
+    attractionPoint: Vec3,
+    pointCount: number,
+    attractionStrength: number,
+    adaptiveStrength: boolean = true,
+    evenSpacedPointCount: number | null = null
+): Vec3[] {
+    // 0. Add evenly distanced points
+    let t_even_index = 0;
+    evenSpacedPointCount = evenSpacedPointCount ?? Math.floor(pointCount / 2.5);
+    const t_event = Array.from({ length: evenSpacedPointCount }, (_, i) => i / (evenSpacedPointCount - 1));
+
+    const sampledPoints: Vec3[] = [];
+    const epsilon = 1e-9;
+
+    // 1. Normalize all input vectors
+    let nP0 = vec3Normalize(p0);
+    let nP1 = vec3Normalize(p1);
+    let nAxisA = vec3Normalize(axisA);
+    let nAttractionPoint = vec3Normalize(attractionPoint);
+
+    // Handle edge cases for pointCount
+    if (pointCount < 1) return [];
+    if (pointCount === 1) return [nP0];
+
+    // 2. Determine the total rotation angle
+    const p0Projected = vec3Sub(nP0, vec3Scale(nAxisA, vec3Dot(nP0, nAxisA)));
+    const p1Projected = vec3Sub(nP1, vec3Scale(nAxisA, vec3Dot(nP1, nAxisA)));
+
+    if (vec3Dot(p0Projected, p0Projected) < epsilon * epsilon || vec3Dot(p1Projected, p1Projected) < epsilon * epsilon) {
+        console.warn("generateArcPoints: p0 or p1 is colinear with axisA. Cannot form a valid arc. Falling back to linear interpolation.");
+        for (let i = 0; i < pointCount; i++) {
+            const t = i / (pointCount - 1);
+            sampledPoints.push(vec3Normalize(vec3Add(vec3Scale(nP0, 1 - t), vec3Scale(nP1, t))));
+        }
+        return sampledPoints;
+    }
+
+    const nP0Projected = vec3Normalize(p0Projected);
+    const nP1Projected = vec3Normalize(p1Projected);
+    const crossProj = vec3Cross(nP0Projected, nP1Projected);
+    const totalRotationAngle = Math.atan2(vec3Dot(crossProj, nAxisA), vec3Dot(nP0Projected, nP1Projected));
+    if (adaptiveStrength) attractionStrength *= Math.pow(Math.max(1, (totalRotationAngle + 0.1)), 3); // Scale attraction strength by the arc length
+
+    if (Math.abs(totalRotationAngle) < epsilon) {
+        for (let i = 0; i < pointCount; i++) sampledPoints.push(nP0);
+        return sampledPoints;
+    }
+
+    // 3. Find alpha_A: the angle parameter where the arc is closest to the attractionPoint
+
+    const alpha_A = (() => {
+        const dotProduct = vec3Dot(nP0, nAttractionPoint);
+        return Math.acos(dotProduct);
+    })()
+
+    // 4. Define the PDF and CDF based on an exponential decay model
+    const t_peak = totalRotationAngle !== 0 ? clamp(alpha_A / totalRotationAngle, 0, 1) : 0;
+    const s = Math.max(0, attractionStrength);
+
+    const area1 = (1 - Math.exp(-s * t_peak));
+    const area2 = (1 - Math.exp(-s * (1 - t_peak)));
+    const totalIntegratedArea = (area1 + area2) / s;
+    const cdfAtPeak = (area1 / s) / totalIntegratedArea;
+
+    // 5. Generate deterministic points using inverse transform sampling
+    for (let i = 0; i < pointCount - evenSpacedPointCount; i++) {
+        const u = (pointCount === 1) ? 0.5 : (i + 1) / (pointCount - evenSpacedPointCount + 1);
+        let t_sampled: number;
+
+        if (s < epsilon) {
+            t_sampled = u;
+        } else {
+            // Correctly calculate the area under the two parts of the exponential PDF
+
+
+            if (totalIntegratedArea < epsilon) {
+                t_sampled = u; // Fallback for extreme strength values
+            } else {
+                if (u <= cdfAtPeak) {
+                    // *** BUG FIX START ***
+                    // Correctly invert the CDF for the first part: [0, t_peak]
+                    const u_prime = u / cdfAtPeak;
+                    t_sampled = t_peak + Math.log(Math.exp(-s * t_peak) + u_prime * (1 - Math.exp(-s * t_peak))) / s;
+                } else {
+                    // Correctly invert the CDF for the second part: [t_peak, 1]
+                    const u_double_prime = (u - cdfAtPeak) / (1 - cdfAtPeak);
+                    t_sampled = t_peak - Math.log(1 - u_double_prime * (1 - Math.exp(-s * (1 - t_peak)))) / s;
+                }
+                // *** BUG FIX END ***
+            }
+        }
+
+        t_sampled = clamp(t_sampled, 0, 1);
+
+
+        while (t_even_index < evenSpacedPointCount && t_sampled > t_event[t_even_index]) {
+            const actualRotationAngle = totalRotationAngle * t_event[t_even_index];
+            const currentPoint = rotateVector(nP0, nAxisA, actualRotationAngle);
+            sampledPoints.push(currentPoint);
+            t_even_index++;
+        }
+
+        const actualRotationAngle = totalRotationAngle * t_sampled;
+        const currentPoint = rotateVector(nP0, nAxisA, actualRotationAngle);
+        sampledPoints.push(currentPoint);
+    }
+
+    while (t_even_index < evenSpacedPointCount) {
+        const actualRotationAngle = totalRotationAngle * t_event[t_even_index];
+        const currentPoint = rotateVector(nP0, nAxisA, actualRotationAngle);
+        sampledPoints.push(currentPoint);
+        t_even_index++;
+    }
+    return sampledPoints;
+}
+
+
+const _rotationQuaternion = /*@__PURE__*/[0, 0, 0, 1] as Quaternion;
+
+export function evenlySpacedArcPoints(
+    p0: Vec3,
+    axisA: Vec3,
+    coverAngle: Radians,
+    pointCount: number
+): Vec3[] {
+    if (pointCount < 1) return [];
+    if (pointCount === 1) return [vec3Normalize(p0)];
+
+    const point = vec3Normalize(p0);
+    const stepAngle = coverAngle / (pointCount - 1);
+    fromAxisAngle(_rotationQuaternion, axisA, stepAngle);
+
+    const sampledPoints: Vec3[] = new Array<Vec3>(pointCount);
+    sampledPoints[0] = clone(point);
+
+    // Start from index 1 since we already have the first point
+    for (let i = 1; i < pointCount; i++) {
+        applyQuaternion(point, point, _rotationQuaternion);
+        sampledPoints[i] = clone(point);
+    }
+
+    return sampledPoints;
+}
+
+// // --- Example Usage (for demonstration and testing) ---
+
+// // Example 1: Basic arc, very strong attraction point in the middle
+// const p0_ex1: Vec3 = [1, 0, 0];
+// const p1_ex1: Vec3 = [0, 1, 0]; // 90 deg rotation around Z-axis
+// const axisA_ex1: Vec3 = [0, 0, 1];
+// const attractionPoint_ex1: Vec3 = [Math.sqrt(0.5), Math.sqrt(0.5), 0]; // On the arc, middle of P0-P1
+// const numPoints_ex1 = 21;
+// const strength_ex1 = 50.0; // Very strong attraction with the new exponential model
+
+// console.log("--- Example 1: Attraction point in the middle of the arc (Exponentially Strong) ---");
+// const points1 = generateArcPoints(p0_ex1, p1_ex1, axisA_ex1, attractionPoint_ex1, numPoints_ex1, strength_ex1);
+// console.log(`Generated ${points1.length} points.`);
+// // With high strength, points should be extremely clustered around the attraction point.
+// const sequentialDistances1 = points1.map((p, i) => {
+//     if (i === 0) return 0;
+//     return vec3Distance(points1[i - 1], p);
+// });
+// console.log("Distances near the start:", sequentialDistances1.slice(1, 5).map(d => d.toFixed(5)));
+// console.log("Distances near the middle (attraction point):", sequentialDistances1.slice(9, 13).map(d => d.toFixed(5)));
+// console.log("Distances near the end:", sequentialDistances1.slice(-4).map(d => d.toFixed(5)));
+// // Expected: Distances near the middle should be MUCH smaller than at the ends.
+
+// // Example 2: Attraction point near p0, very high strength
+// const p0_ex2: Vec3 = [1, 0, 0];
+// const p1_ex2: Vec3 = [0, 1, 0];
+// const axisA_ex2: Vec3 = [0, 0, 1];
+// const attractionPoint_ex2: Vec3 = [0.99, 0.01, 0]; // Very close to P0
+// const numPoints_ex2 = 10;
+// const strength_ex2 = 100.0; // Extremely strong attraction
+
+// console.log("\n--- Example 2: Attraction point near the start (p0) ---");
+// const points2 = generateArcPoints(p0_ex2, p1_ex2, axisA_ex2, attractionPoint_ex2, numPoints_ex2, strength_ex2);
+// console.log(`Generated ${points2.length} points.`);
+// console.log("First 5 points (should be very close to each other and p0):", points2.slice(0, 5).map(p => p.map(coord => coord.toFixed(5))));
+// console.log("Last 5 points (should be very spread out):", points2.slice(-5).map(p => p.map(coord => coord.toFixed(5))));
+
+
+// // Example 4: No attraction (uniform distribution)
+// const p0_ex4: Vec3 = [1, 0, 0];
+// const p1_ex4: Vec3 = [0, 1, 0];
+// const axisA_ex4: Vec3 = [0, 0, 1];
+// const attractionPoint_ex4: Vec3 = [1, 0, 0]; // Irrelevant when strength is 0
+// const numPoints_ex4 = 11;
+// const strength_ex4 = 0.0; // No attraction (uniform)
+
+// console.log("\n--- Example 4: Uniform distribution (strength = 0) ---");
+// const points4 = generateArcPoints(p0_ex4, p1_ex4, axisA_ex4, attractionPoint_ex4, numPoints_ex4, strength_ex4);
+// const sequentialDistances4 = points4.map((p, i) => {
+//     if (i === 0) return 0;
+//     return vec3Distance(points4[i - 1], p);
+// });
+// console.log("Sequential distances (should be almost identical):", sequentialDistances4.slice(1).map(d => d.toFixed(5)));