@takram/three-geospatial 0.0.1-alpha.4 → 0.0.1-alpha.6

package/build/shaders.js

@@ -0,0 +1,286 @@
+const n = `// cSpell:words logdepthbuf
+
+float reverseLogDepth(const float depth, const float near, const float far) {
+  #ifdef USE_LOGDEPTHBUF
+  float d = pow(2.0, depth * log2(far + 1.0)) - 1.0;
+  float a = far / (far - near);
+  float b = far * near / (near - far);
+  return a + b / d;
+  #else // USE_LOGDEPTHBUF
+  return depth;
+  #endif // USE_LOGDEPTHBUF
+}
+
+float linearizeDepth(const float depth, const float near, const float far) {
+  float ndc = depth * 2.0 - 1.0;
+  return 2.0 * near * far / (far + near - ndc * (far - near));
+}
+`, e = `float checker(const vec2 uv, const vec2 repeats) {
+  vec2 c = floor(repeats * uv);
+  float result = mod(c.x + c.y, 2.0);
+  return sign(result);
+}
+
+float checker(const vec2 uv, const float repeats) {
+  return checker(uv, vec2(repeats));
+}
+`, t = `#if !defined(saturate)
+#define saturate(a) clamp(a, 0.0, 1.0)
+#endif // !defined(saturate)
+
+float inverseLerp(const float x, const float y, const float a) {
+  return (a - x) / (y - x);
+}
+
+vec2 inverseLerp(const vec2 x, const vec2 y, const vec2 a) {
+  return (a - x) / (y - x);
+}
+
+vec3 inverseLerp(const vec3 x, const vec3 y, const vec3 a) {
+  return (a - x) / (y - x);
+}
+
+vec4 inverseLerp(const vec4 x, const vec4 y, const vec4 a) {
+  return (a - x) / (y - x);
+}
+
+float remap(const float x, const float min1, const float max1, const float min2, const float max2) {
+  return min2 + (x - min1) / (max1 - min1) * (max2 - min2);
+}
+
+vec2 remap(const vec2 x, const vec2 min1, const vec2 max1, const vec2 min2, const vec2 max2) {
+  return min2 + (x - min1) / (max1 - min1) * (max2 - min2);
+}
+
+vec3 remap(const vec3 x, const vec3 min1, const vec3 max1, const vec3 min2, const vec3 max2) {
+  return min2 + (x - min1) / (max1 - min1) * (max2 - min2);
+}
+
+vec4 remap(const vec4 x, const vec4 min1, const vec4 max1, const vec4 min2, const vec4 max2) {
+  return min2 + (x - min1) / (max1 - min1) * (max2 - min2);
+}
+
+// Implicitly remap to 0 and 1
+float remap(const float x, const float min1, const float max1) {
+  return (x - min1) / (max1 - min1);
+}
+
+vec2 remap(const vec2 x, const vec2 min1, const vec2 max1) {
+  return (x - min1) / (max1 - min1);
+}
+
+vec3 remap(const vec3 x, const vec3 min1, const vec3 max1) {
+  return (x - min1) / (max1 - min1);
+}
+
+vec4 remap(const vec4 x, const vec4 min1, const vec4 max1) {
+  return (x - min1) / (max1 - min1);
+}
+`, c = `// Reference: https://jcgt.org/published/0003/02/01/paper.pdf
+
+vec2 signNotZero(vec2 v) {
+  return vec2(v.x >= 0.0 ? 1.0 : -1.0, v.y >= 0.0 ? 1.0 : -1.0);
+}
+
+vec2 packNormalToVec2(vec3 v) {
+  vec2 p = v.xy * (1.0 / (abs(v.x) + abs(v.y) + abs(v.z)));
+  return v.z <= 0.0
+    ? (1.0 - abs(p.yx)) * signNotZero(p)
+    : p;
+}
+
+vec3 unpackVec2ToNormal(vec2 e) {
+  vec3 v = vec3(e.xy, 1.0 - abs(e.x) - abs(e.y));
+  if (v.z < 0.0) {
+    v.xy = (1.0 - abs(v.yx)) * signNotZero(v.xy);
+  }
+  return normalize(v);
+}
+`, o = `// Taken from: https://developer.download.nvidia.com/whitepapers/2008/PCSS_Integration.pdf
+const vec2 poissonDisk[16] = vec2[16](
+  vec2(-0.94201624, -0.39906216),
+  vec2(0.94558609, -0.76890725),
+  vec2(-0.094184101, -0.9293887),
+  vec2(0.34495938, 0.2938776),
+  vec2(-0.91588581, 0.45771432),
+  vec2(-0.81544232, -0.87912464),
+  vec2(-0.38277543, 0.27676845),
+  vec2(0.97484398, 0.75648379),
+  vec2(0.44323325, -0.97511554),
+  vec2(0.53742981, -0.4737342),
+  vec2(-0.26496911, -0.41893023),
+  vec2(0.79197514, 0.19090188),
+  vec2(-0.2418884, 0.99706507),
+  vec2(-0.81409955, 0.9143759),
+  vec2(0.19984126, 0.78641367),
+  vec2(0.14383161, -0.1410079)
+);
+
+#define POISSON_DISK_COUNT (16)
+`, r = `float raySphereFirstIntersection(
+  const vec3 origin,
+  const vec3 direction,
+  const vec3 center,
+  const float radius
+) {
+  vec3 a = origin - center;
+  float b = 2.0 * dot(direction, a);
+  float c = dot(a, a) - radius * radius;
+  float discriminant = b * b - 4.0 * c;
+  return discriminant < 0.0
+    ? -1.0
+    : (-b - sqrt(discriminant)) * 0.5;
+}
+
+float raySphereFirstIntersection(const vec3 origin, const vec3 direction, const float radius) {
+  return raySphereFirstIntersection(origin, direction, vec3(0.0), radius);
+}
+
+vec4 raySphereFirstIntersection(
+  const vec3 origin,
+  const vec3 direction,
+  const vec3 center,
+  const vec4 radius
+) {
+  vec3 a = origin - center;
+  float b = 2.0 * dot(direction, a);
+  vec4 c = dot(a, a) - radius * radius;
+  vec4 discriminant = b * b - 4.0 * c;
+  vec4 mask = step(discriminant, vec4(0.0));
+  return mix((-b - sqrt(max(vec4(0.0), discriminant))) * 0.5, vec4(-1.0), mask);
+}
+
+vec4 raySphereFirstIntersection(const vec3 origin, const vec3 direction, const vec4 radius) {
+  return raySphereFirstIntersection(origin, direction, vec3(0.0), radius);
+}
+
+float raySphereSecondIntersection(
+  const vec3 origin,
+  const vec3 direction,
+  const vec3 center,
+  const float radius
+) {
+  vec3 a = origin - center;
+  float b = 2.0 * dot(direction, a);
+  float c = dot(a, a) - radius * radius;
+  float discriminant = b * b - 4.0 * c;
+  return discriminant < 0.0
+    ? -1.0
+    : (-b + sqrt(discriminant)) * 0.5;
+}
+
+float raySphereSecondIntersection(const vec3 origin, const vec3 direction, const float radius) {
+  return raySphereSecondIntersection(origin, direction, vec3(0.0), radius);
+}
+
+vec4 raySphereSecondIntersection(
+  const vec3 origin,
+  const vec3 direction,
+  const vec3 center,
+  const vec4 radius
+) {
+  vec3 a = origin - center;
+  float b = 2.0 * dot(direction, a);
+  vec4 c = dot(a, a) - radius * radius;
+  vec4 discriminant = b * b - 4.0 * c;
+  vec4 mask = step(discriminant, vec4(0.0));
+  return mix((-b + sqrt(max(vec4(0.0), discriminant))) * 0.5, vec4(-1.0), mask);
+}
+
+vec4 raySphereSecondIntersection(const vec3 origin, const vec3 direction, const vec4 radius) {
+  return raySphereSecondIntersection(origin, direction, vec3(0.0), radius);
+}
+
+void raySphereIntersections(
+  const vec3 origin,
+  const vec3 direction,
+  const vec3 center,
+  const float radius,
+  out float intersection1,
+  out float intersection2
+) {
+  vec3 a = origin - center;
+  float b = 2.0 * dot(direction, a);
+  float c = dot(a, a) - radius * radius;
+  float discriminant = b * b - 4.0 * c;
+  if (discriminant < 0.0) {
+    intersection1 = -1.0;
+    intersection2 = -1.0;
+    return;
+  } else {
+    float Q = sqrt(discriminant);
+    intersection1 = (-b - Q) * 0.5;
+    intersection2 = (-b + Q) * 0.5;
+  }
+}
+
+void raySphereIntersections(
+  const vec3 origin,
+  const vec3 direction,
+  const float radius,
+  out float intersection1,
+  out float intersection2
+) {
+  raySphereIntersections(origin, direction, vec3(0.0), radius, intersection1, intersection2);
+}
+
+void raySphereIntersections(
+  const vec3 origin,
+  const vec3 direction,
+  const vec3 center,
+  const vec4 radius,
+  out vec4 intersection1,
+  out vec4 intersection2
+) {
+  vec3 a = origin - center;
+  float b = 2.0 * dot(direction, a);
+  vec4 c = dot(a, a) - radius * radius;
+  vec4 discriminant = b * b - 4.0 * c;
+  vec4 mask = step(discriminant, vec4(0.0));
+  vec4 Q = sqrt(max(vec4(0.0), discriminant));
+  intersection1 = mix((-b - Q) * 0.5, vec4(-1.0), mask);
+  intersection2 = mix((-b + Q) * 0.5, vec4(-1.0), mask);
+}
+
+void raySphereIntersections(
+  const vec3 origin,
+  const vec3 direction,
+  const vec4 radius,
+  out vec4 intersection1,
+  out vec4 intersection2
+) {
+  raySphereIntersections(origin, direction, vec3(0.0), radius, intersection1, intersection2);
+}
+`, i = `vec3 screenToView(
+  const vec2 uv,
+  const float depth,
+  const float viewZ,
+  const mat4 projectionMatrix,
+  const mat4 inverseProjectionMatrix
+) {
+  vec4 clip = vec4(vec3(uv, depth) * 2.0 - 1.0, 1.0);
+  float clipW = projectionMatrix[2][3] * viewZ + projectionMatrix[3][3];
+  clip *= clipW;
+  return (inverseProjectionMatrix * clip).xyz;
+}
+`, s = `// A fifth-order polynomial approximation of Turbo color map.
+// See: https://observablehq.com/@mbostock/turbo
+// prettier-ignore
+vec3 turbo(const float x) {
+  float r = 0.1357 + x * (4.5974 - x * (42.3277 - x * (130.5887 - x * (150.5666 - x * 58.1375))));
+  float g = 0.0914 + x * (2.1856 + x * (4.8052 - x * (14.0195 - x * (4.2109 + x * 2.7747))));
+  float b = 0.1067 + x * (12.5925 - x * (60.1097 - x * (109.0745 - x * (88.5066 - x * 26.8183))));
+  return vec3(r, g, b);
+}
+`, a = n, v = e, d = t, m = c, f = o, x = r, l = i, p = s;
+export {
+  a as depth,
+  v as generators,
+  d as math,
+  m as packing,
+  f as poissonDisk,
+  x as raySphereIntersection,
+  l as transform,
+  p as turbo
+};
+//# sourceMappingURL=shaders.js.map

package/build/shaders.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"shaders.js","sources":["../src/shaders/depth.glsl?raw","../src/shaders/generators.glsl?raw","../src/shaders/math.glsl?raw","../src/shaders/packing.glsl?raw","../src/shaders/poissonDisk.glsl?raw","../src/shaders/raySphereIntersection.glsl?raw","../src/shaders/transform.glsl?raw","../src/shaders/turbo.glsl?raw","../src/shaders/index.ts"],"sourcesContent":null,"names":["_depth","_generators","_math","_packing","_poissonDisk","_raySphereIntersection","_transform","_turbo","depth","generators","math","packing","poissonDisk","raySphereIntersection","transform","turbo"],"mappings":"AAAA,MAAeA,IAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,GCAAC,IAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,GCAAC,IAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,GCAAC,IAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,GCAAC,IAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,GCAAC,IAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,GCAAC,IAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,GCAAC,IAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,GCSFC,IAAgBR,GAChBS,IAAqBR,GACrBS,IAAeR,GACfS,IAAkBR,GAClBS,IAAsBR,GACtBS,IAAgCR,GAChCS,IAAoBR,GACpBS,IAAgBR;"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@takram/three-geospatial",
-  "version": "0.0.1-alpha.4",
+  "version": "0.0.1-alpha.6",
   "license": "MIT",
   "type": "module",
   "exports": {
@@ -13,6 +13,11 @@
       "import": "./build/r3f.js",
       "require": "./build/r3f.cjs",
       "types": "./types/r3f/index.d.ts"
+    },
+    "./shaders": {
+      "import": "./build/shaders.js",
+      "require": "./build/shaders.cjs",
+      "types": "./types/shaders/index.d.ts"
     }
   },
   "main": "./build/index.cjs",
@@ -26,10 +31,9 @@
     "README.md"
   ],
   "dependencies": {
-    "lodash-es": "^4.17.21",
     "react-merge-refs": "^2.1.1",
     "tiny-invariant": "^1.3.3",
-    "type-fest": "^4.28.0"
+    "type-fest": "^4.33.0"
   },
   "peerDependencies": {
     "@react-three/fiber": ">=8.17.10",

package/src/DataLoader.ts

@@ -1,4 +1,5 @@
 import {
+  ByteType,
   ClampToEdgeWrapping,
   Data3DTexture,
   DataTexture,
@@ -6,31 +7,45 @@ import {
   LinearFilter,
   Loader,
   RGBAFormat,
-  type Texture,
+  UnsignedByteType,
   type TypedArray
 } from 'three'
-import { type Class } from 'type-fest'
+import { type Class, type WritableKeysOf } from 'type-fest'
 
+import { getTypedArrayElementType } from './typedArray'
 import {
-  Float32ArrayLoader,
-  Int16ArrayLoader,
-  Uint16ArrayLoader,
+  createTypedArrayLoaderClass,
   type TypedArrayLoader
 } from './TypedArrayLoader'
+import {
+  parseFloat32Array,
+  parseInt16Array,
+  parseUint16Array,
+  type TypedArrayParser
+} from './typedArrayParsers'
 import { type Callable } from './types'
 
-export interface ImageSize {
-  width: number
-  height: number
-  depth?: number
+// TODO: Move to types
+type ParameterProperties<T> = {
+  [K in WritableKeysOf<T> as T[K] extends Callable ? never : K]: T[K]
 }
 
 export type DataTextureParameters = Omit<
-  Partial<{
-    [K in keyof Texture as Texture[K] extends Callable ? never : K]: Texture[K]
-  }>,
+  Partial<ParameterProperties<DataTexture>>,
   'image'
->
+> & {
+  width?: number
+  height?: number
+}
+
+export type Data3DTextureParameters = Omit<
+  Partial<ParameterProperties<Data3DTexture>>,
+  'image'
+> & {
+  width?: number
+  height?: number
+  depth?: number
+}
 
 const defaultDataTextureParameter = {
   format: RGBAFormat,
@@ -38,16 +53,16 @@ const defaultDataTextureParameter = {
   wrapT: ClampToEdgeWrapping,
   minFilter: LinearFilter,
   magFilter: LinearFilter
-} satisfies DataTextureParameters
+} satisfies DataTextureParameters & Data3DTextureParameters
 
 export abstract class DataLoader<
-  T extends DataTexture | Data3DTexture,
-  U extends TypedArray
+  T extends DataTexture | Data3DTexture = DataTexture | Data3DTexture,
+  U extends TypedArray = TypedArray
 > extends Loader<T> {
   abstract readonly Texture: Class<T>
   abstract readonly TypedArrayLoader: Class<TypedArrayLoader<U>>
 
-  readonly parameters?: DataTextureParameters
+  readonly parameters: DataTextureParameters & Data3DTextureParameters = {}
 
   override load(
     url: string,
@@ -64,7 +79,27 @@ export abstract class DataLoader<
       url,
       array => {
         texture.image.data = array as typeof texture.image.data
-        Object.assign(texture, this.parameters)
+        const { width, height, depth, ...params } = this.parameters
+        if (width != null) {
+          texture.image.width = width
+        }
+        if (height != null) {
+          texture.image.height = height
+        }
+        if ('depth' in texture.image && depth != null) {
+          texture.image.depth = depth
+        }
+
+        // Populate the default texture type for the array type.
+        const type = getTypedArrayElementType(array)
+        texture.type =
+          type === 'uint8'
+            ? UnsignedByteType
+            : type === 'int8'
+              ? ByteType
+              : FloatType
+
+        Object.assign(texture, params)
         texture.needsUpdate = true
         onLoad(texture)
       },
@@ -74,41 +109,64 @@ export abstract class DataLoader<
   }
 }
 
-export class Int16Data2DLoader extends DataLoader<DataTexture, Int16Array> {
-  readonly Texture = DataTexture
-  readonly TypedArrayLoader = Int16ArrayLoader
-  readonly parameters = {
-    ...defaultDataTextureParameter,
-    type: FloatType
-  } satisfies DataTextureParameters
+function createDataLoaderClass<
+  T extends DataTexture | Data3DTexture,
+  U extends TypedArray
+>(
+  Texture: Class<T>,
+  parser: TypedArrayParser<U>,
+  parameters?: DataTextureParameters
+): Class<DataLoader<T, U>> {
+  return class extends DataLoader<T, U> {
+    readonly Texture = Texture
+    readonly TypedArrayLoader = createTypedArrayLoaderClass(parser)
+    readonly parameters = {
+      ...defaultDataTextureParameter,
+      ...parameters
+    }
+  }
 }
 
-export class Uint16Data2DLoader extends DataLoader<DataTexture, Uint16Array> {
-  readonly Texture = DataTexture
-  readonly TypedArrayLoader = Uint16ArrayLoader
-  readonly parameters = {
-    ...defaultDataTextureParameter,
-    type: FloatType
-  } satisfies DataTextureParameters
+export function createData3DTextureLoaderClass<T extends TypedArray>(
+  parser: TypedArrayParser<T>,
+  parameters?: Data3DTextureParameters
+): Class<DataLoader<Data3DTexture, T>> {
+  return createDataLoaderClass(Data3DTexture, parser, parameters)
 }
 
-export class Float32Data2DLoader extends DataLoader<DataTexture, Float32Array> {
-  readonly Texture = DataTexture
-  readonly TypedArrayLoader = Float32ArrayLoader
-  readonly parameters = {
-    ...defaultDataTextureParameter,
-    type: FloatType
-  } satisfies DataTextureParameters
+export function createDataTextureLoaderClass<T extends TypedArray>(
+  parser: TypedArrayParser<T>,
+  parameters?: DataTextureParameters
+): Class<DataLoader<DataTexture, T>> {
+  return createDataLoaderClass(DataTexture, parser, parameters)
 }
 
-export class Float32Data3DLoader extends DataLoader<
-  Data3DTexture,
-  Float32Array
-> {
-  readonly Texture = Data3DTexture
-  readonly TypedArrayLoader = Float32ArrayLoader
-  readonly parameters = {
-    ...defaultDataTextureParameter,
-    type: FloatType
-  } satisfies DataTextureParameters
+export function createData3DTextureLoader<T extends TypedArray>(
+  parser: TypedArrayParser<T>,
+  parameters?: Data3DTextureParameters
+): DataLoader<Data3DTexture, T> {
+  return new (createData3DTextureLoaderClass(parser, parameters))()
+}
+
+export function createDataTextureLoader<T extends TypedArray>(
+  parser: TypedArrayParser<T>,
+  parameters?: DataTextureParameters
+): DataLoader<DataTexture, T> {
+  return new (createDataTextureLoaderClass(parser, parameters))()
 }
+
+/** @deprecated Use createDataTextureLoaderClass instead. */
+export const Int16Data2DLoader =
+  /*#__PURE__*/ createDataTextureLoaderClass(parseInt16Array)
+
+/** @deprecated Use createDataTextureLoaderClass instead. */
+export const Uint16Data2DLoader =
+  /*#__PURE__*/ createDataTextureLoaderClass(parseUint16Array)
+
+/** @deprecated Use createDataTextureLoaderClass instead. */
+export const Float32Data2DLoader =
+  /*#__PURE__*/ createDataTextureLoaderClass(parseFloat32Array)
+
+/** @deprecated Use createData3DTextureLoaderClass instead. */
+export const Float32Data3DLoader =
+  /*#__PURE__*/ createData3DTextureLoaderClass(parseFloat32Array)

package/src/Texture3DLoader.ts

@@ -0,0 +1,81 @@
+import {
+  Data3DTexture,
+  ImageLoader,
+  LinearFilter,
+  Loader,
+  RepeatWrapping
+} from 'three'
+
+export class Texture3DLoader extends Loader<Data3DTexture> {
+  override load(
+    url: string,
+    onLoad: (data: Data3DTexture) => void,
+    onProgress?: (event: ProgressEvent) => void,
+    onError?: (error: unknown) => void
+  ): void {
+    const loader = new ImageLoader(this.manager)
+    loader.setRequestHeader(this.requestHeader)
+    loader.setPath(this.path)
+    loader.setWithCredentials(this.withCredentials)
+    loader.load(
+      url,
+      image => {
+        const canvas = document.createElement('canvas')
+        const context = canvas.getContext('2d')
+        if (context == null) {
+          onError?.(new Error('Could not obtain canvas context.'))
+          return
+        }
+
+        // Assume cubic 3D texture.
+        const { width, height } = image
+        const size = Math.min(width, height)
+        canvas.width = width
+        canvas.height = height
+        context.drawImage(image, 0, 0)
+        const imageData = context.getImageData(0, 0, width, height).data
+        let data: Uint8Array
+
+        if (width < height) {
+          data = new Uint8Array(imageData.buffer)
+        } else {
+          data = new Uint8Array(imageData.length)
+          const sizeSq = size ** 2
+          for (let z = 0; z < size; ++z) {
+            for (let y = 0; y < size; ++y) {
+              for (let x = 0; x < size; ++x) {
+                const src = (x + z * size + y * sizeSq) * 4
+                const dest = (x + y * size + z * sizeSq) * 4
+                data[dest + 0] = imageData[src + 0]
+                data[dest + 1] = imageData[src + 1]
+                data[dest + 2] = imageData[src + 2]
+                data[dest + 3] = imageData[src + 3]
+              }
+            }
+          }
+        }
+
+        const texture = new Data3DTexture(data, size, size, size)
+        texture.minFilter = LinearFilter
+        texture.magFilter = LinearFilter
+        texture.wrapS = RepeatWrapping
+        texture.wrapR = RepeatWrapping
+        texture.wrapT = RepeatWrapping
+        texture.needsUpdate = true
+
+        try {
+          onLoad(texture)
+        } catch (error) {
+          if (onError != null) {
+            onError(error)
+          } else {
+            console.error(error)
+          }
+          this.manager.itemError(url)
+        }
+      },
+      onProgress,
+      onError
+    )
+  }
+}

package/src/TypedArrayLoader.ts

@@ -1,11 +1,13 @@
 import { Loader, type TypedArray } from 'three'
+import { type Class } from 'type-fest'
 
 import { ArrayBufferLoader } from './ArrayBufferLoader'
 import {
   parseFloat32Array,
   parseInt16Array,
-  parseUint16Array
-} from './typedArray'
+  parseUint16Array,
+  type TypedArrayParser
+} from './typedArrayParsers'
 
 export abstract class TypedArrayLoader<T extends TypedArray> extends Loader<T> {
   abstract parseTypedArray(buffer: ArrayBuffer): T
@@ -40,14 +42,28 @@ export abstract class TypedArrayLoader<T extends TypedArray> extends Loader<T> {
   }
 }
 
-export class Int16ArrayLoader extends TypedArrayLoader<Int16Array> {
-  readonly parseTypedArray = parseInt16Array
+export function createTypedArrayLoaderClass<T extends TypedArray>(
+  parser: TypedArrayParser<T>
+): Class<TypedArrayLoader<T>> {
+  return class extends TypedArrayLoader<T> {
+    readonly parseTypedArray = parser
+  }
 }
 
-export class Uint16ArrayLoader extends TypedArrayLoader<Uint16Array> {
-  readonly parseTypedArray = parseUint16Array
+export function createTypedArrayLoader<T extends TypedArray>(
+  parser: TypedArrayParser<T>
+): TypedArrayLoader<T> {
+  return new (createTypedArrayLoaderClass(parser))()
 }
 
-export class Float32ArrayLoader extends TypedArrayLoader<Float32Array> {
-  readonly parseTypedArray = parseFloat32Array
-}
+/** @deprecated Use createTypedArrayLoaderClass instead. */
+export const Int16ArrayLoader =
+  /*#__PURE__*/ createTypedArrayLoaderClass(parseInt16Array)
+
+/** @deprecated Use createTypedArrayLoaderClass instead. */
+export const Uint16ArrayLoader =
+  /*#__PURE__*/ createTypedArrayLoaderClass(parseUint16Array)
+
+/** @deprecated Use createTypedArrayLoaderClass instead. */
+export const Float32ArrayLoader =
+  /*#__PURE__*/ createTypedArrayLoaderClass(parseFloat32Array)

package/src/bufferGeometry.ts

@@ -1,4 +1,3 @@
-import { pick } from 'lodash-es'
 import { Box3, BufferAttribute, BufferGeometry, Sphere, Vector3 } from 'three'
 
 export type BufferGeometryLike = Pick<
@@ -9,8 +8,9 @@ export type BufferGeometryLike = Pick<
 export function toBufferGeometryLike(
   geometry: BufferGeometry
 ): [BufferGeometryLike, ArrayBuffer[]] {
+  const { attributes, index, boundingBox, boundingSphere } = geometry
   return [
-    pick(geometry, ['attributes', 'index', 'boundingBox', 'boundingSphere']),
+    { attributes, index, boundingBox, boundingSphere },
     [
       ...Object.values(geometry.attributes).map(
         attribute => attribute.array.buffer

package/src/constants.ts

@@ -0,0 +1,3 @@
+export const STBN_TEXTURE_WIDTH = 128
+export const STBN_TEXTURE_HEIGHT = 128
+export const STBN_TEXTURE_DEPTH = 64