@takram/three-geospatial 0.0.1-alpha.5 → 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.5",
+  "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.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/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,3 @@
+export const STBN_TEXTURE_WIDTH = 128
+export const STBN_TEXTURE_HEIGHT = 128
+export const STBN_TEXTURE_DEPTH = 64

package/src/index.ts

@@ -1,16 +1,7 @@
-/// <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 './Ellipsoid'
 export * from './EllipsoidGeometry'
@@ -18,9 +9,11 @@ export * from './Geodetic'
 export * from './math'
 export * from './PointOfView'
 export * from './Rectangle'
+export * from './resolveIncludes'
 export * from './TileCoordinate'
 export * from './TilingScheme'
 export * from './typedArray'
 export * from './TypedArrayLoader'
 export * from './typedArrayParsers'
 export * from './types'
+export * from './unrollLoops'

package/src/r3f/index.ts

@@ -1,2 +1,3 @@
 export * from './EastNorthUpFrame'
 export * from './EllipsoidMesh'
+export * from './types'

package/src/r3f/types.ts

@@ -0,0 +1,64 @@
+import {
+  type Color,
+  type ExtendedColors,
+  type NodeProps,
+  type Overwrite,
+  type Vector2,
+  type Vector3,
+  type Vector4
+} from '@react-three/fiber'
+import {
+  type Vector2 as Vector2Impl,
+  type Vector3 as Vector3Impl,
+  type Vector4 as Vector4Impl
+} from 'three'
+import { type WritableKeysOf } from 'type-fest'
+
+import { type Callable } from '../types'
+
+// prettier-ignore
+export type ExtendedVectors<T> = {
+  [K in keyof T]:
+    Vector2Impl extends T[K] ? Vector2 | T[K] :
+    Vector3Impl extends T[K] ? Vector3 | T[K] :
+    Vector4Impl extends T[K] ? Vector4 | T[K] :
+    T[K]
+}
+
+export type ExtendedProps<T> = ExtendedColors<ExtendedVectors<T>>
+
+// @react-three/fiber's NonFunctionKeys cannot exclude partial functions.
+// This excludes callback properties, which may be undesirable behavior.
+type NonFunctionKeys<T> = keyof {
+  [K in keyof T as Callable extends T[K] ? never : K]: any
+}
+
+// prettier-ignore
+type WritableNonExtendableKeysOf<T> =
+  | WritableKeysOf<T>
+  | keyof {
+      [K in keyof T as
+        Vector2Impl extends T[K] ? K :
+        Vector3Impl extends T[K] ? K :
+        Vector4Impl extends T[K] ? K :
+        Color extends T[K] ? K :
+        never
+      ]: any
+    }
+
+export type PassThoughInstanceProps<
+  RefType,
+  Args extends readonly any[],
+  Props
+> = Overwrite<
+  ExtendedProps<{
+    [K in NonFunctionKeys<Props> as K extends WritableNonExtendableKeysOf<Props>
+      ? K
+      : never]: Props[K]
+  }>,
+  NodeProps<RefType, Args>
+>
+
+export type ExpandNestedProps<T, Prop extends keyof T & string> = {
+  [K in keyof T[Prop] as K extends string ? `${Prop}-${K}` : never]: T[Prop][K]
+}

package/src/resolveIncludes.test.ts

@@ -0,0 +1,21 @@
+import { resolveIncludes } from './resolveIncludes'
+
+describe('resolveIncludes', () => {
+  test('delimited paths', () => {
+    expect(
+      resolveIncludes('#include "scope/lib"', {
+        scope: {
+          lib: 'imported'
+        }
+      })
+    ).toBe('imported')
+
+    expect(() =>
+      resolveIncludes('#include "scope/lib"', {
+        other: {
+          lib: 'imported'
+        }
+      })
+    ).toThrow()
+  })
+})

package/src/resolveIncludes.ts

@@ -0,0 +1,22 @@
+const includePattern = /^[ \t]*#include +"([\w\d./]+)"/gm
+
+interface Includes {
+  [key: string]: string | Includes
+}
+
+export function resolveIncludes(source: string, includes: Includes): string {
+  return source.replace(includePattern, (match, path: string) => {
+    const components = path.split('/')
+    const include = components.reduce<string | Includes | undefined>(
+      (parent, component) =>
+        typeof parent !== 'string' && parent != null
+          ? parent[component]
+          : undefined,
+      includes
+    )
+    if (typeof include !== 'string') {
+      throw new Error(`Could not find include for ${path}.`)
+    }
+    return resolveIncludes(include, includes)
+  })
+}

package/src/shaders/depth.glsl

@@ -1,10 +1,12 @@
+// 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
+  #else // USE_LOGDEPTHBUF
   return depth;
   #endif // USE_LOGDEPTHBUF
 }

package/src/shaders/generators.glsl

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

package/src/shaders/index.ts

@@ -0,0 +1,17 @@
+import _depth from './depth.glsl?raw'
+import _generators from './generators.glsl?raw'
+import _math from './math.glsl?raw'
+import _packing from './packing.glsl?raw'
+import _poissonDisk from './poissonDisk.glsl?raw'
+import _raySphereIntersection from './raySphereIntersection.glsl?raw'
+import _transform from './transform.glsl?raw'
+import _turbo from './turbo.glsl?raw'
+
+export const depth: string = _depth
+export const generators: string = _generators
+export const math: string = _math
+export const packing: string = _packing
+export const poissonDisk: string = _poissonDisk
+export const raySphereIntersection: string = _raySphereIntersection
+export const transform: string = _transform
+export const turbo: string = _turbo

package/src/shaders/math.glsl

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