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

package/dist/index.d.ts

@@ -0,0 +1,20 @@
+export { default as ScreenGridLayer } from "./screen-grid-layer/screen-grid-layer.js";
+export { default as CPUGridLayer } from "./cpu-grid-layer/cpu-grid-layer.js";
+export { default as HexagonLayer } from "./hexagon-layer/hexagon-layer.js";
+export { default as ContourLayer } from "./contour-layer/contour-layer.js";
+export { default as GridLayer } from "./grid-layer/grid-layer.js";
+export { default as GPUGridLayer } from "./gpu-grid-layer/gpu-grid-layer.js";
+export { AGGREGATION_OPERATION } from "./utils/aggregation-operation-utils.js";
+export { default as HeatmapLayer } from "./heatmap-layer/heatmap-layer.js";
+export { default as _GPUGridAggregator } from "./utils/gpu-grid-aggregation/gpu-grid-aggregator.js";
+export { default as _CPUAggregator } from "./utils/cpu-aggregator.js";
+export { default as _AggregationLayer } from "./aggregation-layer.js";
+export { default as _BinSorter } from "./utils/bin-sorter.js";
+export type { ContourLayerProps } from "./contour-layer/contour-layer.js";
+export type { HeatmapLayerProps } from "./heatmap-layer/heatmap-layer.js";
+export type { HexagonLayerProps } from "./hexagon-layer/hexagon-layer.js";
+export type { CPUGridLayerProps } from "./cpu-grid-layer/cpu-grid-layer.js";
+export type { GridLayerProps } from "./grid-layer/grid-layer.js";
+export type { GPUGridLayerProps } from "./gpu-grid-layer/gpu-grid-layer.js";
+export type { ScreenGridLayerProps } from "./screen-grid-layer/screen-grid-layer.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAoBA,OAAO,EAAC,OAAO,IAAI,eAAe,EAAC,iDAA8C;AACjF,OAAO,EAAC,OAAO,IAAI,YAAY,EAAC,2CAAwC;AACxE,OAAO,EAAC,OAAO,IAAI,YAAY,EAAC,yCAAsC;AACtE,OAAO,EAAC,OAAO,IAAI,YAAY,EAAC,yCAAsC;AACtE,OAAO,EAAC,OAAO,IAAI,SAAS,EAAC,mCAAgC;AAC7D,OAAO,EAAC,OAAO,IAAI,YAAY,EAAC,2CAAwC;AACxE,OAAO,EAAC,qBAAqB,EAAC,+CAA4C;AAG1E,OAAO,EAAC,OAAO,IAAI,YAAY,EAAC,yCAAsC;AACtE,OAAO,EAAC,OAAO,IAAI,kBAAkB,EAAC,4DAAyD;AAC/F,OAAO,EAAC,OAAO,IAAI,cAAc,EAAC,kCAA+B;AACjE,OAAO,EAAC,OAAO,IAAI,iBAAiB,EAAC,+BAA4B;AACjE,OAAO,EAAC,OAAO,IAAI,UAAU,EAAC,8BAA2B;AAGzD,YAAY,EAAC,iBAAiB,EAAC,yCAAsC;AACrE,YAAY,EAAC,iBAAiB,EAAC,yCAAsC;AACrE,YAAY,EAAC,iBAAiB,EAAC,yCAAsC;AACrE,YAAY,EAAC,iBAAiB,EAAC,2CAAwC;AACvE,YAAY,EAAC,cAAc,EAAC,mCAAgC;AAC5D,YAAY,EAAC,iBAAiB,EAAC,2CAAwC;AACvE,YAAY,EAAC,oBAAoB,EAAC,iDAA8C"}

package/dist/index.js

@@ -0,0 +1,32 @@
+// 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 as ScreenGridLayer } from "./screen-grid-layer/screen-grid-layer.js";
+export { default as CPUGridLayer } from "./cpu-grid-layer/cpu-grid-layer.js";
+export { default as HexagonLayer } from "./hexagon-layer/hexagon-layer.js";
+export { default as ContourLayer } from "./contour-layer/contour-layer.js";
+export { default as GridLayer } from "./grid-layer/grid-layer.js";
+export { default as GPUGridLayer } from "./gpu-grid-layer/gpu-grid-layer.js";
+export { AGGREGATION_OPERATION } from "./utils/aggregation-operation-utils.js";
+// experimental export
+export { default as HeatmapLayer } from "./heatmap-layer/heatmap-layer.js";
+export { default as _GPUGridAggregator } from "./utils/gpu-grid-aggregation/gpu-grid-aggregator.js";
+export { default as _CPUAggregator } from "./utils/cpu-aggregator.js";
+export { default as _AggregationLayer } from "./aggregation-layer.js";
+export { default as _BinSorter } from "./utils/bin-sorter.js";

package/{typed → dist}/screen-grid-layer/screen-grid-cell-layer.d.ts

@@ -1,7 +1,7 @@
-import { Device, Texture } from '@luma.gl/core';
+import { Texture } from '@luma.gl/core';
 import { Model } from '@luma.gl/engine';
 import { Layer, LayerProps, UpdateParameters, DefaultProps } from '@deck.gl/core';
-import type { _ScreenGridLayerProps } from './screen-grid-layer';
+import type { _ScreenGridLayerProps } from "./screen-grid-layer.js";
 import { ShaderModule } from '@luma.gl/shadertools';
 /** All properties supported by ScreenGridCellLayer. */
 export type ScreenGridCellLayerProps<DataT = unknown> = _ScreenGridCellLayerProps<DataT> & LayerProps;
@@ -12,7 +12,6 @@ export type _ScreenGridCellLayerProps<DataT> = _ScreenGridLayerProps<DataT> & {
 export default class ScreenGridCellLayer<DataT = any, ExtraPropsT extends {} = {}> extends Layer<ExtraPropsT & Required<_ScreenGridCellLayerProps<DataT>>> {
     static layerName: string;
     static defaultProps: DefaultProps<ScreenGridCellLayerProps<unknown>>;
-    static isSupported(device: Device): boolean;
     state: {
         model?: Model;
     };

package/dist/screen-grid-layer/screen-grid-cell-layer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"screen-grid-cell-layer.d.ts","sourceRoot":"","sources":["../../src/screen-grid-layer/screen-grid-cell-layer.ts"],"names":[],"mappings":"AAoBA,OAAO,EAAC,OAAO,EAAC,MAAM,eAAe,CAAC;AACtC,OAAO,EAAC,KAAK,EAAW,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAC,KAAK,EAAE,UAAU,EAAgB,gBAAgB,EAAE,YAAY,EAAC,MAAM,eAAe,CAAC;AAI9F,OAAO,KAAK,EAAC,qBAAqB,EAAC,+BAA4B;AAC/D,OAAO,EAAC,YAAY,EAAC,MAAM,sBAAsB,CAAC;AAclD,uDAAuD;AACvD,MAAM,MAAM,wBAAwB,CAAC,KAAK,GAAG,OAAO,IAAI,yBAAyB,CAAC,KAAK,CAAC,GACtF,UAAU,CAAC;AAEb,8CAA8C;AAC9C,MAAM,MAAM,yBAAyB,CAAC,KAAK,IAAI,qBAAqB,CAAC,KAAK,CAAC,GAAG;IAC5E,UAAU,EAAE,OAAO,CAAC;CACrB,CAAC;AAEF,MAAM,CAAC,OAAO,OAAO,mBAAmB,CAAC,KAAK,GAAG,GAAG,EAAE,WAAW,SAAS,EAAE,GAAG,EAAE,CAAE,SAAQ,KAAK,CAC9F,WAAW,GAAG,QAAQ,CAAC,yBAAyB,CAAC,KAAK,CAAC,CAAC,CACzD;IACC,MAAM,CAAC,SAAS,SAAyB;IACzC,MAAM,CAAC,YAAY,kDAAgB;IAEnC,KAAK,EAAG;QACN,KAAK,CAAC,EAAE,KAAK,CAAC;KACf,CAAC;IAEF,UAAU,IAAI;QAAC,EAAE,EAAE,MAAM,CAAC;QAAC,EAAE,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,YAAY,EAAE,CAAA;KAAC;IAI/D,eAAe;IAYf,iBAAiB,CAAC,EAAC,WAAW,EAAC;;KAAA;IAK/B,WAAW,CAAC,MAAM,EAAE,gBAAgB,CAAC,IAAI,CAAC;IAe1C,IAAI,CAAC,EAAC,QAAQ,EAAC;;KAAA;IA2Bf,0BAA0B,CAAC,SAAS,KAAA,EAAE,EAAC,YAAY,EAAC;;KAAA;IAkBpD,SAAS,IAAI,KAAK;IAuBlB,gBAAgB,IAAI,OAAO;IAe3B,eAAe,CAAC,QAAQ,KAAA,EAAE,KAAK,KAAA,EAAE,WAAW,KAAA,GAAG,IAAI;CA2BpD"}

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

@@ -0,0 +1,164 @@
+// Copyright (c) 2015 - 2019 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 { Model, Geometry } from '@luma.gl/engine';
+import { Layer, log, picking } from '@deck.gl/core';
+import { defaultColorRange, colorRangeToFlatArray } from "../utils/color-utils.js";
+import vs from "./screen-grid-layer-vertex.glsl.js";
+import fs from "./screen-grid-layer-fragment.glsl.js";
+const DEFAULT_MINCOLOR = [0, 0, 0, 0];
+const DEFAULT_MAXCOLOR = [0, 255, 0, 255];
+const COLOR_PROPS = ['minColor', 'maxColor', 'colorRange', 'colorDomain'];
+const defaultProps = {
+    cellSizePixels: { type: 'number', value: 100, min: 1 },
+    cellMarginPixels: { type: 'number', value: 2, min: 0, max: 5 },
+    colorDomain: null,
+    colorRange: defaultColorRange
+};
+export default class ScreenGridCellLayer extends Layer {
+    static { this.layerName = 'ScreenGridCellLayer'; }
+    static { this.defaultProps = defaultProps; }
+    getShaders() {
+        return { vs, fs, modules: [picking] };
+    }
+    initializeState() {
+        const attributeManager = this.getAttributeManager();
+        attributeManager.addInstanced({
+            // eslint-disable-next-line @typescript-eslint/unbound-method
+            instancePositions: { size: 3, update: this.calculateInstancePositions },
+            instanceCounts: { size: 4, noAlloc: true }
+        });
+        this.setState({
+            model: this._getModel()
+        });
+    }
+    shouldUpdateState({ changeFlags }) {
+        // 'instanceCounts' buffer contetns change on viewport change.
+        return changeFlags.somethingChanged;
+    }
+    updateState(params) {
+        super.updateState(params);
+        const { oldProps, props, changeFlags } = params;
+        const attributeManager = this.getAttributeManager();
+        if (props.numInstances !== oldProps.numInstances) {
+            attributeManager.invalidateAll();
+        }
+        else if (oldProps.cellSizePixels !== props.cellSizePixels) {
+            attributeManager.invalidate('instancePositions');
+        }
+        this._updateUniforms(oldProps, props, changeFlags);
+    }
+    draw({ uniforms }) {
+        const { parameters, maxTexture } = this.props;
+        const minColor = this.props.minColor || DEFAULT_MINCOLOR;
+        const maxColor = this.props.maxColor || DEFAULT_MAXCOLOR;
+        // If colorDomain not specified we use default domain [1, maxCount]
+        // maxCount value will be sampled form maxTexture in vertex shader.
+        const colorDomain = this.props.colorDomain || [1, 0];
+        const model = this.state.model;
+        model.setUniforms(uniforms);
+        model.setBindings({
+            maxTexture
+        });
+        model.setUniforms({
+            minColor,
+            maxColor,
+            colorDomain
+        });
+        model.setParameters({
+            depthWriteEnabled: false,
+            // How to specify depth mask in WebGPU?
+            // depthMask: false,
+            ...parameters
+        });
+        model.draw(this.context.renderPass);
+    }
+    calculateInstancePositions(attribute, { numInstances }) {
+        const { width, height } = this.context.viewport;
+        const { cellSizePixels } = this.props;
+        const numCol = Math.ceil(width / cellSizePixels);
+        const { value, size } = attribute;
+        for (let i = 0; i < numInstances; i++) {
+            const x = i % numCol;
+            const y = Math.floor(i / numCol);
+            value[i * size + 0] = ((x * cellSizePixels) / width) * 2 - 1;
+            value[i * size + 1] = 1 - ((y * cellSizePixels) / height) * 2;
+            value[i * size + 2] = 0;
+        }
+    }
+    // Private Methods
+    _getModel() {
+        return new Model(this.context.device, {
+            ...this.getShaders(),
+            id: this.props.id,
+            bufferLayout: this.getAttributeManager().getBufferLayouts(),
+            geometry: new Geometry({
+                topology: 'triangle-list',
+                attributes: {
+                    // prettier-ignore
+                    positions: new Float32Array([
+                        0, 0, 0,
+                        1, 0, 0,
+                        1, 1, 0,
+                        0, 0, 0,
+                        1, 1, 0,
+                        0, 1, 0,
+                    ])
+                }
+            }),
+            isInstanced: true
+        });
+    }
+    _shouldUseMinMax() {
+        const { minColor, maxColor, colorDomain, colorRange } = this.props;
+        if (minColor || maxColor) {
+            log.deprecated('ScreenGridLayer props: minColor and maxColor', 'colorRange, colorDomain')();
+            return true;
+        }
+        // minColor and maxColor not supplied, check if colorRange or colorDomain supplied.
+        // NOTE: colorDomain and colorRange are experimental features, use them only when supplied.
+        if (colorDomain || colorRange) {
+            return false;
+        }
+        // None specified, use default minColor and maxColor
+        return true;
+    }
+    _updateUniforms(oldProps, props, changeFlags) {
+        const model = this.state.model;
+        if (COLOR_PROPS.some(key => oldProps[key] !== props[key])) {
+            model.setUniforms({ shouldUseMinMax: this._shouldUseMinMax() });
+        }
+        if (oldProps.colorRange !== props.colorRange) {
+            model.setUniforms({ colorRange: colorRangeToFlatArray(props.colorRange) });
+        }
+        if (oldProps.cellMarginPixels !== props.cellMarginPixels ||
+            oldProps.cellSizePixels !== props.cellSizePixels ||
+            changeFlags.viewportChanged) {
+            const { width, height } = this.context.viewport;
+            const { cellSizePixels, cellMarginPixels } = this.props;
+            const margin = cellSizePixels > cellMarginPixels ? cellMarginPixels : 0;
+            const cellScale = new Float32Array([
+                ((cellSizePixels - margin) / width) * 2,
+                (-(cellSizePixels - margin) / height) * 2,
+                1
+            ]);
+            model.setUniforms({ cellScale });
+        }
+    }
+}

package/dist/screen-grid-layer/screen-grid-layer-fragment.glsl.js

@@ -0,0 +1,35 @@
+// 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.
+/* fragment shader for the grid-layer */
+export default `\
+#version 300 es
+#define SHADER_NAME screen-grid-layer-fragment-shader
+precision highp float;
+in vec4 vColor;
+in float vSampleCount;
+out vec4 fragColor;
+void main(void) {
+if (vSampleCount <= 0.0) {
+discard;
+}
+fragColor = vColor;
+DECKGL_FILTER_COLOR(fragColor, geometry);
+}
+`;

package/dist/screen-grid-layer/screen-grid-layer-vertex.glsl.js

@@ -0,0 +1,72 @@
+// 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 screen-grid-layer-vertex-shader
+#define RANGE_COUNT 6
+in vec3 positions;
+in vec3 instancePositions;
+in vec4 instanceCounts;
+in vec3 instancePickingColors;
+uniform float opacity;
+uniform vec3 cellScale;
+uniform vec4 minColor;
+uniform vec4 maxColor;
+uniform vec4 colorRange[RANGE_COUNT];
+uniform vec2 colorDomain;
+uniform bool shouldUseMinMax;
+uniform sampler2D maxTexture;
+out vec4 vColor;
+out float vSampleCount;
+vec4 quantizeScale(vec2 domain, vec4 range[RANGE_COUNT], float value) {
+vec4 outColor = vec4(0., 0., 0., 0.);
+if (value >= domain.x && value <= domain.y) {
+float domainRange = domain.y - domain.x;
+if (domainRange <= 0.) {
+outColor = colorRange[0];
+} else {
+float rangeCount = float(RANGE_COUNT);
+float rangeStep = domainRange / rangeCount;
+float idx = floor((value - domain.x) / rangeStep);
+idx = clamp(idx, 0., rangeCount - 1.);
+int intIdx = int(idx);
+outColor = colorRange[intIdx];
+}
+}
+outColor = outColor / 255.;
+return outColor;
+}
+void main(void) {
+vSampleCount = instanceCounts.a;
+float weight = instanceCounts.r;
+float maxWeight = texture(maxTexture, vec2(0.5)).r;
+float step = weight / maxWeight;
+vec4 minMaxColor = mix(minColor, maxColor, step) / 255.;
+vec2 domain = colorDomain;
+float domainMaxValid = float(colorDomain.y != 0.);
+domain.y = mix(maxWeight, colorDomain.y, domainMaxValid);
+vec4 rangeColor = quantizeScale(domain, colorRange, weight);
+float rangeMinMax = float(shouldUseMinMax);
+vec4 color = mix(rangeColor, minMaxColor, rangeMinMax);
+vColor = vec4(color.rgb, color.a * opacity);
+picking_setPickingColor(instancePickingColors);
+gl_Position = vec4(instancePositions + positions * cellScale, 1.);
+}
+`;

package/{typed → dist}/screen-grid-layer/screen-grid-layer.d.ts

@@ -1,6 +1,6 @@
 import { Accessor, Color, GetPickingInfoParams, Layer, LayerContext, LayersList, PickingInfo, Position, UpdateParameters, DefaultProps } from '@deck.gl/core';
 import type { Buffer, Texture } from '@luma.gl/core';
-import GridAggregationLayer, { GridAggregationLayerProps } from '../grid-aggregation-layer';
+import GridAggregationLayer, { GridAggregationLayerProps } from "../grid-aggregation-layer.js";
 /** All properties supported by ScreenGridLayer. */
 export type ScreenGridLayerProps<DataT = unknown> = _ScreenGridLayerProps<DataT> & GridAggregationLayerProps<DataT>;
 /** Properties added by ScreenGridLayer. */
@@ -53,9 +53,6 @@ export type _ScreenGridLayerProps<DataT> = {
     /**
      * Perform aggregation is performed on GPU.
      *
-     * NOTE: GPU Aggregation requires WebGL2 support by the browser.
-     * When `gpuAggregation` is set to true and browser doesn't support WebGL2, aggregation falls back to CPU.
-     *
      * @default true
      */
     gpuAggregation?: boolean;

package/dist/screen-grid-layer/screen-grid-layer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"screen-grid-layer.d.ts","sourceRoot":"","sources":["../../src/screen-grid-layer/screen-grid-layer.ts"],"names":[],"mappings":"AAoBA,OAAO,EACL,QAAQ,EACR,KAAK,EACL,oBAAoB,EACpB,KAAK,EACL,YAAY,EACZ,UAAU,EAEV,WAAW,EACX,QAAQ,EACR,gBAAgB,EAChB,YAAY,EACb,MAAM,eAAe,CAAC;AACvB,OAAO,KAAK,EAAC,MAAM,EAAE,OAAO,EAAC,MAAM,eAAe,CAAC;AAInD,OAAO,oBAAoB,EAAE,EAAC,yBAAyB,EAAC,qCAAkC;AAuB1F,mDAAmD;AACnD,MAAM,MAAM,oBAAoB,CAAC,KAAK,GAAG,OAAO,IAAI,qBAAqB,CAAC,KAAK,CAAC,GAC9E,yBAAyB,CAAC,KAAK,CAAC,CAAC;AAEnC,2CAA2C;AAC3C,MAAM,MAAM,qBAAqB,CAAC,KAAK,IAAI;IACzC;;;OAGG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;IAExB;;;OAGG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAE1B;;;;OAIG;IACH,QAAQ,CAAC,EAAE,KAAK,GAAG,IAAI,CAAC;IAExB;;;;OAIG;IACH,QAAQ,CAAC,EAAE,KAAK,GAAG,IAAI,CAAC;IAExB;;;OAGG;IACH,WAAW,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI,CAAC;IAEtC;;;;OAIG;IACH,UAAU,CAAC,EAAE,KAAK,EAAE,CAAC;IAErB;;;;OAIG;IACH,WAAW,CAAC,EAAE,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC;IAExC;;;;OAIG;IACH,SAAS,CAAC,EAAE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;IAEpC;;;;OAIG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;IAEzB;;;;;;OAMG;IACH,WAAW,CAAC,EAAE,KAAK,GAAG,MAAM,GAAG,KAAK,GAAG,KAAK,CAAC;CAC9C,CAAC;AAEF,sEAAsE;AACtE,MAAM,CAAC,OAAO,OAAO,eAAe,CAClC,KAAK,GAAG,GAAG,EACX,UAAU,SAAS,EAAE,GAAG,EAAE,CAC1B,SAAQ,oBAAoB,CAAC,KAAK,EAAE,UAAU,GAAG,QAAQ,CAAC,qBAAqB,CAAC,KAAK,CAAC,CAAC,CAAC;IACxF,MAAM,CAAC,SAAS,SAAqB;IACrC,MAAM,CAAC,YAAY,8CAAgB;IAEnC,KAAK,EAAG,oBAAoB,CAAC,KAAK,CAAC,CAAC,OAAO,CAAC,GAAG;QAC7C,SAAS,EAAE,OAAO,CAAC;QACnB,iBAAiB,CAAC,EAAE,GAAG,CAAC;QACxB,cAAc,CAAC,EAAE,GAAG,CAAC;QACrB,OAAO,CAAC,EAAE,GAAG,CAAC;QACd,UAAU,CAAC,EAAE,OAAO,CAAC;QACrB,iBAAiB,CAAC,EAAE,MAAM,CAAC;QAC3B,SAAS,CAAC,EAAE,MAAM,CAAC;KACpB,CAAC;IAEF,eAAe;IAqCf,iBAAiB,CAAC,EAAC,WAAW,EAAC,EAAE,gBAAgB,CAAC,IAAI,CAAC;IAIvD,WAAW,CAAC,IAAI,EAAE,gBAAgB,CAAC,IAAI,CAAC;IAIxC,YAAY,IAAI,UAAU,GAAG,KAAK;IAuBlC,aAAa,CAAC,OAAO,EAAE,YAAY,GAAG,IAAI;IAU1C,cAAc,CAAC,EAAC,IAAI,EAAC,EAAE,oBAAoB,GAAG,WAAW;IAsBzD,aAAa,CAAC,EAAC,eAAe,EAAE,OAAO,EAAC;;;KAAA;IASxC,sBAAsB,CAAC,IAAI,KAAA;IAiE3B,gBAAgB,CAAC,IAAI,KAAA;IAUrB,aAAa;CAMd"}

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

@@ -0,0 +1,209 @@
+// 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 { log } from '@deck.gl/core';
+import GPUGridAggregator from "../utils/gpu-grid-aggregation/gpu-grid-aggregator.js";
+import { AGGREGATION_OPERATION, getValueFunc } from "../utils/aggregation-operation-utils.js";
+import ScreenGridCellLayer from "./screen-grid-cell-layer.js";
+import GridAggregationLayer from "../grid-aggregation-layer.js";
+import { getFloatTexture } from "../utils/resource-utils.js";
+const defaultProps = {
+    ...ScreenGridCellLayer.defaultProps,
+    getPosition: { type: 'accessor', value: (d) => d.position },
+    getWeight: { type: 'accessor', value: 1 },
+    gpuAggregation: false, // TODO(v9): Re-enable GPU aggregation.
+    aggregation: 'SUM'
+};
+const POSITION_ATTRIBUTE_NAME = 'positions';
+const DIMENSIONS = {
+    data: {
+        props: ['cellSizePixels']
+    },
+    weights: {
+        props: ['aggregation'],
+        accessors: ['getWeight']
+    }
+};
+/** Aggregates data into histogram bins and renders them as a grid. */
+export default class ScreenGridLayer extends GridAggregationLayer {
+    static { this.layerName = 'ScreenGridLayer'; }
+    static { this.defaultProps = defaultProps; }
+    initializeState() {
+        super.initializeAggregationLayer({
+            dimensions: DIMENSIONS,
+            // @ts-expect-error
+            getCellSize: props => props.cellSizePixels // TODO
+        });
+        const weights = {
+            count: {
+                size: 1,
+                operation: AGGREGATION_OPERATION.SUM,
+                needMax: true,
+                maxTexture: getFloatTexture(this.context.device, { id: `${this.id}-max-texture` })
+            }
+        };
+        this.setState({
+            supported: true,
+            projectPoints: true, // aggregation in screen space
+            weights,
+            subLayerData: { attributes: {} },
+            maxTexture: weights.count.maxTexture,
+            positionAttributeName: 'positions',
+            posOffset: [0, 0],
+            translation: [1, -1]
+        });
+        const attributeManager = this.getAttributeManager();
+        attributeManager.add({
+            [POSITION_ATTRIBUTE_NAME]: {
+                size: 3,
+                accessor: 'getPosition',
+                type: 'float64',
+                fp64: this.use64bitPositions()
+            },
+            // this attribute is used in gpu aggregation path only
+            count: { size: 3, accessor: 'getWeight' }
+        });
+    }
+    shouldUpdateState({ changeFlags }) {
+        return this.state.supported && changeFlags.somethingChanged;
+    }
+    updateState(opts) {
+        super.updateState(opts);
+    }
+    renderLayers() {
+        if (!this.state.supported) {
+            return [];
+        }
+        const { maxTexture, numRow, numCol, weights } = this.state;
+        const { updateTriggers } = this.props;
+        const { aggregationBuffer } = weights.count;
+        const CellLayerClass = this.getSubLayerClass('cells', ScreenGridCellLayer);
+        return new CellLayerClass(this.props, this.getSubLayerProps({
+            id: 'cell-layer',
+            updateTriggers
+        }), {
+            data: { attributes: { instanceCounts: aggregationBuffer } },
+            maxTexture,
+            numInstances: numRow * numCol
+        });
+    }
+    finalizeState(context) {
+        super.finalizeState(context);
+        const { aggregationBuffer, maxBuffer, maxTexture } = this.state;
+        aggregationBuffer?.delete();
+        maxBuffer?.delete();
+        maxTexture?.delete();
+    }
+    getPickingInfo({ info }) {
+        const { index } = info;
+        if (index >= 0) {
+            const { gpuGridAggregator, gpuAggregation, weights } = this.state;
+            // Get count aggregation results
+            const aggregationResults = gpuAggregation
+                ? gpuGridAggregator.getData('count')
+                : weights.count;
+            // Each instance (one cell) is aggregated into single pixel,
+            // Get current instance's aggregation details.
+            info.object = GPUGridAggregator.getAggregationData({
+                pixelIndex: index,
+                ...aggregationResults
+            });
+        }
+        return info;
+    }
+    // Aggregation Overrides
+    updateResults({ aggregationData, maxData }) {
+        const { count } = this.state.weights;
+        count.aggregationData = aggregationData;
+        count.aggregationBuffer.write(aggregationData);
+        count.maxData = maxData;
+        count.maxTexture.setImageData({ data: maxData });
+    }
+    /* eslint-disable complexity, max-statements */
+    updateAggregationState(opts) {
+        const cellSize = opts.props.cellSizePixels;
+        const cellSizeChanged = opts.oldProps.cellSizePixels !== cellSize;
+        const { viewportChanged } = opts.changeFlags;
+        let gpuAggregation = opts.props.gpuAggregation;
+        if (this.state.gpuAggregation !== opts.props.gpuAggregation) {
+            if (gpuAggregation && !GPUGridAggregator.isSupported(this.context.device)) {
+                log.warn('GPU Grid Aggregation not supported, falling back to CPU')();
+                gpuAggregation = false;
+            }
+        }
+        const gpuAggregationChanged = gpuAggregation !== this.state.gpuAggregation;
+        this.setState({
+            gpuAggregation
+        });
+        const positionsChanged = this.isAttributeChanged(POSITION_ATTRIBUTE_NAME);
+        const { dimensions } = this.state;
+        const { data, weights } = dimensions;
+        const aggregationDataDirty = positionsChanged ||
+            gpuAggregationChanged ||
+            viewportChanged ||
+            this.isAggregationDirty(opts, {
+                compareAll: gpuAggregation, // check for all (including extentions props) when using gpu aggregation
+                dimension: data
+            });
+        const aggregationWeightsDirty = this.isAggregationDirty(opts, { dimension: weights });
+        this.setState({
+            aggregationDataDirty,
+            aggregationWeightsDirty
+        });
+        const { viewport } = this.context;
+        if (viewportChanged || cellSizeChanged) {
+            const { width, height } = viewport;
+            const numCol = Math.ceil(width / cellSize);
+            const numRow = Math.ceil(height / cellSize);
+            this.allocateResources(numRow, numCol);
+            this.setState({
+                // transformation from clipspace to screen(pixel) space
+                scaling: [width / 2, -height / 2, 1],
+                gridOffset: { xOffset: cellSize, yOffset: cellSize },
+                width,
+                height,
+                numCol,
+                numRow
+            });
+        }
+        if (aggregationWeightsDirty) {
+            this._updateAccessors(opts);
+        }
+        if (aggregationDataDirty || aggregationWeightsDirty) {
+            this._resetResults();
+        }
+    }
+    /* eslint-enable complexity, max-statements */
+    // Private
+    _updateAccessors(opts) {
+        const { getWeight, aggregation, data } = opts.props;
+        const { count } = this.state.weights;
+        if (count) {
+            count.getWeight = getWeight;
+            count.operation = AGGREGATION_OPERATION[aggregation];
+        }
+        this.setState({ getValue: getValueFunc(aggregation, getWeight, { data }) });
+    }
+    _resetResults() {
+        const { count } = this.state.weights;
+        if (count) {
+            count.aggregationData = null;
+        }
+    }
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};