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

package/dist/terrain/height-map-builder.js

@@ -0,0 +1,104 @@
+import { joinLayerBounds, getRenderBounds, makeViewport } from "../utils/projection-utils.js";
+import { createRenderTarget } from "./utils.js";
+const MAP_MAX_SIZE = 2048;
+/**
+ * Manages the lifecycle of the height map (a framebuffer that encodes elevation).
+ * One instance of height map is is shared across all layers. It is updated when the viewport changes
+ * or when some terrain source layer's data changes.
+ * During the draw call of any terrainDrawMode:offset layers,
+ * the vertex shader reads from this framebuffer to retrieve its z offset.
+ */
+export class HeightMapBuilder {
+    static isSupported(device) {
+        return device.isTextureFormatRenderable('rgba32float');
+    }
+    constructor(device) {
+        /** Viewport used to draw into the texture */
+        this.renderViewport = null;
+        /** Bounds of the height map texture, in cartesian space */
+        this.bounds = null;
+        /** Last rendered layers */
+        this.layers = [];
+        /** Last layer.getBounds() */
+        this.layersBounds = [];
+        /** The union of layersBounds in cartesian space */
+        this.layersBoundsCommon = null;
+        this.lastViewport = null;
+        this.device = device;
+    }
+    /** Returns the height map framebuffer for read/write access.
+     * Returns null when the texture is invalid.
+     */
+    getRenderFramebuffer() {
+        if (!this.renderViewport) {
+            return null;
+        }
+        if (!this.fbo) {
+            this.fbo = createRenderTarget(this.device, { id: 'height-map', float: true });
+        }
+        return this.fbo;
+    }
+    /** Called every render cycle to check if the framebuffer needs update */
+    shouldUpdate({ layers, viewport }) {
+        const layersChanged = layers.length !== this.layers.length ||
+            layers.some((layer, i) => 
+            // Layer instance is updated
+            // Layer props might have changed
+            // Undetermined props could have an effect on the output geometry of a terrain source,
+            // for example getElevation+updateTriggers, elevationScale, modelMatrix
+            layer !== this.layers[i] ||
+                // Some prop is in transition
+                layer.props.transitions ||
+                // Layer's geometry bounds have changed
+                layer.getBounds() !== this.layersBounds[i]);
+        if (layersChanged) {
+            // Recalculate cached bounds
+            this.layers = layers;
+            this.layersBounds = layers.map(layer => layer.getBounds());
+            this.layersBoundsCommon = joinLayerBounds(layers, viewport);
+        }
+        const viewportChanged = !this.lastViewport || !viewport.equals(this.lastViewport);
+        if (!this.layersBoundsCommon) {
+            this.renderViewport = null;
+        }
+        else if (layersChanged || viewportChanged) {
+            const bounds = getRenderBounds(this.layersBoundsCommon, viewport);
+            if (bounds[2] <= bounds[0] || bounds[3] <= bounds[1]) {
+                this.renderViewport = null;
+                return false;
+            }
+            this.bounds = bounds;
+            this.lastViewport = viewport;
+            const scale = viewport.scale;
+            const pixelWidth = (bounds[2] - bounds[0]) * scale;
+            const pixelHeight = (bounds[3] - bounds[1]) * scale;
+            this.renderViewport =
+                pixelWidth > 0 || pixelHeight > 0
+                    ? makeViewport({
+                        // It's not important whether the geometry is visible in this viewport, because
+                        // vertices will not use the standard project_to_clipspace in the DRAW_TO_HEIGHT_MAP shader
+                        // However the viewport must have the same center and zoom as the screen viewport
+                        // So that projection uniforms used for calculating z are the same
+                        bounds: [
+                            viewport.center[0] - 1,
+                            viewport.center[1] - 1,
+                            viewport.center[0] + 1,
+                            viewport.center[1] + 1
+                        ],
+                        zoom: viewport.zoom,
+                        width: Math.min(pixelWidth, MAP_MAX_SIZE),
+                        height: Math.min(pixelHeight, MAP_MAX_SIZE),
+                        viewport
+                    })
+                    : null;
+            return true;
+        }
+        return false;
+    }
+    delete() {
+        if (this.fbo) {
+            this.fbo.colorAttachments[0].delete();
+            this.fbo.delete();
+        }
+    }
+}

package/{typed → dist}/terrain/shader-module.d.ts

@@ -1,7 +1,7 @@
 import type { ShaderModule } from '@luma.gl/shadertools';
 import type { Texture } from '@luma.gl/core';
-import type { Bounds } from '../utils/projection-utils';
-import type { TerrainCover } from './terrain-cover';
+import type { Bounds } from "../utils/projection-utils.js";
+import type { TerrainCover } from "./terrain-cover.js";
 /** Module parameters expected by the terrain shader module */
 export type TerrainModuleSettings = {
     picking: {

package/dist/terrain/shader-module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shader-module.d.ts","sourceRoot":"","sources":["../../src/terrain/shader-module.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,sBAAsB,CAAC;AAGvD,OAAO,KAAK,EAAC,OAAO,EAAC,MAAM,eAAe,CAAC;AAC3C,OAAO,KAAK,EAAC,MAAM,EAAC,qCAAkC;AACtD,OAAO,KAAK,EAAC,YAAY,EAAC,2BAAwB;AAGlD,8DAA8D;AAC9D,MAAM,MAAM,qBAAqB,GAAG;IAClC,OAAO,EAAE;QAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;KAAC,CAAC;IAC9B,SAAS,EAAE,OAAO,GAAG,IAAI,CAAC;IAC1B,eAAe,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAChC,cAAc,EAAE,OAAO,CAAC;IACxB,YAAY,CAAC,EAAE,YAAY,GAAG,IAAI,CAAC;IACnC,sBAAsB,CAAC,EAAE,OAAO,CAAC;IACjC,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B,iBAAiB,CAAC,EAAE,OAAO,CAAC;CAC7B,CAAC;AAEF,kDAAkD;AAClD,eAAO,MAAM,YAAY;;IAEvB,6EAA6E;;IAE7E,2EAA2E;;IAE3E,6FAA6F;;IAE7F,0EAA0E;;IAE1E,mEAAmE;;CAEpE,CAAC;AAOF,eAAO,MAAM,aAAa,qCA6Hc,CAAC"}

package/dist/terrain/shader-module.js

@@ -0,0 +1,137 @@
+/* eslint-disable camelcase */
+import { project } from '@deck.gl/core';
+import { glsl } from "../utils/syntax-tags.js";
+/** A model can have one of the following modes */
+export const TERRAIN_MODE = {
+    NONE: 0,
+    /** A terrain layer rendering encoded ground elevation into the height map */
+    WRITE_HEIGHT_MAP: 1,
+    /** An offset layer reading encoded ground elevation from the height map */
+    USE_HEIGHT_MAP: 2,
+    /** A terrain layer rendering to screen, using the cover fbo overlaid with its own texture */
+    USE_COVER: 3,
+    /** A terrain layer rendering to screen, using the cover fbo as texture */
+    USE_COVER_ONLY: 4,
+    /** Draped layer is rendered into a texture, and never to screen */
+    SKIP: 5
+};
+const TERRAIN_MODE_CONSTANTS = Object.keys(TERRAIN_MODE)
+    .map(key => `const float TERRAIN_MODE_${key} = ${TERRAIN_MODE[key]}.0;`)
+    .join('\n');
+// @ts-expect-error
+export const terrainModule = {
+    name: 'terrain',
+    dependencies: [project],
+    inject: {
+        'vs:#decl': `
+uniform float terrain_mode;
+uniform sampler2D terrain_map;
+uniform vec4 terrain_bounds;
+out vec3 commonPos;
+` + TERRAIN_MODE_CONSTANTS,
+        'vs:#main-start': `
+if (terrain_mode == TERRAIN_MODE_SKIP) {
+gl_Position = vec4(0.0);
+return;
+}
+`,
+        'vs:DECKGL_FILTER_GL_POSITION': `
+commonPos = geometry.position.xyz;
+if (terrain_mode == TERRAIN_MODE_WRITE_HEIGHT_MAP) {
+vec2 texCoords = (commonPos.xy - terrain_bounds.xy) / terrain_bounds.zw;
+position = vec4(texCoords * 2.0 - 1.0, 0.0, 1.0);
+commonPos.z += project_uCommonOrigin.z;
+}
+if (terrain_mode == TERRAIN_MODE_USE_HEIGHT_MAP) {
+vec3 anchor = geometry.worldPosition;
+anchor.z = 0.0;
+vec3 anchorCommon = project_position(anchor);
+vec2 texCoords = (anchorCommon.xy - terrain_bounds.xy) / terrain_bounds.zw;
+if (texCoords.x >= 0.0 && texCoords.y >= 0.0 && texCoords.x <= 1.0 && texCoords.y <= 1.0) {
+float terrainZ = texture(terrain_map, texCoords).r;
+geometry.position.z += terrainZ;
+position = project_common_position_to_clipspace(geometry.position);
+}
+}
+`,
+        'fs:#decl': `
+uniform float terrain_mode;
+uniform sampler2D terrain_map;
+uniform vec4 terrain_bounds;
+in vec3 commonPos;
+` + TERRAIN_MODE_CONSTANTS,
+        'fs:#main-start': `
+if (terrain_mode == TERRAIN_MODE_WRITE_HEIGHT_MAP) {
+fragColor = vec4(commonPos.z, 0.0, 0.0, 1.0);
+return;
+}
+`,
+        'fs:DECKGL_FILTER_COLOR': `
+if ((terrain_mode == TERRAIN_MODE_USE_COVER) || (terrain_mode == TERRAIN_MODE_USE_COVER_ONLY)) {
+vec2 texCoords = (commonPos.xy - terrain_bounds.xy) / terrain_bounds.zw;
+vec4 pixel = texture(terrain_map, texCoords);
+if (terrain_mode == TERRAIN_MODE_USE_COVER_ONLY) {
+color = pixel;
+} else {
+color = pixel + color * (1.0 - pixel.a);
+}
+return;
+}
+`
+    },
+    // eslint-disable-next-line complexity
+    getUniforms: (opts = {}, uniforms) => {
+        if ('dummyHeightMap' in opts) {
+            const { drawToTerrainHeightMap, heightMap, heightMapBounds, dummyHeightMap, terrainCover, useTerrainHeightMap, terrainSkipRender } = opts;
+            const { project_uCommonOrigin } = uniforms;
+            let mode = terrainSkipRender ? TERRAIN_MODE.SKIP : TERRAIN_MODE.NONE;
+            // height map if case USE_HEIGHT_MAP, terrain cover if USE_COVER, otherwise empty
+            let sampler = dummyHeightMap;
+            // height map bounds if case USE_HEIGHT_MAP, terrain cover bounds if USE_COVER, otherwise null
+            let bounds = null;
+            if (drawToTerrainHeightMap) {
+                mode = TERRAIN_MODE.WRITE_HEIGHT_MAP;
+                bounds = heightMapBounds;
+            }
+            else if (useTerrainHeightMap && heightMap) {
+                mode = TERRAIN_MODE.USE_HEIGHT_MAP;
+                sampler = heightMap;
+                bounds = heightMapBounds;
+            }
+            else if (terrainCover) {
+                // This is a terrain layer
+                const isPicking = opts.picking?.isActive;
+                const fbo = isPicking
+                    ? terrainCover.getPickingFramebuffer()
+                    : terrainCover.getRenderFramebuffer();
+                sampler = fbo?.colorAttachments[0].texture;
+                if (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;
+                }
+            }
+            /* eslint-disable camelcase */
+            return {
+                terrain_mode: mode,
+                terrain_map: sampler,
+                // Convert bounds to the common space, as [minX, minY, width, height]
+                terrain_bounds: bounds
+                    ? [
+                        bounds[0] - project_uCommonOrigin[0],
+                        bounds[1] - project_uCommonOrigin[1],
+                        bounds[2] - bounds[0],
+                        bounds[3] - bounds[1]
+                    ]
+                    : [0, 0, 0, 0]
+            };
+        }
+        return null;
+    }
+};

package/{typed → dist}/terrain/terrain-cover.d.ts

@@ -1,6 +1,6 @@
 import { Framebuffer } from '@luma.gl/core';
 import type { Layer, Viewport } from '@deck.gl/core';
-import { Bounds } from '../utils/projection-utils';
+import { Bounds } from "../utils/projection-utils.js";
 /**
  * Manages the lifecycle of the terrain cover (draped textures over a terrain mesh).
  * One terrain cover is created for each unique terrain layer (primitive layer with operation:terrain).

package/dist/terrain/terrain-cover.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"terrain-cover.d.ts","sourceRoot":"","sources":["../../src/terrain/terrain-cover.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,WAAW,EAAC,MAAM,eAAe,CAAC;AAE1C,OAAO,KAAK,EAAC,KAAK,EAAE,QAAQ,EAAC,MAAM,eAAe,CAAC;AAGnD,OAAO,EAAiD,MAAM,EAAC,qCAAkC;AAMjG;;;;;;GAMG;AACH,qBAAa,YAAY;IACvB,OAAO,EAAE,OAAO,CAAQ;IACxB,sDAAsD;IACtD,WAAW,EAAE,KAAK,CAAC;IACnB,6CAA6C;IAC7C,cAAc,EAAE,QAAQ,GAAG,IAAI,CAAQ;IACvC,8DAA8D;IAC9D,MAAM,EAAE,MAAM,GAAG,IAAI,CAAQ;IAE7B,OAAO,CAAC,GAAG,CAAC,CAAc;IAC1B,OAAO,CAAC,UAAU,CAAC,CAAc;IACjC,OAAO,CAAC,MAAM,CAAgB;IAC9B,OAAO,CAAC,IAAI,CAAoB;IAChC,gDAAgD;IAChD,OAAO,CAAC,YAAY,CAAqC;IACzD,sCAAsC;IACtC,OAAO,CAAC,kBAAkB,CAAuB;gBAErC,WAAW,EAAE,KAAK;IAK9B,IAAI,EAAE,WAEL;IAED,4EAA4E;IAC5E,IAAI,QAAQ,IAAI,OAAO,CAEtB;IAED,YAAY,CAAC,EACX,WAAW,EACX,QAAQ,EACR,MAAM,EACN,gBAAgB,EACjB,EAAE;QACD,WAAW,CAAC,EAAE,KAAK,CAAC;QACpB,QAAQ,CAAC,EAAE,QAAQ,CAAC;QACpB,MAAM,CAAC,EAAE,KAAK,EAAE,CAAC;QACjB,gBAAgB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;KAC5C,GAAG,OAAO;IAqBX,wEAAwE;IACxE,OAAO,CAAC,aAAa;IAuBrB,4FAA4F;IAC5F,OAAO,CAAC,eAAe;IAsDvB,oBAAoB,IAAI,WAAW,GAAG,IAAI;IAU1C,qBAAqB,IAAI,WAAW,GAAG,IAAI;IAY3C,YAAY,CAAC,MAAM,EAAE,KAAK,EAAE;IAI5B,MAAM;CAWP"}

package/dist/terrain/terrain-cover.js

@@ -0,0 +1,187 @@
+import { createRenderTarget } from "./utils.js";
+import { joinLayerBounds, makeViewport, getRenderBounds } from "../utils/projection-utils.js";
+/**
+ * Manages the lifecycle of the terrain cover (draped textures over a terrain mesh).
+ * One terrain cover is created for each unique terrain layer (primitive layer with operation:terrain).
+ * It is updated when the terrain source layer's mesh changes or when any of the terrainDrawMode:drape
+ * layers requires redraw.
+ * During the draw call of a terrain layer, the drape texture is overlaid on top of the layer's own color.
+ */
+export class TerrainCover {
+    constructor(targetLayer) {
+        this.isDirty = true;
+        /** Viewport used to draw into the texture */
+        this.renderViewport = null;
+        /** Bounds of the terrain cover texture, in cartesian space */
+        this.bounds = null;
+        this.layers = [];
+        /** Cached version of targetLayer.getBounds() */
+        this.targetBounds = null;
+        /** targetBounds in cartesian space */
+        this.targetBoundsCommon = null;
+        this.targetLayer = targetLayer;
+        this.tile = getTile(targetLayer);
+    }
+    get id() {
+        return this.targetLayer.id;
+    }
+    /** returns true if the target layer is still in use (i.e. not finalized) */
+    get isActive() {
+        return Boolean(this.targetLayer.getCurrentLayer());
+    }
+    shouldUpdate({ targetLayer, viewport, layers, layerNeedsRedraw }) {
+        if (targetLayer) {
+            this.targetLayer = targetLayer;
+        }
+        const sizeChanged = viewport ? this._updateViewport(viewport) : false;
+        let layersChanged = layers ? this._updateLayers(layers) : false;
+        if (layerNeedsRedraw) {
+            for (const id of this.layers) {
+                if (layerNeedsRedraw[id]) {
+                    layersChanged = true;
+                    // console.log('layer needs redraw', id);
+                    break;
+                }
+            }
+        }
+        return layersChanged || sizeChanged;
+    }
+    /** Compare layers with the last version. Only rerender if necessary. */
+    _updateLayers(layers) {
+        let needsRedraw = false;
+        layers = this.tile ? getIntersectingLayers(this.tile, layers) : layers;
+        if (layers.length !== this.layers.length) {
+            needsRedraw = true;
+            // console.log('layers count changed', this.layers.length, '>>', layers.length);
+        }
+        else {
+            for (let i = 0; i < layers.length; i++) {
+                const id = layers[i].id;
+                if (id !== this.layers[i]) {
+                    needsRedraw = true;
+                    // console.log('layer added/removed', id);
+                    break;
+                }
+            }
+        }
+        if (needsRedraw) {
+            this.layers = layers.map(layer => layer.id);
+        }
+        return needsRedraw;
+    }
+    /** Compare viewport and terrain bounds with the last version. Only rerender if necesary. */
+    _updateViewport(viewport) {
+        const targetLayer = this.targetLayer;
+        let shouldRedraw = false;
+        if (this.tile && 'boundingBox' in this.tile) {
+            if (!this.targetBounds) {
+                shouldRedraw = true;
+                this.targetBounds = this.tile.boundingBox;
+                const bottomLeftCommon = viewport.projectPosition(this.targetBounds[0]);
+                const topRightCommon = viewport.projectPosition(this.targetBounds[1]);
+                this.targetBoundsCommon = [
+                    bottomLeftCommon[0],
+                    bottomLeftCommon[1],
+                    topRightCommon[0],
+                    topRightCommon[1]
+                ];
+            }
+        }
+        else if (this.targetBounds !== targetLayer.getBounds()) {
+            // console.log('bounds changed', this.bounds, '>>', newBounds);
+            shouldRedraw = true;
+            this.targetBounds = targetLayer.getBounds();
+            this.targetBoundsCommon = joinLayerBounds([targetLayer], viewport);
+        }
+        if (!this.targetBoundsCommon) {
+            return false;
+        }
+        const newZoom = Math.ceil(viewport.zoom + 0.5);
+        // If the terrain layer is bound to a tile, always render a texture that cover the whole tile.
+        // Otherwise, use the smaller of layer bounds and the viewport bounds.
+        if (this.tile) {
+            this.bounds = this.targetBoundsCommon;
+        }
+        else {
+            const oldZoom = this.renderViewport?.zoom;
+            shouldRedraw = shouldRedraw || newZoom !== oldZoom;
+            const newBounds = getRenderBounds(this.targetBoundsCommon, viewport);
+            const oldBounds = this.bounds;
+            shouldRedraw = shouldRedraw || !oldBounds || newBounds.some((x, i) => x !== oldBounds[i]);
+            this.bounds = newBounds;
+        }
+        if (shouldRedraw) {
+            this.renderViewport = makeViewport({
+                bounds: this.bounds,
+                zoom: newZoom,
+                viewport
+            });
+        }
+        return shouldRedraw;
+    }
+    getRenderFramebuffer() {
+        if (!this.renderViewport || this.layers.length === 0) {
+            return null;
+        }
+        if (!this.fbo) {
+            this.fbo = createRenderTarget(this.targetLayer.context.device, { id: this.id });
+        }
+        return this.fbo;
+    }
+    getPickingFramebuffer() {
+        if (!this.renderViewport || (this.layers.length === 0 && !this.targetLayer.props.pickable)) {
+            return null;
+        }
+        if (!this.pickingFbo) {
+            this.pickingFbo = createRenderTarget(this.targetLayer.context.device, {
+                id: `${this.id}-picking`
+            });
+        }
+        return this.pickingFbo;
+    }
+    filterLayers(layers) {
+        return layers.filter(({ id }) => this.layers.includes(id));
+    }
+    delete() {
+        const { fbo, pickingFbo } = this;
+        if (fbo) {
+            fbo.colorAttachments[0].destroy();
+            fbo.destroy();
+        }
+        if (pickingFbo) {
+            pickingFbo.colorAttachments[0].destroy();
+            pickingFbo.destroy();
+        }
+    }
+}
+/**
+ * Remove layers that do not overlap with the current terrain cover.
+ * This implementation only has effect when a TileLayer is overlaid on top of a TileLayer
+ */
+function getIntersectingLayers(sourceTile, layers) {
+    return layers.filter(layer => {
+        const tile = getTile(layer);
+        if (tile) {
+            return intersect(sourceTile.boundingBox, tile.boundingBox);
+        }
+        return true;
+    });
+}
+/** If layer is the descendent of a TileLayer, return the corresponding tile. */
+function getTile(layer) {
+    while (layer) {
+        // @ts-expect-error tile may not exist
+        const { tile } = layer.props;
+        if (tile) {
+            return tile;
+        }
+        layer = layer.parent;
+    }
+    return null;
+}
+function intersect(b1, b2) {
+    if (b1 && b2) {
+        return b1[0][0] < b2[1][0] && b2[0][0] < b1[1][0] && b1[0][1] < b2[1][1] && b2[0][1] < b1[1][1];
+    }
+    return false;
+}

package/{typed → dist}/terrain/terrain-effect.d.ts

@@ -1,5 +1,5 @@
 import { Device } from '@luma.gl/core';
-import { TerrainModuleSettings } from './shader-module';
+import { TerrainModuleSettings } from "./shader-module.js";
 import type { Effect, PreRenderOptions, Layer } from '@deck.gl/core';
 /** Class to manage terrain effect */
 export declare class TerrainEffect implements Effect {
@@ -20,7 +20,7 @@ export declare class TerrainEffect implements Effect {
     private terrainCovers;
     initialize(device: Device): void;
     preRender(device: Device, opts: PreRenderOptions): void;
-    getModuleParameters(layer: Layer): TerrainModuleSettings;
+    getModuleParameters(layer: Layer): Omit<TerrainModuleSettings, 'picking'>;
     cleanup(): void;
     private _updateHeightMap;
     private _updateTerrainCovers;

package/dist/terrain/terrain-effect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"terrain-effect.d.ts","sourceRoot":"","sources":["../../src/terrain/terrain-effect.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,MAAM,EAAU,MAAM,eAAe,CAAC;AAG9C,OAAO,EAAgB,qBAAqB,EAAC,2BAAwB;AAMrE,OAAO,KAAK,EAAC,MAAM,EAAE,gBAAgB,EAAE,KAAK,EAAW,MAAM,eAAe,CAAC;AAE7E,qCAAqC;AACrC,qBAAa,aAAc,YAAW,MAAM;IAC1C,EAAE,SAAoB;IACtB,KAAK,OAAQ;IACb,YAAY,UAAQ;IAEpB,0CAA0C;IAC1C,OAAO,CAAC,SAAS,CAAkB;IACnC,6CAA6C;IAC7C,OAAO,CAAC,gBAAgB,CAAkB;IAC1C,sCAAsC;IACtC,OAAO,CAAC,cAAc,CAAC,CAAU;IACjC,wGAAwG;IACxG,OAAO,CAAC,SAAS,CAAC,CAAmB;IACrC,OAAO,CAAC,WAAW,CAAe;IAClC,OAAO,CAAC,kBAAkB,CAAsB;IAChD,wFAAwF;IACxF,OAAO,CAAC,aAAa,CAAwC;IAE7D,UAAU,CAAC,MAAM,EAAE,MAAM;IAkBzB,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,gBAAgB,GAAG,IAAI;IA+CvD,mBAAmB,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC,qBAAqB,EAAE,SAAS,CAAC;IAazE,OAAO,IAAI,IAAI;IAmBf,OAAO,CAAC,gBAAgB;IAuBxB,OAAO,CAAC,oBAAoB;IA2B5B,OAAO,CAAC,mBAAmB;IAwC3B,OAAO,CAAC,mBAAmB;CAY5B"}

package/dist/terrain/terrain-effect.js

@@ -0,0 +1,184 @@
+import { log, getShaderAssembler } from '@deck.gl/core';
+import { terrainModule } from "./shader-module.js";
+import { TerrainCover } from "./terrain-cover.js";
+import { TerrainPass } from "./terrain-pass.js";
+import { TerrainPickingPass } from "./terrain-picking-pass.js";
+import { HeightMapBuilder } from "./height-map-builder.js";
+/** Class to manage terrain effect */
+export class TerrainEffect {
+    constructor() {
+        this.id = 'terrain-effect';
+        this.props = null;
+        this.useInPicking = true;
+        /** true if picking in the current pass */
+        this.isPicking = false;
+        /** true if should use in the current pass */
+        this.isDrapingEnabled = false;
+        /** One texture for each primitive terrain layer, into which the draped layers render */
+        this.terrainCovers = new Map();
+    }
+    initialize(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, opts) {
+        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);
+        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) {
+        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() {
+        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);
+    }
+    _updateHeightMap(terrainLayers, viewport, opts) {
+        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
+            }
+        });
+    }
+    _updateTerrainCovers(terrainLayers, drapeLayers, viewport, opts) {
+        // Mark a terrain cover as dirty if one of the drape layers needs redraw
+        const layerNeedsRedraw = {};
+        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();
+        }
+    }
+    _updateTerrainCover(terrainLayer, drapeLayers, viewport, opts) {
+        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, `Error rendering terrain cover ${terrainCover.id}`);
+        }
+    }
+    _pruneTerrainCovers() {
+        /** Prune the cache, remove textures for layers that have been removed */
+        const idsToRemove = [];
+        for (const [id, terrainCover] of this.terrainCovers) {
+            if (!terrainCover.isActive) {
+                idsToRemove.push(id);
+            }
+        }
+        for (const id of idsToRemove) {
+            this.terrainCovers.delete(id);
+        }
+    }
+}