@pirireis/webglobeplugins 0.16.0 → 0.16.2

package/Math/arc.ts

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

package/Math/circle-cdf-points.ts

@@ -1,143 +0,0 @@
-import { Globe, CentigradeDegree } from "../types";
-import { RADIANS } from "./methods";
-import { Meter } from "./types";
-
-
-
-function createCummulativeTemplate(
-    numberOfPoints: number,
-    strength: number,
-    denseRatio: number = 0.5 // Ratio of points to be densely packed at the start.
-
-): Float64Array {
-    // Handle edge cases for the number of points.
-    if (numberOfPoints <= 0) {
-        // If zero or a negative number of points is requested, return an empty array.
-        return new Float64Array([]);
-    }
-
-    // Create the array to hold the results. Float64Array is used for high-precision floating-point numbers.
-    const distribution = new Float64Array(numberOfPoints);
-
-    if (numberOfPoints === 1) {
-        // If only one point is requested, it represents the entire range [0, 1].
-        // We place it at the start (0.0).
-        distribution[0] = 0.0;
-        return distribution;
-    }
-
-    // The exponent determines the curve of the distribution.
-    // We add 1 to the strength so that a strength of 0 results in an exponent of 1 (linear).
-    // We use Math.max(0, strength) to ensure the strength is not negative.
-
-
-    // The last index is used to normalize the position to a 0-1 range.
-    const lastIndex = numberOfPoints - 1;
-    distribution[0] = 0.0; // The first point is always at 0.0.
-    let totalWeight = 0;
-    let i = 1
-    const denseCount = numberOfPoints * denseRatio;
-    for (i; i < denseCount; i++) {
-        // Calculate the ratio of the current index to the last index.
-        // The ratio is adjusted to create a non-linear distribution.
-        totalWeight += 1;
-        distribution[i] = totalWeight; // Store the raw value in the distribution array.
-    }
-
-    for (i; i < numberOfPoints; i++) {
-        // Calculate the ratio of the current index to the last index.
-
-        const ratio = 1 + ((i - denseCount) / lastIndex) / (1 - denseRatio) * 2;
-        const step = Math.pow(ratio, strength);
-
-        totalWeight += step;
-        distribution[i] = totalWeight; // Store the raw value in the distribution array.
-
-        // Apply the power function to create a non-linear distribution.
-        // The result is normalized to the range [0, 1].
-    }
-    for (let i = 1; i < numberOfPoints; i++) {
-        // Normalize the values to ensure they sum up to 1.
-        distribution[i] = distribution[i] / totalWeight;
-    }
-    return distribution;
-}
-
-
-
-function createCummulativeTemplateStash(
-    levels: number,
-    numberOfPoints: number,
-    denseRatio: number = 0.5,
-    strengthMultiplier: number = 2.4,
-): Float64Array[] {
-    const stash: Float64Array[] = [];
-    for (let i = 0; i < levels; i++) {
-        const template = createCummulativeTemplate(numberOfPoints, i * strengthMultiplier, denseRatio);
-        stash.push(template);
-    }
-    return stash;
-}
-
-function globeFindPointByPolar(
-    out: number[] | Float64Array,
-    globe: Globe,
-    centerLong: CentigradeDegree,
-    centerLat: CentigradeDegree,
-    radius: Meter,
-    ratios: number[]) {
-    for (let i = 0; i < ratios.length; i++) {
-        const point = globe.Math.FindPointByPolar(
-            centerLong,
-            centerLat,
-            radius,
-            ratios[i]
-        );
-        out[i * 2] = point.long;
-        out[i * 2 + 1] = point.lat;
-    }
-}
-
-function globeFindPointByPolarHalfCircle(
-    out: Float64Array,
-    globe: Globe,
-    centerLong: CentigradeDegree,
-    centerLat: CentigradeDegree,
-    radius: Meter,
-    rotation: number,
-    ratios: Float64Array) {
-
-    const rotCentigrade = rotation / RADIANS + 720;
-    for (let i = 0; i < ratios.length; i++) {
-        const point = globe.Math.FindPointByPolar(
-            centerLong,
-            centerLat,
-            radius,
-            (ratios[i] * 180 + rotCentigrade) % 360
-        );
-        out[i * 2] = point.long;
-        out[i * 2 + 1] = point.lat;
-    }
-    // fill reflection
-    let offset = out.length;
-    for (let i = 0; i < ratios.length - 1; i++) {
-        const point = globe.Math.FindPointByPolar(
-            centerLong,
-            centerLat,
-            radius,
-            ((- ratios[i]) * 180 + rotCentigrade) % 360,
-        );
-
-        out[offset - 2] = point.long;
-        out[offset - 1] = point.lat;
-        offset -= 2;
-    }
-}
-
-
-
-export {
-    createCummulativeTemplateStash,
-    globeFindPointByPolar,
-    globeFindPointByPolarHalfCircle
-}

package/Math/circle.ts

@@ -1,49 +0,0 @@
-import { Circle, CircleClosestAzimuthAngleProperties, LongLat, Plane, Vec3 } from '../Math/types.js';
-import { RADIANS } from './methods';
-import { subtract, normalize, dot, fromLongLatToUnitVector, copy, multiplyScalar, clone, add } from './vec3';
-
-const _0vec3: Vec3 = [0, 0, 0];
-
-function closestAzimuthAngle(
-    circleProperties: CircleClosestAzimuthAngleProperties,
-    point: Vec3
-): number {
-    const distance = dot(circleProperties.normal, point);
-    copy(_0vec3, circleProperties.normal)
-    multiplyScalar(_0vec3, _0vec3, distance);
-    subtract(_0vec3, point, _0vec3);
-    normalize(_0vec3, _0vec3);
-    const N = circleProperties.northPointProjectedToOriginPlaneNormalized
-    const _dot = dot(_0vec3, N);
-    let angle = Math.acos(_dot);
-    const z = (_0vec3[0] * N[1] - _0vec3[1] * N[0]) * circleProperties.normal[2];
-    return z < 0 ? -angle : angle;
-}
-
-
-function createCircleClosestAzimuthAngleProperties(
-    circle: Circle,
-
-): CircleClosestAzimuthAngleProperties {
-    const normal: Vec3 = Array(3) as Vec3;
-    fromLongLatToUnitVector(normal,
-        [circle.center[0] * RADIANS, circle.center[1] * RADIANS]);
-    const N: Vec3 = clone(normal);
-
-    const distance = dot([0, 0, 1], normal);
-    multiplyScalar(N, N, distance);
-    // if (N[2] >= 0) {
-    subtract(N, [0, 0, 1], N);
-    // } else {
-    //     subtract(N, [0, 0, -1], N);
-    // }
-    normalize(N, N);
-    return {
-        normal: normal,
-        northPointProjectedToOriginPlaneNormalized: N,
-    };
-}
-
-
-
-export { closestAzimuthAngle, createCircleClosestAzimuthAngleProperties };

package/Math/constants.ts

@@ -1,12 +0,0 @@
-const WORLD_RADIUS_3D = 6378.137;
-const WORLD_RADIUS_MERCATOR = 6378136.99911;
-
-const EPSILON = 1e-10; // Used for floating point comparisons
-
-export {
-    WORLD_RADIUS_3D,
-    WORLD_RADIUS_MERCATOR,
-    EPSILON
-}
-
-

package/Math/juction/arc-plane.ts

@@ -1,129 +0,0 @@
-import { Vec3, Plane, Line, Sphere, Arc } from "../types";
-import { EPSILON } from "../constants";
-import {
-    create as vec3create,
-    copy as vec3copy,
-    dot,
-    distanceSquared,
-} from "../vec3";
-import { create as lineCreate, at as lineAt } 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__*/ lineCreate();
-const _originPlane = /*@__PURE__*/ planeCreate();
-_originPlane.distance = 0;
-const _originSphere = /*@__PURE__*/ { center: vec3create(0, 0, 0), radius: 1 } as Sphere;
-
-const _intersectionPoints: [Vec3, Vec3] = /*@__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 junctionPlane 
- * @returns number of arcs segments in the junction divided by the junction plane.
- */
-export function arcSlice(out: [Arc, Arc], inArc: Arc, junctionPlane: Plane): number {
-
-    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 = getUnitSphereRadiusAngle(inArc.coverPlane);
-    const visibleRadiusAngle = getUnitSphereRadiusAngle(junctionPlane);
-    // TODO: RESEARCH efficient approach --
-    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
-        arcCopy(out[0], inArc);
-        return 1;
-    }
-    // plane-plane intersection line should be calculated for the rest of the calculations
-
-    vec3copy(_originPlane.normal, inArc.normal);
-    const isPlaneJunctions = planePlaneJuction(_intersectionLine, _originPlane, junctionPlane);
-
-    if (!isPlaneJunctions) { // case C: planes are parallel. 
-        if (junctionPlane.distance <= 0) {
-            arcCopy(out[0], inArc);
-            return 1; // No intersection
-        } else {
-            return 0; // No intersection
-        }
-    }
-    // --- read until here ---
-
-    // calculate the intersection points
-
-    const isSphereIntersection = lineSphereIntersection(_intersectionPoints, _intersectionLine, _originSphere);
-    if (!isSphereIntersection) {
-        // other edge caes should be covered by now
-        return 0; // No intersection
-    }
-
-
-    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 = distanceSquared(inArc.p0, _intersectionPoints[0]);
-        const p0i1DistanceSquared = distanceSquared(inArc.p0, _intersectionPoints[1]);
-        const case0 = p0i0DistanceSquared < p0i1DistanceSquared;
-        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) {
-        arcSet(out[0], _intersectionPoints[0], _intersectionPoints[1]);
-        return 1;
-    }
-
-
-    if (p0IsVisible && p1IsVisible) {
-        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");
-    }
-
-    arcSet(
-        out[0],
-        p0IsVisible ? inArc.p0 : inArc.p1,
-        i0IsCovered ? _intersectionPoints[0] : _intersectionPoints[1]
-    );
-
-    return 1;
-}
-

package/Math/juction/line-sphere.ts

@@ -1,30 +0,0 @@
-import { Vec3, Line, Sphere } from "../types";
-
-import { create, dot, lengthSquared, subtract } from "../vec3";
-import { at } from "../line";
-
-const _0vector = /*@__PURE__*/ create(0, 0, 0);
-
-
-export function lineSphereIntersection(out: [Vec3, Vec3], inLine: Line, inSphere: Sphere): boolean {
-
-    subtract(_0vector, inLine.origin, inSphere.center);
-    const distanceSquared = lengthSquared(_0vector);
-    const radiusSquared = inSphere.radius * inSphere.radius;
-    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(discriminant);
-        const t1 = -dot_ - a;
-        const t2 = -dot_ + a;
-
-        at(out[0], inLine, t1);
-        at(out[1], inLine, t2);
-
-        return true;
-    }
-}