@luma.gl/shadertools 9.3.0-alpha.6 → 9.3.0-alpha.9

package/dist/modules/math/fp64/fp64-arithmetic-wgsl.js

@@ -0,0 +1,212 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+export const fp64arithmeticWGSL = /* wgsl */ `\
+struct Fp64ArithmeticUniforms {
+  ONE: f32,
+  SPLIT: f32,
+};
+
+@group(0) @binding(auto) var<uniform> fp64arithmetic : Fp64ArithmeticUniforms;
+
+fn fp64_nan(seed: f32) -> f32 {
+  let nanBits = 0x7fc00000u | select(0u, 1u, seed < 0.0);
+  return bitcast<f32>(nanBits);
+}
+
+fn fp64_runtime_zero() -> f32 {
+  return fp64arithmetic.ONE * 0.0;
+}
+
+fn prevent_fp64_optimization(value: f32) -> f32 {
+#ifdef LUMA_FP64_CODE_ELIMINATION_WORKAROUND
+  return value + fp64_runtime_zero();
+#else
+  return value;
+#endif
+}
+
+fn split(a: f32) -> vec2f {
+  let splitValue = prevent_fp64_optimization(fp64arithmetic.SPLIT + fp64_runtime_zero());
+  let t = prevent_fp64_optimization(a * splitValue);
+  let temp = prevent_fp64_optimization(t - a);
+  let aHi = prevent_fp64_optimization(t - temp);
+  let aLo = prevent_fp64_optimization(a - aHi);
+  return vec2f(aHi, aLo);
+}
+
+fn split2(a: vec2f) -> vec2f {
+  var b = split(a.x);
+  b.y = b.y + a.y;
+  return b;
+}
+
+fn quickTwoSum(a: f32, b: f32) -> vec2f {
+#ifdef LUMA_FP64_CODE_ELIMINATION_WORKAROUND
+  let sum = prevent_fp64_optimization((a + b) * fp64arithmetic.ONE);
+  let err = prevent_fp64_optimization(b - (sum - a) * fp64arithmetic.ONE);
+#else
+  let sum = prevent_fp64_optimization(a + b);
+  let err = prevent_fp64_optimization(b - (sum - a));
+#endif
+  return vec2f(sum, err);
+}
+
+fn twoSum(a: f32, b: f32) -> vec2f {
+  let s = prevent_fp64_optimization(a + b);
+#ifdef LUMA_FP64_CODE_ELIMINATION_WORKAROUND
+  let v = prevent_fp64_optimization((s * fp64arithmetic.ONE - a) * fp64arithmetic.ONE);
+  let err =
+    prevent_fp64_optimization((a - (s - v) * fp64arithmetic.ONE) *
+      fp64arithmetic.ONE *
+      fp64arithmetic.ONE *
+      fp64arithmetic.ONE) +
+    prevent_fp64_optimization(b - v);
+#else
+  let v = prevent_fp64_optimization(s - a);
+  let err = prevent_fp64_optimization(a - (s - v)) + prevent_fp64_optimization(b - v);
+#endif
+  return vec2f(s, err);
+}
+
+fn twoSub(a: f32, b: f32) -> vec2f {
+  let s = prevent_fp64_optimization(a - b);
+#ifdef LUMA_FP64_CODE_ELIMINATION_WORKAROUND
+  let v = prevent_fp64_optimization((s * fp64arithmetic.ONE - a) * fp64arithmetic.ONE);
+  let err =
+    prevent_fp64_optimization((a - (s - v) * fp64arithmetic.ONE) *
+      fp64arithmetic.ONE *
+      fp64arithmetic.ONE *
+      fp64arithmetic.ONE) -
+    prevent_fp64_optimization(b + v);
+#else
+  let v = prevent_fp64_optimization(s - a);
+  let err = prevent_fp64_optimization(a - (s - v)) - prevent_fp64_optimization(b + v);
+#endif
+  return vec2f(s, err);
+}
+
+fn twoSqr(a: f32) -> vec2f {
+  let prod = prevent_fp64_optimization(a * a);
+  let aFp64 = split(a);
+  let highProduct = prevent_fp64_optimization(aFp64.x * aFp64.x);
+  let crossProduct = prevent_fp64_optimization(2.0 * aFp64.x * aFp64.y);
+  let lowProduct = prevent_fp64_optimization(aFp64.y * aFp64.y);
+#ifdef LUMA_FP64_CODE_ELIMINATION_WORKAROUND
+  let err =
+    (prevent_fp64_optimization(highProduct - prod) * fp64arithmetic.ONE +
+      crossProduct * fp64arithmetic.ONE * fp64arithmetic.ONE) +
+    lowProduct * fp64arithmetic.ONE * fp64arithmetic.ONE * fp64arithmetic.ONE;
+#else
+  let err = ((prevent_fp64_optimization(highProduct - prod) + crossProduct) + lowProduct);
+#endif
+  return vec2f(prod, err);
+}
+
+fn twoProd(a: f32, b: f32) -> vec2f {
+  let prod = prevent_fp64_optimization(a * b);
+  let aFp64 = split(a);
+  let bFp64 = split(b);
+  let highProduct = prevent_fp64_optimization(aFp64.x * bFp64.x);
+  let crossProduct1 = prevent_fp64_optimization(aFp64.x * bFp64.y);
+  let crossProduct2 = prevent_fp64_optimization(aFp64.y * bFp64.x);
+  let lowProduct = prevent_fp64_optimization(aFp64.y * bFp64.y);
+#ifdef LUMA_FP64_CODE_ELIMINATION_WORKAROUND
+  let err1 = (highProduct - prod) * fp64arithmetic.ONE;
+  let err2 = crossProduct1 * fp64arithmetic.ONE * fp64arithmetic.ONE;
+  let err3 = crossProduct2 * fp64arithmetic.ONE * fp64arithmetic.ONE * fp64arithmetic.ONE;
+  let err4 =
+    lowProduct *
+    fp64arithmetic.ONE *
+    fp64arithmetic.ONE *
+    fp64arithmetic.ONE *
+    fp64arithmetic.ONE;
+#else
+  let err1 = highProduct - prod;
+  let err2 = crossProduct1;
+  let err3 = crossProduct2;
+  let err4 = lowProduct;
+#endif
+  let err12InputA = prevent_fp64_optimization(err1);
+  let err12InputB = prevent_fp64_optimization(err2);
+  let err12 = prevent_fp64_optimization(err12InputA + err12InputB);
+  let err123InputA = prevent_fp64_optimization(err12);
+  let err123InputB = prevent_fp64_optimization(err3);
+  let err123 = prevent_fp64_optimization(err123InputA + err123InputB);
+  let err1234InputA = prevent_fp64_optimization(err123);
+  let err1234InputB = prevent_fp64_optimization(err4);
+  let err = prevent_fp64_optimization(err1234InputA + err1234InputB);
+  return vec2f(prod, err);
+}
+
+fn sum_fp64(a: vec2f, b: vec2f) -> vec2f {
+  var s = twoSum(a.x, b.x);
+  let t = twoSum(a.y, b.y);
+  s.y = prevent_fp64_optimization(s.y + t.x);
+  s = quickTwoSum(s.x, s.y);
+  s.y = prevent_fp64_optimization(s.y + t.y);
+  s = quickTwoSum(s.x, s.y);
+  return s;
+}
+
+fn sub_fp64(a: vec2f, b: vec2f) -> vec2f {
+  var s = twoSub(a.x, b.x);
+  let t = twoSub(a.y, b.y);
+  s.y = prevent_fp64_optimization(s.y + t.x);
+  s = quickTwoSum(s.x, s.y);
+  s.y = prevent_fp64_optimization(s.y + t.y);
+  s = quickTwoSum(s.x, s.y);
+  return s;
+}
+
+fn mul_fp64(a: vec2f, b: vec2f) -> vec2f {
+  var prod = twoProd(a.x, b.x);
+  let crossProduct1 = prevent_fp64_optimization(a.x * b.y);
+  prod.y = prevent_fp64_optimization(prod.y + crossProduct1);
+#ifdef LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND
+  prod = split2(prod);
+#endif
+  prod = quickTwoSum(prod.x, prod.y);
+  let crossProduct2 = prevent_fp64_optimization(a.y * b.x);
+  prod.y = prevent_fp64_optimization(prod.y + crossProduct2);
+#ifdef LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND
+  prod = split2(prod);
+#endif
+  prod = quickTwoSum(prod.x, prod.y);
+  return prod;
+}
+
+fn div_fp64(a: vec2f, b: vec2f) -> vec2f {
+  let xn = prevent_fp64_optimization(1.0 / b.x);
+  let yn = mul_fp64(a, vec2f(xn, fp64_runtime_zero()));
+  let diff = prevent_fp64_optimization(sub_fp64(a, mul_fp64(b, yn)).x);
+  let prod = twoProd(xn, diff);
+  return sum_fp64(yn, prod);
+}
+
+fn sqrt_fp64(a: vec2f) -> vec2f {
+  if (a.x == 0.0 && a.y == 0.0) {
+    return vec2f(0.0, 0.0);
+  }
+  if (a.x < 0.0) {
+    let nanValue = fp64_nan(a.x);
+    return vec2f(nanValue, nanValue);
+  }
+
+  let x = prevent_fp64_optimization(1.0 / sqrt(a.x));
+  let yn = prevent_fp64_optimization(a.x * x);
+#ifdef LUMA_FP64_CODE_ELIMINATION_WORKAROUND
+  let ynSqr = twoSqr(yn) * fp64arithmetic.ONE;
+#else
+  let ynSqr = twoSqr(yn);
+#endif
+  let diff = prevent_fp64_optimization(sub_fp64(a, ynSqr).x);
+  let prod = twoProd(prevent_fp64_optimization(x * 0.5), diff);
+#ifdef LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND
+  return sum_fp64(split(yn), prod);
+#else
+  return sum_fp64(vec2f(yn, 0.0), prod);
+#endif
+}
+`;
+//# sourceMappingURL=fp64-arithmetic-wgsl.js.map

package/dist/modules/math/fp64/fp64-arithmetic-wgsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fp64-arithmetic-wgsl.js","sourceRoot":"","sources":["../../../../src/modules/math/fp64/fp64-arithmetic-wgsl.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,oCAAoC;AAEpC,MAAM,CAAC,MAAM,kBAAkB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+M5C,CAAC"}

package/dist/modules/math/fp64/fp64.d.ts

@@ -3,6 +3,7 @@ import { fp64ify, fp64LowPart, fp64ifyMatrix4 } from "../../../modules/math/fp64
 type FP64Props = {};
 type FP64Uniforms = {
     ONE: number;
+    SPLIT: number;
 };
 type FP64Bindings = {};
 type FP64Utilities = {

package/dist/modules/math/fp64/fp64.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fp64.d.ts","sourceRoot":"","sources":["../../../../src/modules/math/fp64/fp64.ts"],"names":[],"mappings":"AAIA,OAAO,EAAC,YAAY,EAAC,oDAAiD;AAEtE,OAAO,EAAC,OAAO,EAAE,WAAW,EAAE,cAAc,EAAC,iDAA8C;AAI3F,KAAK,SAAS,GAAG,EAAE,CAAC;AACpB,KAAK,YAAY,GAAG;IAAC,GAAG,EAAE,MAAM,CAAA;CAAC,CAAC;AAClC,KAAK,YAAY,GAAG,EAAE,CAAC;AAEvB,KAAK,aAAa,GAAG;IACnB,OAAO,EAAE,OAAO,OAAO,CAAC;IACxB,WAAW,EAAE,OAAO,WAAW,CAAC;IAChC,cAAc,EAAE,OAAO,cAAc,CAAC;CACvC,CAAC;AAOF;;GAEG;AACH,eAAO,MAAM,cAAc,EAAE,YAAY,CAAC,SAAS,EAAE,YAAY,EAAE,YAAY,CAAC,GAAG,aAUlF,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,IAAI,EAAE,YAAY,CAAC,EAAE,CAAC,GAAG,aASrC,CAAC;AAEF,OAAO,EAAC,OAAO,EAAE,WAAW,EAAE,cAAc,EAAC,CAAC"}
+{"version":3,"file":"fp64.d.ts","sourceRoot":"","sources":["../../../../src/modules/math/fp64/fp64.ts"],"names":[],"mappings":"AAIA,OAAO,EAAC,YAAY,EAAC,oDAAiD;AAEtE,OAAO,EAAC,OAAO,EAAE,WAAW,EAAE,cAAc,EAAC,iDAA8C;AAK3F,KAAK,SAAS,GAAG,EAAE,CAAC;AACpB,KAAK,YAAY,GAAG;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAC,CAAC;AACjD,KAAK,YAAY,GAAG,EAAE,CAAC;AAEvB,KAAK,aAAa,GAAG;IACnB,OAAO,EAAE,OAAO,OAAO,CAAC;IACxB,WAAW,EAAE,OAAO,WAAW,CAAC;IAChC,cAAc,EAAE,OAAO,cAAc,CAAC;CACvC,CAAC;AAUF;;GAEG;AACH,eAAO,MAAM,cAAc,EAAE,YAAY,CAAC,SAAS,EAAE,YAAY,EAAE,YAAY,CAAC,GAAG,aAYlF,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,IAAI,EAAE,YAAY,CAAC,EAAE,CAAC,GAAG,aASrC,CAAC;AAEF,OAAO,EAAC,OAAO,EAAE,WAAW,EAAE,cAAc,EAAC,CAAC"}

package/dist/modules/math/fp64/fp64.js

@@ -3,19 +3,25 @@
 // Copyright (c) vis.gl contributors
 import { fp64ify, fp64LowPart, fp64ifyMatrix4 } from "../../../modules/math/fp64/fp64-utils.js";
 import { fp64arithmeticShader } from "./fp64-arithmetic-glsl.js";
+import { fp64arithmeticWGSL } from "./fp64-arithmetic-wgsl.js";
 import { fp64functionShader } from "./fp64-functions-glsl.js";
 const defaultUniforms = {
     // Used in LUMA_FP64_CODE_ELIMINATION_WORKAROUND
-    ONE: 1.0
+    ONE: 1.0,
+    // Runtime split factor for Dekker splitting. Keeping this as a uniform helps
+    // prevent aggressive constant folding in shader compilers.
+    SPLIT: 4097.0
 };
 /**
  * 64bit arithmetic: add, sub, mul, div (small subset of fp64 module)
  */
 export const fp64arithmetic = {
     name: 'fp64arithmetic',
+    source: fp64arithmeticWGSL,
+    fs: fp64arithmeticShader,
     vs: fp64arithmeticShader,
     defaultUniforms,
-    uniformTypes: { ONE: 'f32' },
+    uniformTypes: { ONE: 'f32', SPLIT: 'f32' },
     // Additional Functions
     fp64ify,
     fp64LowPart,

package/dist/modules/math/fp64/fp64.js.map

@@ -1 +1 @@
-{"version":3,"file":"fp64.js","sourceRoot":"","sources":["../../../../src/modules/math/fp64/fp64.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,oCAAoC;AAIpC,OAAO,EAAC,OAAO,EAAE,WAAW,EAAE,cAAc,EAAC,iDAA8C;AAC3F,OAAO,EAAC,oBAAoB,EAAC,kCAA+B;AAC5D,OAAO,EAAC,kBAAkB,EAAC,iCAA8B;AAYzD,MAAM,eAAe,GAAiB;IACpC,gDAAgD;IAChD,GAAG,EAAE,GAAG;CACT,CAAC;AAEF;;GAEG;AACH,MAAM,CAAC,MAAM,cAAc,GAAwE;IACjG,IAAI,EAAE,gBAAgB;IACtB,EAAE,EAAE,oBAAoB;IACxB,eAAe;IACf,YAAY,EAAE,EAAC,GAAG,EAAE,KAAK,EAAC;IAE1B,uBAAuB;IACvB,OAAO;IACP,WAAW;IACX,cAAc;CACf,CAAC;AAEF;;GAEG;AACH,MAAM,CAAC,MAAM,IAAI,GAAqC;IACpD,IAAI,EAAE,MAAM;IACZ,EAAE,EAAE,kBAAkB;IACtB,YAAY,EAAE,CAAC,cAAc,CAAC;IAE9B,uBAAuB;IACvB,OAAO;IACP,WAAW;IACX,cAAc;CACf,CAAC;AAEF,OAAO,EAAC,OAAO,EAAE,WAAW,EAAE,cAAc,EAAC,CAAC"}
+{"version":3,"file":"fp64.js","sourceRoot":"","sources":["../../../../src/modules/math/fp64/fp64.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,oCAAoC;AAIpC,OAAO,EAAC,OAAO,EAAE,WAAW,EAAE,cAAc,EAAC,iDAA8C;AAC3F,OAAO,EAAC,oBAAoB,EAAC,kCAA+B;AAC5D,OAAO,EAAC,kBAAkB,EAAC,kCAA+B;AAC1D,OAAO,EAAC,kBAAkB,EAAC,iCAA8B;AAYzD,MAAM,eAAe,GAAiB;IACpC,gDAAgD;IAChD,GAAG,EAAE,GAAG;IACR,6EAA6E;IAC7E,2DAA2D;IAC3D,KAAK,EAAE,MAAM;CACd,CAAC;AAEF;;GAEG;AACH,MAAM,CAAC,MAAM,cAAc,GAAwE;IACjG,IAAI,EAAE,gBAAgB;IACtB,MAAM,EAAE,kBAAkB;IAC1B,EAAE,EAAE,oBAAoB;IACxB,EAAE,EAAE,oBAAoB;IACxB,eAAe;IACf,YAAY,EAAE,EAAC,GAAG,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAC;IAExC,uBAAuB;IACvB,OAAO;IACP,WAAW;IACX,cAAc;CACf,CAAC;AAEF;;GAEG;AACH,MAAM,CAAC,MAAM,IAAI,GAAqC;IACpD,IAAI,EAAE,MAAM;IACZ,EAAE,EAAE,kBAAkB;IACtB,YAAY,EAAE,CAAC,cAAc,CAAC;IAE9B,uBAAuB;IACvB,OAAO;IACP,WAAW;IACX,cAAc;CACf,CAAC;AAEF,OAAO,EAAC,OAAO,EAAE,WAAW,EAAE,cAAc,EAAC,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@luma.gl/shadertools",
-  "version": "9.3.0-alpha.6",
+  "version": "9.3.0-alpha.9",
   "description": "Shader module system for luma.gl",
   "type": "module",
   "license": "MIT",
@@ -46,11 +46,11 @@
     "prepublishOnly": "npm run build-minified-bundle && npm run build-dev-bundle"
   },
   "peerDependencies": {
-    "@luma.gl/core": "9.2.0-alpha.6"
+    "@luma.gl/core": "9.3.0-alpha.6"
   },
   "dependencies": {
     "@math.gl/core": "^4.1.0",
     "@math.gl/types": "^4.1.0"
   },
-  "gitHead": "59fda5480c4d0bb3d64545d4621175221f2b6c7c"
+  "gitHead": "737b0f752b3f8a6ae920b394d5ca028427275b37"
 }

package/src/index.ts

@@ -9,17 +9,28 @@
  * Install https://marketplace.visualstudio.com/items?itemName=boyswan.glsl-literal
  */
 export type {PlatformInfo} from './lib/shader-assembly/platform-info';
+export type {ShaderBindingDebugRow} from './lib/shader-assembly/wgsl-binding-debug';
 
 // ShaderModules
 
 export type {ShaderModule} from './lib/shader-module/shader-module';
 export type {ShaderPass} from './lib/shader-module/shader-pass';
-export type {UniformTypes} from './lib/utils/uniform-types';
+export type {ShaderModuleUniformValue, UniformTypes} from './lib/utils/uniform-types';
 
 export {initializeShaderModule, initializeShaderModules} from './lib/shader-module/shader-module';
 export {getShaderModuleUniforms} from './lib/shader-module/shader-module';
 export {getShaderModuleDependencies} from './lib/shader-module/shader-module-dependencies';
 export {checkShaderModuleDeprecations} from './lib/shader-module/shader-module';
+export type {
+  ShaderModuleUniformLayoutStage,
+  ShaderModuleUniformLayoutValidationResult
+} from './lib/shader-module/shader-module-uniform-layout';
+export {
+  getShaderModuleUniformBlockFields,
+  getShaderModuleUniformBlockName,
+  getShaderModuleUniformLayoutValidationResult,
+  validateShaderModuleUniformLayout
+} from './lib/shader-module/shader-module-uniform-layout';
 
 export {getShaderModuleSource} from './lib/shader-assembly/assemble-shaders';
 
@@ -77,12 +88,18 @@ export {
   type Light,
   type AmbientLight,
   type PointLight,
-  type DirectionalLight
+  type SpotLight,
+  type DirectionalLight,
+  type LightingLightUniform
 } from './modules/lighting/lights/lighting';
 
 export type {LightingProps, LightingUniforms} from './modules/lighting/lights/lighting';
 export {lighting} from './modules/lighting/lights/lighting';
+export type {IBLBindings} from './modules/lighting/ibl/ibl';
+export {ibl} from './modules/lighting/ibl/ibl';
 export {dirlight} from './modules/lighting/no-material/dirlight';
+export type {LambertMaterialProps} from './modules/lighting/lambert-material/lambert-material';
+export {lambertMaterial} from './modules/lighting/lambert-material/lambert-material';
 export type {GouraudMaterialProps} from './modules/lighting/gouraud-material/gouraud-material';
 export {gouraudMaterial} from './modules/lighting/gouraud-material/gouraud-material';
 export type {PhongMaterialProps} from './modules/lighting/phong-material/phong-material';

package/src/lib/preprocessor/preprocessor.ts

@@ -2,11 +2,14 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-const IFDEF_REGEXP = /^\s*\#\s*ifdef\s*([a-zA-Z_]+)\s*$/;
-const IFNDEF_REGEXP = /^\s*\#\s*ifndef\s*([a-zA-Z_]+)\s*(?:\/\/.*)?$/;
+const DEFINE_NAME_PATTERN = '([a-zA-Z_][a-zA-Z0-9_]*)';
+const IFDEF_REGEXP = new RegExp(`^\\s*\\#\\s*ifdef\\s*${DEFINE_NAME_PATTERN}\\s*$`);
+const IFNDEF_REGEXP = new RegExp(`^\\s*\\#\\s*ifndef\\s*${DEFINE_NAME_PATTERN}\\s*(?:\\/\\/.*)?$`);
 const ELSE_REGEXP = /^\s*\#\s*else\s*(?:\/\/.*)?$/;
 const ENDIF_REGEXP = /^\s*\#\s*endif\s*$/;
-const IFDEF_WITH_COMMENT_REGEXP = /^\s*\#\s*ifdef\s*([a-zA-Z_]+)\s*(?:\/\/.*)?$/;
+const IFDEF_WITH_COMMENT_REGEXP = new RegExp(
+  `^\\s*\\#\\s*ifdef\\s*${DEFINE_NAME_PATTERN}\\s*(?:\\/\\/.*)?$`
+);
 const ENDIF_WITH_COMMENT_REGEXP = /^\s*\#\s*endif\s*(?:\/\/.*)?$/;
 
 export type PreprocessorOptions = {

package/src/lib/shader-assembler.ts

@@ -10,6 +10,10 @@ import {
   assembleWGSLShader,
   assembleGLSLShaderPair
 } from './shader-assembly/assemble-shaders';
+import {
+  getShaderBindingDebugRowsFromWGSL,
+  type ShaderBindingDebugRow
+} from './shader-assembly/wgsl-binding-debug';
 import {preprocess} from './preprocessor/preprocessor';
 
 /**
@@ -23,6 +27,8 @@ export class ShaderAssembler {
   private readonly _hookFunctions: any[] = [];
   /** Shader modules */
   private _defaultModules: ShaderModule[] = [];
+  /** Stable per-run WGSL auto-binding assignments keyed by group/module/binding. */
+  private readonly _wgslBindingRegistry = new Map<string, number>();
 
   /**
    * A default shader assembler instance - the natural place to register default modules and hooks
@@ -77,13 +83,16 @@ export class ShaderAssembler {
     source: string;
     getUniforms: GetUniformsFunc;
     modules: ShaderModule[];
+    bindingAssignments: {moduleName: string; name: string; group: number; location: number}[];
+    bindingTable: ShaderBindingDebugRow[];
   } {
     const modules = this._getModuleList(props.modules); // Combine with default modules
     const hookFunctions = this._hookFunctions; // TODO - combine with default hook functions
-    const {source, getUniforms} = assembleWGSLShader({
+    const {source, getUniforms, bindingAssignments} = assembleWGSLShader({
       ...props,
       // @ts-expect-error
       source: props.source,
+      _bindingRegistry: this._wgslBindingRegistry,
       modules,
       hookFunctions
     });
@@ -97,7 +106,13 @@ export class ShaderAssembler {
     // WGSL does not have built-in preprocessing support (just compile time constants)
     const preprocessedSource =
       props.platformInfo.shaderLanguage === 'wgsl' ? preprocess(source, {defines}) : source;
-    return {source: preprocessedSource, getUniforms, modules};
+    return {
+      source: preprocessedSource,
+      getUniforms,
+      modules,
+      bindingAssignments,
+      bindingTable: getShaderBindingDebugRowsFromWGSL(preprocessedSource, bindingAssignments)
+    };
   }
 
   /**