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

package/src/math.ts

@@ -10,7 +10,42 @@ export const isPowerOfTwo = MathUtils.isPowerOfTwo
 export const ceilPowerOfTwo = MathUtils.ceilPowerOfTwo
 export const floorPowerOfTwo = MathUtils.floorPowerOfTwo
 export const normalize = MathUtils.normalize
-export const remap = MathUtils.mapLinear
+
+export function remap(x: number, min1: number, max1: number): number
+export function remap(
+  x: number,
+  min1: number,
+  max1: number,
+  min2: number,
+  max2: number
+): number
+export function remap(
+  x: number,
+  min1: number,
+  max1: number,
+  min2 = 0,
+  max2 = 1
+): number {
+  return MathUtils.mapLinear(x, min1, max1, min2, max2)
+}
+
+export function remapClamped(x: number, min1: number, max1: number): number
+export function remapClamped(
+  x: number,
+  min1: number,
+  max1: number,
+  min2: number,
+  max2: number
+): number
+export function remapClamped(
+  x: number,
+  min1: number,
+  max1: number,
+  min2 = 0,
+  max2 = 1
+): number {
+  return clamp(MathUtils.mapLinear(x, min1, max1, min2, max2), min2, max2)
+}
 
 // Prefer glsl's argument order which differs from that of MathUtils.
 export function smoothstep(min: number, max: number, x: number): number {

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,63 @@
+import {
+  type NodeProps,
+  type Overwrite,
+  type Color as R3FColor,
+  type Vector2 as R3FVector2,
+  type Vector3 as R3FVector3,
+  type Vector4 as R3FVector4
+} from '@react-three/fiber'
+import {
+  type Color as ColorImpl,
+  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 ExtendedProps<T> = {
+  [K in keyof T]:
+    Vector2Impl extends T[K] ? R3FVector2 | T[K] :
+    Vector3Impl extends T[K] ? R3FVector3 | T[K] :
+    Vector4Impl extends T[K] ? R3FVector4 | T[K] :
+    ColorImpl extends T[K] ? R3FColor | T[K] :
+    T[K]
+}
+
+// @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 :
+        ColorImpl 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/cascadedShadowMaps.glsl

@@ -0,0 +1,79 @@
+// 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;
+}

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,19 @@
+import _cascadedShadowMaps from './cascadedShadowMaps.glsl?raw'
+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 cascadedShadowMaps: string = _cascadedShadowMaps
+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,92 @@
+#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));
+}

package/src/shaders/poissonDisk.glsl

@@ -0,0 +1,23 @@
+// 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)

package/src/shaders/raySphereIntersection.glsl

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

package/src/shaders/turbo.glsl

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

package/src/typedArrayParsers.ts

@@ -1,5 +1,17 @@
 import { type TypedArray, type TypedArrayConstructor } from './typedArray'
 
+let hostLittleEndian: boolean | undefined
+
+function isHostLittleEndian(): boolean {
+  if (hostLittleEndian != null) {
+    return hostLittleEndian
+  }
+  const a = new Uint32Array([0x10000000])
+  const b = new Uint8Array(a.buffer, a.byteOffset, a.byteLength)
+  hostLittleEndian = b[0] === 0
+  return hostLittleEndian
+}
+
 type GetValue = keyof {
   [K in keyof DataView as DataView[K] extends (byteOffset: number) => number
     ? K
@@ -19,6 +31,9 @@ function parseTypedArray<K extends GetValue>(
   getValue: K,
   littleEndian = true
 ): TypedArray {
+  if (littleEndian === isHostLittleEndian()) {
+    return new TypedArray(buffer)
+  }
   const data = new DataView(buffer)
   const array = new TypedArray(data.byteLength / TypedArray.BYTES_PER_ELEMENT)
   for (
@@ -36,15 +51,11 @@ export type TypedArrayParser<T extends TypedArray> = (
   littleEndian?: boolean
 ) => T
 
-export const parseUint8Array: TypedArrayParser<Uint8Array> = (
-  buffer,
-  littleEndian
-) => parseTypedArray(buffer, Uint8Array, 'getUint8', littleEndian)
+export const parseUint8Array: TypedArrayParser<Uint8Array> = buffer =>
+  new Uint8Array(buffer)
 
-export const parseInt8Array: TypedArrayParser<Int8Array> = (
-  buffer,
-  littleEndian
-) => parseTypedArray(buffer, Int8Array, 'getInt8', littleEndian)
+export const parseInt8Array: TypedArrayParser<Int8Array> = buffer =>
+  new Int8Array(buffer)
 
 export const parseUint16Array: TypedArrayParser<Uint16Array> = (
   buffer,

package/src/types.ts

@@ -1,54 +1,8 @@
-import {
-  type Matrix2,
-  type Matrix3,
-  type Matrix4,
-  type Vector2,
-  type Vector3,
-  type Vector4
-} from 'three'
-import { type ReadonlyTuple } from 'type-fest'
+import { type Uniform } from 'three'
 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 export type Callable = (...args: any) => any
 
-export type ReadonlyTuple2<T = number> = ReadonlyTuple<T, 2>
-export type ReadonlyTuple3<T = number> = ReadonlyTuple<T, 3>
-export type ReadonlyTuple4<T = number> = ReadonlyTuple<T, 4>
-
-// Non-readonly version of ReadonlyTuple. This is not type-safe because mutable
-// methods still exist in the type.
-// See https://github.com/sindresorhus/type-fest/blob/main/source/readonly-tuple.d.ts
-type BuildTupleHelper<
-  Element,
-  Length extends number,
-  Rest extends Element[]
-> = Rest['length'] extends Length
-  ? [...Rest]
-  : BuildTupleHelper<Element, Length, [Element, ...Rest]>
-
-export type Tuple<T, Length extends number> = number extends Length
-  ? readonly T[]
-  : BuildTupleHelper<T, Length, []>
-
-export type Tuple2<T = number> = BuildTupleHelper<T, 2, []>
-export type Tuple3<T = number> = BuildTupleHelper<T, 3, []>
-export type Tuple4<T = number> = BuildTupleHelper<T, 4, []>
-
-// Suppose return type of the mutable methods of classes like Vector3 is `this`.
-// TODO: How can we specify `this` as a constraint?
-type ReadonlyThreeInstance<T> = Readonly<{
-  [K in keyof T as T[K] extends Callable
-    ? ReturnType<T[K]> extends T
-      ? K extends 'clone'
-        ? K
-        : never
-      : K
-    : K]: T[K]
-}>
-
-export type ReadonlyVector2 = ReadonlyThreeInstance<Vector2>
-export type ReadonlyVector3 = ReadonlyThreeInstance<Vector3>
-export type ReadonlyVector4 = ReadonlyThreeInstance<Vector4>
-export type ReadonlyMatrix2 = ReadonlyThreeInstance<Matrix2>
-export type ReadonlyMatrix3 = ReadonlyThreeInstance<Matrix3>
-export type ReadonlyMatrix4 = ReadonlyThreeInstance<Matrix4>
+export type UniformMap<T> = Omit<Map<string, Uniform>, 'get'> & {
+  get: <K extends keyof T>(key: K) => T[K]
+  set: <K extends keyof T>(key: K, value: T[K]) => void
+}

package/src/unrollLoops.ts

@@ -0,0 +1,23 @@
+// Based on: https://github.com/mrdoob/three.js/blob/r170/src/renderers/webgl/WebGLProgram.js#L294
+
+const unrollLoopPattern =
+  /#pragma unroll_loop_start\s+for\s*\(\s*int\s+i\s*=\s*(\d+)\s*;\s*i\s*<\s*(\d+)\s*;\s*(?:i\s*\+\+|\+\+\s*i)\s*\)\s*{([\s\S]+?)}\s+#pragma unroll_loop_end/g
+
+function loopReplacer(
+  match: string,
+  start: string,
+  end: string,
+  snippet: string
+): string {
+  let string = ''
+  for (let i = parseInt(start); i < parseInt(end); ++i) {
+    string += snippet
+      .replace(/\[\s*i\s*\]/g, '[' + i + ']')
+      .replace(/UNROLLED_LOOP_INDEX/g, `${i}`)
+  }
+  return string
+}
+
+export function unrollLoops(string: string): string {
+  return string.replace(unrollLoopPattern, loopReplacer)
+}