@pirireis/webglobeplugins 1.0.2 → 1.0.3

package/tests/Math/junction/arc-plane-points.test.ts

@@ -1,196 +0,0 @@
-import { Plane, Arc, Vec3, Sphere, Quaternion } from '../../../Math/types';
-import * as plane from '../../../Math/plane';
-import * as arc from '../../../Math/arc';
-import * as vec3 from '../../../Math/vec3';
-import * as quateernion from '../../../Math/quaternion';
-import { pointsOnArc } from '../../../Math/juction/arc-plane';
-import { EPSILON } from '../../../Math/constants';
-
-describe('pointsOnArc', () => {
-    const inArc = arc.create(vec3.create(1, 0, 0), vec3.create(0, 1, 0));
-    const junctionPlane = plane.create(vec3.create(0, 0, 1), 0);
-    const outPoints: [Vec3, Vec3] = [vec3.create(), vec3.create()];
-
-    beforeEach(() => {
-        // Reset arc and plane before each test
-        arc.set(inArc, vec3.create(1, 0, 0), vec3.create(0, 1, 0)); // 90-degree arc on XY plane
-        plane.set(junctionPlane, vec3.create(0, 0, 1), 0); // XY plane
-        vec3.set(outPoints[0], 0, 0, 0);
-        vec3.set(outPoints[1], 0, 0, 0);
-    });
-
-    test('should return 0 if junction plane is too far', () => {
-        plane.set(junctionPlane, vec3.create(0, 0, 1), 1.1);
-        const count = pointsOnArc(inArc, junctionPlane, outPoints);
-        expect(count).toBe(0);
-    });
-
-    test('should return 0 if junction plane is too far (negative distance)', () => {
-        plane.set(junctionPlane, vec3.create(0, 0, 1), -1.1);
-        const count = pointsOnArc(inArc, junctionPlane, outPoints);
-        expect(count).toBe(0);
-    });
-
-    test('should return 0 if planes are parallel and distinct', () => {
-        plane.set(junctionPlane, vec3.create(0, 0, 1), 0.5); // Plane parallel to the arc's plane
-        const count = pointsOnArc(inArc, junctionPlane, outPoints);
-        expect(count).toBe(0);
-    });
-
-    test('should return 1 point for a tangent junction plane at an arc endpoint', () => {
-        plane.set(junctionPlane, vec3.create(1, 0, 0), 1); // Tangent at (1,0,0)
-        const count = pointsOnArc(inArc, junctionPlane, outPoints);
-        expect(count).toBe(1);
-        expect(vec3.equals(outPoints[0], vec3.create(1, 0, 0))).toBe(true);
-    });
-
-    test('should return 2 intersection points when arc endpoints are the intersection points', () => {
-        const r2 = Math.sqrt(2) / 2;
-        plane.set(junctionPlane, vec3.create(r2, r2, 0), r2); // Plane whose intersection with the unit sphere includes the arc endpoints
-        const count = pointsOnArc(inArc, junctionPlane, outPoints);
-        expect(count).toBe(2);
-        const p0Found = vec3.equals(outPoints[0], inArc.p0) || vec3.equals(outPoints[1], inArc.p0);
-        const p1Found = vec3.equals(outPoints[0], inArc.p1) || vec3.equals(outPoints[1], inArc.p1);
-        expect(p0Found).toBe(true);
-        expect(p1Found).toBe(true);
-    });
-
-    test('should return 2 intersection points for a 90-degree arc', () => {
-        arc.set(inArc, vec3.create(1, 0, 0), vec3.create(0, 1, 0)); // 90-degree arc on XY plane
-        const r2 = Math.sqrt(2) / 2;
-        plane.set(junctionPlane, vec3.create(r2, -r2, 0), 0); // Plane intersecting at (r2, r2, 0) and (-r2, -r2, 0)
-        const count = pointsOnArc(inArc, junctionPlane, outPoints);
-        expect(count).toBe(1);
-        expect(vec3.equals(outPoints[0], vec3.create(r2, r2, 0))).toBe(true);
-    });
-
-    test('should return 1 intersection point if only one is on the arc', () => {
-        const r2 = Math.sqrt(2) / 2;
-        arc.set(inArc, vec3.create(1, 0, 0), vec3.create(r2, r2, 0)); // 45-degree arc
-        plane.set(junctionPlane, vec3.create(0, 1, 0), 0); // XZ plane, intersects circle at (1,0,0) and (-1,0,0)
-        const count = pointsOnArc(inArc, junctionPlane, outPoints);
-        expect(count).toBe(1);
-        expect(vec3.equals(outPoints[0], vec3.create(1, 0, 0))).toBe(true);
-    });
-
-    test('should return 1 if intersection point is on the arc segment', () => {
-        const r2 = Math.sqrt(2) / 2;
-        arc.set(inArc, vec3.create(r2, r2, 0), vec3.create(-r2, r2, 0)); // Arc in the upper XY quadrant
-        plane.set(junctionPlane, vec3.create(1, 0, 0), 0); // YZ plane, intersects circle at (0,1,0) and (0,-1,0)
-        const count = pointsOnArc(inArc, junctionPlane, outPoints);
-        expect(count).toBe(1);
-        expect(vec3.equals(outPoints[0], vec3.create(0, 1, 0))).toBe(true);
-    });
-
-    test('should return 1 intersection point when plane cuts through middle of 90-degree arc', () => {
-        const r2 = Math.sqrt(2) / 2;
-        arc.set(inArc, vec3.create(1, 0, 0), vec3.create(0, 1, 0)); // 90-degree arc
-        plane.set(junctionPlane, vec3.create(1, -1, 0), 0); // Plane intersecting at (r2, r2, 0) and (-r2, -r2, 0)
-        const count = pointsOnArc(inArc, junctionPlane, outPoints);
-        expect(count).toBe(1);
-        const expectedPoint = vec3.create(r2, r2, 0);
-        expect(vec3.equals(outPoints[0], expectedPoint)).toBe(true);
-    });
-
-    test('long 10 lat 10, long -10 lat 10, cut from 0 long meridian', () => {
-        const r2 = Math.sqrt(2) / 2;
-
-        const long10lat10 = vec3.create()
-        const long_10lat10 = vec3.create()
-        vec3.fromLongLatToUnitVector(long10lat10,[10 * Math.PI / 180, 10 * Math.PI / 180]);
-        vec3.fromLongLatToUnitVector(long_10lat10,[-10 * Math.PI / 180, 10 * Math.PI / 180]);
-        arc.set(inArc, long10lat10, long_10lat10); // Arc in the upper XY quadrant
-
-        plane.set(junctionPlane, vec3.createUnitVectorFromLongLat([Math.PI/2,0]),0); // YZ plane, intersects circle at (1,0,0) and (-1,0,0)
-        const count = pointsOnArc(inArc, junctionPlane, outPoints);
-        expect(count).toBe(1);
-
-        // calculate expected point with quaternion rotation. rotate long10Lat10 by half the angle between the two arc endpoints
-        const angle = Math.acos(vec3.dot(long10lat10, long_10lat10));
-        const halfAngle = angle / 2;
-        const axis = vec3.clone(inArc.normal);
-
-        const q1 = quateernion.create();
-        quateernion.fromAxisAngle(q1, axis, halfAngle);
-        const expectedPoint = vec3.create();
-        vec3.applyQuaternion(expectedPoint, long10lat10, q1);
-        const isEqual = vec3.equals(outPoints[0], expectedPoint);
-        if ( !isEqual ) {
-            console.log('angle', long10lat10, long_10lat10, angle);
-            console.log('outPoints[0]', outPoints[0]);
-            console.log('expectedPoint', expectedPoint);
-        }
-        expect(isEqual).toBe(true);
-    });
-
-    test('should return 1 point for arc from (10,10) to (10,-10) long/lat, cut by lat 0 plane', () => {
-        const deg2rad = Math.PI / 180;
-        const p0 = vec3.create();
-        const p1 = vec3.create();
-        vec3.fromLongLatToUnitVector(p0, [10 * deg2rad, 10 * deg2rad]);
-        vec3.fromLongLatToUnitVector(p1, [10 * deg2rad, -10 * deg2rad]);
-        arc.set(inArc, p0, p1);
-
-        // Equatorial plane (lat 0)
-        plane.set(junctionPlane, vec3.create(0, 0, 1), 0);
-
-        const count = pointsOnArc(inArc, junctionPlane, outPoints);
-        expect(count).toBe(1);
-
-        const expectedPoint = vec3.create();
-        vec3.fromLongLatToUnitVector(expectedPoint, [10 * deg2rad, 0 * deg2rad]);
-        
-        const isEqual = vec3.equals(outPoints[0], expectedPoint);
-        if (!isEqual) {
-            console.log('outPoints[0]', outPoints[0]);
-            console.log('expectedPoint', expectedPoint);
-        }
-        expect(isEqual).toBe(true);
-    });
-
-    
-    test('should return 1 point for arc from (10,10) to (0,-10) long/lat, cut by lat 0 plane', () => {
-        const deg2rad = Math.PI / 180;
-        const p0 = vec3.create();
-        const p1 = vec3.create();
-        vec3.fromLongLatToUnitVector(p0, [10 * deg2rad, 10 * deg2rad]);
-        vec3.fromLongLatToUnitVector(p1, [0 * deg2rad, -10 * deg2rad]);
-        arc.set(inArc, p0, p1);
-
-        // Equatorial plane (lat 0)
-        plane.set(junctionPlane, vec3.create(0, 0, 1), 0);
-
-        const count = pointsOnArc(inArc, junctionPlane, outPoints);
-        expect(count).toBe(1);
-
-        // The intersection point must lie on the great circle defined by p0 and p1,
-        // and also on the equator (z=0).
-        // The line of intersection of the two great circle planes is given by the cross product of their normals.
-        const arcNormal = vec3.clone(inArc.normal);
-        const equatorNormal = vec3.create(0, 0, 1);
-        const intersectionDir = vec3.create();
-        vec3.cross(intersectionDir, arcNormal, equatorNormal);
-        vec3.normalize(intersectionDir, intersectionDir);
-
-        // The two intersection points are intersectionDir and -intersectionDir.
-        // We need to find which one is on the arc.
-        // The correct point should have a positive dot product with both p0 and p1.
-        const dot0 = vec3.dot(intersectionDir, p0);
-        const intersectionDirNeg = vec3.clone(intersectionDir);
-        vec3.negate(intersectionDirNeg);
-        const dot1 = vec3.dot(intersectionDirNeg, p0);
-
-        const expectedPoint = dot0 > dot1 ? intersectionDir : intersectionDirNeg;
-
-        const isEqual = vec3.equals(outPoints[0], expectedPoint);
-        if (!isEqual) {
-            console.log('outPoints[0]', outPoints[0]);
-            console.log('expectedPoint', expectedPoint);
-        }
-        expect(isEqual).toBe(true);
-    });
-
-});
-
-
-

package/tests/Math/junction/arc-plane.test.ts

@@ -1,172 +0,0 @@
-import { Plane, Line, Vec3, Quaternion, Arc, Sphere } from '../../../Math/types';
-import * as plane from '../../../Math/plane';
-import * as line from '../../../Math/line';
-import * as arc from '../../../Math/arc';
-import * as vec3 from '../../../Math/vec3';
-import * as quaternion from '../../../Math/quaternion';
-import { planePlaneJunction } from '../../../Math/juction/plane-plane';
-import { lineSphereIntersection } from '../../../Math/juction/line-sphere';
-import { arcSlice } from '../../../Math/juction/arc-plane';
-import { EPSILON } from '../../../Math/constants';
-
-
-const arcIn = arc.create(vec3.create(0, 0, 1), vec3.create(1, 0, 0));
-const arcOut: [Arc, Arc] = [
-    arc.create(vec3.create(0, 0, 1), vec3.create(1, 0, 0)),
-    arc.create(vec3.create(0, 0, 1), vec3.create(1, 0, 0))
-];
-const arcExpected = arc.create(vec3.create(0, 0, 1), vec3.create(1, 0, 0));
-const junctionPlane = plane.create(vec3.create(0, 0, 1), 0);
-
-const origin = { center: vec3.create(0, 0, 0), radius: 1 } as Sphere;
-
-const r2 = Math.sqrt(2) / 2;
-const r3 = Math.sqrt(3) / 3;
-
-beforeAll(() => {
-    // Initialize any necessary data or state before running the tests
-    arc.set(arcIn, vec3.create(0, 0, 1), vec3.create(1, 0, 0));
-    arc.set(arcOut[0], vec3.create(0, 0, 1), vec3.create(1, 0, 0));
-    arc.set(arcOut[1], vec3.create(0, 0, 1), vec3.create(1, 0, 0));
-
-    plane.set(junctionPlane, vec3.create(0, 0, 1), 0);
-
-});
-
-
-
-
-
-test('arcSlice - No intersection 1', () => {
-    junctionPlane.distance = 2; // Set distance to ensure no intersection
-    const result = arcSlice(arcOut, arcIn, junctionPlane);
-    expect(result).toBe(0);
-});
-
-
-
-test('arcSlice - Full intersection 1', () => {
-    junctionPlane.distance = 0; // Set distance to ensure full intersection
-    const result = arcSlice(arcOut, arcIn, junctionPlane);
-    expect(result).toBe(1);
-    const isEqual = arc.equals(arcOut[0], arcExpected);
-    expect(isEqual).toBe(true);
-});
-
-
-test('arcSlice-1', () => {
-    // Set up a case where the arc intersects with the plane
-
-
-    const r3 = Math.sqrt(3);
-    const juctionNormal = vec3.create(r3, r3, r3);
-
-    plane.set(junctionPlane, juctionNormal, 0);
-
-    const result = arcSlice(arcOut, arcIn, junctionPlane);
-    expect(result).toBe(1);
-});
-
-
-test('arcSlice - Plane intersection line is out of sphere', () => {
-    // Set up a case where the arc intersects with the plane
-
-    const point1 = vec3.create(0, 1, 0);
-    const point2 = vec3.create(0, 0, 1);
-    arc.set(arcIn, point1, point2);
-
-    const juctionNormal = vec3.create(r3, r3, r3);
-
-    const closestPoint = vec3.create(r2, r2, 0);
-    const distance = vec3.dot(juctionNormal, closestPoint) + EPSILON;
-    plane.set(junctionPlane, juctionNormal, distance);
-
-    const result = arcSlice(arcOut, arcIn, junctionPlane);
-    expect(result).toBe(0);
-});
-
-
-test("arcSlice - Planes are parallel", () => {
-
-    const point1 = vec3.create(0, 1, 0);
-    const point2 = vec3.create(0, 0, 1);
-    arc.set(arcIn, point1, point2);
-
-    plane.fromValues(junctionPlane, 1, 0, 0, 0.3); // Set a plane parallel to the arc's normal
-    const result = arcSlice(arcOut, arcIn, junctionPlane);
-    expect(result).toBe(0); // Expect no intersection
-
-    junctionPlane.distance = -0.3;
-
-    const result2 = arcSlice(arcOut, arcIn, junctionPlane);
-    expect(result2).toBe(1); // Expect no intersection
-    const isEqual = arc.equals(arcOut[0], arcIn);
-    expect(isEqual).toBe(true); // Expect the output arc to be equal to the input arc
-});
-
-
-test("arcSlice - Arc sliced in half", () => {
-
-    const point1 = vec3.create(0, 1, 0);
-    const point2 = vec3.create(0, 0, 1);
-    arc.set(arcIn, point1, point2);
-
-    expect(vec3.equals(arcIn.normal, vec3.create(1, 0, 0))).toBe(true); // Arc normal should be (1, 0, 0)
-
-    plane.fromValues(junctionPlane, 0, -r2, r2, 0); // Set a plane parallel to the arc's normal
-
-    const result = arcSlice(arcOut, arcIn, junctionPlane);
-    expect(result).toBe(1); // Expect an intersection
-    const expectedPoint1 = vec3.create(0, r2, r2);
-    const expectedPoint2 = vec3.create(0, 0, 1);
-    arc.set(arcExpected, expectedPoint1, expectedPoint2);
-    const isEqual = arc.equals(arcOut[0], arcExpected);
-    expect(isEqual).toBe(true); // Expect the output arc to be equal to the expected arc
-});
-
-
-test("arcSlice - Arc sliced in middle", () => {
-    const point1 = vec3.create(0, 1, 0);
-    const point2 = vec3.create(0, 0, 1);
-    arc.set(arcIn, point1, point2);
-
-
-    plane.fromValues(junctionPlane, 0, r2, r2, r2);
-
-    const result = arcSlice(arcOut, arcIn, junctionPlane);
-    expect(result).toBe(1);
-    expect(arc.equals(arcOut[0], arcIn)).toBe(true);
-
-
-    const gap = 1 - r2;
-    const stepCount = 100;
-
-    const points: [Vec3, Vec3] = [vec3.create(0, 1, 0), vec3.create(0, 0, 1)];
-    const lineOfPoints = line.create();
-    vec3.set(lineOfPoints.direction, 0, -r2, r2);
-    // Add normalization:
-    vec3.normalize(lineOfPoints.direction, lineOfPoints.direction);
-
-    for (let i = 0; i < stepCount - 1; i++) {
-        const distance = gap * i / stepCount + r2;
-        junctionPlane.distance = distance;
-        const result = arcSlice(arcOut, arcIn, junctionPlane);
-        expect(result).toBe(1);
-
-        vec3.set(lineOfPoints.origin, 0, r2 * distance, r2 * distance);
-        const haveIntersections = lineSphereIntersection(points, lineOfPoints, origin);
-        expect(haveIntersections).toBe(true); // Expect the line to intersect with the sphere
-        
-        arc.set(arcExpected, points[0], points[1]);
-        
-        const isEqual = arc.equals(arcOut[0], arcExpected);
-        if (!isEqual) {
-            console.log('Iteration:', i);
-            console.log('Expected arc:', arcExpected);
-            console.log('Actual arc:', arcOut[0]);
-            console.log('Points from intersection:', points);
-        }
-        expect(isEqual).toBe(true); // Expect the output arc to be equal to the expected arc
-
-    }
-});

package/tests/Math/junction/line-sphere.test.ts

@@ -1,127 +0,0 @@
-import { lineSphereIntersection } from '../../../Math/juction/line-sphere';
-import { create } from '../../../Math/vec3';
-import type { Line, Sphere, Vec3 } from '../../../Math/types';
-
-describe('lineSphereIntersection', () => {
-    let intersections: [Vec3, Vec3];
-
-    beforeEach(() => {
-        intersections = [create(0, 0, 0), create(0, 0, 0)];
-    });
-
-    test('should return true for a line intersecting the sphere at two points', () => {
-        const line: Line = { origin: create(-2, 0.5, 0), direction: create(1, 0, 0) };
-        const sphere: Sphere = { center: create(0, 0, 0), radius: 1 };
-
-        const result = lineSphereIntersection(intersections, line, sphere);
-
-        expect(result).toBe(true);
-        const t1 = 2 - Math.sqrt(0.75);
-        const t2 = 2 + Math.sqrt(0.75);
-
-        expect(intersections[0][0]).toBeCloseTo(t1 - 2);
-        expect(intersections[0][1]).toBeCloseTo(0.5);
-        expect(intersections[0][2]).toBeCloseTo(0);
-
-        expect(intersections[1][0]).toBeCloseTo(t2 - 2);
-        expect(intersections[1][1]).toBeCloseTo(0.5);
-        expect(intersections[1][2]).toBeCloseTo(0);
-    });
-
-    test('should return true for a line passing through the center of the sphere', () => {
-        const line: Line = { origin: create(0, 0, 0), direction: create(0, 1, 0) };
-        const sphere: Sphere = { center: create(0, 0, 0), radius: 5 };
-
-        const result = lineSphereIntersection(intersections, line, sphere);
-
-        expect(result).toBe(true);
-        // Order might vary, so check both possibilities
-        const p1 = create(0, -5, 0);
-        const p2 = create(0, 5, 0);
-        const receivedP1 = intersections[0];
-        const receivedP2 = intersections[1];
-
-        const match1 = Math.abs(receivedP1[1] - p1[1]) < 1e-9 && Math.abs(receivedP2[1] - p2[1]) < 1e-9;
-        const match2 = Math.abs(receivedP1[1] - p2[1]) < 1e-9 && Math.abs(receivedP2[1] - p1[1]) < 1e-9;
-
-        expect(match1 || match2).toBe(true);
-    });
-
-    test('should return true for a tangent line', () => {
-        const line: Line = { origin: create(-2, 1, 0), direction: create(1, 0, 0) };
-        const sphere: Sphere = { center: create(0, 0, 0), radius: 1 };
-
-        const result = lineSphereIntersection(intersections, line, sphere);
-
-        expect(result).toBe(true);
-        expect(intersections[0][0]).toBeCloseTo(0);
-        expect(intersections[0][1]).toBeCloseTo(1);
-        expect(intersections[0][2]).toBeCloseTo(0);
-        expect(intersections[1][0]).toBeCloseTo(0);
-        expect(intersections[1][1]).toBeCloseTo(1);
-        expect(intersections[1][2]).toBeCloseTo(0);
-    });
-
-    test('should return false for a line that does not intersect the sphere', () => {
-        const line: Line = { origin: create(-5, 5, 0), direction: create(1, 0, 0) };
-        const sphere: Sphere = { center: create(0, 0, 0), radius: 1 };
-
-        const result = lineSphereIntersection(intersections, line, sphere);
-
-        expect(result).toBe(false);
-    });
-
-    test('should handle non-normalized direction vectors', () => {
-        const line: Line = { origin: create(-10, 0, 0), direction: create(2, 0, 0) };
-        const sphere: Sphere = { center: create(0, 0, 0), radius: 1 };
-
-        const result = lineSphereIntersection(intersections, line, sphere);
-
-        expect(result).toBe(true);
-        const p1 = create(-1, 0, 0);
-        const p2 = create(1, 0, 0);
-        const receivedP1 = intersections[0];
-        const receivedP2 = intersections[1];
-
-        const match1 = Math.abs(receivedP1[0] - p1[0]) < 1e-9 && Math.abs(receivedP2[0] - p2[0]) < 1e-9;
-        const match2 = Math.abs(receivedP1[0] - p2[0]) < 1e-9 && Math.abs(receivedP2[0] - p1[0]) < 1e-9;
-
-        expect(match1 || match2).toBe(true);
-    });
-
-    test('should handle sphere not at the origin', () => {
-        const line: Line = { origin: create(8, 5, 5), direction: create(1, 0, 0) };
-        const sphere: Sphere = { center: create(10, 5, 5), radius: 1 };
-
-        const result = lineSphereIntersection(intersections, line, sphere);
-
-        expect(result).toBe(true);
-        const p1 = create(9, 5, 5);
-        const p2 = create(11, 5, 5);
-        const receivedP1 = intersections[0];
-        const receivedP2 = intersections[1];
-
-        const match1 = Math.abs(receivedP1[0] - p1[0]) < 1e-9 && Math.abs(receivedP2[0] - p2[0]) < 1e-9;
-        const match2 = Math.abs(receivedP1[0] - p2[0]) < 1e-9 && Math.abs(receivedP2[0] - p1[0]) < 1e-9;
-
-        expect(match1 || match2).toBe(true);
-    });
-
-    test('should return true when the line origin is inside the sphere', () => {
-        const line: Line = { origin: create(0, 0, 0), direction: create(1, 1, 1) };
-        const sphere: Sphere = { center: create(0, 0, 0), radius: 5 };
-
-        const result = lineSphereIntersection(intersections, line, sphere);
-
-        expect(result).toBe(true);
-        const t = 5 / Math.sqrt(3);
-
-        expect(intersections[0][0]).toBeCloseTo(-t);
-        expect(intersections[0][1]).toBeCloseTo(-t);
-        expect(intersections[0][2]).toBeCloseTo(-t);
-
-        expect(intersections[1][0]).toBeCloseTo(t);
-        expect(intersections[1][1]).toBeCloseTo(t);
-        expect(intersections[1][2]).toBeCloseTo(t);
-    });
-});

package/tests/Math/junction/plane-plane.test.ts

@@ -1,91 +0,0 @@
-import { Plane, Line, Vec3, Quaternion } from '../../../Math/types';
-import * as plane from '../../../Math/plane';
-import * as line from '../../../Math/line';
-import * as vec3 from '../../../Math/vec3';
-import * as quaternion from '../../../Math/quaternion';
-import { planePlaneJunction } from '../../../Math/juction/plane-plane';
-
-
-let plane1: Plane;
-let plane2: Plane;
-let intersectionLine: Line;
-let quaternion1: Quaternion;
-
-beforeAll(() => {
-    plane1 = plane.create();
-    plane2 = plane.create();
-    intersectionLine = line.create();
-    quaternion1 = quaternion.create();
-});
-
-
-test('plane-plane intersection - parallel planes', () => {
-    plane.fromValues(plane1, 0, 0, 1, 5); // Plane: z = 5
-    plane.fromValues(plane2, 0, 0, 1, 10); // Plane: z = 10
-    const result = planePlaneJunction(intersectionLine, plane1, plane2);
-    expect(result).toBe(false);
-});
-
-test('plane-plane intersection - intersecting planes', () => {
-    plane.fromValues(plane1, 0, 0, 1, 5); // Plane: z = 5
-    plane.fromValues(plane2, 1, 0, 0, 3); // Plane: x = 3
-
-    const result = planePlaneJunction(intersectionLine, plane1, plane2);
-    expect(result).toBe(true);
-    expect(vec3.equals(intersectionLine.direction, vec3.create(0, 1, 0))).toBe(true);
-    expect(vec3.equals(intersectionLine.origin, vec3.create(3, 0, 5))).toBe(true);
-});
-
-
-test('plane-plane intersection - rotating a plane', () => {
-    // plane1 z = 5
-    plane.fromValues(plane1, 0, 0, 1, 5);
-
-    // plane2 x = 3, for the start
-    vec3.randomUnit(plane2.normal);
-    plane2.distance = 3;
-
-    const result = planePlaneJunction(intersectionLine, plane1, plane2);
-    expect(result).toBe(true);
-    const quaRotateLine = line.clone(intersectionLine);
-
-    const step = 90;
-    quaternion.fromAxisAngle(quaternion1, plane1.normal, Math.PI / step); // Rotate 90 degrees around Y-axis
-
-
-    for (let i = 0; i < step; i++) {
-
-        vec3.applyQuaternion(plane2.normal, plane2.normal, quaternion1);
-
-        const result = planePlaneJunction(intersectionLine, plane1, plane2);
-
-
-        line.applyQuaternion(quaRotateLine, quaRotateLine, quaternion1);
-
-        expect(result).toBe(true);
-        expect(vec3.equals(intersectionLine.direction, quaRotateLine.direction)).toBe(true);
-        expect(line.contains(intersectionLine, quaRotateLine.origin)).toBe(true);
-    }
-});
-
-test("plane-plane intersection 1", () => {
-    const r2 = Math.sqrt(2) / 2;
-    plane.fromValues(plane1, 1, 0, 0, 0);
-    plane.fromValues(plane2, 0, -r2, r2, 0);
-    const result = planePlaneJunction(intersectionLine, plane1, plane2);
-
-    expect(result).toBe(true);
-    console.log(intersectionLine);
-    expect(vec3.equals(intersectionLine.direction, vec3.create(0, r2, r2)) || vec3.equals(intersectionLine.direction, vec3.create(0, -r2, -r2))
-    ).toBe(true);
-    expect(line.contains(intersectionLine, vec3.create(0, 0, 0))).toBe(true);
-});
-
-test("plane-plane intersection 2", () => {
-    plane.fromValues(plane1, 1, 0, 0, 1);
-    plane.fromValues(plane2, 0, 1, 0, 1);
-    const result = planePlaneJunction(intersectionLine, plane1, plane2);
-    expect(result).toBe(true);
-    expect(vec3.equals(intersectionLine.direction, vec3.create(0, 0, 1))).toBe(true);
-    expect(line.contains(intersectionLine, vec3.create(1, 1, 0))).toBe(true);
-});

package/tests/Math/plane-test.ts

@@ -1,17 +0,0 @@
-import { Vec3, Plane } from '../../Math/types';
-import * as vec3 from '../../Math/vec3';
-import * as plane from '../../Math/plane';
-
-
-const EPSILON = 1e-6;
-
-const _0plane = plane.create(vec3.create(0, 0, 1), 0);
-const _1plane = plane.create(vec3.create(1, 1, 1), 0);
-
-beforeAll(() => {
-    // Initialize any necessary data or state before running the tests
-    plane.set(_0plane, vec3.create(0, 0, 1), 0);
-    plane.set(_1plane, vec3.create(1, 1, 1), 0);
-});
-
-

package/tests/Math/plane.test.ts

@@ -1,43 +0,0 @@
-import { Plane, Vec3 } from "../../Math/types";
-import * as vec3 from "../../Math/vec3";
-import * as plane from "../../Math/plane";
-
-
-const _planeA = /*@__PURE__*/ plane.create(vec3.create(1, 0, 0), 0);
-const _planeB = /*@__PURE__*/ plane.create(vec3.create(0, 1, 0), 0);
-const _vecA = /*@__PURE__*/ vec3.create(1, 0, 0);
-
-beforeAll(() => {
-    vec3.set(_vecA, 1, 0, 0);
-    plane.set(_planeA, vec3.create(1, 0, 0), 0);
-    plane.set(_planeB, vec3.create(0, 1, 0), 0);
-});
-
-test("Plane: getUnitSphereRadiusAngle", () => {
-    const angleA = plane.getUnitSphereRadiusAngle(_planeA);
-    const angleB = plane.getUnitSphereRadiusAngle(_planeB);
-
-    expect(angleA).toBeCloseTo(Math.PI / 2, 5); // 90 degrees
-    expect(angleB).toBeCloseTo(Math.PI / 2, 5); // 90 degrees
-});
-
-
-test("Plane: getUnitSphereRadiusAngle 1", () => {
-
-    vec3.set(_vecA, 1, 1, 0);
-    vec3.normalize(_vecA, _vecA);
-    const distance = Math.sqrt(2) / 2; // Distance from origin to the plane
-    plane.set(_planeA, _vecA, distance);
-    const angleA = plane.getUnitSphereRadiusAngle(_planeA);
-    expect(angleA).toBeCloseTo(Math.PI / 4, 5); // 45 degrees
-
-    for (let i = 0; i < 100; i++) {
-        const distance = Math.random();
-
-        const angle = Math.acos(distance);
-        vec3.randomUnit(_vecA)
-        plane.set(_planeA, _vecA, distance);
-        const angleA = plane.getUnitSphereRadiusAngle(_planeA);
-        expect(angleA).toBeCloseTo(angle, 5); // Check if the angle is close to the expected value
-    }
-});  

package/tests/Math/vec3.test.ts

@@ -1,33 +0,0 @@
-import { Vec3 } from "../../Math/types";
-import * as vec3 from "../../Math/vec3";
-
-test("vec3.create", () => {
-    const v = vec3.create(1, 2, 3);
-    expect(v).toEqual([1, 2, 3]);
-});
-
-
-test("vec3.length", () => {
-    const v = vec3.create(3, 4, 0);
-    const length = vec3.length(v);
-    expect(length).toBe(5);
-});
-
-
-test("LongLat to Vec3 and back", () => {
-    const longLat: [number, number] = [0, 0]
-    const longLatBack: [number, number] = [0, 0]
-    const v = vec3.create();
-    for (let lon = -170; lon <= 170; lon += 30) {
-        for (let lat = -85; lat <= 85; lat += 30) {
-            longLat[0] = lon * Math.PI / 180;
-            longLat[1] = lat * Math.PI / 180;
-            vec3.fromLongLatToUnitVector(v, longLat);
-            vec3.fromUnitVectorToLongLat(longLatBack, v);
-            expect(Math.abs(longLatBack[0] - longLat[0]) < 0.00001).toBe(true);
-            expect(Math.abs(longLatBack[1] - longLat[1]) < 0.00001).toBe(true);
-        }
-    }
-
-});
-