@navaramap/three-api 0.0.0

package/LICENSE

@@ -0,0 +1,8 @@
+Copyright (c) 2026 MapLibre contributors
+
+This project is dual-licensed under either of
+
+- Apache License, Version 2.0 (see LICENSE-APACHE)
+- MIT license (see LICENSE-MIT)
+
+at your option.

package/README.md

@@ -0,0 +1,3 @@
+# @navaramap/three-api
+
+This is a api module for Navara for Web platform.

package/dist/ellipsoidGeodesic.d.ts

@@ -0,0 +1,54 @@
+import { LatLngHeight } from '@navaramap/core';
+/**
+ * Wrapper class for geodesic calculations on an ellipsoid surface.
+ * Precomputes common variables for optimization when instantiated.
+ *
+ * @example
+ * ```typescript
+ * const geodesic = new EllipsoidGeodesic(
+ *   { lat: 0.5, lng: 2.0, height: 0 },
+ *   { lat: 0.6, lng: 2.1, height: 0 }
+ * );
+ *
+ * console.log(geodesic.distance);
+ * const points = geodesic.interpolatePoints(1000);
+ * const midpoint = geodesic.interpolateDistance(geodesic.distance / 2);
+ *
+ * geodesic.dispose(); // Free WASM memory when done
+ * ```
+ */
+export declare class EllipsoidGeodesic {
+    private _raw;
+    /**
+     * Create a new geodesic between two points on the ellipsoid.
+     * @param start - Start point in geodetic coordinates (lat/lng in radians)
+     * @param end - End point in geodetic coordinates (lat/lng in radians)
+     */
+    constructor(start: LatLngHeight, end: LatLngHeight);
+    /** Distance in meters between start and end points */
+    get distance(): number;
+    /** Heading at the start point in radians */
+    get startHeading(): number;
+    /** Heading at the end point in radians */
+    get endHeading(): number;
+    /** Start point in geodetic coordinates */
+    get start(): LatLngHeight;
+    /** End point in geodetic coordinates */
+    get end(): LatLngHeight;
+    /**
+     * Interpolate points along the geodesic path.
+     * @param granularity - Distance between interpolated points in meters (optional)
+     * @returns Array of interpolated points in geodetic coordinates
+     */
+    interpolatePoints(granularity?: number): LatLngHeight[];
+    /**
+     * Interpolate a point at a specific distance along the geodesic path.
+     * @param distance - Distance from start point in meters
+     * @returns Interpolated point in geodetic coordinates
+     */
+    interpolateDistance(distance: number): LatLngHeight;
+    /**
+     * Free WASM memory. Call this when the geodesic is no longer needed.
+     */
+    dispose(): void;
+}

package/dist/index.d.ts

@@ -0,0 +1,106 @@
+import { LatLngHeight, Window as WindowObject } from '@navaramap/core';
+import { Vector3, Vector2, Matrix4, PerspectiveCamera } from 'three';
+export type { LatLngHeight, LatLng } from '@navaramap/core';
+export type { Window, Transform, CameraFrustum, Plane, Ray, Vec2, Vec3, } from '@navaramap/core';
+export * from './intersection';
+export * from './rte';
+export * from './ellipsoidGeodesic';
+/**
+ * Initializes the Navara API WASM module. Must be called before using other API functions.
+ */
+export declare function initNavaraApi(): Promise<void>;
+/**
+ * Converts geodetic coordinates (longitude, latitude, height) to a Cartesian Vector3 in ECEF coordinates.
+ * @param lle - Geodetic coordinates (lng in radians, lat in radians, height in meters)
+ * @returns Cartesian Vector3 in Earth-Centered Earth-Fixed (ECEF) coordinates
+ */
+export declare function geodeticToVector3(lle: LatLngHeight): Vector3;
+/**
+ * Converts a Cartesian Vector3 in ECEF coordinates to geodetic coordinates.
+ * @param xyz - Cartesian Vector3 in Earth-Centered Earth-Fixed (ECEF) coordinates
+ * @returns Geodetic coordinates (lng in radians, lat in radians, height in meters)
+ */
+export declare function vector3ToGeodetic(xyz: Vector3): LatLngHeight;
+/**
+ * Converts an angle from degrees to radians.
+ * @param degree - Angle in degrees
+ * @returns Angle in radians
+ */
+export declare function degreeToRadian(degree: number): number;
+/**
+ * Converts an angle from radians to degrees.
+ * @param radian - Angle in radians
+ * @returns Angle in degrees
+ */
+export declare function radianToDegree(radian: number): number;
+/**
+ * Converts screen coordinates to world coordinates by raycasting against the WGS84 ellipsoid.
+ * @param window - Window configuration with width, height, and pixelRatio
+ * @param camera - Three.js PerspectiveCamera
+ * @param vec2 - Screen coordinates in CSS pixels (same as MouseEvent clientX/clientY)
+ * @returns World position Vector3 in ECEF coordinates, or undefined if no intersection with ellipsoid
+ */
+export declare function convertScreenToWorld(windowObject: WindowObject, camera: PerspectiveCamera, vec2: Vector2): Vector3 | undefined;
+/**
+ * Computes the surface normal vector at a geodetic position on the WGS84 ellipsoid.
+ * @param lle - Geodetic coordinates (lng in radians, lat in radians, height in meters)
+ * @returns Unit normal vector pointing outward from the ellipsoid surface
+ */
+export declare function geodeticSurfaceNormal(lle: LatLngHeight): Vector3;
+/**
+ * Creates a local East-North-Up (ENU) reference frame transformation matrix at a position.
+ * @param origin - Origin position in ECEF coordinates
+ * @returns 4x4 transformation matrix from ENU to ECEF
+ */
+export declare function eastNorthUpToFixedFrame(origin: Vector3): Matrix4;
+/**
+ * Creates a local North-East-Down (NED) reference frame transformation matrix at a position.
+ * @param origin - Origin position in ECEF coordinates
+ * @returns 4x4 transformation matrix from NED to ECEF
+ */
+export declare function northEastDownToFixedFrame(origin: Vector3): Matrix4;
+/**
+ * Creates a local North-Up-East (NUE) reference frame transformation matrix at a position.
+ * @param origin - Origin position in ECEF coordinates
+ * @returns 4x4 transformation matrix from NUE to ECEF
+ */
+export declare function northUpEastToFixedFrame(origin: Vector3): Matrix4;
+/**
+ * Creates a local North-West-Up (NWU) reference frame transformation matrix at a position.
+ * @param origin - Origin position in ECEF coordinates
+ * @returns 4x4 transformation matrix from NWU to ECEF
+ */
+export declare function northWestUpToFixedFrame(origin: Vector3): Matrix4;
+/**
+ * Converts world coordinates to screen coordinates.
+ * @param window - Window configuration with width, height, and pixelRatio
+ * @param camera - Three.js PerspectiveCamera
+ * @param worldPos - World position Vector3 in ECEF coordinates
+ * @returns Screen coordinates in CSS pixels, or undefined if behind camera
+ */
+export declare function convertWorldToScreen(windowObject: WindowObject, camera: PerspectiveCamera, worldPos: Vector3): Vector2 | undefined;
+/**
+ * Returns the WGS84 ellipsoid semi-major axis (equatorial radius) in meters.
+ * @returns Semi-major axis (approximately 6,378,137 meters)
+ */
+export declare function getWGS84SemiMajorAxis(): number;
+/**
+ * Returns the WGS84 ellipsoid semi-minor axis (polar radius) in meters.
+ * @returns Semi-minor axis (approximately 6,356,752 meters)
+ */
+export declare function getWGS84SemiMinorAxis(): number;
+/**
+ * Returns the WGS84 ellipsoid first eccentricity squared.
+ * @returns Eccentricity squared value
+ */
+export declare function getWGS84EccentricitySquared(): number;
+/**
+ * Returns the WGS84 ellipsoid flattening ratio.
+ * @returns Flattening value (approximately 1/298.257)
+ */
+export declare function getWGS84Flattening(): number;
+/**
+ * Returns the WGS84 ellipsoid first eccentricity.
+ * @returns Eccentricity value
+ */
+export declare function getWGS84Eccentricity(): number;

package/dist/index.js

@@ -0,0 +1,180 @@
+import e, { CameraFrustum as t, EllipsoidGeodesic as n, LLE as r, Ray as i, Transform as a, Vec2 as o, Vec3 as s, Window as c, angleToDegree as l, angleToRadian as u, eastNorthUpToFixedFrame as ee, encodePosition as d, geodeticSurfaceNormal as f, geodeticToXyz as p, getHeightFromEllipsoid as m, getPickRay as h, getPlaneFromPointNormal as g, getRayPlaneIntersection as _, getWGS84Eccentricity as v, getWGS84EccentricitySquared as y, getWGS84Flattening as b, getWGS84SemiMajorAxis as x, getWGS84SemiMinorAxis as S, northEastDownToFixedFrame as C, northUpEastToFixedFrame as w, northWestUpToFixedFrame as T, screenToWorld as E, worldToScreen as D, xyzToGeodetic as O } from "@navaramap/engine-api";
+import { Matrix4 as k, Plane as A, Ray as j, Vector2 as M, Vector3 as N } from "three";
+//#region src/intersection.ts
+function P(e, t) {
+	let n = g(new s(e.x, e.y, e.z), new s(t.x, t.y, t.z)), r = new A(new N(n.normal.x, n.normal.y, n.normal.z), -n.distance);
+	return n.free(), r;
+}
+function F(e, n, r) {
+	let i = new c(e.width, e.height, e.pixelRatio);
+	i.width *= i.pixelRatio, i.height *= i.pixelRatio;
+	let s = h(i, new a(n.position.x, n.position.y, n.position.z, n.quaternion.x, n.quaternion.y, n.quaternion.z, n.quaternion.w, n.scale.x, n.scale.y, n.scale.z), new t(n.near, n.far, u(n.fov), n.aspect), new o(r.x, r.y)), l = new j(new N(s.origin.x, s.origin.y, s.origin.z), new N(s.direction.x, s.direction.y, s.direction.z));
+	return s.free(), l;
+}
+function I(e, t) {
+	let n = _(new i(new s(e.origin.x, e.origin.y, e.origin.z), new s(e.direction.x, e.direction.y, e.direction.z)), g(new s(t.normal.x * -t.constant, t.normal.y * -t.constant, t.normal.z * -t.constant), new s(t.normal.x, t.normal.y, t.normal.z)));
+	if (n) {
+		let e = new N(n.x, n.y, n.z);
+		return n.free(), e;
+	}
+}
+function te(e) {
+	return m(new s(e.x, e.y, e.z));
+}
+//#endregion
+//#region src/rte.ts
+var L = Object.freeze({ value: 1 });
+function R(e, t = new N(), n = new N()) {
+	let r = d(e.x, e.y, e.z);
+	return t.set(r.high.x, r.high.y, r.high.z), n.set(r.low.x, r.low.y, r.low.z), r.free(), {
+		high: t,
+		low: n
+	};
+}
+var z = (e, t, n = new k()) => {
+	n.multiplyMatrices(t, e);
+	let r = n.elements;
+	return r[12] = 0, r[13] = 0, r[14] = 0, n;
+};
+function B(e, t, n = new N(), r = new k()) {
+	r.multiplyMatrices(e, t), n.setFromMatrixPosition(r);
+	let i = r.elements;
+	return i[12] = 0, i[13] = 0, i[14] = 0, {
+		position: n,
+		rotationScale: r
+	};
+}
+var V = new k(), H = new N(), U = (e, t) => {
+	V.copy(t).invert(), H.copy(e).applyMatrix4(V);
+	let n = d(H.x, H.y, H.z), r = n.high, i = n.low, a = {
+		high: new N(r.x, r.y, r.z),
+		low: new N(i.x, i.y, i.z)
+	};
+	return n.free(), a;
+}, W = class {
+	_raw;
+	constructor(e, t) {
+		this._raw = new n(new r(e.lat, e.lng, e.height), new r(t.lat, t.lng, t.height));
+	}
+	get distance() {
+		return this._raw.distance;
+	}
+	get startHeading() {
+		return this._raw.start_heading;
+	}
+	get endHeading() {
+		return this._raw.end_heading;
+	}
+	get start() {
+		let e = this._raw.start;
+		return {
+			lat: e.lat,
+			lng: e.lng,
+			height: e.height
+		};
+	}
+	get end() {
+		let e = this._raw.end;
+		return {
+			lat: e.lat,
+			lng: e.lng,
+			height: e.height
+		};
+	}
+	interpolatePoints(e) {
+		let t = this._raw.interpolateGeodeticPoints(e ?? null), n = [];
+		for (let e of t) n.push({
+			lat: e.lat,
+			lng: e.lng,
+			height: e.height
+		}), e.free();
+		return n;
+	}
+	interpolateDistance(e) {
+		let t = this._raw.interpolateDistance(e), n = {
+			lat: t.lat,
+			lng: t.lng,
+			height: t.height
+		};
+		return t.free(), n;
+	}
+	dispose() {
+		this._raw.free();
+	}
+};
+//#endregion
+//#region src/index.ts
+async function G() {
+	await e();
+}
+function K(e) {
+	let t = p(new r(e.lat, e.lng, e.height)), n = new N(t.x, t.y, t.z);
+	return t.free(), n;
+}
+function q(e) {
+	let t = O(new s(e.x, e.y, e.z)), n = {
+		lat: t.lat,
+		lng: t.lng,
+		height: t.height
+	};
+	return t.free(), n;
+}
+function J(e) {
+	return u(e);
+}
+function Y(e) {
+	return l(e);
+}
+function X(e, n, r) {
+	let i = new c(e.width, e.height, e.pixelRatio);
+	i.width *= i.pixelRatio, i.height *= i.pixelRatio;
+	let s = E(i, new a(n.position.x, n.position.y, n.position.z, n.quaternion.x, n.quaternion.y, n.quaternion.z, n.quaternion.w, n.scale.x, n.scale.y, n.scale.z), new t(n.near, n.far, u(n.fov), n.aspect), new o(r.x, r.y));
+	if (!s) return;
+	let l = new N(s.x, s.y, s.z);
+	return s.free(), l;
+}
+function Z(e) {
+	let t = f(new r(e.lat, e.lng, e.height)), n = new N(t.x, t.y, t.z);
+	return t.free(), n;
+}
+function Q(e) {
+	let t = ee(new s(e.x, e.y, e.z));
+	return new k().fromArray(t);
+}
+function ne(e) {
+	let t = C(new s(e.x, e.y, e.z));
+	return new k().fromArray(t);
+}
+function re(e) {
+	let t = w(new s(e.x, e.y, e.z));
+	return new k().fromArray(t);
+}
+function ie(e) {
+	let t = T(new s(e.x, e.y, e.z));
+	return new k().fromArray(t);
+}
+function ae(e, n, r) {
+	let i = new c(e.width, e.height, e.pixelRatio);
+	i.width *= i.pixelRatio, i.height *= i.pixelRatio;
+	let o = D(i, new a(n.position.x, n.position.y, n.position.z, n.quaternion.x, n.quaternion.y, n.quaternion.z, n.quaternion.w, n.scale.x, n.scale.y, n.scale.z), new t(n.near, n.far, u(n.fov), n.aspect), new s(r.x, r.y, r.z));
+	if (!o) return;
+	let l = new M(o.x, o.y);
+	return o.free(), l;
+}
+function oe() {
+	return x();
+}
+function $() {
+	return S();
+}
+function se() {
+	return y();
+}
+function ce() {
+	return b();
+}
+function le() {
+	return v();
+}
+//#endregion
+export { W as EllipsoidGeodesic, L as RTE_ONE_UNIFORM, U as calcCameraPosition, z as calcModelMatrixRTE, B as composeWorldMatrixForRTE, X as convertScreenToWorld, ae as convertWorldToScreen, J as degreeToRadian, Q as eastNorthUpToFixedFrame, R as encodePositionRTE, Z as geodeticSurfaceNormal, K as geodeticToVector3, te as getHeightFromEllipsoid, F as getPickRay, P as getPlaneFromPointNormal, I as getRayPlaneIntersection, le as getWGS84Eccentricity, se as getWGS84EccentricitySquared, ce as getWGS84Flattening, oe as getWGS84SemiMajorAxis, $ as getWGS84SemiMinorAxis, G as initNavaraApi, ne as northEastDownToFixedFrame, re as northUpEastToFixedFrame, ie as northWestUpToFixedFrame, Y as radianToDegree, q as vector3ToGeodetic };

package/dist/index.umd.cjs

@@ -0,0 +1 @@
+(function(e,t){typeof exports==`object`&&typeof module<`u`?t(exports,require("@navaramap/engine-api"),require("three")):typeof define==`function`&&define.amd?define([`exports`,`@navaramap/engine-api`,`three`],t):(e=typeof globalThis<`u`?globalThis:e||self,t(e.NavaraThreeApi={},e._navaramap_engine_api,e.three))})(this,function(e,t,n){Object.defineProperty(e,Symbol.toStringTag,{value:`Module`});var r=Object.create,i=Object.defineProperty,a=Object.getOwnPropertyDescriptor,o=Object.getOwnPropertyNames,s=Object.getPrototypeOf,c=Object.prototype.hasOwnProperty,l=(e,t,n,r)=>{if(t&&typeof t==`object`||typeof t==`function`)for(var s=o(t),l=0,u=s.length,d;l<u;l++)d=s[l],!c.call(e,d)&&d!==n&&i(e,d,{get:(e=>t[e]).bind(null,d),enumerable:!(r=a(t,d))||r.enumerable});return e};t=((e,t,n)=>(n=e==null?{}:r(s(e)),l(t||!e||!e.__esModule?i(n,`default`,{value:e,enumerable:!0}):n,e)))(t,1);function u(e,r){let i=(0,t.getPlaneFromPointNormal)(new t.Vec3(e.x,e.y,e.z),new t.Vec3(r.x,r.y,r.z)),a=new n.Plane(new n.Vector3(i.normal.x,i.normal.y,i.normal.z),-i.distance);return i.free(),a}function d(e,r,i){let a=new t.Window(e.width,e.height,e.pixelRatio);a.width*=a.pixelRatio,a.height*=a.pixelRatio;let o=(0,t.getPickRay)(a,new t.Transform(r.position.x,r.position.y,r.position.z,r.quaternion.x,r.quaternion.y,r.quaternion.z,r.quaternion.w,r.scale.x,r.scale.y,r.scale.z),new t.CameraFrustum(r.near,r.far,(0,t.angleToRadian)(r.fov),r.aspect),new t.Vec2(i.x,i.y)),s=new n.Ray(new n.Vector3(o.origin.x,o.origin.y,o.origin.z),new n.Vector3(o.direction.x,o.direction.y,o.direction.z));return o.free(),s}function f(e,r){let i=(0,t.getRayPlaneIntersection)(new t.Ray(new t.Vec3(e.origin.x,e.origin.y,e.origin.z),new t.Vec3(e.direction.x,e.direction.y,e.direction.z)),(0,t.getPlaneFromPointNormal)(new t.Vec3(r.normal.x*-r.constant,r.normal.y*-r.constant,r.normal.z*-r.constant),new t.Vec3(r.normal.x,r.normal.y,r.normal.z)));if(i){let e=new n.Vector3(i.x,i.y,i.z);return i.free(),e}}function p(e){return(0,t.getHeightFromEllipsoid)(new t.Vec3(e.x,e.y,e.z))}var m=Object.freeze({value:1});function h(e,r=new n.Vector3,i=new n.Vector3){let a=(0,t.encodePosition)(e.x,e.y,e.z);return r.set(a.high.x,a.high.y,a.high.z),i.set(a.low.x,a.low.y,a.low.z),a.free(),{high:r,low:i}}var g=(e,t,r=new n.Matrix4)=>{r.multiplyMatrices(t,e);let i=r.elements;return i[12]=0,i[13]=0,i[14]=0,r};function _(e,t,r=new n.Vector3,i=new n.Matrix4){i.multiplyMatrices(e,t),r.setFromMatrixPosition(i);let a=i.elements;return a[12]=0,a[13]=0,a[14]=0,{position:r,rotationScale:i}}var v=new n.Matrix4,y=new n.Vector3,b=(e,r)=>{v.copy(r).invert(),y.copy(e).applyMatrix4(v);let i=(0,t.encodePosition)(y.x,y.y,y.z),a=i.high,o=i.low,s={high:new n.Vector3(a.x,a.y,a.z),low:new n.Vector3(o.x,o.y,o.z)};return i.free(),s},x=class{_raw;constructor(e,n){this._raw=new t.EllipsoidGeodesic(new t.LLE(e.lat,e.lng,e.height),new t.LLE(n.lat,n.lng,n.height))}get distance(){return this._raw.distance}get startHeading(){return this._raw.start_heading}get endHeading(){return this._raw.end_heading}get start(){let e=this._raw.start;return{lat:e.lat,lng:e.lng,height:e.height}}get end(){let e=this._raw.end;return{lat:e.lat,lng:e.lng,height:e.height}}interpolatePoints(e){let t=this._raw.interpolateGeodeticPoints(e??null),n=[];for(let e of t)n.push({lat:e.lat,lng:e.lng,height:e.height}),e.free();return n}interpolateDistance(e){let t=this._raw.interpolateDistance(e),n={lat:t.lat,lng:t.lng,height:t.height};return t.free(),n}dispose(){this._raw.free()}};async function S(){await(0,t.default)()}function C(e){let r=(0,t.geodeticToXyz)(new t.LLE(e.lat,e.lng,e.height)),i=new n.Vector3(r.x,r.y,r.z);return r.free(),i}function w(e){let n=(0,t.xyzToGeodetic)(new t.Vec3(e.x,e.y,e.z)),r={lat:n.lat,lng:n.lng,height:n.height};return n.free(),r}function T(e){return(0,t.angleToRadian)(e)}function E(e){return(0,t.angleToDegree)(e)}function D(e,r,i){let a=new t.Window(e.width,e.height,e.pixelRatio);a.width*=a.pixelRatio,a.height*=a.pixelRatio;let o=(0,t.screenToWorld)(a,new t.Transform(r.position.x,r.position.y,r.position.z,r.quaternion.x,r.quaternion.y,r.quaternion.z,r.quaternion.w,r.scale.x,r.scale.y,r.scale.z),new t.CameraFrustum(r.near,r.far,(0,t.angleToRadian)(r.fov),r.aspect),new t.Vec2(i.x,i.y));if(!o)return;let s=new n.Vector3(o.x,o.y,o.z);return o.free(),s}function O(e){let r=(0,t.geodeticSurfaceNormal)(new t.LLE(e.lat,e.lng,e.height)),i=new n.Vector3(r.x,r.y,r.z);return r.free(),i}function k(e){let r=(0,t.eastNorthUpToFixedFrame)(new t.Vec3(e.x,e.y,e.z));return new n.Matrix4().fromArray(r)}function A(e){let r=(0,t.northEastDownToFixedFrame)(new t.Vec3(e.x,e.y,e.z));return new n.Matrix4().fromArray(r)}function j(e){let r=(0,t.northUpEastToFixedFrame)(new t.Vec3(e.x,e.y,e.z));return new n.Matrix4().fromArray(r)}function M(e){let r=(0,t.northWestUpToFixedFrame)(new t.Vec3(e.x,e.y,e.z));return new n.Matrix4().fromArray(r)}function N(e,r,i){let a=new t.Window(e.width,e.height,e.pixelRatio);a.width*=a.pixelRatio,a.height*=a.pixelRatio;let o=(0,t.worldToScreen)(a,new t.Transform(r.position.x,r.position.y,r.position.z,r.quaternion.x,r.quaternion.y,r.quaternion.z,r.quaternion.w,r.scale.x,r.scale.y,r.scale.z),new t.CameraFrustum(r.near,r.far,(0,t.angleToRadian)(r.fov),r.aspect),new t.Vec3(i.x,i.y,i.z));if(!o)return;let s=new n.Vector2(o.x,o.y);return o.free(),s}function P(){return(0,t.getWGS84SemiMajorAxis)()}function F(){return(0,t.getWGS84SemiMinorAxis)()}function I(){return(0,t.getWGS84EccentricitySquared)()}function L(){return(0,t.getWGS84Flattening)()}function R(){return(0,t.getWGS84Eccentricity)()}e.EllipsoidGeodesic=x,e.RTE_ONE_UNIFORM=m,e.calcCameraPosition=b,e.calcModelMatrixRTE=g,e.composeWorldMatrixForRTE=_,e.convertScreenToWorld=D,e.convertWorldToScreen=N,e.degreeToRadian=T,e.eastNorthUpToFixedFrame=k,e.encodePositionRTE=h,e.geodeticSurfaceNormal=O,e.geodeticToVector3=C,e.getHeightFromEllipsoid=p,e.getPickRay=d,e.getPlaneFromPointNormal=u,e.getRayPlaneIntersection=f,e.getWGS84Eccentricity=R,e.getWGS84EccentricitySquared=I,e.getWGS84Flattening=L,e.getWGS84SemiMajorAxis=P,e.getWGS84SemiMinorAxis=F,e.initNavaraApi=S,e.northEastDownToFixedFrame=A,e.northUpEastToFixedFrame=j,e.northWestUpToFixedFrame=M,e.radianToDegree=E,e.vector3ToGeodetic=w});

package/dist/intersection.d.ts

@@ -0,0 +1,30 @@
+import { Window as WindowObject } from '@navaramap/core';
+import { Vector3, Vector2, PerspectiveCamera, Ray as ThreeRay, Plane as ThreePlane } from 'three';
+/**
+ * Creates a plane from a point and a normal vector.
+ * @param point - A point on the plane
+ * @param normal - The normal vector of the plane
+ * @returns A Plane object defined by the point and normal
+ */
+export declare function getPlaneFromPointNormal(point: Vector3, normal: Vector3): ThreePlane;
+/**
+ * Creates a picking ray from screen coordinates for raycasting.
+ * @param window - Window configuration with width, height, and pixelRatio
+ * @param camera - Three.js PerspectiveCamera
+ * @param vec2 - Screen coordinates in CSS pixels (same as MouseEvent clientX/clientY)
+ * @returns A Ray starting from the camera through the screen point
+ */
+export declare function getPickRay(windowObject: WindowObject, camera: PerspectiveCamera, vec2: Vector2): ThreeRay;
+/**
+ * Computes the intersection point between a ray and a plane.
+ * @param ray - The ray to test
+ * @param plane - The plane to intersect with
+ * @returns Intersection point Vector3 or undefined if no intersection
+ */
+export declare function getRayPlaneIntersection(ray: ThreeRay, plane: ThreePlane): Vector3 | undefined;
+/**
+ * Computes the height of a point above the WGS84 ellipsoid surface.
+ * @param point - Position in ECEF coordinates
+ * @returns Height above the ellipsoid in meters
+ */
+export declare function getHeightFromEllipsoid(point: Vector3): number;

package/dist/rte.d.ts

@@ -0,0 +1,60 @@
+import { Matrix4, Vector3 } from 'three';
+/**
+ * Shared `u_rteOne` uniform for RTE vertex shaders. Always 1.0.
+ *
+ * Multiplying the high-order difference by a uniform the shader compiler
+ * cannot constant-fold blocks fast-math reassociation of
+ * `(high - camHigh) + (low - camLow)` into `(high + low) - (camHigh + camLow)`,
+ * which would collapse the math to absolute-ECEF f32 precision and make
+ * geometry freeze/snap in ~0.25-0.5 m steps as the camera moves
+ * (observed on ANGLE Metal). One frozen object is shared by every material.
+ */
+export declare const RTE_ONE_UNIFORM: {
+    readonly value: number;
+};
+/**
+ * Encodes a position into high and low precision Vector3 components for RTE (Relative-To-Eye) rendering.
+ * This enables GPU double precision emulation by splitting a position into two float components.
+ * @param original - Position to encode
+ * @param resultHigh - Vector3 to store the high precision component (reused to avoid GC)
+ * @param resultLow - Vector3 to store the low precision component (reused to avoid GC)
+ */
+export declare function encodePositionRTE(original: Vector3, resultHigh?: Vector3, resultLow?: Vector3): {
+    high: Vector3;
+    low: Vector3;
+};
+/**
+ * Calculates the model-view matrix for Relative-To-Eye (RTE) rendering, which improves precision for distant objects.
+ * @param objectMatrixWorld - The object's world transformation matrix
+ * @param matrixWorldInverse - The camera's inverse world matrix
+ * @param result - Optional matrix to store the result (creates new if omitted)
+ * @returns Model-view matrix with translation zeroed for RTE rendering
+ */
+export declare const calcModelMatrixRTE: (objectMatrixWorld: Matrix4, matrixWorldInverse: Matrix4, result?: Matrix4) => Matrix4;
+/**
+ * Composes a frame matrix with a local transform, then splits the result into
+ * a translation Vector3 and a rotation/scale-only Matrix4 for RTE rendering.
+ *
+ * The translation is intended to be encoded as high/low RTE uniforms for GPU
+ * precision, while the rotation/scale matrix is assigned to the mesh's
+ * matrixWorld so it becomes the shader's modelMatrix uniform.
+ *
+ * @param frameMatrix - The frame transformation matrix (e.g. NUE-to-ECEF)
+ * @param localMatrix - The local T*R*S transform to compose within the frame
+ * @param resultPosition - Vector3 to store the extracted translation (reused to avoid GC)
+ * @param resultRotationScale - Matrix4 to store the translation-zeroed matrix (reused to avoid GC)
+ */
+export declare function composeWorldMatrixForRTE(frameMatrix: Matrix4, localMatrix: Matrix4, resultPosition?: Vector3, resultRotationScale?: Matrix4): {
+    position: Vector3;
+    rotationScale: Matrix4;
+};
+/**
+ * Calculates the camera position relative to an object with high/low precision encoding for RTE rendering.
+ * @param cameraPosition - The camera's world position
+ * @param modelMatrixWorld - The object's world transformation matrix
+ * @returns Object with high and low precision Vector3 components for GPU double precision emulation
+ */
+export declare const calcCameraPosition: (cameraPosition: Vector3, modelMatrixWorld: Matrix4) => {
+    high: Vector3;
+    low: Vector3;
+};

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@navaramap/three-api",
+  "type": "module",
+  "version": "0.0.0",
+  "main": "dist/index.umd.cjs",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "src",
+    "dist"
+  ],
+  "license": "MIT OR Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/reearth/navara.git",
+    "directory": "web/navara_three_api"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "peerDependencies": {
+    "three": ">=0.183.0"
+  },
+  "dependencies": {
+    "@navaramap/core": "0.0.0",
+    "@navaramap/engine-api": "0.0.0"
+  },
+  "devDependencies": {
+    "@types/three": "0.185.1",
+    "three": "0.185.1"
+  },
+  "scripts": {
+    "type-check": "tsc && tsc -p tsconfig.node.json",
+    "build": "pnpm type-check && vite build --watch=false",
+    "build:dev": "vite build --mode development",
+    "build:dev:watch": "pnpm build:dev --watch",
+    "test": "vitest --passWithNoTests --watch=false",
+    "lint": "eslint . --fix",
+    "lint:check": "eslint .",
+    "format": "prettier --write --ignore-path ../../.gitignore --ignore-path ../../.prettierignore .",
+    "format:check": "prettier --check --ignore-path ../../.gitignore --ignore-path ../../.prettierignore ."
+  }
+}

package/src/ellipsoidGeodesic.ts

@@ -0,0 +1,113 @@
+import type { LatLngHeight } from "@navaramap/core";
+import {
+  EllipsoidGeodesic as EllipsoidGeodesicImpl,
+  LLE,
+} from "@navaramap/engine-api";
+
+/**
+ * Wrapper class for geodesic calculations on an ellipsoid surface.
+ * Precomputes common variables for optimization when instantiated.
+ *
+ * @example
+ * ```typescript
+ * const geodesic = new EllipsoidGeodesic(
+ *   { lat: 0.5, lng: 2.0, height: 0 },
+ *   { lat: 0.6, lng: 2.1, height: 0 }
+ * );
+ *
+ * console.log(geodesic.distance);
+ * const points = geodesic.interpolatePoints(1000);
+ * const midpoint = geodesic.interpolateDistance(geodesic.distance / 2);
+ *
+ * geodesic.dispose(); // Free WASM memory when done
+ * ```
+ */
+export class EllipsoidGeodesic {
+  private _raw: EllipsoidGeodesicImpl;
+
+  /**
+   * Create a new geodesic between two points on the ellipsoid.
+   * @param start - Start point in geodetic coordinates (lat/lng in radians)
+   * @param end - End point in geodetic coordinates (lat/lng in radians)
+   */
+  constructor(start: LatLngHeight, end: LatLngHeight) {
+    this._raw = new EllipsoidGeodesicImpl(
+      new LLE(start.lat, start.lng, start.height),
+      new LLE(end.lat, end.lng, end.height),
+    );
+  }
+
+  /** Distance in meters between start and end points */
+  get distance(): number {
+    return this._raw.distance;
+  }
+
+  /** Heading at the start point in radians */
+  get startHeading(): number {
+    return this._raw.start_heading;
+  }
+
+  /** Heading at the end point in radians */
+  get endHeading(): number {
+    return this._raw.end_heading;
+  }
+
+  /** Start point in geodetic coordinates */
+  get start(): LatLngHeight {
+    const lle = this._raw.start;
+    return { lat: lle.lat, lng: lle.lng, height: lle.height };
+  }
+
+  /** End point in geodetic coordinates */
+  get end(): LatLngHeight {
+    const lle = this._raw.end;
+    return { lat: lle.lat, lng: lle.lng, height: lle.height };
+  }
+
+  /**
+   * Interpolate points along the geodesic path.
+   * @param granularity - Distance between interpolated points in meters (optional)
+   * @returns Array of interpolated points in geodetic coordinates
+   */
+  interpolatePoints(granularity?: number): LatLngHeight[] {
+    const wasmPoints = this._raw.interpolateGeodeticPoints(granularity ?? null);
+
+    const results: LatLngHeight[] = [];
+    for (const point of wasmPoints) {
+      results.push({
+        lat: point.lat,
+        lng: point.lng,
+        height: point.height,
+      });
+      point.free();
+    }
+
+    return results;
+  }
+
+  /**
+   * Interpolate a point at a specific distance along the geodesic path.
+   * @param distance - Distance from start point in meters
+   * @returns Interpolated point in geodetic coordinates
+   */
+  interpolateDistance(distance: number): LatLngHeight {
+    const wasmPoint = this._raw.interpolateDistance(distance);
+
+    const result: LatLngHeight = {
+      lat: wasmPoint.lat,
+      lng: wasmPoint.lng,
+      height: wasmPoint.height,
+    };
+
+    wasmPoint.free();
+
+    return result;
+  }
+
+  /**
+   * Free WASM memory. Call this when the geodesic is no longer needed.
+   */
+  dispose(): void {
+    this._raw.free();
+  }
+}

package/src/index.ts

@@ -0,0 +1,303 @@
+import type { LatLngHeight, Window as WindowObject } from "@navaramap/core";
+import initApi, {
+  Window,
+  LLE,
+  Vec3,
+  Vec2,
+  Transform,
+  CameraFrustum,
+  geodeticToXyz,
+  xyzToGeodetic,
+  angleToRadian,
+  angleToDegree,
+  screenToWorld,
+  worldToScreen,
+  geodeticSurfaceNormal as nvGeodeticSurfaceNormal,
+  eastNorthUpToFixedFrame as nvEastNorthUpToFixedFrame,
+  northEastDownToFixedFrame as nvNorthEastDownToFixedFrame,
+  northUpEastToFixedFrame as nvNorthUpEastToFixedFrame,
+  northWestUpToFixedFrame as nvNorthWestUpToFixedFrame,
+  getWGS84SemiMajorAxis as nvGetWGS84SemiMajorAxis,
+  getWGS84SemiMinorAxis as nvGetWGS84SemiMinorAxis,
+  getWGS84EccentricitySquared as nvGetWGS84EccentricitySquared,
+  getWGS84Flattening as nvGetWGS84Flattening,
+  getWGS84Eccentricity as nvGetWGS84Eccentricity,
+} from "@navaramap/engine-api";
+import { Vector3, Vector2, Matrix4, PerspectiveCamera } from "three";
+
+export type { LatLngHeight, LatLng } from "@navaramap/core";
+export type {
+  Window,
+  Transform,
+  CameraFrustum,
+  Plane,
+  Ray,
+  Vec2,
+  Vec3,
+} from "@navaramap/core";
+
+export * from "./intersection";
+export * from "./rte";
+export * from "./ellipsoidGeodesic";
+
+/**
+ * Initializes the Navara API WASM module. Must be called before using other API functions.
+ */
+export async function initNavaraApi() {
+  await initApi();
+}
+
+/**
+ * Converts geodetic coordinates (longitude, latitude, height) to a Cartesian Vector3 in ECEF coordinates.
+ * @param lle - Geodetic coordinates (lng in radians, lat in radians, height in meters)
+ * @returns Cartesian Vector3 in Earth-Centered Earth-Fixed (ECEF) coordinates
+ */
+export function geodeticToVector3(lle: LatLngHeight): Vector3 {
+  const pos = geodeticToXyz(new LLE(lle.lat, lle.lng, lle.height));
+  const result = new Vector3(pos.x, pos.y, pos.z);
+  pos.free();
+  return result;
+}
+
+/**
+ * Converts a Cartesian Vector3 in ECEF coordinates to geodetic coordinates.
+ * @param xyz - Cartesian Vector3 in Earth-Centered Earth-Fixed (ECEF) coordinates
+ * @returns Geodetic coordinates (lng in radians, lat in radians, height in meters)
+ */
+export function vector3ToGeodetic(xyz: Vector3): LatLngHeight {
+  const vec3 = new Vec3(xyz.x, xyz.y, xyz.z);
+  const lle = xyzToGeodetic(vec3);
+  const result = { lat: lle.lat, lng: lle.lng, height: lle.height };
+  lle.free();
+  return result;
+}
+
+/**
+ * Converts an angle from degrees to radians.
+ * @param degree - Angle in degrees
+ * @returns Angle in radians
+ */
+export function degreeToRadian(degree: number): number {
+  return angleToRadian(degree);
+}
+
+/**
+ * Converts an angle from radians to degrees.
+ * @param radian - Angle in radians
+ * @returns Angle in degrees
+ */
+export function radianToDegree(radian: number): number {
+  return angleToDegree(radian);
+}
+
+/**
+ * Converts screen coordinates to world coordinates by raycasting against the WGS84 ellipsoid.
+ * @param window - Window configuration with width, height, and pixelRatio
+ * @param camera - Three.js PerspectiveCamera
+ * @param vec2 - Screen coordinates in CSS pixels (same as MouseEvent clientX/clientY)
+ * @returns World position Vector3 in ECEF coordinates, or undefined if no intersection with ellipsoid
+ */
+export function convertScreenToWorld(
+  windowObject: WindowObject,
+  camera: PerspectiveCamera,
+  vec2: Vector2,
+): Vector3 | undefined {
+  const window = new Window(
+    windowObject.width,
+    windowObject.height,
+    windowObject.pixelRatio,
+  );
+  window.width = window.width * window.pixelRatio;
+  window.height = window.height * window.pixelRatio;
+
+  const transform = new Transform(
+    camera.position.x,
+    camera.position.y,
+    camera.position.z,
+    camera.quaternion.x,
+    camera.quaternion.y,
+    camera.quaternion.z,
+    camera.quaternion.w,
+    camera.scale.x,
+    camera.scale.y,
+    camera.scale.z,
+  );
+
+  const frustum = new CameraFrustum(
+    camera.near,
+    camera.far,
+    angleToRadian(camera.fov),
+    camera.aspect,
+  );
+
+  const pos = screenToWorld(
+    window,
+    transform,
+    frustum,
+    new Vec2(vec2.x, vec2.y),
+  );
+
+  if (!pos) {
+    return undefined;
+  }
+  const result = new Vector3(pos.x, pos.y, pos.z);
+  pos.free();
+
+  return result;
+}
+
+/**
+ * Computes the surface normal vector at a geodetic position on the WGS84 ellipsoid.
+ * @param lle - Geodetic coordinates (lng in radians, lat in radians, height in meters)
+ * @returns Unit normal vector pointing outward from the ellipsoid surface
+ */
+export function geodeticSurfaceNormal(lle: LatLngHeight): Vector3 {
+  const pos = nvGeodeticSurfaceNormal(new LLE(lle.lat, lle.lng, lle.height));
+  const result = new Vector3(pos.x, pos.y, pos.z);
+  pos.free();
+  return result;
+}
+
+/**
+ * Creates a local East-North-Up (ENU) reference frame transformation matrix at a position.
+ * @param origin - Origin position in ECEF coordinates
+ * @returns 4x4 transformation matrix from ENU to ECEF
+ */
+export function eastNorthUpToFixedFrame(origin: Vector3): Matrix4 {
+  const vec3 = new Vec3(origin.x, origin.y, origin.z);
+  const arr = nvEastNorthUpToFixedFrame(vec3);
+  const matrix = new Matrix4().fromArray(arr);
+  return matrix;
+}
+
+/**
+ * Creates a local North-East-Down (NED) reference frame transformation matrix at a position.
+ * @param origin - Origin position in ECEF coordinates
+ * @returns 4x4 transformation matrix from NED to ECEF
+ */
+export function northEastDownToFixedFrame(origin: Vector3): Matrix4 {
+  const vec3 = new Vec3(origin.x, origin.y, origin.z);
+  const arr = nvNorthEastDownToFixedFrame(vec3);
+  const matrix = new Matrix4().fromArray(arr);
+  return matrix;
+}
+
+/**
+ * Creates a local North-Up-East (NUE) reference frame transformation matrix at a position.
+ * @param origin - Origin position in ECEF coordinates
+ * @returns 4x4 transformation matrix from NUE to ECEF
+ */
+export function northUpEastToFixedFrame(origin: Vector3): Matrix4 {
+  const vec3 = new Vec3(origin.x, origin.y, origin.z);
+  const arr = nvNorthUpEastToFixedFrame(vec3);
+  const matrix = new Matrix4().fromArray(arr);
+  return matrix;
+}
+
+/**
+ * Creates a local North-West-Up (NWU) reference frame transformation matrix at a position.
+ * @param origin - Origin position in ECEF coordinates
+ * @returns 4x4 transformation matrix from NWU to ECEF
+ */
+export function northWestUpToFixedFrame(origin: Vector3): Matrix4 {
+  const vec3 = new Vec3(origin.x, origin.y, origin.z);
+  const arr = nvNorthWestUpToFixedFrame(vec3);
+  const matrix = new Matrix4().fromArray(arr);
+  return matrix;
+}
+
+/**
+ * Converts world coordinates to screen coordinates.
+ * @param window - Window configuration with width, height, and pixelRatio
+ * @param camera - Three.js PerspectiveCamera
+ * @param worldPos - World position Vector3 in ECEF coordinates
+ * @returns Screen coordinates in CSS pixels, or undefined if behind camera
+ */
+export function convertWorldToScreen(
+  windowObject: WindowObject,
+  camera: PerspectiveCamera,
+  worldPos: Vector3,
+): Vector2 | undefined {
+  const window = new Window(
+    windowObject.width,
+    windowObject.height,
+    windowObject.pixelRatio,
+  );
+  window.width = window.width * window.pixelRatio;
+  window.height = window.height * window.pixelRatio;
+
+  const transform = new Transform(
+    camera.position.x,
+    camera.position.y,
+    camera.position.z,
+    camera.quaternion.x,
+    camera.quaternion.y,
+    camera.quaternion.z,
+    camera.quaternion.w,
+    camera.scale.x,
+    camera.scale.y,
+    camera.scale.z,
+  );
+
+  const frustum = new CameraFrustum(
+    camera.near,
+    camera.far,
+    angleToRadian(camera.fov),
+    camera.aspect,
+  );
+
+  const screenPos = worldToScreen(
+    window,
+    transform,
+    frustum,
+    new Vec3(worldPos.x, worldPos.y, worldPos.z),
+  );
+
+  if (!screenPos) {
+    return undefined;
+  }
+  const result = new Vector2(screenPos.x, screenPos.y);
+  screenPos.free();
+
+  return result;
+}
+
+/**
+ * Returns the WGS84 ellipsoid semi-major axis (equatorial radius) in meters.
+ * @returns Semi-major axis (approximately 6,378,137 meters)
+ */
+export function getWGS84SemiMajorAxis(): number {
+  return nvGetWGS84SemiMajorAxis();
+}
+
+/**
+ * Returns the WGS84 ellipsoid semi-minor axis (polar radius) in meters.
+ * @returns Semi-minor axis (approximately 6,356,752 meters)
+ */
+export function getWGS84SemiMinorAxis(): number {
+  return nvGetWGS84SemiMinorAxis();
+}
+
+/**
+ * Returns the WGS84 ellipsoid first eccentricity squared.
+ * @returns Eccentricity squared value
+ */
+export function getWGS84EccentricitySquared(): number {
+  return nvGetWGS84EccentricitySquared();
+}
+
+/**
+ * Returns the WGS84 ellipsoid flattening ratio.
+ * @returns Flattening value (approximately 1/298.257)
+ */
+export function getWGS84Flattening(): number {
+  return nvGetWGS84Flattening();
+}
+
+/**
+ * Returns the WGS84 ellipsoid first eccentricity.
+ * @returns Eccentricity value
+ */
+export function getWGS84Eccentricity(): number {
+  return nvGetWGS84Eccentricity();
+}

package/src/intersection.ts

@@ -0,0 +1,163 @@
+import type { Window as WindowObject } from "@navaramap/core";
+import {
+  angleToRadian,
+  getPlaneFromPointNormal as nvGetPlaneFromPointNormal,
+  getPickRay as nvGetPickRay,
+  getRayPlaneIntersection as nvGetRayPlaneIntersection,
+  getHeightFromEllipsoid as nvGetHeightFromEllipsoid,
+  Vec3,
+  Vec2,
+  Window,
+  Transform,
+  CameraFrustum,
+  Ray as WASMRay,
+} from "@navaramap/engine-api";
+import {
+  Vector3,
+  Vector2,
+  PerspectiveCamera,
+  Ray as ThreeRay,
+  Plane as ThreePlane,
+} from "three";
+
+/**
+ * Creates a plane from a point and a normal vector.
+ * @param point - A point on the plane
+ * @param normal - The normal vector of the plane
+ * @returns A Plane object defined by the point and normal
+ */
+export function getPlaneFromPointNormal(
+  point: Vector3,
+  normal: Vector3,
+): ThreePlane {
+  const pointVec3 = new Vec3(point.x, point.y, point.z);
+  const normalVec3 = new Vec3(normal.x, normal.y, normal.z);
+
+  const wasmPlane = nvGetPlaneFromPointNormal(pointVec3, normalVec3);
+
+  // Convert WASM Plane to Three.js Plane
+  const threeNormal = new Vector3(
+    wasmPlane.normal.x,
+    wasmPlane.normal.y,
+    wasmPlane.normal.z,
+  );
+  // Three.js Plane uses constant = -distance (dot product of normal and point on plane)
+  const threePlane = new ThreePlane(threeNormal, -wasmPlane.distance);
+
+  wasmPlane.free();
+
+  return threePlane;
+}
+
+/**
+ * Creates a picking ray from screen coordinates for raycasting.
+ * @param window - Window configuration with width, height, and pixelRatio
+ * @param camera - Three.js PerspectiveCamera
+ * @param vec2 - Screen coordinates in CSS pixels (same as MouseEvent clientX/clientY)
+ * @returns A Ray starting from the camera through the screen point
+ */
+export function getPickRay(
+  windowObject: WindowObject,
+  camera: PerspectiveCamera,
+  vec2: Vector2,
+): ThreeRay {
+  const window = new Window(
+    windowObject.width,
+    windowObject.height,
+    windowObject.pixelRatio,
+  );
+  window.width = window.width * window.pixelRatio;
+  window.height = window.height * window.pixelRatio;
+
+  const transform = new Transform(
+    camera.position.x,
+    camera.position.y,
+    camera.position.z,
+    camera.quaternion.x,
+    camera.quaternion.y,
+    camera.quaternion.z,
+    camera.quaternion.w,
+    camera.scale.x,
+    camera.scale.y,
+    camera.scale.z,
+  );
+
+  const frustum = new CameraFrustum(
+    camera.near,
+    camera.far,
+    angleToRadian(camera.fov),
+    camera.aspect,
+  );
+
+  const wasmRay = nvGetPickRay(
+    window,
+    transform,
+    frustum,
+    new Vec2(vec2.x, vec2.y),
+  );
+
+  // Convert WASM Ray to Three.js Ray
+  const origin = new Vector3(
+    wasmRay.origin.x,
+    wasmRay.origin.y,
+    wasmRay.origin.z,
+  );
+  const direction = new Vector3(
+    wasmRay.direction.x,
+    wasmRay.direction.y,
+    wasmRay.direction.z,
+  );
+  const threeRay = new ThreeRay(origin, direction);
+
+  wasmRay.free();
+
+  return threeRay;
+}
+
+/**
+ * Computes the intersection point between a ray and a plane.
+ * @param ray - The ray to test
+ * @param plane - The plane to intersect with
+ * @returns Intersection point Vector3 or undefined if no intersection
+ */
+export function getRayPlaneIntersection(
+  ray: ThreeRay,
+  plane: ThreePlane,
+): Vector3 | undefined {
+  // Convert Three.js Ray to WASM Ray
+  const wasmRay = new WASMRay(
+    new Vec3(ray.origin.x, ray.origin.y, ray.origin.z),
+    new Vec3(ray.direction.x, ray.direction.y, ray.direction.z),
+  );
+
+  // Convert Three.js Plane to WASM Plane
+  // Three.js uses constant = -distance, so we need to negate it
+  const wasmPlane = nvGetPlaneFromPointNormal(
+    new Vec3(
+      plane.normal.x * -plane.constant,
+      plane.normal.y * -plane.constant,
+      plane.normal.z * -plane.constant,
+    ),
+    new Vec3(plane.normal.x, plane.normal.y, plane.normal.z),
+  );
+
+  const intersection = nvGetRayPlaneIntersection(wasmRay, wasmPlane);
+
+  if (intersection) {
+    const result = new Vector3(intersection.x, intersection.y, intersection.z);
+    intersection.free();
+    return result;
+  }
+  return undefined;
+}
+
+/**
+ * Computes the height of a point above the WGS84 ellipsoid surface.
+ * @param point - Position in ECEF coordinates
+ * @returns Height above the ellipsoid in meters
+ */
+export function getHeightFromEllipsoid(point: Vector3): number {
+  const vec3 = new Vec3(point.x, point.y, point.z);
+  const result = nvGetHeightFromEllipsoid(vec3);
+  return result;
+}

package/src/rte.ts

@@ -0,0 +1,114 @@
+import { encodePosition } from "@navaramap/engine-api";
+import { Matrix4, Vector3 } from "three";
+
+/**
+ * Shared `u_rteOne` uniform for RTE vertex shaders. Always 1.0.
+ *
+ * Multiplying the high-order difference by a uniform the shader compiler
+ * cannot constant-fold blocks fast-math reassociation of
+ * `(high - camHigh) + (low - camLow)` into `(high + low) - (camHigh + camLow)`,
+ * which would collapse the math to absolute-ECEF f32 precision and make
+ * geometry freeze/snap in ~0.25-0.5 m steps as the camera moves
+ * (observed on ANGLE Metal). One frozen object is shared by every material.
+ */
+export const RTE_ONE_UNIFORM: { readonly value: number } = Object.freeze({
+  value: 1.0,
+});
+
+/**
+ * Encodes a position into high and low precision Vector3 components for RTE (Relative-To-Eye) rendering.
+ * This enables GPU double precision emulation by splitting a position into two float components.
+ * @param original - Position to encode
+ * @param resultHigh - Vector3 to store the high precision component (reused to avoid GC)
+ * @param resultLow - Vector3 to store the low precision component (reused to avoid GC)
+ */
+export function encodePositionRTE(
+  original: Vector3,
+  resultHigh = new Vector3(),
+  resultLow = new Vector3(),
+): { high: Vector3; low: Vector3 } {
+  const encoded = encodePosition(original.x, original.y, original.z);
+  resultHigh.set(encoded.high.x, encoded.high.y, encoded.high.z);
+  resultLow.set(encoded.low.x, encoded.low.y, encoded.low.z);
+  encoded.free();
+  return { high: resultHigh, low: resultLow };
+}
+
+/**
+ * Calculates the model-view matrix for Relative-To-Eye (RTE) rendering, which improves precision for distant objects.
+ * @param objectMatrixWorld - The object's world transformation matrix
+ * @param matrixWorldInverse - The camera's inverse world matrix
+ * @param result - Optional matrix to store the result (creates new if omitted)
+ * @returns Model-view matrix with translation zeroed for RTE rendering
+ */
+export const calcModelMatrixRTE = (
+  objectMatrixWorld: Matrix4,
+  matrixWorldInverse: Matrix4,
+  result = new Matrix4(),
+) => {
+  result.multiplyMatrices(matrixWorldInverse, objectMatrixWorld);
+  const e = result.elements;
+  e[12] = 0.0;
+  e[13] = 0.0;
+  e[14] = 0.0; // zero translation
+  return result;
+};
+
+/**
+ * Composes a frame matrix with a local transform, then splits the result into
+ * a translation Vector3 and a rotation/scale-only Matrix4 for RTE rendering.
+ *
+ * The translation is intended to be encoded as high/low RTE uniforms for GPU
+ * precision, while the rotation/scale matrix is assigned to the mesh's
+ * matrixWorld so it becomes the shader's modelMatrix uniform.
+ *
+ * @param frameMatrix - The frame transformation matrix (e.g. NUE-to-ECEF)
+ * @param localMatrix - The local T*R*S transform to compose within the frame
+ * @param resultPosition - Vector3 to store the extracted translation (reused to avoid GC)
+ * @param resultRotationScale - Matrix4 to store the translation-zeroed matrix (reused to avoid GC)
+ */
+export function composeWorldMatrixForRTE(
+  frameMatrix: Matrix4,
+  localMatrix: Matrix4,
+  resultPosition = new Vector3(),
+  resultRotationScale = new Matrix4(),
+): { position: Vector3; rotationScale: Matrix4 } {
+  resultRotationScale.multiplyMatrices(frameMatrix, localMatrix);
+  resultPosition.setFromMatrixPosition(resultRotationScale);
+  const e = resultRotationScale.elements;
+  e[12] = 0;
+  e[13] = 0;
+  e[14] = 0;
+  return { position: resultPosition, rotationScale: resultRotationScale };
+}
+
+const INVERSE_MODEL_MATRIX = new Matrix4();
+const CAMERA_MODEL_POSITION = new Vector3();
+/**
+ * Calculates the camera position relative to an object with high/low precision encoding for RTE rendering.
+ * @param cameraPosition - The camera's world position
+ * @param modelMatrixWorld - The object's world transformation matrix
+ * @returns Object with high and low precision Vector3 components for GPU double precision emulation
+ */
+export const calcCameraPosition = (
+  cameraPosition: Vector3,
+  modelMatrixWorld: Matrix4,
+) => {
+  INVERSE_MODEL_MATRIX.copy(modelMatrixWorld).invert();
+  CAMERA_MODEL_POSITION.copy(cameraPosition).applyMatrix4(INVERSE_MODEL_MATRIX);
+  const encoded = encodePosition(
+    CAMERA_MODEL_POSITION.x,
+    CAMERA_MODEL_POSITION.y,
+    CAMERA_MODEL_POSITION.z,
+  );
+  const high = encoded.high;
+  const low = encoded.low;
+  const result = {
+    high: new Vector3(high.x, high.y, high.z),
+    low: new Vector3(low.x, low.y, low.z),
+  };
+
+  encoded.free();
+
+  return result;
+};

package/src/vite-env.d.ts

@@ -0,0 +1 @@
+/// <reference types="vite/client" />