@pirireis/webglobeplugins 0.8.26 → 0.9.2

package/Math/arc.ts

@@ -1,247 +1,76 @@
-
-import { Vector3D } from "./vector3d";
-import { Plane } from "./plane";
-import { Quaternion } from "./quaternion";
-import { Radians } from "./types";
-import { Ray } from "./ray";
-
-const _quaternion = /*@__PURE__*/ new Quaternion(0, 0, 0, 0);
-const _ray = /*@__PURE__*/ new Ray(new Vector3D(0, 0, 0), new Vector3D(0, 0, 0));
-const _0vector = /*@__PURE__*/ new Vector3D(0, 0, 0);
-const _0plane = /*@__PURE__*/ new Plane(_0vector, 0);
-
-const _A_x_otherA = /*@__PURE__*/ new Vector3D(0, 0, 0);
-const _A_x_otherB = /*@__PURE__*/ new Vector3D(0, 0, 0);
-const _AxB = /*@__PURE__*/ new Vector3D(0, 0, 0);
-
-
-
-
-
-export class Arc {
-    pointA: Vector3D;
-    pointB: Vector3D;
-    _dot: number;
-    _AxB: Vector3D;
-    _theta: Radians;
-    _imageinaryPlane: Plane;
-    constructor(
-        pointA: Vector3D,
-        pointB: Vector3D,
-    ) {
-        this.pointA = pointA.normalize();
-        this.pointB = pointB.normalize();
-        this._AxB = pointA.clone().cross(pointB);
-        this._dot = this.pointA.dot(this.pointB);
-        this._theta = Math.acos(this._dot);
-        this._imageinaryPlane = new Plane(this._AxB.clone().normalize(), 0);
-    }
-
-
-    copy(arc: Arc): Arc {
-        this.pointA.copy(arc.pointA);
-        this.pointB.copy(arc.pointB);
-        this._AxB.copy(arc._AxB);
-        this._dot = arc._dot;
-        this._theta = arc._theta;
-        this._imageinaryPlane.copy(arc._imageinaryPlane);
-        return this;
-    }
-
-
-    clone(): Arc {
-        return new Arc(this.pointA.clone(), this.pointB.clone());
-    }
-
-
-    equals(arc: Arc): boolean {
-        return (this.pointA.equals(arc.pointA) && this.pointB.equals(arc.pointB)) || (this.pointA.equals(arc.pointB) && this.pointB.equals(arc.pointA));
-    }
-
-
-    slerp(t: number): Vector3D {
-
-        const pointA = this.pointA;
-        const pointB = this.pointB;
-
-        const step = t / this._theta;
-        const sinTheta = Math.sin(this._theta);
-        const sinStep = Math.sin(step * this._theta);
-        const sinOneMinusStep = Math.sin((1 - step) * this._theta);
-
-        const x = (sinOneMinusStep * pointA[0] + sinStep * pointB[0]) / sinTheta;
-        const y = (sinOneMinusStep * pointA[1] + sinStep * pointB[1]) / sinTheta;
-        const z = (sinOneMinusStep * pointA[2] + sinStep * pointB[2]) / sinTheta;
-
-        return new Vector3D(x, y, z);
-
-    }
-
-
-
-    intersectionMedium(medium: Plane, target: Arc | null = null): Arc | null {
-        // Orianted in right hand rule
-        if (this.pointA.equals(this.pointB)) return null; // arc is too short
-
-        const result = this._imageinaryPlane.intersectionPlane(medium);
-        if (result instanceof Plane) {
-            return this.clone();
-        }
-
-        if (result === null) { console.log("null intersection"); return null; } // planes are parallel
-
-        const intersectionPoints = _ray.set(result.origin, result.direction).intersectionSphere(_0vector.set(0, 0, 0), 1);
-        if (intersectionPoints === null) {
-            return null; // no intersection
-        }
-
-        // think as this.pointA is on y=1 on a x-y space. this.pointB is on the x>0 part of the space.
-        // any point on x<0 is outside. Any point y<this._dot is outside.
-
-        // A is before B with right hand rule
-        const [A, B] = (() => {
-            Vector3D.crossVectors(...intersectionPoints, _AxB);
-            if (_AxB.dot(this._AxB) >= 0) {
-                return [intersectionPoints[0], intersectionPoints[1]];
-            } else {
-                return [intersectionPoints[1], intersectionPoints[0]];
-            }
-        })();
-
-
-        Vector3D.crossVectors(this.pointA, A, _A_x_otherA);
-        Vector3D.crossVectors(this.pointA, B, _A_x_otherB);
-
-        const _yA = this.pointA.dot(A);
-        const _yB = this.pointA.dot(B);
-
-        const _xA = _A_x_otherA.dot(this._imageinaryPlane.normal); //  this._AxB.normalize() == this._imageinaryPlane.normal
-        const _xB = _A_x_otherB.dot(this._imageinaryPlane.normal);
-
-
-        if (_xA < 0 && _xB < 0) {
-            if (_yA > _yB) {
-                throw new Error("A is before B with right hand rule but A is on the left side of the arc. This should not happen.");
-            }
-            return null; // no intersection
-        } else if (_xA > 0 && _xB > 0 && _yA < this._dot && _yB < this._dot) {
-            return null; // no intersection
-        }
-
-
-        const resultPoints: [Vector3D, Vector3D] = [
-            _xA < 0 ? this.pointA.clone() : A,
-            _yB <= this._dot ? this.pointB.clone() : B
-        ];
-        if (target === null) {
-            target = new Arc(...resultPoints);
-        } else if (target instanceof Arc) {
-            target.setFromUnitVectors(...resultPoints);
-        } else {
-            throw new Error("target is not null or an Arc instance");
-        }
-
-        return target;
-    }
-
-
-
-
-    setFromUnitVectors(
-        pointA: Vector3D,
-        pointB: Vector3D,
-    ) {
-
-        // following values might be calculated lazily
-        this.pointA.copy(pointA).normalize();
-        this.pointB.copy(pointB).normalize();
-        this._AxB = pointA.clone().cross(pointB);
-        this._dot = this.pointA.dot(this.pointB);
-        this._theta = Math.acos(this._dot);
-        this._imageinaryPlane = new Plane(this._AxB.clone().normalize(), 0);
-    }
-
-
-
-    populatePoints3D(pointCount: number, startProportion: number = 0, endProportion: number = 1): Float32Array {
-
-        const points3D = new Float32Array(pointCount * 3);
-        const step = (endProportion - startProportion) / (pointCount - 1);
-        const _AxBnormalized = this._AxB.clone().normalize();
-
-        _0vector.copy(this.pointA);
-
-        if (startProportion > 0) {
-            _quaternion.setFromAxisAngle(_AxBnormalized, this._theta * startProportion);
-            _0vector.applyQuaternion(_quaternion);
+import { Vec3, Plane, Arc } from "./types";
+
+import { vec3 } from "./vec3";
+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: Vec3, p1: Vec3): Arc {
+        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]] as Vec3;
+        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
+            } as Plane
         }
-        _quaternion.setFromAxisAngle(_AxBnormalized, this._theta * step);
-        let index = 0;
-        for (let i = 0; i < pointCount; i++) {
-            points3D[index++] = _0vector.x;
-            points3D[index++] = _0vector.y;
-            points3D[index++] = _0vector.z;
-            _0vector.applyQuaternion(_quaternion);
-        }
-
-        return points3D;
+    },
+
+    set(out: Arc, p0: Vec3, p1: Vec3) {
+        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]] as Vec3;
+        vec3.normalize(coverPlaneNormal, coverPlaneNormal);
+        out.coverPlane.normal = coverPlaneNormal;
+        out.coverPlane.distance = vec3.dot(coverPlaneNormal, p0);
+    },
+
+
+    copy(out: Arc, a: Arc) {
+        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: Arc): Arc {
+        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
+            } as Plane
+        };
+    },
+
+
+
+    isPointOn(arc: Arc, point: Vec3): boolean {
+        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: Arc, b: Arc): boolean {
+        return vec3.equals(a.p0, b.p0) && vec3.equals(a.p1, b.p1)
+    },
+
+    populatePoints(out: Float32Array, arc: Arc, count: number) {
+        // rotate p0 around normal vector with a quaternion
+        // calculate angle
     }
-
-
-    // cutBoundingBoxes(dotStep: number = 0.025): { minX: number, minY: number, maxX: number, maxY: number }[] {
-    //     const pointA = this.pointA;
-    //     const to = this.pointB;
-    //     const a = [pointA.x, pointA.y, pointA.z];
-    //     const b = [to.x, to.y, to.z];
-
-    //     const theta = Math.acos(a[0] * b[0] + a[1] * b[1] + a[2] * b[2]);
-    //     const step = dotStep / theta;
-
-    //     if (step >= 1) {
-    //         return [{ minX: Math.min(pointA.x, to.x), minY: Math.min(pointA.y, to.y), maxX: Math.max(pointA.x, to.x), maxY: Math.max(pointA.y, to.y) }];
-    //     }
-
-    //     let points = [pointA] as Vector3D[];
-    //     let currentStep = 0;
-    //     while (currentStep < 1) {
-    //         currentStep += step;
-    //         points.push(this.slerp(currentStep, currentStep + step, 1)[0]);
-    //     }
-
-    //     return points.map(point => ({ minX: point.x, minY: point.y, maxX: point.x, maxY: point.y }));
-    // }
-
-    // boundingBox(): { minLon: Radians, minLat: Radians, maxLon: Radians, maxLat: Radians } {
-
-    //     // Do two poınts remaın on the same half when the circle is cut by Z axis?
-    //     const Z = Math.sign(this.pointA.z + this.pointB.z);
-    //     _0vector.set(0, 0, Z);
-    //     const zDot = this.greatCirclePlaneNormalVector.dot(_0vector);
-    //     const zDif = Math.abs(this.pointA.z - this.pointB.z);
-    //     const minPossibleZDistanceIfOnTheSameHalf = (1 - this.dot) * zDot;
-
-    //     const aLonLat = this.pointA.toLonLat();
-    //     const bLonLat = this.pointB.toLonLat();
-
-    //     if (zDif >= minPossibleZDistanceIfOnTheSameHalf) {
-    //         return {
-    //             minLon: Math.min(aLonLat.lon, bLonLat.lon),
-    //             minLat: Math.min(aLonLat.lat, bLonLat.lat),
-    //             maxLon: Math.max(aLonLat.lon, bLonLat.lon),
-    //             maxLat: Math.max(aLonLat.lat, bLonLat.lat)
-    //         }
-    //     }
-
-    //     // if not, we need to calculate Z peek of the arc
-    //     const z = Math.asin(zDot * Z);
-    //     return {
-    //         minLon: Math.min(aLonLat.lon, bLonLat.lon),
-    //         minLat: Math.min(aLonLat.lat, bLonLat.lat, z),
-    //         maxLon: Math.max(aLonLat.lon, bLonLat.lon),
-    //         maxLat: Math.max(aLonLat.lat, bLonLat.lat, z)
-
-    //     }
-    // }
-
-}
-
+});

package/Math/constants.ts

@@ -1,8 +1,11 @@
 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
+    WORLD_RADIUS_MERCATOR,
+    EPSILON
 }
 

package/Math/frustum/camera.ts

@@ -0,0 +1,32 @@
+// import { WORLD_RADIUS_3D } from '../constants';
+// import { Plane } from '../plane';
+// import { Vector3D } from '../vector3d';
+// import { Quaternion } from '../quaternion';
+
+
+// function cameraFrustum(
+
+//     globe: any,
+//     out: {
+//         near: Plane,
+//         far: Plane,
+//         left: Plane,
+//         right: Plane,
+//         top: Plane,
+//         bottom: Plane
+//     },
+//     fieldOfView: number = 50 // in degrees
+
+// ): void {
+
+//     const lookinfo = globe.api_GetCurrentLookInfo();
+
+//     lookinfo.CenterLong *= Math.PI / 180; // convert degrees to radians
+//     lookinfo.CenterLat *= Math.PI / 180; // convert degrees to radians
+
+//     const lookAtPosition = Vector3D.fromLongLatRadians(lookinfo.CenterLong, lookinfo.CenterLat);
+
+//     const cameraPosition = new Vector3D(globe.Fp.x, globe.Fp.y, globe.Fp.z).divideByScaler(WORLD_RADIUS_3D);
+
+//     return
+// }

package/Math/frustum/from-globeinfo.ts

@@ -0,0 +1,63 @@
+// import { Plane } from "../plane";
+// import { Vector3D } from "../vector3d";
+// import { WORLD_RADIUS_3D } from "../constants";
+// import { Quaternion } from "../quaternion";
+
+// import { FrustumPlanes } from "./types";
+
+// const _quaternion = new Quaternion();
+
+// export function getFrustum(globe: any, fieldOfView: number = 50 * Math.PI / 180,
+//     out: FrustumPlanes): void {
+
+//     const lookinfo = globe.api_GetCurrentLookInfo();
+//     lookinfo.CenterLong *= Math.PI / 180; // convert degrees to radians
+//     lookinfo.CenterLat *= Math.PI / 180; // convert degrees to radians
+//     lookinfo.NorthAng *= Math.PI / 180; // convert degrees to radians
+
+//     const lookAtPosition = Vector3D.fromLongLatRadians(lookinfo.CenterLong, lookinfo.CenterLat);
+//     const cameraPosition = new Vector3D(globe.Fp.x, globe.Fp.y, globe.Fp.z).divideByScaler(WORLD_RADIUS_3D);
+//     const lookFromCamera = lookAtPosition.clone().subtract(cameraPosition).normalize();
+
+
+//     const cameraZ = new Vector3D(globe.Fu.x, globe.Fu.y, globe.Fu.z);
+//     const cameraY = cameraZ.clone().cross(lookFromCamera).normalize();
+
+//     const bottomNormal = cameraZ.clone().applyQuaternion(
+//         _quaternion.setFromAxisAngle(cameraY, -fieldOfView)
+//     ).normalize();
+
+//     const topNormal = cameraZ.clone().applyQuaternion(
+//         _quaternion.setFromAxisAngle(cameraY, fieldOfView)
+//     ).negate().normalize();
+//     const leftNormal = cameraY.clone().applyQuaternion(
+//         _quaternion.setFromAxisAngle(cameraZ, fieldOfView)
+//     ).negate().normalize();
+
+//     const rightNormal = cameraY.clone().applyQuaternion(
+//         _quaternion.setFromAxisAngle(cameraZ, -fieldOfView)
+//     ).normalize();
+
+
+//     out.top.set(topNormal, topNormal.dot(cameraPosition));
+//     out.bottom.set(bottomNormal, bottomNormal.dot(cameraPosition));
+//     out.left.set(leftNormal, leftNormal.dot(cameraPosition));
+//     out.right.set(rightNormal, rightNormal.dot(cameraPosition));
+//     out.far.set(cameraPosition.normalize(), 0.01);
+//     out.near = null; // Near plane is not calculated in this function, set to null
+//     vectorInfo(globe, [out]);
+
+// }
+
+// let interval = 0;
+
+// const vectorInfo = (globe, args: null | Array<any>) => {
+//     interval++;
+//     if (interval % 100 === 0) {
+//         console.log("Fp:", globe.Fp.x / WORLD_RADIUS_3D, globe.Fp.y / WORLD_RADIUS_3D, globe.Fp.z / WORLD_RADIUS_3D);
+//         console.log("Fu:", globe.Fu.x, globe.Fu.y, globe.Fu.z);
+
+//         if (args) console.log(...args)
+//         interval = 0;
+//     }
+// }

package/Math/frustum/types.ts

@@ -0,0 +1,11 @@
+import { Plane } from "../types";
+
+export type FrustumPlanes =
+    {
+        top: Plane,
+        bottom: Plane,
+        left: Plane,
+        right: Plane,
+        near: Plane | null,
+        far: Plane
+    };

package/Math/globe-util/horizon-plane.ts

@@ -0,0 +1,137 @@
+// TODO: REMOVE
+
+// // import { Vector3D, Quaternion, Plane, Ray, Matrix4 } from 'your-3d-math-library'; // <-- ADAPT THIS IMPORT
+
+// import { Vector3D } from '../vector3d';
+// import { Plane } from '../plane';
+// import { Line } from '../line';
+// import { Matrix4 } from '../matrix4';
+// import { Quaternion } from '../quaternion';
+
+// // --- Assume these static helper variables exist within your class ---
+// const _lookFromOrigin = new Vector3D();
+// const _cameraPosition = new Vector3D();
+// const _finalForward = new Vector3D();
+// const _approxUp = new Vector3D();
+// const _finalRight = new Vector3D();
+// const _finalUp = new Vector3D();
+// const _tempVec = new Vector3D(); // General purpose helper
+// const _initialBottomRayDir = new Vector3D();
+// const _qOrient = new Quaternion();
+// const _rollQuaternion = new Quaternion();
+// const _rotationMatrix = new Matrix4();
+// const _fieldOfViewBottomRay = new Line(new Vector3D(), new Vector3D());
+// const _origin3d = new Vector3D(0, 0, 0); // Globe Center
+
+// // --- Assume these constants exist ---
+// const WORLD_RADIUS_3D = 6371000; // Example: Earth radius
+// const FIELD_OF_VIEW = (25 * Math.PI) / 180; // Example: 25 degrees half-FOV in radians
+
+// // // --- Assume Plane class has these methods ---
+// // interface Plane {
+// //     setFromNormalAndPoint(normal: Vector3D, point: Vector3D): this;
+// //     set(normal: Vector3D, constant: number): this;
+// //     // ... other plane methods
+// // }
+
+// // // --- Assume Ray class has these methods ---
+// // interface Ray {
+// //     origin: Vector3D;
+// //     direction: Vector3D;
+// //     intersectionSphere(center: Vector3D, radius: number): Vector3D[] | null; // Or similar
+// //     // ... other ray methods
+// // }
+
+// // // --- Assume Vector3D has setFromLongLat ---
+// // interface Vector3D {
+// //     setFromLongLat(lon: number, lat: number): this;
+// //     // ... other vector methods
+// // }
+// // // --- END OF ASSUMPTIONS ---
+
+
+// /**
+//  * Calculates a culling plane representing the bottom edge of the camera's field of view.
+//  * @param globe - The globe object, expected to have api_GetCurrentLookInfo and Fp properties.
+//  * @param out - The Plane object to store the result.
+//  * @param fieldOfView - The vertical half-angle of the field of view in radians.
+//  * @returns The calculated Plane.
+//  */
+// function calculateHorizonPlane(globe: any, out: Plane, fieldOfView: number = FIELD_OF_VIEW): Plane {
+
+//     const cameraLookInfo = globe.api_GetCurrentLookInfo();
+//     cameraLookInfo.CenterLong *= Math.PI / 180;
+//     cameraLookInfo.CenterLat *= Math.PI / 180;
+//     // cameraLookInfo.Tilt *= Math.PI / 180; // Tilt is now implicitly handled
+//     cameraLookInfo.NorthAng *= Math.PI / 180;
+
+//     // Set _lookFromOrigin based on camera target (Lon/Lat)
+//     (_lookFromOrigin as any).setFromLongLat(cameraLookInfo.CenterLong, cameraLookInfo.CenterLat); // Cast to any if setFromLongLat is custom
+
+//     // 1. Calculate _cameraPosition and _finalForward (_lookFromCamera)
+//     _cameraPosition.set(globe.Fp.x, globe.Fp.y, globe.Fp.z); // Using your X negation
+//     _cameraPosition.divideScalar(WORLD_RADIUS_3D); // Scale to unit sphere
+
+//     Vector3D.subVectors(_lookFromOrigin, _cameraPosition, _finalForward).normalize();
+
+//     // 2. Calculate Q_orient (Final Camera Orientation Quaternion)
+
+//     // Use the vector from origin to camera as an initial 'up' reference
+//     _approxUp.copy(_cameraPosition).normalize();
+
+//     // Calculate Right vector using cross product
+//     Vector3D.crossVectors(_finalForward, _approxUp, _finalRight).normalize();
+
+//     // Handle edge case: If looking straight along (or opposite to) _approxUp
+//     if (_finalRight.lengthSq() < 0.0001) {
+//         // If vectors are parallel, _approxUp is not good.
+//         // Choose a different 'up', e.g., if _approxUp is near Z, use Y.
+//         if (Math.abs(_approxUp.z) > 0.9) {
+//             _approxUp.set(0, 1, 0);
+//         } else {
+//             _approxUp.set(0, 0, 1);
+//         }
+//         Vector3D.crossVectors(_finalForward, _approxUp, _finalRight).normalize();
+//     }
+
+//     // Calculate the 'true' Up vector, orthogonal to Right and Forward
+//     Vector3D.crossVectors(_finalRight, _finalForward, _finalUp).normalize();
+
+//     // Apply NorthAng (Roll) around the Forward axis
+//     _rollQuaternion.setFromAxisAngle(_finalForward, cameraLookInfo.NorthAng);
+//     _finalUp.applyQuaternion(_rollQuaternion);
+//     _finalRight.applyQuaternion(_rollQuaternion); // Must rotate Right as well!
+
+//     // Create Q_orient from the final basis vectors (Right, Up, -Forward)
+//     // This assumes a Matrix4.makeBasis(x, y, z) exists and builds a rotation matrix.
+//     // It also assumes local camera looks down -Z, hence negating _finalForward for the Z basis.
+//     _tempVec.copy(_finalForward).negate();
+//     _rotationMatrix.makeBasis(_finalRight, _finalUp, _tempVec); // <-- ADAPT: Ensure your library has makeBasis or equivalent
+//     _qOrient.setFromRotationMatrix(_rotationMatrix); // <-- ADAPT: Ensure this function exists
+
+//     // 3. Calculate Initial Bottom Ray (Local: -Z forward, Y up, X right)
+//     // Rotates (0, 0, -1) around (1, 0, 0) by fieldOfView
+//     _initialBottomRayDir.set(0, -Math.sin(fieldOfView), -Math.cos(fieldOfView));
+
+//     // 4. Calculate Final Bottom Ray (World)
+//     _fieldOfViewBottomRay.direction.copy(_initialBottomRayDir).applyQuaternion(_qOrient).normalize();
+//     _fieldOfViewBottomRay.origin.copy(_cameraPosition);
+
+//     // 5. Intersection and Plane
+//     const intersection = (_fieldOfViewBottomRay as any).intersectionSphere(_origin3d, 1); // Cast to any if method isn't standard
+
+//     if (intersection && intersection.length > 0) {
+//         // If ray intersects, use the closest point for the plane
+//         out.setFromNormalAndPoint(_lookFromOrigin, intersection[0]);
+//     } else {
+//         // If ray does not intersect (FOV covers globe or misses)
+//         // WARNING: This sets a plane through the globe's center.
+//         // This might not be the desired behavior for culling.
+//         // Consider what should happen if the whole globe *is* visible.
+//         out.set(_lookFromOrigin, 0.0);
+//     }
+
+//     return out;
+// }
+
+// export { calculateHorizonPlane };

package/Math/juction/arc-plane.ts

@@ -0,0 +1,90 @@
+import { Vec3, Plane, Line, Sphere, Arc } from "../types";
+import { EPSILON } from "../constants";
+import { vec3 } from "../vec3";
+import { line } from "../line";
+import { plane } from "../plane";
+import { arc } from "../arc";
+import { planePlaneJuction } from "./plane-plane";
+import { lineSphereIntersection } from "./line-sphere";
+
+const _intersectionLine = /*@__PURE__*/ line.create();
+const _originPlane = /*@__PURE__*/ plane.create();
+_originPlane.distance = 0;
+const _originSphere = /*@__PURE__*/ { center: vec3.create(0, 0, 0), radius: 1 } as Sphere;
+
+const _intersectionPoints: [Vec3, Vec3] = /*@__PURE__*/[vec3.create(), vec3.create()];
+
+// 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
+export function arcSlice(out: Arc, inArc: Arc, juctionPlane: Plane): boolean {
+
+    // arc coverPlane and junctionPlane intersection exist in the range of unit sphere
+    const coverRadiusAngle = plane.getUnitSphereRadiusAngle(inArc.coverPlane);
+    const visibleRadiusAngle = plane.getUnitSphereRadiusAngle(juctionPlane);
+    // TODO: RESEARCH efficient approach --
+    const angleBetween_Cover_Visible = Math.acos(vec3.dot(inArc.coverPlane.normal, juctionPlane.normal));
+
+    if (coverRadiusAngle + visibleRadiusAngle < angleBetween_Cover_Visible - EPSILON) { // case A: out of range
+        return false; // 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, inArc);
+        return true;
+    }
+    // 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);
+
+    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");
+    }
+
+
+    // calculate the intersection points
+
+    const isSphereIntersection = lineSphereIntersection(_intersectionPoints, _intersectionLine, _originSphere);
+
+    if (!isSphereIntersection) {
+        // other edge caes should be covered by now
+        return false; // No intersection
+    }
+
+
+    const i0IsCovered = plane.distanceToPoint(inArc.coverPlane, _intersectionPoints[0]) > -EPSILON;
+    const i1IsCovered = plane.distanceToPoint(inArc.coverPlane, _intersectionPoints[1]) > -EPSILON;
+
+    if (i0IsCovered && i1IsCovered) {
+        arc.set(out, _intersectionPoints[0], _intersectionPoints[1]);
+        return true;
+    }
+
+    const p0IsVisible = plane.distanceToPoint(juctionPlane, inArc.p0) > -EPSILON;
+    const p1IsVisible = plane.distanceToPoint(juctionPlane, inArc.p1) > -EPSILON;
+
+    if (p0IsVisible && p1IsVisible) {
+        arc.copy(out, inArc);
+        return true;
+    }
+
+    if (!p0IsVisible && !p1IsVisible && !i0IsCovered && !i1IsCovered) {
+        return false; // No intersection
+    }
+
+    if ((p0IsVisible || p1IsVisible) !== (i0IsCovered || i1IsCovered)) {
+        throw new Error("Unexpected case: one covered and one visible point must be present");
+    }
+
+    arc.set(
+        out,
+        p0IsVisible ? inArc.p0 : inArc.p1,
+        i0IsCovered ? _intersectionPoints[0] : _intersectionPoints[1]
+    );
+
+    return true;
+}