@deck.gl/aggregation-layers 9.0.0-beta.1 → 9.0.0-beta.3

package/dist/gpu-grid-layer/gpu-grid-cell-layer-fragment.glsl.js

@@ -0,0 +1,34 @@
+// 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.
+export default `\
+#version 300 es
+#define SHADER_NAME gpu-grid-cell-layer-fragment-shader
+
+precision highp float;
+
+in vec4 vColor;
+
+out vec4 fragColor;
+
+void main(void) {
+  fragColor = vColor;
+  fragColor = picking_filterColor(fragColor);
+}
+`;

package/dist/{esm/gpu-grid-layer → gpu-grid-layer}/gpu-grid-cell-layer-vertex.glsl.js

@@ -1,3 +1,23 @@
+// 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.
+// Inspired by screen-grid-layer vertex shader in deck.gl
 export default `\
 #version 300 es
 #define SHADER_NAME gpu-grid-cell-layer-vertex-shader
@@ -119,4 +139,3 @@ void main(void) {
   }
 }
 `;
-//# sourceMappingURL=gpu-grid-cell-layer-vertex.glsl.js.map

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

@@ -0,0 +1,145 @@
+// 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 { Layer, fp64LowPart, project32, gouraudLighting, picking } from '@deck.gl/core';
+import { CubeGeometry } from '@luma.gl/engine';
+import { fp64arithmetic } from '@luma.gl/shadertools';
+import { Model } from '@luma.gl/engine';
+import { GL } from '@luma.gl/constants';
+import { defaultColorRange, colorRangeToFlatArray } from "../utils/color-utils.js";
+import vs from "./gpu-grid-cell-layer-vertex.glsl.js";
+import fs from "./gpu-grid-cell-layer-fragment.glsl.js";
+const COLOR_DATA_UBO_INDEX = 0;
+const ELEVATION_DATA_UBO_INDEX = 1;
+const defaultProps = {
+    // color
+    colorDomain: null,
+    colorRange: defaultColorRange,
+    // elevation
+    elevationDomain: null,
+    elevationRange: [0, 1000],
+    elevationScale: { type: 'number', min: 0, value: 1 },
+    // grid
+    gridSize: { type: 'array', value: [1, 1] },
+    gridOrigin: { type: 'array', value: [0, 0] },
+    gridOffset: { type: 'array', value: [0, 0] },
+    cellSize: { type: 'number', min: 0, max: 1000, value: 1000 },
+    offset: { type: 'array', value: [1, 1] },
+    coverage: { type: 'number', min: 0, max: 1, value: 1 },
+    extruded: true,
+    material: true // Use lighting module defaults
+};
+export default class GPUGridCellLayer extends Layer {
+    static { this.layerName = 'GPUGridCellLayer'; }
+    static { this.defaultProps = defaultProps; }
+    getShaders() {
+        return super.getShaders({
+            vs,
+            fs,
+            modules: [project32, gouraudLighting, picking, fp64arithmetic]
+        });
+    }
+    initializeState() {
+        const attributeManager = this.getAttributeManager();
+        attributeManager.addInstanced({
+            colors: {
+                size: 4,
+                noAlloc: true
+            },
+            elevations: {
+                size: 4,
+                noAlloc: true
+            }
+        });
+        const model = this._getModel();
+        this._setupUniformBuffer(model);
+        this.setState({ model });
+    }
+    _getModel() {
+        return new Model(this.context.device, {
+            ...this.getShaders(),
+            id: this.props.id,
+            geometry: new CubeGeometry(),
+            isInstanced: true
+        });
+    }
+    draw({ uniforms }) {
+        const { cellSize, offset, extruded, elevationScale, coverage, gridSize, gridOrigin, gridOffset, elevationRange, colorMaxMinBuffer, elevationMaxMinBuffer } = this.props;
+        const model = this.state.model;
+        const gridOriginLow = [fp64LowPart(gridOrigin[0]), fp64LowPart(gridOrigin[1])];
+        const gridOffsetLow = [fp64LowPart(gridOffset[0]), fp64LowPart(gridOffset[1])];
+        const domainUniforms = this.getDomainUniforms();
+        const colorRange = colorRangeToFlatArray(this.props.colorRange);
+        this.bindUniformBuffers(colorMaxMinBuffer, elevationMaxMinBuffer);
+        model.setUniforms(uniforms);
+        model.setUniforms(domainUniforms);
+        model.setUniforms({
+            cellSize,
+            offset,
+            extruded,
+            elevationScale,
+            coverage,
+            gridSize,
+            gridOrigin,
+            gridOriginLow,
+            gridOffset,
+            gridOffsetLow,
+            colorRange,
+            elevationRange
+        });
+        model.draw(this.context.renderPass);
+        this.unbindUniformBuffers(colorMaxMinBuffer, elevationMaxMinBuffer);
+    }
+    bindUniformBuffers(colorMaxMinBuffer, elevationMaxMinBuffer) {
+        colorMaxMinBuffer.bind({ target: GL.UNIFORM_BUFFER, index: COLOR_DATA_UBO_INDEX });
+        elevationMaxMinBuffer.bind({ target: GL.UNIFORM_BUFFER, index: ELEVATION_DATA_UBO_INDEX });
+    }
+    unbindUniformBuffers(colorMaxMinBuffer, elevationMaxMinBuffer) {
+        colorMaxMinBuffer.unbind({ target: GL.UNIFORM_BUFFER, index: COLOR_DATA_UBO_INDEX });
+        elevationMaxMinBuffer.unbind({ target: GL.UNIFORM_BUFFER, index: ELEVATION_DATA_UBO_INDEX });
+    }
+    getDomainUniforms() {
+        const { colorDomain, elevationDomain } = this.props;
+        const domainUniforms = {};
+        if (colorDomain !== null) {
+            domainUniforms.colorDomainValid = true;
+            domainUniforms.colorDomain = colorDomain;
+        }
+        else {
+            domainUniforms.colorDomainValid = false;
+        }
+        if (elevationDomain !== null) {
+            domainUniforms.elevationDomainValid = true;
+            domainUniforms.elevationDomain = elevationDomain;
+        }
+        else {
+            domainUniforms.elevationDomainValid = false;
+        }
+        return domainUniforms;
+    }
+    _setupUniformBuffer(model) {
+        // @ts-expect-error TODO v9 This code is not portable to WebGPU
+        const programHandle = model.pipeline.handle;
+        const gl = this.context.gl;
+        const colorIndex = gl.getUniformBlockIndex(programHandle, 'ColorData');
+        const elevationIndex = gl.getUniformBlockIndex(programHandle, 'ElevationData');
+        gl.uniformBlockBinding(programHandle, colorIndex, COLOR_DATA_UBO_INDEX);
+        gl.uniformBlockBinding(programHandle, elevationIndex, ELEVATION_DATA_UBO_INDEX);
+    }
+}

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

@@ -0,0 +1,288 @@
+// 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 { GL } from '@luma.gl/constants';
+import { log } from '@deck.gl/core';
+import GPUGridAggregator from "../utils/gpu-grid-aggregation/gpu-grid-aggregator.js";
+import { AGGREGATION_OPERATION } from "../utils/aggregation-operation-utils.js";
+import { defaultColorRange, colorRangeToFlatArray } from "../utils/color-utils.js";
+import GPUGridCellLayer from "./gpu-grid-cell-layer.js";
+import { pointToDensityGridDataCPU } from "./../cpu-grid-layer/grid-aggregator.js";
+import GridAggregationLayer from "../grid-aggregation-layer.js";
+import { getBoundingBox, getGridParams } from "../utils/grid-aggregation-utils.js";
+const defaultProps = {
+    // color
+    colorDomain: null,
+    colorRange: defaultColorRange,
+    getColorWeight: { type: 'accessor', value: 1 },
+    colorAggregation: 'SUM',
+    // elevation
+    elevationDomain: null,
+    elevationRange: [0, 1000],
+    getElevationWeight: { type: 'accessor', value: 1 },
+    elevationAggregation: 'SUM',
+    elevationScale: { type: 'number', min: 0, value: 1 },
+    // grid
+    cellSize: { type: 'number', min: 1, max: 1000, value: 1000 },
+    coverage: { type: 'number', min: 0, max: 1, value: 1 },
+    getPosition: { type: 'accessor', value: (x) => x.position },
+    extruded: false,
+    // Optional material for 'lighting' shader module
+    material: true
+};
+// This layer only perform GPU aggregation, no need to seperate data and weight props
+// aggregation will be dirty when any of the props are changed.
+const DIMENSIONS = {
+    data: {
+        props: ['cellSize', 'colorAggregation', 'elevationAggregation']
+    }
+    // rest of the changes are detected by `state.attributesChanged`
+};
+const POSITION_ATTRIBUTE_NAME = 'positions';
+/** Aggregate data into a grid-based heatmap. Aggregation is performed on GPU (WebGL2 only). */
+export default class GPUGridLayer extends GridAggregationLayer {
+    static { this.layerName = 'GPUGridLayer'; }
+    static { this.defaultProps = defaultProps; }
+    initializeState({ device }) {
+        const isSupported = GPUGridAggregator.isSupported(device);
+        if (!isSupported) {
+            log.error('GPUGridLayer is not supported on this browser, use GridLayer instead')();
+        }
+        super.initializeAggregationLayer({
+            dimensions: DIMENSIONS
+        });
+        this.setState({
+            gpuAggregation: false, // TODO(v9): Re-enable GPU aggregation.
+            projectPoints: false, // aggregation in world space
+            isSupported,
+            weights: {
+                color: {
+                    needMin: true,
+                    needMax: true,
+                    combineMaxMin: true,
+                    maxMinBuffer: device.createBuffer({
+                        byteLength: 4 * 4,
+                        // @ts-expect-error webgl-legacy
+                        accessor: { size: 4, type: GL.FLOAT, divisor: 1 }
+                    })
+                },
+                elevation: {
+                    needMin: true,
+                    needMax: true,
+                    combineMaxMin: true,
+                    maxMinBuffer: device.createBuffer({
+                        byteLength: 4 * 4,
+                        // @ts-expect-error
+                        accessor: { size: 4, type: GL.FLOAT, divisor: 1 }
+                    })
+                }
+            },
+            positionAttributeName: 'positions'
+        });
+        const attributeManager = this.getAttributeManager();
+        attributeManager.add({
+            [POSITION_ATTRIBUTE_NAME]: {
+                size: 3,
+                accessor: 'getPosition',
+                type: GL.DOUBLE,
+                fp64: this.use64bitPositions()
+            },
+            color: { size: 3, accessor: 'getColorWeight' },
+            elevation: { size: 3, accessor: 'getElevationWeight' }
+        });
+    }
+    updateState(opts) {
+        if (this.state.isSupported === false) {
+            // Skip update, layer not supported
+            return;
+        }
+        super.updateState(opts);
+        const { aggregationDirty } = this.state;
+        if (aggregationDirty) {
+            // reset cached CPU Aggregation results (used for picking)
+            this.setState({
+                gridHash: null
+            });
+        }
+    }
+    getHashKeyForIndex(index) {
+        const { numRow, numCol, boundingBox, gridOffset } = this.state;
+        const gridSize = [numCol, numRow];
+        const gridOrigin = [boundingBox.xMin, boundingBox.yMin];
+        const cellSize = [gridOffset.xOffset, gridOffset.yOffset];
+        const yIndex = Math.floor(index / gridSize[0]);
+        const xIndex = index - yIndex * gridSize[0];
+        // This will match the index to the hash-key to access aggregation data from CPU aggregation results.
+        const latIdx = Math.floor((yIndex * cellSize[1] + gridOrigin[1] + 90 + cellSize[1] / 2) / cellSize[1]);
+        const lonIdx = Math.floor((xIndex * cellSize[0] + gridOrigin[0] + 180 + cellSize[0] / 2) / cellSize[0]);
+        return `${latIdx}-${lonIdx}`;
+    }
+    getPositionForIndex(index) {
+        const { numRow, numCol, boundingBox, gridOffset } = this.state;
+        const gridSize = [numCol, numRow];
+        const gridOrigin = [boundingBox.xMin, boundingBox.yMin];
+        const cellSize = [gridOffset.xOffset, gridOffset.yOffset];
+        const yIndex = Math.floor(index / gridSize[0]);
+        const xIndex = index - yIndex * gridSize[0];
+        const yPos = yIndex * cellSize[1] + gridOrigin[1];
+        const xPos = xIndex * cellSize[0] + gridOrigin[0];
+        return [xPos, yPos];
+    }
+    getPickingInfo({ info, mode }) {
+        const { index } = info;
+        let object = null;
+        if (index >= 0) {
+            const gpuGridAggregator = this.state.gpuGridAggregator;
+            const position = this.getPositionForIndex(index);
+            const colorInfo = GPUGridAggregator.getAggregationData({
+                pixelIndex: index,
+                ...gpuGridAggregator.getData('color')
+            });
+            const elevationInfo = GPUGridAggregator.getAggregationData({
+                pixelIndex: index,
+                ...gpuGridAggregator.getData('elevation')
+            });
+            object = {
+                colorValue: colorInfo.cellWeight,
+                elevationValue: elevationInfo.cellWeight,
+                count: colorInfo.cellCount || elevationInfo.cellCount,
+                position,
+                totalCount: colorInfo.totalCount || elevationInfo.totalCount
+            };
+            if (mode !== 'hover') {
+                // perform CPU aggregation for full list of points for each cell
+                const { props } = this;
+                let { gridHash } = this.state;
+                if (!gridHash) {
+                    const { gridOffset, translation, boundingBox } = this.state;
+                    const { viewport } = this.context;
+                    const attributes = this.getAttributes();
+                    const cpuAggregation = pointToDensityGridDataCPU(props, {
+                        gridOffset,
+                        attributes,
+                        viewport,
+                        translation,
+                        boundingBox
+                    });
+                    gridHash = cpuAggregation.gridHash;
+                    this.setState({ gridHash });
+                }
+                const key = this.getHashKeyForIndex(index);
+                const cpuAggregationData = gridHash[key];
+                Object.assign(object, cpuAggregationData);
+            }
+        }
+        // override object with picked cell
+        info.picked = Boolean(object);
+        info.object = object;
+        return info;
+    }
+    renderLayers() {
+        if (!this.state.isSupported) {
+            return null;
+        }
+        const { elevationScale, extruded, cellSize: cellSizeMeters, coverage, material, elevationRange, colorDomain, elevationDomain } = this.props;
+        const { weights, numRow, numCol, gridOrigin, gridOffset } = this.state;
+        const { color, elevation } = weights;
+        const colorRange = colorRangeToFlatArray(this.props.colorRange);
+        const SubLayerClass = this.getSubLayerClass('gpu-grid-cell', GPUGridCellLayer);
+        return new SubLayerClass({
+            gridSize: [numCol, numRow],
+            gridOrigin,
+            gridOffset: [gridOffset.xOffset, gridOffset.yOffset],
+            colorRange,
+            elevationRange,
+            colorDomain,
+            elevationDomain,
+            cellSize: cellSizeMeters,
+            coverage,
+            material,
+            elevationScale,
+            extruded
+        }, this.getSubLayerProps({
+            id: 'gpu-grid-cell'
+        }), {
+            data: {
+                attributes: {
+                    colors: color.aggregationBuffer,
+                    elevations: elevation.aggregationBuffer
+                }
+            },
+            colorMaxMinBuffer: color.maxMinBuffer,
+            elevationMaxMinBuffer: elevation.maxMinBuffer,
+            numInstances: numCol * numRow
+        });
+    }
+    finalizeState(context) {
+        const { color, elevation } = this.state.weights;
+        [color, elevation].forEach(weight => {
+            const { aggregationBuffer, maxMinBuffer } = weight;
+            maxMinBuffer?.destroy();
+            aggregationBuffer?.destroy();
+        });
+        super.finalizeState(context);
+    }
+    // Aggregation Overrides
+    updateAggregationState(opts) {
+        const { props, oldProps } = opts;
+        const { cellSize, coordinateSystem } = props;
+        const { viewport } = this.context;
+        const cellSizeChanged = oldProps.cellSize !== cellSize;
+        const { dimensions } = this.state;
+        const positionsChanged = this.isAttributeChanged(POSITION_ATTRIBUTE_NAME);
+        // any attribute changed
+        const attributesChanged = positionsChanged || this.isAttributeChanged();
+        let { boundingBox } = this.state;
+        if (positionsChanged) {
+            boundingBox = getBoundingBox(this.getAttributes(), this.getNumInstances());
+            this.setState({ boundingBox });
+        }
+        if (positionsChanged || cellSizeChanged) {
+            const { gridOffset, translation, width, height, numCol, numRow } = getGridParams(boundingBox, cellSize, viewport, coordinateSystem);
+            this.allocateResources(numRow, numCol);
+            this.setState({
+                gridOffset,
+                translation,
+                gridOrigin: [-1 * translation[0], -1 * translation[1]],
+                width,
+                height,
+                numCol,
+                numRow
+            });
+        }
+        const aggregationDataDirty = attributesChanged ||
+            this.isAggregationDirty(opts, {
+                dimension: dimensions.data,
+                compareAll: true
+            });
+        if (aggregationDataDirty) {
+            this._updateAccessors(opts);
+        }
+        this.setState({
+            aggregationDataDirty
+        });
+    }
+    // Private
+    _updateAccessors(opts) {
+        const { colorAggregation, elevationAggregation } = opts.props;
+        const { color, elevation } = this.state.weights;
+        color.operation = AGGREGATION_OPERATION[colorAggregation];
+        elevation.operation = AGGREGATION_OPERATION[elevationAggregation];
+    }
+}

package/dist/grid-aggregation-layer.js

@@ -0,0 +1,172 @@
+// 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 { GL } from '@luma.gl/constants';
+import { log } from '@deck.gl/core';
+import AggregationLayer from "./aggregation-layer.js";
+import GPUGridAggregator from "./utils/gpu-grid-aggregation/gpu-grid-aggregator.js";
+import BinSorter from "./utils/bin-sorter.js";
+import { pointToDensityGridDataCPU } from "./cpu-grid-layer/grid-aggregator.js";
+export default class GridAggregationLayer extends AggregationLayer {
+    static { this.layerName = 'GridAggregationLayer'; }
+    initializeAggregationLayer({ dimensions }) {
+        super.initializeAggregationLayer(dimensions);
+        this.setState({
+            // CPU aggregation results
+            layerData: {},
+            gpuGridAggregator: new GPUGridAggregator(this.context.device, {
+                id: `${this.id}-gpu-aggregator`
+            }),
+            cpuGridAggregator: pointToDensityGridDataCPU
+        });
+    }
+    updateState(opts) {
+        // get current attributes
+        super.updateState(opts);
+        this.updateAggregationState(opts);
+        const { aggregationDataDirty, aggregationWeightsDirty, gpuAggregation } = this.state;
+        if (this.getNumInstances() <= 0) {
+            return;
+        }
+        let aggregationDirty = false;
+        // CPU aggregation is two steps
+        // 1. Create bins (based on cellSize and position) 2. Aggregate weights for each bin
+        // For GPU aggregation both above steps are combined into one step
+        // step-1
+        if (aggregationDataDirty || (gpuAggregation && aggregationWeightsDirty)) {
+            this._updateAggregation(opts);
+            aggregationDirty = true;
+        }
+        // step-2 (Applicalbe for CPU aggregation only)
+        if (!gpuAggregation && (aggregationDataDirty || aggregationWeightsDirty)) {
+            this._updateWeightBins();
+            this._uploadAggregationResults();
+            aggregationDirty = true;
+        }
+        this.setState({ aggregationDirty });
+    }
+    finalizeState(context) {
+        const { count } = this.state.weights;
+        if (count && count.aggregationBuffer) {
+            count.aggregationBuffer.delete();
+        }
+        this.state.gpuGridAggregator?.delete();
+        super.finalizeState(context);
+    }
+    updateShaders(shaders) {
+        if (this.state.gpuAggregation) {
+            this.state.gpuGridAggregator.updateShaders(shaders);
+        }
+    }
+    // Methods that can be overriden by subclasses for customizations
+    updateAggregationState(opts) {
+        // Sublayers should implement this method.
+        log.assert(false);
+    }
+    allocateResources(numRow, numCol) {
+        if (this.state.numRow !== numRow || this.state.numCol !== numCol) {
+            const dataBytes = numCol * numRow * 4 * 4;
+            const { weights } = this.state;
+            for (const name in weights) {
+                const weight = weights[name];
+                if (weight.aggregationBuffer) {
+                    weight.aggregationBuffer.delete();
+                }
+                weight.aggregationBuffer = this.context.device.createBuffer({
+                    byteLength: dataBytes,
+                    // @ts-expect-error legacy
+                    accessor: {
+                        size: 4,
+                        type: GL.FLOAT,
+                        divisor: 1
+                    }
+                });
+            }
+        }
+    }
+    updateResults({ aggregationData, maxMinData, maxData, minData }) {
+        const { count } = this.state.weights;
+        if (count) {
+            count.aggregationData = aggregationData;
+            count.maxMinData = maxMinData;
+            count.maxData = maxData;
+            count.minData = minData;
+        }
+    }
+    // Private
+    _updateAggregation(opts) {
+        const { cpuGridAggregator, gpuGridAggregator, gridOffset, posOffset, translation = [0, 0], scaling = [0, 0, 0], boundingBox, projectPoints, gpuAggregation, numCol, numRow } = this.state;
+        const { props } = opts;
+        const { viewport } = this.context;
+        const attributes = this.getAttributes();
+        const vertexCount = this.getNumInstances();
+        if (!gpuAggregation) {
+            const result = cpuGridAggregator(props, {
+                gridOffset,
+                projectPoints,
+                attributes,
+                viewport,
+                posOffset,
+                boundingBox
+            });
+            this.setState({
+                layerData: result
+            });
+        }
+        else {
+            const { weights } = this.state;
+            gpuGridAggregator.run({
+                weights,
+                cellSize: [gridOffset.xOffset, gridOffset.yOffset],
+                numCol,
+                numRow,
+                translation,
+                scaling,
+                vertexCount,
+                projectPoints,
+                attributes,
+                moduleSettings: this.getModuleSettings()
+            });
+        }
+    }
+    _updateWeightBins() {
+        const { getValue } = this.state;
+        const sortedBins = new BinSorter(this.state.layerData.data || [], { getValue });
+        this.setState({ sortedBins });
+    }
+    _uploadAggregationResults() {
+        const { numCol, numRow } = this.state;
+        const { data } = this.state.layerData;
+        const { aggregatedBins, minValue, maxValue, totalCount } = this.state.sortedBins;
+        const ELEMENTCOUNT = 4;
+        const aggregationSize = numCol * numRow * ELEMENTCOUNT;
+        const aggregationData = new Float32Array(aggregationSize).fill(0);
+        for (const bin of aggregatedBins) {
+            const { lonIdx, latIdx } = data[bin.i];
+            const { value, counts } = bin;
+            const cellIndex = (lonIdx + latIdx * numCol) * ELEMENTCOUNT;
+            aggregationData[cellIndex] = value;
+            aggregationData[cellIndex + ELEMENTCOUNT - 1] = counts;
+        }
+        const maxMinData = new Float32Array([maxValue, 0, 0, minValue]);
+        const maxData = new Float32Array([maxValue, 0, 0, totalCount]);
+        const minData = new Float32Array([minValue, 0, 0, totalCount]);
+        this.updateResults({ aggregationData, maxMinData, maxData, minData });
+    }
+}