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

package/src/hexagon-layer/hexbin.ts

@@ -0,0 +1,79 @@
+// deck.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+const THIRD_PI = Math.PI / 3;
+const DIST_X = 2 * Math.sin(THIRD_PI);
+const DIST_Y = 1.5;
+
+type HexBin = [i: number, j: number];
+type Point = [x: number, y: number];
+
+export const HexbinVertices = Array.from({length: 6}, (_, i) => {
+  const angle = i * THIRD_PI;
+  return [Math.sin(angle), -Math.cos(angle)];
+});
+
+/**
+ * Adapted from d3-hexbin
+ * Copyright Mike Bostock, 2012-2016
+   All rights reserved.
+ * https://github.com/d3/d3-hexbin/blob/master/src/hexbin.js
+ *
+ * Returns the hexbin that a point (x,y) falls into
+ */
+export function pointToHexbin([px, py]: Point, radius: number): HexBin {
+  let pj = Math.round((py = py / radius / DIST_Y));
+  let pi = Math.round((px = px / radius / DIST_X - (pj & 1) / 2));
+  const py1 = py - pj;
+
+  if (Math.abs(py1) * 3 > 1) {
+    const px1 = px - pi;
+    const pi2 = pi + (px < pi ? -1 : 1) / 2;
+    const pj2 = pj + (py < pj ? -1 : 1);
+    const px2 = px - pi2;
+    const py2 = py - pj2;
+    if (px1 * px1 + py1 * py1 > px2 * px2 + py2 * py2) {
+      pi = pi2 + (pj & 1 ? 1 : -1) / 2;
+      pj = pj2;
+    }
+  }
+  return [pi, pj];
+}
+
+export const pointToHexbinGLSL = /* glsl */ `
+const vec2 DIST = vec2(${DIST_X}, ${DIST_Y});
+
+ivec2 pointToHexbin(vec2 p, float radius) {
+  p /= radius * DIST;
+  float pj = round(p.y);
+  float pjm2 = mod(pj, 2.0);
+  p.x -= pjm2 * 0.5;
+  float pi = round(p.x);
+  vec2 d1 = p - vec2(pi, pj);
+
+  if (abs(d1.y) * 3. > 1.) {
+    vec2 v2 = step(0.0, d1) - 0.5;
+    v2.y *= 2.0;
+    vec2 d2 = d1 - v2;
+    if (dot(d1, d1) > dot(d2, d2)) {
+      pi += v2.x + pjm2 - 0.5;
+      pj += v2.y;
+    }
+  }
+  return ivec2(pi, pj);
+}
+`;
+
+export function getHexbinCentroid([i, j]: HexBin, radius: number): Point {
+  return [(i + (j & 1) / 2) * radius * DIST_X, j * radius * DIST_Y];
+}
+
+export const getHexbinCentroidGLSL = `
+const vec2 DIST = vec2(${DIST_X}, ${DIST_Y});
+
+vec2 hexbinCentroid(vec2 binId, float radius) {
+  binId.x += fract(binId.y * 0.5);
+  return binId * DIST * radius;
+}
+`;

package/src/index.ts

@@ -1,43 +1,30 @@
-// 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
 
 export {default as ScreenGridLayer} from './screen-grid-layer/screen-grid-layer';
-export {default as CPUGridLayer} from './cpu-grid-layer/cpu-grid-layer';
 export {default as HexagonLayer} from './hexagon-layer/hexagon-layer';
 export {default as ContourLayer} from './contour-layer/contour-layer';
 export {default as GridLayer} from './grid-layer/grid-layer';
-export {default as GPUGridLayer} from './gpu-grid-layer/gpu-grid-layer';
-export {AGGREGATION_OPERATION} from './utils/aggregation-operation-utils';
-
-// experimental export
 export {default as HeatmapLayer} from './heatmap-layer/heatmap-layer';
-export {default as _GPUGridAggregator} from './utils/gpu-grid-aggregation/gpu-grid-aggregator';
-export {default as _CPUAggregator} from './utils/cpu-aggregator';
-export {default as _AggregationLayer} from './aggregation-layer';
-export {default as _BinSorter} from './utils/bin-sorter';
+
+export {default as _AggregationLayer} from './common/aggregation-layer';
+export {WebGLAggregator, CPUAggregator} from './common/aggregator/index';
 
 // types
-export type {ContourLayerProps} from './contour-layer/contour-layer';
+export type {ContourLayerProps, ContourLayerPickingInfo} from './contour-layer/contour-layer';
 export type {HeatmapLayerProps} from './heatmap-layer/heatmap-layer';
-export type {HexagonLayerProps} from './hexagon-layer/hexagon-layer';
-export type {CPUGridLayerProps} from './cpu-grid-layer/cpu-grid-layer';
-export type {GridLayerProps} from './grid-layer/grid-layer';
-export type {GPUGridLayerProps} from './gpu-grid-layer/gpu-grid-layer';
-export type {ScreenGridLayerProps} from './screen-grid-layer/screen-grid-layer';
+export type {HexagonLayerProps, HexagonLayerPickingInfo} from './hexagon-layer/hexagon-layer';
+export type {GridLayerProps, GridLayerPickingInfo} from './grid-layer/grid-layer';
+export type {
+  ScreenGridLayerProps,
+  ScreenGridLayerPickingInfo
+} from './screen-grid-layer/screen-grid-layer';
+
+export type {
+  Aggregator,
+  AggregationOperation,
+  AggregationProps,
+  WebGLAggregatorProps,
+  CPUAggregatorProps
+} from './common/aggregator/index';

package/src/screen-grid-layer/bin-options-uniforms.ts

@@ -0,0 +1,23 @@
+// deck.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import type {ShaderModule} from '@luma.gl/shadertools';
+
+const uniformBlock = /* glsl */ `\
+uniform binOptionsUniforms {
+  float cellSizePixels;
+} binOptions;
+`;
+
+export type BinOptions = {
+  cellSizePixels: number;
+};
+
+export const binOptionsUniforms = {
+  name: 'binOptions',
+  vs: uniformBlock,
+  uniformTypes: {
+    cellSizePixels: 'f32'
+  }
+} as const satisfies ShaderModule<BinOptions>;

package/src/screen-grid-layer/screen-grid-cell-layer.ts

@@ -1,142 +1,106 @@
-// 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.
+// deck.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
 
 import {Texture} from '@luma.gl/core';
 import {Model, Geometry} from '@luma.gl/engine';
-import {Layer, LayerProps, log, picking, UpdateParameters, DefaultProps} from '@deck.gl/core';
-import {defaultColorRange, colorRangeToFlatArray} from '../utils/color-utils';
+import {Layer, picking, UpdateParameters, DefaultProps, Color} from '@deck.gl/core';
+import {createColorRangeTexture, updateColorRangeTexture} from '../common/utils/color-utils';
 import vs from './screen-grid-layer-vertex.glsl';
 import fs from './screen-grid-layer-fragment.glsl';
-import type {_ScreenGridLayerProps} from './screen-grid-layer';
+import {ScreenGridProps, screenGridUniforms} from './screen-grid-layer-uniforms';
 import {ShaderModule} from '@luma.gl/shadertools';
-
-const DEFAULT_MINCOLOR = [0, 0, 0, 0];
-const DEFAULT_MAXCOLOR = [0, 255, 0, 255];
-const COLOR_PROPS = ['minColor', 'maxColor', 'colorRange', 'colorDomain'];
-
-const defaultProps: DefaultProps<ScreenGridCellLayerProps> = {
-  cellSizePixels: {type: 'number', value: 100, min: 1},
-  cellMarginPixels: {type: 'number', value: 2, min: 0, max: 5},
-
-  colorDomain: null,
-  colorRange: defaultColorRange
-};
-
-/** All properties supported by ScreenGridCellLayer. */
-export type ScreenGridCellLayerProps<DataT = unknown> = _ScreenGridCellLayerProps<DataT> &
-  LayerProps;
+import type {ScaleType} from '../common/types';
 
 /** Proprties added by ScreenGridCellLayer. */
-export type _ScreenGridCellLayerProps<DataT> = _ScreenGridLayerProps<DataT> & {
-  maxTexture: Texture;
+export type _ScreenGridCellLayerProps = {
+  cellSizePixels: number;
+  cellMarginPixels: number;
+  colorScaleType: ScaleType;
+  colorDomain: () => [number, number];
+  colorRange?: Color[];
 };
 
-export default class ScreenGridCellLayer<DataT = any, ExtraPropsT extends {} = {}> extends Layer<
-  ExtraPropsT & Required<_ScreenGridCellLayerProps<DataT>>
+export default class ScreenGridCellLayer<ExtraPropsT extends {} = {}> extends Layer<
+  ExtraPropsT & Required<_ScreenGridCellLayerProps>
 > {
   static layerName = 'ScreenGridCellLayer';
-  static defaultProps = defaultProps;
 
   state!: {
     model?: Model;
+    colorTexture: Texture;
   };
 
   getShaders(): {vs: string; fs: string; modules: ShaderModule[]} {
-    return {vs, fs, modules: [picking as ShaderModule]};
+    return super.getShaders({vs, fs, modules: [picking, screenGridUniforms]});
   }
 
   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()
+    this.getAttributeManager()!.addInstanced({
+      instancePositions: {
+        size: 2,
+        type: 'float32',
+        accessor: 'getBin'
+      },
+      instanceWeights: {
+        size: 1,
+        type: 'float32',
+        accessor: 'getWeight'
+      }
     });
-  }
 
-  shouldUpdateState({changeFlags}) {
-    // 'instanceCounts' buffer contetns change on viewport change.
-    return changeFlags.somethingChanged;
+    this.state.model = this._getModel();
   }
 
   updateState(params: UpdateParameters<this>) {
     super.updateState(params);
 
-    const {oldProps, props, changeFlags} = params;
+    const {props, oldProps, changeFlags} = params;
+    const model = this.state.model!;
 
-    const attributeManager = this.getAttributeManager()!;
-    if (props.numInstances !== oldProps.numInstances) {
-      attributeManager.invalidateAll();
-    } else if (oldProps.cellSizePixels !== props.cellSizePixels) {
-      attributeManager.invalidate('instancePositions');
+    if (oldProps.colorRange !== props.colorRange) {
+      this.state.colorTexture?.destroy();
+      this.state.colorTexture = createColorRangeTexture(
+        this.context.device,
+        props.colorRange,
+        props.colorScaleType
+      );
+      const screenGridProps: Partial<ScreenGridProps> = {colorRange: this.state.colorTexture};
+      model.shaderInputs.setProps({screenGrid: screenGridProps});
+    } else if (oldProps.colorScaleType !== props.colorScaleType) {
+      updateColorRangeTexture(this.state.colorTexture, props.colorScaleType);
     }
 
-    this._updateUniforms(oldProps, props, changeFlags);
+    if (
+      oldProps.cellMarginPixels !== props.cellMarginPixels ||
+      oldProps.cellSizePixels !== props.cellSizePixels ||
+      changeFlags.viewportChanged
+    ) {
+      const {width, height} = this.context.viewport;
+      const {cellSizePixels: gridSize, cellMarginPixels} = this.props;
+      const cellSize = Math.max(gridSize - cellMarginPixels, 0);
+
+      const screenGridProps: Partial<ScreenGridProps> = {
+        gridSizeClipspace: [(gridSize / width) * 2, (gridSize / height) * 2],
+        cellSizeClipspace: [(cellSize / width) * 2, (cellSize / height) * 2]
+      };
+      model.shaderInputs.setProps({screenGrid: screenGridProps});
+    }
   }
 
-  draw({uniforms}) {
-    const {parameters, maxTexture} = this.props;
-    const minColor = this.props.minColor || DEFAULT_MINCOLOR;
-    const maxColor = this.props.maxColor || DEFAULT_MAXCOLOR;
+  finalizeState(context) {
+    super.finalizeState(context);
 
-    // 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({
-      // @ts-expect-error stricter luma gl types
-      minColor,
-      // @ts-expect-error stricter luma gl types
-      maxColor,
-      colorDomain
-    });
-    model.setParameters({
-      depthWriteEnabled: false,
-      // How to specify depth mask in WebGPU?
-      // depthMask: false,
-      ...parameters
-    });
-    model.draw(this.context.renderPass);
+    this.state.colorTexture?.destroy();
   }
 
-  calculateInstancePositions(attribute, {numInstances}) {
-    const {width, height} = this.context.viewport;
-    const {cellSizePixels} = this.props;
-    const numCol = Math.ceil(width / cellSizePixels);
-
-    const {value, size} = attribute;
+  draw({uniforms}) {
+    const colorDomain = this.props.colorDomain();
+    const model = this.state.model!;
 
-    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;
-    }
+    const screenGridProps: Partial<ScreenGridProps> = {colorDomain};
+    model.shaderInputs.setProps({screenGrid: screenGridProps});
+    model.draw(this.context.renderPass);
   }
 
   // Private Methods
@@ -147,64 +111,15 @@ export default class ScreenGridCellLayer<DataT = any, ExtraPropsT extends {} = {
       id: this.props.id,
       bufferLayout: this.getAttributeManager()!.getBufferLayouts(),
       geometry: new Geometry({
-        topology: 'triangle-list',
+        topology: 'triangle-strip',
         attributes: {
-          // prettier-ignore
-          positions: new Float32Array([
-            0, 0, 0,
-            1, 0, 0,
-            1, 1, 0,
-            0, 0, 0,
-            1, 1, 0,
-            0, 1, 0,
-          ])
+          positions: {
+            value: new Float32Array([0, 0, 1, 0, 0, 1, 1, 1]),
+            size: 2
+          }
         }
       }),
       isInstanced: true
     });
   }
-
-  _shouldUseMinMax(): boolean {
-    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): void {
-    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
-      ]);
-      // @ts-expect-error stricter luma gl types
-      model.setUniforms({cellScale});
-    }
-  }
 }

package/src/screen-grid-layer/screen-grid-layer-fragment.glsl.ts

@@ -1,39 +1,19 @@
-// 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
 
 /* fragment shader for the grid-layer */
-export default `\
+export default /* glsl */ `\
 #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/src/screen-grid-layer/screen-grid-layer-uniforms.ts

@@ -0,0 +1,31 @@
+// deck.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import {Texture} from '@luma.gl/core';
+import type {ShaderModule} from '@luma.gl/shadertools';
+
+const uniformBlock = /* glsl */ `\
+uniform screenGridUniforms {
+  vec2 cellSizeClipspace;
+  vec2 gridSizeClipspace;
+  vec2 colorDomain;
+} screenGrid;
+`;
+
+export type ScreenGridProps = {
+  cellSizeClipspace: [number, number];
+  gridSizeClipspace: [number, number];
+  colorDomain: [number, number];
+  colorRange: Texture;
+};
+
+export const screenGridUniforms = {
+  name: 'screenGrid',
+  vs: uniformBlock,
+  uniformTypes: {
+    cellSizeClipspace: 'vec2<f32>',
+    gridSizeClipspace: 'vec2<f32>',
+    colorDomain: 'vec2<f32>'
+  }
+} as const satisfies ShaderModule<ScreenGridProps>;

package/src/screen-grid-layer/screen-grid-layer-vertex.glsl.ts

@@ -1,85 +1,42 @@
-// 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
 
-export default `\
+export default /* glsl */ `\
 #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 vec2 positions;
+in vec2 instancePositions;
+in float instanceWeights;
 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;
+uniform sampler2D colorRange;
 
 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;
+vec4 interp(float value, vec2 domain, sampler2D range) {
+  float r = (value - domain.x) / (domain.y - domain.x);
+  return texture(range, vec2(r, 0.5));
 }
 
 void main(void) {
-  vSampleCount = instanceCounts.a;
-
-  float weight = instanceCounts.r;
-  float maxWeight = texture(maxTexture, vec2(0.5)).r;
+  if (isnan(instanceWeights)) {
+    gl_Position = vec4(0.);
+    return;
+  }
 
-  float step = weight / maxWeight;
-  vec4 minMaxColor = mix(minColor, maxColor, step) / 255.;
+  vec2 pos = instancePositions * screenGrid.gridSizeClipspace + positions * screenGrid.cellSizeClipspace;
+  pos.x = pos.x - 1.0;
+  pos.y = 1.0 - pos.y;
 
-  vec2 domain = colorDomain;
-  float domainMaxValid = float(colorDomain.y != 0.);
-  domain.y = mix(maxWeight, colorDomain.y, domainMaxValid);
-  vec4 rangeColor = quantizeScale(domain, colorRange, weight);
+  gl_Position = vec4(pos, 0., 1.);
 
-  float rangeMinMax = float(shouldUseMinMax);
-  vec4 color = mix(rangeColor, minMaxColor, rangeMinMax);
-  vColor = vec4(color.rgb, color.a * opacity);
+  vColor = interp(instanceWeights, screenGrid.colorDomain, colorRange);
+  vColor.a *= layer.opacity;
 
   // Set color to be rendered to picking fbo (also used to check for selection highlight).
   picking_setPickingColor(instancePickingColors);
-
-  gl_Position = vec4(instancePositions + positions * cellScale, 1.);
 }
 `;