@deck.gl/aggregation-layers 9.0.40 → 9.1.0-beta.3

package/src/hexagon-layer/hexagon-cell-layer-vertex.glsl.ts

@@ -0,0 +1,73 @@
+// deck.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import {getHexbinCentroidGLSL} from './hexbin';
+
+export default /* glsl */ `\
+#version 300 es
+#define SHADER_NAME hexagon-cell-layer-vertex-shader
+
+in vec3 positions;
+in vec3 normals;
+
+in vec2 instancePositions;
+in float instanceElevationValues;
+in float instanceColorValues;
+in vec3 instancePickingColors;
+
+uniform sampler2D colorRange;
+
+// Result
+out vec4 vColor;
+
+${getHexbinCentroidGLSL}
+
+float interp(float value, vec2 domain, vec2 range) {
+  float r = min(max((value - domain.x) / (domain.y - domain.x), 0.), 1.);
+  return mix(range.x, range.y, r);
+}
+
+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) {
+  geometry.pickingColor = instancePickingColors;
+
+  if (isnan(instanceColorValues) ||
+    instanceColorValues < hexagon.colorDomain.z ||
+    instanceColorValues > hexagon.colorDomain.w ||
+    instanceElevationValues < hexagon.elevationDomain.z ||
+    instanceElevationValues > hexagon.elevationDomain.w
+  ) {
+    gl_Position = vec4(0.);
+    return;
+  }
+  
+  vec2 commonPosition = hexbinCentroid(instancePositions, column.radius) + (hexagon.originCommon - project.commonOrigin.xy);
+  commonPosition += positions.xy * column.radius * column.coverage;
+  geometry.position = vec4(commonPosition, 0.0, 1.0);
+  geometry.normal = project_normal(normals);
+
+  // calculate z, if 3d not enabled set to 0
+  float elevation = 0.0;
+  if (column.extruded) {
+    elevation = interp(instanceElevationValues, hexagon.elevationDomain.xy, hexagon.elevationRange);
+    elevation = project_size(elevation);
+    // cylindar gemoetry height are between -1.0 to 1.0, transform it to between 0, 1
+    geometry.position.z = (positions.z + 1.0) / 2.0 * elevation;
+  }
+
+  gl_Position = project_common_position_to_clipspace(geometry.position);
+  DECKGL_FILTER_GL_POSITION(gl_Position, geometry);
+
+  vColor = interp(instanceColorValues, hexagon.colorDomain.xy, colorRange);
+  vColor.a *= layer.opacity;
+  if (column.extruded) {
+    vColor.rgb = lighting_getLightColor(vColor.rgb, project.cameraPosition, geometry.position.xyz, geometry.normal);
+  }
+  DECKGL_FILTER_COLOR(vColor, geometry);
+}
+`;

package/src/hexagon-layer/hexagon-cell-layer.ts

@@ -0,0 +1,141 @@
+// deck.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import {Texture} from '@luma.gl/core';
+import {UpdateParameters, Color} from '@deck.gl/core';
+import {ColumnLayer} from '@deck.gl/layers';
+import {createColorRangeTexture, updateColorRangeTexture} from '../common/utils/color-utils';
+import vs from './hexagon-cell-layer-vertex.glsl';
+import {HexagonProps, hexagonUniforms} from './hexagon-layer-uniforms';
+import type {ScaleType} from '../common/types';
+
+/** Proprties added by HexagonCellLayer. */
+export type _HexagonCellLayerProps = {
+  hexOriginCommon: [number, number];
+  colorDomain: [number, number];
+  colorCutoff: [number, number] | null;
+  colorRange: Color[];
+  colorScaleType: ScaleType;
+  elevationDomain: [number, number];
+  elevationCutoff: [number, number] | null;
+  elevationRange: [number, number];
+};
+
+export default class HexagonCellLayer<ExtraPropsT extends {} = {}> extends ColumnLayer<
+  null,
+  ExtraPropsT & Required<_HexagonCellLayerProps>
+> {
+  static layerName = 'HexagonCellLayer';
+
+  state!: ColumnLayer['state'] & {
+    colorTexture: Texture;
+  };
+
+  getShaders() {
+    const shaders = super.getShaders();
+    shaders.modules.push(hexagonUniforms);
+    return {...shaders, vs};
+  }
+
+  initializeState() {
+    super.initializeState();
+
+    const attributeManager = this.getAttributeManager()!;
+    attributeManager.remove([
+      'instanceElevations',
+      'instanceFillColors',
+      'instanceLineColors',
+      'instanceStrokeWidths'
+    ]);
+    attributeManager.addInstanced({
+      instancePositions: {
+        size: 2,
+        type: 'float32',
+        accessor: 'getBin'
+      },
+      instanceColorValues: {
+        size: 1,
+        type: 'float32',
+        accessor: 'getColorValue'
+      },
+      instanceElevationValues: {
+        size: 1,
+        type: 'float32',
+        accessor: 'getElevationValue'
+      }
+    });
+  }
+
+  updateState(params: UpdateParameters<this>) {
+    super.updateState(params);
+
+    const {props, oldProps} = params;
+    const model = this.state.fillModel!;
+
+    if (oldProps.colorRange !== props.colorRange) {
+      this.state.colorTexture?.destroy();
+      this.state.colorTexture = createColorRangeTexture(
+        this.context.device,
+        props.colorRange,
+        props.colorScaleType
+      );
+      const hexagonProps: Partial<HexagonProps> = {colorRange: this.state.colorTexture};
+      model.shaderInputs.setProps({hexagon: hexagonProps});
+    } else if (oldProps.colorScaleType !== props.colorScaleType) {
+      updateColorRangeTexture(this.state.colorTexture, props.colorScaleType);
+    }
+  }
+
+  finalizeState(context) {
+    super.finalizeState(context);
+
+    this.state.colorTexture?.destroy();
+  }
+
+  draw({uniforms}) {
+    const {
+      radius,
+      hexOriginCommon,
+      elevationRange,
+      elevationScale,
+      extruded,
+      coverage,
+      colorDomain,
+      elevationDomain
+    } = this.props;
+    const colorCutoff = this.props.colorCutoff || [-Infinity, Infinity];
+    const elevationCutoff = this.props.elevationCutoff || [-Infinity, Infinity];
+    const fillModel = this.state.fillModel!;
+
+    if (fillModel.vertexArray.indexBuffer) {
+      // indices are for drawing wireframe, disable them
+      // TODO - this should be handled in ColumnLayer?
+      fillModel.setIndexBuffer(null);
+    }
+    fillModel.setVertexCount(this.state.fillVertexCount);
+
+    const hexagonProps: Omit<HexagonProps, 'colorRange'> = {
+      colorDomain: [
+        Math.max(colorDomain[0], colorCutoff[0]), // instanceColorValue that maps to colorRange[0]
+        Math.min(colorDomain[1], colorCutoff[1]), // instanceColorValue that maps to colorRange[colorRange.length - 1]
+        Math.max(colorDomain[0] - 1, colorCutoff[0]), // hide cell if instanceColorValue is less than this
+        Math.min(colorDomain[1] + 1, colorCutoff[1]) // hide cell if instanceColorValue is greater than this
+      ],
+      elevationDomain: [
+        Math.max(elevationDomain[0], elevationCutoff[0]), // instanceElevationValue that maps to elevationRange[0]
+        Math.min(elevationDomain[1], elevationCutoff[1]), // instanceElevationValue that maps to elevationRange[elevationRange.length - 1]
+        Math.max(elevationDomain[0] - 1, elevationCutoff[0]), // hide cell if instanceElevationValue is less than this
+        Math.min(elevationDomain[1] + 1, elevationCutoff[1]) // hide cell if instanceElevationValue is greater than this
+      ],
+      elevationRange: [elevationRange[0] * elevationScale, elevationRange[1] * elevationScale],
+      originCommon: hexOriginCommon
+    };
+
+    fillModel.shaderInputs.setProps({
+      column: {extruded, coverage, radius},
+      hexagon: hexagonProps
+    });
+    fillModel.draw(this.context.renderPass);
+  }
+}

package/src/hexagon-layer/hexagon-layer-uniforms.ts

@@ -0,0 +1,34 @@
+// 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 hexagonUniforms {
+  vec4 colorDomain;
+  vec4 elevationDomain;
+  vec2 elevationRange;
+  vec2 originCommon;
+} hexagon;
+`;
+
+export type HexagonProps = {
+  colorDomain: [number, number, number, number];
+  colorRange: Texture;
+  elevationDomain: [number, number, number, number];
+  elevationRange: [number, number];
+  originCommon: [number, number];
+};
+
+export const hexagonUniforms = {
+  name: 'hexagon',
+  vs: uniformBlock,
+  uniformTypes: {
+    colorDomain: 'vec4<f32>',
+    elevationDomain: 'vec4<f32>',
+    elevationRange: 'vec2<f32>',
+    originCommon: 'vec2<f32>'
+  }
+} as const satisfies ShaderModule<HexagonProps>;