@takram/three-geospatial 0.0.1-alpha.5 → 0.0.1-alpha.7

package/build/shaders.js

@@ -0,0 +1,408 @@
+const n = `// Reference: https://github.com/mrdoob/three.js/blob/r171/examples/jsm/csm/CSMShader.js
+
+#ifndef SHADOW_CASCADE_COUNT
+#error "SHADOW_CASCADE_COUNT macro must be defined."
+#endif // SHADOW_CASCADE_COUNT
+
+int getCascadeIndex(
+  const mat4 viewMatrix,
+  const vec3 worldPosition,
+  const vec2 intervals[SHADOW_CASCADE_COUNT],
+  const float near,
+  const float far
+) {
+  vec4 viewPosition = viewMatrix * vec4(worldPosition, 1.0);
+  float depth = viewZToOrthographicDepth(viewPosition.z, near, far);
+  vec2 interval;
+  #pragma unroll_loop_start
+  for (int i = 0; i < 4; ++i) {
+    #if UNROLLED_LOOP_INDEX < SHADOW_CASCADE_COUNT
+    interval = intervals[i];
+    if (depth >= interval.x && depth < interval.y) {
+      return UNROLLED_LOOP_INDEX;
+    }
+    #endif // UNROLLED_LOOP_INDEX < SHADOW_CASCADE_COUNT
+  }
+  #pragma unroll_loop_end
+  return SHADOW_CASCADE_COUNT - 1;
+}
+
+int getFadedCascadeIndex(
+  const mat4 viewMatrix,
+  const vec3 worldPosition,
+  const vec2 intervals[SHADOW_CASCADE_COUNT],
+  const float near,
+  const float far,
+  const float jitter
+) {
+  vec4 viewPosition = viewMatrix * vec4(worldPosition, 1.0);
+  float depth = viewZToOrthographicDepth(viewPosition.z, near, far);
+
+  vec2 interval;
+  float intervalCenter;
+  float closestEdge;
+  float margin;
+  int nextIndex = -1;
+  int prevIndex = -1;
+  float alpha;
+
+  #pragma unroll_loop_start
+  for (int i = 0; i < 4; ++i) {
+    #if UNROLLED_LOOP_INDEX < SHADOW_CASCADE_COUNT
+    interval = intervals[i];
+    intervalCenter = (interval.x + interval.y) * 0.5;
+    closestEdge = depth < intervalCenter ? interval.x : interval.y;
+    margin = closestEdge * closestEdge * 0.5;
+    interval += margin * vec2(-0.5, 0.5);
+
+    #if UNROLLED_LOOP_INDEX < SHADOW_CASCADE_COUNT - 1
+    if (depth >= interval.x && depth < interval.y) {
+      prevIndex = nextIndex;
+      nextIndex = UNROLLED_LOOP_INDEX;
+      alpha = saturate(min(depth - interval.x, interval.y - depth) / margin);
+    }
+    #else // UNROLLED_LOOP_INDEX < SHADOW_CASCADE_COUNT - 1
+    // Don't fade out the last cascade.
+    if (depth >= interval.x) {
+      prevIndex = nextIndex;
+      nextIndex = UNROLLED_LOOP_INDEX;
+      alpha = saturate((depth - interval.x) / margin);
+    }
+    #endif // UNROLLED_LOOP_INDEX < SHADOW_CASCADE_COUNT - 1
+    #endif // UNROLLED_LOOP_INDEX < SHADOW_CASCADE_COUNT
+  }
+  #pragma unroll_loop_end
+
+  return jitter <= alpha
+    ? nextIndex
+    : prevIndex;
+}
+`, e = `// 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));
+}
+`, t = `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));
+}
+`, c = `#if !defined(saturate)
+#define saturate(a) clamp(a, 0.0, 1.0)
+#endif // !defined(saturate)
+
+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);
+}
+
+float remapClamped(
+  const float x,
+  const float min1,
+  const float max1,
+  const float min2,
+  const float max2
+) {
+  return clamp(min2 + (x - min1) / (max1 - min1) * (max2 - min2), min2, max2);
+}
+
+vec2 remapClamped(
+  const vec2 x,
+  const vec2 min1,
+  const vec2 max1,
+  const vec2 min2,
+  const vec2 max2
+) {
+  return clamp(min2 + (x - min1) / (max1 - min1) * (max2 - min2), min2, max2);
+}
+
+vec3 remapClamped(
+  const vec3 x,
+  const vec3 min1,
+  const vec3 max1,
+  const vec3 min2,
+  const vec3 max2
+) {
+  return clamp(min2 + (x - min1) / (max1 - min1) * (max2 - min2), min2, max2);
+}
+
+vec4 remapClamped(
+  const vec4 x,
+  const vec4 min1,
+  const vec4 max1,
+  const vec4 min2,
+  const vec4 max2
+) {
+  return clamp(min2 + (x - min1) / (max1 - min1) * (max2 - min2), min2, max2);
+}
+
+// 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);
+}
+
+float remapClamped(const float x, const float min1, const float max1) {
+  return saturate((x - min1) / (max1 - min1));
+}
+
+vec2 remapClamped(const vec2 x, const vec2 min1, const vec2 max1) {
+  return saturate((x - min1) / (max1 - min1));
+}
+
+vec3 remapClamped(const vec3 x, const vec3 min1, const vec3 max1) {
+  return saturate((x - min1) / (max1 - min1));
+}
+
+vec4 remapClamped(const vec4 x, const vec4 min1, const vec4 max1) {
+  return saturate((x - min1) / (max1 - min1));
+}
+`, i = `// 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 = `// TODO: Maybe switch to Vogel disk with IGN:
+// https://www.gamedev.net/tutorials/programming/graphics/contact-hardening-soft-shadows-made-fast-r4906/
+// 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);
+}
+`, a = `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);
+}
+`, v = n, m = e, d = t, l = c, x = i, p = o, f = r, u = a, h = s;
+export {
+  v as cascadedShadowMaps,
+  m as depth,
+  d as generators,
+  l as math,
+  x as packing,
+  p as poissonDisk,
+  f as raySphereIntersection,
+  u as transform,
+  h as turbo
+};
+//# sourceMappingURL=shaders.js.map

package/build/shaders.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"shaders.js","sources":["../src/shaders/cascadedShadowMaps.glsl?raw","../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":["_cascadedShadowMaps","_depth","_generators","_math","_packing","_poissonDisk","_raySphereIntersection","_transform","_turbo","cascadedShadowMaps","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;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;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;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;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,GCUFC,IAA6BT,GAC7BU,IAAgBT,GAChBU,IAAqBT,GACrBU,IAAeT,GACfU,IAAkBT,GAClBU,IAAsBT,GACtBU,IAAgCT,GAChCU,IAAoBT,GACpBU,IAAgBT;"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@takram/three-geospatial",
-  "version": "0.0.1-alpha.5",
+  "version": "0.0.1-alpha.7",
   "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.32.0"
+    "type-fest": "^4.33.0"
   },
   "peerDependencies": {
     "@react-three/fiber": ">=8.17.10",

package/src/DataLoader.ts

@@ -25,6 +25,7 @@ import {
 } from './typedArrayParsers'
 import { type Callable } from './types'
 
+// TODO: Move to types
 type ParameterProperties<T> = {
   [K in WritableKeysOf<T> as T[K] extends Callable ? never : K]: T[K]
 }

package/src/STBNLoader.ts

@@ -0,0 +1,21 @@
+import { NearestFilter, RedFormat, RepeatWrapping } from 'three'
+
+import {
+  STBN_TEXTURE_DEPTH,
+  STBN_TEXTURE_HEIGHT,
+  STBN_TEXTURE_WIDTH
+} from './constants'
+import { createData3DTextureLoaderClass } from './DataLoader'
+import { parseUint8Array } from './typedArrayParsers'
+
+export const STBNLoader = createData3DTextureLoaderClass(parseUint8Array, {
+  format: RedFormat,
+  minFilter: NearestFilter,
+  magFilter: NearestFilter,
+  wrapS: RepeatWrapping,
+  wrapT: RepeatWrapping,
+  wrapR: RepeatWrapping,
+  width: STBN_TEXTURE_WIDTH,
+  height: STBN_TEXTURE_HEIGHT,
+  depth: STBN_TEXTURE_DEPTH
+})

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/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,6 @@
+export const STBN_TEXTURE_WIDTH = 128
+export const STBN_TEXTURE_HEIGHT = 128
+export const STBN_TEXTURE_DEPTH = 64
+
+export const DEFAULT_STBN_URL =
+  'https://media.githubusercontent.com/media/takram-design-engineering/three-geospatial/9627216cc50057994c98a2118f3c4a23765d43b9/packages/core/assets/stbn.bin'

package/src/defineShorthand.ts

@@ -0,0 +1,68 @@
+import { type Uniform } from 'three'
+
+// TODO: Make mutable value types (e.g. vectors, matrices) read-only.
+
+// Maps argument of type [T1, K1[], T2, K2[], ...] to:
+// { [K in K1]: T1[K],
+//   [K in K2]: T2[K], ... }
+export type PropertyShorthand<Args extends readonly unknown[]> =
+  Args extends readonly [infer T, infer K, ...infer Rest]
+    ? K extends readonly string[]
+      ? K[number] extends keyof T
+        ? Rest extends readonly unknown[]
+          ? { [P in K[number]]: T[P] } & PropertyShorthand<Rest>
+          : { [P in K[number]]: T[P] }
+        : never // K must be keyof T
+      : never // K must be an array
+    : {} // Termination
+
+export function definePropertyShorthand<T, Args extends readonly unknown[]>(
+  destination: T,
+  ...sourceKeysArgs: [...Args]
+): T & PropertyShorthand<Args> {
+  const descriptors: PropertyDescriptorMap = {}
+  for (let i = 0; i < sourceKeysArgs.length; i += 2) {
+    const source = sourceKeysArgs[i]
+    const keys = sourceKeysArgs[i + 1] as ReadonlyArray<keyof typeof source>
+    for (const key of keys) {
+      descriptors[key] = {
+        enumerable: true,
+        get: () => source[key],
+        set: (value: any) => {
+          source[key] = value
+        }
+      }
+    }
+  }
+  Object.defineProperties(destination, descriptors)
+  return destination as T & PropertyShorthand<Args>
+}
+
+// The argument of defineUniformShorthand can also be variadic, but I can't
+// think of any practical use cases for it.
+
+export type UniformShorthand<
+  T extends { uniforms: Record<K, Uniform> },
+  K extends keyof T['uniforms']
+> = {
+  [P in K]: T['uniforms'][P] extends Uniform<infer U> ? U : never
+}
+
+export function defineUniformShorthand<
+  T,
+  S extends { uniforms: Record<K, Uniform> },
+  K extends keyof S['uniforms']
+>(destination: T, source: S, keys: readonly K[]): T & UniformShorthand<S, K> {
+  const descriptors: PropertyDescriptorMap = {}
+  for (const key of keys) {
+    descriptors[key] = {
+      enumerable: true,
+      get: () => source.uniforms[key].value,
+      set: (value: S['uniforms'][K]) => {
+        source.uniforms[key].value = value
+      }
+    }
+  }
+  Object.defineProperties(destination, descriptors)
+  return destination as T & UniformShorthand<S, K>
+}

package/src/index.ts

@@ -1,26 +1,21 @@
-/// <reference types="vite-plugin-glsl/ext" />
-
-import depth from './shaders/depth.glsl'
-import packing from './shaders/packing.glsl'
-import transform from './shaders/transform.glsl'
-
-export const depthShader: string = depth
-export const packingShader: string = packing
-export const transformShader: string = transform
-
 export * from './ArrayBufferLoader'
 export * from './assertions'
 export * from './bufferGeometry'
+export * from './constants'
 export * from './DataLoader'
+export * from './defineShorthand'
 export * from './Ellipsoid'
 export * from './EllipsoidGeometry'
 export * from './Geodetic'
 export * from './math'
 export * from './PointOfView'
 export * from './Rectangle'
+export * from './resolveIncludes'
+export * from './STBNLoader'
 export * from './TileCoordinate'
 export * from './TilingScheme'
 export * from './typedArray'
 export * from './TypedArrayLoader'
 export * from './typedArrayParsers'
 export * from './types'
+export * from './unrollLoops'