@takram/three-geospatial 0.0.1-alpha.1

package/build/r3f.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const u=require("react/jsx-runtime"),i=require("react"),l=require("three"),n=require("./shared.cjs"),f=require("@react-three/fiber"),m=new l.Matrix4,d=new n.Geodetic,E=new l.Vector3;class h extends l.Group{set(t,e,r,o=n.Ellipsoid.WGS84){const s=d.set(t,e,r).toECEF(E);o.getEastNorthUpFrame(s,m).decompose(this.position,this.quaternion,this.scale)}}const x=i.forwardRef(function({longitude:t,latitude:e,height:r=0,ellipsoid:o=n.Ellipsoid.WGS84,children:s},p){const a=i.useMemo(()=>new h,[]);return i.useEffect(()=>{a.set(t,e,r,o)},[t,e,r,o,a]),u.jsx("primitive",{ref:p,object:a,children:s})});function G(c){return t=>{c.forEach(e=>{typeof e=="function"?e(t):e!=null&&(e.current=t)})}}const S=i.forwardRef(function({args:t,children:e,...r},o){const s=i.useRef(null);return f.extend({EllipsoidGeometry:n.EllipsoidGeometry}),u.jsxs("mesh",{ref:G([s,o]),...r,children:[u.jsx("ellipsoidGeometry",{args:t}),e]})});exports.EastNorthUpFrame=x;exports.EllipsoidMesh=S;

package/build/r3f.js

@@ -0,0 +1,38 @@
+import { jsx as a, jsxs as f } from "react/jsx-runtime";
+import { forwardRef as m, useMemo as u, useEffect as l, useRef as E } from "react";
+import { Group as h, Matrix4 as d, Vector3 as x } from "three";
+import { E as p, G, a as w } from "./shared.js";
+import { extend as F } from "@react-three/fiber";
+const S = /* @__PURE__ */ new d(), N = /* @__PURE__ */ new G(), U = /* @__PURE__ */ new x();
+class j extends h {
+  set(o, t, r, e = p.WGS84) {
+    const s = N.set(o, t, r).toECEF(U);
+    e.getEastNorthUpFrame(s, S).decompose(this.position, this.quaternion, this.scale);
+  }
+}
+const g = /* @__PURE__ */ m(function({ longitude: o, latitude: t, height: r = 0, ellipsoid: e = p.WGS84, children: s }, n) {
+  const c = u(() => new j(), []);
+  return l(() => {
+    c.set(o, t, r, e);
+  }, [o, t, r, e, c]), /* @__PURE__ */ a("primitive", { ref: n, object: c, children: s });
+});
+function y(i) {
+  return (o) => {
+    i.forEach((t) => {
+      typeof t == "function" ? t(o) : t != null && (t.current = o);
+    });
+  };
+}
+const q = /* @__PURE__ */ m(
+  function({ args: o, children: t, ...r }, e) {
+    const s = E(null);
+    return F({ EllipsoidGeometry: w }), /* @__PURE__ */ f("mesh", { ref: y([s, e]), ...r, children: [
+      /* @__PURE__ */ a("ellipsoidGeometry", { args: o }),
+      t
+    ] });
+  }
+);
+export {
+  g as EastNorthUpFrame,
+  q as EllipsoidMesh
+};

package/build/shared.cjs

@@ -0,0 +1 @@
+"use strict";var P=Object.defineProperty;var j=(p,t,e)=>t in p?P(p,t,{enumerable:!0,configurable:!0,writable:!0,value:e}):p[t]=e;var g=(p,t,e)=>j(p,typeof t!="symbol"?t+"":t,e);const s=require("three"),W=new s.Vector3;function G(p,t,e=new s.Vector3,r){const{x:i,y:n,z:c}=p,o=t.x,a=t.y,y=t.z,d=i*i*o,u=n*n*a,m=c*c*y,l=d+u+m,h=Math.sqrt(1/l);if(!Number.isFinite(h))return;const f=W.copy(p).multiplyScalar(h);if(l<((r==null?void 0:r.centerTolerance)??.1))return e.copy(f);const A=f.multiply(t).multiplyScalar(2);let M=(1-h)*p.length()/(A.length()/2),z=0,w,x,V,E;do{M-=z,w=1/(1+M*o),x=1/(1+M*a),V=1/(1+M*y);const v=w*w,L=x*x,T=V*V,B=v*w,C=L*x,D=T*V;E=d*v+u*L+m*T-1,z=E/((d*B*o+u*C*a+m*D*y)*-2)}while(Math.abs(E)>1e-12);return e.set(i*w,n*x,c*V)}const b=new s.Vector3,U=new s.Vector3,O=new s.Vector3,S=class S{constructor(t,e,r){g(this,"radii");this.radii=new s.Vector3(t,e,r)}get minimumRadius(){return Math.min(this.radii.x,this.radii.y,this.radii.z)}get maximumRadius(){return Math.max(this.radii.x,this.radii.y,this.radii.z)}reciprocalRadii(t=new s.Vector3){const{x:e,y:r,z:i}=this.radii;return t.set(1/e,1/r,1/i)}reciprocalRadiiSquared(t=new s.Vector3){const{x:e,y:r,z:i}=this.radii;return t.set(1/e**2,1/r**2,1/i**2)}projectOnSurface(t,e=new s.Vector3,r){return G(t,this.reciprocalRadiiSquared(),e,r)}getSurfaceNormal(t,e=new s.Vector3){return e.multiplyVectors(this.reciprocalRadiiSquared(b),t).normalize()}getEastNorthUpVectors(t,e=new s.Vector3,r=new s.Vector3,i=new s.Vector3){this.getSurfaceNormal(t,i),e.set(-t.y,t.x,0).normalize(),r.crossVectors(i,e).normalize()}getEastNorthUpFrame(t,e=new s.Matrix4){const r=b,i=U,n=O;return this.getEastNorthUpVectors(t,r,i,n),e.makeBasis(r,i,n).setPosition(t)}getIntersection(t,e=new s.Vector3){const r=this.reciprocalRadii(b),i=U.copy(r).multiply(t.origin),n=O.copy(r).multiply(t.direction),c=i.lengthSq(),o=n.lengthSq(),a=i.dot(n),y=a**2-o*(c-1);if(c===1)return e.copy(t.origin);if(c>1){if(a>=0||y<0)return;const d=Math.sqrt(y),u=(-a-d)/o,m=(-a+d)/o;return t.at(Math.min(u,m),e)}if(c<1){const d=a**2-o*(c-1),u=Math.sqrt(d),m=(-a+u)/o;return t.at(m,e)}if(a<0)return t.at(-a/o,e)}getOsculatingSphereCenter(t,e,r=new s.Vector3){const i=this.radii.x**2,n=b.set(t.x/i,t.y/i,t.z/this.radii.z**2).normalize();return r.copy(n.multiplyScalar(-e).add(t))}};g(S,"WGS84",new S(6378137,6378137,6356752314245179e-9));let q=S;class $ extends s.BufferGeometry{constructor(e=new s.Vector3(1,1,1),r=32,i=16){super();g(this,"type","EllipsoidGeometry");g(this,"parameters");this.parameters={radii:e,longitudeSegments:r,latitudeSegments:i},r=Math.max(3,Math.floor(r)),i=Math.max(2,Math.floor(i));const n=(r+1)*(i+1),c=new s.Vector3,o=new s.Vector3,a=new Float32Array(n*3),y=new Float32Array(n*3),d=new Float32Array(n*2),u=[],m=[];for(let l=0,h=0,f=0,A=0;l<=i;++l){const M=[],z=l/i,w=z*Math.PI;let x=0;l===0?x=.5/r:l===i&&(x=-.5/r);for(let V=0;V<=r;++V,h+=3,f+=2,++A){const E=V/r,v=E*Math.PI*2;c.x=e.x*Math.cos(v)*Math.sin(w),c.y=e.y*Math.sin(v)*Math.sin(w),c.z=e.z*Math.cos(w),a[h]=c.x,a[h+1]=c.y,a[h+2]=c.z,o.copy(c).normalize(),y[h]=o.x,y[h+1]=o.y,y[h+2]=o.z,d[f]=E+x,d[f+1]=1-z,M.push(A)}u.push(M)}for(let l=0;l<i;++l)for(let h=0;h<r;++h){const f=u[l][h+1],A=u[l][h],M=u[l+1][h],z=u[l+1][h+1];l!==0&&m.push(f,A,z),l!==i-1&&m.push(A,M,z)}this.setIndex(m),this.setAttribute("position",new s.BufferAttribute(a,3)),this.setAttribute("normal",new s.BufferAttribute(y,3)),this.setAttribute("uv",new s.BufferAttribute(d,2))}copy(e){return super.copy(e),this.parameters={...e.parameters},this}}const N=new s.Vector3,R=new s.Vector3,I=class I{constructor(t=0,e=0,r=0){this.longitude=t,this.latitude=e,this.height=r}set(t,e,r){return this.longitude=t,this.latitude=e,r!=null&&(this.height=r),this}clone(){return new I(this.longitude,this.latitude,this.height)}copy(t){return this.longitude=t.longitude,this.latitude=t.latitude,this.height=t.height,this}equals(t){return t.longitude===this.longitude&&t.latitude===this.latitude&&t.height===this.height}setLongitude(t){return this.longitude=t,this}setLatitude(t){return this.latitude=t,this}setHeight(t){return this.height=t,this}normalize(){return this.longitude<I.MIN_LONGITUDE&&(this.longitude+=Math.PI*2),this}setFromECEF(t,e){const i=((e==null?void 0:e.ellipsoid)??q.WGS84).reciprocalRadiiSquared(N),n=G(t,i,R,e);if(n==null)throw new Error(`Could not project position to ellipsoid surface: ${t.toArray()}`);const c=N.multiplyVectors(n,i).normalize();this.longitude=Math.atan2(c.y,c.x),this.latitude=Math.asin(c.z);const o=N.subVectors(t,n);return this.height=Math.sign(o.dot(t))*o.length(),this}toECEF(t=new s.Vector3,e){const r=(e==null?void 0:e.ellipsoid)??q.WGS84,i=N.multiplyVectors(r.radii,r.radii),n=Math.cos(this.latitude),c=R.set(n*Math.cos(this.longitude),n*Math.sin(this.longitude),Math.sin(this.latitude)).normalize();return t.multiplyVectors(i,c),t.divideScalar(Math.sqrt(c.dot(t))).add(c.multiplyScalar(this.height))}fromArray(t,e=0){return this.longitude=t[e],this.latitude=t[e+1],this.height=t[e+2],this}toArray(t=[],e=0){return t[e]=this.longitude,t[e+1]=this.latitude,t[e+2]=this.height,t}*[Symbol.iterator](){yield this.longitude,yield this.latitude,yield this.height}};g(I,"MIN_LONGITUDE",-Math.PI),g(I,"MAX_LONGITUDE",Math.PI),g(I,"MIN_LATITUDE",-Math.PI/2),g(I,"MAX_LATITUDE",Math.PI/2);let F=I;exports.Ellipsoid=q;exports.EllipsoidGeometry=$;exports.Geodetic=F;

package/build/shared.js

@@ -0,0 +1,198 @@
+var B = Object.defineProperty;
+var W = (p, t, i) => t in p ? B(p, t, { enumerable: !0, configurable: !0, writable: !0, value: i }) : p[t] = i;
+var z = (p, t, i) => W(p, typeof t != "symbol" ? t + "" : t, i);
+import { Vector3 as c, Matrix4 as $, BufferGeometry as Q, BufferAttribute as F } from "three";
+const X = /* @__PURE__ */ new c();
+function D(p, t, i = new c(), r) {
+  const { x: s, y: n, z: e } = p, a = t.x, o = t.y, y = t.z, d = s * s * a, u = n * n * o, m = e * e * y, l = d + u + m, h = Math.sqrt(1 / l);
+  if (!Number.isFinite(h))
+    return;
+  const f = X.copy(p).multiplyScalar(h);
+  if (l < ((r == null ? void 0 : r.centerTolerance) ?? 0.1))
+    return i.copy(f);
+  const E = f.multiply(t).multiplyScalar(2);
+  let M = (1 - h) * p.length() / (E.length() / 2), I = 0, w, x, g, A;
+  do {
+    M -= I, w = 1 / (1 + M * a), x = 1 / (1 + M * o), g = 1 / (1 + M * y);
+    const q = w * w, L = x * x, T = g * g, G = q * w, P = L * x, j = T * g;
+    A = d * q + u * L + m * T - 1, I = A / ((d * G * a + u * P * o + m * j * y) * -2);
+  } while (Math.abs(A) > 1e-12);
+  return i.set(s * w, n * x, e * g);
+}
+const N = /* @__PURE__ */ new c(), U = /* @__PURE__ */ new c(), O = /* @__PURE__ */ new c(), V = class V {
+  constructor(t, i, r) {
+    z(this, "radii");
+    this.radii = new c(t, i, r);
+  }
+  get minimumRadius() {
+    return Math.min(this.radii.x, this.radii.y, this.radii.z);
+  }
+  get maximumRadius() {
+    return Math.max(this.radii.x, this.radii.y, this.radii.z);
+  }
+  reciprocalRadii(t = new c()) {
+    const { x: i, y: r, z: s } = this.radii;
+    return t.set(1 / i, 1 / r, 1 / s);
+  }
+  reciprocalRadiiSquared(t = new c()) {
+    const { x: i, y: r, z: s } = this.radii;
+    return t.set(1 / i ** 2, 1 / r ** 2, 1 / s ** 2);
+  }
+  projectOnSurface(t, i = new c(), r) {
+    return D(
+      t,
+      this.reciprocalRadiiSquared(),
+      i,
+      r
+    );
+  }
+  getSurfaceNormal(t, i = new c()) {
+    return i.multiplyVectors(this.reciprocalRadiiSquared(N), t).normalize();
+  }
+  getEastNorthUpVectors(t, i = new c(), r = new c(), s = new c()) {
+    this.getSurfaceNormal(t, s), i.set(-t.y, t.x, 0).normalize(), r.crossVectors(s, i).normalize();
+  }
+  getEastNorthUpFrame(t, i = new $()) {
+    const r = N, s = U, n = O;
+    return this.getEastNorthUpVectors(t, r, s, n), i.makeBasis(r, s, n).setPosition(t);
+  }
+  getIntersection(t, i = new c()) {
+    const r = this.reciprocalRadii(N), s = U.copy(r).multiply(t.origin), n = O.copy(r).multiply(t.direction), e = s.lengthSq(), a = n.lengthSq(), o = s.dot(n), y = o ** 2 - a * (e - 1);
+    if (e === 1)
+      return i.copy(t.origin);
+    if (e > 1) {
+      if (o >= 0 || y < 0)
+        return;
+      const d = Math.sqrt(y), u = (-o - d) / a, m = (-o + d) / a;
+      return t.at(Math.min(u, m), i);
+    }
+    if (e < 1) {
+      const d = o ** 2 - a * (e - 1), u = Math.sqrt(d), m = (-o + u) / a;
+      return t.at(m, i);
+    }
+    if (o < 0)
+      return t.at(-o / a, i);
+  }
+  getOsculatingSphereCenter(t, i, r = new c()) {
+    const s = this.radii.x ** 2, n = N.set(
+      t.x / s,
+      t.y / s,
+      t.z / this.radii.z ** 2
+    ).normalize();
+    return r.copy(n.multiplyScalar(-i).add(t));
+  }
+};
+z(V, "WGS84", /* @__PURE__ */ new V(
+  6378137,
+  6378137,
+  6356752314245179e-9
+));
+let b = V;
+class J extends Q {
+  constructor(i = new c(1, 1, 1), r = 32, s = 16) {
+    super();
+    z(this, "type", "EllipsoidGeometry");
+    z(this, "parameters");
+    this.parameters = {
+      radii: i,
+      longitudeSegments: r,
+      latitudeSegments: s
+    }, r = Math.max(3, Math.floor(r)), s = Math.max(2, Math.floor(s));
+    const n = (r + 1) * (s + 1), e = new c(), a = new c(), o = new Float32Array(n * 3), y = new Float32Array(n * 3), d = new Float32Array(n * 2), u = [], m = [];
+    for (let l = 0, h = 0, f = 0, E = 0; l <= s; ++l) {
+      const M = [], I = l / s, w = I * Math.PI;
+      let x = 0;
+      l === 0 ? x = 0.5 / r : l === s && (x = -0.5 / r);
+      for (let g = 0; g <= r; ++g, h += 3, f += 2, ++E) {
+        const A = g / r, q = A * Math.PI * 2;
+        e.x = i.x * Math.cos(q) * Math.sin(w), e.y = i.y * Math.sin(q) * Math.sin(w), e.z = i.z * Math.cos(w), o[h] = e.x, o[h + 1] = e.y, o[h + 2] = e.z, a.copy(e).normalize(), y[h] = a.x, y[h + 1] = a.y, y[h + 2] = a.z, d[f] = A + x, d[f + 1] = 1 - I, M.push(E);
+      }
+      u.push(M);
+    }
+    for (let l = 0; l < s; ++l)
+      for (let h = 0; h < r; ++h) {
+        const f = u[l][h + 1], E = u[l][h], M = u[l + 1][h], I = u[l + 1][h + 1];
+        l !== 0 && m.push(f, E, I), l !== s - 1 && m.push(E, M, I);
+      }
+    this.setIndex(m), this.setAttribute("position", new F(o, 3)), this.setAttribute("normal", new F(y, 3)), this.setAttribute("uv", new F(d, 2));
+  }
+  copy(i) {
+    return super.copy(i), this.parameters = { ...i.parameters }, this;
+  }
+}
+const S = /* @__PURE__ */ new c(), R = /* @__PURE__ */ new c(), v = class v {
+  constructor(t = 0, i = 0, r = 0) {
+    this.longitude = t, this.latitude = i, this.height = r;
+  }
+  set(t, i, r) {
+    return this.longitude = t, this.latitude = i, r != null && (this.height = r), this;
+  }
+  clone() {
+    return new v(this.longitude, this.latitude, this.height);
+  }
+  copy(t) {
+    return this.longitude = t.longitude, this.latitude = t.latitude, this.height = t.height, this;
+  }
+  equals(t) {
+    return t.longitude === this.longitude && t.latitude === this.latitude && t.height === this.height;
+  }
+  setLongitude(t) {
+    return this.longitude = t, this;
+  }
+  setLatitude(t) {
+    return this.latitude = t, this;
+  }
+  setHeight(t) {
+    return this.height = t, this;
+  }
+  normalize() {
+    return this.longitude < v.MIN_LONGITUDE && (this.longitude += Math.PI * 2), this;
+  }
+  // See: https://en.wikipedia.org/wiki/Geographic_coordinate_conversion
+  // Reference: https://github.com/CesiumGS/cesium/blob/1.122/packages/engine/Source/Core/Geodetic.js#L119
+  setFromECEF(t, i) {
+    const s = ((i == null ? void 0 : i.ellipsoid) ?? b.WGS84).reciprocalRadiiSquared(S), n = D(
+      t,
+      s,
+      R,
+      i
+    );
+    if (n == null)
+      throw new Error(
+        `Could not project position to ellipsoid surface: ${t.toArray()}`
+      );
+    const e = S.multiplyVectors(n, s).normalize();
+    this.longitude = Math.atan2(e.y, e.x), this.latitude = Math.asin(e.z);
+    const a = S.subVectors(t, n);
+    return this.height = Math.sign(a.dot(t)) * a.length(), this;
+  }
+  // See: https://en.wikipedia.org/wiki/Geographic_coordinate_conversion
+  // Reference: https://github.com/CesiumGS/cesium/blob/1.122/packages/engine/Source/Core/Cartesian3.js#L916
+  toECEF(t = new c(), i) {
+    const r = (i == null ? void 0 : i.ellipsoid) ?? b.WGS84, s = S.multiplyVectors(
+      r.radii,
+      r.radii
+    ), n = Math.cos(this.latitude), e = R.set(
+      n * Math.cos(this.longitude),
+      n * Math.sin(this.longitude),
+      Math.sin(this.latitude)
+    ).normalize();
+    return t.multiplyVectors(s, e), t.divideScalar(Math.sqrt(e.dot(t))).add(e.multiplyScalar(this.height));
+  }
+  fromArray(t, i = 0) {
+    return this.longitude = t[i], this.latitude = t[i + 1], this.height = t[i + 2], this;
+  }
+  toArray(t = [], i = 0) {
+    return t[i] = this.longitude, t[i + 1] = this.latitude, t[i + 2] = this.height, t;
+  }
+  *[Symbol.iterator]() {
+    yield this.longitude, yield this.latitude, yield this.height;
+  }
+};
+z(v, "MIN_LONGITUDE", -Math.PI), z(v, "MAX_LONGITUDE", Math.PI), z(v, "MIN_LATITUDE", -Math.PI / 2), z(v, "MAX_LATITUDE", Math.PI / 2);
+let C = v;
+export {
+  b as E,
+  C as G,
+  J as a
+};

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@takram/three-geospatial",
+  "version": "0.0.1-alpha.1",
+  "license": "MIT",
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./build/index.js",
+      "require": "./build/index.cjs",
+      "types": "./types/index.d.ts"
+    },
+    "./r3f": {
+      "import": "./build/r3f.js",
+      "require": "./build/r3f.cjs",
+      "types": "./types/r3f/index.d.ts"
+    }
+  },
+  "main": "./build/index.cjs",
+  "module": "./build/index.js",
+  "types": "./types/index.d.ts",
+  "files": [
+    "build",
+    "src",
+    "types",
+    "package.json",
+    "README.md"
+  ],
+  "dependencies": {
+    "lodash-es": "^4.17.21",
+    "react-merge-refs": "^2.1.1",
+    "tiny-invariant": "^1.3.3",
+    "type-fest": "^4.28.0"
+  },
+  "peerDependencies": {
+    "@react-three/fiber": ">=8.17.10",
+    "react": ">=18.0",
+    "three": ">=0.170.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/ArrayBufferLoader.ts

@@ -0,0 +1,35 @@
+import { FileLoader, Loader } from 'three'
+import invariant from 'tiny-invariant'
+
+export class ArrayBufferLoader extends Loader<ArrayBuffer> {
+  override load(
+    url: string,
+    onLoad: (data: ArrayBuffer) => void,
+    onProgress?: (event: ProgressEvent) => void,
+    onError?: (error: unknown) => void
+  ): void {
+    const loader = new FileLoader(this.manager)
+    loader.setResponseType('arraybuffer')
+    loader.setRequestHeader(this.requestHeader)
+    loader.setPath(this.path)
+    loader.setWithCredentials(this.withCredentials)
+    loader.load(
+      url,
+      arrayBuffer => {
+        invariant(arrayBuffer instanceof ArrayBuffer)
+        try {
+          onLoad(arrayBuffer)
+        } catch (error) {
+          if (onError != null) {
+            onError(error)
+          } else {
+            console.error(error)
+          }
+          this.manager.itemError(url)
+        }
+      },
+      onProgress,
+      onError
+    )
+  }
+}

package/src/DataLoader.ts

@@ -0,0 +1,114 @@
+import {
+  ClampToEdgeWrapping,
+  Data3DTexture,
+  DataTexture,
+  FloatType,
+  LinearFilter,
+  Loader,
+  RGBAFormat,
+  type Texture,
+  type TypedArray
+} from 'three'
+import { type Class } from 'type-fest'
+
+import {
+  Float32ArrayLoader,
+  Int16ArrayLoader,
+  Uint16ArrayLoader,
+  type TypedArrayLoader
+} from './TypedArrayLoader'
+import { type Callable } from './types'
+
+export interface ImageSize {
+  width: number
+  height: number
+  depth?: number
+}
+
+export type DataTextureParameters = Omit<
+  Partial<{
+    [K in keyof Texture as Texture[K] extends Callable ? never : K]: Texture[K]
+  }>,
+  'image'
+>
+
+const defaultDataTextureParameter = {
+  format: RGBAFormat,
+  wrapS: ClampToEdgeWrapping,
+  wrapT: ClampToEdgeWrapping,
+  minFilter: LinearFilter,
+  magFilter: LinearFilter
+} satisfies DataTextureParameters
+
+export abstract class DataLoader<
+  T extends DataTexture | Data3DTexture,
+  U extends TypedArray
+> extends Loader<T> {
+  abstract readonly Texture: Class<T>
+  abstract readonly TypedArrayLoader: Class<TypedArrayLoader<U>>
+
+  readonly parameters?: DataTextureParameters
+
+  override load(
+    url: string,
+    onLoad: (data: T) => void,
+    onProgress?: (event: ProgressEvent) => void,
+    onError?: (error: unknown) => void
+  ): void {
+    const texture = new this.Texture()
+    const loader = new this.TypedArrayLoader(this.manager)
+    loader.setRequestHeader(this.requestHeader)
+    loader.setPath(this.path)
+    loader.setWithCredentials(this.withCredentials)
+    loader.load(
+      url,
+      array => {
+        texture.image.data = array as typeof texture.image.data
+        Object.assign(texture, this.parameters)
+        texture.needsUpdate = true
+        onLoad(texture)
+      },
+      onProgress,
+      onError
+    )
+  }
+}
+
+export class Int16Data2DLoader extends DataLoader<DataTexture, Int16Array> {
+  readonly Texture = DataTexture
+  readonly TypedArrayLoader = Int16ArrayLoader
+  readonly parameters = {
+    ...defaultDataTextureParameter,
+    type: FloatType
+  } satisfies DataTextureParameters
+}
+
+export class Uint16Data2DLoader extends DataLoader<DataTexture, Uint16Array> {
+  readonly Texture = DataTexture
+  readonly TypedArrayLoader = Uint16ArrayLoader
+  readonly parameters = {
+    ...defaultDataTextureParameter,
+    type: FloatType
+  } satisfies DataTextureParameters
+}
+
+export class Float32Data2DLoader extends DataLoader<DataTexture, Float32Array> {
+  readonly Texture = DataTexture
+  readonly TypedArrayLoader = Float32ArrayLoader
+  readonly parameters = {
+    ...defaultDataTextureParameter,
+    type: FloatType
+  } satisfies DataTextureParameters
+}
+
+export class Float32Data3DLoader extends DataLoader<
+  Data3DTexture,
+  Float32Array
+> {
+  readonly Texture = Data3DTexture
+  readonly TypedArrayLoader = Float32ArrayLoader
+  readonly parameters = {
+    ...defaultDataTextureParameter,
+    type: FloatType
+  } satisfies DataTextureParameters
+}

package/src/Ellipsoid.ts

@@ -0,0 +1,128 @@
+import { Matrix4, Vector3, type Ray } from 'three'
+
+import {
+  projectOnEllipsoidSurface,
+  type ProjectOnEllipsoidSurfaceOptions
+} from './helpers/projectOnEllipsoidSurface'
+
+const vectorScratch1 = /*#__PURE__*/ new Vector3()
+const vectorScratch2 = /*#__PURE__*/ new Vector3()
+const vectorScratch3 = /*#__PURE__*/ new Vector3()
+
+export class Ellipsoid {
+  static readonly WGS84 = /*#__PURE__*/ new Ellipsoid(
+    6378137,
+    6378137,
+    6356752.3142451793
+  )
+
+  readonly radii: Vector3
+
+  constructor(x: number, y: number, z: number) {
+    this.radii = new Vector3(x, y, z)
+  }
+
+  get minimumRadius(): number {
+    return Math.min(this.radii.x, this.radii.y, this.radii.z)
+  }
+
+  get maximumRadius(): number {
+    return Math.max(this.radii.x, this.radii.y, this.radii.z)
+  }
+
+  reciprocalRadii(result = new Vector3()): Vector3 {
+    const { x, y, z } = this.radii
+    return result.set(1 / x, 1 / y, 1 / z)
+  }
+
+  reciprocalRadiiSquared(result = new Vector3()): Vector3 {
+    const { x, y, z } = this.radii
+    return result.set(1 / x ** 2, 1 / y ** 2, 1 / z ** 2)
+  }
+
+  projectOnSurface(
+    position: Vector3,
+    result = new Vector3(),
+    options?: ProjectOnEllipsoidSurfaceOptions
+  ): Vector3 | undefined {
+    return projectOnEllipsoidSurface(
+      position,
+      this.reciprocalRadiiSquared(),
+      result,
+      options
+    )
+  }
+
+  getSurfaceNormal(position: Vector3, result = new Vector3()): Vector3 {
+    return result
+      .multiplyVectors(this.reciprocalRadiiSquared(vectorScratch1), position)
+      .normalize()
+  }
+
+  getEastNorthUpVectors(
+    position: Vector3,
+    east = new Vector3(),
+    north = new Vector3(),
+    up = new Vector3()
+  ): void {
+    this.getSurfaceNormal(position, up)
+    east.set(-position.y, position.x, 0).normalize()
+    north.crossVectors(up, east).normalize()
+  }
+
+  getEastNorthUpFrame(position: Vector3, result = new Matrix4()): Matrix4 {
+    const east = vectorScratch1
+    const north = vectorScratch2
+    const up = vectorScratch3
+    this.getEastNorthUpVectors(position, east, north, up)
+    return result.makeBasis(east, north, up).setPosition(position)
+  }
+
+  getIntersection(ray: Ray, result = new Vector3()): Vector3 | undefined {
+    const reciprocalRadii = this.reciprocalRadii(vectorScratch1)
+    const p = vectorScratch2.copy(reciprocalRadii).multiply(ray.origin)
+    const d = vectorScratch3.copy(reciprocalRadii).multiply(ray.direction)
+    const p2 = p.lengthSq()
+    const d2 = d.lengthSq()
+    const pd = p.dot(d)
+    const discriminant = pd ** 2 - d2 * (p2 - 1)
+    if (p2 === 1) {
+      return result.copy(ray.origin)
+    }
+    if (p2 > 1) {
+      if (pd >= 0 || discriminant < 0) {
+        return // No intersection
+      }
+      const Q = Math.sqrt(discriminant)
+      const t1 = (-pd - Q) / d2
+      const t2 = (-pd + Q) / d2
+      return ray.at(Math.min(t1, t2), result)
+    }
+    if (p2 < 1) {
+      const discriminant = pd ** 2 - d2 * (p2 - 1)
+      const Q = Math.sqrt(discriminant)
+      const t = (-pd + Q) / d2
+      return ray.at(t, result) // Backface of the ellipsoid
+    }
+    if (pd < 0) {
+      return ray.at(-pd / d2, result) // Backface of the ellipsoid
+    }
+    // No intersection
+  }
+
+  getOsculatingSphereCenter(
+    surfacePosition: Vector3,
+    radius: number,
+    result = new Vector3()
+  ): Vector3 {
+    const xySquared = this.radii.x ** 2
+    const normal = vectorScratch1
+      .set(
+        surfacePosition.x / xySquared,
+        surfacePosition.y / xySquared,
+        surfacePosition.z / this.radii.z ** 2
+      )
+      .normalize()
+    return result.copy(normal.multiplyScalar(-radius).add(surfacePosition))
+  }
+}

package/src/EllipsoidGeometry.ts

@@ -0,0 +1,107 @@
+import { BufferAttribute, BufferGeometry, Vector3 } from 'three'
+
+export interface EllipsoidGeometryParameters {
+  radii: Vector3
+  longitudeSegments?: number
+  latitudeSegments?: number
+}
+
+export class EllipsoidGeometry extends BufferGeometry {
+  readonly type = 'EllipsoidGeometry'
+
+  parameters: EllipsoidGeometryParameters
+
+  constructor(
+    radii = new Vector3(1, 1, 1),
+    longitudeSegments = 32,
+    latitudeSegments = 16
+  ) {
+    super()
+    this.parameters = {
+      radii,
+      longitudeSegments,
+      latitudeSegments
+    }
+
+    longitudeSegments = Math.max(3, Math.floor(longitudeSegments))
+    latitudeSegments = Math.max(2, Math.floor(latitudeSegments))
+
+    const elementCount = (longitudeSegments + 1) * (latitudeSegments + 1)
+    const vertex = new Vector3()
+    const normal = new Vector3()
+    const vertices = new Float32Array(elementCount * 3)
+    const normals = new Float32Array(elementCount * 3)
+    const uvs = new Float32Array(elementCount * 2)
+    const grid: number[][] = []
+    const indices: number[] = []
+
+    // Vertices, normals and UVs
+    for (
+      let y = 0, vertexIndex = 0, uvIndex = 0, rowIndex = 0;
+      y <= latitudeSegments;
+      ++y
+    ) {
+      const rowIndices = []
+      const v = y / latitudeSegments
+      const phi = v * Math.PI
+
+      // Special case for the poles
+      let uOffset = 0
+      if (y === 0) {
+        uOffset = 0.5 / longitudeSegments
+      } else if (y === latitudeSegments) {
+        uOffset = -0.5 / longitudeSegments
+      }
+
+      for (
+        let x = 0;
+        x <= longitudeSegments;
+        ++x, vertexIndex += 3, uvIndex += 2, ++rowIndex
+      ) {
+        const u = x / longitudeSegments
+        const theta = u * Math.PI * 2
+        vertex.x = radii.x * Math.cos(theta) * Math.sin(phi)
+        vertex.y = radii.y * Math.sin(theta) * Math.sin(phi)
+        vertex.z = radii.z * Math.cos(phi)
+        vertices[vertexIndex] = vertex.x
+        vertices[vertexIndex + 1] = vertex.y
+        vertices[vertexIndex + 2] = vertex.z
+        normal.copy(vertex).normalize()
+        normals[vertexIndex] = normal.x
+        normals[vertexIndex + 1] = normal.y
+        normals[vertexIndex + 2] = normal.z
+        uvs[uvIndex] = u + uOffset
+        uvs[uvIndex + 1] = 1 - v
+        rowIndices.push(rowIndex)
+      }
+      grid.push(rowIndices)
+    }
+
+    // Indices
+    for (let y = 0; y < latitudeSegments; ++y) {
+      for (let x = 0; x < longitudeSegments; ++x) {
+        const a = grid[y][x + 1]
+        const b = grid[y][x]
+        const c = grid[y + 1][x]
+        const d = grid[y + 1][x + 1]
+        if (y !== 0) {
+          indices.push(a, b, d)
+        }
+        if (y !== latitudeSegments - 1) {
+          indices.push(b, c, d)
+        }
+      }
+    }
+
+    this.setIndex(indices)
+    this.setAttribute('position', new BufferAttribute(vertices, 3))
+    this.setAttribute('normal', new BufferAttribute(normals, 3))
+    this.setAttribute('uv', new BufferAttribute(uvs, 2))
+  }
+
+  copy(source: EllipsoidGeometry): this {
+    super.copy(source)
+    this.parameters = { ...source.parameters }
+    return this
+  }
+}