@pirireis/webglobeplugins 0.9.14 → 0.10.0-alpha

package/Math/arc.js

@@ -1,62 +1,190 @@
-import { vec3 } from "./vec3";
+import { create as vec3create, set as vec3set, cross, dot, normalize, clone as vec3clone, copy as vec3copy, equals as vec3equals, lengthSquared, fromUnitVectorLongLat, subtract, applyQuaternion, toUnitVectorLongLat } 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";
-const _0vector = /*@__PURE__*/ vec3.create(0, 0, 0);
-const _1vector = /*@__PURE__*/ vec3.create(1, 1, 1);
-export const arc = Object.freeze({
-    create(p0, p1) {
-        const normal = vec3.create(0, 0, 0);
-        vec3.cross(normal, p0, p1);
-        const coverPlaneNormal = [p0[0] + p1[0], p0[1] + p1[1], p0[2] + p1[2]];
-        vec3.normalize(coverPlaneNormal, coverPlaneNormal);
-        const dot = vec3.dot(coverPlaneNormal, p0);
-        return {
-            p0: vec3.clone(p0),
-            p1: vec3.clone(p1),
-            normal: vec3.clone(normal),
-            coverPlane: {
-                normal: coverPlaneNormal,
-                distance: dot
-            }
-        };
-    },
-    set(out, p0, p1) {
-        vec3.copy(out.p0, p0);
-        vec3.copy(out.p1, p1);
-        vec3.cross(out.normal, p0, p1);
-        const coverPlaneNormal = [p0[0] + p1[0], p0[1] + p1[1], p0[2] + p1[2]];
-        vec3.normalize(coverPlaneNormal, coverPlaneNormal);
-        out.coverPlane.normal = coverPlaneNormal;
-        out.coverPlane.distance = vec3.dot(coverPlaneNormal, p0);
-    },
-    copy(out, a) {
-        vec3.copy(out.p0, a.p0);
-        vec3.copy(out.p1, a.p1);
-        vec3.copy(out.normal, a.normal);
-        out.coverPlane.normal = vec3.clone(a.coverPlane.normal);
-        out.coverPlane.distance = a.coverPlane.distance;
-    },
-    clone(a) {
-        return {
-            p0: vec3.clone(a.p0),
-            p1: vec3.clone(a.p1),
-            normal: vec3.clone(a.normal),
-            coverPlane: {
-                normal: vec3.clone(a.coverPlane.normal),
-                distance: a.coverPlane.distance
-            }
-        };
-    },
-    isPointOn(arc, point) {
-        const alignment = Math.abs(vec3.dot(point, arc.normal)) < EPSILON;
-        const distance = Math.abs(vec3.lengthSquared(point) - 1) < EPSILON;
-        const cover = vec3.dot(arc.coverPlane.normal, point) >= arc.coverPlane.distance;
-        return alignment || distance || cover;
-    },
-    equals(a, b) {
-        return vec3.equals(a.p0, b.p0) && vec3.equals(a.p1, b.p1);
-    },
-    populatePoints(out, arc, count) {
-        // rotate p0 around normal vector with a quaternion
-        // calculate angle
+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];
+function create(p0, p1) {
+    const normal = vec3create(0, 0, 0);
+    cross(normal, p0, p1);
+    const coverPlaneNormal = [p0[0] + p1[0], p0[1] + p1[1], p0[2] + p1[2]];
+    normalize(coverPlaneNormal, coverPlaneNormal);
+    const dot_ = dot(coverPlaneNormal, p0);
+    return {
+        p0: vec3clone(p0),
+        p1: vec3clone(p1),
+        normal: vec3clone(normal),
+        coverPlane: {
+            normal: coverPlaneNormal,
+            distance: dot_
+        }
+    };
+}
+function set(out, p0, p1) {
+    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, 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;
+}
+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
+        }
+    };
+}
+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;
+    fromUnitVectorLongLat(_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
+        fromUnitVectorLongLat(_0vector, [37.0016 * radians, 35.3213 * radians]); // Selanic
+    }
+    planeFromPoints({ normal: outNormal, distance: 0 }, p0, _0vector, p1);
+    cross(outCoverPlane.normal, outNormal, p0);
+}
+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);
+}
+function _populatePointsWithoutClosestPoint(out, arc, count) {
+}
+/**
+ * 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), // TODO
+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.
+        toUnitVectorLongLat(_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;
+        toUnitVectorLongLat(_longLat, endPoint);
+        out[finalIndex * 2] = _longLat[0];
+        out[finalIndex * 2 + 1] = _longLat[1];
+    }
+}
+export { create, set, copy, clone, isPointOn, equals, closestPoint, populatePoints };

package/Math/juction/arc-plane.js

@@ -1,45 +1,53 @@
 import { EPSILON } from "../constants";
-import { vec3 } from "../vec3";
-import { line } from "../line";
-import { plane } from "../plane";
-import { arc } from "../arc";
+import { create as vec3create, copy as vec3copy, dot, distanceSquared, } from "../vec3";
+import { create as lineCreate } from "../line";
+import { create as planeCreate, distanceToPoint, getUnitSphereRadiusAngle } from "../plane";
+import { copy as arcCopy, set as arcSet } from "../arc";
 import { planePlaneJuction } from "./plane-plane";
 import { lineSphereIntersection } from "./line-sphere";
-const _intersectionLine = /*@__PURE__*/ line.create();
-const _originPlane = /*@__PURE__*/ plane.create();
+const _intersectionLine = /*@__PURE__*/ lineCreate();
+const _originPlane = /*@__PURE__*/ planeCreate();
 _originPlane.distance = 0;
-const _originSphere = /*@__PURE__*/ { center: vec3.create(0, 0, 0), radius: 1 };
-const _intersectionPoints = /*@__PURE__*/ [vec3.create(), vec3.create()];
+const _originSphere = /*@__PURE__*/ { center: vec3create(0, 0, 0), radius: 1 };
+const _intersectionPoints = /*@__PURE__*/ [vec3create(), vec3create()];
 // TODO: out must be [Arc, Arc] there is a case where split into three arcs, visible by points or arcs but middle is not visible
 /**
  *
  * @param out \
  * @param inArc
- * @param juctionPlane
+ * @param junctionPlane
  * @returns number of arcs segments in the junction divided by the junction plane.
  */
-export function arcSlice(out, inArc, juctionPlane) {
+export function arcSlice(out, inArc, junctionPlane) {
+    if (junctionPlane.distance < -1 + EPSILON) {
+        arcCopy(out[0], inArc);
+        return 1;
+    }
     // arc coverPlane and junctionPlane intersection exist in the range of unit sphere
-    const coverRadiusAngle = plane.getUnitSphereRadiusAngle(inArc.coverPlane);
-    const visibleRadiusAngle = plane.getUnitSphereRadiusAngle(juctionPlane);
+    const coverRadiusAngle = getUnitSphereRadiusAngle(inArc.coverPlane);
+    const visibleRadiusAngle = getUnitSphereRadiusAngle(junctionPlane);
     // TODO: RESEARCH efficient approach --
-    const angleBetween_Cover_Visible = Math.acos(vec3.dot(inArc.coverPlane.normal, juctionPlane.normal));
+    const angleBetween_Cover_Visible = Math.acos(dot(inArc.coverPlane.normal, junctionPlane.normal));
     if (coverRadiusAngle + visibleRadiusAngle < angleBetween_Cover_Visible - EPSILON) { // case A: out of range
         return 0; // No intersection
     }
     // ------------------------------------
     // the case when the arc is completely covered by the juction plane
     if (visibleRadiusAngle + EPSILON >= angleBetween_Cover_Visible + coverRadiusAngle) { // case B: fully visible
-        arc.copy(out[0], inArc);
+        arcCopy(out[0], inArc);
         return 1;
     }
     // plane-plane intersection line should be calculated for the rest of the calculations
-    vec3.copy(_originPlane.normal, inArc.normal);
-    const isPlaneJunctions = planePlaneJuction(_intersectionLine, _originPlane, juctionPlane);
+    vec3copy(_originPlane.normal, inArc.normal);
+    const isPlaneJunctions = planePlaneJuction(_intersectionLine, _originPlane, junctionPlane);
     if (!isPlaneJunctions) { // case C: planes are parallel. 
-        // case A covers opposite directions
-        // case B Covers they face each other
-        throw new Error("Unexpected case: planes are parallel, case A and B should Cover it");
+        if (junctionPlane.distance <= 0) {
+            arcCopy(out[0], inArc);
+            return 1; // No intersection
+        }
+        else {
+            return 0; // No intersection
+        }
     }
     // --- read until here ---
     // calculate the intersection points
@@ -48,33 +56,33 @@ export function arcSlice(out, inArc, juctionPlane) {
         // other edge caes should be covered by now
         return 0; // No intersection
     }
-    const i0IsCovered = plane.distanceToPoint(inArc.coverPlane, _intersectionPoints[0]) > -EPSILON;
-    const i1IsCovered = plane.distanceToPoint(inArc.coverPlane, _intersectionPoints[1]) > -EPSILON;
-    const p0IsVisible = plane.distanceToPoint(juctionPlane, inArc.p0) > -EPSILON;
-    const p1IsVisible = plane.distanceToPoint(juctionPlane, inArc.p1) > -EPSILON;
+    const i0IsCovered = distanceToPoint(inArc.coverPlane, _intersectionPoints[0]) > -EPSILON;
+    const i1IsCovered = distanceToPoint(inArc.coverPlane, _intersectionPoints[1]) > -EPSILON;
+    const p0IsVisible = distanceToPoint(junctionPlane, inArc.p0) > -EPSILON;
+    const p1IsVisible = distanceToPoint(junctionPlane, inArc.p1) > -EPSILON;
     if (!p0IsVisible && !p1IsVisible && !i0IsCovered && !i1IsCovered) {
         return 0; // No intersection
     }
     if (i0IsCovered && i1IsCovered && p0IsVisible && p1IsVisible) {
         // calculate which points are closer
-        const p0i0DistanceSquared = vec3.distanceSquared(inArc.p0, _intersectionPoints[0]);
-        const p0i1DistanceSquared = vec3.distanceSquared(inArc.p0, _intersectionPoints[1]);
+        const p0i0DistanceSquared = distanceSquared(inArc.p0, _intersectionPoints[0]);
+        const p0i1DistanceSquared = distanceSquared(inArc.p0, _intersectionPoints[1]);
         const case0 = p0i0DistanceSquared < p0i1DistanceSquared;
-        arc.set(out[0], inArc.p0, case0 ? _intersectionPoints[0] : _intersectionPoints[1]);
-        arc.set(out[1], inArc.p1, !case0 ? _intersectionPoints[0] : _intersectionPoints[1]);
+        arcSet(out[0], inArc.p0, case0 ? _intersectionPoints[0] : _intersectionPoints[1]);
+        arcSet(out[1], inArc.p1, !case0 ? _intersectionPoints[0] : _intersectionPoints[1]);
         return 2;
     }
     if (i0IsCovered && i1IsCovered) {
-        arc.set(out[0], _intersectionPoints[0], _intersectionPoints[1]);
+        arcSet(out[0], _intersectionPoints[0], _intersectionPoints[1]);
         return 1;
     }
     if (p0IsVisible && p1IsVisible) {
-        arc.copy(out[0], inArc);
+        arcCopy(out[0], inArc);
         return 1;
     }
     if ((p0IsVisible || p1IsVisible) !== (i0IsCovered || i1IsCovered)) {
         throw new Error("Unexpected case: one covered and one visible point must be present");
     }
-    arc.set(out[0], p0IsVisible ? inArc.p0 : inArc.p1, i0IsCovered ? _intersectionPoints[0] : _intersectionPoints[1]);
+    arcSet(out[0], p0IsVisible ? inArc.p0 : inArc.p1, i0IsCovered ? _intersectionPoints[0] : _intersectionPoints[1]);
     return 1;
 }

package/Math/juction/line-sphere.js

@@ -1,22 +1,22 @@
-import { vec3 } from "../vec3";
-import { line } from "../line";
-const _0vector = /*@__PURE__*/ vec3.create(0, 0, 0);
+import { create, dot, lengthSquared, subtract } from "../vec3";
+import { at } from "../line";
+const _0vector = /*@__PURE__*/ create(0, 0, 0);
 export function lineSphereIntersection(out, inLine, inSphere) {
-    vec3.subtract(_0vector, inLine.origin, inSphere.center);
-    const distanceSquared = vec3.lengthSquared(_0vector);
+    subtract(_0vector, inLine.origin, inSphere.center);
+    const distanceSquared = lengthSquared(_0vector);
     const radiusSquared = inSphere.radius * inSphere.radius;
-    const dot = vec3.dot(_0vector, inLine.direction);
-    const dotSquared = dot * dot;
-    const _a = dotSquared + radiusSquared - distanceSquared;
-    if (_a < 0) {
+    const dot_ = dot(_0vector, inLine.direction);
+    const dotSquared = dot_ * dot_;
+    const discriminant = dotSquared + radiusSquared - distanceSquared;
+    if (discriminant < 0) {
         return false; // no intersection
     }
     else {
-        const a = Math.sqrt(_a);
-        const t1 = dot - a;
-        const t2 = dot + a;
-        line.at(out[0], inLine, t1);
-        line.at(out[1], inLine, t2);
+        const a = Math.sqrt(discriminant);
+        const t1 = -dot_ - a;
+        const t2 = -dot_ + a;
+        at(out[0], inLine, t1);
+        at(out[1], inLine, t2);
         return true;
     }
 }

package/Math/juction/plane-plane.js

@@ -1,19 +1,19 @@
 import { EPSILON } from "../constants";
-import { vec3 } from "../vec3";
-const _normal1 = vec3.create();
-const _normal2 = vec3.create();
+import { copy, create, dot, cross, lengthSquared } from "../vec3";
+const _normal1 = create();
+const _normal2 = create();
 export function planePlaneJuction(out, plane1, plane2) {
-    vec3.copy(_normal1, plane1.normal);
-    vec3.copy(_normal2, plane2.normal);
+    copy(_normal1, plane1.normal);
+    copy(_normal2, plane2.normal);
     const distance1 = plane1.distance;
     const distance2 = plane2.distance;
     const { origin, direction } = out;
-    const dot = vec3.dot(_normal1, _normal2);
-    if (Math.abs(dot) > 1 - EPSILON) {
+    const d = dot(_normal1, _normal2);
+    if (Math.abs(d) > 1 - EPSILON) {
         return false; // Planes are parallel, no intersection
     }
-    vec3.cross(direction, _normal1, _normal2);
-    const magnitudeSquired = vec3.lengthSquared(out.direction);
+    cross(direction, _normal1, _normal2);
+    const magnitudeSquired = lengthSquared(out.direction);
     if (magnitudeSquired < EPSILON) {
         return false; // No valid intersection line
     }

package/Math/line.js

@@ -1,53 +1,52 @@
 import { EPSILON } from './constants';
-import { vec3 } from './vec3';
-const _0vector = /*@__PURE__*/ vec3.create(0, 0, 0);
-export const line = Object.freeze({
-    create(origin = vec3.create(), direction = vec3.create()) {
-        const direction_ = vec3.clone(direction);
-        vec3.normalize(direction_, direction_);
-        return {
-            origin: vec3.clone(origin),
-            direction: direction_
-        };
-    },
-    set(out, origin, direction) {
-        vec3.copy(out.origin, origin);
-        vec3.copy(out.direction, direction);
-    },
-    copy(out, a) {
-        out.origin = vec3.copy(out.origin, a.origin);
-        out.direction = vec3.copy(out.direction, a.direction);
-    },
-    clone(a) {
-        return {
-            origin: vec3.clone(a.origin),
-            direction: vec3.clone(a.direction)
-        };
-    },
-    fromTwoPoints(out, a, b) {
-        vec3.subtract(out.direction, b, a);
-        vec3.normalize(out.direction, out.direction);
-        vec3.copy(out.origin, a);
-    },
-    at(out, line, distance) {
-        vec3.multiplyScalar(_0vector, line.direction, distance);
-        vec3.add(out, _0vector, line.origin);
-    },
-    closestPoint(out, line, point) {
-        vec3.subtract(_0vector, point, line.origin);
-        const dot = vec3.dot(_0vector, line.direction);
-        vec3.copy(out, line.direction);
-        vec3.multiplyScalar(out, out, dot);
-        vec3.add(out, out, line.origin);
-    },
-    contains(line, point) {
-        vec3.subtract(_0vector, point, line.origin);
-        vec3.cross(_0vector, _0vector, line.direction);
-        return vec3.lengthSquared(_0vector) < EPSILON;
-    },
-    applyQuaternion(out, line, quaternion) {
-        vec3.applyQuaternion(out.origin, line.origin, quaternion);
-        vec3.applyQuaternion(out.direction, line.direction, quaternion);
-        vec3.normalize(out.direction, out.direction);
-    }
-});
+import { subtract, applyQuaternion as vec3applyQuaternion, add, multiplyScalar, normalize, dot, cross, lengthSquared, clone as vec3clone, create as vec3create, copy as vec3copy } from './vec3';
+const _0vector = /*@__PURE__*/ vec3create(0, 0, 0);
+function create(origin = vec3create(), direction = vec3create()) {
+    const direction_ = vec3clone(direction);
+    normalize(direction_, direction_);
+    return {
+        origin: vec3clone(origin),
+        direction: direction_
+    };
+}
+function set(out, origin, direction) {
+    vec3copy(out.origin, origin);
+    vec3copy(out.direction, direction);
+}
+function copy(out, a) {
+    out.origin = vec3copy(out.origin, a.origin);
+    out.direction = vec3copy(out.direction, a.direction);
+}
+function clone(a) {
+    return {
+        origin: vec3clone(a.origin),
+        direction: vec3clone(a.direction)
+    };
+}
+function fromTwoPoints(out, a, b) {
+    subtract(out.direction, b, a);
+    normalize(out.direction, out.direction);
+    vec3copy(out.origin, a);
+}
+function at(out, line, distance) {
+    multiplyScalar(_0vector, line.direction, distance);
+    add(out, _0vector, line.origin);
+}
+function closestPoint(out, line, point) {
+    subtract(_0vector, point, line.origin);
+    const dot_ = dot(_0vector, line.direction);
+    vec3copy(out, line.direction);
+    multiplyScalar(out, out, dot_);
+    add(out, out, line.origin);
+}
+function contains(line, point) {
+    subtract(_0vector, point, line.origin);
+    cross(_0vector, _0vector, line.direction);
+    return lengthSquared(_0vector) < EPSILON;
+}
+function applyQuaternion(out, line, quaternion) {
+    vec3applyQuaternion(out.origin, line.origin, quaternion);
+    vec3applyQuaternion(out.direction, line.direction, quaternion);
+    normalize(out.direction, out.direction);
+}
+export { create, set, copy, clone, fromTwoPoints, at, closestPoint, contains, applyQuaternion };