@deck.gl/extensions 9.0.0-beta.10 → 9.0.0-beta.11

package/dist/dist.dev.js

@@ -247,33 +247,43 @@ var __exports__ = (() => {
 
   // src/data-filter/shader-module.ts
   var vs2 = glsl`
-uniform DATAFILTER_TYPE filter_min;
-uniform DATAFILTER_TYPE filter_softMin;
-uniform DATAFILTER_TYPE filter_softMax;
-uniform DATAFILTER_TYPE filter_max;
 uniform bool filter_useSoftMargin;
 uniform bool filter_enabled;
 uniform bool filter_transformSize;
 uniform ivec4 filter_categoryBitMask;
 
-#ifdef NON_INSTANCED_MODEL
-  #define DATAFILTER_ATTRIB filterValues
-  #define DATAFILTER_ATTRIB_64LOW filterValues64Low
-  #define DATACATEGORY_ATTRIB filterCategoryValues
-#else
-  #define DATAFILTER_ATTRIB instanceFilterValues
-  #define DATAFILTER_ATTRIB_64LOW instanceFilterValues64Low
-  #define DATACATEGORY_ATTRIB instanceFilterCategoryValues
+#ifdef DATAFILTER_TYPE
+  uniform DATAFILTER_TYPE filter_min;
+  uniform DATAFILTER_TYPE filter_softMin;
+  uniform DATAFILTER_TYPE filter_softMax;
+  uniform DATAFILTER_TYPE filter_max;
+
+  #ifdef NON_INSTANCED_MODEL
+    #define DATAFILTER_ATTRIB filterValues
+    #define DATAFILTER_ATTRIB_64LOW filterValues64Low
+  #else
+    #define DATAFILTER_ATTRIB instanceFilterValues
+    #define DATAFILTER_ATTRIB_64LOW instanceFilterValues64Low
+  #endif
+
+  in DATAFILTER_TYPE DATAFILTER_ATTRIB;
+  #ifdef DATAFILTER_DOUBLE
+    in DATAFILTER_TYPE DATAFILTER_ATTRIB_64LOW;
+
+    uniform DATAFILTER_TYPE filter_min64High;
+    uniform DATAFILTER_TYPE filter_max64High;
+  #endif
 #endif
 
-in DATAFILTER_TYPE DATAFILTER_ATTRIB;
-#ifdef DATAFILTER_DOUBLE
-  in DATAFILTER_TYPE DATAFILTER_ATTRIB_64LOW;
 
-  uniform DATAFILTER_TYPE filter_min64High;
-  uniform DATAFILTER_TYPE filter_max64High;
+#ifdef DATACATEGORY_TYPE
+  #ifdef NON_INSTANCED_MODEL
+    #define DATACATEGORY_ATTRIB filterCategoryValues
+  #else
+    #define DATACATEGORY_ATTRIB instanceFilterCategoryValues
+  #endif
+  in DATACATEGORY_TYPE DATACATEGORY_ATTRIB;
 #endif
-in DATACATEGORY_TYPE DATACATEGORY_ATTRIB;
 
 out float dataFilter_value;
 
@@ -289,30 +299,44 @@ float dataFilter_reduceValue(vec3 value) {
 float dataFilter_reduceValue(vec4 value) {
   return min(min(value.x, value.y), min(value.z, value.w));
 }
-void dataFilter_setValue(DATAFILTER_TYPE valueFromMin, DATAFILTER_TYPE valueFromMax, DATACATEGORY_TYPE category) {
-  if (filter_enabled) {
+
+#ifdef DATAFILTER_TYPE
+  void dataFilter_setValue(DATAFILTER_TYPE valueFromMin, DATAFILTER_TYPE valueFromMax) {
     if (filter_useSoftMargin) {
-      dataFilter_value = dataFilter_reduceValue(
-        smoothstep(filter_min, filter_softMin, valueFromMin) *
-        (1.0 - smoothstep(filter_softMax, filter_max, valueFromMax))
+      // smoothstep results are undefined if edge0 ≥ edge1
+      // Fallback to ignore filterSoftRange if it is truncated by filterRange
+      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)
       );
     }
+  }
+#endif
 
+#ifdef DATACATEGORY_ATTRIB
+  void dataFilter_setCategoryValue(DATACATEGORY_TYPE category) {
     #if DATACATEGORY_CHANNELS == 1 // One 128-bit mask
-      int dataFilter_masks = filter_categoryBitMask[int(category / 32.0)];
+    int dataFilter_masks = filter_categoryBitMask[int(category / 32.0)];
     #elif DATACATEGORY_CHANNELS == 2 // Two 64-bit masks
-      ivec2 dataFilter_masks = ivec2(
-        filter_categoryBitMask[int(category.x / 32.0)],
-        filter_categoryBitMask[int(category.y / 32.0) + 2]
-      );
+    ivec2 dataFilter_masks = ivec2(
+      filter_categoryBitMask[int(category.x / 32.0)],
+      filter_categoryBitMask[int(category.y / 32.0) + 2]
+    );
     #elif DATACATEGORY_CHANNELS == 3 // Three 32-bit masks
-      ivec3 dataFilter_masks = filter_categoryBitMask.xyz;
+    ivec3 dataFilter_masks = filter_categoryBitMask.xyz;
     #else // Four 32-bit masks
-      ivec4 dataFilter_masks = filter_categoryBitMask;
+    ivec4 dataFilter_masks = filter_categoryBitMask;
     #endif
 
     // Shift mask and extract relevant bits
@@ -320,14 +344,12 @@ void dataFilter_setValue(DATAFILTER_TYPE valueFromMin, DATAFILTER_TYPE valueFrom
     dataFilter_bits = mod(floor(dataFilter_bits), 2.0);
 
     #if DATACATEGORY_CHANNELS == 1
-      if(dataFilter_bits == 0.0) dataFilter_value = 0.0;
+    if(dataFilter_bits == 0.0) dataFilter_value = 0.0;
     #else
     if(any(equal(dataFilter_bits, DATACATEGORY_TYPE(0.0)))) dataFilter_value = 0.0;
     #endif
-  } else {
-    dataFilter_value = 1.0;
   }
-}
+#endif
 `;
   var fs2 = glsl`
 uniform bool filter_transformColor;
@@ -390,15 +412,23 @@ in float dataFilter_value;
   }
   var inject2 = {
     "vs:#main-start": glsl`
-    #ifdef DATAFILTER_DOUBLE
-      dataFilter_setValue(
-        DATAFILTER_ATTRIB - filter_min64High + DATAFILTER_ATTRIB_64LOW,
-        DATAFILTER_ATTRIB - filter_max64High + DATAFILTER_ATTRIB_64LOW,
-        DATACATEGORY_ATTRIB
-      );
-    #else
-      dataFilter_setValue(DATAFILTER_ATTRIB, DATAFILTER_ATTRIB, DATACATEGORY_ATTRIB);
-    #endif
+    dataFilter_value = 1.0;
+    if (filter_enabled) {
+      #ifdef DATAFILTER_ATTRIB
+        #ifdef DATAFILTER_DOUBLE
+          dataFilter_setValue(
+            DATAFILTER_ATTRIB - filter_min64High + DATAFILTER_ATTRIB_64LOW,
+            DATAFILTER_ATTRIB - filter_max64High + DATAFILTER_ATTRIB_64LOW
+          );
+        #else
+          dataFilter_setValue(DATAFILTER_ATTRIB, DATAFILTER_ATTRIB);
+        #endif
+      #endif
+
+      #ifdef DATACATEGORY_ATTRIB
+        dataFilter_setCategoryValue(DATACATEGORY_ATTRIB);
+      #endif
+    }
   `,
     "vs:#main-end": glsl`
     if (dataFilter_value == 0.0) {
@@ -1196,7 +1226,7 @@ void main() {
     filterTransformColor: true
   };
   var defaultOptions = {
-    categorySize: 1,
+    categorySize: 0,
     filterSize: 1,
     fp64: false,
     countItems: false
@@ -1213,48 +1243,55 @@ void main() {
     }
     getShaders(extension) {
       const { categorySize, filterSize, fp64: fp642 } = extension.opts;
-      return {
-        modules: [fp642 ? shaderModule64 : shaderModule],
-        defines: {
-          DATACATEGORY_TYPE: DATA_TYPE_FROM_SIZE[categorySize],
-          DATACATEGORY_CHANNELS: categorySize,
-          DATAFILTER_TYPE: DATA_TYPE_FROM_SIZE[filterSize],
-          DATAFILTER_DOUBLE: Boolean(fp642)
-        }
-      };
+      const defines = {};
+      if (categorySize) {
+        defines.DATACATEGORY_TYPE = DATA_TYPE_FROM_SIZE[categorySize];
+        defines.DATACATEGORY_CHANNELS = categorySize;
+      }
+      if (filterSize) {
+        defines.DATAFILTER_TYPE = DATA_TYPE_FROM_SIZE[filterSize];
+        defines.DATAFILTER_DOUBLE = Boolean(fp642);
+      }
+      return { modules: [fp642 ? shaderModule64 : shaderModule], defines };
     }
     initializeState(context, extension) {
       const attributeManager = this.getAttributeManager();
       const { categorySize, filterSize, fp64: fp642 } = extension.opts;
       if (attributeManager) {
-        attributeManager.add({
-          filterValues: {
-            size: filterSize,
-            type: fp642 ? "float64" : "float32",
-            accessor: "getFilterValue",
-            shaderAttributes: {
-              filterValues: {
-                divisor: 0
-              },
-              instanceFilterValues: {
-                divisor: 1
+        if (filterSize) {
+          attributeManager.add({
+            filterValues: {
+              size: filterSize,
+              type: fp642 ? "float64" : "float32",
+              accessor: "getFilterValue",
+              shaderAttributes: {
+                filterValues: {
+                  divisor: 0
+                },
+                instanceFilterValues: {
+                  divisor: 1
+                }
               }
             }
-          },
-          filterCategoryValues: {
-            size: categorySize,
-            accessor: "getFilterCategory",
-            transform: categorySize === 1 ? (d) => extension._getCategoryKey.call(this, d, 0) : (d) => d.map((x, i) => extension._getCategoryKey.call(this, x, i)),
-            shaderAttributes: {
-              filterCategoryValues: {
-                divisor: 0
-              },
-              instanceFilterCategoryValues: {
-                divisor: 1
+          });
+        }
+        if (categorySize) {
+          attributeManager.add({
+            filterCategoryValues: {
+              size: categorySize,
+              accessor: "getFilterCategory",
+              transform: categorySize === 1 ? (d) => extension._getCategoryKey.call(this, d, 0) : (d) => d.map((x, i) => extension._getCategoryKey.call(this, x, i)),
+              shaderAttributes: {
+                filterCategoryValues: {
+                  divisor: 0
+                },
+                instanceFilterCategoryValues: {
+                  divisor: 1
+                }
               }
             }
-          }
-        });
+          });
+        }
       }
       const { device } = this.context;
       if (attributeManager && extension.opts.countItems) {
@@ -1291,7 +1328,7 @@ void main() {
       const attributeManager = this.getAttributeManager();
       const { categorySize } = extension.opts;
       if (this.state.filterModel) {
-        const filterNeedsUpdate = attributeManager.attributes.filterValues.needsUpdate() || attributeManager.attributes.filterCategoryValues?.needsUpdate() || props.filterEnabled !== oldProps.filterEnabled || props.filterRange !== oldProps.filterRange || props.filterSoftRange !== oldProps.filterSoftRange || props.filterCategories !== oldProps.filterCategories;
+        const filterNeedsUpdate = attributeManager.attributes.filterValues?.needsUpdate() || attributeManager.attributes.filterCategoryValues?.needsUpdate() || props.filterEnabled !== oldProps.filterEnabled || props.filterRange !== oldProps.filterRange || props.filterSoftRange !== oldProps.filterSoftRange || props.filterCategories !== oldProps.filterCategories;
         if (filterNeedsUpdate) {
           this.setState({ filterNeedsUpdate });
         }
@@ -1327,7 +1364,7 @@ void main() {
         this.context.device.clearWebGL({ framebuffer: filterFBO, color: [0, 0, 0, 0] });
         filterModel.updateModuleSettings(params.moduleParameters);
         filterModel.setAttributes({
-          ...filterValues.getValue(),
+          ...filterValues?.getValue(),
           ...filterCategoryValues?.getValue(),
           ...filterIndices?.getValue()
         });
@@ -2101,11 +2138,7 @@ vec4_dot_fp64(a, tmp, out_val[i]);
     printRowMajor: true,
     _cartographicRadians: false
   };
-  globalThis.mathgl = globalThis.mathgl || {
-    config: {
-      ...DEFAULT_CONFIG
-    }
-  };
+  globalThis.mathgl = globalThis.mathgl || { config: { ...DEFAULT_CONFIG } };
   var config = globalThis.mathgl.config;
   function isArray(value) {
     return Array.isArray(value) || ArrayBuffer.isView(value) && !(value instanceof DataView);
@@ -2533,7 +2566,7 @@ vec4_dot_fp64(a, tmp, out_val[i]);
     return out;
   }
   function str(a) {
-    return "vec3(".concat(a[0], ", ").concat(a[1], ", ").concat(a[2], ")");
+    return `vec3(${a[0]}, ${a[1]}, ${a[2]})`;
   }
   function exactEquals(a, b) {
     return a[0] === b[0] && a[1] === b[1] && a[2] === b[2];
@@ -2883,6 +2916,7 @@ in float instanceOffsets;
         }
         prevP = p;
       }
+      result[geometrySize - 1] = 0;
       return result;
     }
   };
@@ -3191,7 +3225,7 @@ in vec2 clip_commonPosition;
   ClipExtension.extensionName = "ClipExtension";
 
   // src/collision-filter/collision-filter-extension.ts
-  var import_core20 = __toESM(require_core(), 1);
+  var import_core16 = __toESM(require_core(), 1);
 
   // src/collision-filter/shader-module.ts
   var import_core12 = __toESM(require_core(), 1);
@@ -3292,7 +3326,7 @@ float collision_isVisible(vec2 texCoords, vec3 pickingColor) {
   };
 
   // src/collision-filter/collision-filter-effect.ts
-  var import_core19 = __toESM(require_core(), 1);
+  var import_core15 = __toESM(require_core(), 1);
 
   // src/collision-filter/collision-filter-pass.ts
   var import_core13 = __toESM(require_core(), 1);
@@ -3300,16 +3334,11 @@ float collision_isVisible(vec2 texCoords, vec3 pickingColor) {
     renderCollisionMap(target, options) {
       const padding = 1;
       const clearColor = [0, 0, 0, 0];
-      return this.device.withParametersWebGL(
-        {
-          scissorTest: true,
-          scissor: [padding, padding, target.width - 2 * padding, target.height - 2 * padding],
-          blend: false,
-          depthTest: true,
-          depthRange: [0, 1]
-        },
-        () => this.render({ ...options, clearColor, target, pass: "collision" })
-      );
+      const scissorRect = [padding, padding, target.width - 2 * padding, target.height - 2 * padding];
+      this.render({ ...options, clearColor, scissorRect, target, pass: "collision" });
+    }
+    getLayerParameters(layer, layerIndex, viewport) {
+      return { ...layer.props.parameters, blend: false, depthRange: [0, 1], depthTest: true };
     }
     getModuleParameters() {
       return {
@@ -3323,62 +3352,377 @@ float collision_isVisible(vec2 texCoords, vec3 pickingColor) {
     }
   };
 
-  // src/mask/mask-effect.ts
-  var import_core16 = __toESM(require_core(), 1);
-
-  // src/mask/mask-pass.ts
-  var import_core14 = __toESM(require_core(), 1);
-  var MaskPass = class extends import_core14._LayersPass {
-    constructor(device, props) {
-      super(device, props);
-      const { mapSize = 2048 } = props;
-      this.maskMap = device.createTexture({
+  // src/collision-filter/collision-filter-effect.ts
+  var DOWNSCALE = 2;
+  var CollisionFilterEffect = class {
+    constructor() {
+      this.id = "collision-filter-effect";
+      this.props = null;
+      this.useInPicking = true;
+      this.order = 1;
+      this.channels = {};
+      this.collisionFBOs = {};
+    }
+    setup(context) {
+      this.context = context;
+      const { device } = context;
+      this.dummyCollisionMap = device.createTexture({ width: 1, height: 1 });
+      this.collisionFilterPass = new CollisionFilterPass(device, { id: "default-collision-filter" });
+    }
+    preRender({
+      effects: allEffects,
+      layers,
+      layerFilter,
+      viewports,
+      onViewportActive,
+      views,
+      isPicking,
+      preRenderStats = {}
+    }) {
+      const { device } = this.context;
+      if (isPicking) {
+        return;
+      }
+      const collisionLayers = layers.filter(
+        ({ props: { visible, collisionEnabled } }) => visible && collisionEnabled
+      );
+      if (collisionLayers.length === 0) {
+        this.channels = {};
+        return;
+      }
+      const effects = allEffects?.filter((e) => e.useInPicking && preRenderStats[e.id]);
+      const maskEffectRendered = preRenderStats["mask-effect"]?.didRender;
+      const channels = this._groupByCollisionGroup(device, collisionLayers);
+      const viewport = viewports[0];
+      const viewportChanged = !this.lastViewport || !this.lastViewport.equals(viewport) || maskEffectRendered;
+      for (const collisionGroup in channels) {
+        const collisionFBO = this.collisionFBOs[collisionGroup];
+        const renderInfo = channels[collisionGroup];
+        const [width, height] = device.canvasContext.getPixelSize();
+        collisionFBO.resize({
+          width: width / DOWNSCALE,
+          height: height / DOWNSCALE
+        });
+        this._render(renderInfo, {
+          effects,
+          layerFilter,
+          onViewportActive,
+          views,
+          viewport,
+          viewportChanged
+        });
+      }
+    }
+    _render(renderInfo, {
+      effects,
+      layerFilter,
+      onViewportActive,
+      views,
+      viewport,
+      viewportChanged
+    }) {
+      const { collisionGroup } = renderInfo;
+      const oldRenderInfo = this.channels[collisionGroup];
+      if (!oldRenderInfo) {
+        return;
+      }
+      const needsRender = viewportChanged || renderInfo === oldRenderInfo || !(0, import_core15._deepEqual)(oldRenderInfo.layers, renderInfo.layers, 1) || renderInfo.layerBounds.some((b, i) => !equals(b, oldRenderInfo.layerBounds[i])) || renderInfo.allLayersLoaded !== oldRenderInfo.allLayersLoaded || renderInfo.layers.some((layer) => layer.props.transitions);
+      this.channels[collisionGroup] = renderInfo;
+      if (needsRender) {
+        this.lastViewport = viewport;
+        const collisionFBO = this.collisionFBOs[collisionGroup];
+        this.collisionFilterPass.renderCollisionMap(collisionFBO, {
+          pass: "collision-filter",
+          isPicking: true,
+          layers: renderInfo.layers,
+          effects,
+          layerFilter,
+          viewports: viewport ? [viewport] : [],
+          onViewportActive,
+          views,
+          moduleParameters: {
+            dummyCollisionMap: this.dummyCollisionMap,
+            devicePixelRatio: collisionFBO.device.canvasContext.getDevicePixelRatio() / DOWNSCALE
+          }
+        });
+      }
+    }
+    _groupByCollisionGroup(device, collisionLayers) {
+      const channelMap = {};
+      for (const layer of collisionLayers) {
+        const { collisionGroup } = layer.props;
+        let channelInfo = channelMap[collisionGroup];
+        if (!channelInfo) {
+          channelInfo = { collisionGroup, layers: [], layerBounds: [], allLayersLoaded: true };
+          channelMap[collisionGroup] = channelInfo;
+        }
+        channelInfo.layers.push(layer);
+        channelInfo.layerBounds.push(layer.getBounds());
+        if (!layer.isLoaded) {
+          channelInfo.allLayersLoaded = false;
+        }
+      }
+      for (const collisionGroup of Object.keys(channelMap)) {
+        if (!this.collisionFBOs[collisionGroup]) {
+          this.createFBO(device, collisionGroup);
+        }
+        if (!this.channels[collisionGroup]) {
+          this.channels[collisionGroup] = channelMap[collisionGroup];
+        }
+      }
+      for (const collisionGroup of Object.keys(this.collisionFBOs)) {
+        if (!channelMap[collisionGroup]) {
+          this.destroyFBO(collisionGroup);
+        }
+      }
+      return channelMap;
+    }
+    getModuleParameters(layer) {
+      const { collisionGroup } = layer.props;
+      const { collisionFBOs, dummyCollisionMap } = this;
+      return { collisionFBO: collisionFBOs[collisionGroup], dummyCollisionMap };
+    }
+    cleanup() {
+      if (this.dummyCollisionMap) {
+        this.dummyCollisionMap.delete();
+        this.dummyCollisionMap = void 0;
+      }
+      this.channels = {};
+      for (const collisionGroup of Object.keys(this.collisionFBOs)) {
+        this.destroyFBO(collisionGroup);
+      }
+      this.collisionFBOs = {};
+      this.lastViewport = void 0;
+    }
+    createFBO(device, collisionGroup) {
+      const { width, height } = device.gl.canvas;
+      const collisionMap = device.createTexture({
         format: "rgba8unorm",
-        width: mapSize,
-        height: mapSize,
+        width,
+        height,
         sampler: {
-          minFilter: "linear",
-          magFilter: "linear",
+          minFilter: "nearest",
+          magFilter: "nearest",
           addressModeU: "clamp-to-edge",
           addressModeV: "clamp-to-edge"
         }
       });
-      this.fbo = device.createFramebuffer({
-        id: "maskmap",
-        width: mapSize,
-        height: mapSize,
-        colorAttachments: [this.maskMap]
+      const depthStencilAttachment = device.createTexture({
+        format: "depth16unorm",
+        width,
+        height,
+        mipmaps: false,
+        dataFormat: 6402,
+        type: 5125
+      });
+      this.collisionFBOs[collisionGroup] = device.createFramebuffer({
+        id: `collision-${collisionGroup}`,
+        width,
+        height,
+        colorAttachments: [collisionMap],
+        depthStencilAttachment
       });
     }
-    render(options) {
-      const colorMask = [false, false, false, false];
-      colorMask[options.channel] = true;
-      const clearColor = [255, 255, 255, 255];
-      return this.device.withParametersWebGL(
-        {
-          blend: true,
-          blendFunc: [GLEnum.ZERO, GLEnum.ONE],
-          blendEquation: GLEnum.FUNC_SUBTRACT,
-          colorMask,
-          depthTest: false
-        },
-        () => super.render({ ...options, clearColor, target: this.fbo, pass: "mask" })
-      );
-    }
-    shouldDrawLayer(layer) {
-      return layer.props.operation.includes("mask");
-    }
-    delete() {
-      this.fbo.delete();
-      this.maskMap.delete();
+    destroyFBO(collisionGroup) {
+      const fbo = this.collisionFBOs[collisionGroup];
+      fbo.colorAttachments[0]?.destroy();
+      fbo.depthStencilAttachment?.destroy();
+      fbo.destroy();
+      delete this.collisionFBOs[collisionGroup];
     }
   };
 
-  // src/utils/projection-utils.ts
-  var import_core15 = __toESM(require_core(), 1);
-  function joinLayerBounds(layers, viewport) {
-    const bounds = [Infinity, Infinity, -Infinity, -Infinity];
-    for (const layer of layers) {
+  // src/collision-filter/collision-filter-extension.ts
+  var defaultProps6 = {
+    getCollisionPriority: { type: "accessor", value: 0 },
+    collisionEnabled: true,
+    collisionGroup: { type: "string", value: "default" },
+    collisionTestProps: {}
+  };
+  var CollisionFilterExtension = class extends import_core16.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) {
+        this.props = this.clone(this.props.collisionTestProps).props;
+      }
+    }
+    initializeState(context, extension) {
+      if (this.getAttributeManager() === null) {
+        return;
+      }
+      this.context.deck?._addDefaultEffect(new CollisionFilterEffect());
+      const attributeManager = this.getAttributeManager();
+      attributeManager.add({
+        collisionPriorities: {
+          size: 1,
+          accessor: "getCollisionPriority",
+          shaderAttributes: {
+            collisionPriorities: { divisor: 0 },
+            instanceCollisionPriorities: { divisor: 1 }
+          }
+        }
+      });
+    }
+    getNeedsPickingBuffer() {
+      return this.props.collisionEnabled;
+    }
+  };
+  CollisionFilterExtension.defaultProps = defaultProps6;
+  CollisionFilterExtension.extensionName = "CollisionFilterExtension";
+
+  // src/mask/mask-extension.ts
+  var import_core22 = __toESM(require_core(), 1);
+
+  // src/mask/shader-module.ts
+  var import_core17 = __toESM(require_core(), 1);
+  var vs4 = glsl`
+uniform vec4 mask_bounds;
+uniform bool mask_maskByInstance;
+vec2 mask_getCoords(vec4 position) {
+  return (position.xy - mask_bounds.xy) / (mask_bounds.zw - mask_bounds.xy);
+}
+`;
+  var fs3 = 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;
+  }
+}
+`;
+  var inject5 = {
+    "vs:#decl": glsl`
+out vec2 mask_texCoords;
+`,
+    "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": 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) {
+      return {
+        mask_texture: opts.maskMap
+      };
+    }
+    return {};
+  };
+  var shader_module_default3 = {
+    name: "mask",
+    dependencies: [import_core17.project],
+    vs: vs4,
+    fs: fs3,
+    inject: inject5,
+    getUniforms: getMaskUniforms
+  };
+
+  // src/mask/mask-effect.ts
+  var import_core20 = __toESM(require_core(), 1);
+
+  // src/mask/mask-pass.ts
+  var import_core18 = __toESM(require_core(), 1);
+  var MASK_BLENDING = {
+    blendColorOperation: "subtract",
+    blendColorSrcFactor: "zero",
+    blendColorDstFactor: "one",
+    blendAlphaOperation: "subtract",
+    blendAlphaSrcFactor: "zero",
+    blendAlphaDstFactor: "one"
+  };
+  var MaskPass = class extends import_core18._LayersPass {
+    constructor(device, props) {
+      super(device, props);
+      const { mapSize = 2048 } = props;
+      this.maskMap = device.createTexture({
+        format: "rgba8unorm",
+        width: mapSize,
+        height: mapSize,
+        sampler: {
+          minFilter: "linear",
+          magFilter: "linear",
+          addressModeU: "clamp-to-edge",
+          addressModeV: "clamp-to-edge"
+        }
+      });
+      this.fbo = device.createFramebuffer({
+        id: "maskmap",
+        width: mapSize,
+        height: mapSize,
+        colorAttachments: [this.maskMap]
+      });
+    }
+    render(options) {
+      const colorMask = 2 ** options.channel;
+      const clearColor = [255, 255, 255, 255];
+      super.render({ ...options, clearColor, colorMask, target: this.fbo, pass: "mask" });
+    }
+    getLayerParameters(layer, layerIndex, viewport) {
+      return {
+        ...layer.props.parameters,
+        blend: true,
+        depthTest: false,
+        ...MASK_BLENDING
+      };
+    }
+    shouldDrawLayer(layer) {
+      return layer.props.operation.includes("mask");
+    }
+    delete() {
+      this.fbo.delete();
+      this.maskMap.delete();
+    }
+  };
+
+  // src/utils/projection-utils.ts
+  var import_core19 = __toESM(require_core(), 1);
+  function joinLayerBounds(layers, viewport) {
+    const bounds = [Infinity, Infinity, -Infinity, -Infinity];
+    for (const layer of layers) {
       const layerBounds = layer.getBounds();
       if (layerBounds) {
         const bottomLeftCommon = layer.projectPosition(layerBounds[0], { viewport, autoOffset: false });
@@ -3424,7 +3768,7 @@ float collision_isVisible(vec2 texCoords, vec3 pickingColor) {
         zoom += Math.log2(r);
       }
     }
-    return isGeospatial ? new import_core15.WebMercatorViewport({
+    return isGeospatial ? new import_core19.WebMercatorViewport({
       id: viewport.id,
       x: border,
       y: border,
@@ -3434,7 +3778,7 @@ float collision_isVisible(vec2 texCoords, vec3 pickingColor) {
       latitude: centerWorld[1],
       zoom,
       orthographic: true
-    }) : new import_core15.OrthographicViewport({
+    }) : new import_core19.OrthographicViewport({
       id: viewport.id,
       x: border,
       y: border,
@@ -3503,14 +3847,23 @@ float collision_isVisible(vec2 texCoords, vec3 pickingColor) {
       this.channels = [];
       this.masks = null;
     }
-    preRender(device, { layers, layerFilter, viewports, onViewportActive, views, isPicking }) {
+    setup({ device }) {
+      this.dummyMaskMap = device.createTexture({
+        width: 1,
+        height: 1
+      });
+      this.maskPass = new MaskPass(device, { id: "default-mask" });
+      this.maskMap = this.maskPass.maskMap;
+    }
+    preRender({
+      layers,
+      layerFilter,
+      viewports,
+      onViewportActive,
+      views,
+      isPicking
+    }) {
       let didRender = false;
-      if (!this.dummyMaskMap) {
-        this.dummyMaskMap = device.createTexture({
-          width: 1,
-          height: 1
-        });
-      }
       if (isPicking) {
         return { didRender };
       }
@@ -3521,15 +3874,11 @@ float collision_isVisible(vec2 texCoords, vec3 pickingColor) {
         return { didRender };
       }
       this.masks = {};
-      if (!this.maskPass) {
-        this.maskPass = new MaskPass(device, { id: "default-mask" });
-        this.maskMap = this.maskPass.maskMap;
-      }
       const channelMap = this._sortMaskChannels(maskLayers);
       const viewport = viewports[0];
       const viewportChanged = !this.lastViewport || !this.lastViewport.equals(viewport);
       if (viewport.resolution !== void 0) {
-        import_core16.log.warn("MaskExtension is not supported in GlobeView")();
+        import_core20.log.warn("MaskExtension is not supported in GlobeView")();
         return { didRender };
       }
       for (const maskId in channelMap) {
@@ -3607,7 +3956,7 @@ float collision_isVisible(vec2 texCoords, vec3 pickingColor) {
         let channelInfo = channelMap[id];
         if (!channelInfo) {
           if (++channelCount > 4) {
-            import_core16.log.warn("Too many mask layers. The max supported is 4")();
+            import_core20.log.warn("Too many mask layers. The max supported is 4")();
             continue;
           }
           channelInfo = {
@@ -3660,314 +4009,6 @@ float collision_isVisible(vec2 texCoords, vec3 pickingColor) {
     }
   };
 
-  // src/collision-filter/collision-filter-effect.ts
-  var DOWNSCALE = 2;
-  var CollisionFilterEffect = class {
-    constructor() {
-      this.id = "collision-filter-effect";
-      this.props = null;
-      this.useInPicking = true;
-      this.order = 1;
-      this.channels = {};
-      this.collisionFBOs = {};
-    }
-    preRender(device, {
-      effects: allEffects,
-      layers,
-      layerFilter,
-      viewports,
-      onViewportActive,
-      views,
-      isPicking,
-      preRenderStats = {}
-    }) {
-      if (!this.dummyCollisionMap) {
-        this.dummyCollisionMap = device.createTexture({ width: 1, height: 1 });
-      }
-      if (isPicking) {
-        return;
-      }
-      const collisionLayers = layers.filter(
-        ({ props: { visible, collisionEnabled } }) => visible && collisionEnabled
-      );
-      if (collisionLayers.length === 0) {
-        this.channels = {};
-        return;
-      }
-      if (!this.collisionFilterPass) {
-        this.collisionFilterPass = new CollisionFilterPass(device, { id: "default-collision-filter" });
-      }
-      const effects = allEffects?.filter((e) => e.constructor === MaskEffect);
-      const maskEffectRendered = preRenderStats["mask-effect"]?.didRender;
-      const channels = this._groupByCollisionGroup(device, collisionLayers);
-      const viewport = viewports[0];
-      const viewportChanged = !this.lastViewport || !this.lastViewport.equals(viewport) || maskEffectRendered;
-      for (const collisionGroup in channels) {
-        const collisionFBO = this.collisionFBOs[collisionGroup];
-        const renderInfo = channels[collisionGroup];
-        const [width, height] = device.canvasContext.getPixelSize();
-        collisionFBO.resize({
-          width: width / DOWNSCALE,
-          height: height / DOWNSCALE
-        });
-        this._render(renderInfo, {
-          effects,
-          layerFilter,
-          onViewportActive,
-          views,
-          viewport,
-          viewportChanged
-        });
-      }
-    }
-    _render(renderInfo, {
-      effects,
-      layerFilter,
-      onViewportActive,
-      views,
-      viewport,
-      viewportChanged
-    }) {
-      const { collisionGroup } = renderInfo;
-      const oldRenderInfo = this.channels[collisionGroup];
-      if (!oldRenderInfo) {
-        return;
-      }
-      const needsRender = viewportChanged || renderInfo === oldRenderInfo || !(0, import_core19._deepEqual)(oldRenderInfo.layers, renderInfo.layers, 1) || renderInfo.layerBounds.some((b, i) => !equals(b, oldRenderInfo.layerBounds[i])) || renderInfo.allLayersLoaded !== oldRenderInfo.allLayersLoaded || renderInfo.layers.some((layer) => layer.props.transitions);
-      this.channels[collisionGroup] = renderInfo;
-      if (needsRender) {
-        this.lastViewport = viewport;
-        const collisionFBO = this.collisionFBOs[collisionGroup];
-        this.collisionFilterPass.renderCollisionMap(collisionFBO, {
-          pass: "collision-filter",
-          isPicking: true,
-          layers: renderInfo.layers,
-          effects,
-          layerFilter,
-          viewports: viewport ? [viewport] : [],
-          onViewportActive,
-          views,
-          moduleParameters: {
-            dummyCollisionMap: this.dummyCollisionMap,
-            devicePixelRatio: collisionFBO.device.canvasContext.getDevicePixelRatio() / DOWNSCALE
-          }
-        });
-      }
-    }
-    _groupByCollisionGroup(device, collisionLayers) {
-      const channelMap = {};
-      for (const layer of collisionLayers) {
-        const { collisionGroup } = layer.props;
-        let channelInfo = channelMap[collisionGroup];
-        if (!channelInfo) {
-          channelInfo = { collisionGroup, layers: [], layerBounds: [], allLayersLoaded: true };
-          channelMap[collisionGroup] = channelInfo;
-        }
-        channelInfo.layers.push(layer);
-        channelInfo.layerBounds.push(layer.getBounds());
-        if (!layer.isLoaded) {
-          channelInfo.allLayersLoaded = false;
-        }
-      }
-      for (const collisionGroup of Object.keys(channelMap)) {
-        if (!this.collisionFBOs[collisionGroup]) {
-          this.createFBO(device, collisionGroup);
-        }
-        if (!this.channels[collisionGroup]) {
-          this.channels[collisionGroup] = channelMap[collisionGroup];
-        }
-      }
-      for (const collisionGroup of Object.keys(this.collisionFBOs)) {
-        if (!channelMap[collisionGroup]) {
-          this.destroyFBO(collisionGroup);
-        }
-      }
-      return channelMap;
-    }
-    getModuleParameters(layer) {
-      const { collisionGroup } = layer.props;
-      const { collisionFBOs, dummyCollisionMap } = this;
-      return { collisionFBO: collisionFBOs[collisionGroup], dummyCollisionMap };
-    }
-    cleanup() {
-      if (this.dummyCollisionMap) {
-        this.dummyCollisionMap.delete();
-        this.dummyCollisionMap = void 0;
-      }
-      this.channels = {};
-      for (const collisionGroup of Object.keys(this.collisionFBOs)) {
-        this.destroyFBO(collisionGroup);
-      }
-      this.collisionFBOs = {};
-      this.lastViewport = void 0;
-    }
-    createFBO(device, collisionGroup) {
-      const { width, height } = device.gl.canvas;
-      const collisionMap = device.createTexture({
-        format: "rgba8unorm",
-        width,
-        height,
-        sampler: {
-          minFilter: "nearest",
-          magFilter: "nearest",
-          addressModeU: "clamp-to-edge",
-          addressModeV: "clamp-to-edge"
-        }
-      });
-      const depthStencilAttachment = device.createTexture({
-        format: "depth16unorm",
-        width,
-        height,
-        mipmaps: false,
-        dataFormat: 6402,
-        type: 5125
-      });
-      this.collisionFBOs[collisionGroup] = device.createFramebuffer({
-        id: `collision-${collisionGroup}`,
-        width,
-        height,
-        colorAttachments: [collisionMap],
-        depthStencilAttachment
-      });
-    }
-    destroyFBO(collisionGroup) {
-      const fbo = this.collisionFBOs[collisionGroup];
-      fbo.colorAttachments[0]?.destroy();
-      fbo.depthStencilAttachment?.destroy();
-      fbo.destroy();
-      delete this.collisionFBOs[collisionGroup];
-    }
-  };
-
-  // src/collision-filter/collision-filter-extension.ts
-  var defaultProps6 = {
-    getCollisionPriority: { type: "accessor", value: 0 },
-    collisionEnabled: true,
-    collisionGroup: { type: "string", value: "default" },
-    collisionTestProps: {}
-  };
-  var CollisionFilterExtension = class extends import_core20.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) {
-        this.props = this.clone(this.props.collisionTestProps).props;
-      }
-    }
-    initializeState(context, extension) {
-      if (this.getAttributeManager() === null) {
-        return;
-      }
-      this.context.deck?._addDefaultEffect(new CollisionFilterEffect());
-      const attributeManager = this.getAttributeManager();
-      attributeManager.add({
-        collisionPriorities: {
-          size: 1,
-          accessor: "getCollisionPriority",
-          shaderAttributes: {
-            collisionPriorities: { divisor: 0 },
-            instanceCollisionPriorities: { divisor: 1 }
-          }
-        }
-      });
-    }
-    getNeedsPickingBuffer() {
-      return this.props.collisionEnabled;
-    }
-  };
-  CollisionFilterExtension.defaultProps = defaultProps6;
-  CollisionFilterExtension.extensionName = "CollisionFilterExtension";
-
-  // src/mask/mask-extension.ts
-  var import_core22 = __toESM(require_core(), 1);
-
-  // src/mask/shader-module.ts
-  var import_core21 = __toESM(require_core(), 1);
-  var vs4 = glsl`
-uniform vec4 mask_bounds;
-uniform bool mask_maskByInstance;
-vec2 mask_getCoords(vec4 position) {
-  return (position.xy - mask_bounds.xy) / (mask_bounds.zw - mask_bounds.xy);
-}
-`;
-  var fs3 = 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;
-  }
-}
-`;
-  var inject5 = {
-    "vs:#decl": glsl`
-out vec2 mask_texCoords;
-`,
-    "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": 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) {
-      return {
-        mask_texture: opts.maskMap
-      };
-    }
-    return {};
-  };
-  var shader_module_default3 = {
-    name: "mask",
-    dependencies: [import_core21.project],
-    vs: vs4,
-    fs: fs3,
-    inject: inject5,
-    getUniforms: getMaskUniforms
-  };
-
   // src/mask/mask-extension.ts
   var defaultProps7 = {
     maskId: "",
@@ -4152,16 +4193,18 @@ if ((terrain_mode == TERRAIN_MODE_USE_COVER) || (terrain_mode == TERRAIN_MODE_US
       id: opts.id,
       colorAttachments: [
         device.createTexture({
+          id: opts.id,
           ...opts.float && {
             format: "rgba32float",
             type: GLEnum.FLOAT
           },
           mipmaps: false,
-          sampler: {
+          sampler: opts.interpolate === false ? {
+            minFilter: "nearest",
+            magFilter: "nearest"
+          } : {
             minFilter: "linear",
-            magFilter: "linear",
-            addressModeU: "clamp-to-edge",
-            addressModeV: "clamp-to-edge"
+            magFilter: "linear"
           }
         })
       ]
@@ -4285,7 +4328,8 @@ if ((terrain_mode == TERRAIN_MODE_USE_COVER) || (terrain_mode == TERRAIN_MODE_US
       }
       if (!this.pickingFbo) {
         this.pickingFbo = createRenderTarget(this.targetLayer.context.device, {
-          id: `${this.id}-picking`
+          id: `${this.id}-picking`,
+          interpolate: false
         });
       }
       return this.pickingFbo;
@@ -4333,6 +4377,14 @@ if ((terrain_mode == TERRAIN_MODE_USE_COVER) || (terrain_mode == TERRAIN_MODE_US
 
   // src/terrain/terrain-pass.ts
   var import_core24 = __toESM(require_core(), 1);
+  var TERRAIN_BLENDING = {
+    blendColorOperation: "max",
+    blendColorSrcFactor: "one",
+    blendColorDstFactor: "one",
+    blendAlphaOperation: "max",
+    blendAlphaSrcFactor: "one",
+    blendAlphaDstFactor: "one"
+  };
   var TerrainPass = class extends import_core24._LayersPass {
     getRenderableLayers(viewport, opts) {
       const { layers } = opts;
@@ -4353,23 +4405,15 @@ if ((terrain_mode == TERRAIN_MODE_USE_COVER) || (terrain_mode == TERRAIN_MODE_US
         return;
       }
       target.resize(viewport);
-      this.device.withParametersWebGL(
-        {
-          clearColor: [0, 0, 0, 0],
-          blend: true,
-          blendFunc: [GLEnum.ONE, GLEnum.ONE],
-          blendEquation: GLEnum.MAX,
-          depthTest: false
-        },
-        () => this.render({
-          ...opts,
-          target,
-          pass: "terrain-height-map",
-          layers: opts.layers,
-          viewports: [viewport],
-          effects: []
-        })
-      );
+      this.render({
+        ...opts,
+        target,
+        pass: "terrain-height-map",
+        layers: opts.layers,
+        viewports: [viewport],
+        effects: [],
+        clearColor: [0, 0, 0, 0]
+      });
     }
     renderTerrainCover(terrainCover, opts) {
       const target = terrainCover.getRenderFramebuffer();
@@ -4379,20 +4423,23 @@ if ((terrain_mode == TERRAIN_MODE_USE_COVER) || (terrain_mode == TERRAIN_MODE_US
       }
       const layers = terrainCover.filterLayers(opts.layers);
       target.resize(viewport);
-      this.device.withParametersWebGL(
-        {
-          clearColor: [0, 0, 0, 0],
-          depthTest: false
-        },
-        () => this.render({
-          ...opts,
-          target,
-          pass: `terrain-cover-${terrainCover.id}`,
-          layers,
-          effects: [],
-          viewports: [viewport]
-        })
-      );
+      this.render({
+        ...opts,
+        target,
+        pass: `terrain-cover-${terrainCover.id}`,
+        layers,
+        effects: [],
+        viewports: [viewport],
+        clearColor: [0, 0, 0, 0]
+      });
+    }
+    getLayerParameters(layer, layerIndex, viewport) {
+      return {
+        ...layer.props.parameters,
+        blend: true,
+        depthTest: false,
+        ...layer.props.operation.includes("terrain") && TERRAIN_BLENDING
+      };
     }
   };
 
@@ -4430,30 +4477,27 @@ if ((terrain_mode == TERRAIN_MODE_USE_COVER) || (terrain_mode == TERRAIN_MODE_US
         layers.unshift(terrainLayer);
       }
       target.resize(viewport);
-      this.device.withParametersWebGL(
-        {
-          depthTest: false
-        },
-        () => this.render({
-          ...opts,
-          pickingFBO: target,
-          pass: `terrain-cover-picking-${terrainCover.id}`,
-          layers,
-          effects: [],
-          viewports: [viewport],
-          cullRect: void 0,
-          deviceRect: viewport,
-          pickZ: false
-        })
-      );
+      this.render({
+        ...opts,
+        pickingFBO: target,
+        pass: `terrain-cover-picking-${terrainCover.id}`,
+        layers,
+        effects: [],
+        viewports: [viewport],
+        cullRect: void 0,
+        deviceRect: viewport,
+        pickZ: false
+      });
     }
     getLayerParameters(layer, layerIndex, viewport) {
+      let parameters2;
       if (this.drawParameters[layer.id]) {
-        return this.drawParameters[layer.id];
+        parameters2 = this.drawParameters[layer.id];
+      } else {
+        parameters2 = super.getLayerParameters(layer, layerIndex, viewport);
+        parameters2.blend = true;
       }
-      const parameters2 = super.getLayerParameters(layer, layerIndex, viewport);
-      parameters2.blend = true;
-      return parameters2;
+      return { ...parameters2, depthTest: false };
     }
   };
 
@@ -4538,7 +4582,7 @@ if ((terrain_mode == TERRAIN_MODE_USE_COVER) || (terrain_mode == TERRAIN_MODE_US
       this.isDrapingEnabled = false;
       this.terrainCovers = /* @__PURE__ */ new Map();
     }
-    initialize(device) {
+    setup({ device, deck }) {
       this.dummyHeightMap = device.createTexture({
         width: 1,
         height: 1,
@@ -4551,17 +4595,9 @@ if ((terrain_mode == TERRAIN_MODE_USE_COVER) || (terrain_mode == TERRAIN_MODE_US
       } else {
         import_core26.log.warn("Terrain offset mode is not supported by this browser")();
       }
-      (0, import_core26.getShaderAssembler)().addDefaultModule(terrainModule);
-    }
-    preRender(device, opts) {
-      if (!this.dummyHeightMap) {
-        this.initialize(device);
-        for (const layer of opts.layers) {
-          if (layer.props.operation.includes("terrain")) {
-            layer.setChangeFlags({ extensionsChanged: true });
-          }
-        }
-      }
+      deck._addDefaultShaderModule(terrainModule);
+    }
+    preRender(opts) {
       if (opts.pickZ) {
         this.isDrapingEnabled = false;
         return;
@@ -4599,7 +4635,7 @@ if ((terrain_mode == TERRAIN_MODE_USE_COVER) || (terrain_mode == TERRAIN_MODE_US
         terrainSkipRender: terrainDrawMode === "drape" || !layer.props.operation.includes("draw")
       };
     }
-    cleanup() {
+    cleanup({ deck }) {
       if (this.dummyHeightMap) {
         this.dummyHeightMap.delete();
         this.dummyHeightMap = void 0;
@@ -4612,7 +4648,7 @@ if ((terrain_mode == TERRAIN_MODE_USE_COVER) || (terrain_mode == TERRAIN_MODE_US
         terrainCover.delete();
       }
       this.terrainCovers.clear();
-      (0, import_core26.getShaderAssembler)().removeDefaultModule(terrainModule);
+      deck._removeDefaultShaderModule(terrainModule);
     }
     _updateHeightMap(terrainLayers, viewport, opts) {
       if (!this.heightMap) {