fix(TerrainExtension): Handle pick events in TerrainExtension & draped layers

modules/core/src/lib/deck-picker.ts

@@ -281,16 +281,17 @@ export default class DeckPicker {
       }
 
       let z;
-      if (pickInfo.pickedLayer && unproject3D && this.depthFBO) {
+      const depthLayers = this._getDepthLayers(pickInfo, pickableLayers, unproject3D);
+      if (depthLayers.length > 0) {
         const {pickedColors: pickedColors2} = this._drawAndSample(
           {
-            layers: [pickInfo.pickedLayer],
+            layers: depthLayers,
             views,
             viewports,
             onViewportActive,
             deviceRect: {
-              x: pickInfo.pickedX as number,
-              y: pickInfo.pickedY as number,
+              x: pickInfo.pickedX ?? devicePixel[0],
+              y: pickInfo.pickedY ?? devicePixel[1],
               width: 1,
               height: 1
             },
@@ -444,16 +445,17 @@ export default class DeckPicker {
       }
 
       let z;
-      if (pickInfo.pickedLayer && unproject3D && this.depthFBO) {
+      const depthLayers = this._getDepthLayers(pickInfo, pickableLayers, unproject3D);
+      if (depthLayers.length > 0) {
         const {pickedColors: pickedColors2} = this._drawAndSample(
           {
-            layers: [pickInfo.pickedLayer],
+            layers: depthLayers,
             views,
             viewports,
             onViewportActive,
             deviceRect: {
-              x: pickInfo.pickedX as number,
-              y: pickInfo.pickedY as number,
+              x: pickInfo.pickedX ?? devicePixel[0],
+              y: pickInfo.pickedY ?? devicePixel[1],
               width: 1,
               height: 1
             },
@@ -928,6 +930,25 @@ export default class DeckPicker {
     return {pickedColors, decodePickingColor};
   }
 
+  /**
+   * Determine which layers to use for the depth (pickZ) pass.
+   * - If a non-draped layer was picked, use just that layer.
+   * - If a draped layer was picked (geometry is at z=0) or no layer was picked
+   *   (e.g. no-FBO tiles at extreme zoom), fall back to terrain layers.
+   */
+  _getDepthLayers(pickInfo: PickedPixel, pickableLayers: Layer[], unproject3D?: boolean): Layer[] {
+    if (!unproject3D || !this.depthFBO) {
+      return [];
+    }
+    const {pickedLayer} = pickInfo;
+    const isDraped = pickedLayer?.state?.terrainDrawMode === 'drape';
+    if (pickedLayer && !isDraped) {
+      return [pickedLayer];
+    }
+    // For draped layers or when no layer was picked, use terrain layers for depth
+    return pickableLayers.filter(l => l.props.operation.includes('terrain'));
+  }
+
   /**
    * Calculate a picking rect centered on deviceX and deviceY and clipped to device
    * @returns null if pixel is outside of device

modules/core/src/passes/pick-layers-pass.ts

@@ -70,7 +70,8 @@ export default class PickLayersPass extends LayersPass {
     effects,
     pass = 'picking',
     pickZ,
-    shaderModuleProps
+    shaderModuleProps,
+    clearColor
   }: PickLayersPassRenderOptions): {
     decodePickingColor: PickingColorDecoder | null;
     stats: RenderStats;
@@ -96,7 +97,7 @@ export default class PickLayersPass extends LayersPass {
       pass,
       isPicking: true,
       shaderModuleProps,
-      clearColor: [0, 0, 0, 0],
+      clearColor: clearColor ?? [0, 0, 0, 0],
       colorMask: 0xf,
       scissorRect
     });
@@ -145,6 +146,13 @@ export default class PickLayersPass extends LayersPass {
       pickParameters.blend = true;
       // TODO: blendColor no longer part of luma.gl API
       pickParameters.blendColor = encodeColor(this._colorEncoderState, layer, viewport);
+      if (operation.includes('terrain') && layer.state?._hasPickingCover) {
+        // For terrain+draw layers with a valid cover FBO, the terrain shader outputs the
+        // cover FBO pixel which already has correctly encoded alpha from the cover encoder.
+        // Use srcFactor 'one' to pass through the cover alpha without double-encoding.
+        // Without a cover FBO, keep 'constant' so the layer's own picking colors encode correctly.
+        pickParameters.blendAlphaSrcFactor = 'one';
+      }
     } else if (operation.includes('terrain')) {
       // Pure terrain layers (without 'draw') don't need picking colors
       pickParameters.blend = false;

modules/extensions/src/terrain/shader-module.ts

@@ -151,14 +151,17 @@ if ((terrain.mode == TERRAIN_MODE_USE_COVER) || (terrain.mode == TERRAIN_MODE_US
           : terrainCover.getRenderFramebuffer();
         sampler = fbo?.colorAttachments[0].texture;
         if (opts.isPicking) {
-          // Never render the layer itself in picking pass
           mode = TERRAIN_MODE.SKIP;
         }
         if (sampler) {
           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;
+          }
         }
       }
 

modules/extensions/src/terrain/terrain-effect.ts

@@ -91,6 +91,12 @@ export class TerrainEffect implements Effect {
     otherShaderModuleProps: Record<string, any>
   ): {terrain: TerrainModuleProps} {
     const {terrainDrawMode} = layer.state;
+    const terrainCover = this.isDrapingEnabled ? (this.terrainCovers.get(layer.id) ?? null) : null;
+
+    // Communicate cover FBO availability to getLayerParameters for blend factor selection
+    if (this.isPicking && layer.props.operation.includes('terrain')) {
+      layer.state._hasPickingCover = Boolean(terrainCover?.getPickingFramebuffer());
+    }
 
     return {
       terrain: {
@@ -99,7 +105,7 @@ export class TerrainEffect implements Effect {
         heightMap: this.heightMap?.getRenderFramebuffer()?.colorAttachments[0].texture || null,
         heightMapBounds: this.heightMap?.bounds,
         dummyHeightMap: this.dummyHeightMap!,
-        terrainCover: this.isDrapingEnabled ? this.terrainCovers.get(layer.id) : null,
+        terrainCover,
         useTerrainHeightMap: terrainDrawMode === 'offset',
         terrainSkipRender: terrainDrawMode === 'drape' || !layer.props.operation.includes('draw')
       }

modules/extensions/src/terrain/terrain-picking-pass.ts

@@ -58,6 +58,12 @@ export class TerrainPickingPass extends PickLayersPass {
     }
     target.resize(viewport);
 
+    // Use the terrain layer's encoded alpha as the cover clear color.
+    // At pixels where no layer renders in the cover (e.g. mesh gaps at tile edges),
+    // this ensures the pixel still maps to the terrain layer instead of MISS.
+    const terrainParams = this.drawParameters[terrainLayer.id];
+    const terrainAlpha = terrainParams?.blendColor?.[3] ?? 0;
+
     this.render({
       ...opts,
       pickingFBO: target,
@@ -69,7 +75,8 @@ export class TerrainPickingPass extends PickLayersPass {
       // not the viewport of the terrain cover. Culling is already done by `terrainCover.filterLayers`
       cullRect: undefined,
       deviceRect: viewport,
-      pickZ: false
+      pickZ: false,
+      clearColor: [0, 0, 0, terrainAlpha]
     });
   }
 
@@ -81,7 +88,10 @@ export class TerrainPickingPass extends PickLayersPass {
       parameters = super.getLayerParameters(layer, layerIndex, viewport);
       parameters.blend = true;
     }
-    return {...parameters, depthCompare: 'always'};
+    // Cover rendering must use 'constant' blend factor to correctly encode layer indices
+    // in the alpha channel. The main picking pass uses 'one' for terrain+draw layers to
+    // pass through the cover alpha, but the cover itself needs proper encoding.
+    return {...parameters, depthCompare: 'always', blendAlphaSrcFactor: 'constant'};
   }
 
   getShaderModuleProps(layer: Layer, effects: any, otherShaderModuleProps: Record<string, any>) {