@deck.gl/aggregation-layers 9.0.35 → 9.1.0-beta.1

package/dist/grid-layer/grid-layer.js

@@ -1,62 +1,358 @@
-import { CompositeLayer } from '@deck.gl/core';
-import GPUGridAggregator from "../utils/gpu-grid-aggregation/gpu-grid-aggregator.js";
-import GPUGridLayer from "../gpu-grid-layer/gpu-grid-layer.js";
-import CPUGridLayer from "../cpu-grid-layer/cpu-grid-layer.js";
+// deck.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+import { log, createIterable, project32, Viewport } from '@deck.gl/core';
+import { WebGLAggregator, CPUAggregator } from "../common/aggregator/index.js";
+import AggregationLayer from "../common/aggregation-layer.js";
+import { defaultColorRange } from "../common/utils/color-utils.js";
+import { AttributeWithScale } from "../common/utils/scale-utils.js";
+import { getBinIdRange } from "../common/utils/bounds-utils.js";
+import { GridCellLayer } from "./grid-cell-layer.js";
+import { binOptionsUniforms } from "./bin-options-uniforms.js";
+// eslint-disable-next-line @typescript-eslint/no-empty-function
+function noop() { }
 const defaultProps = {
-    ...GPUGridLayer.defaultProps,
-    ...CPUGridLayer.defaultProps,
-    gpuAggregation: false
+    gpuAggregation: false,
+    // color
+    colorDomain: null,
+    colorRange: defaultColorRange,
+    getColorValue: { type: 'accessor', value: null }, // default value is calculated from `getColorWeight` and `colorAggregation`
+    getColorWeight: { type: 'accessor', value: 1 },
+    colorAggregation: 'SUM',
+    lowerPercentile: { type: 'number', min: 0, max: 100, value: 0 },
+    upperPercentile: { type: 'number', min: 0, max: 100, value: 100 },
+    colorScaleType: 'quantize',
+    onSetColorDomain: noop,
+    // elevation
+    elevationDomain: null,
+    elevationRange: [0, 1000],
+    getElevationValue: { type: 'accessor', value: null }, // default value is calculated from `getElevationWeight` and `elevationAggregation`
+    getElevationWeight: { type: 'accessor', value: 1 },
+    elevationAggregation: 'SUM',
+    elevationScale: { type: 'number', min: 0, value: 1 },
+    elevationLowerPercentile: { type: 'number', min: 0, max: 100, value: 0 },
+    elevationUpperPercentile: { type: 'number', min: 0, max: 100, value: 100 },
+    elevationScaleType: 'linear',
+    onSetElevationDomain: noop,
+    // grid
+    cellSize: { type: 'number', min: 0, value: 1000 },
+    coverage: { type: 'number', min: 0, max: 1, value: 1 },
+    getPosition: { type: 'accessor', value: (x) => x.position },
+    gridAggregator: { type: 'function', optional: true, value: null },
+    extruded: false,
+    // Optional material for 'lighting' shader module
+    material: true
 };
 /** Aggregate data into a grid-based heatmap. The color and height of a cell are determined based on the objects it contains. */
-class GridLayer extends CompositeLayer {
-    initializeState() {
-        this.state = {
-            useGPUAggregation: false // TODO(v9): Re-enable GPU aggregation.
-        };
+class GridLayer extends AggregationLayer {
+    getAggregatorType() {
+        const { gpuAggregation, gridAggregator, getColorValue, getElevationValue } = this.props;
+        if (gpuAggregation && (gridAggregator || getColorValue || getElevationValue)) {
+            // If these features are desired by the app, the user should explicitly use CPU aggregation
+            log.warn('Features not supported by GPU aggregation, falling back to CPU')();
+            return 'cpu';
+        }
+        if (
+        // GPU aggregation is requested
+        gpuAggregation &&
+            // GPU aggregation is supported by the device
+            WebGLAggregator.isSupported(this.context.device)) {
+            return 'gpu';
+        }
+        return 'cpu';
     }
-    updateState({ props }) {
-        this.setState({
-            // TODO(v9): Re-enable GPU aggregation.
-            // useGPUAggregation: this.canUseGPUAggregation(props)
-            useGPUAggregation: false
+    createAggregator(type) {
+        if (type === 'cpu') {
+            const { gridAggregator, cellSize } = this.props;
+            return new CPUAggregator({
+                dimensions: 2,
+                getBin: {
+                    sources: ['positions'],
+                    getValue: ({ positions }, index, opts) => {
+                        if (gridAggregator) {
+                            return gridAggregator(positions, cellSize);
+                        }
+                        const viewport = this.state.aggregatorViewport;
+                        // project to common space
+                        const p = viewport.projectPosition(positions);
+                        const { cellSizeCommon, cellOriginCommon } = opts;
+                        return [
+                            Math.floor((p[0] - cellOriginCommon[0]) / cellSizeCommon[0]),
+                            Math.floor((p[1] - cellOriginCommon[1]) / cellSizeCommon[1])
+                        ];
+                    }
+                },
+                getValue: [
+                    { sources: ['colorWeights'], getValue: ({ colorWeights }) => colorWeights },
+                    { sources: ['elevationWeights'], getValue: ({ elevationWeights }) => elevationWeights }
+                ]
+            });
+        }
+        return new WebGLAggregator(this.context.device, {
+            dimensions: 2,
+            channelCount: 2,
+            bufferLayout: this.getAttributeManager().getBufferLayouts({ isInstanced: false }),
+            ...super.getShaders({
+                modules: [project32, binOptionsUniforms],
+                vs: /* glsl */ `
+  in vec3 positions;
+  in vec3 positions64Low;
+  in float colorWeights;
+  in float elevationWeights;
+
+  void getBin(out ivec2 binId) {
+    vec3 positionCommon = project_position(positions, positions64Low);
+    vec2 gridCoords = floor(positionCommon.xy / binOptions.cellSizeCommon);
+    binId = ivec2(gridCoords);
+  }
+  void getValue(out vec2 value) {
+    value = vec2(colorWeights, elevationWeights);
+  }
+  `
+            })
         });
     }
-    renderLayers() {
-        const { data, updateTriggers } = this.props;
-        const id = this.state.useGPUAggregation ? 'GPU' : 'CPU';
-        const LayerType = this.state.useGPUAggregation
-            ? this.getSubLayerClass('GPU', GPUGridLayer)
-            : this.getSubLayerClass('CPU', CPUGridLayer);
-        return new LayerType(this.props, this.getSubLayerProps({
-            id,
-            updateTriggers
-        }), {
-            data
+    initializeState() {
+        super.initializeState();
+        const attributeManager = this.getAttributeManager();
+        attributeManager.add({
+            positions: {
+                size: 3,
+                accessor: 'getPosition',
+                type: 'float64',
+                fp64: this.use64bitPositions()
+            },
+            colorWeights: { size: 1, accessor: 'getColorWeight' },
+            elevationWeights: { size: 1, accessor: 'getElevationWeight' }
         });
     }
-    // Private methods
-    canUseGPUAggregation(props) {
-        const { gpuAggregation, lowerPercentile, upperPercentile, getColorValue, getElevationValue, colorScaleType } = props;
-        if (!gpuAggregation) {
-            // cpu aggregation is requested
-            return false;
+    updateState(params) {
+        const aggregatorChanged = super.updateState(params);
+        const { props, oldProps, changeFlags } = params;
+        const { aggregator } = this.state;
+        if ((changeFlags.dataChanged || !this.state.dataAsArray) &&
+            (props.getColorValue || props.getElevationValue)) {
+            // Convert data to array
+            this.state.dataAsArray = Array.from(createIterable(props.data).iterable);
+        }
+        if (aggregatorChanged ||
+            changeFlags.dataChanged ||
+            props.cellSize !== oldProps.cellSize ||
+            props.getColorValue !== oldProps.getColorValue ||
+            props.getElevationValue !== oldProps.getElevationValue ||
+            props.colorAggregation !== oldProps.colorAggregation ||
+            props.elevationAggregation !== oldProps.elevationAggregation) {
+            this._updateBinOptions();
+            const { cellSizeCommon, cellOriginCommon, binIdRange, dataAsArray } = this.state;
+            aggregator.setProps({
+                // @ts-expect-error only used by GPUAggregator
+                binIdRange,
+                pointCount: this.getNumInstances(),
+                operations: [props.colorAggregation, props.elevationAggregation],
+                binOptions: {
+                    cellSizeCommon,
+                    cellOriginCommon
+                },
+                onUpdate: this._onAggregationUpdate.bind(this)
+            });
+            if (dataAsArray) {
+                const { getColorValue, getElevationValue } = this.props;
+                aggregator.setProps({
+                    // @ts-expect-error only used by CPUAggregator
+                    customOperations: [
+                        getColorValue &&
+                            ((indices) => getColorValue(indices.map(i => dataAsArray[i]), { indices, data: props.data })),
+                        getElevationValue &&
+                            ((indices) => getElevationValue(indices.map(i => dataAsArray[i]), { indices, data: props.data }))
+                    ]
+                });
+            }
+        }
+        if (changeFlags.updateTriggersChanged && changeFlags.updateTriggersChanged.getColorValue) {
+            aggregator.setNeedsUpdate(0);
+        }
+        if (changeFlags.updateTriggersChanged && changeFlags.updateTriggersChanged.getElevationValue) {
+            aggregator.setNeedsUpdate(1);
+        }
+        return aggregatorChanged;
+    }
+    _updateBinOptions() {
+        const bounds = this.getBounds();
+        const cellSizeCommon = [1, 1];
+        let cellOriginCommon = [0, 0];
+        let binIdRange = [
+            [0, 1],
+            [0, 1]
+        ];
+        let viewport = this.context.viewport;
+        if (bounds && Number.isFinite(bounds[0][0])) {
+            let centroid = [(bounds[0][0] + bounds[1][0]) / 2, (bounds[0][1] + bounds[1][1]) / 2];
+            const { cellSize } = this.props;
+            const { unitsPerMeter } = viewport.getDistanceScales(centroid);
+            cellSizeCommon[0] = unitsPerMeter[0] * cellSize;
+            cellSizeCommon[1] = unitsPerMeter[1] * cellSize;
+            // Offset common space to center at the origin of the grid cell where the data center is in
+            // This improves precision without affecting the cell positions
+            const centroidCommon = viewport.projectFlat(centroid);
+            cellOriginCommon = [
+                Math.floor(centroidCommon[0] / cellSizeCommon[0]) * cellSizeCommon[0],
+                Math.floor(centroidCommon[1] / cellSizeCommon[1]) * cellSizeCommon[1]
+            ];
+            centroid = viewport.unprojectFlat(cellOriginCommon);
+            const ViewportType = viewport.constructor;
+            // We construct a viewport for the GPU aggregator's project module
+            // This viewport is determined by data
+            // removes arbitrary precision variance that depends on initial view state
+            viewport = viewport.isGeospatial
+                ? new ViewportType({ longitude: centroid[0], latitude: centroid[1], zoom: 12 })
+                : new Viewport({ position: [centroid[0], centroid[1], 0], zoom: 12 });
+            // Round to the nearest 32-bit float to match CPU and GPU results
+            cellOriginCommon = [Math.fround(viewport.center[0]), Math.fround(viewport.center[1])];
+            binIdRange = getBinIdRange({
+                dataBounds: bounds,
+                getBinId: (p) => {
+                    const positionCommon = viewport.projectFlat(p);
+                    return [
+                        Math.floor((positionCommon[0] - cellOriginCommon[0]) / cellSizeCommon[0]),
+                        Math.floor((positionCommon[1] - cellOriginCommon[1]) / cellSizeCommon[1])
+                    ];
+                }
+            });
         }
-        if (!GPUGridAggregator.isSupported(this.context.device)) {
-            return false;
+        this.setState({ cellSizeCommon, cellOriginCommon, binIdRange, aggregatorViewport: viewport });
+    }
+    draw(opts) {
+        // Replaces render time viewport with our own
+        if (opts.shaderModuleProps.project) {
+            opts.shaderModuleProps.project.viewport = this.state.aggregatorViewport;
+        }
+        super.draw(opts);
+    }
+    _onAggregationUpdate({ channel }) {
+        const props = this.getCurrentLayer().props;
+        const { aggregator } = this.state;
+        if (channel === 0) {
+            const result = aggregator.getResult(0);
+            this.setState({
+                colors: new AttributeWithScale(result, aggregator.binCount)
+            });
+            props.onSetColorDomain(aggregator.getResultDomain(0));
         }
-        if (lowerPercentile !== 0 || upperPercentile !== 100) {
-            // percentile calculations requires sorting not supported on GPU
-            return false;
+        else if (channel === 1) {
+            const result = aggregator.getResult(1);
+            this.setState({
+                elevations: new AttributeWithScale(result, aggregator.binCount)
+            });
+            props.onSetElevationDomain(aggregator.getResultDomain(1));
         }
-        if (getColorValue !== null || getElevationValue !== null) {
-            // accessor for custom color or elevation calculation is specified
-            return false;
+    }
+    onAttributeChange(id) {
+        const { aggregator } = this.state;
+        switch (id) {
+            case 'positions':
+                aggregator.setNeedsUpdate();
+                this._updateBinOptions();
+                const { cellSizeCommon, cellOriginCommon, binIdRange } = this.state;
+                aggregator.setProps({
+                    // @ts-expect-error only used by GPUAggregator
+                    binIdRange,
+                    binOptions: {
+                        cellSizeCommon,
+                        cellOriginCommon
+                    }
+                });
+                break;
+            case 'colorWeights':
+                aggregator.setNeedsUpdate(0);
+                break;
+            case 'elevationWeights':
+                aggregator.setNeedsUpdate(1);
+                break;
+            default:
+            // This should not happen
+        }
+    }
+    renderLayers() {
+        const { aggregator, cellOriginCommon, cellSizeCommon } = this.state;
+        const { elevationScale, colorRange, elevationRange, extruded, coverage, material, transitions, colorScaleType, lowerPercentile, upperPercentile, colorDomain, elevationScaleType, elevationLowerPercentile, elevationUpperPercentile, elevationDomain } = this.props;
+        const CellLayerClass = this.getSubLayerClass('cells', GridCellLayer);
+        const binAttribute = aggregator.getBins();
+        const colors = this.state.colors?.update({
+            scaleType: colorScaleType,
+            lowerPercentile,
+            upperPercentile
+        });
+        const elevations = this.state.elevations?.update({
+            scaleType: elevationScaleType,
+            lowerPercentile: elevationLowerPercentile,
+            upperPercentile: elevationUpperPercentile
+        });
+        if (!colors || !elevations) {
+            return null;
         }
-        if (colorScaleType === 'quantile' || colorScaleType === 'ordinal') {
-            // quantile and ordinal scales are not supported on GPU
-            return false;
+        return new CellLayerClass(this.getSubLayerProps({
+            id: 'cells'
+        }), {
+            data: {
+                length: aggregator.binCount,
+                attributes: {
+                    getBin: binAttribute,
+                    getColorValue: colors.attribute,
+                    getElevationValue: elevations.attribute
+                }
+            },
+            // Data has changed shallowly, but we likely don't need to update the attributes
+            dataComparator: (data, oldData) => data.length === oldData.length,
+            updateTriggers: {
+                getBin: [binAttribute],
+                getColorValue: [colors.attribute],
+                getElevationValue: [elevations.attribute]
+            },
+            cellOriginCommon,
+            cellSizeCommon,
+            elevationScale,
+            colorRange,
+            colorScaleType,
+            elevationRange,
+            extruded,
+            coverage,
+            material,
+            colorDomain: colors.domain || colorDomain || aggregator.getResultDomain(0),
+            elevationDomain: elevations.domain || elevationDomain || aggregator.getResultDomain(1),
+            colorCutoff: colors.cutoff,
+            elevationCutoff: elevations.cutoff,
+            transitions: transitions && {
+                getFillColor: transitions.getColorValue || transitions.getColorWeight,
+                getElevation: transitions.getElevationValue || transitions.getElevationWeight
+            },
+            // Extensions are already handled by the GPUAggregator, do not pass it down
+            extensions: []
+        });
+    }
+    getPickingInfo(params) {
+        const info = params.info;
+        const { index } = info;
+        if (index >= 0) {
+            const bin = this.state.aggregator.getBin(index);
+            let object;
+            if (bin) {
+                object = {
+                    col: bin.id[0],
+                    row: bin.id[1],
+                    colorValue: bin.value[0],
+                    elevationValue: bin.value[1],
+                    count: bin.count
+                };
+                if (bin.pointIndices) {
+                    object.pointIndices = bin.pointIndices;
+                    object.points = Array.isArray(this.props.data)
+                        ? bin.pointIndices.map(i => this.props.data[i])
+                        : [];
+                }
+            }
+            info.object = object;
         }
-        return true;
+        return info;
     }
 }
 GridLayer.layerName = 'GridLayer';

package/dist/{aggregation-layer.d.ts → heatmap-layer/aggregation-layer.d.ts}

@@ -2,6 +2,7 @@ import { CompositeLayer, AttributeManager, LayerDataSource, UpdateParameters, Co
 export type AggregationLayerProps<DataT> = CompositeLayerProps & {
     data: LayerDataSource<DataT>;
 };
+/** Legacy AggregationLayer, to be removed in v9.1 */
 export default abstract class AggregationLayer<DataT, ExtraPropsT extends {} = {}> extends CompositeLayer<Required<AggregationLayer<DataT>> & ExtraPropsT> {
     static layerName: string;
     state: {

package/dist/heatmap-layer/aggregation-layer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aggregation-layer.d.ts","sourceRoot":"","sources":["../../src/heatmap-layer/aggregation-layer.ts"],"names":[],"mappings":"AAIA,OAAO,EACL,cAAc,EACd,gBAAgB,EAChB,eAAe,EAEf,gBAAgB,EAChB,mBAAmB,EACnB,SAAS,EACV,MAAM,eAAe,CAAC;AAGvB,MAAM,MAAM,qBAAqB,CAAC,KAAK,IAAI,mBAAmB,GAAG;IAC/D,IAAI,EAAE,eAAe,CAAC,KAAK,CAAC,CAAC;CAC9B,CAAC;AAEF,qDAAqD;AACrD,MAAM,CAAC,OAAO,CAAC,QAAQ,OAAO,gBAAgB,CAC5C,KAAK,EACL,WAAW,SAAS,EAAE,GAAG,EAAE,CAC3B,SAAQ,cAAc,CAAC,QAAQ,CAAC,gBAAgB,CAAC,KAAK,CAAC,CAAC,GAAG,WAAW,CAAC;IACvE,MAAM,CAAC,SAAS,SAAsB;IAEtC,KAAK,EAAG;QACN,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;QAClC,UAAU,CAAC,EAAE,GAAG,CAAC;QACjB,iBAAiB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;KACzC,CAAC;IAEF,0BAA0B,CAAC,UAAU,EAAE,GAAG;IAU1C,WAAW,CAAC,IAAI,EAAE,gBAAgB,CAAC,IAAI,CAAC;IAexC,gBAAgB,CAAC,iBAAiB,KAAA;IAMlC,aAAa,IAAI;QAAC,CAAC,EAAE,EAAE,MAAM,GAAG,SAAS,CAAA;KAAC;IAI1C,iBAAiB;IAiBjB,aAAa,CAAC,OAAO,KAAA;IAIrB;;;;;;;QAOI;IACJ,kBAAkB,CAChB,UAAU,KAAA,EACV,MAAM,GAAE;QAAC,UAAU,CAAC,EAAE,OAAO,CAAC;QAAC,SAAS,CAAC,EAAE,GAAG,CAAA;KAAM,GACnD,MAAM,GAAG,OAAO;IAyCnB;;;;;QAKI;IACJ,kBAAkB,CAAC,IAAI,CAAC,EAAE,MAAM;IAYhC,oBAAoB;CAMrB"}

package/dist/{aggregation-layer.js → heatmap-layer/aggregation-layer.js}

@@ -1,24 +1,9 @@
-// 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.
+// deck.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
 import { CompositeLayer, AttributeManager, _compareProps as compareProps } from '@deck.gl/core';
-import { filterProps } from "./utils/prop-utils.js";
+import { filterProps } from "../common/utils/prop-utils.js";
+/** Legacy AggregationLayer, to be removed in v9.1 */
 class AggregationLayer extends CompositeLayer {
     initializeAggregationLayer(dimensions) {
         super.initializeState(this.context);
@@ -52,7 +37,7 @@ class AggregationLayer extends CompositeLayer {
     getModuleSettings() {
         // For regular layer draw this happens during draw cycle (_drawLayersInViewport) not during update cycle
         // For aggregation layers this is called during updateState to update aggregation data
-        // NOTE: it is similar to LayerPass._getModuleParameters() but doesn't inlcude `effects` it is not needed for aggregation
+        // NOTE: it is similar to LayerPass._getShaderModuleProps() but doesn't inlcude `effects` it is not needed for aggregation
         const { viewport, mousePosition, device } = this.context;
         const moduleSettings = Object.assign(Object.create(this.props), {
             viewport,

package/dist/heatmap-layer/heatmap-layer-uniforms.d.ts

@@ -0,0 +1,30 @@
+import { Texture } from '@luma.gl/core';
+export type WeightProps = {
+    commonBounds: [number, number, number, number];
+    radiusPixels: number;
+    textureWidth: number;
+    weightsScale: number;
+    weightsTexture: Texture;
+};
+export declare const weightUniforms: {
+    readonly name: "weight";
+    readonly vs: "uniform weightUniforms {\n  vec4 commonBounds;\n  float radiusPixels;\n  float textureWidth;\n  float weightsScale;\n} weight;\n";
+    readonly uniformTypes: {
+        readonly commonBounds: "vec4<f32>";
+        readonly radiusPixels: "f32";
+        readonly textureWidth: "f32";
+        readonly weightsScale: "f32";
+    };
+};
+export type MaxWeightProps = {
+    inTexture: Texture;
+    textureSize: number;
+};
+export declare const maxWeightUniforms: {
+    readonly name: "maxWeight";
+    readonly vs: "uniform maxWeightUniforms {\n  float textureSize;\n} maxWeight;\n";
+    readonly uniformTypes: {
+        readonly textureSize: "f32";
+    };
+};
+//# sourceMappingURL=heatmap-layer-uniforms.d.ts.map

package/dist/heatmap-layer/heatmap-layer-uniforms.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"heatmap-layer-uniforms.d.ts","sourceRoot":"","sources":["../../src/heatmap-layer/heatmap-layer-uniforms.ts"],"names":[],"mappings":"AAIA,OAAO,EAAC,OAAO,EAAC,MAAM,eAAe,CAAC;AAWtC,MAAM,MAAM,WAAW,GAAG;IACxB,YAAY,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IAC/C,YAAY,EAAE,MAAM,CAAC;IACrB,YAAY,EAAE,MAAM,CAAC;IACrB,YAAY,EAAE,MAAM,CAAC;IACrB,cAAc,EAAE,OAAO,CAAC;CACzB,CAAC;AAEF,eAAO,MAAM,cAAc;;;;;;;;;CASmB,CAAC;AAE/C,MAAM,MAAM,cAAc,GAAG;IAC3B,SAAS,EAAE,OAAO,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF,eAAO,MAAM,iBAAiB;;;;;;CAUmB,CAAC"}

package/dist/heatmap-layer/heatmap-layer-uniforms.js

@@ -0,0 +1,32 @@
+// deck.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+const uniformBlock = `\
+uniform weightUniforms {
+  vec4 commonBounds;
+  float radiusPixels;
+  float textureWidth;
+  float weightsScale;
+} weight;
+`;
+export const weightUniforms = {
+    name: 'weight',
+    vs: uniformBlock,
+    uniformTypes: {
+        commonBounds: 'vec4<f32>',
+        radiusPixels: 'f32',
+        textureWidth: 'f32',
+        weightsScale: 'f32'
+    }
+};
+export const maxWeightUniforms = {
+    name: 'maxWeight',
+    vs: `\
+uniform maxWeightUniforms {
+  float textureSize;
+} maxWeight;
+`,
+    uniformTypes: {
+        textureSize: 'f32'
+    }
+};

package/dist/heatmap-layer/heatmap-layer-utils.d.ts

@@ -1,6 +1,6 @@
 export declare function getBounds(points: number[][]): number[];
 export declare function boundsContain(currentBounds: number[], targetBounds: number[]): boolean;
 export declare function packVertices(points: number[][], dimensions?: number): Float32Array;
-export declare function scaleToAspectRatio(boundingBox: number[], width: number, height: number): number[];
+export declare function scaleToAspectRatio(boundingBox: [number, number, number, number], width: number, height: number): [number, number, number, number];
 export declare function getTextureCoordinates(point: number[], bounds: number[]): number[];
 //# sourceMappingURL=heatmap-layer-utils.d.ts.map

package/dist/heatmap-layer/heatmap-layer-utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"heatmap-layer-utils.d.ts","sourceRoot":"","sources":["../../src/heatmap-layer/heatmap-layer-utils.ts"],"names":[],"mappings":"AAAA,wBAAgB,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,GAAG,MAAM,EAAE,CAWtD;AAGD,wBAAgB,aAAa,CAAC,aAAa,EAAE,MAAM,EAAE,EAAE,YAAY,EAAE,MAAM,EAAE,GAAG,OAAO,CAUtF;AAKD,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,EAAE,UAAU,GAAE,MAAU,GAAG,YAAY,CAQrF;AAGD,wBAAgB,kBAAkB,CAAC,WAAW,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CA6BjG;AAGD,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,YAGtE"}
+{"version":3,"file":"heatmap-layer-utils.d.ts","sourceRoot":"","sources":["../../src/heatmap-layer/heatmap-layer-utils.ts"],"names":[],"mappings":"AAIA,wBAAgB,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,GAAG,MAAM,EAAE,CAWtD;AAGD,wBAAgB,aAAa,CAAC,aAAa,EAAE,MAAM,EAAE,EAAE,YAAY,EAAE,MAAM,EAAE,GAAG,OAAO,CAUtF;AAKD,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,EAAE,UAAU,GAAE,MAAU,GAAG,YAAY,CAQrF;AAGD,wBAAgB,kBAAkB,CAChC,WAAW,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EAC7C,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,GACb,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CA6BlC;AAGD,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,YAGtE"}

package/dist/heatmap-layer/heatmap-layer-utils.js

@@ -1,3 +1,6 @@
+// deck.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
 export function getBounds(points) {
     // Now build bounding box in world space (aligned to world coordiante system)
     const x = points.map(p => p[0]);

package/dist/heatmap-layer/heatmap-layer.d.ts

@@ -1,7 +1,7 @@
 import { Buffer, Texture, TextureFormat } from '@luma.gl/core';
 import { TextureTransform } from '@luma.gl/engine';
 import { Accessor, AccessorFunction, AttributeManager, ChangeFlags, Color, Layer, LayerContext, LayersList, Position, UpdateParameters, DefaultProps } from '@deck.gl/core';
-import AggregationLayer, { AggregationLayerProps } from "../aggregation-layer.js";
+import AggregationLayer, { AggregationLayerProps } from "./aggregation-layer.js";
 export type HeatmapLayerProps<DataT = unknown> = _HeatmapLayerProps<DataT> & AggregationLayerProps<DataT>;
 type _HeatmapLayerProps<DataT> = {
     /**
@@ -93,6 +93,7 @@ export default class HeatmapLayer<DataT = any, ExtraPropsT extends {} = {}> exte
         visibleWorldBounds: number[];
         viewportCorners: number[][];
     };
+    getShaders(shaders: any): any;
     initializeState(): void;
     shouldUpdateState({ changeFlags }: UpdateParameters<this>): boolean;
     updateState(opts: UpdateParameters<this>): void;
@@ -101,8 +102,8 @@ export default class HeatmapLayer<DataT = any, ExtraPropsT extends {} = {}> exte
     finalizeState(context: LayerContext): void;
     _getAttributeManager(): AttributeManager;
     _getChangeFlags(opts: UpdateParameters<this>): Partial<ChangeFlags> & {
-        boundsChanged?: boolean | undefined;
-        viewportZoomChanged?: boolean | undefined;
+        boundsChanged?: boolean;
+        viewportZoomChanged?: boolean;
     };
     _createTextures(): void;
     _setupAttributes(): void;
@@ -110,6 +111,7 @@ export default class HeatmapLayer<DataT = any, ExtraPropsT extends {} = {}> exte
     _createWeightsTransform(shaders: {
         vs: string;
         fs?: string;
+        modules: any[];
     }): void;
     _setupResources(): void;
     updateShaders(shaderOptions: any): void;
@@ -121,7 +123,7 @@ export default class HeatmapLayer<DataT = any, ExtraPropsT extends {} = {}> exte
     _debouncedUpdateWeightmap(fromTimer?: boolean): void;
     _worldToCommonBounds(worldBounds: any, opts?: {
         useLayerCoordinateSystem?: boolean;
-    }): number[];
+    }): [number, number, number, number];
     _commonToWorldBounds(commonBounds: any): number[];
 }
 export {};

package/dist/heatmap-layer/heatmap-layer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"heatmap-layer.d.ts","sourceRoot":"","sources":["../../src/heatmap-layer/heatmap-layer.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"heatmap-layer.d.ts","sourceRoot":"","sources":["../../src/heatmap-layer/heatmap-layer.ts"],"names":[],"mappings":"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"}