@deck.gl/extensions 9.3.0-alpha.3 → 9.3.0-alpha.6

package/dist/dist.dev.js

@@ -85,7 +85,7 @@ var __exports__ = (() => {
   var import_core2 = __toESM(require_core(), 1);
   var uniformBlock = (
     /* glsl */
-    `uniform brushingUniforms {
+    `layout(std140) uniform brushingUniforms {
   bool enabled;
   highp int target;
   vec2 mousePos;
@@ -269,24 +269,18 @@ ${fragment}
   // src/data-filter/shader-module.ts
   var uniformBlock2 = (
     /* glsl */
-    `uniform dataFilterUniforms {
+    `layout(std140) uniform dataFilterUniforms {
   bool useSoftMargin;
   bool enabled;
   bool transformSize;
   bool transformColor;
-#ifdef DATAFILTER_TYPE
-  DATAFILTER_TYPE min;
-  DATAFILTER_TYPE softMin;
-  DATAFILTER_TYPE softMax;
-  DATAFILTER_TYPE max;
-#ifdef DATAFILTER_DOUBLE
-  DATAFILTER_TYPE min64High;
-  DATAFILTER_TYPE max64High;
-#endif
-#endif
-#ifdef DATACATEGORY_TYPE
+  vec4 min;
+  vec4 softMin;
+  vec4 softMax;
+  vec4 max;
+  vec4 min64High;
+  vec4 max64High;
   highp uvec4 categoryBitMask;
-#endif
 } dataFilter;
 `
   );
@@ -306,6 +300,86 @@ ${fragment}
 
 out float dataFilter_value;
 
+#ifdef DATAFILTER_TYPE
+  float dataFilter_getMin(float _) {
+    return dataFilter.min.x;
+  }
+  vec2 dataFilter_getMin(vec2 _) {
+    return dataFilter.min.xy;
+  }
+  vec3 dataFilter_getMin(vec3 _) {
+    return dataFilter.min.xyz;
+  }
+  vec4 dataFilter_getMin(vec4 _) {
+    return dataFilter.min;
+  }
+
+  float dataFilter_getSoftMin(float _) {
+    return dataFilter.softMin.x;
+  }
+  vec2 dataFilter_getSoftMin(vec2 _) {
+    return dataFilter.softMin.xy;
+  }
+  vec3 dataFilter_getSoftMin(vec3 _) {
+    return dataFilter.softMin.xyz;
+  }
+  vec4 dataFilter_getSoftMin(vec4 _) {
+    return dataFilter.softMin;
+  }
+
+  float dataFilter_getSoftMax(float _) {
+    return dataFilter.softMax.x;
+  }
+  vec2 dataFilter_getSoftMax(vec2 _) {
+    return dataFilter.softMax.xy;
+  }
+  vec3 dataFilter_getSoftMax(vec3 _) {
+    return dataFilter.softMax.xyz;
+  }
+  vec4 dataFilter_getSoftMax(vec4 _) {
+    return dataFilter.softMax;
+  }
+
+  float dataFilter_getMax(float _) {
+    return dataFilter.max.x;
+  }
+  vec2 dataFilter_getMax(vec2 _) {
+    return dataFilter.max.xy;
+  }
+  vec3 dataFilter_getMax(vec3 _) {
+    return dataFilter.max.xyz;
+  }
+  vec4 dataFilter_getMax(vec4 _) {
+    return dataFilter.max;
+  }
+
+  float dataFilter_getMin64High(float _) {
+    return dataFilter.min64High.x;
+  }
+  vec2 dataFilter_getMin64High(vec2 _) {
+    return dataFilter.min64High.xy;
+  }
+  vec3 dataFilter_getMin64High(vec3 _) {
+    return dataFilter.min64High.xyz;
+  }
+  vec4 dataFilter_getMin64High(vec4 _) {
+    return dataFilter.min64High;
+  }
+
+  float dataFilter_getMax64High(float _) {
+    return dataFilter.max64High.x;
+  }
+  vec2 dataFilter_getMax64High(vec2 _) {
+    return dataFilter.max64High.xy;
+  }
+  vec3 dataFilter_getMax64High(vec3 _) {
+    return dataFilter.max64High.xyz;
+  }
+  vec4 dataFilter_getMax64High(vec4 _) {
+    return dataFilter.max64High;
+  }
+#endif
+
 float dataFilter_reduceValue(float value) {
   return value;
 }
@@ -321,23 +395,27 @@ float dataFilter_reduceValue(vec4 value) {
 
 #ifdef DATAFILTER_TYPE
   void dataFilter_setValue(DATAFILTER_TYPE valueFromMin, DATAFILTER_TYPE valueFromMax) {
+    DATAFILTER_TYPE dataFilter_min = dataFilter_getMin(valueFromMin);
+    DATAFILTER_TYPE dataFilter_softMin = dataFilter_getSoftMin(valueFromMin);
+    DATAFILTER_TYPE dataFilter_softMax = dataFilter_getSoftMax(valueFromMin);
+    DATAFILTER_TYPE dataFilter_max = dataFilter_getMax(valueFromMin);
     if (dataFilter.useSoftMargin) {
       // smoothstep results are undefined if edge0 \u2265 edge1
       // Fallback to ignore filterSoftRange if it is truncated by filterRange
       DATAFILTER_TYPE leftInRange = mix(
-        smoothstep(dataFilter.min, dataFilter.softMin, valueFromMin),
-        step(dataFilter.min, valueFromMin),
-        step(dataFilter.softMin, dataFilter.min)
+        smoothstep(dataFilter_min, dataFilter_softMin, valueFromMin),
+        step(dataFilter_min, valueFromMin),
+        step(dataFilter_softMin, dataFilter_min)
       );
       DATAFILTER_TYPE rightInRange = mix(
-        1.0 - smoothstep(dataFilter.softMax, dataFilter.max, valueFromMax),
-        step(valueFromMax, dataFilter.max),
-        step(dataFilter.max, dataFilter.softMax)
+        1.0 - smoothstep(dataFilter_softMax, dataFilter_max, valueFromMax),
+        step(valueFromMax, dataFilter_max),
+        step(dataFilter_max, dataFilter_softMax)
       );
       dataFilter_value = dataFilter_reduceValue(leftInRange * rightInRange);
     } else {
       dataFilter_value = dataFilter_reduceValue(
-        step(dataFilter.min, valueFromMin) * step(valueFromMax, dataFilter.max)
+        step(dataFilter_min, valueFromMin) * step(valueFromMax, dataFilter_max)
       );
     }
   }
@@ -363,9 +441,9 @@ float dataFilter_reduceValue(vec4 value) {
     dataFilter_bits &= 1u;
 
     #if DATACATEGORY_CHANNELS == 1
-    if(dataFilter_bits == 0u) dataFilter_value = 0.0;
+    if (dataFilter_bits == 0u) dataFilter_value = 0.0;
     #else
-    if(any(equal(dataFilter_bits, DATACATEGORY_TYPE(0u)))) dataFilter_value = 0.0;
+    if (any(equal(dataFilter_bits, DATACATEGORY_TYPE(0u)))) dataFilter_value = 0.0;
     #endif
   }
 #endif
@@ -397,17 +475,23 @@ ${fragment2}
       categoryBitMask
     } = opts;
     const filterSoftRange = opts.filterSoftRange || filterRange;
+    const padRange = (value) => {
+      if (Array.isArray(value)) {
+        return [value[0] || 0, value[1] || 0, value[2] || 0, value[3] || 0];
+      }
+      return [value, 0, 0, 0];
+    };
     return {
       ...Number.isFinite(filterRange[0]) ? {
-        min: filterRange[0],
-        softMin: filterSoftRange[0],
-        softMax: filterSoftRange[1],
-        max: filterRange[1]
+        min: padRange(filterRange[0]),
+        softMin: padRange(filterSoftRange[0]),
+        softMax: padRange(filterSoftRange[1]),
+        max: padRange(filterRange[1])
       } : {
-        min: filterRange.map((r) => r[0]),
-        softMin: filterSoftRange.map((r) => r[0]),
-        softMax: filterSoftRange.map((r) => r[1]),
-        max: filterRange.map((r) => r[1])
+        min: padRange(filterRange.map((r) => r[0])),
+        softMin: padRange(filterSoftRange.map((r) => r[0])),
+        softMax: padRange(filterSoftRange.map((r) => r[1])),
+        max: padRange(filterRange.map((r) => r[1]))
       },
       enabled: filterEnabled,
       useSoftMargin: Boolean(opts.filterSoftRange),
@@ -421,25 +505,14 @@ ${fragment2}
       return {};
     }
     const uniforms = getUniforms(opts);
-    if (Number.isFinite(uniforms.min)) {
-      const min64High = Math.fround(uniforms.min);
-      uniforms.min -= min64High;
-      uniforms.softMin -= min64High;
-      uniforms.min64High = min64High;
-      const max64High = Math.fround(uniforms.max);
-      uniforms.max -= max64High;
-      uniforms.softMax -= max64High;
-      uniforms.max64High = max64High;
-    } else {
-      const min64High = uniforms.min.map(Math.fround);
-      uniforms.min = uniforms.min.map((x, i) => x - min64High[i]);
-      uniforms.softMin = uniforms.softMin.map((x, i) => x - min64High[i]);
-      uniforms.min64High = min64High;
-      const max64High = uniforms.max.map(Math.fround);
-      uniforms.max = uniforms.max.map((x, i) => x - max64High[i]);
-      uniforms.softMax = uniforms.softMax.map((x, i) => x - max64High[i]);
-      uniforms.max64High = max64High;
-    }
+    const min64High = uniforms.min.map(Math.fround);
+    uniforms.min = uniforms.min.map((x, i) => x - min64High[i]);
+    uniforms.softMin = uniforms.softMin.map((x, i) => x - min64High[i]);
+    uniforms.min64High = min64High;
+    const max64High = uniforms.max.map(Math.fround);
+    uniforms.max = uniforms.max.map((x, i) => x - max64High[i]);
+    uniforms.softMax = uniforms.softMax.map((x, i) => x - max64High[i]);
+    uniforms.max64High = max64High;
     return uniforms;
   }
   var inject2 = {
@@ -451,8 +524,8 @@ ${fragment2}
       #ifdef DATAFILTER_TYPE
         #ifdef DATAFILTER_DOUBLE
           dataFilter_setValue(
-            filterValues - dataFilter.min64High + filterValues64Low,
-            filterValues - dataFilter.max64High + filterValues64Low
+            filterValues - dataFilter_getMin64High(filterValues) + filterValues64Low,
+            filterValues - dataFilter_getMax64High(filterValues) + filterValues64Low
           );
         #else
           dataFilter_setValue(filterValues, filterValues);
@@ -492,27 +565,19 @@ ${fragment2}
     )
   };
   function uniformTypesFromOptions(opts) {
-    const { categorySize, filterSize, fp64: fp642 } = opts;
     const uniformTypes = {
       useSoftMargin: "i32",
       enabled: "i32",
       transformSize: "i32",
-      transformColor: "i32"
+      transformColor: "i32",
+      min: "vec4<f32>",
+      softMin: "vec4<f32>",
+      softMax: "vec4<f32>",
+      max: "vec4<f32>",
+      min64High: "vec4<f32>",
+      max64High: "vec4<f32>",
+      categoryBitMask: "vec4<u32>"
     };
-    if (filterSize) {
-      const uniformFormat = filterSize === 1 ? "f32" : `vec${filterSize}<f32>`;
-      uniformTypes.min = uniformFormat;
-      uniformTypes.softMin = uniformFormat;
-      uniformTypes.softMax = uniformFormat;
-      uniformTypes.max = uniformFormat;
-      if (fp642) {
-        uniformTypes.min64High = uniformFormat;
-        uniformTypes.max64High = uniformFormat;
-      }
-    }
-    if (categorySize) {
-      uniformTypes.categoryBitMask = "vec4<i32>";
-    }
     return uniformTypes;
   }
   var dataFilter = {
@@ -1407,8 +1472,9 @@ void main() {
   var fp64arithmeticShader = (
     /* glsl */
     `
-uniform fp64arithmeticUniforms {
+layout(std140) uniform fp64arithmeticUniforms {
   uniform float ONE;
+  uniform float SPLIT;
 } fp64;
 
 /*
@@ -1418,6 +1484,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
@@ -1426,17 +1498,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);
 }
 
@@ -1500,8 +1578,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);
 }
 
@@ -1577,6 +1673,218 @@ vec2 sqrt_fp64(vec2 a) {
 `
   );
 
+  // ../../node_modules/@luma.gl/shadertools/dist/modules/math/fp64/fp64-arithmetic-wgsl.js
+  var 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
+}
+`
+  );
+
   // ../../node_modules/@luma.gl/shadertools/dist/modules/math/fp64/fp64-functions-glsl.js
   var fp64functionShader = (
     /* glsl */
@@ -2255,13 +2563,18 @@ void mat4_vec4_mul_fp64(vec2 b[16], vec2 a[4], out vec2 out_val[4]) {
   // ../../node_modules/@luma.gl/shadertools/dist/modules/math/fp64/fp64.js
   var defaultUniforms = {
     // Used in LUMA_FP64_CODE_ELIMINATION_WORKAROUND
-    ONE: 1
+    ONE: 1,
+    // Runtime split factor for Dekker splitting. Keeping this as a uniform helps
+    // prevent aggressive constant folding in shader compilers.
+    SPLIT: 4097
   };
   var fp64arithmetic = {
     name: "fp64arithmetic",
+    source: fp64arithmeticWGSL,
+    fs: fp64arithmeticShader,
     vs: fp64arithmeticShader,
     defaultUniforms,
-    uniformTypes: { ONE: "f32" },
+    uniformTypes: { ONE: "f32", SPLIT: "f32" },
     // Additional Functions
     fp64ify,
     fp64LowPart,
@@ -2284,7 +2597,7 @@ void mat4_vec4_mul_fp64(vec2 b[16], vec2 a[4], out vec2 out_val[4]) {
   var project64_glsl_default = `
 const vec2 WORLD_SCALE_FP64 = vec2(81.4873275756836, 0.0000032873668232014097);
 
-uniform project64Uniforms {
+layout(std140) uniform project64Uniforms {
   vec2 scale;
   mat4 viewProjectionMatrix;
   mat4 viewProjectionMatrix64Low;
@@ -2460,7 +2773,7 @@ vDashOffset = 0.0;
 #endif
 `,
       "fs:#decl": `
-uniform pathStyleUniforms {
+layout(std140) uniform pathStyleUniforms {
   float dashAlignMode;
   bool dashGapPickable;
 } pathStyle;
@@ -2652,7 +2965,7 @@ in float instanceOffsets;
   var import_core9 = __toESM(require_core(), 1);
   var uniformBlock3 = (
     /* glsl */
-    `uniform fillUniforms {
+    `layout(std140) uniform fillUniforms {
   vec2 patternTextureSize;
   bool patternEnabled;
   bool patternMask;
@@ -2877,7 +3190,7 @@ ${patternFs}
   var shaderFunction = (
     /* glsl */
     `
-uniform clipUniforms {
+layout(std140) uniform clipUniforms {
   vec4 bounds;
 } clip;
 
@@ -3001,7 +3314,7 @@ in float collisionPriorities;
 
 uniform sampler2D collision_texture;
 
-uniform collisionUniforms {
+layout(std140) uniform collisionUniforms {
   bool sort;
   bool enabled;
 } collision;
@@ -3383,7 +3696,7 @@ float collision_isVisible(vec2 texCoords, vec3 pickingColor) {
   var import_core17 = __toESM(require_core(), 1);
   var uniformBlock4 = (
     /* glsl */
-    `uniform maskUniforms {
+    `layout(std140) uniform maskUniforms {
   vec4 bounds;
   highp int channel;
   bool enabled;
@@ -3951,7 +4264,7 @@ in vec2 mask_texCoords;
     // eslint-disable-next-line prefer-template
     TERRAIN_MODE_CONSTANTS + /* glsl */
     `
-uniform terrainUniforms {
+layout(std140) uniform terrainUniforms {
   float mode;
   vec4 bounds;
 } terrain;
@@ -4086,7 +4399,7 @@ if ((terrain.mode == TERRAIN_MODE_USE_COVER) || (terrain.mode == TERRAIN_MODE_US
     }
   };
 
-  // ../../node_modules/@luma.gl/constants/dist/webgl-constants.js
+  // ../../node_modules/@luma.gl/webgl/dist/constants/webgl-constants.js
   var GLEnum;
   (function(GLEnum2) {
     GLEnum2[GLEnum2["DEPTH_BUFFER_BIT"] = 256] = "DEPTH_BUFFER_BIT";

package/dist/fill-style/shader-module.d.ts

@@ -19,8 +19,8 @@ type FillStyleModuleBindings = {
 declare function getPatternUniforms(opts?: FillStyleModuleProps | {}): FillStyleModuleBindings & FillStyleModuleUniforms;
 export declare const patternShaders: {
     readonly name: "fill";
-    readonly vs: "\nuniform fillUniforms {\n  vec2 patternTextureSize;\n  bool patternEnabled;\n  bool patternMask;\n  vec2 uvCoordinateOrigin;\n  vec2 uvCoordinateOrigin64Low;\n} fill;\n\n\nin vec4 fillPatternFrames;\nin float fillPatternScales;\nin vec2 fillPatternOffsets;\n\nout vec2 fill_uv;\nout vec4 fill_patternBounds;\nout vec4 fill_patternPlacement;\n\n";
-    readonly fs: "\nuniform fillUniforms {\n  vec2 patternTextureSize;\n  bool patternEnabled;\n  bool patternMask;\n  vec2 uvCoordinateOrigin;\n  vec2 uvCoordinateOrigin64Low;\n} fill;\n\n\nuniform sampler2D fill_patternTexture;\n\nin vec4 fill_patternBounds;\nin vec4 fill_patternPlacement;\nin vec2 fill_uv;\n\nconst float FILL_UV_SCALE = 512.0 / 40000000.0;\n\n";
+    readonly vs: "\nlayout(std140) uniform fillUniforms {\n  vec2 patternTextureSize;\n  bool patternEnabled;\n  bool patternMask;\n  vec2 uvCoordinateOrigin;\n  vec2 uvCoordinateOrigin64Low;\n} fill;\n\n\nin vec4 fillPatternFrames;\nin float fillPatternScales;\nin vec2 fillPatternOffsets;\n\nout vec2 fill_uv;\nout vec4 fill_patternBounds;\nout vec4 fill_patternPlacement;\n\n";
+    readonly fs: "\nlayout(std140) uniform fillUniforms {\n  vec2 patternTextureSize;\n  bool patternEnabled;\n  bool patternMask;\n  vec2 uvCoordinateOrigin;\n  vec2 uvCoordinateOrigin64Low;\n} fill;\n\n\nuniform sampler2D fill_patternTexture;\n\nin vec4 fill_patternBounds;\nin vec4 fill_patternPlacement;\nin vec2 fill_uv;\n\nconst float FILL_UV_SCALE = 512.0 / 40000000.0;\n\n";
     readonly inject: {
         'vs:DECKGL_FILTER_GL_POSITION': string;
         'vs:DECKGL_FILTER_COLOR': string;

package/dist/fill-style/shader-module.js

@@ -3,7 +3,7 @@
 // Copyright (c) vis.gl contributors
 import { project, fp64LowPart } from '@deck.gl/core';
 const uniformBlock = /* glsl */ `\
-uniform fillUniforms {
+layout(std140) uniform fillUniforms {
   vec2 patternTextureSize;
   bool patternEnabled;
   bool patternMask;