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

package/dist/mask/mask-effect.js

@@ -0,0 +1,194 @@
+import { log } from '@deck.gl/core';
+import { equals } from '@math.gl/core';
+import MaskPass from "./mask-pass.js";
+import { joinLayerBounds, getRenderBounds, makeViewport } from "../utils/projection-utils.js";
+// Class to manage mask effect
+export default class MaskEffect {
+    constructor() {
+        this.id = 'mask-effect';
+        this.props = null;
+        this.useInPicking = true;
+        this.order = 0;
+        this.channels = [];
+        this.masks = null;
+    }
+    preRender(device, { layers, layerFilter, viewports, onViewportActive, views, isPicking }) {
+        let didRender = false;
+        if (!this.dummyMaskMap) {
+            this.dummyMaskMap = device.createTexture({
+                width: 1,
+                height: 1
+            });
+        }
+        if (isPicking) {
+            // Do not update on picking pass
+            return { didRender };
+        }
+        const maskLayers = layers.filter(l => l.props.visible && l.props.operation.includes('mask'));
+        if (maskLayers.length === 0) {
+            this.masks = null;
+            this.channels.length = 0;
+            return { didRender };
+        }
+        this.masks = {};
+        if (!this.maskPass) {
+            this.maskPass = new MaskPass(device, { id: 'default-mask' });
+            this.maskMap = this.maskPass.maskMap;
+        }
+        // Map layers to channels
+        const channelMap = this._sortMaskChannels(maskLayers);
+        // TODO - support multiple views
+        const viewport = viewports[0];
+        const viewportChanged = !this.lastViewport || !this.lastViewport.equals(viewport);
+        if (viewport.resolution !== undefined) {
+            log.warn('MaskExtension is not supported in GlobeView')();
+            return { didRender };
+        }
+        for (const maskId in channelMap) {
+            const result = this._renderChannel(channelMap[maskId], {
+                layerFilter,
+                onViewportActive,
+                views,
+                viewport,
+                viewportChanged
+            });
+            didRender ||= result;
+        }
+        // debugFBO(this.maskMap, {opaque: true});
+        return { didRender };
+    }
+    /* eslint-disable-next-line complexity */
+    _renderChannel(channelInfo, { layerFilter, onViewportActive, views, viewport, viewportChanged }) {
+        let didRender = false;
+        const oldChannelInfo = this.channels[channelInfo.index];
+        if (!oldChannelInfo) {
+            return didRender;
+        }
+        const maskChanged = 
+        // If a channel is new
+        channelInfo === oldChannelInfo ||
+            // If sublayers have changed
+            channelInfo.layers.length !== oldChannelInfo.layers.length ||
+            channelInfo.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 mask layer,
+            // for example getRadius+updateTriggers, radiusScale, modelMatrix
+            layer !== oldChannelInfo.layers[i] ||
+                // Some prop is in transition
+                layer.props.transitions) ||
+            // If a sublayer's positions have been updated, the cached bounds will change shallowly
+            channelInfo.layerBounds.some((b, i) => b !== oldChannelInfo.layerBounds[i]);
+        channelInfo.bounds = oldChannelInfo.bounds;
+        channelInfo.maskBounds = oldChannelInfo.maskBounds;
+        this.channels[channelInfo.index] = channelInfo;
+        if (maskChanged || viewportChanged) {
+            // Recalculate mask bounds
+            this.lastViewport = viewport;
+            const layerBounds = joinLayerBounds(channelInfo.layers, viewport);
+            channelInfo.bounds = layerBounds && getRenderBounds(layerBounds, viewport);
+            if (maskChanged || !equals(channelInfo.bounds, oldChannelInfo.bounds)) {
+                // Rerender mask FBO
+                const { maskPass, maskMap } = this;
+                const maskViewport = layerBounds &&
+                    makeViewport({
+                        bounds: channelInfo.bounds,
+                        viewport,
+                        width: maskMap.width,
+                        height: maskMap.height,
+                        border: 1
+                    });
+                channelInfo.maskBounds = maskViewport ? maskViewport.getBounds() : [0, 0, 1, 1];
+                // @ts-ignore (2532) This method is only called from preRender where maskPass is defined
+                maskPass.render({
+                    pass: 'mask',
+                    channel: channelInfo.index,
+                    layers: channelInfo.layers,
+                    layerFilter,
+                    viewports: maskViewport ? [maskViewport] : [],
+                    onViewportActive,
+                    views,
+                    moduleParameters: {
+                        devicePixelRatio: 1
+                    }
+                });
+                didRender = true;
+            }
+        }
+        // @ts-ignore (2532) This method is only called from preRender where masks is defined
+        this.masks[channelInfo.id] = {
+            index: channelInfo.index,
+            bounds: channelInfo.maskBounds,
+            coordinateOrigin: channelInfo.coordinateOrigin,
+            coordinateSystem: channelInfo.coordinateSystem
+        };
+        return didRender;
+    }
+    /**
+     * Find a channel to render each mask into
+     * If a maskId already exists, diff and update the existing channel
+     * Otherwise replace a removed mask
+     * Otherwise create a new channel
+     * Returns a map from mask layer id to channel info
+     */
+    _sortMaskChannels(maskLayers) {
+        const channelMap = {};
+        let channelCount = 0;
+        for (const layer of maskLayers) {
+            const { id } = layer.root;
+            let channelInfo = channelMap[id];
+            if (!channelInfo) {
+                if (++channelCount > 4) {
+                    log.warn('Too many mask layers. The max supported is 4')();
+                    continue; // eslint-disable-line no-continue
+                }
+                channelInfo = {
+                    id,
+                    index: this.channels.findIndex(c => c?.id === id),
+                    layers: [],
+                    layerBounds: [],
+                    coordinateOrigin: layer.root.props.coordinateOrigin,
+                    coordinateSystem: layer.root.props.coordinateSystem
+                };
+                channelMap[id] = channelInfo;
+            }
+            channelInfo.layers.push(layer);
+            channelInfo.layerBounds.push(layer.getBounds());
+        }
+        for (let i = 0; i < 4; i++) {
+            const channelInfo = this.channels[i];
+            if (!channelInfo || !(channelInfo.id in channelMap)) {
+                // The mask id at this channel no longer exists
+                this.channels[i] = null;
+            }
+        }
+        for (const maskId in channelMap) {
+            const channelInfo = channelMap[maskId];
+            if (channelInfo.index < 0) {
+                channelInfo.index = this.channels.findIndex(c => !c);
+                this.channels[channelInfo.index] = channelInfo;
+            }
+        }
+        return channelMap;
+    }
+    getModuleParameters() {
+        return {
+            maskMap: this.masks ? this.maskMap : this.dummyMaskMap,
+            maskChannels: this.masks
+        };
+    }
+    cleanup() {
+        if (this.dummyMaskMap) {
+            this.dummyMaskMap.delete();
+            this.dummyMaskMap = undefined;
+        }
+        if (this.maskPass) {
+            this.maskPass.delete();
+            this.maskPass = undefined;
+            this.maskMap = undefined;
+        }
+        this.lastViewport = undefined;
+        this.masks = null;
+        this.channels.length = 0;
+    }
+}

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: [0, 1],
+            blendEquation: 32778,
+            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/{typed → dist}/mask/shader-module.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader-module.d.ts","sourceRoot":"","sources":["../../src/mask/shader-module.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,sBAAsB,CAAC;AAEvD,OAAO,KAAK,EAAC,OAAO,EAAC,MAAM,eAAe,CAAC;AAoE3C,KAAK,kBAAkB,GAAG;IACxB,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB,CAAC;;AAYF,wBAOsC"}
+{"version":3,"file":"shader-module.d.ts","sourceRoot":"","sources":["../../src/mask/shader-module.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,sBAAsB,CAAC;AAEvD,OAAO,KAAK,EAAC,OAAO,EAAC,MAAM,eAAe,CAAC;AAqE3C,KAAK,kBAAkB,GAAG;IACxB,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB,CAAC;;AAYF,wBAOsC"}

package/dist/mask/shader-module.js

@@ -0,0 +1,77 @@
+import { project } from '@deck.gl/core';
+import { glsl } from "../utils/syntax-tags.js";
+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;
+uniform bool mask_inverted;
+bool mask_isInBounds(vec2 texCoords) {
+if (!mask_enabled) {
+return true;
+}
+vec4 maskColor = texture(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;
+}
+if (mask_inverted) {
+return maskValue >= 0.5;
+} else {
+return maskValue < 0.5;
+}
+}
+`;
+const inject = {
+    'vs:#decl': `
+out 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': `
+in vec2 mask_texCoords;
+`,
+    'fs:#main-start': `
+if (mask_enabled) {
+bool mask = mask_isInBounds(mask_texCoords);
+fragColor = texture(mask_texture, mask_texCoords);
+if (!mask) discard;
+}
+`
+};
+/* 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
+};

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/path-style/shaders.glsl.js

@@ -0,0 +1,86 @@
+export const dashShaders = {
+    inject: {
+        'vs:#decl': `
+in vec2 instanceDashArrays;
+in float instanceDashOffsets;
+out vec2 vDashArray;
+out float vDashOffset;
+`,
+        'vs:#main-end': `
+vDashArray = instanceDashArrays;
+vDashOffset = instanceDashOffsets / width.x;
+`,
+        'fs:#decl': `
+uniform float dashAlignMode;
+uniform float capType;
+uniform bool dashGapPickable;
+in vec2 vDashArray;
+in float vDashOffset;
+`,
+        // 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(vPathPosition.y + offset, unitLength);
+if (gapLength > 0.0 && unitOffset > solidLength) {
+if (capType <= 0.5) {
+if (!(dashGapPickable && bool(picking.isActive))) {
+discard;
+}
+} else {
+float distToEnd = length(vec2(
+min(unitOffset - solidLength, unitLength - unitOffset),
+vPathPosition.x
+));
+if (distToEnd > 1.0) {
+if (!(dashGapPickable && bool(picking.isActive))) {
+discard;
+}
+}
+}
+}
+}
+`
+    }
+};
+export const offsetShaders = {
+    inject: {
+        'vs:#decl': `
+in float instanceOffsets;
+`,
+        'vs:DECKGL_FILTER_SIZE': `
+float offsetWidth = abs(instanceOffsets * 2.0) + 1.0;
+size *= offsetWidth;
+`,
+        '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': `
+float isInside;
+isInside = step(-1.0, vPathPosition.x) * step(vPathPosition.x, 1.0);
+if (isInside == 0.0) {
+discard;
+}
+`
+    }
+};

package/{typed → dist}/terrain/height-map-builder.d.ts

@@ -1,5 +1,5 @@
 import { Device, Framebuffer } from '@luma.gl/core';
-import { Bounds } from '../utils/projection-utils';
+import { Bounds } from "../utils/projection-utils.js";
 import type { Viewport, Layer } from '@deck.gl/core';
 /**
  * Manages the lifecycle of the height map (a framebuffer that encodes elevation).

package/dist/terrain/height-map-builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"height-map-builder.d.ts","sourceRoot":"","sources":["../../src/terrain/height-map-builder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,MAAM,EAAE,WAAW,EAAC,MAAM,eAAe,CAAC;AAClD,OAAO,EAAiD,MAAM,EAAC,qCAAkC;AAGjG,OAAO,KAAK,EAAC,QAAQ,EAAE,KAAK,EAAC,MAAM,eAAe,CAAC;AAInD;;;;;;GAMG;AACH,qBAAa,gBAAgB;IAC3B,6CAA6C;IAC7C,cAAc,EAAE,QAAQ,GAAG,IAAI,CAAQ;IACvC,2DAA2D;IAC3D,MAAM,EAAE,MAAM,GAAG,IAAI,CAAQ;IAE7B,SAAS,CAAC,GAAG,CAAC,EAAE,WAAW,CAAC;IAC5B,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC;IACzB,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,MAAM,EAAE,MAAM,GAAG,OAAO;gBAI/B,MAAM,EAAE,MAAM;IAI1B;;OAEG;IACH,oBAAoB,IAAI,WAAW,GAAG,IAAI;IAU1C,yEAAyE;IACzE,YAAY,CAAC,EAAC,MAAM,EAAE,QAAQ,EAAC,EAAE;QAAC,MAAM,EAAE,KAAK,EAAE,CAAC;QAAC,QAAQ,EAAE,QAAQ,CAAA;KAAC,GAAG,OAAO;IAiEhF,MAAM;CAMP"}