@deck.gl/extensions 9.3.2 → 9.3.4

package/src/mask/mask-effect.ts

@@ -70,6 +70,7 @@ export default class MaskEffect implements Effect {
     viewports,
     onViewportActive,
     views,
+    effects,
     isPicking
   }: PreRenderOptions): MaskPreRenderStats {
     let didRender = false;
@@ -103,6 +104,7 @@ export default class MaskEffect implements Effect {
         layerFilter,
         onViewportActive,
         views,
+        effects,
         viewport,
         viewportChanged
       });
@@ -120,12 +122,14 @@ export default class MaskEffect implements Effect {
       layerFilter,
       onViewportActive,
       views,
+      effects,
       viewport,
       viewportChanged
     }: {
       layerFilter: PreRenderOptions['layerFilter'];
       onViewportActive: PreRenderOptions['onViewportActive'];
       views: PreRenderOptions['views'];
+      effects: PreRenderOptions['effects'];
       viewport: Viewport;
       viewportChanged: boolean;
     }
@@ -190,6 +194,7 @@ export default class MaskEffect implements Effect {
           viewports: maskViewport ? [maskViewport] : [],
           onViewportActive,
           views,
+          effects,
           shaderModuleProps: {
             project: {
               devicePixelRatio: 1

package/src/terrain/shader-module.ts

@@ -119,7 +119,13 @@ if ((terrain.mode == TERRAIN_MODE_USE_COVER) || (terrain.mode == TERRAIN_MODE_US
   },
   // eslint-disable-next-line complexity
   getUniforms: (opts: Partial<TerrainModuleProps> = {}) => {
-    if ('dummyHeightMap' in opts) {
+    if (!opts.dummyHeightMap) {
+      // TerrainEffect has not provided props (e.g. not set up yet, or this pass
+      // doesn't include the terrain effect in its effects list)
+      return {};
+    }
+
+    if ('terrainSkipRender' in opts || 'drawToTerrainHeightMap' in opts) {
       const {
         drawToTerrainHeightMap,
         heightMap,
@@ -134,7 +140,7 @@ if ((terrain.mode == TERRAIN_MODE_USE_COVER) || (terrain.mode == TERRAIN_MODE_US
 
       let mode: number = terrainSkipRender ? TERRAIN_MODE.SKIP : TERRAIN_MODE.NONE;
       // height map if case USE_HEIGHT_MAP, terrain cover if USE_COVER, otherwise empty
-      let sampler: Texture | undefined = dummyHeightMap as Texture;
+      let sampler: Texture = dummyHeightMap;
       // height map bounds if case USE_HEIGHT_MAP, terrain cover bounds if USE_COVER, otherwise null
       let bounds: number[] | null = null;
       if (drawToTerrainHeightMap) {
@@ -149,19 +155,17 @@ if ((terrain.mode == TERRAIN_MODE_USE_COVER) || (terrain.mode == TERRAIN_MODE_US
         const fbo = opts.isPicking
           ? terrainCover.getPickingFramebuffer()
           : terrainCover.getRenderFramebuffer();
-        sampler = fbo?.colorAttachments[0].texture;
+        const coverTexture = fbo?.colorAttachments[0].texture;
         if (opts.isPicking) {
           mode = TERRAIN_MODE.SKIP;
         }
-        if (sampler) {
+        if (coverTexture) {
+          sampler = coverTexture;
           mode = mode === TERRAIN_MODE.SKIP ? TERRAIN_MODE.USE_COVER_ONLY : TERRAIN_MODE.USE_COVER;
           bounds = terrainCover.bounds;
-        } else {
-          sampler = dummyHeightMap!;
-          if (opts.isPicking && !terrainSkipRender) {
-            // terrain+draw layer without cover FBO: render own picking colors
-            mode = TERRAIN_MODE.NONE;
-          }
+        } else if (opts.isPicking && !terrainSkipRender) {
+          // terrain+draw layer without cover FBO: render own picking colors
+          mode = TERRAIN_MODE.NONE;
         }
       }
 
@@ -180,7 +184,14 @@ if ((terrain.mode == TERRAIN_MODE_USE_COVER) || (terrain.mode == TERRAIN_MODE_US
           : [0, 0, 0, 0]
       };
     }
-    return {};
+    // No terrain-specific props provided but dummyHeightMap is available
+    // (e.g. non-terrain render pass where the effect still provides props).
+    // Provide the dummy texture to satisfy the terrain_map binding.
+    return {
+      mode: TERRAIN_MODE.NONE,
+      terrain_map: opts.dummyHeightMap,
+      bounds: [0, 0, 0, 0]
+    };
   },
   uniformTypes: {
     mode: 'f32',

package/src/terrain/terrain-effect.ts

@@ -38,6 +38,7 @@ export class TerrainEffect implements Effect {
       height: 1,
       data: new Uint8Array([0, 0, 0, 0])
     });
+
     this.terrainPass = new TerrainPass(device, {id: 'terrain'});
     this.terrainPickingPass = new TerrainPickingPass(device, {id: 'terrain-picking'});
 
@@ -83,13 +84,29 @@ export class TerrainEffect implements Effect {
     }
 
     const drapeLayers = layers.filter(l => l.state.terrainDrawMode === 'drape');
-    this._updateTerrainCovers(terrainLayers, drapeLayers, viewport, opts);
+    // Filter out the terrain effect itself to avoid feedback loops when rendering terrain covers
+    // (the terrain cover FBO would be both read and written to). Other effects like MaskEffect
+    // need to be passed through so they can apply to draped layers.
+    const nonTerrainEffects = opts.effects?.filter(e => e !== this);
+    this._updateTerrainCovers(terrainLayers, drapeLayers, viewport, {
+      ...opts,
+      effects: nonTerrainEffects
+    });
   }
 
   getShaderModuleProps(
     layer: Layer,
     otherShaderModuleProps: Record<string, any>
-  ): {terrain: TerrainModuleProps} {
+  ): {terrain: Partial<TerrainModuleProps>} {
+    // Mask layers need the terrain_map binding satisfied but shouldn't use terrain features
+    if (layer.props.operation.includes('mask')) {
+      return {
+        terrain: {
+          dummyHeightMap: this.dummyHeightMap!
+        }
+      };
+    }
+
     const {terrainDrawMode} = layer.state;
     const terrainCover = this.isDrapingEnabled ? (this.terrainCovers.get(layer.id) ?? null) : null;
 

package/src/terrain/terrain-pass.ts

@@ -73,7 +73,6 @@ export class TerrainPass extends LayersPass {
       target,
       pass: `terrain-cover-${terrainCover.id}`,
       layers,
-      effects: [],
       viewports: [viewport],
       clearColor: [0, 0, 0, 0]
     });

package/src/terrain/terrain-picking-pass.ts

@@ -69,7 +69,6 @@ export class TerrainPickingPass extends PickLayersPass {
       pickingFBO: target,
       pass: `terrain-cover-picking-${terrainCover.id}`,
       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`