@deck.gl/aggregation-layers 9.0.0-beta.5 → 9.0.0-beta.6

package/dist/index.cjs

@@ -37,7 +37,6 @@ module.exports = __toCommonJS(dist_exports);
 
 // dist/screen-grid-layer/screen-grid-layer.js
 var import_core8 = require("@deck.gl/core");
-var import_constants4 = require("@luma.gl/constants");
 
 // dist/utils/gpu-grid-aggregation/gpu-grid-aggregator.js
 var import_engine = require("@luma.gl/engine");
@@ -132,12 +131,12 @@ var DEFAULT_RUN_PARAMS = {
   moduleSettings: {}
 };
 var MAX_32_BIT_FLOAT = 3402823466e29;
-var MIN_BLEND_EQUATION = [import_constants.GL.MIN, import_constants.GL.FUNC_ADD];
-var MAX_BLEND_EQUATION = [import_constants.GL.MAX, import_constants.GL.FUNC_ADD];
-var MAX_MIN_BLEND_EQUATION = [import_constants.GL.MAX, import_constants.GL.MIN];
+var MIN_BLEND_EQUATION = [32775, 32774];
+var MAX_BLEND_EQUATION = [32776, 32774];
+var MAX_MIN_BLEND_EQUATION = [32776, 32775];
 var EQUATION_MAP = {
-  [AGGREGATION_OPERATION.SUM]: import_constants.GL.FUNC_ADD,
-  [AGGREGATION_OPERATION.MEAN]: import_constants.GL.FUNC_ADD,
+  [AGGREGATION_OPERATION.SUM]: 32774,
+  [AGGREGATION_OPERATION.MEAN]: 32774,
   [AGGREGATION_OPERATION.MIN]: MIN_BLEND_EQUATION,
   [AGGREGATION_OPERATION.MAX]: MAX_BLEND_EQUATION
 };
@@ -149,24 +148,10 @@ var DEFAULT_WEIGHT_PARAMS = {
   combineMaxMin: false
 };
 var PIXEL_SIZE = 4;
-var MAX_MIN_TEXTURE_OPTS = {
-  format: import_constants.GL.RGBA32F,
-  type: import_constants.GL.FLOAT,
-  border: 0,
-  mipmaps: false,
-  sampler: {
-    minFilter: "nearest",
-    magFilter: "nearest"
-  },
-  dataFormat: import_constants.GL.RGBA,
-  width: 1,
-  height: 1
-};
 
 // dist/utils/gpu-grid-aggregation/aggregate-to-grid-vs.glsl.js
 var aggregate_to_grid_vs_glsl_default = `#version 300 es
 #define SHADER_NAME gpu-aggregation-to-grid-vs
-
 in vec3 positions;
 in vec3 positions64Low;
 in vec3 weights;
@@ -175,123 +160,89 @@ uniform vec2 gridSize;
 uniform bool projectPoints;
 uniform vec2 translation;
 uniform vec3 scaling;
-
 out vec3 vWeights;
-
 vec2 project_to_pixel(vec4 pos) {
-  vec4 result;
-  pos.xy = pos.xy/pos.w;
-  result = pos + vec4(translation, 0., 0.);
-  result.xy = scaling.z > 0. ? result.xy * scaling.xy : result.xy;
-  return result.xy;
+vec4 result;
+pos.xy = pos.xy/pos.w;
+result = pos + vec4(translation, 0., 0.);
+result.xy = scaling.z > 0. ? result.xy * scaling.xy : result.xy;
+return result.xy;
 }
-
 void main(void) {
-
-  vWeights = weights;
-
-  vec4 windowPos = vec4(positions, 1.);
-  if (projectPoints) {
-    windowPos = project_position_to_clipspace(positions, positions64Low, vec3(0));
-  }
-
-  vec2 pos = project_to_pixel(windowPos);
-
-  vec2 pixelXY64[2];
-  pixelXY64[0] = vec2(pos.x, 0.);
-  pixelXY64[1] = vec2(pos.y, 0.);
-
-  // Transform (0,0):windowSize -> (0, 0): gridSize
-  vec2 gridXY64[2];
-  gridXY64[0] = div_fp64(pixelXY64[0], vec2(cellSize.x, 0));
-  gridXY64[1] = div_fp64(pixelXY64[1], vec2(cellSize.y, 0));
-  float x = floor(gridXY64[0].x);
-  float y = floor(gridXY64[1].x);
-  pos = vec2(x, y);
-
-  // Transform (0,0):gridSize -> (-1, -1):(1,1)
-  pos = (pos * (2., 2.) / (gridSize)) - (1., 1.);
-
-  // Move to pixel center, pixel-size in screen sapce (2/gridSize) * 0.5 => 1/gridSize
-  vec2 offset = 1.0 / gridSize;
-  pos = pos + offset;
-
-  gl_Position = vec4(pos, 0.0, 1.0);
-
-  // Enforce default value for ANGLE issue (https://bugs.chromium.org/p/angleproject/issues/detail?id=3941)
-  gl_PointSize = 1.0;
+vWeights = weights;
+vec4 windowPos = vec4(positions, 1.);
+if (projectPoints) {
+windowPos = project_position_to_clipspace(positions, positions64Low, vec3(0));
+}
+vec2 pos = project_to_pixel(windowPos);
+vec2 pixelXY64[2];
+pixelXY64[0] = vec2(pos.x, 0.);
+pixelXY64[1] = vec2(pos.y, 0.);
+vec2 gridXY64[2];
+gridXY64[0] = div_fp64(pixelXY64[0], vec2(cellSize.x, 0));
+gridXY64[1] = div_fp64(pixelXY64[1], vec2(cellSize.y, 0));
+float x = floor(gridXY64[0].x);
+float y = floor(gridXY64[1].x);
+pos = vec2(x, y);
+pos = (pos * (2., 2.) / (gridSize)) - (1., 1.);
+vec2 offset = 1.0 / gridSize;
+pos = pos + offset;
+gl_Position = vec4(pos, 0.0, 1.0);
+gl_PointSize = 1.0;
 }
 `;
 
 // dist/utils/gpu-grid-aggregation/aggregate-to-grid-fs.glsl.js
 var aggregate_to_grid_fs_glsl_default = `#version 300 es
 #define SHADER_NAME gpu-aggregation-to-grid-fs
-
 precision highp float;
-
 in vec3 vWeights;
-
 out vec4 fragColor;
-
 void main(void) {
-  fragColor = vec4(vWeights, 1.0);
-  DECKGL_FILTER_COLOR(fragColor, geometry);
+fragColor = vec4(vWeights, 1.0);
+DECKGL_FILTER_COLOR(fragColor, geometry);
 }
 `;
 
 // dist/utils/gpu-grid-aggregation/aggregate-all-vs.glsl.js
 var aggregate_all_vs_glsl_default = `#version 300 es
 #define SHADER_NAME gpu-aggregation-all-vs-64
-
 in vec2 position;
 uniform ivec2 gridSize;
 out vec2 vTextureCoord;
-
 void main(void) {
-  // Map each position to single pixel
-  vec2 pos = vec2(-1.0, -1.0);
-
-  // Move to pixel center, pixel-size in screen sapce (2/gridSize) * 0.5 => 1/gridSize
-  vec2 offset = 1.0 / vec2(gridSize);
-  pos = pos + offset;
-
-  gl_Position = vec4(pos, 0.0, 1.0);
-
-  int yIndex = gl_InstanceID / gridSize[0];
-  int xIndex = gl_InstanceID - (yIndex * gridSize[0]);
-
-  vec2 yIndexFP64 = vec2(float(yIndex), 0.);
-  vec2 xIndexFP64 = vec2(float(xIndex), 0.);
-  vec2 gridSizeYFP64 = vec2(gridSize[1], 0.);
-  vec2 gridSizeXFP64 = vec2(gridSize[0], 0.);
-
-  vec2 texCoordXFP64 = div_fp64(yIndexFP64, gridSizeYFP64);
-  vec2 texCoordYFP64 = div_fp64(xIndexFP64, gridSizeXFP64);
-
-  vTextureCoord = vec2(texCoordYFP64.x, texCoordXFP64.x);
-  // Enforce default value for ANGLE issue (https://bugs.chromium.org/p/angleproject/issues/detail?id=3941)
-  gl_PointSize = 1.0;
+vec2 pos = vec2(-1.0, -1.0);
+vec2 offset = 1.0 / vec2(gridSize);
+pos = pos + offset;
+gl_Position = vec4(pos, 0.0, 1.0);
+int yIndex = gl_InstanceID / gridSize[0];
+int xIndex = gl_InstanceID - (yIndex * gridSize[0]);
+vec2 yIndexFP64 = vec2(float(yIndex), 0.);
+vec2 xIndexFP64 = vec2(float(xIndex), 0.);
+vec2 gridSizeYFP64 = vec2(gridSize[1], 0.);
+vec2 gridSizeXFP64 = vec2(gridSize[0], 0.);
+vec2 texCoordXFP64 = div_fp64(yIndexFP64, gridSizeYFP64);
+vec2 texCoordYFP64 = div_fp64(xIndexFP64, gridSizeXFP64);
+vTextureCoord = vec2(texCoordYFP64.x, texCoordXFP64.x);
+gl_PointSize = 1.0;
 }
 `;
 
 // dist/utils/gpu-grid-aggregation/aggregate-all-fs.glsl.js
 var aggregate_all_fs_glsl_default = `#version 300 es
 #define SHADER_NAME gpu-aggregation-all-fs
-
 precision highp float;
-
 in vec2 vTextureCoord;
 uniform sampler2D uSampler;
 uniform bool combineMaxMin;
 out vec4 fragColor;
 void main(void) {
-  vec4 textureColor = texture(uSampler, vec2(vTextureCoord.s, vTextureCoord.t));
-  if (textureColor.a == 0.) {
-    discard;
-  }
-  fragColor.rgb = textureColor.rgb;
-  // if combineMinMax is true, use Alpha channel for first weights min value.
-  fragColor.a = combineMaxMin ? textureColor.r : textureColor.a;
+vec4 textureColor = texture(uSampler, vec2(vTextureCoord.s, vTextureCoord.t));
+if (textureColor.a == 0.) {
+discard;
+}
+fragColor.rgb = textureColor.rgb;
+fragColor.a = combineMaxMin ? textureColor.r : textureColor.a;
 }
 `;
 
@@ -300,17 +251,12 @@ var transform_mean_vs_glsl_default = `#version 300 es
 #define SHADER_NAME gpu-aggregation-transform-mean-vs
 in vec4 aggregationValues;
 out vec4 meanValues;
-
 void main()
 {
-  // TODO: Use 64-bit division ?? not needed given this is aggregation ??
-  bool isCellValid = bool(aggregationValues.w > 0.);
-  // aggregationValues:  XYZ contain aggregated values, W contains count
-  meanValues.xyz = isCellValid ? aggregationValues.xyz/aggregationValues.w : vec3(0, 0, 0);
-  meanValues.w = aggregationValues.w;
-
-  // Enforce default value for ANGLE issue (https://bugs.chromium.org/p/angleproject/issues/detail?id=3941)
-  gl_PointSize = 1.0;
+bool isCellValid = bool(aggregationValues.w > 0.);
+meanValues.xyz = isCellValid ? aggregationValues.xyz/aggregationValues.w : vec3(0, 0, 0);
+meanValues.w = aggregationValues.w;
+gl_PointSize = 1.0;
 }
 `;
 
@@ -350,11 +296,8 @@ var ARRAY_BUFFER_MAP = {
   maxMinData: "maxMinBuffer"
 };
 var REQUIRED_FEATURES = [
-  "webgl2",
-  "blend-minmax-webgl1",
-  "texture-renderable-float32-webgl",
-  "texture-blend-float-webgl1",
-  "texture-formats-float32-webgl1"
+  "float32-renderable-webgl",
+  "texture-blend-float-webgl"
 ];
 var GPUGridAggregator = class {
   static getAggregationData({ aggregationData, maxData, minData, maxMinData, pixelIndex }) {
@@ -412,12 +355,10 @@ var GPUGridAggregator = class {
     };
     this.id = props.id || "gpu-grid-aggregator";
     this.device = device;
-    const REQUIRED_FEATURES3 = [
-      "blend-minmax-webgl1",
-      "texture-renderable-float32-webgl",
-      "texture-formats-float32-webgl1"
+    const REQUIRED_FEATURES2 = [
+      "float32-renderable-webgl"
     ];
-    this._hasGPUSupport = this.device.info.type === "webgl2" && REQUIRED_FEATURES3.every((feature) => device.features.has(feature));
+    this._hasGPUSupport = REQUIRED_FEATURES2.every((feature) => device.features.has(feature));
     if (this._hasGPUSupport) {
       this._setupModels();
     }
@@ -441,9 +382,6 @@ var GPUGridAggregator = class {
   run(opts = {}) {
     this.setState({ results: {} });
     const aggregationParams = this._normalizeAggregationParams(opts);
-    if (!this._hasGPUSupport) {
-      import_core.log.log(1, "GPUGridAggregator: not supported")();
-    }
     return this._runAggregation(aggregationParams);
   }
   getData(weightId) {
@@ -486,26 +424,26 @@ var GPUGridAggregator = class {
       results[id].aggregationTexture = textures[id];
       results[id].aggregationBuffer = this.device.readPixelsToBufferWebGL(framebuffers[id], {
         target: weights[id].aggregationBuffer,
-        sourceType: import_constants2.GL.FLOAT
+        sourceType: 5126
       });
       if (needMin && needMax && combineMaxMin) {
         results[id].maxMinBuffer = this.device.readPixelsToBufferWebGL(maxMinFramebuffers[id], {
           target: weights[id].maxMinBuffer,
-          sourceType: import_constants2.GL.FLOAT
+          sourceType: 5126
         });
         results[id].maxMinTexture = resources[`${id}-maxMinTexture`];
       } else {
         if (needMin) {
           results[id].minBuffer = this.device.readPixelsToBufferWebGL(minFramebuffers[id], {
             target: weights[id].minBuffer,
-            sourceType: import_constants2.GL.FLOAT
+            sourceType: 5126
           });
           results[id].minTexture = resources[`${id}-minTexture`];
         }
         if (needMax) {
           results[id].maxBuffer = this.device.readPixelsToBufferWebGL(maxFramebuffers[id], {
             target: weights[id].maxBuffer,
-            sourceType: import_constants2.GL.FLOAT
+            sourceType: 5126
           });
           results[id].maxTexture = resources[`${id}-maxTexture`];
         }
@@ -521,7 +459,7 @@ var GPUGridAggregator = class {
     const parameters = {
       blend: true,
       depthTest: false,
-      blendFunc: [import_constants2.GL.ONE, import_constants2.GL.ONE]
+      blendFunc: [1, 1]
     };
     const uniforms = {
       cellSize,
@@ -628,7 +566,7 @@ var GPUGridAggregator = class {
           depthTest: false
         }
       });
-      framebuffers[id].attach({ [import_constants2.GL.COLOR_ATTACHMENT0]: textures[id] });
+      framebuffers[id].attach({ [36064]: textures[id] });
     }
   }
   _runAggregation(opts) {
@@ -655,7 +593,7 @@ var GPUGridAggregator = class {
         texture = meanTextures[id];
       }
       if (framebuffers[id]) {
-        framebuffers[id].attach({ [import_constants2.GL.COLOR_ATTACHMENT0]: texture });
+        framebuffers[id].attach({ [36064]: texture });
       } else {
         framebuffers[id] = getFramebuffer(this.device, {
           id: `${id}-fb`,
@@ -772,7 +710,7 @@ function getAggregationModel(device, shaderOptions) {
   return new import_engine.Model(device, {
     id: "Grid-Aggregation-Model",
     vertexCount: 1,
-    drawMode: import_constants2.GL.POINTS,
+    drawMode: 0,
     shaderAssembler: (0, import_core.getShaderAssembler)(),
     ...shaders
   });
@@ -840,12 +778,10 @@ function colorRangeToFlatArray(colorRange, normalize = false, ArrayType = Float3
 var screen_grid_layer_vertex_glsl_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;
@@ -854,72 +790,57 @@ 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;
+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);
-
-  // 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.);
+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.);
 }
 `;
 
 // dist/screen-grid-layer/screen-grid-layer-fragment.glsl.js
 var screen_grid_layer_fragment_glsl_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);
+if (vSampleCount <= 0.0) {
+discard;
+}
+fragColor = vColor;
+DECKGL_FILTER_COLOR(fragColor, geometry);
 }
 `;
 
@@ -934,9 +855,6 @@ var defaultProps = {
   colorRange: defaultColorRange
 };
 var _ScreenGridCellLayer = class extends import_core2.Layer {
-  static isSupported(device) {
-    return device.features.has("texture-formats-float32-webgl1");
-  }
   getShaders() {
     return { vs: screen_grid_layer_vertex_glsl_default, fs: screen_grid_layer_fragment_glsl_default, modules: [import_core2.picking] };
   }
@@ -1676,7 +1594,7 @@ var _GridAggregationLayer = class extends AggregationLayer {
           byteLength: dataBytes,
           accessor: {
             size: 4,
-            type: import_constants3.GL.FLOAT,
+            type: 5126,
             divisor: 1
           }
         });
@@ -1776,11 +1694,6 @@ var DIMENSIONS = {
 };
 var _ScreenGridLayer = class extends GridAggregationLayer {
   initializeState() {
-    if (!ScreenGridCellLayer.isSupported(this.context.device)) {
-      this.setState({ supported: false });
-      import_core8.log.error(`ScreenGridLayer: ${this.id} is not supported on this browser`)();
-      return;
-    }
     super.initializeAggregationLayer({
       dimensions: DIMENSIONS,
       getCellSize: (props) => props.cellSizePixels
@@ -1808,7 +1721,7 @@ var _ScreenGridLayer = class extends GridAggregationLayer {
       [POSITION_ATTRIBUTE_NAME]: {
         size: 3,
         accessor: "getPosition",
-        type: import_constants4.GL.DOUBLE,
+        type: "float64",
         fp64: this.use64bitPositions()
       },
       count: { size: 3, accessor: "getWeight" }
@@ -1937,7 +1850,6 @@ var ScreenGridLayer = _ScreenGridLayer;
 })();
 
 // dist/cpu-grid-layer/cpu-grid-layer.js
-var import_constants5 = require("@luma.gl/constants");
 var import_layers = require("@deck.gl/layers");
 
 // dist/utils/cpu-aggregator.js
@@ -2319,7 +2231,7 @@ var _CPUGridLayer = class extends AggregationLayer {
     };
     const attributeManager = this.getAttributeManager();
     attributeManager.add({
-      positions: { size: 3, type: import_constants5.GL.DOUBLE, accessor: "getPosition" }
+      positions: { size: 3, type: "float64", accessor: "getPosition" }
     });
   }
   updateState(opts) {
@@ -2380,7 +2292,6 @@ var CPUGridLayer = _CPUGridLayer;
 // dist/hexagon-layer/hexagon-layer.js
 var import_core10 = require("@deck.gl/core");
 var import_layers2 = require("@deck.gl/layers");
-var import_constants6 = require("@luma.gl/constants");
 
 // dist/hexagon-layer/hexagon-aggregator.js
 var import_d3_hexbin = require("d3-hexbin");
@@ -2491,7 +2402,7 @@ var _HexagonLayer = class extends AggregationLayer {
     };
     const attributeManager = this.getAttributeManager();
     attributeManager.add({
-      positions: { size: 3, type: import_constants6.GL.DOUBLE, accessor: "getPosition" }
+      positions: { size: 3, type: "float64", accessor: "getPosition" }
     });
   }
   updateState(opts) {
@@ -2584,7 +2495,6 @@ var HexagonLayer = _HexagonLayer;
 })();
 
 // dist/contour-layer/contour-layer.js
-var import_constants7 = require("@luma.gl/constants");
 var import_layers3 = require("@deck.gl/layers");
 
 // dist/contour-layer/marching-squares.js
@@ -3105,7 +3015,7 @@ var _ContourLayer = class extends GridAggregationLayer {
       [POSITION_ATTRIBUTE_NAME2]: {
         size: 3,
         accessor: "getPosition",
-        type: import_constants7.GL.DOUBLE,
+        type: "float64",
         fp64: this.use64bitPositions()
       },
       count: { size: 3, accessor: "getWeight" }
@@ -3223,7 +3133,7 @@ var _ContourLayer = class extends GridAggregationLayer {
     const { count } = this.state.weights;
     let { aggregationData } = count;
     if (!aggregationData) {
-      aggregationData = count.aggregationBuffer.readSyncWebGL2();
+      aggregationData = count.aggregationBuffer.readSyncWebGL();
       count.aggregationData = aggregationData;
     }
     const { cellWeights } = GPUGridAggregator.getCellData({ countsData: aggregationData });
@@ -3263,7 +3173,7 @@ var ContourLayer = _ContourLayer;
 var import_core15 = require("@deck.gl/core");
 
 // dist/gpu-grid-layer/gpu-grid-layer.js
-var import_constants9 = require("@luma.gl/constants");
+var import_constants5 = require("@luma.gl/constants");
 var import_core14 = require("@deck.gl/core");
 
 // dist/gpu-grid-layer/gpu-grid-cell-layer.js
@@ -3271,28 +3181,23 @@ var import_core13 = require("@deck.gl/core");
 var import_engine3 = require("@luma.gl/engine");
 var import_shadertools2 = require("@luma.gl/shadertools");
 var import_engine4 = require("@luma.gl/engine");
-var import_constants8 = require("@luma.gl/constants");
+var import_constants4 = require("@luma.gl/constants");
 
 // dist/gpu-grid-layer/gpu-grid-cell-layer-vertex.glsl.js
 var gpu_grid_cell_layer_vertex_glsl_default = `#version 300 es
 #define SHADER_NAME gpu-grid-cell-layer-vertex-shader
 #define RANGE_COUNT 6
-
 in vec3 positions;
 in vec3 normals;
-
 in vec4 colors;
 in vec4 elevations;
 in vec3 instancePickingColors;
-
-// Custom uniforms
 uniform vec2 offset;
 uniform bool extruded;
 uniform float cellSize;
 uniform float coverage;
 uniform float opacity;
 uniform float elevationScale;
-
 uniform ivec2 gridSize;
 uniform vec2 gridOrigin;
 uniform vec2 gridOriginLow;
@@ -3300,114 +3205,86 @@ uniform vec2 gridOffset;
 uniform vec2 gridOffsetLow;
 uniform vec4 colorRange[RANGE_COUNT];
 uniform vec2 elevationRange;
-
-// Domain uniforms
 uniform vec2 colorDomain;
 uniform bool colorDomainValid;
 uniform vec2 elevationDomain;
 uniform bool elevationDomainValid;
-
 layout(std140) uniform;
 uniform ColorData
 {
-  vec4 maxMinCount;
+vec4 maxMinCount;
 } colorData;
 uniform ElevationData
 {
-  vec4 maxMinCount;
+vec4 maxMinCount;
 } elevationData;
-
 #define EPSILON 0.00001
-
-// Result
 out vec4 vColor;
-
 vec4 quantizeScale(vec2 domain, vec4 range[RANGE_COUNT], float value) {
-  vec4 outColor = vec4(0., 0., 0., 0.);
-  if (value >= (domain.x - EPSILON) && value <= (domain.y + EPSILON)) {
-    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];
-    }
-  }
-  return outColor;
+vec4 outColor = vec4(0., 0., 0., 0.);
+if (value >= (domain.x - EPSILON) && value <= (domain.y + EPSILON)) {
+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];
+}
+}
+return outColor;
 }
-
 float linearScale(vec2 domain, vec2 range, float value) {
-  if (value >= (domain.x - EPSILON) && value <= (domain.y + EPSILON)) {
-    return ((value - domain.x) / (domain.y - domain.x)) * (range.y - range.x) + range.x;
-  }
-  return -1.;
+if (value >= (domain.x - EPSILON) && value <= (domain.y + EPSILON)) {
+return ((value - domain.x) / (domain.y - domain.x)) * (range.y - range.x) + range.x;
+}
+return -1.;
 }
-
 void main(void) {
-  vec2 clrDomain = colorDomainValid ? colorDomain : vec2(colorData.maxMinCount.a, colorData.maxMinCount.r);
-  vec4 color = quantizeScale(clrDomain, colorRange, colors.r);
-
-  float elevation = 0.0;
-
-  if (extruded) {
-    vec2 elvDomain = elevationDomainValid ? elevationDomain : vec2(elevationData.maxMinCount.a, elevationData.maxMinCount.r);
-    elevation = linearScale(elvDomain, elevationRange, elevations.r);
-    elevation = elevation  * (positions.z + 1.0) / 2.0 * elevationScale;
-  }
-
-  // if aggregated color or elevation is 0 do not render
-  float shouldRender = float(color.r > 0.0 && elevations.r >= 0.0);
-  float dotRadius = cellSize / 2. * coverage * shouldRender;
-
-  int yIndex = (gl_InstanceID / gridSize[0]);
-  int xIndex = gl_InstanceID - (yIndex * gridSize[0]);
-
-  vec2 instancePositionXFP64 = mul_fp64(vec2(gridOffset[0], gridOffsetLow[0]), vec2(float(xIndex), 0.));
-  instancePositionXFP64 = sum_fp64(instancePositionXFP64, vec2(gridOrigin[0], gridOriginLow[0]));
-  vec2 instancePositionYFP64 = mul_fp64(vec2(gridOffset[1], gridOffsetLow[1]), vec2(float(yIndex), 0.));
-  instancePositionYFP64 = sum_fp64(instancePositionYFP64, vec2(gridOrigin[1], gridOriginLow[1]));
-
-  vec3 centroidPosition = vec3(instancePositionXFP64[0], instancePositionYFP64[0], elevation);
-  vec3 centroidPosition64Low = vec3(instancePositionXFP64[1], instancePositionYFP64[1], 0.0);
-  geometry.worldPosition = centroidPosition;
-  vec3 pos = vec3(project_size(positions.xy + offset) * dotRadius, 0.);
-
-  // Set color to be rendered to picking fbo (also used to check for selection highlight).
-  picking_setPickingColor(instancePickingColors);
-
-  gl_Position = project_position_to_clipspace(centroidPosition, centroidPosition64Low, pos, geometry.position);
-
-  // Light calculations
-  // Worldspace is the linear space after Mercator projection
-
-  vec3 normals_commonspace = project_normal(normals);
-
-   if (extruded) {
-    vec3 lightColor = lighting_getLightColor(color.rgb, project_uCameraPosition, geometry.position.xyz, normals_commonspace);
-    vColor = vec4(lightColor, color.a * opacity) / 255.;
-  } else {
-    vColor = vec4(color.rgb, color.a * opacity) / 255.;
-  }
+vec2 clrDomain = colorDomainValid ? colorDomain : vec2(colorData.maxMinCount.a, colorData.maxMinCount.r);
+vec4 color = quantizeScale(clrDomain, colorRange, colors.r);
+float elevation = 0.0;
+if (extruded) {
+vec2 elvDomain = elevationDomainValid ? elevationDomain : vec2(elevationData.maxMinCount.a, elevationData.maxMinCount.r);
+elevation = linearScale(elvDomain, elevationRange, elevations.r);
+elevation = elevation  * (positions.z + 1.0) / 2.0 * elevationScale;
+}
+float shouldRender = float(color.r > 0.0 && elevations.r >= 0.0);
+float dotRadius = cellSize / 2. * coverage * shouldRender;
+int yIndex = (gl_InstanceID / gridSize[0]);
+int xIndex = gl_InstanceID - (yIndex * gridSize[0]);
+vec2 instancePositionXFP64 = mul_fp64(vec2(gridOffset[0], gridOffsetLow[0]), vec2(float(xIndex), 0.));
+instancePositionXFP64 = sum_fp64(instancePositionXFP64, vec2(gridOrigin[0], gridOriginLow[0]));
+vec2 instancePositionYFP64 = mul_fp64(vec2(gridOffset[1], gridOffsetLow[1]), vec2(float(yIndex), 0.));
+instancePositionYFP64 = sum_fp64(instancePositionYFP64, vec2(gridOrigin[1], gridOriginLow[1]));
+vec3 centroidPosition = vec3(instancePositionXFP64[0], instancePositionYFP64[0], elevation);
+vec3 centroidPosition64Low = vec3(instancePositionXFP64[1], instancePositionYFP64[1], 0.0);
+geometry.worldPosition = centroidPosition;
+vec3 pos = vec3(project_size(positions.xy + offset) * dotRadius, 0.);
+picking_setPickingColor(instancePickingColors);
+gl_Position = project_position_to_clipspace(centroidPosition, centroidPosition64Low, pos, geometry.position);
+vec3 normals_commonspace = project_normal(normals);
+if (extruded) {
+vec3 lightColor = lighting_getLightColor(color.rgb, project_uCameraPosition, geometry.position.xyz, normals_commonspace);
+vColor = vec4(lightColor, color.a * opacity) / 255.;
+} else {
+vColor = vec4(color.rgb, color.a * opacity) / 255.;
+}
 }
 `;
 
 // dist/gpu-grid-layer/gpu-grid-cell-layer-fragment.glsl.js
 var gpu_grid_cell_layer_fragment_glsl_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);
+fragColor = vColor;
+fragColor = picking_filterColor(fragColor);
 }
 `;
 
@@ -3489,12 +3366,12 @@ var _GPUGridCellLayer = class extends import_core13.Layer {
     this.unbindUniformBuffers(colorMaxMinBuffer, elevationMaxMinBuffer);
   }
   bindUniformBuffers(colorMaxMinBuffer, elevationMaxMinBuffer) {
-    colorMaxMinBuffer.bind({ target: import_constants8.GL.UNIFORM_BUFFER, index: COLOR_DATA_UBO_INDEX });
-    elevationMaxMinBuffer.bind({ target: import_constants8.GL.UNIFORM_BUFFER, index: ELEVATION_DATA_UBO_INDEX });
+    colorMaxMinBuffer.bind({ target: 35345, index: COLOR_DATA_UBO_INDEX });
+    elevationMaxMinBuffer.bind({ target: 35345, index: ELEVATION_DATA_UBO_INDEX });
   }
   unbindUniformBuffers(colorMaxMinBuffer, elevationMaxMinBuffer) {
-    colorMaxMinBuffer.unbind({ target: import_constants8.GL.UNIFORM_BUFFER, index: COLOR_DATA_UBO_INDEX });
-    elevationMaxMinBuffer.unbind({ target: import_constants8.GL.UNIFORM_BUFFER, index: ELEVATION_DATA_UBO_INDEX });
+    colorMaxMinBuffer.unbind({ target: 35345, index: COLOR_DATA_UBO_INDEX });
+    elevationMaxMinBuffer.unbind({ target: 35345, index: ELEVATION_DATA_UBO_INDEX });
   }
   getDomainUniforms() {
     const { colorDomain, elevationDomain } = this.props;
@@ -3573,7 +3450,7 @@ var _GPUGridLayer = class extends GridAggregationLayer {
           combineMaxMin: true,
           maxMinBuffer: device.createBuffer({
             byteLength: 4 * 4,
-            accessor: { size: 4, type: import_constants9.GL.FLOAT, divisor: 1 }
+            accessor: { size: 4, type: 5126, divisor: 1 }
           })
         },
         elevation: {
@@ -3582,7 +3459,7 @@ var _GPUGridLayer = class extends GridAggregationLayer {
           combineMaxMin: true,
           maxMinBuffer: device.createBuffer({
             byteLength: 4 * 4,
-            accessor: { size: 4, type: import_constants9.GL.FLOAT, divisor: 1 }
+            accessor: { size: 4, type: 5126, divisor: 1 }
           })
         }
       },
@@ -3593,7 +3470,7 @@ var _GPUGridLayer = class extends GridAggregationLayer {
       [POSITION_ATTRIBUTE_NAME3]: {
         size: 3,
         accessor: "getPosition",
-        type: import_constants9.GL.DOUBLE,
+        type: "float64",
         fp64: this.use64bitPositions()
       },
       color: { size: 3, accessor: "getColorWeight" },
@@ -3890,7 +3767,6 @@ function getTextureCoordinates(point, bounds) {
 }
 
 // dist/heatmap-layer/heatmap-layer.js
-var import_constants10 = require("@luma.gl/constants");
 var import_engine6 = require("@luma.gl/engine");
 var import_core17 = require("@deck.gl/core");
 
@@ -3901,76 +3777,61 @@ var import_core16 = require("@deck.gl/core");
 // dist/heatmap-layer/triangle-layer-vertex.glsl.js
 var triangle_layer_vertex_glsl_default = `#version 300 es
 #define SHADER_NAME heatp-map-layer-vertex-shader
-
 uniform sampler2D maxTexture;
 uniform float intensity;
 uniform vec2 colorDomain;
 uniform float threshold;
 uniform float aggregationMode;
-
 in vec3 positions;
 in vec2 texCoords;
-
 out vec2 vTexCoords;
 out float vIntensityMin;
 out float vIntensityMax;
-
 void main(void) {
-  gl_Position = project_position_to_clipspace(positions, vec3(0.0), vec3(0.0));
-  vTexCoords = texCoords;
-  vec4 maxTexture = texture(maxTexture, vec2(0.5));
-  float maxValue = aggregationMode < 0.5 ? maxTexture.r : maxTexture.g;
-  float minValue = maxValue * threshold;
-  if (colorDomain[1] > 0.) {
-    // if user specified custom domain use it.
-    maxValue = colorDomain[1];
-    minValue = colorDomain[0];
-  }
-  vIntensityMax = intensity / maxValue;
-  vIntensityMin = intensity / minValue;
+gl_Position = project_position_to_clipspace(positions, vec3(0.0), vec3(0.0));
+vTexCoords = texCoords;
+vec4 maxTexture = texture(maxTexture, vec2(0.5));
+float maxValue = aggregationMode < 0.5 ? maxTexture.r : maxTexture.g;
+float minValue = maxValue * threshold;
+if (colorDomain[1] > 0.) {
+maxValue = colorDomain[1];
+minValue = colorDomain[0];
+}
+vIntensityMax = intensity / maxValue;
+vIntensityMin = intensity / minValue;
 }
 `;
 
 // dist/heatmap-layer/triangle-layer-fragment.glsl.js
 var triangle_layer_fragment_glsl_default = `#version 300 es
 #define SHADER_NAME triangle-layer-fragment-shader
-
 precision highp float;
-
 uniform float opacity;
 uniform sampler2D weightsTexture;
 uniform sampler2D colorTexture;
 uniform float aggregationMode;
-
 in vec2 vTexCoords;
 in float vIntensityMin;
 in float vIntensityMax;
-
 out vec4 fragColor;
-
 vec4 getLinearColor(float value) {
-  float factor = clamp(value * vIntensityMax, 0., 1.);
-  vec4 color = texture(colorTexture, vec2(factor, 0.5));
-  color.a *= min(value * vIntensityMin, 1.0);
-  return color;
+float factor = clamp(value * vIntensityMax, 0., 1.);
+vec4 color = texture(colorTexture, vec2(factor, 0.5));
+color.a *= min(value * vIntensityMin, 1.0);
+return color;
 }
-
 void main(void) {
-  vec4 weights = texture(weightsTexture, vTexCoords);
-  float weight = weights.r;
-
-  if (aggregationMode > 0.5) {
-    weight /= max(1.0, weights.a);
-  }
-
-  // discard pixels with 0 weight.
-  if (weight <= 0.) {
-     discard;
-  }
-
-  vec4 linearColor = getLinearColor(weight);
-  linearColor.a *= opacity;
-  fragColor = linearColor;
+vec4 weights = texture(weightsTexture, vTexCoords);
+float weight = weights.r;
+if (aggregationMode > 0.5) {
+weight /= max(1.0, weights.a);
+}
+if (weight <= 0.) {
+discard;
+}
+vec4 linearColor = getLinearColor(weight);
+linearColor.a *= opacity;
+fragColor = linearColor;
 }
 `;
 
@@ -4025,20 +3886,15 @@ uniform float radiusPixels;
 uniform float textureWidth;
 uniform vec4 commonBounds;
 uniform float weightsScale;
-
 void main()
 {
-  weightsTexture = vec4(weights * weightsScale, 0., 0., 1.);
-
-  float radiusTexels = project_pixel_size(radiusPixels) * textureWidth / (commonBounds.z - commonBounds.x);
-  gl_PointSize = radiusTexels * 2.;
-
-  vec3 commonPosition = project_position(positions, positions64Low);
-
-  // // map xy from commonBounds to [-1, 1]
-  gl_Position.xy = (commonPosition.xy - commonBounds.xy) / (commonBounds.zw - commonBounds.xy) ;
-  gl_Position.xy = (gl_Position.xy * 2.) - (1.);
-  gl_Position.w = 1.0;
+weightsTexture = vec4(weights * weightsScale, 0., 0., 1.);
+float radiusTexels = project_pixel_size(radiusPixels) * textureWidth / (commonBounds.z - commonBounds.x);
+gl_PointSize = radiusTexels * 2.;
+vec3 commonPosition = project_position(positions, positions64Low);
+gl_Position.xy = (commonPosition.xy - commonBounds.xy) / (commonBounds.zw - commonBounds.xy) ;
+gl_Position.xy = (gl_Position.xy * 2.) - (1.);
+gl_Position.w = 1.0;
 }
 `;
 
@@ -4046,21 +3902,17 @@ void main()
 var weights_fs_glsl_default = `#version 300 es
 in vec4 weightsTexture;
 out vec4 fragColor;
-// Epanechnikov function, keeping for reference
-// float epanechnikovKDE(float u) {
-//   return 0.75 * (1.0 - u * u);
-// }
 float gaussianKDE(float u){
-  return pow(2.71828, -u*u/0.05555)/(1.77245385*0.166666);
+return pow(2.71828, -u*u/0.05555)/(1.77245385*0.166666);
 }
 void main()
 {
-  float dist = length(gl_PointCoord - vec2(0.5, 0.5));
-  if (dist > 0.5) {
-    discard;
-  }
-  fragColor = weightsTexture * gaussianKDE(2. * dist);
-  DECKGL_FILTER_COLOR(fragColor, geometry);
+float dist = length(gl_PointCoord - vec2(0.5, 0.5));
+if (dist > 0.5) {
+discard;
+}
+fragColor = weightsTexture * gaussianKDE(2. * dist);
+DECKGL_FILTER_COLOR(fragColor, geometry);
 }
 `;
 
@@ -4069,18 +3921,14 @@ var max_vs_glsl_default = `#version 300 es
 uniform sampler2D inTexture;
 uniform float textureSize;
 out vec4 outTexture;
-
 void main()
 {
-  // Sample every pixel in texture
-  int yIndex = gl_VertexID / int(textureSize);
-  int xIndex = gl_VertexID - (yIndex * int(textureSize));
-  vec2 uv = (0.5 + vec2(float(xIndex), float(yIndex))) / textureSize;
-  outTexture = texture(inTexture, uv);
-
-  gl_Position = vec4(0.0, 0.0, 0.0, 1.0);
-  // Enforce default value for ANGLE issue (https://bugs.chromium.org/p/angleproject/issues/detail?id=3941)
-  gl_PointSize = 1.0;
+int yIndex = gl_VertexID / int(textureSize);
+int xIndex = gl_VertexID - (yIndex * int(textureSize));
+vec2 uv = (0.5 + vec2(float(xIndex), float(yIndex))) / textureSize;
+outTexture = texture(inTexture, uv);
+gl_Position = vec4(0.0, 0.0, 0.0, 1.0);
+gl_PointSize = 1.0;
 }
 `;
 
@@ -4089,8 +3937,8 @@ var max_fs_glsl_default = `#version 300 es
 in vec4 outTexture;
 out vec4 fragColor;
 void main() {
-  fragColor = outTexture;
-  fragColor.g = outTexture.r / max(1.0, outTexture.a);
+fragColor = outTexture;
+fragColor.g = outTexture.r / max(1.0, outTexture.a);
 }
 `;
 
@@ -4123,13 +3971,9 @@ var defaultProps10 = {
   weightsTextureSize: { type: "number", min: 128, max: 2048, value: 2048 },
   debounceTimeout: { type: "number", min: 0, max: 1e3, value: 500 }
 };
-var REQUIRED_FEATURES2 = [
-  "blend-minmax-webgl1",
-  "texture-formats-float32-webgl1"
-];
 var FLOAT_TARGET_FEATURES = [
-  "texture-renderable-float32-webgl",
-  "texture-blend-float-webgl1"
+  "float32-renderable-webgl",
+  "texture-blend-float-webgl"
 ];
 var DIMENSIONS4 = {
   data: {
@@ -4138,13 +3982,8 @@ var DIMENSIONS4 = {
 };
 var _HeatmapLayer = class extends AggregationLayer {
   initializeState() {
-    if (!REQUIRED_FEATURES2.every((feature) => this.context.device.features.has(feature))) {
-      this.setState({ supported: false });
-      import_core17.log.error(`HeatmapLayer: ${this.id} is not supported on this browser`)();
-      return;
-    }
     super.initializeAggregationLayer(DIMENSIONS4);
-    this.setState({ supported: true, colorDomain: DEFAULT_COLOR_DOMAIN });
+    this.setState({ colorDomain: DEFAULT_COLOR_DOMAIN });
     this._setupTextureParams();
     this._setupAttributes();
     this._setupResources();
@@ -4153,9 +3992,6 @@ var _HeatmapLayer = class extends AggregationLayer {
     return changeFlags.somethingChanged;
   }
   updateState(opts) {
-    if (!this.state.supported) {
-      return;
-    }
     super.updateState(opts);
     this._updateHeatmapState(opts);
   }
@@ -4181,9 +4017,6 @@ var _HeatmapLayer = class extends AggregationLayer {
     this.setState({ zoom: opts.context.viewport.zoom });
   }
   renderLayers() {
-    if (!this.state.supported) {
-      return [];
-    }
     const { weightsTexture, triPositionBuffer, triTexCoordBuffer, maxWeightsTexture, colorTexture, colorDomain } = this.state;
     const { updateTriggers, intensity, threshold: threshold2, aggregation } = this.props;
     const TriangleLayerClass = this.getSubLayerClass("triangle", TriangleLayer);
@@ -4262,7 +4095,7 @@ var _HeatmapLayer = class extends AggregationLayer {
   _setupAttributes() {
     const attributeManager = this.getAttributeManager();
     attributeManager.add({
-      positions: { size: 3, type: import_constants10.GL.DOUBLE, accessor: "getPosition" },
+      positions: { size: 3, type: "float64", accessor: "getPosition" },
       weights: { size: 1, accessor: "getWeight" }
     });
     this.setState({ positionAttributeName: "positions" });