@deck.gl/extensions 9.0.34 → 9.1.0-beta.1

package/dist/index.cjs

@@ -38,32 +38,56 @@ var import_core2 = require("@deck.gl/core");
 
 // dist/brushing/shader-module.js
 var import_core = require("@deck.gl/core");
+var uniformBlock = (
+  /* glsl */
+  `uniform brushingUniforms {
+  bool enabled;
+  highp int target;
+  vec2 mousePos;
+  float radius;
+} brushing;
+`
+);
+var vertex = (
+  /* glsl */
+  `
+  in vec2 brushingTargets;
+
+  out float brushing_isVisible;
+
+  bool brushing_isPointInRange(vec2 position) {
+    if (!brushing.enabled) {
+      return true;
+    }
+    vec2 source_commonspace = project_position(position);
+    vec2 target_commonspace = project_position(brushing.mousePos);
+    float distance = length((target_commonspace - source_commonspace) / project.commonUnitsPerMeter.xy);
+
+    return distance <= brushing.radius;
+  }
+
+  bool brushing_arePointsInRange(vec2 sourcePos, vec2 targetPos) {
+    return brushing_isPointInRange(sourcePos) || brushing_isPointInRange(targetPos);
+  }
+
+  void brushing_setVisible(bool visible) {
+    brushing_isVisible = float(visible);
+  }
+`
+);
 var vs = `
-uniform bool brushing_enabled;
-uniform int brushing_target;
-uniform vec2 brushing_mousePos;
-uniform float brushing_radius;
-in vec2 brushingTargets;
-out float brushing_isVisible;
-bool brushing_isPointInRange(vec2 position) {
-if (!brushing_enabled) {
-return true;
-}
-vec2 source_commonspace = project_position(position);
-vec2 target_commonspace = project_position(brushing_mousePos);
-float distance = length((target_commonspace - source_commonspace) / project_uCommonUnitsPerMeter.xy);
-return distance <= brushing_radius;
-}
-bool brushing_arePointsInRange(vec2 sourcePos, vec2 targetPos) {
-return brushing_isPointInRange(sourcePos) || brushing_isPointInRange(targetPos);
-}
-void brushing_setVisible(bool visible) {
-brushing_isVisible = float(visible);
-}
+${uniformBlock}
+${vertex}
 `;
+var fragment = (
+  /* glsl */
+  `
+  in float brushing_isVisible;
+`
+);
 var fs = `
-uniform bool brushing_enabled;
-in float brushing_isVisible;
+${uniformBlock}
+${fragment}
 `;
 var TARGET = {
   source: 0,
@@ -72,29 +96,32 @@ var TARGET = {
   source_target: 3
 };
 var inject = {
-  "vs:DECKGL_FILTER_GL_POSITION": `
-vec2 brushingTarget;
-vec2 brushingSource;
-if (brushing_target == 3) {
-brushingTarget = geometry.worldPositionAlt.xy;
-brushingSource = geometry.worldPosition.xy;
-} else if (brushing_target == 0) {
-brushingTarget = geometry.worldPosition.xy;
-} else if (brushing_target == 1) {
-brushingTarget = geometry.worldPositionAlt.xy;
-} else {
-brushingTarget = brushingTargets;
-}
-bool visible;
-if (brushing_target == 3) {
-visible = brushing_arePointsInRange(brushingSource, brushingTarget);
-} else {
-visible = brushing_isPointInRange(brushingTarget);
-}
-brushing_setVisible(visible);
-`,
+  "vs:DECKGL_FILTER_GL_POSITION": (
+    /* glsl */
+    `
+    vec2 brushingTarget;
+    vec2 brushingSource;
+    if (brushing.target == 3) {
+      brushingTarget = geometry.worldPositionAlt.xy;
+      brushingSource = geometry.worldPosition.xy;
+    } else if (brushing.target == 0) {
+      brushingTarget = geometry.worldPosition.xy;
+    } else if (brushing.target == 1) {
+      brushingTarget = geometry.worldPositionAlt.xy;
+    } else {
+      brushingTarget = brushingTargets;
+    }
+    bool visible;
+    if (brushing.target == 3) {
+      visible = brushing_arePointsInRange(brushingSource, brushingTarget);
+    } else {
+      visible = brushing_isPointInRange(brushingTarget);
+    }
+    brushing_setVisible(visible);
+  `
+  ),
   "fs:DECKGL_FILTER_COLOR": `
-    if (brushing_enabled && brushing_isVisible < 0.5) {
+    if (brushing.enabled && brushing_isVisible < 0.5) {
       discard;
     }
   `
@@ -111,11 +138,17 @@ var shader_module_default = {
     }
     const { brushingEnabled = true, brushingRadius = 1e4, brushingTarget = "source", mousePosition, viewport } = opts;
     return {
-      brushing_enabled: Boolean(brushingEnabled && mousePosition && viewport.containsPixel(mousePosition)),
-      brushing_radius: brushingRadius,
-      brushing_target: TARGET[brushingTarget] || 0,
-      brushing_mousePos: mousePosition ? viewport.unproject([mousePosition.x - viewport.x, mousePosition.y - viewport.y]) : [0, 0]
+      enabled: Boolean(brushingEnabled && mousePosition && viewport.containsPixel(mousePosition)),
+      radius: brushingRadius,
+      target: TARGET[brushingTarget] || 0,
+      mousePos: mousePosition ? viewport.unproject([mousePosition.x - viewport.x, mousePosition.y - viewport.y]) : [0, 0]
     };
+  },
+  uniformTypes: {
+    enabled: "i32",
+    target: "i32",
+    mousePos: "vec2<f32>",
+    radius: "f32"
   }
 };
 
@@ -164,6 +197,18 @@ var BrushingExtension = class extends import_core2.LayerExtension {
       });
     }
   }
+  draw(params, extension) {
+    const { viewport, mousePosition } = params.context;
+    const { brushingEnabled, brushingRadius, brushingTarget } = this.props;
+    const brushingProps = {
+      viewport,
+      mousePosition,
+      brushingEnabled,
+      brushingRadius,
+      brushingTarget
+    };
+    this.setShaderModuleProps({ brushing: brushingProps });
+  }
 };
 BrushingExtension.defaultProps = defaultProps;
 BrushingExtension.extensionName = "BrushingExtension";
@@ -173,110 +218,147 @@ var brushing_extension_default = BrushingExtension;
 var import_core3 = require("@deck.gl/core");
 
 // dist/data-filter/shader-module.js
-var vs2 = `
-uniform bool filter_useSoftMargin;
-uniform bool filter_enabled;
-uniform bool filter_transformSize;
-uniform ivec4 filter_categoryBitMask;
+var uniformBlock2 = (
+  /* glsl */
+  `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
+  highp ivec4 categoryBitMask;
+#endif
+} dataFilter;
+`
+);
+var vertex2 = (
+  /* glsl */
+  `
 #ifdef DATAFILTER_TYPE
-uniform DATAFILTER_TYPE filter_min;
-uniform DATAFILTER_TYPE filter_softMin;
-uniform DATAFILTER_TYPE filter_softMax;
-uniform DATAFILTER_TYPE filter_max;
-in DATAFILTER_TYPE filterValues;
+  in DATAFILTER_TYPE filterValues;
 #ifdef DATAFILTER_DOUBLE
-in DATAFILTER_TYPE filterValues64Low;
-uniform DATAFILTER_TYPE filter_min64High;
-uniform DATAFILTER_TYPE filter_max64High;
+  in DATAFILTER_TYPE filterValues64Low;
 #endif
 #endif
+
 #ifdef DATACATEGORY_TYPE
-in DATACATEGORY_TYPE filterCategoryValues;
+  in DATACATEGORY_TYPE filterCategoryValues;
 #endif
+
 out float dataFilter_value;
+
 float dataFilter_reduceValue(float value) {
-return value;
+  return value;
 }
 float dataFilter_reduceValue(vec2 value) {
-return min(value.x, value.y);
+  return min(value.x, value.y);
 }
 float dataFilter_reduceValue(vec3 value) {
-return min(min(value.x, value.y), value.z);
+  return min(min(value.x, value.y), value.z);
 }
 float dataFilter_reduceValue(vec4 value) {
-return min(min(value.x, value.y), min(value.z, value.w));
+  return min(min(value.x, value.y), min(value.z, value.w));
 }
+
 #ifdef DATAFILTER_TYPE
-void dataFilter_setValue(DATAFILTER_TYPE valueFromMin, DATAFILTER_TYPE valueFromMax) {
-if (filter_useSoftMargin) {
-DATAFILTER_TYPE leftInRange = mix(
-smoothstep(filter_min, filter_softMin, valueFromMin),
-step(filter_min, valueFromMin),
-step(filter_softMin, filter_min)
-);
-DATAFILTER_TYPE rightInRange = mix(
-1.0 - smoothstep(filter_softMax, filter_max, valueFromMax),
-step(valueFromMax, filter_max),
-step(filter_max, filter_softMax)
-);
-dataFilter_value = dataFilter_reduceValue(leftInRange * rightInRange);
-} else {
-dataFilter_value = dataFilter_reduceValue(
-step(filter_min, valueFromMin) * step(valueFromMax, filter_max)
-);
-}
-}
+  void dataFilter_setValue(DATAFILTER_TYPE valueFromMin, DATAFILTER_TYPE valueFromMax) {
+    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)
+      );
+      DATAFILTER_TYPE rightInRange = mix(
+        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)
+      );
+    }
+  }
 #endif
+
 #ifdef DATACATEGORY_TYPE
-void dataFilter_setCategoryValue(DATACATEGORY_TYPE category) {
-#if DATACATEGORY_CHANNELS == 1
-int dataFilter_masks = filter_categoryBitMask[int(category / 32.0)];
-#elif DATACATEGORY_CHANNELS == 2
-ivec2 dataFilter_masks = ivec2(
-filter_categoryBitMask[int(category.x / 32.0)],
-filter_categoryBitMask[int(category.y / 32.0) + 2]
-);
-#elif DATACATEGORY_CHANNELS == 3
-ivec3 dataFilter_masks = filter_categoryBitMask.xyz;
-#else
-ivec4 dataFilter_masks = filter_categoryBitMask;
-#endif
-DATACATEGORY_TYPE dataFilter_bits = DATACATEGORY_TYPE(dataFilter_masks) / pow(DATACATEGORY_TYPE(2.0), mod(category, 32.0));
-dataFilter_bits = mod(floor(dataFilter_bits), 2.0);
-#if DATACATEGORY_CHANNELS == 1
-if(dataFilter_bits == 0.0) dataFilter_value = 0.0;
-#else
-if(any(equal(dataFilter_bits, DATACATEGORY_TYPE(0.0)))) dataFilter_value = 0.0;
-#endif
-}
+  void dataFilter_setCategoryValue(DATACATEGORY_TYPE category) {
+    #if DATACATEGORY_CHANNELS == 1 // One 128-bit mask
+    int dataFilter_masks = dataFilter.categoryBitMask[int(category / 32.0)];
+    #elif DATACATEGORY_CHANNELS == 2 // Two 64-bit masks
+    ivec2 dataFilter_masks = ivec2(
+      dataFilter.categoryBitMask[int(category.x / 32.0)],
+      dataFilter.categoryBitMask[int(category.y / 32.0) + 2]
+    );
+    #elif DATACATEGORY_CHANNELS == 3 // Three 32-bit masks
+    ivec3 dataFilter_masks = dataFilter.categoryBitMask.xyz;
+    #else // Four 32-bit masks
+    ivec4 dataFilter_masks = dataFilter.categoryBitMask;
+    #endif
+
+    // Shift mask and extract relevant bits
+    DATACATEGORY_TYPE dataFilter_bits = DATACATEGORY_TYPE(dataFilter_masks) / pow(DATACATEGORY_TYPE(2.0), mod(category, 32.0));
+    dataFilter_bits = mod(floor(dataFilter_bits), 2.0);
+
+    #if DATACATEGORY_CHANNELS == 1
+    if(dataFilter_bits == 0.0) dataFilter_value = 0.0;
+    #else
+    if(any(equal(dataFilter_bits, DATACATEGORY_TYPE(0.0)))) dataFilter_value = 0.0;
+    #endif
+  }
 #endif
+`
+);
+var vs2 = `
+${uniformBlock2}
+${vertex2}
 `;
-var fs2 = `
-uniform bool filter_transformColor;
+var fragment2 = (
+  /* glsl */
+  `
 in float dataFilter_value;
+`
+);
+var fs2 = `
+${uniformBlock2}
+${fragment2}
 `;
 function getUniforms(opts) {
   if (!opts || !("extensions" in opts)) {
     return {};
   }
-  const { filterRange = [-1, 1], filterEnabled = true, filterTransformSize = true, filterTransformColor = true } = opts;
+  const { filterRange = [-1, 1], filterEnabled = true, filterTransformSize = true, filterTransformColor = true, categoryBitMask = [0, 0, 0, 0] } = opts;
   const filterSoftRange = opts.filterSoftRange || filterRange;
   return {
     ...Number.isFinite(filterRange[0]) ? {
-      filter_min: filterRange[0],
-      filter_softMin: filterSoftRange[0],
-      filter_softMax: filterSoftRange[1],
-      filter_max: filterRange[1]
+      min: filterRange[0],
+      softMin: filterSoftRange[0],
+      softMax: filterSoftRange[1],
+      max: filterRange[1]
     } : {
-      filter_min: filterRange.map((r) => r[0]),
-      filter_softMin: filterSoftRange.map((r) => r[0]),
-      filter_softMax: filterSoftRange.map((r) => r[1]),
-      filter_max: filterRange.map((r) => r[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])
     },
-    filter_enabled: filterEnabled,
-    filter_useSoftMargin: Boolean(opts.filterSoftRange),
-    filter_transformSize: filterEnabled && filterTransformSize,
-    filter_transformColor: filterEnabled && filterTransformColor
+    enabled: filterEnabled,
+    useSoftMargin: Boolean(opts.filterSoftRange),
+    transformSize: filterEnabled && filterTransformSize,
+    transformColor: filterEnabled && filterTransformColor,
+    categoryBitMask
   };
 }
 function getUniforms64(opts) {
@@ -284,81 +366,119 @@ function getUniforms64(opts) {
     return {};
   }
   const uniforms = getUniforms(opts);
-  if (Number.isFinite(uniforms.filter_min)) {
-    const min64High = Math.fround(uniforms.filter_min);
-    uniforms.filter_min -= min64High;
-    uniforms.filter_softMin -= min64High;
-    uniforms.filter_min64High = min64High;
-    const max64High = Math.fround(uniforms.filter_max);
-    uniforms.filter_max -= max64High;
-    uniforms.filter_softMax -= max64High;
-    uniforms.filter_max64High = max64High;
+  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.filter_min.map(Math.fround);
-    uniforms.filter_min = uniforms.filter_min.map((x, i) => x - min64High[i]);
-    uniforms.filter_softMin = uniforms.filter_softMin.map((x, i) => x - min64High[i]);
-    uniforms.filter_min64High = min64High;
-    const max64High = uniforms.filter_max.map(Math.fround);
-    uniforms.filter_max = uniforms.filter_max.map((x, i) => x - max64High[i]);
-    uniforms.filter_softMax = uniforms.filter_softMax.map((x, i) => x - max64High[i]);
-    uniforms.filter_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 = {
-  "vs:#main-start": `
-dataFilter_value = 1.0;
-if (filter_enabled) {
-#ifdef DATAFILTER_TYPE
-#ifdef DATAFILTER_DOUBLE
-dataFilter_setValue(
-filterValues - filter_min64High + filterValues64Low,
-filterValues - filter_max64High + filterValues64Low
-);
-#else
-dataFilter_setValue(filterValues, filterValues);
-#endif
-#endif
-#ifdef DATACATEGORY_TYPE
-dataFilter_setCategoryValue(filterCategoryValues);
-#endif
-}
-`,
-  "vs:#main-end": `
-if (dataFilter_value == 0.0) {
-gl_Position = vec4(0.);
-}
-`,
-  "vs:DECKGL_FILTER_SIZE": `
-if (filter_transformSize) {
-size = size * dataFilter_value;
-}
-`,
-  "fs:DECKGL_FILTER_COLOR": `
-if (dataFilter_value == 0.0) discard;
-if (filter_transformColor) {
-color.a *= dataFilter_value;
-}
-`
+  "vs:#main-start": (
+    /* glsl */
+    `
+    dataFilter_value = 1.0;
+    if (dataFilter.enabled) {
+      #ifdef DATAFILTER_TYPE
+        #ifdef DATAFILTER_DOUBLE
+          dataFilter_setValue(
+            filterValues - dataFilter.min64High + filterValues64Low,
+            filterValues - dataFilter.max64High + filterValues64Low
+          );
+        #else
+          dataFilter_setValue(filterValues, filterValues);
+        #endif
+      #endif
+
+      #ifdef DATACATEGORY_TYPE
+        dataFilter_setCategoryValue(filterCategoryValues);
+      #endif
+    }
+  `
+  ),
+  "vs:#main-end": (
+    /* glsl */
+    `
+    if (dataFilter_value == 0.0) {
+      gl_Position = vec4(0.);
+    }
+  `
+  ),
+  "vs:DECKGL_FILTER_SIZE": (
+    /* glsl */
+    `
+    if (dataFilter.transformSize) {
+      size = size * dataFilter_value;
+    }
+  `
+  ),
+  "fs:DECKGL_FILTER_COLOR": (
+    /* glsl */
+    `
+    if (dataFilter_value == 0.0) discard;
+    if (dataFilter.transformColor) {
+      color.a *= dataFilter_value;
+    }
+  `
+  )
 };
-var shaderModule = {
-  name: "data-filter",
+function uniformTypesFromOptions(opts) {
+  const { categorySize, filterSize, fp64: fp642 } = opts;
+  const uniformTypes = {
+    useSoftMargin: "i32",
+    enabled: "i32",
+    transformSize: "i32",
+    transformColor: "i32"
+  };
+  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 = {
+  name: "dataFilter",
   vs: vs2,
   fs: fs2,
   inject: inject2,
-  getUniforms
+  getUniforms,
+  uniformTypesFromOptions
 };
-var shaderModule64 = {
-  name: "data-filter-fp64",
+var dataFilter64 = {
+  name: "dataFilter",
   vs: vs2,
   fs: fs2,
   inject: inject2,
-  getUniforms: getUniforms64
+  getUniforms: getUniforms64,
+  uniformTypesFromOptions
 };
 
 // dist/data-filter/aggregator.js
 var import_engine = require("@luma.gl/engine");
-var import_constants = require("@luma.gl/constants");
 var AGGREGATE_VS = `#version 300 es
 #define SHADER_NAME data-filter-vertex-shader
 
@@ -408,7 +528,9 @@ void main() {
 `;
 var FLOAT_TARGET_FEATURES = [
   "float32-renderable-webgl",
+  // ability to render to float texture
   "texture-blend-float-webgl"
+  // ability to blend when rendering to float texture
 ];
 function supportsFloatTarget(device) {
   return FLOAT_TARGET_FEATURES.every((feature) => device.features.has(feature));
@@ -421,7 +543,6 @@ function getFramebuffer(device, useFloatTarget) {
       colorAttachments: [
         device.createTexture({
           format: "rgba32float",
-          type: 5126,
           mipmaps: false
         })
       ]
@@ -430,10 +551,10 @@ function getFramebuffer(device, useFloatTarget) {
   return device.createFramebuffer({
     width: 256,
     height: 64,
-    colorAttachments: [device.createTexture({ format: "rgba8unorm", type: 5126, mipmaps: false })]
+    colorAttachments: [device.createTexture({ format: "rgba8unorm", mipmaps: false })]
   });
 }
-function getModel(device, shaderOptions, useFloatTarget) {
+function getModel(device, bufferLayout, shaderOptions, useFloatTarget) {
   shaderOptions.defines.NON_INSTANCED_MODEL = 1;
   if (useFloatTarget) {
     shaderOptions.defines.FLOAT_TARGET = 1;
@@ -442,17 +563,22 @@ function getModel(device, shaderOptions, useFloatTarget) {
     id: "data-filter-aggregation-model",
     vertexCount: 1,
     isInstanced: false,
-    drawMode: 0,
+    topology: "point-list",
     vs: AGGREGATE_VS,
     fs: AGGREGATE_FS,
+    bufferLayout,
     ...shaderOptions
   });
 }
 var parameters = {
   blend: true,
-  blendFunc: [1, 1, 1, 1],
-  blendEquation: [32774, 32774],
-  depthTest: false
+  blendColorSrcFactor: "one",
+  blendColorDstFactor: "one",
+  blendAlphaSrcFactor: "one",
+  blendAlphaDstFactor: "one",
+  blendColorOperation: "add",
+  blendAlphaOperation: "add",
+  depthCompare: "never"
 };
 
 // dist/data-filter/data-filter-extension.js
@@ -494,7 +620,9 @@ var DataFilterExtension = class extends import_core3.LayerExtension {
       defines.DATAFILTER_TYPE = DATA_TYPE_FROM_SIZE[filterSize];
       defines.DATAFILTER_DOUBLE = Boolean(fp642);
     }
-    return { modules: [fp642 ? shaderModule64 : shaderModule], defines };
+    const module2 = fp642 ? dataFilter64 : dataFilter;
+    module2.uniformTypes = module2.uniformTypesFromOptions(extension.opts);
+    return { modules: [module2], defines };
   }
   initializeState(context, extension) {
     const attributeManager = this.getAttributeManager();
@@ -525,7 +653,7 @@ var DataFilterExtension = class extends import_core3.LayerExtension {
     if (attributeManager && extension.opts.countItems) {
       const useFloatTarget = supportsFloatTarget(device);
       attributeManager.add({
-        filterIndices: {
+        filterVertexIndices: {
           size: useFloatTarget ? 1 : 2,
           vertexOffset: 1,
           type: "unorm8",
@@ -544,7 +672,7 @@ var DataFilterExtension = class extends import_core3.LayerExtension {
         }
       });
       const filterFBO = getFramebuffer(device, useFloatTarget);
-      const filterModel = getModel(device, extension.getShaders.call(this, extension), useFloatTarget);
+      const filterModel = getModel(device, attributeManager.getBufferLayouts({ isInstanced: false }), extension.getShaders.call(this, extension), useFloatTarget);
       this.setState({ filterFBO, filterModel });
     }
   }
@@ -553,7 +681,10 @@ var DataFilterExtension = class extends import_core3.LayerExtension {
     const attributeManager = this.getAttributeManager();
     const { categorySize } = extension.opts;
     if (this.state.filterModel) {
-      const filterNeedsUpdate = ((_a = attributeManager.attributes.filterValues) == null ? void 0 : _a.needsUpdate()) || ((_b = attributeManager.attributes.filterCategoryValues) == null ? void 0 : _b.needsUpdate()) || props.filterEnabled !== oldProps.filterEnabled || props.filterRange !== oldProps.filterRange || props.filterSoftRange !== oldProps.filterSoftRange || props.filterCategories !== oldProps.filterCategories;
+      const filterNeedsUpdate = (
+        // attributeManager must be defined for filterModel to be set
+        ((_a = attributeManager.attributes.filterValues) == null ? void 0 : _a.needsUpdate()) || ((_b = attributeManager.attributes.filterCategoryValues) == null ? void 0 : _b.needsUpdate()) || props.filterEnabled !== oldProps.filterEnabled || props.filterRange !== oldProps.filterRange || props.filterSoftRange !== oldProps.filterSoftRange || props.filterCategories !== oldProps.filterCategories
+      );
       if (filterNeedsUpdate) {
         this.setState({ filterNeedsUpdate });
       }
@@ -576,29 +707,46 @@ var DataFilterExtension = class extends import_core3.LayerExtension {
     const filterFBO = this.state.filterFBO;
     const filterModel = this.state.filterModel;
     const filterNeedsUpdate = this.state.filterNeedsUpdate;
-    const { onFilteredItemsChange } = this.props;
     if (!this.state.categoryBitMask) {
       extension._updateCategoryBitMask.call(this, params, extension);
     }
-    params.uniforms.filter_categoryBitMask = this.state.categoryBitMask;
+    const { onFilteredItemsChange, extensions, filterEnabled, filterRange, filterSoftRange, filterTransformSize, filterTransformColor, filterCategories } = this.props;
+    const dataFilterProps = {
+      extensions,
+      filterEnabled,
+      filterRange,
+      filterSoftRange,
+      filterTransformSize,
+      filterTransformColor,
+      filterCategories
+    };
+    if (this.state.categoryBitMask) {
+      dataFilterProps.categoryBitMask = this.state.categoryBitMask;
+    }
+    this.setShaderModuleProps({ dataFilter: dataFilterProps });
     if (filterNeedsUpdate && onFilteredItemsChange && filterModel) {
-      const { attributes: { filterValues, filterCategoryValues, filterIndices } } = this.getAttributeManager();
+      const attributeManager = this.getAttributeManager();
+      const { attributes: { filterValues, filterCategoryValues, filterVertexIndices } } = attributeManager;
       filterModel.setVertexCount(this.getNumInstances());
-      this.context.device.clearWebGL({ framebuffer: filterFBO, color: [0, 0, 0, 0] });
-      filterModel.updateModuleSettings(params.moduleParameters);
-      filterModel.setAttributes({
+      const attributes = {
         ...filterValues == null ? void 0 : filterValues.getValue(),
         ...filterCategoryValues == null ? void 0 : filterCategoryValues.getValue(),
-        ...filterIndices == null ? void 0 : filterIndices.getValue()
+        ...filterVertexIndices == null ? void 0 : filterVertexIndices.getValue()
+      };
+      filterModel.setAttributes(attributes);
+      filterModel.shaderInputs.setProps({
+        dataFilter: dataFilterProps
       });
-      filterModel.setUniforms(params.uniforms);
-      filterModel.device.withParametersWebGL({
+      const viewport = [0, 0, filterFBO.width, filterFBO.height];
+      const renderPass = filterModel.device.beginRenderPass({
+        id: "data-filter-aggregation",
         framebuffer: filterFBO,
-        ...parameters,
-        viewport: [0, 0, filterFBO.width, filterFBO.height]
-      }, () => {
-        filterModel.draw(this.context.renderPass);
+        parameters: { viewport },
+        clearColor: [0, 0, 0, 0]
       });
+      filterModel.setParameters(parameters);
+      filterModel.draw(renderPass);
+      renderPass.end();
       const color = filterModel.device.readPixelsToArrayWebGL(filterFBO);
       let count = 0;
       for (let i = 0; i < color.length; i++) {
@@ -614,6 +762,11 @@ var DataFilterExtension = class extends import_core3.LayerExtension {
     filterFBO == null ? void 0 : filterFBO.destroy();
     filterModel == null ? void 0 : filterModel.destroy();
   }
+  /**
+   * Updates the bitmask used on the GPU to perform the filter based on the
+   * `filterCategories` prop. The mapping between categories and bit in the bitmask
+   * is performed by `_getCategoryKey()`
+   */
   _updateCategoryBitMask(params, extension) {
     const { categorySize } = extension.opts;
     if (!categorySize)
@@ -636,6 +789,10 @@ var DataFilterExtension = class extends import_core3.LayerExtension {
     }
     this.state.categoryBitMask = categoryBitMask;
   }
+  /**
+   * Returns an index of bit in the bitmask for a given category. If the category has
+   * not yet been assigned a bit, a new one is assigned.
+   */
   _getCategoryKey(category, channel) {
     const categoryMap = this.state.categoryMap[channel];
     if (!(category in categoryMap)) {
@@ -657,7 +814,11 @@ var import_core4 = require("@deck.gl/core");
 
 // dist/fp64/project64.glsl.js
 var project64_glsl_default = `const vec2 WORLD_SCALE_FP64 = vec2(81.4873275756836, 0.0000032873668232014097);
-uniform vec2 project_uViewProjectionMatrixFP64[16];
+uniform project64Uniforms {
+vec2 scale;
+mat4 viewProjectionMatrix;
+mat4 viewProjectionMatrix64Low;
+} project64;
 void mercatorProject_fp64(vec4 lnglat_fp64, out vec2 out_val[2]) {
 #if defined(NVIDIA_FP64_WORKAROUND)
 out_val[0] = sum_fp64(radians_fp64(lnglat_fp64.xy), PI_FP64 * ONE);
@@ -683,7 +844,16 @@ project_position_fp64(position64xy, out_val);
 }
 vec4 project_common_position_to_clipspace_fp64(vec2 vertex_pos_modelspace[4]) {
 vec2 vertex_pos_clipspace[4];
-mat4_vec4_mul_fp64(project_uViewProjectionMatrixFP64, vertex_pos_modelspace,
+vec2 viewProjectionMatrixFP64[16];
+for (int i = 0; i < 4; i++) {
+for (int j = 0; j < 4; j++) {
+viewProjectionMatrixFP64[4 * i + j] = vec2(
+project64.viewProjectionMatrix[j][i],
+project64.viewProjectionMatrix64Low[j][i]
+);
+}
+}
+mat4_vec4_mul_fp64(viewProjectionMatrixFP64, vertex_pos_modelspace,
 vertex_pos_clipspace);
 return vec4(
 vertex_pos_clipspace[0].x,
@@ -724,7 +894,13 @@ var project64_default = {
   name: "project64",
   dependencies: [import_core4.project, import_shadertools.fp64],
   vs: project64_glsl_default,
-  getUniforms: getUniforms2
+  getUniforms: getUniforms2,
+  uniformTypes: {
+    scale: "vec2<f32>",
+    // Cannot pass as vec2[16], so instead split into 2 mat4x4
+    viewProjectionMatrix: "mat4x4<f32>",
+    viewProjectionMatrix64Low: "mat4x4<f32>"
+  }
 };
 var getMemoizedUniforms = (0, import_core4._memoize)(calculateUniforms);
 function getUniforms2(opts) {
@@ -736,11 +912,20 @@ function getUniforms2(opts) {
 }
 function calculateUniforms({ viewProjectionMatrix, scale }) {
   const glViewProjectionMatrixFP64 = fp64ifyMatrix4(viewProjectionMatrix);
-  const scaleFP64 = fp64ify(scale);
+  const viewProjectionMatrix64High = new Float32Array(16);
+  const viewProjectionMatrix64Low = new Float32Array(16);
+  for (let i = 0; i < 4; i++) {
+    for (let j = 0; j < 4; j++) {
+      const from = 4 * i + j;
+      const to = 4 * j + i;
+      viewProjectionMatrix64High[to] = glViewProjectionMatrixFP64[2 * from];
+      viewProjectionMatrix64Low[to] = glViewProjectionMatrixFP64[2 * from + 1];
+    }
+  }
   return {
-    project_uViewProjectionMatrixFP64: glViewProjectionMatrixFP64,
-    project64_uViewProjectionMatrix: glViewProjectionMatrixFP64,
-    project64_uScale: scaleFP64
+    scale: fp64ify(scale),
+    viewProjectionMatrix: [...viewProjectionMatrix64High],
+    viewProjectionMatrix64Low: [...viewProjectionMatrix64Low]
   };
 }
 
@@ -755,6 +940,10 @@ var Fp64Extension = class extends import_core5.LayerExtension {
       modules: [project64_default]
     };
   }
+  draw(params, extension) {
+    const { viewport } = params.context;
+    this.setShaderModuleProps({ project64: { viewport } });
+  }
 };
 Fp64Extension.extensionName = "Fp64Extension";
 var fp64_extension_default = Fp64Extension;
@@ -777,19 +966,28 @@ vDashArray = instanceDashArrays;
 vDashOffset = instanceDashOffsets / width.x;
 `,
     "fs:#decl": `
-uniform float dashAlignMode;
-uniform float capType;
-uniform bool dashGapPickable;
+uniform pathStyleUniforms {
+float dashAlignMode;
+bool dashGapPickable;
+} pathStyle;
 in vec2 vDashArray;
 in float vDashOffset;
 `,
+    // if given position is in the gap part of the dashed line
+    // dashArray.x: solid stroke length, relative to width
+    // dashArray.y: gap length, relative to width
+    // alignMode:
+    // 0 - no adjustment
+    // o----     ----     ----     ---- o----     -o----     ----     o
+    // 1 - stretch to fit, draw half dash at each end for nicer joints
+    // o--    ----    ----    ----    --o--      --o--     ----     --o
     "fs:#main-start": `
 float solidLength = vDashArray.x;
 float gapLength = vDashArray.y;
 float unitLength = solidLength + gapLength;
 float offset;
 if (unitLength > 0.0) {
-if (dashAlignMode == 0.0) {
+if (pathStyle.dashAlignMode == 0.0) {
 offset = vDashOffset;
 } else {
 unitLength = vPathLength / round(vPathLength / unitLength);
@@ -797,8 +995,8 @@ offset = solidLength / 2.0;
 }
 float unitOffset = mod(vPathPosition.y + offset, unitLength);
 if (gapLength > 0.0 && unitOffset > solidLength) {
-if (capType <= 0.5) {
-if (!(dashGapPickable && bool(picking.isActive))) {
+if (path.capType <= 0.5) {
+if (!(pathStyle.dashGapPickable && bool(picking.isActive))) {
 discard;
 }
 } else {
@@ -807,7 +1005,7 @@ min(unitOffset - solidLength, unitLength - unitOffset),
 vPathPosition.x
 ));
 if (distToEnd > 1.0) {
-if (!(dashGapPickable && bool(picking.isActive))) {
+if (!(pathStyle.dashGapPickable && bool(picking.isActive))) {
 discard;
 }
 }
@@ -868,7 +1066,18 @@ var PathStyleExtension = class extends import_core6.LayerExtension {
     if (extension.opts.offset) {
       result = (0, import_core6._mergeShaders)(result, offsetShaders);
     }
-    return result;
+    const { inject: inject6 } = result;
+    const pathStyle = {
+      name: "pathStyle",
+      inject: inject6,
+      uniformTypes: {
+        dashAlignMode: "f32",
+        dashGapPickable: "i32"
+      }
+    };
+    return {
+      modules: [pathStyle]
+    };
   }
   initializeState(context, extension) {
     const attributeManager = this.getAttributeManager();
@@ -898,16 +1107,16 @@ var PathStyleExtension = class extends import_core6.LayerExtension {
     }
   }
   updateState(params, extension) {
-    var _a;
     if (!extension.isEnabled(this)) {
       return;
     }
-    const uniforms = {};
     if (extension.opts.dash) {
-      uniforms.dashAlignMode = this.props.dashJustified ? 1 : 0;
-      uniforms.dashGapPickable = Boolean(this.props.dashGapPickable);
+      const pathStyleProps = {
+        dashAlignMode: this.props.dashJustified ? 1 : 0,
+        dashGapPickable: Boolean(this.props.dashGapPickable)
+      };
+      this.setShaderModuleProps({ pathStyle: pathStyleProps });
     }
-    (_a = this.state.model) == null ? void 0 : _a.setUniforms(uniforms);
   }
   getDashOffsets(path) {
     const result = [0];
@@ -937,86 +1146,124 @@ var import_core9 = require("@deck.gl/core");
 
 // dist/fill-style/shader-module.js
 var import_core8 = require("@deck.gl/core");
-var patternVs = `
+var uniformBlock3 = (
+  /* glsl */
+  `uniform fillUniforms {
+  vec2 patternTextureSize;
+  bool patternEnabled;
+  bool patternMask;
+  vec2 uvCoordinateOrigin;
+  vec2 uvCoordinateOrigin64Low;
+} fill;
+`
+);
+var patternVs = (
+  /* glsl */
+  `
 in vec4 fillPatternFrames;
 in float fillPatternScales;
 in vec2 fillPatternOffsets;
-uniform bool fill_patternEnabled;
-uniform vec2 fill_patternTextureSize;
+
 out vec2 fill_uv;
 out vec4 fill_patternBounds;
 out vec4 fill_patternPlacement;
+`
+);
+var vs3 = `
+${uniformBlock3}
+${patternVs}
 `;
-var patternFs = `
-uniform bool fill_patternEnabled;
-uniform bool fill_patternMask;
+var patternFs = (
+  /* glsl */
+  `
 uniform sampler2D fill_patternTexture;
-uniform vec2 fill_uvCoordinateOrigin;
-uniform vec2 fill_uvCoordinateOrigin64Low;
+
 in vec4 fill_patternBounds;
 in vec4 fill_patternPlacement;
 in vec2 fill_uv;
+
 const float FILL_UV_SCALE = 512.0 / 40000000.0;
+`
+);
+var fs3 = `
+${uniformBlock3}
+${patternFs}
 `;
 var inject3 = {
-  "vs:DECKGL_FILTER_GL_POSITION": `
-fill_uv = geometry.position.xy;
-`,
-  "vs:DECKGL_FILTER_COLOR": `
-if (fill_patternEnabled) {
-fill_patternBounds = fillPatternFrames / vec4(fill_patternTextureSize, fill_patternTextureSize);
-fill_patternPlacement.xy = fillPatternOffsets;
-fill_patternPlacement.zw = fillPatternScales * fillPatternFrames.zw;
-}
-`,
-  "fs:DECKGL_FILTER_COLOR": `
-if (fill_patternEnabled) {
-vec2 scale = FILL_UV_SCALE * fill_patternPlacement.zw;
-vec2 patternUV = mod(mod(fill_uvCoordinateOrigin, scale) + fill_uvCoordinateOrigin64Low + fill_uv, scale) / scale;
-patternUV = mod(fill_patternPlacement.xy + patternUV, 1.0);
-vec2 texCoords = fill_patternBounds.xy + fill_patternBounds.zw * patternUV;
-vec4 patternColor = texture(fill_patternTexture, texCoords);
-color.a *= patternColor.a;
-if (!fill_patternMask) {
-color.rgb = patternColor.rgb;
-}
-}
-`
+  "vs:DECKGL_FILTER_GL_POSITION": (
+    /* glsl */
+    `
+    fill_uv = geometry.position.xy;
+  `
+  ),
+  "vs:DECKGL_FILTER_COLOR": (
+    /* glsl */
+    `
+    if (fill.patternEnabled) {
+      fill_patternBounds = fillPatternFrames / vec4(fill.patternTextureSize, fill.patternTextureSize);
+      fill_patternPlacement.xy = fillPatternOffsets;
+      fill_patternPlacement.zw = fillPatternScales * fillPatternFrames.zw;
+    }
+  `
+  ),
+  "fs:DECKGL_FILTER_COLOR": (
+    /* glsl */
+    `
+    if (fill.patternEnabled) {
+      vec2 scale = FILL_UV_SCALE * fill_patternPlacement.zw;
+      vec2 patternUV = mod(mod(fill.uvCoordinateOrigin, scale) + fill.uvCoordinateOrigin64Low + fill_uv, scale) / scale;
+      patternUV = mod(fill_patternPlacement.xy + patternUV, 1.0);
+
+      vec2 texCoords = fill_patternBounds.xy + fill_patternBounds.zw * patternUV;
+
+      vec4 patternColor = texture(fill_patternTexture, texCoords);
+      color.a *= patternColor.a;
+      if (!fill.patternMask) {
+        color.rgb = patternColor.rgb;
+      }
+    }
+  `
+  )
 };
-function getPatternUniforms(opts, uniforms) {
+function getPatternUniforms(opts) {
   if (!opts) {
     return {};
   }
+  const uniforms = {};
   if ("fillPatternTexture" in opts) {
     const { fillPatternTexture } = opts;
-    return {
-      fill_patternTexture: fillPatternTexture,
-      fill_patternTextureSize: [fillPatternTexture.width, fillPatternTexture.height]
-    };
+    uniforms.fill_patternTexture = fillPatternTexture;
+    uniforms.patternTextureSize = [fillPatternTexture.width, fillPatternTexture.height];
   }
-  if ("viewport" in opts) {
+  if ("project" in opts) {
     const { fillPatternMask = true, fillPatternEnabled = true } = opts;
-    const { project_uCommonOrigin: coordinateOriginCommon } = uniforms;
+    const projectUniforms = import_core8.project.getUniforms(opts.project);
+    const { commonOrigin: coordinateOriginCommon } = projectUniforms;
     const coordinateOriginCommon64Low = [
       (0, import_core8.fp64LowPart)(coordinateOriginCommon[0]),
       (0, import_core8.fp64LowPart)(coordinateOriginCommon[1])
     ];
-    return {
-      fill_uvCoordinateOrigin: coordinateOriginCommon.slice(0, 2),
-      fill_uvCoordinateOrigin64Low: coordinateOriginCommon64Low,
-      fill_patternMask: fillPatternMask,
-      fill_patternEnabled: fillPatternEnabled
-    };
+    uniforms.uvCoordinateOrigin = coordinateOriginCommon.slice(0, 2);
+    uniforms.uvCoordinateOrigin64Low = coordinateOriginCommon64Low;
+    uniforms.patternMask = fillPatternMask;
+    uniforms.patternEnabled = fillPatternEnabled;
   }
-  return {};
+  return uniforms;
 }
 var patternShaders = {
-  name: "fill-pattern",
-  vs: patternVs,
-  fs: patternFs,
+  name: "fill",
+  vs: vs3,
+  fs: fs3,
   inject: inject3,
   dependencies: [import_core8.project],
-  getUniforms: getPatternUniforms
+  getUniforms: getPatternUniforms,
+  uniformTypes: {
+    patternTextureSize: "vec2<f32>",
+    patternEnabled: "i32",
+    patternMask: "i32",
+    uvCoordinateOrigin: "vec2<f32>",
+    uvCoordinateOrigin64Low: "vec2<f32>"
+  }
 };
 
 // dist/fill-style/fill-style-extension.js
@@ -1095,10 +1342,14 @@ var FillStyleExtension = class extends import_core9.LayerExtension {
     if (!extension.isEnabled(this)) {
       return;
     }
-    const { fillPatternAtlas } = this.props;
-    this.setModuleParameters({
+    const { fillPatternAtlas, fillPatternEnabled, fillPatternMask } = this.props;
+    const fillProps = {
+      project: params.shaderModuleProps.project,
+      fillPatternEnabled,
+      fillPatternMask,
       fillPatternTexture: fillPatternAtlas || this.state.emptyTexture
-    });
+    };
+    this.setShaderModuleProps({ fill: fillProps });
   }
   finalizeState() {
     const emptyTexture = this.state.emptyTexture;
@@ -1120,47 +1371,83 @@ var defaultProps5 = {
   clipBounds: [0, 0, 1, 1],
   clipByInstance: void 0
 };
-var shaderFunction = `
-uniform vec4 clip_bounds;
+var shaderFunction = (
+  /* glsl */
+  `
+uniform clipUniforms {
+  vec4 bounds;
+} clip;
+
 bool clip_isInBounds(vec2 position) {
-return position.x >= clip_bounds[0] && position.y >= clip_bounds[1] && position.x < clip_bounds[2] && position.y < clip_bounds[3];
+  return position.x >= clip.bounds[0] && position.y >= clip.bounds[1] && position.x < clip.bounds[2] && position.y < clip.bounds[3];
 }
-`;
+`
+);
 var shaderModuleVs = {
-  name: "clip-vs",
-  vs: shaderFunction
+  name: "clip",
+  vs: shaderFunction,
+  uniformTypes: {
+    bounds: "vec4<f32>"
+  }
 };
 var injectionVs = {
-  "vs:#decl": `
+  "vs:#decl": (
+    /* glsl */
+    `
 out float clip_isVisible;
-`,
-  "vs:DECKGL_FILTER_GL_POSITION": `
-clip_isVisible = float(clip_isInBounds(geometry.worldPosition.xy));
-`,
-  "fs:#decl": `
+`
+  ),
+  "vs:DECKGL_FILTER_GL_POSITION": (
+    /* glsl */
+    `
+  clip_isVisible = float(clip_isInBounds(geometry.worldPosition.xy));
+`
+  ),
+  "fs:#decl": (
+    /* glsl */
+    `
 in float clip_isVisible;
-`,
-  "fs:DECKGL_FILTER_COLOR": `
-if (clip_isVisible < 0.5) discard;
 `
+  ),
+  "fs:DECKGL_FILTER_COLOR": (
+    /* glsl */
+    `
+  if (clip_isVisible < 0.5) discard;
+`
+  )
 };
 var shaderModuleFs = {
-  name: "clip-fs",
-  fs: shaderFunction
+  name: "clip",
+  fs: shaderFunction,
+  uniformTypes: {
+    bounds: "vec4<f32>"
+  }
 };
 var injectionFs = {
-  "vs:#decl": `
+  "vs:#decl": (
+    /* glsl */
+    `
 out vec2 clip_commonPosition;
-`,
-  "vs:DECKGL_FILTER_GL_POSITION": `
-clip_commonPosition = geometry.position.xy;
-`,
-  "fs:#decl": `
+`
+  ),
+  "vs:DECKGL_FILTER_GL_POSITION": (
+    /* glsl */
+    `
+  clip_commonPosition = geometry.position.xy;
+`
+  ),
+  "fs:#decl": (
+    /* glsl */
+    `
 in vec2 clip_commonPosition;
-`,
-  "fs:DECKGL_FILTER_COLOR": `
-if (!clip_isInBounds(clip_commonPosition)) discard;
 `
+  ),
+  "fs:DECKGL_FILTER_COLOR": (
+    /* glsl */
+    `
+  if (!clip_isInBounds(clip_commonPosition)) discard;
+`
+  )
 };
 var ClipExtension = class extends import_core10.LayerExtension {
   getShaders() {
@@ -1177,20 +1464,23 @@ var ClipExtension = class extends import_core10.LayerExtension {
       inject: injectionFs
     };
   }
-  draw({ uniforms }) {
+  /* eslint-disable camelcase */
+  draw() {
     const { clipBounds } = this.props;
+    const clipProps = {};
     if (this.state.clipByInstance) {
-      uniforms.clip_bounds = clipBounds;
+      clipProps.bounds = clipBounds;
     } else {
       const corner0 = this.projectPosition([clipBounds[0], clipBounds[1], 0]);
       const corner1 = this.projectPosition([clipBounds[2], clipBounds[3], 0]);
-      uniforms.clip_bounds = [
+      clipProps.bounds = [
         Math.min(corner0[0], corner1[0]),
         Math.min(corner0[1], corner1[1]),
         Math.max(corner0[0], corner1[0]),
         Math.max(corner0[1], corner1[1])
       ];
     }
+    this.setShaderModuleProps({ clip: clipProps });
   }
 };
 ClipExtension.defaultProps = defaultProps5;
@@ -1202,80 +1492,112 @@ var import_core15 = require("@deck.gl/core");
 
 // dist/collision-filter/shader-module.js
 var import_core11 = require("@deck.gl/core");
-var vs3 = `
+var vs4 = (
+  /* glsl */
+  `
 in float collisionPriorities;
+
 uniform sampler2D collision_texture;
-uniform bool collision_sort;
-uniform bool collision_enabled;
+
+uniform collisionUniforms {
+  bool sort;
+  bool enabled;
+} collision;
+
 vec2 collision_getCoords(vec4 position) {
-vec4 collision_clipspace = project_common_position_to_clipspace(position);
-return (1.0 + collision_clipspace.xy / collision_clipspace.w) / 2.0;
+  vec4 collision_clipspace = project_common_position_to_clipspace(position);
+  return (1.0 + collision_clipspace.xy / collision_clipspace.w) / 2.0;
 }
+
 float collision_match(vec2 tex, vec3 pickingColor) {
-vec4 collision_pickingColor = texture(collision_texture, tex);
-float delta = dot(abs(collision_pickingColor.rgb - pickingColor), vec3(1.0));
-float e = 0.001;
-return step(delta, e);
+  vec4 collision_pickingColor = texture(collision_texture, tex);
+  float delta = dot(abs(collision_pickingColor.rgb - pickingColor), vec3(1.0));
+  float e = 0.001;
+  return step(delta, e);
 }
+
 float collision_isVisible(vec2 texCoords, vec3 pickingColor) {
-if (!collision_enabled) {
-return 1.0;
-}
-const int N = 2;
-float accumulator = 0.0;
-vec2 step = vec2(1.0 / project_uViewportSize);
-const float floatN = float(N);
-vec2 delta = -floatN * step;
-for(int i = -N; i <= N; i++) {
-delta.x = -step.x * floatN;
-for(int j = -N; j <= N; j++) {
-accumulator += collision_match(texCoords + delta, pickingColor);
-delta.x += step.x;
-}
-delta.y += step.y;
-}
-float W = 2.0 * floatN + 1.0;
-return pow(accumulator / (W * W), 2.2);
+  if (!collision.enabled) {
+    return 1.0;
+  }
+
+  // Visibility test, sample area of 5x5 pixels in order to fade in/out.
+  // Due to the locality, the lookups will be cached
+  // This reduces the flicker present when objects are shown/hidden
+  const int N = 2;
+  float accumulator = 0.0;
+  vec2 step = vec2(1.0 / project.viewportSize);
+
+  const float floatN = float(N);
+  vec2 delta = -floatN * step;
+  for(int i = -N; i <= N; i++) {
+    delta.x = -step.x * floatN;
+    for(int j = -N; j <= N; j++) {
+      accumulator += collision_match(texCoords + delta, pickingColor);
+      delta.x += step.x;
+    }
+    delta.y += step.y;
+  }
+
+  float W = 2.0 * floatN + 1.0;
+  return pow(accumulator / (W * W), 2.2);
 }
-`;
+`
+);
 var inject4 = {
-  "vs:#decl": `
-float collision_fade = 1.0;
-`,
-  "vs:DECKGL_FILTER_GL_POSITION": `
-if (collision_sort) {
-float collisionPriority = collisionPriorities;
-position.z = -0.001 * collisionPriority * position.w;
-}
-if (collision_enabled) {
-vec4 collision_common_position = project_position(vec4(geometry.worldPosition, 1.0));
-vec2 collision_texCoords = collision_getCoords(collision_common_position);
-collision_fade = collision_isVisible(collision_texCoords, geometry.pickingColor / 255.0);
-if (collision_fade < 0.0001) {
-position = vec4(0.0, 0.0, 2.0, 1.0);
-}
-}
-`,
-  "vs:DECKGL_FILTER_COLOR": `
-color.a *= collision_fade;
+  "vs:#decl": (
+    /* glsl */
+    `
+  float collision_fade = 1.0;
 `
+  ),
+  "vs:DECKGL_FILTER_GL_POSITION": (
+    /* glsl */
+    `
+  if (collision.sort) {
+    float collisionPriority = collisionPriorities;
+    position.z = -0.001 * collisionPriority * position.w; // Support range -1000 -> 1000
+  }
+
+  if (collision.enabled) {
+    vec4 collision_common_position = project_position(vec4(geometry.worldPosition, 1.0));
+    vec2 collision_texCoords = collision_getCoords(collision_common_position);
+    collision_fade = collision_isVisible(collision_texCoords, geometry.pickingColor / 255.0);
+    if (collision_fade < 0.0001) {
+      // Position outside clip space bounds to discard
+      position = vec4(0.0, 0.0, 2.0, 1.0);
+    }
+  }
+  `
+  ),
+  "vs:DECKGL_FILTER_COLOR": (
+    /* glsl */
+    `
+  color.a *= collision_fade;
+  `
+  )
 };
-var getCollisionUniforms = (opts, uniforms) => {
+var getCollisionUniforms = (opts) => {
   if (!opts || !("dummyCollisionMap" in opts)) {
     return {};
   }
-  const { collisionFBO, drawToCollisionMap, dummyCollisionMap } = opts;
+  const { enabled, collisionFBO, drawToCollisionMap, dummyCollisionMap } = opts;
   return {
-    collision_sort: Boolean(drawToCollisionMap),
+    enabled: enabled && !drawToCollisionMap,
+    sort: Boolean(drawToCollisionMap),
     collision_texture: !drawToCollisionMap && collisionFBO ? collisionFBO.colorAttachments[0] : dummyCollisionMap
   };
 };
 var shader_module_default2 = {
   name: "collision",
   dependencies: [import_core11.project],
-  vs: vs3,
+  vs: vs4,
   inject: inject4,
-  getUniforms: getCollisionUniforms
+  getUniforms: getCollisionUniforms,
+  uniformTypes: {
+    sort: "i32",
+    enabled: "i32"
+  }
 };
 
 // dist/collision-filter/collision-filter-effect.js
@@ -1294,14 +1616,16 @@ var CollisionFilterPass = class extends import_core12._LayersPass {
   getLayerParameters(layer, layerIndex, viewport) {
     return { ...layer.props.parameters, blend: false, depthRange: [0, 1], depthTest: true };
   }
-  getModuleParameters() {
+  getShaderModuleProps() {
     return {
-      drawToCollisionMap: true,
+      collision: {
+        drawToCollisionMap: true
+      },
       picking: {
         isActive: 1,
         isAttribute: false
       },
-      lightSources: {}
+      lighting: { enabled: false }
     };
   }
 };
@@ -1330,6 +1654,7 @@ var CollisionFilterEffect = class {
       return;
     }
     const collisionLayers = layers.filter(
+      // @ts-ignore
       ({ props: { visible, collisionEnabled } }) => visible && collisionEnabled
     );
     if (collisionLayers.length === 0) {
@@ -1365,7 +1690,12 @@ var CollisionFilterEffect = class {
     if (!oldRenderInfo) {
       return;
     }
-    const needsRender = viewportChanged || renderInfo === oldRenderInfo || !(0, import_core14._deepEqual)(oldRenderInfo.layers, renderInfo.layers, 1) || renderInfo.layerBounds.some((b, i) => !(0, import_core13.equals)(b, oldRenderInfo.layerBounds[i])) || renderInfo.allLayersLoaded !== oldRenderInfo.allLayersLoaded || renderInfo.layers.some((layer) => layer.props.transitions);
+    const needsRender = viewportChanged || // If render info is new
+    renderInfo === oldRenderInfo || // If sublayers have changed
+    !(0, import_core14._deepEqual)(oldRenderInfo.layers, renderInfo.layers, 1) || // If a sublayer's bounds have been updated
+    renderInfo.layerBounds.some((b, i) => !(0, import_core13.equals)(b, oldRenderInfo.layerBounds[i])) || // If a sublayer's isLoaded state has been updated
+    renderInfo.allLayersLoaded !== oldRenderInfo.allLayersLoaded || // Some prop is in transition
+    renderInfo.layers.some((layer) => layer.props.transitions);
     this.channels[collisionGroup] = renderInfo;
     if (needsRender) {
       this.lastViewport = viewport;
@@ -1379,17 +1709,28 @@ var CollisionFilterEffect = class {
         viewports: viewport ? [viewport] : [],
         onViewportActive,
         views,
-        moduleParameters: {
-          dummyCollisionMap: this.dummyCollisionMap,
-          devicePixelRatio: collisionFBO.device.canvasContext.getDevicePixelRatio() / DOWNSCALE
+        shaderModuleProps: {
+          collision: {
+            enabled: true,
+            // To avoid feedback loop forming between Framebuffer and active Texture.
+            dummyCollisionMap: this.dummyCollisionMap
+          },
+          project: {
+            // @ts-expect-error TODO - assuming WebGL context
+            devicePixelRatio: collisionFBO.device.canvasContext.getDevicePixelRatio() / DOWNSCALE
+          }
         }
       });
     }
   }
+  /**
+   * Group layers by collisionGroup
+   * Returns a map from collisionGroup to render info
+   */
   _groupByCollisionGroup(device, collisionLayers) {
     const channelMap = {};
     for (const layer of collisionLayers) {
-      const { collisionGroup } = layer.props;
+      const collisionGroup = layer.props.collisionGroup;
       let channelInfo = channelMap[collisionGroup];
       if (!channelInfo) {
         channelInfo = { collisionGroup, layers: [], layerBounds: [], allLayersLoaded: true };
@@ -1416,10 +1757,18 @@ var CollisionFilterEffect = class {
     }
     return channelMap;
   }
-  getModuleParameters(layer) {
-    const { collisionGroup } = layer.props;
+  getShaderModuleProps(layer) {
+    const { collisionGroup, collisionEnabled } = layer.props;
     const { collisionFBOs, dummyCollisionMap } = this;
-    return { collisionFBO: collisionFBOs[collisionGroup], dummyCollisionMap };
+    const collisionFBO = collisionFBOs[collisionGroup];
+    const enabled = collisionEnabled && Boolean(collisionFBO);
+    return {
+      collision: {
+        enabled,
+        collisionFBO,
+        dummyCollisionMap
+      }
+    };
   }
   cleanup() {
     if (this.dummyCollisionMap) {
@@ -1450,9 +1799,7 @@ var CollisionFilterEffect = class {
       format: "depth16unorm",
       width,
       height,
-      mipmaps: false,
-      dataFormat: 6402,
-      type: 5125
+      mipmaps: false
     });
     this.collisionFBOs[collisionGroup] = device.createFramebuffer({
       id: `collision-${collisionGroup}`,
@@ -1483,12 +1830,10 @@ var CollisionFilterExtension = class extends import_core15.LayerExtension {
   getShaders() {
     return { modules: [shader_module_default2] };
   }
-  draw({ uniforms, context, moduleParameters }) {
-    const { collisionEnabled } = this.props;
-    const { collisionFBO, drawToCollisionMap } = moduleParameters;
-    const enabled = collisionEnabled && Boolean(collisionFBO);
-    uniforms.collision_enabled = enabled;
-    if (drawToCollisionMap) {
+  /* eslint-disable camelcase */
+  draw({ shaderModuleProps }) {
+    var _a;
+    if ((_a = shaderModuleProps.collision) == null ? void 0 : _a.drawToCollisionMap) {
       this.props = this.clone(this.props.collisionTestProps).props;
     }
   }
@@ -1520,63 +1865,101 @@ var import_core21 = require("@deck.gl/core");
 
 // dist/mask/shader-module.js
 var import_core16 = require("@deck.gl/core");
-var vs4 = `
-uniform vec4 mask_bounds;
-uniform bool mask_maskByInstance;
+var uniformBlock4 = (
+  /* glsl */
+  `uniform maskUniforms {
+  vec4 bounds;
+  highp int channel;
+  bool enabled;
+  bool inverted;
+  bool maskByInstance;
+} mask;
+`
+);
+var vertex3 = (
+  /* glsl */
+  `
 vec2 mask_getCoords(vec4 position) {
-return (position.xy - mask_bounds.xy) / (mask_bounds.zw - mask_bounds.xy);
+  return (position.xy - mask.bounds.xy) / (mask.bounds.zw - mask.bounds.xy);
 }
+`
+);
+var vs5 = `
+${uniformBlock4}
+${vertex3}
 `;
-var fs3 = `
+var fragment3 = (
+  /* glsl */
+  `
 uniform sampler2D mask_texture;
-uniform int mask_channel;
-uniform bool mask_enabled;
-uniform bool mask_inverted;
+
 bool mask_isInBounds(vec2 texCoords) {
-if (!mask_enabled) {
-return true;
-}
-vec4 maskColor = texture(mask_texture, texCoords);
-float maskValue = 1.0;
-if (mask_channel == 0) {
-maskValue = maskColor.r;
-} else if (mask_channel == 1) {
-maskValue = maskColor.g;
-} else if (mask_channel == 2) {
-maskValue = maskColor.b;
-} else if (mask_channel == 3) {
-maskValue = maskColor.a;
-}
-if (mask_inverted) {
-return maskValue >= 0.5;
-} else {
-return maskValue < 0.5;
-}
+  if (!mask.enabled) {
+    return true;
+  }
+  vec4 maskColor = texture(mask_texture, texCoords);
+  float maskValue = 1.0;
+  if (mask.channel == 0) {
+    maskValue = maskColor.r;
+  } else if (mask.channel == 1) {
+    maskValue = maskColor.g;
+  } else if (mask.channel == 2) {
+    maskValue = maskColor.b;
+  } else if (mask.channel == 3) {
+    maskValue = maskColor.a;
+  }
+
+  if (mask.inverted) {
+    return maskValue >= 0.5;
+  } else {
+    return maskValue < 0.5;
+  }
 }
+`
+);
+var fs4 = `
+${uniformBlock4}
+${fragment3}
 `;
 var inject5 = {
-  "vs:#decl": `
+  "vs:#decl": (
+    /* glsl */
+    `
 out vec2 mask_texCoords;
-`,
-  "vs:#main-end": `
-vec4 mask_common_position;
-if (mask_maskByInstance) {
-mask_common_position = project_position(vec4(geometry.worldPosition, 1.0));
-} else {
-mask_common_position = geometry.position;
-}
-mask_texCoords = mask_getCoords(mask_common_position);
-`,
-  "fs:#decl": `
+`
+  ),
+  "vs:#main-end": (
+    /* glsl */
+    `
+   vec4 mask_common_position;
+   if (mask.maskByInstance) {
+     mask_common_position = project_position(vec4(geometry.worldPosition, 1.0));
+   } else {
+     mask_common_position = geometry.position;
+   }
+   mask_texCoords = mask_getCoords(mask_common_position);
+`
+  ),
+  "fs:#decl": (
+    /* glsl */
+    `
 in vec2 mask_texCoords;
-`,
-  "fs:#main-start": `
-if (mask_enabled) {
-bool mask = mask_isInBounds(mask_texCoords);
-fragColor = texture(mask_texture, mask_texCoords);
-if (!mask) discard;
-}
 `
+  ),
+  "fs:#main-start": (
+    /* glsl */
+    `
+  if (mask.enabled) {
+    bool mask = mask_isInBounds(mask_texCoords);
+
+    // Debug: show extent of render target
+    // fragColor = vec4(mask_texCoords, 0.0, 1.0);
+    // fragColor = texture(mask_texture, mask_texCoords);
+
+    if (!mask) discard;
+  }
+`
+  )
 };
 var getMaskUniforms = (opts) => {
   if (opts && "maskMap" in opts) {
@@ -1584,15 +1967,22 @@ var getMaskUniforms = (opts) => {
       mask_texture: opts.maskMap
     };
   }
-  return {};
+  return opts || {};
 };
 var shader_module_default3 = {
   name: "mask",
   dependencies: [import_core16.project],
-  vs: vs4,
-  fs: fs3,
+  vs: vs5,
+  fs: fs4,
   inject: inject5,
-  getUniforms: getMaskUniforms
+  getUniforms: getMaskUniforms,
+  uniformTypes: {
+    bounds: "vec4<f32>",
+    channel: "i32",
+    enabled: "i32",
+    inverted: "i32",
+    maskByInstance: "i32"
+  }
 };
 
 // dist/mask/mask-effect.js
@@ -1821,13 +2211,26 @@ var MaskEffect = class {
     }
     return { didRender };
   }
+  /* eslint-disable-next-line complexity */
   _renderChannel(channelInfo, { layerFilter, onViewportActive, views, viewport, viewportChanged }) {
     let didRender = false;
     const oldChannelInfo = this.channels[channelInfo.index];
     if (!oldChannelInfo) {
       return didRender;
     }
-    const maskChanged = channelInfo === oldChannelInfo || channelInfo.layers.length !== oldChannelInfo.layers.length || channelInfo.layers.some((layer, i) => layer !== oldChannelInfo.layers[i] || layer.props.transitions) || channelInfo.layerBounds.some((b, i) => b !== oldChannelInfo.layerBounds[i]);
+    const maskChanged = (
+      // If a channel is new
+      channelInfo === oldChannelInfo || // If sublayers have changed
+      channelInfo.layers.length !== oldChannelInfo.layers.length || channelInfo.layers.some((layer, i) => (
+        // Layer instance is updated
+        // Layer props might have changed
+        // Undetermined props could have an effect on the output geometry of a mask layer,
+        // for example getRadius+updateTriggers, radiusScale, modelMatrix
+        layer !== oldChannelInfo.layers[i] || // Some prop is in transition
+        layer.props.transitions
+      )) || // If a sublayer's positions have been updated, the cached bounds will change shallowly
+      channelInfo.layerBounds.some((b, i) => b !== oldChannelInfo.layerBounds[i])
+    );
     channelInfo.bounds = oldChannelInfo.bounds;
     channelInfo.maskBounds = oldChannelInfo.maskBounds;
     this.channels[channelInfo.index] = channelInfo;
@@ -1853,8 +2256,10 @@ var MaskEffect = class {
           viewports: maskViewport ? [maskViewport] : [],
           onViewportActive,
           views,
-          moduleParameters: {
-            devicePixelRatio: 1
+          shaderModuleProps: {
+            project: {
+              devicePixelRatio: 1
+            }
           }
         });
         didRender = true;
@@ -1868,6 +2273,13 @@ var MaskEffect = class {
     };
     return didRender;
   }
+  /**
+   * Find a channel to render each mask into
+   * If a maskId already exists, diff and update the existing channel
+   * Otherwise replace a removed mask
+   * Otherwise create a new channel
+   * Returns a map from mask layer id to channel info
+   */
   _sortMaskChannels(maskLayers) {
     const channelMap = {};
     let channelCount = 0;
@@ -1907,10 +2319,12 @@ var MaskEffect = class {
     }
     return channelMap;
   }
-  getModuleParameters() {
+  getShaderModuleProps() {
     return {
-      maskMap: this.masks ? this.maskMap : this.dummyMaskMap,
-      maskChannels: this.masks
+      mask: {
+        maskMap: this.masks ? this.maskMap : this.dummyMaskMap,
+        maskChannels: this.masks
+      }
     };
   }
   cleanup() {
@@ -1950,30 +2364,33 @@ var MaskExtension = class extends import_core21.LayerExtension {
       modules: [shader_module_default3]
     };
   }
-  draw({ uniforms, context, moduleParameters }) {
-    uniforms.mask_maskByInstance = this.state.maskByInstance;
+  /* eslint-disable camelcase */
+  draw({ context, shaderModuleProps }) {
+    const maskProps = {};
+    maskProps.maskByInstance = Boolean(this.state.maskByInstance);
     const { maskId, maskInverted } = this.props;
-    const { maskChannels } = moduleParameters;
+    const { maskChannels } = shaderModuleProps.mask || {};
     const { viewport } = context;
     if (maskChannels && maskChannels[maskId]) {
       const { index, bounds, coordinateOrigin: fromCoordinateOrigin } = maskChannels[maskId];
       let { coordinateSystem: fromCoordinateSystem } = maskChannels[maskId];
-      uniforms.mask_enabled = true;
-      uniforms.mask_channel = index;
-      uniforms.mask_inverted = maskInverted;
+      maskProps.enabled = true;
+      maskProps.channel = index;
+      maskProps.inverted = maskInverted;
       if (fromCoordinateSystem === import_core21.COORDINATE_SYSTEM.DEFAULT) {
         fromCoordinateSystem = viewport.isGeospatial ? import_core21.COORDINATE_SYSTEM.LNGLAT : import_core21.COORDINATE_SYSTEM.CARTESIAN;
       }
       const opts = { modelMatrix: null, fromCoordinateOrigin, fromCoordinateSystem };
       const bl = this.projectPosition([bounds[0], bounds[1], 0], opts);
       const tr = this.projectPosition([bounds[2], bounds[3], 0], opts);
-      uniforms.mask_bounds = [bl[0], bl[1], tr[0], tr[1]];
+      maskProps.bounds = [bl[0], bl[1], tr[0], tr[1]];
     } else {
       if (maskId) {
         import_core21.log.warn(`Could not find a mask layer with id: ${maskId}`)();
       }
-      uniforms.mask_enabled = false;
+      maskProps.enabled = false;
     }
+    this.setShaderModuleProps({ mask: maskProps });
   }
 };
 MaskExtension.defaultProps = defaultProps7;
@@ -1990,78 +2407,103 @@ var import_core25 = require("@deck.gl/core");
 var import_core22 = require("@deck.gl/core");
 var TERRAIN_MODE = {
   NONE: 0,
+  /** A terrain layer rendering encoded ground elevation into the height map */
   WRITE_HEIGHT_MAP: 1,
+  /** An offset layer reading encoded ground elevation from the height map */
   USE_HEIGHT_MAP: 2,
+  /** A terrain layer rendering to screen, using the cover fbo overlaid with its own texture */
   USE_COVER: 3,
+  /** A terrain layer rendering to screen, using the cover fbo as texture */
   USE_COVER_ONLY: 4,
+  /** Draped layer is rendered into a texture, and never to screen */
   SKIP: 5
 };
 var TERRAIN_MODE_CONSTANTS = Object.keys(TERRAIN_MODE).map((key) => `const float TERRAIN_MODE_${key} = ${TERRAIN_MODE[key]}.0;`).join("\n");
+var uniformBlock5 = (
+  // eslint-disable-next-line prefer-template
+  TERRAIN_MODE_CONSTANTS + /* glsl */
+  `
+uniform terrainUniforms {
+  float mode;
+  vec4 bounds;
+} terrain;
+
+uniform sampler2D terrain_map;
+`
+);
 var terrainModule = {
   name: "terrain",
   dependencies: [import_core22.project],
+  // eslint-disable-next-line prefer-template
+  vs: uniformBlock5 + /* glsl */
+  "out vec3 commonPos;",
+  // eslint-disable-next-line prefer-template
+  fs: uniformBlock5 + /* glsl */
+  "in vec3 commonPos;",
   inject: {
-    "vs:#decl": `
-uniform float terrain_mode;
-uniform sampler2D terrain_map;
-uniform vec4 terrain_bounds;
-out vec3 commonPos;
-` + TERRAIN_MODE_CONSTANTS,
-    "vs:#main-start": `
-if (terrain_mode == TERRAIN_MODE_SKIP) {
-gl_Position = vec4(0.0);
-return;
+    "vs:#main-start": (
+      /* glsl */
+      `
+if (terrain.mode == TERRAIN_MODE_SKIP) {
+  gl_Position = vec4(0.0);
+  return;
 }
-`,
-    "vs:DECKGL_FILTER_GL_POSITION": `
+`
+    ),
+    "vs:DECKGL_FILTER_GL_POSITION": (
+      /* glsl */
+      `
 commonPos = geometry.position.xyz;
-if (terrain_mode == TERRAIN_MODE_WRITE_HEIGHT_MAP) {
-vec2 texCoords = (commonPos.xy - terrain_bounds.xy) / terrain_bounds.zw;
-position = vec4(texCoords * 2.0 - 1.0, 0.0, 1.0);
-commonPos.z += project_uCommonOrigin.z;
-}
-if (terrain_mode == TERRAIN_MODE_USE_HEIGHT_MAP) {
-vec3 anchor = geometry.worldPosition;
-anchor.z = 0.0;
-vec3 anchorCommon = project_position(anchor);
-vec2 texCoords = (anchorCommon.xy - terrain_bounds.xy) / terrain_bounds.zw;
-if (texCoords.x >= 0.0 && texCoords.y >= 0.0 && texCoords.x <= 1.0 && texCoords.y <= 1.0) {
-float terrainZ = texture(terrain_map, texCoords).r;
-geometry.position.z += terrainZ;
-position = project_common_position_to_clipspace(geometry.position);
-}
-}
-`,
-    "fs:#decl": `
-uniform float terrain_mode;
-uniform sampler2D terrain_map;
-uniform vec4 terrain_bounds;
-in vec3 commonPos;
-` + TERRAIN_MODE_CONSTANTS,
-    "fs:#main-start": `
-if (terrain_mode == TERRAIN_MODE_WRITE_HEIGHT_MAP) {
-fragColor = vec4(commonPos.z, 0.0, 0.0, 1.0);
-return;
-}
-`,
-    "fs:DECKGL_FILTER_COLOR": `
-if ((terrain_mode == TERRAIN_MODE_USE_COVER) || (terrain_mode == TERRAIN_MODE_USE_COVER_ONLY)) {
-vec2 texCoords = (commonPos.xy - terrain_bounds.xy) / terrain_bounds.zw;
-vec4 pixel = texture(terrain_map, texCoords);
-if (terrain_mode == TERRAIN_MODE_USE_COVER_ONLY) {
-color = pixel;
-} else {
-color = pixel + color * (1.0 - pixel.a);
-}
-return;
+if (terrain.mode == TERRAIN_MODE_WRITE_HEIGHT_MAP) {
+  vec2 texCoords = (commonPos.xy - terrain.bounds.xy) / terrain.bounds.zw;
+  position = vec4(texCoords * 2.0 - 1.0, 0.0, 1.0);
+  commonPos.z += project.commonOrigin.z;
+}
+if (terrain.mode == TERRAIN_MODE_USE_HEIGHT_MAP) {
+  vec3 anchor = geometry.worldPosition;
+  anchor.z = 0.0;
+  vec3 anchorCommon = project_position(anchor);
+  vec2 texCoords = (anchorCommon.xy - terrain.bounds.xy) / terrain.bounds.zw;
+  if (texCoords.x >= 0.0 && texCoords.y >= 0.0 && texCoords.x <= 1.0 && texCoords.y <= 1.0) {
+    float terrainZ = texture(terrain_map, texCoords).r;
+    geometry.position.z += terrainZ;
+    position = project_common_position_to_clipspace(geometry.position);
+  }
+}
+    `
+    ),
+    "fs:#main-start": (
+      /* glsl */
+      `
+if (terrain.mode == TERRAIN_MODE_WRITE_HEIGHT_MAP) {
+  fragColor = vec4(commonPos.z, 0.0, 0.0, 1.0);
+  return;
+}
+    `
+    ),
+    "fs:DECKGL_FILTER_COLOR": (
+      /* glsl */
+      `
+if ((terrain.mode == TERRAIN_MODE_USE_COVER) || (terrain.mode == TERRAIN_MODE_USE_COVER_ONLY)) {
+  vec2 texCoords = (commonPos.xy - terrain.bounds.xy) / terrain.bounds.zw;
+  vec4 pixel = texture(terrain_map, texCoords);
+  if (terrain.mode == TERRAIN_MODE_USE_COVER_ONLY) {
+    color = pixel;
+  } else {
+    // pixel is premultiplied
+    color = pixel + color * (1.0 - pixel.a);
+  }
+  return;
 }
-`
+    `
+    )
   },
-  getUniforms: (opts = {}, uniforms) => {
-    var _a;
+  // eslint-disable-next-line complexity
+  getUniforms: (opts = {}) => {
     if ("dummyHeightMap" in opts) {
       const { drawToTerrainHeightMap, heightMap, heightMapBounds, dummyHeightMap, terrainCover, useTerrainHeightMap, terrainSkipRender } = opts;
-      const { project_uCommonOrigin } = uniforms;
+      const projectUniforms = import_core22.project.getUniforms(opts.project);
+      const { commonOrigin } = projectUniforms;
       let mode = terrainSkipRender ? TERRAIN_MODE.SKIP : TERRAIN_MODE.NONE;
       let sampler = dummyHeightMap;
       let bounds = null;
@@ -2073,10 +2515,9 @@ return;
         sampler = heightMap;
         bounds = heightMapBounds;
       } else if (terrainCover) {
-        const isPicking = (_a = opts.picking) == null ? void 0 : _a.isActive;
-        const fbo = isPicking ? terrainCover.getPickingFramebuffer() : terrainCover.getRenderFramebuffer();
+        const fbo = opts.isPicking ? terrainCover.getPickingFramebuffer() : terrainCover.getRenderFramebuffer();
         sampler = fbo == null ? void 0 : fbo.colorAttachments[0].texture;
-        if (isPicking) {
+        if (opts.isPicking) {
           mode = TERRAIN_MODE.SKIP;
         }
         if (sampler) {
@@ -2087,22 +2528,27 @@ return;
         }
       }
       return {
-        terrain_mode: mode,
+        mode,
         terrain_map: sampler,
-        terrain_bounds: bounds ? [
-          bounds[0] - project_uCommonOrigin[0],
-          bounds[1] - project_uCommonOrigin[1],
+        // Convert bounds to the common space, as [minX, minY, width, height]
+        bounds: bounds ? [
+          bounds[0] - commonOrigin[0],
+          bounds[1] - commonOrigin[1],
           bounds[2] - bounds[0],
           bounds[3] - bounds[1]
         ] : [0, 0, 0, 0]
       };
     }
-    return null;
+    return {};
+  },
+  uniformTypes: {
+    mode: "f32",
+    bounds: "vec4<f32>"
   }
 };
 
 // dist/terrain/utils.js
-var import_constants2 = require("@luma.gl/constants");
+var import_constants = require("@luma.gl/constants");
 function createRenderTarget(device, opts) {
   return device.createFramebuffer({
     id: opts.id,
@@ -2141,6 +2587,7 @@ var TerrainCover = class {
   get id() {
     return this.targetLayer.id;
   }
+  /** returns true if the target layer is still in use (i.e. not finalized) */
   get isActive() {
     return Boolean(this.targetLayer.getCurrentLayer());
   }
@@ -2160,6 +2607,7 @@ var TerrainCover = class {
     }
     return layersChanged || sizeChanged;
   }
+  /** Compare layers with the last version. Only rerender if necessary. */
   _updateLayers(layers) {
     let needsRedraw = false;
     layers = this.tile ? getIntersectingLayers(this.tile, layers) : layers;
@@ -2179,6 +2627,7 @@ var TerrainCover = class {
     }
     return needsRedraw;
   }
+  /** Compare viewport and terrain bounds with the last version. Only rerender if necesary. */
   _updateViewport(viewport) {
     var _a;
     const targetLayer = this.targetLayer;
@@ -2352,6 +2801,13 @@ var TerrainPass = class extends import_core23._LayersPass {
       ...layer.props.operation.includes("terrain") && TERRAIN_BLENDING
     };
   }
+  getShaderModuleProps(layer, effects, otherShaderModuleProps) {
+    return {
+      terrain: {
+        project: otherShaderModuleProps.project
+      }
+    };
+  }
 };
 
 // dist/terrain/terrain-picking-pass.js
@@ -2395,6 +2851,8 @@ var TerrainPickingPass = class extends import_core24._PickLayersPass {
       layers,
       effects: [],
       viewports: [viewport],
+      // Disable the default culling because TileLayer would cull sublayers based on the screen viewport,
+      // not the viewport of the terrain cover. Culling is already done by `terrainCover.filterLayers`
       cullRect: void 0,
       deviceRect: viewport,
       pickZ: false
@@ -2410,6 +2868,13 @@ var TerrainPickingPass = class extends import_core24._PickLayersPass {
     }
     return { ...parameters2, depthTest: false };
   }
+  getShaderModuleProps(layer, effects, otherShaderModuleProps) {
+    return {
+      terrain: {
+        project: otherShaderModuleProps.project
+      }
+    };
+  }
 };
 
 // dist/terrain/height-map-builder.js
@@ -2427,6 +2892,9 @@ var HeightMapBuilder = class {
     this.lastViewport = null;
     this.device = device;
   }
+  /** Returns the height map framebuffer for read/write access.
+   * Returns null when the texture is invalid.
+   */
   getRenderFramebuffer() {
     if (!this.renderViewport) {
       return null;
@@ -2436,8 +2904,17 @@ var HeightMapBuilder = class {
     }
     return this.fbo;
   }
+  /** Called every render cycle to check if the framebuffer needs update */
   shouldUpdate({ layers, viewport }) {
-    const layersChanged = layers.length !== this.layers.length || layers.some((layer, i) => layer !== this.layers[i] || layer.props.transitions || layer.getBounds() !== this.layersBounds[i]);
+    const layersChanged = layers.length !== this.layers.length || layers.some((layer, i) => (
+      // Layer instance is updated
+      // Layer props might have changed
+      // Undetermined props could have an effect on the output geometry of a terrain source,
+      // for example getElevation+updateTriggers, elevationScale, modelMatrix
+      layer !== this.layers[i] || // Some prop is in transition
+      layer.props.transitions || // Layer's geometry bounds have changed
+      layer.getBounds() !== this.layersBounds[i]
+    ));
     if (layersChanged) {
       this.layers = layers;
       this.layersBounds = layers.map((layer) => layer.getBounds());
@@ -2458,6 +2935,10 @@ var HeightMapBuilder = class {
       const pixelWidth = (bounds[2] - bounds[0]) * scale;
       const pixelHeight = (bounds[3] - bounds[1]) * scale;
       this.renderViewport = pixelWidth > 0 || pixelHeight > 0 ? makeViewport({
+        // It's not important whether the geometry is visible in this viewport, because
+        // vertices will not use the standard project_to_clipspace in the DRAW_TO_HEIGHT_MAP shader
+        // However the viewport must have the same center and zoom as the screen viewport
+        // So that projection uniforms used for calculating z are the same
         bounds: [
           viewport.center[0] - 1,
           viewport.center[1] - 1,
@@ -2530,16 +3011,20 @@ var TerrainEffect = class {
     const drapeLayers = layers.filter((l) => l.state.terrainDrawMode === "drape");
     this._updateTerrainCovers(terrainLayers, drapeLayers, viewport, opts);
   }
-  getModuleParameters(layer) {
+  getShaderModuleProps(layer, otherShaderModuleProps) {
     var _a, _b, _c;
     const { terrainDrawMode } = layer.state;
     return {
-      heightMap: ((_b = (_a = this.heightMap) == null ? void 0 : _a.getRenderFramebuffer()) == null ? void 0 : _b.colorAttachments[0].texture) || null,
-      heightMapBounds: (_c = this.heightMap) == null ? void 0 : _c.bounds,
-      dummyHeightMap: this.dummyHeightMap,
-      terrainCover: this.isDrapingEnabled ? this.terrainCovers.get(layer.id) : null,
-      useTerrainHeightMap: terrainDrawMode === "offset",
-      terrainSkipRender: terrainDrawMode === "drape" || !layer.props.operation.includes("draw")
+      terrain: {
+        project: otherShaderModuleProps.project,
+        isPicking: this.isPicking,
+        heightMap: ((_b = (_a = this.heightMap) == null ? void 0 : _a.getRenderFramebuffer()) == null ? void 0 : _b.colorAttachments[0].texture) || null,
+        heightMapBounds: (_c = this.heightMap) == null ? void 0 : _c.bounds,
+        dummyHeightMap: this.dummyHeightMap,
+        terrainCover: this.isDrapingEnabled ? this.terrainCovers.get(layer.id) : null,
+        useTerrainHeightMap: terrainDrawMode === "offset",
+        terrainSkipRender: terrainDrawMode === "drape" || !layer.props.operation.includes("draw")
+      }
     };
   }
   cleanup({ deck }) {
@@ -2568,11 +3053,15 @@ var TerrainEffect = class {
     this.terrainPass.renderHeightMap(this.heightMap, {
       ...opts,
       layers: terrainLayers,
-      moduleParameters: {
-        heightMapBounds: this.heightMap.bounds,
-        dummyHeightMap: this.dummyHeightMap,
-        devicePixelRatio: 1,
-        drawToTerrainHeightMap: true
+      shaderModuleProps: {
+        terrain: {
+          heightMapBounds: this.heightMap.bounds,
+          dummyHeightMap: this.dummyHeightMap,
+          drawToTerrainHeightMap: true
+        },
+        project: {
+          devicePixelRatio: 1
+        }
       }
     });
   }
@@ -2611,10 +3100,14 @@ var TerrainEffect = class {
         renderPass.renderTerrainCover(terrainCover, {
           ...opts,
           layers: drapeLayers,
-          moduleParameters: {
-            dummyHeightMap: this.dummyHeightMap,
-            terrainSkipRender: false,
-            devicePixelRatio: 1
+          shaderModuleProps: {
+            terrain: {
+              dummyHeightMap: this.dummyHeightMap,
+              terrainSkipRender: false
+            },
+            project: {
+              devicePixelRatio: 1
+            }
           }
         });
         if (!this.isPicking) {
@@ -2655,7 +3148,8 @@ var TerrainExtension = class extends import_core26.LayerExtension {
   updateState(params) {
     var _a;
     const { props, oldProps } = params;
-    if (this.state.terrainDrawMode && props.terrainDrawMode === oldProps.terrainDrawMode && props.extruded === oldProps.extruded) {
+    if (this.state.terrainDrawMode && props.terrainDrawMode === oldProps.terrainDrawMode && // @ts-ignore `extruded` may not exist in props
+    props.extruded === oldProps.extruded) {
       return;
     }
     let { terrainDrawMode } = props;