@pirireis/webglobeplugins 0.9.6 → 0.9.7

package/package.json

@@ -1,10 +1,13 @@
 {
     "name": "@pirireis/webglobeplugins",
-    "version": "0.9.6",
+    "version": "0.9.7",
     "main": "index.js",
     "author": "Toprak Nihat Deniz Ozturk",
     "license": "MIT",
     "scripts": {
         "build": "tsc"
-    }
+    },
+    "files": [
+        "dist"
+    ]
 }

package/Math/angle-calculation.js

@@ -1,14 +0,0 @@
-function bearingRealAngle(long, lat, endLong, endLat) {
-    const rLong = Radians * long;
-    const rLat = Radians * lat;
-    const rEndLong = Radians * endLong;
-    const rEndLat = Radians * endLat;
-    const delta_long = rEndLong - rLong;
-    const x = Math.sin(delta_long) * Math.cos(rEndLat);
-    const y = Math.cos(rLat) * Math.sin(rEndLat) - Math.sin(rLat) * Math.cos(rEndLat) * Math.cos(delta_long);
-    let initialBearing = Math.atan2(x, y) / Radians;
-    initialBearing = (initialBearing + 360) % 360;
-    return initialBearing;
-}
-
-export { bearingRealAngle };

package/Math/arc.ts

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

package/Math/bounds/line-bbox.js

@@ -1,225 +0,0 @@
-function isClose(a, b, rtol = 1e-5, 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
-        }
-    }
-
-    const deltaLambda = lambda2 - lambda1;
-    const y = Math.sin(deltaLambda) * Math.cos(phi2);
-    const x = Math.cos(phi1) * Math.sin(phi2) - Math.sin(phi1) * Math.cos(phi2) * Math.cos(deltaLambda);
-    const 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 ===
-    const 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 ===
-    let lambda1Adj = lambda1Rad;
-    let lambda2Adj = lambda2Rad;
-
-    // Handle antimeridian crossing
-    let deltaLambda = lambda2Rad - lambda1Rad;
-    if (deltaLambda > Math.PI) {
-        deltaLambda -= 2 * Math.PI;
-    } else if (deltaLambda <= -Math.PI) {
-        deltaLambda += 2 * Math.PI;
-    }
-
-    const 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;
-        }
-    }
-
-    const lambdaMin = Math.min(lambda1Adj, lambda2Adj);
-    const lambdaMax = Math.max(lambda1Adj, lambda2Adj);
-
-    // === Latitude Bounds ===
-    let phiMin = Math.min(phi1Rad, phi2Rad);
-    let phiMax = Math.max(phi1Rad, phi2Rad);
-
-    // === Vertex Check ===
-    // Check the maximum/minimum latitude reached by the great circle
-    const theta12 = calculateInitialBearing(phi1Rad, lambda1Rad, phi2Rad, lambda2Rad);
-    const theta21 = calculateInitialBearing(phi2Rad, lambda2Rad, phi1Rad, lambda1Rad);
-
-    const cosPhi1 = Math.cos(phi1Rad);
-    if (!isClose(cosPhi1, 0)) { // Starting point is not a pole
-        // Compute the absolute latitude of the vertex
-        const argAcos = Math.abs(Math.sin(theta12) * cosPhi1);
-        const 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
-            const 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;
-}
-
-
-export { getGreatCircleArcBBox };
-
-// Test Case 1: London to Tokyo
-const lat1Deg = 51.5, lon1Deg = -0.1;
-const lat2Deg = 35.7, lon2Deg = 139.7;
-
-const phi1 = degreesToRadians(lat1Deg);
-const lambda1 = degreesToRadians(lon1Deg);
-const phi2 = degreesToRadians(lat2Deg);
-const lambda2 = degreesToRadians(lon2Deg);
-
-const [phiMinRad, phiMaxRad, lambdaMinRad, lambdaMaxRad] = getGreatCircleArcBBox(phi1, lambda1, phi2, lambda2);
-
-const phiMinDeg = radiansToDegrees(phiMinRad);
-const phiMaxDeg = radiansToDegrees(phiMaxRad);
-const lambdaMinDeg = radiansToDegrees(lambdaMinRad);
-const lambdaMaxDeg = radiansToDegrees(lambdaMaxRad);
-
-console.log("Input Points (Radians):");
-console.log(`  P1: Latitude=${lat1Deg}, Longitude=${lon1Deg}`);
-console.log(`  P2: Latitude=${lat2Deg}, Longitude=${lon2Deg}`);
-console.log(`  P1: Latitude=${phi1.toFixed(4)}, Longitude=${lambda1.toFixed(4)}`);
-console.log(`  P2: Latitude=${phi2.toFixed(4)}, Longitude=${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): ${phiMaxRad.toFixed(4)}`);
-console.log(`  Minimum Longitude (lambda_min): ${lambdaMinRad.toFixed(4)}`);
-console.log(`  Maximum Longitude (lambda_max): ${lambdaMaxRad.toFixed(4)}`);
-console.log("-".repeat(20));
-console.log("Bounding Box (Degrees):");
-console.log(`  Minimum Latitude: ${phiMinDeg.toFixed(2)}°`);
-console.log(`  Maximum Latitude: ${phiMaxDeg.toFixed(2)}°`);
-console.log(`  Minimum Longitude: ${lambdaMinDeg.toFixed(2)}°`);
-console.log(`  Maximum Longitude: ${lambdaMaxDeg.toFixed(2)}°`);
-
-// --- Antimeridian Crossing Test ---
-console.log("\n" + "=".repeat(30));
-console.log("Antimeridian Crossing Test");
-const lat1DegAm = -18, lon1DegAm = 178;
-const lat2DegAm = -14, lon2DegAm = -172;
-
-const phi1Am = degreesToRadians(lat1DegAm);
-const lambda1Am = degreesToRadians(lon1DegAm);
-const phi2Am = degreesToRadians(lat2DegAm);
-const lambda2Am = degreesToRadians(lon2DegAm);
-
-const [phiMinRadAm, phiMaxRadAm, lambdaMinRadAm, lambdaMaxRadAm] = getGreatCircleArcBBox(phi1Am, lambda1Am, phi2Am, lambda2Am);
-
-const phiMinDegAm = radiansToDegrees(phiMinRadAm);
-const phiMaxDegAm = radiansToDegrees(phiMaxRadAm);
-const lambdaMinDegAm = radiansToDegrees(lambdaMinRadAm);
-const lambdaMaxDegAm = radiansToDegrees(lambdaMaxRadAm);
-
-console.log(`Input Points (Degrees): P1=(${lat1DegAm}, ${lon1DegAm}), P2=(${lat2DegAm}, ${lon2DegAm})`);
-console.log("Bounding Box (Radians):");
-console.log(`  phi_min=${phiMinRadAm.toFixed(4)}, phi_max=${phiMaxRadAm.toFixed(4)}`);
-console.log(`  lambda_min=${lambdaMinRadAm.toFixed(4)}, lambda_max=${lambdaMaxRadAm.toFixed(4)}`);
-console.log("Bounding Box (Degrees):");
-console.log(`  Min Latitude: ${phiMinDegAm.toFixed(2)}°`);
-console.log(`  Max Latitude: ${phiMaxDegAm.toFixed(2)}°`);
-console.log(`  Min Longitude: ${lambdaMinDegAm.toFixed(2)}° (178° expected)`);
-console.log(`  Max Longitude: ${lambdaMaxDegAm.toFixed(2)}° (188° expected, which is -172° + 360°)`);
-
-// --- Polar Crossing Test ---
-console.log("\n" + "=".repeat(30));
-console.log("Polar Crossing Test");
-const lat1DegP = 80, lon1DegP = 20;
-const lat2DegP = 80, lon2DegP = -100;
-
-const phi1P = degreesToRadians(lat1DegP);
-const lambda1P = degreesToRadians(lon1DegP);
-const phi2P = degreesToRadians(lat2DegP);
-const lambda2P = degreesToRadians(lon2DegP);
-
-const [phiMinRadP, phiMaxRadP, lambdaMinRadP, lambdaMaxRadP] = getGreatCircleArcBBox(phi1P, lambda1P, phi2P, lambda2P);
-
-const phiMinDegP = radiansToDegrees(phiMinRadP);
-const phiMaxDegP = radiansToDegrees(phiMaxRadP);
-const lambdaMinDegP = radiansToDegrees(lambdaMinRadP);
-const lambdaMaxDegP = radiansToDegrees(lambdaMaxRadP);
-
-console.log(`Input Points (Degrees): P1=(${lat1DegP}, ${lon1DegP}), P2=(${lat2DegP}, ${lon2DegP})`);
-console.log("Bounding Box (Radians):");
-console.log(`  phi_min=${phiMinRadP.toFixed(4)}, phi_max=${phiMaxRadP.toFixed(4)}`);
-console.log(`  lambda_min=${lambdaMinRadP.toFixed(4)}, lambda_max=${lambdaMaxRadP.toFixed(4)}`);
-console.log("Bounding Box (Degrees):");
-console.log(`  Min Latitude: ${phiMinDegP.toFixed(2)}°`);
-console.log(`  Max Latitude: ${phiMaxDegP.toFixed(2)}° (Should be close to North Pole > 80°)`);
-console.log(`  Min Longitude: ${lambdaMinDegP.toFixed(2)}°`);
-console.log(`  Max Longitude: ${lambdaMaxDegP.toFixed(2)}°`);
-
-
-
-// --- line points intersection with bbox ---
-

package/Math/constants.ts

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

package/Math/frustum/camera.ts

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

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

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

@@ -1,137 +0,0 @@
-// 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 };