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

package/dist/mask/mask-extension.js

@@ -0,0 +1,57 @@
+import { COORDINATE_SYSTEM, LayerExtension, log } from '@deck.gl/core';
+import mask from "./shader-module.js";
+import MaskEffect from "./mask-effect.js";
+const defaultProps = {
+    maskId: '',
+    maskByInstance: undefined,
+    maskInverted: false
+};
+/** Allows layers to show/hide objects by a geofence. */
+export default class MaskExtension extends LayerExtension {
+    static { this.defaultProps = defaultProps; }
+    static { this.extensionName = 'MaskExtension'; }
+    initializeState() {
+        this.context.deck?._addDefaultEffect(new MaskEffect());
+    }
+    getShaders() {
+        // Infer by geometry if 'maskByInstance' prop isn't explictly set
+        let maskByInstance = 'instancePositions' in this.getAttributeManager().attributes;
+        // Users can override by setting the `maskByInstance` prop
+        if (this.props.maskByInstance !== undefined) {
+            maskByInstance = Boolean(this.props.maskByInstance);
+        }
+        this.state.maskByInstance = maskByInstance;
+        return {
+            modules: [mask]
+        };
+    }
+    /* eslint-disable camelcase */
+    draw({ uniforms, context, moduleParameters }) {
+        uniforms.mask_maskByInstance = this.state.maskByInstance;
+        const { maskId, maskInverted } = this.props;
+        const { maskChannels } = moduleParameters;
+        const { viewport } = context;
+        if (maskChannels && maskChannels[maskId]) {
+            const { index, bounds, coordinateOrigin: fromCoordinateOrigin } = maskChannels[maskId];
+            let { coordinateSystem: fromCoordinateSystem } = maskChannels[maskId];
+            uniforms.mask_enabled = true;
+            uniforms.mask_channel = index;
+            uniforms.mask_inverted = maskInverted;
+            if (fromCoordinateSystem === COORDINATE_SYSTEM.DEFAULT) {
+                fromCoordinateSystem = viewport.isGeospatial
+                    ? COORDINATE_SYSTEM.LNGLAT
+                    : COORDINATE_SYSTEM.CARTESIAN;
+            }
+            const opts = { modelMatrix: null, fromCoordinateOrigin, fromCoordinateSystem };
+            const bl = this.projectPosition([bounds[0], bounds[1], 0], opts);
+            const tr = this.projectPosition([bounds[2], bounds[3], 0], opts);
+            uniforms.mask_bounds = [bl[0], bl[1], tr[0], tr[1]];
+        }
+        else {
+            if (maskId) {
+                log.warn(`Could not find a mask layer with id: ${maskId}`)();
+            }
+            uniforms.mask_enabled = false;
+        }
+    }
+}

package/{typed → dist}/mask/mask-pass.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mask-pass.d.ts","sourceRoot":"","sources":["../../src/mask/mask-pass.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,MAAM,EAAE,WAAW,EAAE,OAAO,EAAC,MAAM,eAAe,CAAC;AAGhE,OAAO,EAAC,WAAW,IAAI,UAAU,EAAE,uBAAuB,EAAC,MAAM,eAAe,CAAC;AAEjF,KAAK,qBAAqB,GAAG,uBAAuB,GAAG;IACrD,kEAAkE;IAClE,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,MAAM,CAAC,OAAO,OAAO,QAAS,SAAQ,UAAU;IAC9C,OAAO,EAAE,OAAO,CAAC;IACjB,GAAG,EAAE,WAAW,CAAC;gBAEL,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE;QAAC,EAAE,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAA;KAAC;IAyBjE,MAAM,CAAC,OAAO,EAAE,qBAAqB;IAkBrC,eAAe,CAAC,KAAK,KAAA;IAIrB,MAAM;CAIP"}
+{"version":3,"file":"mask-pass.d.ts","sourceRoot":"","sources":["../../src/mask/mask-pass.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,MAAM,EAAE,WAAW,EAAE,OAAO,EAAC,MAAM,eAAe,CAAC;AAEhE,OAAO,EAAC,WAAW,IAAI,UAAU,EAAE,uBAAuB,EAAC,MAAM,eAAe,CAAC;AAEjF,KAAK,qBAAqB,GAAG,uBAAuB,GAAG;IACrD,kEAAkE;IAClE,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,MAAM,CAAC,OAAO,OAAO,QAAS,SAAQ,UAAU;IAC9C,OAAO,EAAE,OAAO,CAAC;IACjB,GAAG,EAAE,WAAW,CAAC;gBAEL,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE;QAAC,EAAE,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAA;KAAC;IAyBjE,MAAM,CAAC,OAAO,EAAE,qBAAqB;IAiBrC,eAAe,CAAC,KAAK,KAAA;IAIrB,MAAM;CAIP"}

package/dist/mask/mask-pass.js

@@ -0,0 +1,44 @@
+import { GL } from '@luma.gl/constants';
+import { _LayersPass as LayersPass } from '@deck.gl/core';
+export default class MaskPass extends LayersPass {
+    constructor(device, props) {
+        super(device, props);
+        const { mapSize = 2048 } = props;
+        this.maskMap = device.createTexture({
+            format: 'rgba8unorm',
+            width: mapSize,
+            height: mapSize,
+            sampler: {
+                minFilter: 'linear',
+                magFilter: 'linear',
+                addressModeU: 'clamp-to-edge',
+                addressModeV: 'clamp-to-edge'
+            }
+        });
+        this.fbo = device.createFramebuffer({
+            id: 'maskmap',
+            width: mapSize,
+            height: mapSize,
+            colorAttachments: [this.maskMap]
+        });
+    }
+    render(options) {
+        const colorMask = [false, false, false, false];
+        colorMask[options.channel] = true;
+        const clearColor = [255, 255, 255, 255];
+        return this.device.withParametersWebGL({
+            blend: true,
+            blendFunc: [GL.ZERO, GL.ONE],
+            blendEquation: GL.FUNC_SUBTRACT,
+            colorMask,
+            depthTest: false
+        }, () => super.render({ ...options, clearColor, target: this.fbo, pass: 'mask' }));
+    }
+    shouldDrawLayer(layer) {
+        return layer.props.operation.includes('mask');
+    }
+    delete() {
+        this.fbo.delete();
+        this.maskMap.delete();
+    }
+}

package/dist/{esm/mask → mask}/shader-module.js

@@ -35,10 +35,10 @@ bool mask_isInBounds(vec2 texCoords) {
 }
 `;
 const inject = {
-  'vs:#decl': `
+    'vs:#decl': `
 out vec2 mask_texCoords;
 `,
-  'vs:#main-end': `
+    'vs:#main-end': `
    vec4 mask_common_position;
    if (mask_maskByInstance) {
      mask_common_position = project_position(vec4(geometry.worldPosition, 1.0));
@@ -47,10 +47,10 @@ out vec2 mask_texCoords;
    }
    mask_texCoords = mask_getCoords(mask_common_position);
 `,
-  'fs:#decl': `
+    'fs:#decl': `
 in vec2 mask_texCoords;
 `,
-  'fs:#main-start': `
+    'fs:#main-start': `
   if (mask_enabled) {
     bool mask = mask_isInBounds(mask_texCoords);
 
@@ -62,23 +62,20 @@ in vec2 mask_texCoords;
   }
 `
 };
-
-const getMaskUniforms = opts => {
-  if (opts && 'maskMap' in opts) {
-    return {
-      mask_texture: opts.maskMap
-    };
-  }
-
-  return {};
+/* eslint-disable camelcase */
+const getMaskUniforms = (opts) => {
+    if (opts && 'maskMap' in opts) {
+        return {
+            mask_texture: opts.maskMap
+        };
+    }
+    return {};
 };
-
 export default {
-  name: 'mask',
-  dependencies: [project],
-  vs,
-  fs,
-  inject,
-  getUniforms: getMaskUniforms
+    name: 'mask',
+    dependencies: [project],
+    vs,
+    fs,
+    inject,
+    getUniforms: getMaskUniforms
 };
-//# sourceMappingURL=shader-module.js.map

package/dist/path-style/path-style-extension.js

@@ -0,0 +1,111 @@
+// Copyright (c) 2015 - 2017 Uber Technologies, Inc.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+import { LayerExtension, _mergeShaders as mergeShaders } from '@deck.gl/core';
+import { vec3 } from '@math.gl/core';
+import { dashShaders, offsetShaders } from "./shaders.glsl.js";
+const defaultProps = {
+    getDashArray: { type: 'accessor', value: [0, 0] },
+    getOffset: { type: 'accessor', value: 0 },
+    dashJustified: false,
+    dashGapPickable: false
+};
+/** Adds selected features to the `PathLayer` and composite layers that render the `PathLayer`. */
+export default class PathStyleExtension extends LayerExtension {
+    static { this.defaultProps = defaultProps; }
+    static { this.extensionName = 'PathStyleExtension'; }
+    constructor({ dash = false, offset = false, highPrecisionDash = false } = {}) {
+        super({ dash: dash || highPrecisionDash, offset, highPrecisionDash });
+    }
+    isEnabled(layer) {
+        return 'pathTesselator' in layer.state;
+    }
+    getShaders(extension) {
+        if (!extension.isEnabled(this)) {
+            return null;
+        }
+        // Merge shader injection
+        let result = {};
+        if (extension.opts.dash) {
+            result = mergeShaders(result, dashShaders);
+        }
+        if (extension.opts.offset) {
+            result = mergeShaders(result, offsetShaders);
+        }
+        return result;
+    }
+    initializeState(context, extension) {
+        const attributeManager = this.getAttributeManager();
+        if (!attributeManager || !extension.isEnabled(this)) {
+            // This extension only works with the PathLayer
+            return;
+        }
+        if (extension.opts.dash) {
+            attributeManager.addInstanced({
+                instanceDashArrays: { size: 2, accessor: 'getDashArray' },
+                instanceDashOffsets: extension.opts.highPrecisionDash
+                    ? {
+                        size: 1,
+                        accessor: 'getPath',
+                        transform: extension.getDashOffsets.bind(this)
+                    }
+                    : {
+                        size: 1,
+                        update: attribute => {
+                            attribute.constant = true;
+                            attribute.value = [0];
+                        }
+                    }
+            });
+        }
+        if (extension.opts.offset) {
+            attributeManager.addInstanced({
+                instanceOffsets: { size: 1, accessor: 'getOffset' }
+            });
+        }
+    }
+    updateState(params, extension) {
+        if (!extension.isEnabled(this)) {
+            return;
+        }
+        const uniforms = {};
+        if (extension.opts.dash) {
+            uniforms.dashAlignMode = this.props.dashJustified ? 1 : 0;
+            uniforms.dashGapPickable = Boolean(this.props.dashGapPickable);
+        }
+        this.state.model?.setUniforms(uniforms);
+    }
+    getDashOffsets(path) {
+        const result = [0];
+        const positionSize = this.props.positionFormat === 'XY' ? 2 : 3;
+        const isNested = Array.isArray(path[0]);
+        const geometrySize = isNested ? path.length : path.length / positionSize;
+        let p;
+        let prevP;
+        for (let i = 0; i < geometrySize - 1; i++) {
+            p = isNested ? path[i] : path.slice(i * positionSize, i * positionSize + positionSize);
+            p = this.projectPosition(p);
+            if (i > 0) {
+                result[i] = result[i - 1] + vec3.dist(prevP, p);
+            }
+            prevP = p;
+        }
+        return result;
+    }
+}

package/dist/{esm/path-style → path-style}/shaders.glsl.js

@@ -1,23 +1,31 @@
 export const dashShaders = {
-  inject: {
-    'vs:#decl': `
+    inject: {
+        'vs:#decl': `
 in vec2 instanceDashArrays;
 in float instanceDashOffsets;
 out vec2 vDashArray;
 out float vDashOffset;
 `,
-    'vs:#main-end': `
+        'vs:#main-end': `
 vDashArray = instanceDashArrays;
 vDashOffset = instanceDashOffsets / width.x;
 `,
-    'fs:#decl': `
+        'fs:#decl': `
 uniform float dashAlignMode;
 uniform float capType;
 uniform bool dashGapPickable;
 in vec2 vDashArray;
 in float vDashOffset;
 `,
-    'fs:#main-start': `
+        // if given position is in the gap part of the dashed line
+        // dashArray.x: solid stroke length, relative to width
+        // dashArray.y: gap length, relative to width
+        // alignMode:
+        // 0 - no adjustment
+        // o----     ----     ----     ---- o----     -o----     ----     o
+        // 1 - stretch to fit, draw half dash at each end for nicer joints
+        // o--    ----    ----    ----    --o--      --o--     ----     --o
+        'fs:#main-start': `
   float solidLength = vDashArray.x;
   float gapLength = vDashArray.y;
   float unitLength = solidLength + gapLength;
@@ -54,31 +62,30 @@ in float vDashOffset;
     }
   }
 `
-  }
+    }
 };
 export const offsetShaders = {
-  inject: {
-    'vs:#decl': `
+    inject: {
+        'vs:#decl': `
 in float instanceOffsets;
 `,
-    'vs:DECKGL_FILTER_SIZE': `
+        'vs:DECKGL_FILTER_SIZE': `
   float offsetWidth = abs(instanceOffsets * 2.0) + 1.0;
   size *= offsetWidth;
 `,
-    'vs:#main-end': `
+        'vs:#main-end': `
   float offsetWidth = abs(instanceOffsets * 2.0) + 1.0;
   float offsetDir = sign(instanceOffsets);
   vPathPosition.x = (vPathPosition.x + offsetDir) * offsetWidth - offsetDir;
   vPathPosition.y *= offsetWidth;
   vPathLength *= offsetWidth;
 `,
-    'fs:#main-start': `
+        'fs:#main-start': `
   float isInside;
   isInside = step(-1.0, vPathPosition.x) * step(vPathPosition.x, 1.0);
   if (isInside == 0.0) {
     discard;
   }
 `
-  }
+    }
 };
-//# sourceMappingURL=shaders.glsl.js.map

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/dist/terrain/shader-module.js

@@ -0,0 +1,139 @@
+/* eslint-disable camelcase */
+import { project } from '@deck.gl/core';
+/** 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 {
+    // pixel is premultiplied
+    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;
+                // @ts-expect-error
+                sampler = isPicking
+                    ? terrainCover.getPickingFramebuffer()
+                    : terrainCover.getRenderFramebuffer();
+                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;
+    }
+};