@pirireis/webglobeplugins 0.17.1 → 1.0.2

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

@@ -0,0 +1,196 @@
+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

@@ -0,0 +1,172 @@
+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

@@ -0,0 +1,127 @@
+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

@@ -0,0 +1,91 @@
+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

@@ -0,0 +1,17 @@
+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

@@ -0,0 +1,43 @@
+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

@@ -0,0 +1,33 @@
+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);
+        }
+    }
+
+});
+