@pirireis/webglobeplugins 0.9.9 → 0.9.11

package/Math/angle-calculation.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bearingRealAngle = bearingRealAngle;
+function bearingRealAngle(long, lat, endLong, endLat) {
+    var rLong = Radians * long;
+    var rLat = Radians * lat;
+    var rEndLong = Radians * endLong;
+    var rEndLat = Radians * endLat;
+    var delta_long = rEndLong - rLong;
+    var x = Math.sin(delta_long) * Math.cos(rEndLat);
+    var y = Math.cos(rLat) * Math.sin(rEndLat) - Math.sin(rLat) * Math.cos(rEndLat) * Math.cos(delta_long);
+    var initialBearing = Math.atan2(x, y) / Radians;
+    initialBearing = (initialBearing + 360) % 360;
+    return initialBearing;
+}

package/Math/arc.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.arc = void 0;
+var vec3_1 = require("./vec3");
+var constants_1 = require("./constants");
+var _0vector = /*@__PURE__*/ vec3_1.vec3.create(0, 0, 0);
+var _1vector = /*@__PURE__*/ vec3_1.vec3.create(1, 1, 1);
+exports.arc = Object.freeze({
+    create: function (p0, p1) {
+        var normal = vec3_1.vec3.create(0, 0, 0);
+        vec3_1.vec3.cross(normal, p0, p1);
+        var coverPlaneNormal = [p0[0] + p1[0], p0[1] + p1[1], p0[2] + p1[2]];
+        vec3_1.vec3.normalize(coverPlaneNormal, coverPlaneNormal);
+        var dot = vec3_1.vec3.dot(coverPlaneNormal, p0);
+        return {
+            p0: vec3_1.vec3.clone(p0),
+            p1: vec3_1.vec3.clone(p1),
+            normal: vec3_1.vec3.clone(normal),
+            coverPlane: {
+                normal: coverPlaneNormal,
+                distance: dot
+            }
+        };
+    },
+    set: function (out, p0, p1) {
+        vec3_1.vec3.copy(out.p0, p0);
+        vec3_1.vec3.copy(out.p1, p1);
+        vec3_1.vec3.cross(out.normal, p0, p1);
+        var coverPlaneNormal = [p0[0] + p1[0], p0[1] + p1[1], p0[2] + p1[2]];
+        vec3_1.vec3.normalize(coverPlaneNormal, coverPlaneNormal);
+        out.coverPlane.normal = coverPlaneNormal;
+        out.coverPlane.distance = vec3_1.vec3.dot(coverPlaneNormal, p0);
+    },
+    copy: function (out, a) {
+        vec3_1.vec3.copy(out.p0, a.p0);
+        vec3_1.vec3.copy(out.p1, a.p1);
+        vec3_1.vec3.copy(out.normal, a.normal);
+        out.coverPlane.normal = vec3_1.vec3.clone(a.coverPlane.normal);
+        out.coverPlane.distance = a.coverPlane.distance;
+    },
+    clone: function (a) {
+        return {
+            p0: vec3_1.vec3.clone(a.p0),
+            p1: vec3_1.vec3.clone(a.p1),
+            normal: vec3_1.vec3.clone(a.normal),
+            coverPlane: {
+                normal: vec3_1.vec3.clone(a.coverPlane.normal),
+                distance: a.coverPlane.distance
+            }
+        };
+    },
+    isPointOn: function (arc, point) {
+        var alignment = Math.abs(vec3_1.vec3.dot(point, arc.normal)) < constants_1.EPSILON;
+        var distance = Math.abs(vec3_1.vec3.lengthSquared(point) - 1) < constants_1.EPSILON;
+        var cover = vec3_1.vec3.dot(arc.coverPlane.normal, point) >= arc.coverPlane.distance;
+        return alignment || distance || cover;
+    },
+    equals: function (a, b) {
+        return vec3_1.vec3.equals(a.p0, b.p0) && vec3_1.vec3.equals(a.p1, b.p1);
+    },
+    populatePoints: function (out, arc, count) {
+        // rotate p0 around normal vector with a quaternion
+        // calculate angle
+    }
+});

package/Math/bounds/line-bbox.js

@@ -0,0 +1,190 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getGreatCircleArcBBox = getGreatCircleArcBBox;
+function isClose(a, b, rtol, atol) {
+    if (rtol === void 0) { rtol = 1e-5; }
+    if (atol === void 0) { atol = 1e-8; }
+    // JavaScript equivalent of NumPy's isclose
+    return Math.abs(a - b) <= (atol + rtol * Math.abs(b));
+}
+function mod(n, m) {
+    // Proper modulo operation that handles negative numbers
+    return ((n % m) + m) % m;
+}
+function calculateInitialBearing(phi1, lambda1, phi2, lambda2) {
+    // Calculates the initial bearing (forward azimuth) from point 1 to point 2
+    if (isClose(Math.cos(phi1), 0)) { // Starting from a pole
+        if (phi1 > 0) { // North pole
+            return Math.PI; // Bearing is South
+        }
+        else { // South pole
+            return 0; // Bearing is North
+        }
+    }
+    var deltaLambda = lambda2 - lambda1;
+    var y = Math.sin(deltaLambda) * Math.cos(phi2);
+    var x = Math.cos(phi1) * Math.sin(phi2) - Math.sin(phi1) * Math.cos(phi2) * Math.cos(deltaLambda);
+    var theta = Math.atan2(y, x);
+    return theta;
+}
+function getGreatCircleArcBBox(phi1Rad, lambda1Rad, phi2Rad, lambda2Rad) {
+    // Calculates the bounding box around the great circle arc between two points
+    // on a spherical surface, handling edge cases like poles and antimeridian crossing.
+    // Args: Latitudes and longitudes in radians
+    // Returns: [phiMin, phiMax, lambdaMin, lambdaMax] in radians
+    // === Edge Case: Same Points ===
+    if (isClose(phi1Rad, phi2Rad) && isClose(lambda1Rad, lambda2Rad)) {
+        return [phi1Rad, phi1Rad, lambda1Rad, lambda1Rad];
+    }
+    // === Edge Case: Antipodal Points ===
+    var deltaLambdaNorm = mod(lambda1Rad - lambda2Rad + Math.PI, 2 * Math.PI) - Math.PI;
+    if (isClose(phi1Rad, -phi2Rad) && isClose(Math.abs(deltaLambdaNorm), Math.PI)) {
+        // Path covers all longitudes and passes through poles
+        return [-Math.PI / 2, Math.PI / 2, -Math.PI, Math.PI];
+    }
+    // === Longitude Bounds ===
+    var lambda1Adj = lambda1Rad;
+    var lambda2Adj = lambda2Rad;
+    // Handle antimeridian crossing
+    var deltaLambda = lambda2Rad - lambda1Rad;
+    if (deltaLambda > Math.PI) {
+        deltaLambda -= 2 * Math.PI;
+    }
+    else if (deltaLambda <= -Math.PI) {
+        deltaLambda += 2 * Math.PI;
+    }
+    var crossesAntimeridian = Math.abs(lambda2Rad - lambda1Rad) > Math.PI;
+    if (crossesAntimeridian) {
+        // Add 2*pi to the smaller longitude
+        if (lambda1Rad < lambda2Rad) {
+            lambda1Adj += 2 * Math.PI;
+        }
+        else {
+            lambda2Adj += 2 * Math.PI;
+        }
+    }
+    var lambdaMin = Math.min(lambda1Adj, lambda2Adj);
+    var lambdaMax = Math.max(lambda1Adj, lambda2Adj);
+    // === Latitude Bounds ===
+    var phiMin = Math.min(phi1Rad, phi2Rad);
+    var phiMax = Math.max(phi1Rad, phi2Rad);
+    // === Vertex Check ===
+    // Check the maximum/minimum latitude reached by the great circle
+    var theta12 = calculateInitialBearing(phi1Rad, lambda1Rad, phi2Rad, lambda2Rad);
+    var theta21 = calculateInitialBearing(phi2Rad, lambda2Rad, phi1Rad, lambda1Rad);
+    var cosPhi1 = Math.cos(phi1Rad);
+    if (!isClose(cosPhi1, 0)) { // Starting point is not a pole
+        // Compute the absolute latitude of the vertex
+        var argAcos = Math.abs(Math.sin(theta12) * cosPhi1);
+        var phiVtxAbs = Math.acos(Math.min(Math.max(argAcos, -1.0), 1.0));
+        // Check if the path crosses the northern vertex
+        if (isClose(theta12, 0) && phiVtxAbs > phiMax) { // Starting due north
+            phiMax = phiVtxAbs;
+        }
+        else if (isClose(Math.abs(theta12), Math.PI) && -phiVtxAbs < phiMin) { // Starting due south
+            phiMin = -phiVtxAbs;
+        }
+        else {
+            // General case: Check if the path crosses the vertex
+            var finalBearingAtP2 = mod(theta21 + Math.PI + Math.PI, 2 * Math.PI) - Math.PI;
+            // Northern vertex check
+            if ((-Math.PI / 2 < theta12 && theta12 < Math.PI / 2) &&
+                !(finalBearingAtP2 >= -Math.PI / 2 && finalBearingAtP2 <= Math.PI / 2)) {
+                if (phiVtxAbs > phiMax) {
+                    phiMax = phiVtxAbs;
+                }
+            }
+            // Southern vertex check
+            if (!(theta12 >= -Math.PI / 2 && theta12 <= Math.PI / 2) &&
+                (-Math.PI / 2 < finalBearingAtP2 && finalBearingAtP2 < Math.PI / 2)) {
+                if (-phiVtxAbs < phiMin) {
+                    phiMin = -phiVtxAbs;
+                }
+            }
+        }
+    }
+    return [phiMin, phiMax, lambdaMin, lambdaMax];
+}
+// --- Example Usage ---
+function degreesToRadians(deg) {
+    return deg * Math.PI / 180;
+}
+function radiansToDegrees(rad) {
+    return rad * 180 / Math.PI;
+}
+// Test Case 1: London to Tokyo
+var lat1Deg = 51.5, lon1Deg = -0.1;
+var lat2Deg = 35.7, lon2Deg = 139.7;
+var phi1 = degreesToRadians(lat1Deg);
+var lambda1 = degreesToRadians(lon1Deg);
+var phi2 = degreesToRadians(lat2Deg);
+var lambda2 = degreesToRadians(lon2Deg);
+var _a = getGreatCircleArcBBox(phi1, lambda1, phi2, lambda2), phiMinRad = _a[0], phiMaxRad = _a[1], lambdaMinRad = _a[2], lambdaMaxRad = _a[3];
+var phiMinDeg = radiansToDegrees(phiMinRad);
+var phiMaxDeg = radiansToDegrees(phiMaxRad);
+var lambdaMinDeg = radiansToDegrees(lambdaMinRad);
+var lambdaMaxDeg = radiansToDegrees(lambdaMaxRad);
+console.log("Input Points (Radians):");
+console.log("  P1: Latitude=".concat(lat1Deg, ", Longitude=").concat(lon1Deg));
+console.log("  P2: Latitude=".concat(lat2Deg, ", Longitude=").concat(lon2Deg));
+console.log("  P1: Latitude=".concat(phi1.toFixed(4), ", Longitude=").concat(lambda1.toFixed(4)));
+console.log("  P2: Latitude=".concat(phi2.toFixed(4), ", Longitude=").concat(lambda2.toFixed(4)));
+console.log("-".repeat(20));
+console.log("Bounding Box (Radians):");
+// console phys://console.log(`  Minimum Latitude (phi_min): ${phiMinRad.toFixed(4)}`);
+console.log("  Maximum Latitude (phi_max): ".concat(phiMaxRad.toFixed(4)));
+console.log("  Minimum Longitude (lambda_min): ".concat(lambdaMinRad.toFixed(4)));
+console.log("  Maximum Longitude (lambda_max): ".concat(lambdaMaxRad.toFixed(4)));
+console.log("-".repeat(20));
+console.log("Bounding Box (Degrees):");
+console.log("  Minimum Latitude: ".concat(phiMinDeg.toFixed(2), "\u00B0"));
+console.log("  Maximum Latitude: ".concat(phiMaxDeg.toFixed(2), "\u00B0"));
+console.log("  Minimum Longitude: ".concat(lambdaMinDeg.toFixed(2), "\u00B0"));
+console.log("  Maximum Longitude: ".concat(lambdaMaxDeg.toFixed(2), "\u00B0"));
+// --- Antimeridian Crossing Test ---
+console.log("\n" + "=".repeat(30));
+console.log("Antimeridian Crossing Test");
+var lat1DegAm = -18, lon1DegAm = 178;
+var lat2DegAm = -14, lon2DegAm = -172;
+var phi1Am = degreesToRadians(lat1DegAm);
+var lambda1Am = degreesToRadians(lon1DegAm);
+var phi2Am = degreesToRadians(lat2DegAm);
+var lambda2Am = degreesToRadians(lon2DegAm);
+var _b = getGreatCircleArcBBox(phi1Am, lambda1Am, phi2Am, lambda2Am), phiMinRadAm = _b[0], phiMaxRadAm = _b[1], lambdaMinRadAm = _b[2], lambdaMaxRadAm = _b[3];
+var phiMinDegAm = radiansToDegrees(phiMinRadAm);
+var phiMaxDegAm = radiansToDegrees(phiMaxRadAm);
+var lambdaMinDegAm = radiansToDegrees(lambdaMinRadAm);
+var lambdaMaxDegAm = radiansToDegrees(lambdaMaxRadAm);
+console.log("Input Points (Degrees): P1=(".concat(lat1DegAm, ", ").concat(lon1DegAm, "), P2=(").concat(lat2DegAm, ", ").concat(lon2DegAm, ")"));
+console.log("Bounding Box (Radians):");
+console.log("  phi_min=".concat(phiMinRadAm.toFixed(4), ", phi_max=").concat(phiMaxRadAm.toFixed(4)));
+console.log("  lambda_min=".concat(lambdaMinRadAm.toFixed(4), ", lambda_max=").concat(lambdaMaxRadAm.toFixed(4)));
+console.log("Bounding Box (Degrees):");
+console.log("  Min Latitude: ".concat(phiMinDegAm.toFixed(2), "\u00B0"));
+console.log("  Max Latitude: ".concat(phiMaxDegAm.toFixed(2), "\u00B0"));
+console.log("  Min Longitude: ".concat(lambdaMinDegAm.toFixed(2), "\u00B0 (178\u00B0 expected)"));
+console.log("  Max Longitude: ".concat(lambdaMaxDegAm.toFixed(2), "\u00B0 (188\u00B0 expected, which is -172\u00B0 + 360\u00B0)"));
+// --- Polar Crossing Test ---
+console.log("\n" + "=".repeat(30));
+console.log("Polar Crossing Test");
+var lat1DegP = 80, lon1DegP = 20;
+var lat2DegP = 80, lon2DegP = -100;
+var phi1P = degreesToRadians(lat1DegP);
+var lambda1P = degreesToRadians(lon1DegP);
+var phi2P = degreesToRadians(lat2DegP);
+var lambda2P = degreesToRadians(lon2DegP);
+var _c = getGreatCircleArcBBox(phi1P, lambda1P, phi2P, lambda2P), phiMinRadP = _c[0], phiMaxRadP = _c[1], lambdaMinRadP = _c[2], lambdaMaxRadP = _c[3];
+var phiMinDegP = radiansToDegrees(phiMinRadP);
+var phiMaxDegP = radiansToDegrees(phiMaxRadP);
+var lambdaMinDegP = radiansToDegrees(lambdaMinRadP);
+var lambdaMaxDegP = radiansToDegrees(lambdaMaxRadP);
+console.log("Input Points (Degrees): P1=(".concat(lat1DegP, ", ").concat(lon1DegP, "), P2=(").concat(lat2DegP, ", ").concat(lon2DegP, ")"));
+console.log("Bounding Box (Radians):");
+console.log("  phi_min=".concat(phiMinRadP.toFixed(4), ", phi_max=").concat(phiMaxRadP.toFixed(4)));
+console.log("  lambda_min=".concat(lambdaMinRadP.toFixed(4), ", lambda_max=").concat(lambdaMaxRadP.toFixed(4)));
+console.log("Bounding Box (Degrees):");
+console.log("  Min Latitude: ".concat(phiMinDegP.toFixed(2), "\u00B0"));
+console.log("  Max Latitude: ".concat(phiMaxDegP.toFixed(2), "\u00B0 (Should be close to North Pole > 80\u00B0)"));
+console.log("  Min Longitude: ".concat(lambdaMinDegP.toFixed(2), "\u00B0"));
+console.log("  Max Longitude: ".concat(lambdaMaxDegP.toFixed(2), "\u00B0"));
+// --- line points intersection with bbox ---

package/Math/constants.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EPSILON = exports.WORLD_RADIUS_MERCATOR = exports.WORLD_RADIUS_3D = void 0;
+var WORLD_RADIUS_3D = 6378.137;
+exports.WORLD_RADIUS_3D = WORLD_RADIUS_3D;
+var WORLD_RADIUS_MERCATOR = 6378136.99911;
+exports.WORLD_RADIUS_MERCATOR = WORLD_RADIUS_MERCATOR;
+var EPSILON = 1e-10; // Used for floating point comparisons
+exports.EPSILON = EPSILON;

package/Math/frustum/camera.js

@@ -0,0 +1,24 @@
+"use strict";
+// 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.js

@@ -0,0 +1,48 @@
+"use strict";
+// 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.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,112 @@
+"use strict";
+// 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/index.js

@@ -0,0 +1 @@
+"use strict";

package/Math/juction/arc-plane.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.arcSlice = arcSlice;
+var constants_1 = require("../constants");
+var vec3_1 = require("../vec3");
+var line_1 = require("../line");
+var plane_1 = require("../plane");
+var arc_1 = require("../arc");
+var plane_plane_1 = require("./plane-plane");
+var line_sphere_1 = require("./line-sphere");
+var _intersectionLine = /*@__PURE__*/ line_1.line.create();
+var _originPlane = /*@__PURE__*/ plane_1.plane.create();
+_originPlane.distance = 0;
+var _originSphere = /*@__PURE__*/ { center: vec3_1.vec3.create(0, 0, 0), radius: 1 };
+var _intersectionPoints = /*@__PURE__*/ [vec3_1.vec3.create(), vec3_1.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
+/**
+ *
+ * @param out \
+ * @param inArc
+ * @param juctionPlane
+ * @returns number of arcs segments in the junction divided by the junction plane.
+ */
+function arcSlice(out, inArc, juctionPlane) {
+    // arc coverPlane and junctionPlane intersection exist in the range of unit sphere
+    var coverRadiusAngle = plane_1.plane.getUnitSphereRadiusAngle(inArc.coverPlane);
+    var visibleRadiusAngle = plane_1.plane.getUnitSphereRadiusAngle(juctionPlane);
+    // TODO: RESEARCH efficient approach --
+    var angleBetween_Cover_Visible = Math.acos(vec3_1.vec3.dot(inArc.coverPlane.normal, juctionPlane.normal));
+    if (coverRadiusAngle + visibleRadiusAngle < angleBetween_Cover_Visible - constants_1.EPSILON) { // case A: out of range
+        return 0; // No intersection
+    }
+    // ------------------------------------
+    // the case when the arc is completely covered by the juction plane
+    if (visibleRadiusAngle + constants_1.EPSILON >= angleBetween_Cover_Visible + coverRadiusAngle) { // case B: fully visible
+        arc_1.arc.copy(out[0], inArc);
+        return 1;
+    }
+    // plane-plane intersection line should be calculated for the rest of the calculations
+    vec3_1.vec3.copy(_originPlane.normal, inArc.normal);
+    var isPlaneJunctions = (0, plane_plane_1.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");
+    }
+    // --- read until here ---
+    // calculate the intersection points
+    var isSphereIntersection = (0, line_sphere_1.lineSphereIntersection)(_intersectionPoints, _intersectionLine, _originSphere);
+    if (!isSphereIntersection) {
+        // other edge caes should be covered by now
+        return 0; // No intersection
+    }
+    var i0IsCovered = plane_1.plane.distanceToPoint(inArc.coverPlane, _intersectionPoints[0]) > -constants_1.EPSILON;
+    var i1IsCovered = plane_1.plane.distanceToPoint(inArc.coverPlane, _intersectionPoints[1]) > -constants_1.EPSILON;
+    var p0IsVisible = plane_1.plane.distanceToPoint(juctionPlane, inArc.p0) > -constants_1.EPSILON;
+    var p1IsVisible = plane_1.plane.distanceToPoint(juctionPlane, inArc.p1) > -constants_1.EPSILON;
+    if (!p0IsVisible && !p1IsVisible && !i0IsCovered && !i1IsCovered) {
+        return 0; // No intersection
+    }
+    if (i0IsCovered && i1IsCovered && p0IsVisible && p1IsVisible) {
+        // calculate which points are closer
+        var p0i0DistanceSquared = vec3_1.vec3.distanceSquared(inArc.p0, _intersectionPoints[0]);
+        var p0i1DistanceSquared = vec3_1.vec3.distanceSquared(inArc.p0, _intersectionPoints[1]);
+        var case0 = p0i0DistanceSquared < p0i1DistanceSquared;
+        arc_1.arc.set(out[0], inArc.p0, case0 ? _intersectionPoints[0] : _intersectionPoints[1]);
+        arc_1.arc.set(out[1], inArc.p1, !case0 ? _intersectionPoints[0] : _intersectionPoints[1]);
+        return 2;
+    }
+    if (i0IsCovered && i1IsCovered) {
+        arc_1.arc.set(out[0], _intersectionPoints[0], _intersectionPoints[1]);
+        return 1;
+    }
+    if (p0IsVisible && p1IsVisible) {
+        arc_1.arc.copy(out[0], inArc);
+        return 1;
+    }
+    if ((p0IsVisible || p1IsVisible) !== (i0IsCovered || i1IsCovered)) {
+        throw new Error("Unexpected case: one covered and one visible point must be present");
+    }
+    arc_1.arc.set(out[0], p0IsVisible ? inArc.p0 : inArc.p1, i0IsCovered ? _intersectionPoints[0] : _intersectionPoints[1]);
+    return 1;
+}

package/Math/juction/line-sphere.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lineSphereIntersection = lineSphereIntersection;
+var vec3_1 = require("../vec3");
+var line_1 = require("../line");
+var _0vector = /*@__PURE__*/ vec3_1.vec3.create(0, 0, 0);
+function lineSphereIntersection(out, inLine, inSphere) {
+    vec3_1.vec3.subtract(_0vector, inLine.origin, inSphere.center);
+    var distanceSquared = vec3_1.vec3.lengthSquared(_0vector);
+    var radiusSquared = inSphere.radius * inSphere.radius;
+    var dot = vec3_1.vec3.dot(_0vector, inLine.direction);
+    var dotSquared = dot * dot;
+    var _a = dotSquared + radiusSquared - distanceSquared;
+    if (_a < 0) {
+        return false; // no intersection
+    }
+    else {
+        var a = Math.sqrt(_a);
+        var t1 = dot - a;
+        var t2 = dot + a;
+        line_1.line.at(out[0], inLine, t1);
+        line_1.line.at(out[1], inLine, t2);
+        return true;
+    }
+}

package/Math/juction/plane-plane.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.planePlaneJuction = planePlaneJuction;
+var constants_1 = require("../constants");
+var vec3_1 = require("../vec3");
+var _normal1 = vec3_1.vec3.create();
+var _normal2 = vec3_1.vec3.create();
+function planePlaneJuction(out, plane1, plane2) {
+    vec3_1.vec3.copy(_normal1, plane1.normal);
+    vec3_1.vec3.copy(_normal2, plane2.normal);
+    var distance1 = plane1.distance;
+    var distance2 = plane2.distance;
+    var origin = out.origin, direction = out.direction;
+    var dot = vec3_1.vec3.dot(_normal1, _normal2);
+    if (Math.abs(dot) > 1 - constants_1.EPSILON) {
+        return false; // Planes are parallel, no intersection
+    }
+    vec3_1.vec3.cross(direction, _normal1, _normal2);
+    var magnitudeSquired = vec3_1.vec3.lengthSquared(out.direction);
+    if (magnitudeSquired < constants_1.EPSILON) {
+        return false; // No valid intersection line
+    }
+    var magnitude = Math.sqrt(magnitudeSquired);
+    direction[0] /= magnitude;
+    direction[1] /= magnitude;
+    direction[2] /= magnitude;
+    var determinant;
+    // Calculate the intersection point
+    // set z = 0
+    determinant = _normal1[0] * _normal2[1] - _normal1[1] * _normal2[0];
+    if (Math.abs(determinant) > constants_1.EPSILON) {
+        origin[0] = (distance1 * _normal2[1] - distance2 * _normal1[1]) / determinant;
+        origin[1] = (distance2 * _normal1[0] - distance1 * _normal2[0]) / determinant;
+        origin[2] = 0;
+    }
+    else {
+        // set y = 0
+        determinant = _normal1[0] * _normal2[2] - _normal1[2] * _normal2[0];
+        if (Math.abs(determinant) > constants_1.EPSILON) {
+            origin[0] = (distance1 * _normal2[2] - distance2 * _normal1[2]) / determinant;
+            origin[1] = 0;
+            origin[2] = (distance2 * _normal1[0] - distance1 * _normal2[0]) / determinant;
+        }
+        else {
+            // set x = 0
+            determinant = _normal1[1] * _normal2[2] - _normal1[2] * _normal2[1];
+            if (Math.abs(determinant) > constants_1.EPSILON) {
+                origin[0] = 0;
+                origin[1] = (distance1 * _normal2[2] - distance2 * _normal1[2]) / determinant;
+                origin[2] = (distance2 * _normal1[1] - distance1 * _normal2[1]) / determinant;
+            }
+            else {
+                return false; // No valid intersection point
+            }
+        }
+    }
+    return true;
+}