8295129408

Committed 15 Mar 2024 10:59AM UTC coverage: 86.419% (+0.008%) from 86.411%

Build # 8295129408

Build Type

Pull #8666

github

Committed by

web-flow

Commit Message

Merge 1bcb65f3b into 12624ac7b

Pull Request Pull Request #8666: Remove terrainModule from ShaderAssembler on cleanup

Run Details

5636 of 6305 branches covered (89.39%)

Branch coverage included in aggregate %.

0 of 2 new or added lines in 1 file covered. (0.0%)

1 existing line in 1 file now uncovered.

49293 of 57256 relevant lines covered (86.09%)

2874.55 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

13.42

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

import {Device, Texture} from '@luma.gl/core';
import {log, getShaderAssembler} from '@deck.gl/core';

import {terrainModule, TerrainModuleSettings} from './shader-module';
import {TerrainCover} from './terrain-cover';
import {TerrainPass} from './terrain-pass';
import {TerrainPickingPass, TerrainPickingPassRenderOptions} from './terrain-picking-pass';
import {HeightMapBuilder} from './height-map-builder';

import type {Effect, PreRenderOptions, Layer, Viewport} from '@deck.gl/core';

/** Class to manage terrain effect */
export class TerrainEffect implements Effect {
  id = 'terrain-effect';
  props = null;
  useInPicking = true;

  /** true if picking in the current pass */
  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;
  private terrainPickingPass!: TerrainPickingPass;
  /** One texture for each primitive terrain layer, into which the draped layers render */
  private terrainCovers: Map<string, TerrainCover> = new Map();

  initialize(device: Device) {
    this.dummyHeightMap = device.createTexture({
      width: 1,
      height: 1,
      data: new Uint8Array([0, 0, 0, 0])
    });
    this.terrainPass = new TerrainPass(device, {id: 'terrain'});
    this.terrainPickingPass = new TerrainPickingPass(device, {id: 'terrain-picking'});

    if (HeightMapBuilder.isSupported(device)) {
      this.heightMap = new HeightMapBuilder(device);
    } else {
      log.warn('Terrain offset mode is not supported by this browser')();
    }

    getShaderAssembler().addDefaultModule(terrainModule);
  }

  preRender(device: Device, opts: PreRenderOptions): void {
    if (!this.dummyHeightMap) {
      // First time this effect is in use, initialize resources and register the shader module
      this.initialize(device);
      for (const layer of opts.layers) {
        // Force the terrain layer (and its descendents) to rebuild their models with the new shader
        if (layer.props.operation.includes('terrain')) {
          layer.setChangeFlags({extensionsChanged: true});
        }
      }
    }

    // @ts-expect-error pickZ only defined in picking pass
    if (opts.pickZ) {
      // Do not update if picking attributes
      this.isDrapingEnabled = false;
      return;
    }

    const {viewports} = opts;
    const isPicking = opts.pass.startsWith('picking');
    this.isPicking = isPicking;
    this.isDrapingEnabled = true;

    // TODO - support multiple views?
    const viewport = viewports[0];
    const layers = (isPicking ? this.terrainPickingPass : this.terrainPass).getRenderableLayers(
      viewport,
      opts as TerrainPickingPassRenderOptions
    );

    const terrainLayers = layers.filter(l => l.props.operation.includes('terrain'));
    if (terrainLayers.length === 0) {
      return;
    }

    if (!isPicking) {
      const offsetLayers = layers.filter(l => l.state.terrainDrawMode === 'offset');
      if (offsetLayers.length > 0) {
        this._updateHeightMap(terrainLayers, viewport, opts);
      }
    }

    const drapeLayers = layers.filter(l => l.state.terrainDrawMode === 'drape');
    this._updateTerrainCovers(terrainLayers, drapeLayers, viewport, opts);
  }

  getModuleParameters(layer: Layer): Omit<TerrainModuleSettings, 'picking'> {
    const {terrainDrawMode} = layer.state;

    return {
      heightMap: this.heightMap?.getRenderFramebuffer()?.colorAttachments[0].texture || null,
      heightMapBounds: this.heightMap?.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(): void {
    if (this.dummyHeightMap) {
      this.dummyHeightMap.delete();
      this.dummyHeightMap = undefined;
    }

    if (this.heightMap) {
      this.heightMap.delete();
      this.heightMap = undefined;
    }

    for (const terrainCover of this.terrainCovers.values()) {
      terrainCover.delete();
    }
    this.terrainCovers.clear();

    getShaderAssembler().removeDefaultModule(terrainModule);
  }

  private _updateHeightMap(terrainLayers: Layer[], viewport: Viewport, opts: PreRenderOptions) {
    if (!this.heightMap) {
      // Not supported
      return;
    }

    const shouldUpdate = this.heightMap.shouldUpdate({layers: terrainLayers, viewport});
    if (!shouldUpdate) {
      return;
    }

    this.terrainPass.renderHeightMap(this.heightMap, {
      ...opts,
      layers: terrainLayers,
      moduleParameters: {
        heightMapBounds: this.heightMap.bounds,
        dummyHeightMap: this.dummyHeightMap,
        devicePixelRatio: 1,
        drawToTerrainHeightMap: true
      }
    });
  }

  private _updateTerrainCovers(
    terrainLayers: Layer[],
    drapeLayers: Layer[],
    viewport: Viewport,
    opts: PreRenderOptions
  ) {
    // Mark a terrain cover as dirty if one of the drape layers needs redraw
    const layerNeedsRedraw: Record<string, boolean> = {};
    for (const layer of drapeLayers) {
      if (layer.state.terrainCoverNeedsRedraw) {
        layerNeedsRedraw[layer.id] = true;
        layer.state.terrainCoverNeedsRedraw = false;
      }
    }
    for (const terrainCover of this.terrainCovers.values()) {
      terrainCover.isDirty = terrainCover.isDirty || terrainCover.shouldUpdate({layerNeedsRedraw});
    }

    for (const layer of terrainLayers) {
      this._updateTerrainCover(layer, drapeLayers, viewport, opts);
    }

    if (!this.isPicking) {
      this._pruneTerrainCovers();
    }
  }

  private _updateTerrainCover(
    terrainLayer: Layer,
    drapeLayers: Layer[],
    viewport: Viewport,
    opts: PreRenderOptions
  ) {
    const renderPass = this.isPicking ? this.terrainPickingPass : this.terrainPass;
    let terrainCover = this.terrainCovers.get(terrainLayer.id);
    if (!terrainCover) {
      terrainCover = new TerrainCover(terrainLayer);
      this.terrainCovers.set(terrainLayer.id, terrainCover);
    }
    try {
      const isDirty = terrainCover.shouldUpdate({
        targetLayer: terrainLayer,
        viewport,
        layers: drapeLayers
      });
      if (this.isPicking || terrainCover.isDirty || isDirty) {
        renderPass.renderTerrainCover(terrainCover, {
          ...opts,
          layers: drapeLayers,
          moduleParameters: {
            dummyHeightMap: this.dummyHeightMap,
            terrainSkipRender: false,
            devicePixelRatio: 1
          }
        });

        if (!this.isPicking) {
          // IsDirty refers to the normal fbo, not the picking fbo.
          // Only mark it as not dirty if the normal fbo was updated.
          terrainCover.isDirty = false;
        }
      }
    } catch (err) {
      terrainLayer.raiseError(err as Error, `Error rendering terrain cover ${terrainCover.id}`);
    }
  }

  private _pruneTerrainCovers() {
    /** Prune the cache, remove textures for layers that have been removed */
    const idsToRemove: string[] = [];
    for (const [id, terrainCover] of this.terrainCovers) {
      if (!terrainCover.isActive) {
        idsToRemove.push(id);
      }
    }
    for (const id of idsToRemove) {
      this.terrainCovers.delete(id);
    }
  }
}

1	import {Device, Texture} from '@luma.gl/core';	1✔
2	import {log, getShaderAssembler} from '@deck.gl/core';	1✔
3		1✔
4	import {terrainModule, TerrainModuleSettings} from './shader-module';	1✔
5	import {TerrainCover} from './terrain-cover';	1✔
6	import {TerrainPass} from './terrain-pass';	1✔
7	import {TerrainPickingPass, TerrainPickingPassRenderOptions} from './terrain-picking-pass';	1✔
8	import {HeightMapBuilder} from './height-map-builder';	1✔
9		1✔
10	import type {Effect, PreRenderOptions, Layer, Viewport} from '@deck.gl/core';	1✔
11		1✔
12	/** Class to manage terrain effect */	1✔
13	export class TerrainEffect implements Effect {	1✔
14	id = 'terrain-effect';	×
15	props = null;	×
16	useInPicking = true;	×
17		×
18	/** true if picking in the current pass */	×
19	private isPicking: boolean = false;	×
20	/** true if should use in the current pass */	×
21	private isDrapingEnabled: boolean = false;	×
22	/** An empty texture as placeholder */	×
23	private dummyHeightMap?: Texture;	×
24	/** A texture encoding the ground elevation, updated once per redraw. Used by layers with offset mode */	×
25	private heightMap?: HeightMapBuilder;	×
26	private terrainPass!: TerrainPass;	×
27	private terrainPickingPass!: TerrainPickingPass;	×
28	/** One texture for each primitive terrain layer, into which the draped layers render */	×
29	private terrainCovers: Map<string, TerrainCover> = new Map();	×
30		1✔
31	initialize(device: Device) {	1✔
32	this.dummyHeightMap = device.createTexture({	×
33	width: 1,	×
34	height: 1,	×
35	data: new Uint8Array([0, 0, 0, 0])	×
36	});	×
37	this.terrainPass = new TerrainPass(device, {id: 'terrain'});	×
38	this.terrainPickingPass = new TerrainPickingPass(device, {id: 'terrain-picking'});	×
39		×
40	if (HeightMapBuilder.isSupported(device)) {	×
41	this.heightMap = new HeightMapBuilder(device);	×
42	} else {	×
43	log.warn('Terrain offset mode is not supported by this browser')();	×
44	}	×
45		×
46	getShaderAssembler().addDefaultModule(terrainModule);	×
47	}	×
48		1✔
49	preRender(device: Device, opts: PreRenderOptions): void {	1✔
50	if (!this.dummyHeightMap) {	×
51	// First time this effect is in use, initialize resources and register the shader module	×
52	this.initialize(device);	×
53	for (const layer of opts.layers) {	×
54	// Force the terrain layer (and its descendents) to rebuild their models with the new shader	×
55	if (layer.props.operation.includes('terrain')) {	×
56	layer.setChangeFlags({extensionsChanged: true});	×
57	}	×
58	}	×
59	}	×
60		×
61	// @ts-expect-error pickZ only defined in picking pass	×
62	if (opts.pickZ) {	×
63	// Do not update if picking attributes	×
64	this.isDrapingEnabled = false;	×
65	return;	×
66	}	×
67		×
68	const {viewports} = opts;	×
69	const isPicking = opts.pass.startsWith('picking');	×
70	this.isPicking = isPicking;	×
71	this.isDrapingEnabled = true;	×
72		×
73	// TODO - support multiple views?	×
74	const viewport = viewports[0];	×
75	const layers = (isPicking ? this.terrainPickingPass : this.terrainPass).getRenderableLayers(	×
76	viewport,	×
77	opts as TerrainPickingPassRenderOptions	×
78	);	×
79		×
80	const terrainLayers = layers.filter(l => l.props.operation.includes('terrain'));	×
81	if (terrainLayers.length === 0) {	×
82	return;	×
83	}	×
84		×
85	if (!isPicking) {	×
86	const offsetLayers = layers.filter(l => l.state.terrainDrawMode === 'offset');	×
87	if (offsetLayers.length > 0) {	×
88	this._updateHeightMap(terrainLayers, viewport, opts);	×
89	}	×
90	}	×
91		×
92	const drapeLayers = layers.filter(l => l.state.terrainDrawMode === 'drape');	×
93	this._updateTerrainCovers(terrainLayers, drapeLayers, viewport, opts);	×
94	}	×
95		1✔
96	getModuleParameters(layer: Layer): Omit<TerrainModuleSettings, 'picking'> {	1✔
97	const {terrainDrawMode} = layer.state;	×
98		×
99	return {	×
100	heightMap: this.heightMap?.getRenderFramebuffer()?.colorAttachments[0].texture \|\| null,	×
101	heightMapBounds: this.heightMap?.bounds,	×
102	dummyHeightMap: this.dummyHeightMap!,	×
103	terrainCover: this.isDrapingEnabled ? this.terrainCovers.get(layer.id) : null,	×
104	useTerrainHeightMap: terrainDrawMode === 'offset',	×
105	terrainSkipRender: terrainDrawMode === 'drape' \|\| !layer.props.operation.includes('draw')	×
106	};	×
107	}	×
108		1✔
109	cleanup(): void {	1✔
110	if (this.dummyHeightMap) {	×
111	this.dummyHeightMap.delete();	×
112	this.dummyHeightMap = undefined;	×
113	}	×
114		×
115	if (this.heightMap) {	×
116	this.heightMap.delete();	×
117	this.heightMap = undefined;	×
118	}	×
119		×
120	for (const terrainCover of this.terrainCovers.values()) {	×
121	terrainCover.delete();	×
122	}	×
123	this.terrainCovers.clear();	×
NEW 124		×
NEW 125	getShaderAssembler().removeDefaultModule(terrainModule);	×
UNCOV 126	}	×
127		1✔
128	private _updateHeightMap(terrainLayers: Layer[], viewport: Viewport, opts: PreRenderOptions) {	1✔
129	if (!this.heightMap) {	×
130	// Not supported	×
131	return;	×
132	}	×
133		×
134	const shouldUpdate = this.heightMap.shouldUpdate({layers: terrainLayers, viewport});	×
135	if (!shouldUpdate) {	×
136	return;	×
137	}	×
138		×
139	this.terrainPass.renderHeightMap(this.heightMap, {	×
140	...opts,	×
141	layers: terrainLayers,	×
142	moduleParameters: {	×
143	heightMapBounds: this.heightMap.bounds,	×
144	dummyHeightMap: this.dummyHeightMap,	×
145	devicePixelRatio: 1,	×
146	drawToTerrainHeightMap: true	×
147	}	×
148	});	×
149	}	×
150		1✔
151	private _updateTerrainCovers(	1✔
152	terrainLayers: Layer[],	×
153	drapeLayers: Layer[],	×
154	viewport: Viewport,	×
155	opts: PreRenderOptions	×
156	) {	×
157	// Mark a terrain cover as dirty if one of the drape layers needs redraw	×
158	const layerNeedsRedraw: Record<string, boolean> = {};	×
159	for (const layer of drapeLayers) {	×
160	if (layer.state.terrainCoverNeedsRedraw) {	×
161	layerNeedsRedraw[layer.id] = true;	×
162	layer.state.terrainCoverNeedsRedraw = false;	×
163	}	×
164	}	×
165	for (const terrainCover of this.terrainCovers.values()) {	×
166	terrainCover.isDirty = terrainCover.isDirty \|\| terrainCover.shouldUpdate({layerNeedsRedraw});	×
167	}	×
168		×
169	for (const layer of terrainLayers) {	×
170	this._updateTerrainCover(layer, drapeLayers, viewport, opts);	×
171	}	×
172		×
173	if (!this.isPicking) {	×
174	this._pruneTerrainCovers();	×
175	}	×
176	}	×
177		1✔
178	private _updateTerrainCover(	1✔
179	terrainLayer: Layer,	×
180	drapeLayers: Layer[],	×
181	viewport: Viewport,	×
182	opts: PreRenderOptions	×
183	) {	×
184	const renderPass = this.isPicking ? this.terrainPickingPass : this.terrainPass;	×
185	let terrainCover = this.terrainCovers.get(terrainLayer.id);	×
186	if (!terrainCover) {	×
187	terrainCover = new TerrainCover(terrainLayer);	×
188	this.terrainCovers.set(terrainLayer.id, terrainCover);	×
189	}	×
190	try {	×
191	const isDirty = terrainCover.shouldUpdate({	×
192	targetLayer: terrainLayer,	×
193	viewport,	×
194	layers: drapeLayers	×
195	});	×
196	if (this.isPicking \|\| terrainCover.isDirty \|\| isDirty) {	×
197	renderPass.renderTerrainCover(terrainCover, {	×
198	...opts,	×
199	layers: drapeLayers,	×
200	moduleParameters: {	×
201	dummyHeightMap: this.dummyHeightMap,	×
202	terrainSkipRender: false,	×
203	devicePixelRatio: 1	×
204	}	×
205	});	×
206		×
207	if (!this.isPicking) {	×
208	// IsDirty refers to the normal fbo, not the picking fbo.	×
209	// Only mark it as not dirty if the normal fbo was updated.	×
210	terrainCover.isDirty = false;	×
211	}	×
212	}	×
213	} catch (err) {	×
214	terrainLayer.raiseError(err as Error, `Error rendering terrain cover ${terrainCover.id}`);	×
215	}	×
216	}	×
217		1✔
218	private _pruneTerrainCovers() {	1✔
219	/** Prune the cache, remove textures for layers that have been removed */	×
220	const idsToRemove: string[] = [];	×
221	for (const [id, terrainCover] of this.terrainCovers) {	×
222	if (!terrainCover.isActive) {	×
223	idsToRemove.push(id);	×
224	}	×
225	}	×
226	for (const id of idsToRemove) {	×
227	this.terrainCovers.delete(id);	×
228	}	×
229	}	×
230	}	1✔

visgl / deck.gl / 8295129408

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous