Centralize dummy map

Author: felixpalmer

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

@@ -17,7 +17,6 @@ export type TerrainModuleProps = {
   isPicking: boolean;
   heightMap: Texture | null;
   heightMapBounds?: Bounds | null;
-  dummyHeightMap: Texture;
   terrainCover?: TerrainCover | null;
   drawToTerrainHeightMap?: boolean;
   useTerrainHeightMap?: boolean;
@@ -119,23 +118,27 @@ 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) {
+    const dummyHeightMap = terrainModule.dummyHeightMap;
+    if (!dummyHeightMap) {
+      // TerrainEffect has not been set up yet
+      return {};
+    }
+
+    if ('terrainSkipRender' in opts || 'drawToTerrainHeightMap' in opts) {
       const {
         drawToTerrainHeightMap,
         heightMap,
         heightMapBounds,
-        dummyHeightMap,
         terrainCover,
         useTerrainHeightMap,
         terrainSkipRender
       } = opts;
-
       const projectUniforms = project.getUniforms(opts.project) as ProjectUniforms;
       const {commonOrigin} = projectUniforms;
 
       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) {
@@ -150,15 +153,15 @@ 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;
@@ -181,22 +184,20 @@ if ((terrain.mode == TERRAIN_MODE_USE_COVER) || (terrain.mode == TERRAIN_MODE_US
           : [0, 0, 0, 0]
       };
     }
-    // When terrain props are not provided (e.g. mask pass), provide the dummy
-    // texture to satisfy the terrain_map binding and prevent draw abort.
-    // dummyHeightMap is stored on the module by TerrainEffect.setup.
-    if (terrainModule.dummyHeightMap) {
-      return {
-        mode: TERRAIN_MODE.NONE,
-        terrain_map: terrainModule.dummyHeightMap,
-        bounds: [0, 0, 0, 0]
-      };
-    }
-    return {};
+    // No terrain-specific props provided (e.g. mask pass or other non-terrain render pass).
+    // Provide the dummy texture to satisfy the terrain_map binding.
+    return {
+      mode: TERRAIN_MODE.NONE,
+      terrain_map: dummyHeightMap,
+      bounds: [0, 0, 0, 0]
+    };
   },
   uniformTypes: {
     mode: 'f32',
     bounds: 'vec4<f32>'
   },
-  /** Dummy texture stored by TerrainEffect.setup, used as fallback terrain_map binding */
+  /** Dummy texture created by TerrainEffect.setup, used as default terrain_map binding */
   dummyHeightMap: null as Texture | null
-} as ShaderModule<TerrainModuleProps, TerrainModuleUniforms, TerrainModuleBindings> & {dummyHeightMap: Texture | null};
+} as ShaderModule<TerrainModuleProps, TerrainModuleUniforms, TerrainModuleBindings> & {
+  dummyHeightMap: Texture | null;
+};

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

@@ -2,7 +2,6 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import {Texture} from '@luma.gl/core';
 import {log} from '@deck.gl/core';
 
 import {terrainModule, TerrainModuleProps} from './shader-module';
@@ -23,8 +22,6 @@ export class TerrainEffect implements Effect {
   private isPicking: boolean = false;
   /** true if should use in the current pass */
   private isDrapingEnabled: boolean = false;
-  /** An empty texture as placeholder */
-  private dummyHeightMap?: Texture;
   /** A texture encoding the ground elevation, updated once per redraw. Used by layers with offset mode */
   private heightMap?: HeightMapBuilder;
   private terrainPass!: TerrainPass;
@@ -33,14 +30,11 @@ export class TerrainEffect implements Effect {
   private terrainCovers: Map<string, TerrainCover> = new Map();
 
   setup({device, deck}: EffectContext) {
-    this.dummyHeightMap = device.createTexture({
+    terrainModule.dummyHeightMap = device.createTexture({
       width: 1,
       height: 1,
       data: new Uint8Array([0, 0, 0, 0])
     });
-    // Store on the module so it can provide a fallback terrain_map binding
-    // when rendered in passes that don't provide terrain effect props (e.g. mask pass)
-    terrainModule.dummyHeightMap = this.dummyHeightMap;
 
     this.terrainPass = new TerrainPass(device, {id: 'terrain'});
     this.terrainPickingPass = new TerrainPickingPass(device, {id: 'terrain-picking'});
@@ -115,7 +109,6 @@ export class TerrainEffect implements Effect {
         isPicking: this.isPicking,
         heightMap: this.heightMap?.getRenderFramebuffer()?.colorAttachments[0].texture || null,
         heightMapBounds: this.heightMap?.bounds,
-        dummyHeightMap: this.dummyHeightMap!,
         terrainCover,
         useTerrainHeightMap: terrainDrawMode === 'offset',
         terrainSkipRender: terrainDrawMode === 'drape' || !layer.props.operation.includes('draw')
@@ -124,9 +117,8 @@ export class TerrainEffect implements Effect {
   }
 
   cleanup({deck}: EffectContext): void {
-    if (this.dummyHeightMap) {
-      this.dummyHeightMap.delete();
-      this.dummyHeightMap = undefined;
+    if (terrainModule.dummyHeightMap) {
+      terrainModule.dummyHeightMap.delete();
       terrainModule.dummyHeightMap = null;
     }
 
@@ -160,7 +152,6 @@ export class TerrainEffect implements Effect {
       shaderModuleProps: {
         terrain: {
           heightMapBounds: this.heightMap.bounds,
-          dummyHeightMap: this.dummyHeightMap,
           drawToTerrainHeightMap: true
         },
         project: {
@@ -221,7 +212,6 @@ export class TerrainEffect implements Effect {
           layers: drapeLayers,
           shaderModuleProps: {
             terrain: {
-              dummyHeightMap: this.dummyHeightMap,
               terrainSkipRender: false
             },
             project: {