@deck.gl/extensions 8.8.23 → 8.8.24

package/typed/mask/mask.js

@@ -0,0 +1,48 @@
+import { COORDINATE_SYSTEM, LayerExtension, log } from '@deck.gl/core';
+import mask from './shader-module';
+const defaultProps = {
+    maskId: ''
+};
+export default class MaskExtension extends LayerExtension {
+    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 ('maskByInstance' in this.props) {
+            maskByInstance = this.props.maskByInstance;
+        }
+        this.state.maskByInstance = maskByInstance;
+        return {
+            modules: [mask]
+        };
+    }
+    draw({ uniforms, context, moduleParameters }) {
+        uniforms.mask_maskByInstance = this.state.maskByInstance;
+        const { maskId } = 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;
+            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;
+        }
+    }
+}
+MaskExtension.extensionName = 'MaskExtension';
+MaskExtension.defaultProps = defaultProps;

package/typed/mask/shader-module.js

@@ -0,0 +1,73 @@
+import { project } from '@deck.gl/core';
+const vs = `
+uniform vec4 mask_bounds;
+uniform bool mask_maskByInstance;
+vec2 mask_getCoords(vec4 position) {
+  return (position.xy - mask_bounds.xy) / (mask_bounds.zw - mask_bounds.xy);
+}
+`;
+const fs = `
+uniform sampler2D mask_texture;
+uniform int mask_channel;
+uniform bool mask_enabled;
+bool mask_isInBounds(vec2 texCoords) {
+  if (!mask_enabled) {
+    return true;
+  }
+  vec4 maskColor = texture2D(mask_texture, texCoords);
+  float maskValue = 1.0;
+  if (mask_channel == 0) {
+    maskValue = maskColor.r;
+  } else if (mask_channel == 1) {
+    maskValue = maskColor.g;
+  } else if (mask_channel == 2) {
+    maskValue = maskColor.b;
+  } else if (mask_channel == 3) {
+    maskValue = maskColor.a;
+  }
+  return maskValue < 0.5;
+}
+`;
+const inject = {
+    'vs:#decl': `
+varying vec2 mask_texCoords;
+`,
+    'vs:#main-end': `
+   vec4 mask_common_position;
+   if (mask_maskByInstance) {
+     mask_common_position = project_position(vec4(geometry.worldPosition, 1.0));
+   } else {
+     mask_common_position = geometry.position;
+   }
+   mask_texCoords = mask_getCoords(mask_common_position);
+`,
+    'fs:#decl': `
+varying vec2 mask_texCoords;
+`,
+    'fs:#main-start': `
+  if (mask_enabled) {
+    bool mask = mask_isInBounds(mask_texCoords);
+
+    // Debug: show extent of render target
+    // gl_FragColor = vec4(mask_texCoords, 0.0, 1.0);
+    gl_FragColor = texture2D(mask_texture, mask_texCoords);
+
+    if (!mask) discard;
+  }
+`
+};
+const getMaskUniforms = (opts = {}) => {
+    const uniforms = {};
+    if (opts.maskMap) {
+        uniforms.mask_texture = opts.maskMap;
+    }
+    return uniforms;
+};
+export default {
+    name: 'mask',
+    dependencies: [project],
+    vs,
+    fs,
+    inject,
+    getUniforms: getMaskUniforms
+};

package/typed/path-style/path-style.js

@@ -0,0 +1,107 @@
+// 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 { dashShaders, offsetShaders } from './shaders.glsl';
+import { dist } from 'gl-matrix/vec3';
+const defaultProps = {
+    getDashArray: { type: 'accessor', value: [0, 0] },
+    getOffset: { type: 'accessor', value: 0 },
+    dashJustified: false,
+    dashGapPickable: false
+};
+export default class PathStyleExtension extends LayerExtension {
+    constructor({ dash = false, offset = false, highPrecisionDash = false } = {}) {
+        super({ dash: dash || highPrecisionDash, offset, highPrecisionDash });
+    }
+    isEnabled(layer) {
+        return layer.state.pathTesselator;
+    }
+    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;
+        }
+        extension.enabled = true;
+        if (extension.opts.dash) {
+            attributeManager.addInstanced({
+                instanceDashArrays: { size: 2, accessor: 'getDashArray' }
+            });
+        }
+        if (extension.opts.highPrecisionDash) {
+            attributeManager.addInstanced({
+                instanceDashOffsets: {
+                    size: 1,
+                    accessor: 'getPath',
+                    transform: extension.getDashOffsets.bind(this)
+                }
+            });
+        }
+        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] + dist(prevP, p);
+            }
+            prevP = p;
+        }
+        return result;
+    }
+}
+PathStyleExtension.extensionName = 'PathStyleExtension';
+PathStyleExtension.defaultProps = defaultProps;

package/typed/path-style/shaders.glsl.js

@@ -0,0 +1,93 @@
+export const dashShaders = {
+    inject: {
+        'vs:#decl': `
+attribute vec2 instanceDashArrays;
+attribute float instanceDashOffsets;
+varying vec2 vDashArray;
+varying float vDashOffset;
+`,
+        'vs:#main-end': `
+vDashArray = instanceDashArrays;
+vDashOffset = instanceDashOffsets / width.x;
+`,
+        'fs:#decl': `
+uniform float dashAlignMode;
+uniform float capType;
+uniform bool dashGapPickable;
+varying vec2 vDashArray;
+varying float vDashOffset;
+
+float round(float x) {
+  return floor(x + 0.5);
+}
+`,
+        // 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;
+
+  float offset;
+
+  if (unitLength > 0.0) {
+    if (dashAlignMode == 0.0) {
+      offset = vDashOffset;
+    } else {
+      unitLength = vPathLength / round(vPathLength / unitLength);
+      offset = solidLength / 2.0;
+    }
+
+    float unitOffset = mod(clamp(vPathPosition.y, 0.0, vPathLength) + offset, unitLength);
+
+    if (gapLength > 0.0 && unitOffset > solidLength) {
+      if (capType <= 0.5) {
+        if (!(dashGapPickable && picking_uActive)) {
+          discard;
+        }
+      } else {
+        // caps are rounded, test the distance to solid ends
+        float distToEnd = length(vec2(
+          min(unitOffset - solidLength, unitLength - unitOffset),
+          vPathPosition.x
+        ));
+        if (distToEnd > 1.0) {
+          if (!(dashGapPickable && picking_uActive)) {
+            discard;
+          }
+        }
+      }
+    }
+  }
+`
+    }
+};
+export const offsetShaders = {
+    inject: {
+        'vs:#decl': `
+attribute float instanceOffsets;
+`,
+        'vs:DECKGL_FILTER_SIZE': `
+  float offsetWidth = abs(instanceOffsets * 2.0) + 1.0;
+  size *= offsetWidth;
+`,
+        'vCornerOffset = offsetVec;': `
+  float offsetWidth = abs(instanceOffsets * 2.0) + 1.0;
+  vec2 offsetCenter = -instanceOffsets * (isCap ? perp : miterVec * miterSize) * 2.0;
+  vCornerOffset = vCornerOffset * offsetWidth - offsetCenter;
+`,
+        'fs:#main-start': `
+  float isInside;
+  isInside = step(-1.0, vPathPosition.x) * step(vPathPosition.x, 1.0);
+  if (isInside == 0.0) {
+    discard;
+  }
+`
+    }
+};

package/typed/terrain/height-map.d.ts

@@ -0,0 +1,27 @@
+import { Framebuffer } from '@luma.gl/core';
+import { Bounds } from '../common/projection-utils';
+import type { Viewport, Layer } from '@deck.gl/core/typed';
+export declare class HeightMap {
+    /** Viewport used to draw into the texture */
+    renderViewport: Viewport | null;
+    /** Bounds of the height map texture, in cartesian space */
+    bounds: Bounds | null;
+    private fbo?;
+    private gl;
+    /** Last rendered layers */
+    private layers;
+    /** Last layer.getBounds() */
+    private layersBounds;
+    /** The union of layersBounds in cartesian space */
+    private layersBoundsCommon;
+    private lastViewport;
+    static isSupported(gl: WebGLRenderingContext): boolean;
+    constructor(gl: WebGLRenderingContext);
+    getRenderFramebuffer(): Framebuffer | null;
+    shouldUpdate({ layers, viewport }: {
+        layers: Layer[];
+        viewport: Viewport;
+    }): boolean;
+    delete(): void;
+}
+//# sourceMappingURL=height-map.d.ts.map

package/typed/terrain/height-map.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"height-map.d.ts","sourceRoot":"","sources":["../../src/terrain/height-map.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,WAAW,EAAC,MAAM,eAAe,CAAC;AAC1C,OAAO,EAAiD,MAAM,EAAC,MAAM,4BAA4B,CAAC;AAGlG,OAAO,KAAK,EAAC,QAAQ,EAAE,KAAK,EAAC,MAAM,eAAe,CAAC;AAEnD,qBAAa,SAAS;IACpB,6CAA6C;IAC7C,cAAc,EAAE,QAAQ,GAAG,IAAI,CAAQ;IACvC,2DAA2D;IAC3D,MAAM,EAAE,MAAM,GAAG,IAAI,CAAQ;IAE7B,OAAO,CAAC,GAAG,CAAC,CAAc;IAC1B,OAAO,CAAC,EAAE,CAAwB;IAClC,2BAA2B;IAC3B,OAAO,CAAC,MAAM,CAAe;IAC7B,6BAA6B;IAC7B,OAAO,CAAC,YAAY,CAAuC;IAC3D,mDAAmD;IACnD,OAAO,CAAC,kBAAkB,CAAuB;IACjD,OAAO,CAAC,YAAY,CAAyB;IAE7C,MAAM,CAAC,WAAW,CAAC,EAAE,EAAE,qBAAqB,GAAG,OAAO;gBAI1C,EAAE,EAAE,qBAAqB;IAIrC,oBAAoB,IAAI,WAAW,GAAG,IAAI;IAU1C,YAAY,CAAC,EAAC,MAAM,EAAE,QAAQ,EAAC,EAAE;QAAC,MAAM,EAAE,KAAK,EAAE,CAAC;QAAC,QAAQ,EAAE,QAAQ,CAAA;KAAC,GAAG,OAAO;IAoDhF,MAAM;CAMP"}

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

@@ -1,4 +1,4 @@
 import type { _ShaderModule as ShaderModule } from '@deck.gl/core/typed';
 declare const _default: ShaderModule<any>;
 export default _default;
-//# sourceMappingURL=shader-module.d.ts.map
+//# sourceMappingURL=shader-module-offset.d.ts.map

package/typed/terrain/shader-module-offset.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shader-module-offset.d.ts","sourceRoot":"","sources":["../../src/terrain/shader-module-offset.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,aAAa,IAAI,YAAY,EAAC,MAAM,eAAe,CAAC;;AAEjE,wBAyBkB"}

package/typed/terrain/shader-module-source.d.ts

@@ -0,0 +1,4 @@
+import type { _ShaderModule as ShaderModule } from '@deck.gl/core/typed';
+declare const _default: ShaderModule<any>;
+export default _default;
+//# sourceMappingURL=shader-module-source.d.ts.map

package/typed/terrain/shader-module-source.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shader-module-source.d.ts","sourceRoot":"","sources":["../../src/terrain/shader-module-source.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,aAAa,IAAI,YAAY,EAAC,MAAM,eAAe,CAAC;;AAEjE,wBAiCkB"}

package/typed/terrain/shader-module.d.ts

@@ -0,0 +1,31 @@
+import type { _ShaderModule as ShaderModule } from '@deck.gl/core/typed';
+import type { Texture2D } from '@luma.gl/core';
+import type { Bounds } from '../common/projection-utils';
+import type { TerrainCover } from './terrain-cover';
+/** Module parameters expected by the terrain shader module */
+export declare type TerrainModuleSettings = {
+    pickingActive?: boolean;
+    heightMap: Texture2D | null;
+    heightMapBounds?: Bounds | null;
+    dummyHeightMap: Texture2D;
+    terrainCover?: TerrainCover | null;
+    drawToTerrainHeightMap?: boolean;
+    useTerrainHeightMap?: boolean;
+    terrainSkipRender?: boolean;
+};
+/** A model can have one of the following modes */
+export declare const TERRAIN_MODE: {
+    NONE: number;
+    /** A terrain layer rendering encoded ground elevation into the height map */
+    WRITE_HEIGHT_MAP: number;
+    /** An offset layer reading encoded ground elevation from the height map */
+    USE_HEIGHT_MAP: number;
+    /** A terrain layer rendering to screen, using the cover fbo overlaid with its own texture */
+    USE_COVER: number;
+    /** A terrain layer rendering to screen, using the cover fbo as texture */
+    USE_COVER_ONLY: number;
+    /** Draped layer is rendered into a texture, and never to screen */
+    SKIP: number;
+};
+export declare const terrainModule: ShaderModule<TerrainModuleSettings>;
+//# sourceMappingURL=shader-module.d.ts.map

package/typed/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":"AACA,OAAO,KAAK,EAAC,aAAa,IAAI,YAAY,EAAC,MAAM,eAAe,CAAC;AAEjE,OAAO,KAAK,EAAC,SAAS,EAAC,MAAM,eAAe,CAAC;AAC7C,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,4BAA4B,CAAC;AACvD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAEpD,8DAA8D;AAC9D,oBAAY,qBAAqB,GAAG;IAClC,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,SAAS,EAAE,SAAS,GAAG,IAAI,CAAC;IAC5B,eAAe,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAChC,cAAc,EAAE,SAAS,CAAC;IAC1B,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;AAMF,eAAO,MAAM,aAAa,qCA0Hc,CAAC"}

package/typed/terrain/terrain-cover.d.ts

@@ -0,0 +1,40 @@
+import { Framebuffer } from '@luma.gl/core';
+import type { Layer, Viewport } from '@deck.gl/core/typed';
+import { Bounds } from '../common/projection-utils';
+/** Class to manage draped texture for each terrain layer */
+export declare class TerrainCover {
+    isDirty: boolean;
+    /** The terrain layer that this instance belongs to */
+    targetLayer: Layer;
+    /** Viewport used to draw into the texture */
+    renderViewport: Viewport | null;
+    /** Bounds of the terrain cover texture, in cartesian space */
+    bounds: Bounds | null;
+    private fbo?;
+    private pickingFbo?;
+    private layers;
+    private tile;
+    /** Cached version of targetLayer.getBounds() */
+    private targetBounds;
+    /** targetBounds in cartesian space */
+    private targetBoundsCommon;
+    constructor(targetLayer: Layer);
+    get id(): string;
+    /** returns true if the target layer is still in use (i.e. not finalized) */
+    get isActive(): boolean;
+    shouldUpdate({ targetLayer, viewport, layers, layerNeedsRedraw }: {
+        targetLayer?: Layer;
+        viewport?: Viewport;
+        layers?: Layer[];
+        layerNeedsRedraw?: Record<string, boolean>;
+    }): boolean;
+    /** Compare layers with the last version. Only rerender if necessary. */
+    private _updateLayers;
+    /** Compare viewport and terrain bounds with the last version. Only rerender if necesary. */
+    private _updateViewport;
+    getRenderFramebuffer(): Framebuffer | null;
+    getPickingFramebuffer(): Framebuffer | null;
+    filterLayers(layers: Layer[]): Layer<{}>[];
+    delete(): void;
+}
+//# sourceMappingURL=terrain-cover.d.ts.map

package/typed/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,MAAM,4BAA4B,CAAC;AASlG,4DAA4D;AAC5D,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,CAAsB;IAClC,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;IAwCvB,oBAAoB,IAAI,WAAW,GAAG,IAAI;IAU1C,qBAAqB,IAAI,WAAW,GAAG,IAAI;IAU3C,YAAY,CAAC,MAAM,EAAE,KAAK,EAAE;IAI5B,MAAM;CAWP"}

package/typed/terrain/terrain-effect.d.ts

@@ -0,0 +1,29 @@
+import { TerrainModuleSettings } from './shader-module';
+import type { Effect, PreRenderOptions, Layer } from '@deck.gl/core/typed';
+/** Class to manage terrain effect */
+export declare class TerrainEffect implements Effect {
+    id: string;
+    props: null;
+    useInPicking: boolean;
+    /** true if picking in the current pass */
+    private isPicking;
+    /** true if should use in the current pass */
+    private isDrapingEnabled;
+    /** An empty texture as placeholder */
+    private dummyHeightMap;
+    /** A texture encoding the ground elevation, updated once per redraw. Used by layers with offset mode */
+    private heightMap?;
+    private terrainPass;
+    private terrainPickingPass;
+    /** One texture for each primitive terrain layer, into which the draped layers render */
+    private terrainCovers;
+    initialize(gl: WebGLRenderingContext): void;
+    preRender(gl: WebGLRenderingContext, opts: PreRenderOptions): void;
+    getModuleParameters(layer: Layer): TerrainModuleSettings;
+    cleanup(): void;
+    private _updateHeightMap;
+    private _updateTerrainCovers;
+    private _updateTerrainCover;
+    private _pruneTerrainCovers;
+}
+//# sourceMappingURL=terrain-effect.d.ts.map

package/typed/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":"AAGA,OAAO,EAAgB,qBAAqB,EAAC,MAAM,iBAAiB,CAAC;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,CAAY;IAClC,wGAAwG;IACxG,OAAO,CAAC,SAAS,CAAC,CAAY;IAC9B,OAAO,CAAC,WAAW,CAAe;IAClC,OAAO,CAAC,kBAAkB,CAAsB;IAChD,wFAAwF;IACxF,OAAO,CAAC,aAAa,CAAwC;IAE7D,UAAU,CAAC,EAAE,EAAE,qBAAqB;IAkBpC,SAAS,CAAC,EAAE,EAAE,qBAAqB,EAAE,IAAI,EAAE,gBAAgB,GAAG,IAAI;IA+ClE,mBAAmB,CAAC,KAAK,EAAE,KAAK,GAAG,qBAAqB;IAaxD,OAAO,IAAI,IAAI;IAiBf,OAAO,CAAC,gBAAgB;IAuBxB,OAAO,CAAC,oBAAoB;IA2B5B,OAAO,CAAC,mBAAmB;IAmC3B,OAAO,CAAC,mBAAmB;CAY5B"}

package/typed/terrain/terrain-pass.d.ts

@@ -0,0 +1,11 @@
+import { Layer, Viewport, _LayersPass as LayersPass, LayersPassRenderOptions } from '@deck.gl/core/typed';
+import { HeightMap } from './height-map';
+import type { TerrainCover } from './terrain-cover';
+export declare type TerrainPassRenderOptions = LayersPassRenderOptions;
+/** Renders textures used by the TerrainEffect render pass */
+export declare class TerrainPass extends LayersPass {
+    getRenderableLayers(viewport: Viewport, opts: TerrainPassRenderOptions): Layer[];
+    renderHeightMap(heightMap: HeightMap, opts: Partial<TerrainPassRenderOptions>): void;
+    renderTerrainCover(terrainCover: TerrainCover, opts: Partial<TerrainPassRenderOptions>): void;
+}
+//# sourceMappingURL=terrain-pass.d.ts.map

package/typed/terrain/terrain-pass.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"terrain-pass.d.ts","sourceRoot":"","sources":["../../src/terrain/terrain-pass.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,KAAK,EAAE,QAAQ,EAAE,WAAW,IAAI,UAAU,EAAE,uBAAuB,EAAC,MAAM,eAAe,CAAC;AAClG,OAAO,EAAC,SAAS,EAAC,MAAM,cAAc,CAAC;AACvC,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,iBAAiB,CAAC;AAIlD,oBAAY,wBAAwB,GAAG,uBAAuB,CAAC;AAE/D,6DAA6D;AAC7D,qBAAa,WAAY,SAAQ,UAAU;IACzC,mBAAmB,CAAC,QAAQ,EAAE,QAAQ,EAAE,IAAI,EAAE,wBAAwB,GAAG,KAAK,EAAE;IAchF,eAAe,CAAC,SAAS,EAAE,SAAS,EAAE,IAAI,EAAE,OAAO,CAAC,wBAAwB,CAAC;IAgC7E,kBAAkB,CAAC,YAAY,EAAE,YAAY,EAAE,IAAI,EAAE,OAAO,CAAC,wBAAwB,CAAC;CA4BvF"}

package/typed/terrain/terrain-picking-pass.d.ts

@@ -0,0 +1,19 @@
+import { Layer, Viewport, LayersPassRenderOptions, _PickLayersPass as PickLayersPass } from '@deck.gl/core/typed';
+import type { TerrainCover } from './terrain-cover';
+export declare type TerrainPickingPassRenderOptions = LayersPassRenderOptions & {
+    pickZ: boolean;
+};
+/** Renders textures used by the TerrainEffect picking pass */
+export declare class TerrainPickingPass extends PickLayersPass {
+    /** Save layer index for use when drawing to terrain cover.
+     * When a terrain cover's picking buffer is rendered,
+     * we need to make sure each layer receives a consistent index (encoded in the alpha channel)
+     * so that a picked color can be decoded back to the correct layer.
+     * Updated in getRenderableLayers which is called in TerrainEffect.preRender
+     */
+    drawIndices: Record<string, number>;
+    getRenderableLayers(viewport: Viewport, opts: TerrainPickingPassRenderOptions): Layer[];
+    renderTerrainCover(terrainCover: TerrainCover, opts: Partial<TerrainPickingPassRenderOptions>): void;
+    protected getLayerParameters(layer: Layer, layerIndex: number, viewport: Viewport): any;
+}
+//# sourceMappingURL=terrain-picking-pass.d.ts.map

package/typed/terrain/terrain-picking-pass.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"terrain-picking-pass.d.ts","sourceRoot":"","sources":["../../src/terrain/terrain-picking-pass.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,EACL,QAAQ,EACR,uBAAuB,EACvB,eAAe,IAAI,cAAc,EAClC,MAAM,eAAe,CAAC;AAEvB,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,iBAAiB,CAAC;AAElD,oBAAY,+BAA+B,GAAG,uBAAuB,GAAG;IACtE,KAAK,EAAE,OAAO,CAAC;CAChB,CAAC;AAEF,8DAA8D;AAC9D,qBAAa,kBAAmB,SAAQ,cAAc;IACpD;;;;;OAKG;IACH,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAM;IAEzC,mBAAmB,CAAC,QAAQ,EAAE,QAAQ,EAAE,IAAI,EAAE,+BAA+B,GAAG,KAAK,EAAE;IAiBvF,kBAAkB,CAAC,YAAY,EAAE,YAAY,EAAE,IAAI,EAAE,OAAO,CAAC,+BAA+B,CAAC;IAsC7F,SAAS,CAAC,kBAAkB,CAAC,KAAK,EAAE,KAAK,EAAE,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,QAAQ,GAAG,GAAG;CAQxF"}

package/typed/terrain/terrain.d.ts

@@ -0,0 +1,21 @@
+import { LayerExtension, UpdateParameters } from '@deck.gl/core/typed';
+import type { Layer } from '@deck.gl/core/typed';
+export declare type TerrainExtensionProps = {
+    /**
+     * controls whether an object is drawn over the terrain surface by its anchor (usually defined by an accessor called `getPosition`, e.g. icon, scatterplot) or by its geometry (e.g. path, polygon).
+     * If not specified, it is automatically deduced from the layer.
+     */
+    terrainFittingMode?: 'offset' | 'drape';
+};
+/** Allows layers to show/hide objects by a geofence. */
+export default class TerrainExtension extends LayerExtension {
+    static defaultProps: {
+        terrainFittingMode: undefined;
+    };
+    static extensionName: string;
+    getShaders(this: Layer<TerrainExtensionProps>): any;
+    initializeState(this: Layer<TerrainExtensionProps>): void;
+    updateState(this: Layer<TerrainExtensionProps>, params: UpdateParameters<Layer<TerrainExtensionProps>>): void;
+    onNeedsRedraw(this: Layer<{}>): void;
+}
+//# sourceMappingURL=terrain.d.ts.map

package/typed/terrain/terrain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"terrain.d.ts","sourceRoot":"","sources":["../../src/terrain/terrain.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,cAAc,EAAE,gBAAgB,EAAC,MAAM,eAAe,CAAC;AAI/D,OAAO,KAAK,EAAC,KAAK,EAAC,MAAM,eAAe,CAAC;AAMzC,oBAAY,qBAAqB,GAAG;IAClC;;;OAGG;IACH,kBAAkB,CAAC,EAAE,QAAQ,GAAG,OAAO,CAAC;CACzC,CAAC;AASF,wDAAwD;AACxD,MAAM,CAAC,OAAO,OAAO,gBAAiB,SAAQ,cAAc;IAC1D,MAAM,CAAC,YAAY;;MAAgB;IACnC,MAAM,CAAC,aAAa,SAAsB;IAE1C,UAAU,CAAC,IAAI,EAAE,KAAK,CAAC,qBAAqB,CAAC,GAAG,GAAG;IAMnD,eAAe,CAAC,IAAI,EAAE,KAAK,CAAC,qBAAqB,CAAC;IAIlD,WAAW,CACT,IAAI,EAAE,KAAK,CAAC,qBAAqB,CAAC,EAClC,MAAM,EAAE,gBAAgB,CAAC,KAAK,CAAC,qBAAqB,CAAC,CAAC;IAyBxD,aAAa,CAAC,IAAI,EAAE,KAAK,CAAC,EAAE,CAAC,GAAG,IAAI;CAMrC"}

package/typed/terrain/utils.d.ts

@@ -0,0 +1,5 @@
+export declare function createRenderTarget(gl: WebGLRenderingContext, opts: {
+    id: string;
+    float?: boolean;
+}): any;
+//# sourceMappingURL=utils.d.ts.map

package/typed/terrain/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/terrain/utils.ts"],"names":[],"mappings":"AAGA,wBAAgB,kBAAkB,CAChC,EAAE,EAAE,qBAAqB,EACzB,IAAI,EAAE;IACJ,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB,OAoBF"}

package/typed/collide/collide-effect.d.ts

@@ -1,30 +0,0 @@
-import { Texture2D } from '@luma.gl/core';
-import type { Effect, PreRenderOptions } from '@deck.gl/core/typed';
-declare global {
-    interface Window {
-        debug: any;
-    }
-}
-export default class CollideEffect implements Effect {
-    id: string;
-    props: null;
-    useInPicking: boolean;
-    private channels;
-    private collidePasses;
-    private dummyCollideMap?;
-    private lastViewport?;
-    preRender(gl: WebGLRenderingContext, { effects: allEffects, layers, layerFilter, viewports, onViewportActive, views }: PreRenderOptions): void;
-    private _render;
-    /**
-     * Group layers by collideGroup
-     * Returns a map from collideGroup to render info
-     */
-    private _groupByCollideGroup;
-    getModuleParameters(): {
-        collideMaps: Record<string, Texture2D>;
-        dummyCollideMap: Texture2D;
-    };
-    cleanup(): void;
-    _debug(collidePass: any): void;
-}
-//# sourceMappingURL=collide-effect.d.ts.map

package/typed/collide/collide-effect.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"collide-effect.d.ts","sourceRoot":"","sources":["../../src/collide/collide-effect.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,SAAS,EAAmB,MAAM,eAAe,CAAC;AAE1D,OAAO,KAAK,EAAC,MAAM,EAAS,gBAAgB,EAAW,MAAM,eAAe,CAAC;AAG7E,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,MAAM;QACd,KAAK,EAAE,GAAG,CAAC;KACZ;CACF;AAiBD,MAAM,CAAC,OAAO,OAAO,aAAc,YAAW,MAAM;IAClD,EAAE,SAAoB;IACtB,KAAK,OAAQ;IACb,YAAY,UAAQ;IAEpB,OAAO,CAAC,QAAQ,CAAkC;IAClD,OAAO,CAAC,aAAa,CAAmC;IACxD,OAAO,CAAC,eAAe,CAAC,CAAY;IACpC,OAAO,CAAC,YAAY,CAAC,CAAW;IAEhC,SAAS,CACP,EAAE,EAAE,qBAAqB,EACzB,EAAC,OAAO,EAAE,UAAU,EAAE,MAAM,EAAE,WAAW,EAAE,SAAS,EAAE,gBAAgB,EAAE,KAAK,EAAC,EAAE,gBAAgB,GAC/F,IAAI;IAsDP,OAAO,CAAC,OAAO;IAsDf;;;OAGG;IACH,OAAO,CAAC,oBAAoB;IAwC5B,mBAAmB,IAAI;QAAC,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;QAAC,eAAe,EAAE,SAAS,CAAA;KAAC;IAQ3F,OAAO,IAAI,IAAI;IAcf,MAAM,CAAC,WAAW,KAAA;CAoDnB"}

package/typed/collide/collide-pass.d.ts

@@ -1,25 +0,0 @@
-import { Framebuffer, Renderbuffer, Texture2D } from '@luma.gl/core';
-import { _LayersPass as LayersPass, LayersPassRenderOptions } from '@deck.gl/core/typed';
-declare type CollidePassRenderOptions = LayersPassRenderOptions & {};
-export default class CollidePass extends LayersPass {
-    collideMap: Texture2D;
-    depthBuffer: Renderbuffer;
-    dummyCollideMap: Texture2D;
-    fbo: Framebuffer;
-    constructor(gl: any, props: {
-        id: string;
-        dummyCollideMap: Texture2D;
-    });
-    render(options: CollidePassRenderOptions): any;
-    shouldDrawLayer(layer: any): boolean;
-    getModuleParameters(): {
-        drawToCollideMap: boolean;
-        dummyCollideMap: Texture2D;
-        pickingActive: number;
-        pickingAttribute: boolean;
-        lightSources: {};
-    };
-    delete(): void;
-}
-export {};
-//# sourceMappingURL=collide-pass.d.ts.map

package/typed/collide/collide-pass.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"collide-pass.d.ts","sourceRoot":"","sources":["../../src/collide/collide-pass.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,WAAW,EAAE,YAAY,EAAE,SAAS,EAAiB,MAAM,eAAe,CAAC;AACnF,OAAO,EAAY,WAAW,IAAI,UAAU,EAAE,uBAAuB,EAAC,MAAM,eAAe,CAAC;AAE5F,aAAK,wBAAwB,GAAG,uBAAuB,GAAG,EAAE,CAAC;AAE7D,MAAM,CAAC,OAAO,OAAO,WAAY,SAAQ,UAAU;IACjD,UAAU,EAAE,SAAS,CAAC;IACtB,WAAW,EAAE,YAAY,CAAC;IAC1B,eAAe,EAAE,SAAS,CAAC;IAC3B,GAAG,EAAE,WAAW,CAAC;gBAEL,EAAE,KAAA,EAAE,KAAK,EAAE;QAAC,EAAE,EAAE,MAAM,CAAC;QAAC,eAAe,EAAE,SAAS,CAAA;KAAC;IA8B/D,MAAM,CAAC,OAAO,EAAE,wBAAwB;IAqBxC,eAAe,CAAC,KAAK,KAAA;IAMrB,mBAAmB;;;;;;;IAYnB,MAAM;CAQP"}