@luma.gl/shadertools 9.3.0-alpha.4 → 9.3.0-alpha.8

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

@@ -5,6 +5,7 @@ export const fp64arithmeticShader = /* glsl */ `\
 
 uniform fp64arithmeticUniforms {
   uniform float ONE;
+  uniform float SPLIT;
 } fp64;
 
 /*
@@ -14,6 +15,12 @@ The purpose of this workaround is to prevent shader compilers from
 optimizing away necessary arithmetic operations by swapping their sequences
 or transform the equation to some 'equivalent' form.
 
+These helpers implement Dekker/Veltkamp-style error tracking. If the compiler
+folds constants or reassociates the arithmetic, the high/low split can stop
+tracking the rounding error correctly. That failure mode tends to look fine in
+simple coordinate setup, but then breaks down inside iterative arithmetic such
+as fp64 Mandelbrot loops.
+
 The method is to multiply an artifical variable, ONE, which will be known to
 the compiler to be 1 only at runtime. The whole expression is then represented
 as a polynomial with respective to ONE. In the coefficients of all terms, only one a
@@ -22,17 +29,23 @@ and one b should appear
 err = (a + b) * ONE^6 - a * ONE^5 - (a + b) * ONE^4 + a * ONE^3 - b - (a + b) * ONE^2 + a * ONE
 */
 
-// Divide float number to high and low floats to extend fraction bits
-vec2 split(float a) {
-  const float SPLIT = 4097.0;
-  float t = a * SPLIT;
+float prevent_fp64_optimization(float value) {
 #if defined(LUMA_FP64_CODE_ELIMINATION_WORKAROUND)
-  float a_hi = t * fp64.ONE - (t - a);
-  float a_lo = a * fp64.ONE - a_hi;
+  return value + fp64.ONE * 0.0;
 #else
-  float a_hi = t - (t - a);
-  float a_lo = a - a_hi;
+  return value;
 #endif
+}
+
+// Divide float number to high and low floats to extend fraction bits
+vec2 split(float a) {
+  // Keep SPLIT as a runtime uniform so the compiler cannot fold the Dekker
+  // split into a constant expression and reassociate the recovery steps.
+  float split = prevent_fp64_optimization(fp64.SPLIT);
+  float t = prevent_fp64_optimization(a * split);
+  float temp = t - a;
+  float a_hi = t - temp;
+  float a_lo = a - a_hi;
   return vec2(a_hi, a_lo);
 }
 
@@ -96,8 +109,26 @@ vec2 twoProd(float a, float b) {
   float prod = a * b;
   vec2 a_fp64 = split(a);
   vec2 b_fp64 = split(b);
-  float err = ((a_fp64.x * b_fp64.x - prod) + a_fp64.x * b_fp64.y +
-    a_fp64.y * b_fp64.x) + a_fp64.y * b_fp64.y;
+  // twoProd is especially sensitive because mul_fp64 and div_fp64 both depend
+  // on the split terms and cross terms staying in the original evaluation
+  // order. If the compiler folds or reassociates them, the low part tends to
+  // collapse to zero or NaN on some drivers.
+  float highProduct = prevent_fp64_optimization(a_fp64.x * b_fp64.x);
+  float crossProduct1 = prevent_fp64_optimization(a_fp64.x * b_fp64.y);
+  float crossProduct2 = prevent_fp64_optimization(a_fp64.y * b_fp64.x);
+  float lowProduct = prevent_fp64_optimization(a_fp64.y * b_fp64.y);
+#if defined(LUMA_FP64_CODE_ELIMINATION_WORKAROUND)
+  float err1 = (highProduct - prod) * fp64.ONE;
+  float err2 = crossProduct1 * fp64.ONE * fp64.ONE;
+  float err3 = crossProduct2 * fp64.ONE * fp64.ONE * fp64.ONE;
+  float err4 = lowProduct * fp64.ONE * fp64.ONE * fp64.ONE * fp64.ONE;
+#else
+  float err1 = highProduct - prod;
+  float err2 = crossProduct1;
+  float err3 = crossProduct2;
+  float err4 = lowProduct;
+#endif
+  float err = ((err1 + err2) + err3) + err4;
   return vec2(prod, err);
 }
 

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

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

package/dist/modules/math/fp64/fp64-arithmetic-wgsl.d.ts

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

package/dist/modules/math/fp64/fp64-arithmetic-wgsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fp64-arithmetic-wgsl.d.ts","sourceRoot":"","sources":["../../../../src/modules/math/fp64/fp64-arithmetic-wgsl.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,kBAAkB,yyNA+M9B,CAAC"}

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/dist/modules/math/random/random.d.ts

@@ -1,7 +1,7 @@
 /** Quick random generator for fragment shaders */
 export declare const random: {
     readonly name: "random";
-    readonly source: "fn random(scale: vec3f, seed: float) -> f32 {\n  /* use the fragment position for a different seed per-pixel */\n  return fract(sin(dot(gl_FragCoord.xyz + seed, scale)) * 43758.5453 + seed);\n}\n";
+    readonly source: "fn random(scale: vec3f, seed: f32) -> f32 {\n  return fract(sin(dot(scale + vec3f(seed), vec3f(12.9898, 78.233, 151.7182))) * 43758.5453 + seed);\n}\n";
     readonly fs: "float random(vec3 scale, float seed) {\n  /* use the fragment position for a different seed per-pixel */\n  return fract(sin(dot(gl_FragCoord.xyz + seed, scale)) * 43758.5453 + seed);\n}\n";
 };
 //# sourceMappingURL=random.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"random.d.ts","sourceRoot":"","sources":["../../../../src/modules/math/random/random.ts"],"names":[],"mappings":"AAoBA,kDAAkD;AAClD,eAAO,MAAM,MAAM;;;;CAIsB,CAAC"}
+{"version":3,"file":"random.d.ts","sourceRoot":"","sources":["../../../../src/modules/math/random/random.ts"],"names":[],"mappings":"AAmBA,kDAAkD;AAClD,eAAO,MAAM,MAAM;;;;CAIsB,CAAC"}

package/dist/modules/math/random/random.js

@@ -2,9 +2,8 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 const source = /* wgsl */ `\
-fn random(scale: vec3f, seed: float) -> f32 {
-  /* use the fragment position for a different seed per-pixel */
-  return fract(sin(dot(gl_FragCoord.xyz + seed, scale)) * 43758.5453 + seed);
+fn random(scale: vec3f, seed: f32) -> f32 {
+  return fract(sin(dot(scale + vec3f(seed), vec3f(12.9898, 78.233, 151.7182))) * 43758.5453 + seed);
 }
 `;
 const fs = /* glsl */ `\

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

@@ -1 +1 @@
-{"version":3,"file":"random.js","sourceRoot":"","sources":["../../../../src/modules/math/random/random.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,oCAAoC;AAIpC,MAAM,MAAM,GAAG,UAAU,CAAC;;;;;CAKzB,CAAC;AAEF,MAAM,EAAE,GAAG,UAAU,CAAC;;;;;CAKrB,CAAC;AAEF,kDAAkD;AAClD,MAAM,CAAC,MAAM,MAAM,GAAG;IACpB,IAAI,EAAE,QAAQ;IACd,MAAM;IACN,EAAE;CACqC,CAAC"}
+{"version":3,"file":"random.js","sourceRoot":"","sources":["../../../../src/modules/math/random/random.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,oCAAoC;AAIpC,MAAM,MAAM,GAAG,UAAU,CAAC;;;;CAIzB,CAAC;AAEF,MAAM,EAAE,GAAG,UAAU,CAAC;;;;;CAKrB,CAAC;AAEF,kDAAkD;AAClD,MAAM,CAAC,MAAM,MAAM,GAAG;IACpB,IAAI,EAAE,QAAQ;IACd,MAAM;IACN,EAAE;CACqC,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@luma.gl/shadertools",
-  "version": "9.3.0-alpha.4",
+  "version": "9.3.0-alpha.8",
   "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": "7486e7b0377fb6ab961b4499828681bede60f3b1"
+  "gitHead": "371f0979c1cd01563badc36118f314365a66e1a1"
 }

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';
 
@@ -70,18 +81,25 @@ export {fp64, fp64arithmetic} from './modules/math/fp64/fp64';
 // export {projection} from './modules/engine/project/project';
 export type {PickingProps, PickingUniforms} from './modules/engine/picking/picking';
 export {picking} from './modules/engine/picking/picking';
+export {skin} from './modules/engine/skin/skin';
 
 // lighting
 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,8 +2,15 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-const IFDEF_REGEXP = /^\s*\#\s*ifdef\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 = new RegExp(
+  `^\\s*\\#\\s*ifdef\\s*${DEFINE_NAME_PATTERN}\\s*(?:\\/\\/.*)?$`
+);
+const ENDIF_WITH_COMMENT_REGEXP = /^\s*\#\s*endif\s*(?:\/\/.*)?$/;
 
 export type PreprocessorOptions = {
   defines?: Record<string, boolean>;
@@ -13,19 +20,48 @@ export function preprocess(source: string, options?: PreprocessorOptions): strin
   const lines = source.split('\n');
   const output: string[] = [];
 
+  const conditionalStack: Array<{
+    parentActive: boolean;
+    branchTaken: boolean;
+    active: boolean;
+  }> = [];
   let conditional = true;
-  let currentDefine: string | null = null;
+
   for (const line of lines) {
-    const matchIf = line.match(IFDEF_REGEXP);
-    const matchEnd = line.match(ENDIF_REGEXP);
-    if (matchIf) {
-      currentDefine = matchIf[1];
-      conditional = Boolean(options?.defines?.[currentDefine]);
+    const matchIf = line.match(IFDEF_WITH_COMMENT_REGEXP) || line.match(IFDEF_REGEXP);
+    const matchIfNot = line.match(IFNDEF_REGEXP);
+    const matchElse = line.match(ELSE_REGEXP);
+    const matchEnd = line.match(ENDIF_WITH_COMMENT_REGEXP) || line.match(ENDIF_REGEXP);
+
+    if (matchIf || matchIfNot) {
+      const defineName = (matchIf || matchIfNot)?.[1];
+      const defineValue: boolean = Boolean(options?.defines?.[defineName!]);
+      const branchTaken: boolean = matchIf ? defineValue : !defineValue;
+      const active: boolean = conditional && branchTaken;
+      conditionalStack.push({parentActive: conditional, branchTaken, active});
+      conditional = active;
+    } else if (matchElse) {
+      const currentConditional = conditionalStack[conditionalStack.length - 1];
+      if (!currentConditional) {
+        throw new Error('Encountered #else without matching #ifdef or #ifndef');
+      }
+      currentConditional.active =
+        currentConditional.parentActive && !currentConditional.branchTaken;
+      currentConditional.branchTaken = true;
+      conditional = currentConditional.active;
     } else if (matchEnd) {
-      conditional = true;
+      conditionalStack.pop();
+      conditional = conditionalStack.length
+        ? conditionalStack[conditionalStack.length - 1].active
+        : true;
     } else if (conditional) {
       output.push(line);
     }
   }
+
+  if (conditionalStack.length > 0) {
+    throw new Error('Unterminated conditional block in shader source');
+  }
+
   return output.join('\n');
 }

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,20 +83,36 @@ 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
     });
+    const defines = {
+      ...modules.reduce<Record<string, boolean>>((accumulator, module) => {
+        Object.assign(accumulator, module.defines);
+        return accumulator;
+      }, {}),
+      ...props.defines
+    };
     // WGSL does not have built-in preprocessing support (just compile time constants)
     const preprocessedSource =
-      props.platformInfo.shaderLanguage === 'wgsl' ? preprocess(source) : source;
-    return {source: preprocessedSource, getUniforms, modules};
+      props.platformInfo.shaderLanguage === 'wgsl' ? preprocess(source, {defines}) : source;
+    return {
+      source: preprocessedSource,
+      getUniforms,
+      modules,
+      bindingAssignments,
+      bindingTable: getShaderBindingDebugRowsFromWGSL(preprocessedSource, bindingAssignments)
+    };
   }
 
   /**