@deck.gl/extensions 9.0.0-beta.4 → 9.0.0-beta.6

package/dist/index.cjs

@@ -39,41 +39,35 @@ var import_core2 = require("@deck.gl/core");
 // dist/brushing/shader-module.js
 var import_core = require("@deck.gl/core");
 var vs = `
-  uniform bool brushing_enabled;
-  uniform int brushing_target;
-  uniform vec2 brushing_mousePos;
-  uniform float brushing_radius;
-
-  #ifdef NON_INSTANCED_MODEL
-  in vec2 brushingTargets;
-  #else
-  in vec2 instanceBrushingTargets;
-  #endif
-
-  out float brushing_isVisible;
-
-  bool brushing_isPointInRange(vec2 position) {
-    if (!brushing_enabled) {
-      return true;
-    }
-    vec2 source_commonspace = project_position(position);
-    vec2 target_commonspace = project_position(brushing_mousePos);
-    float distance = length((target_commonspace - source_commonspace) / project_uCommonUnitsPerMeter.xy);
-
-    return distance <= brushing_radius;
-  }
-
-  bool brushing_arePointsInRange(vec2 sourcePos, vec2 targetPos) {
-    return brushing_isPointInRange(sourcePos) || brushing_isPointInRange(targetPos);
-  }
-
-  void brushing_setVisible(bool visible) {
-    brushing_isVisible = float(visible);
-  }
+uniform bool brushing_enabled;
+uniform int brushing_target;
+uniform vec2 brushing_mousePos;
+uniform float brushing_radius;
+#ifdef NON_INSTANCED_MODEL
+in vec2 brushingTargets;
+#else
+in vec2 instanceBrushingTargets;
+#endif
+out float brushing_isVisible;
+bool brushing_isPointInRange(vec2 position) {
+if (!brushing_enabled) {
+return true;
+}
+vec2 source_commonspace = project_position(position);
+vec2 target_commonspace = project_position(brushing_mousePos);
+float distance = length((target_commonspace - source_commonspace) / project_uCommonUnitsPerMeter.xy);
+return distance <= brushing_radius;
+}
+bool brushing_arePointsInRange(vec2 sourcePos, vec2 targetPos) {
+return brushing_isPointInRange(sourcePos) || brushing_isPointInRange(targetPos);
+}
+void brushing_setVisible(bool visible) {
+brushing_isVisible = float(visible);
+}
 `;
 var fs = `
-  uniform bool brushing_enabled;
-  in float brushing_isVisible;
+uniform bool brushing_enabled;
+in float brushing_isVisible;
 `;
 var TARGET = {
   source: 0,
@@ -83,30 +77,30 @@ var TARGET = {
 };
 var inject = {
   "vs:DECKGL_FILTER_GL_POSITION": `
-    vec2 brushingTarget;
-    vec2 brushingSource;
-    if (brushing_target == 3) {
-      brushingTarget = geometry.worldPositionAlt.xy;
-      brushingSource = geometry.worldPosition.xy;
-    } else if (brushing_target == 0) {
-      brushingTarget = geometry.worldPosition.xy;
-    } else if (brushing_target == 1) {
-      brushingTarget = geometry.worldPositionAlt.xy;
-    } else {
-      #ifdef NON_INSTANCED_MODEL
-      brushingTarget = brushingTargets;
-      #else
-      brushingTarget = instanceBrushingTargets;
-      #endif
-    }
-    bool visible;
-    if (brushing_target == 3) {
-      visible = brushing_arePointsInRange(brushingSource, brushingTarget);
-    } else {
-      visible = brushing_isPointInRange(brushingTarget);
-    }
-    brushing_setVisible(visible);
-  `,
+vec2 brushingTarget;
+vec2 brushingSource;
+if (brushing_target == 3) {
+brushingTarget = geometry.worldPositionAlt.xy;
+brushingSource = geometry.worldPosition.xy;
+} else if (brushing_target == 0) {
+brushingTarget = geometry.worldPosition.xy;
+} else if (brushing_target == 1) {
+brushingTarget = geometry.worldPositionAlt.xy;
+} else {
+#ifdef NON_INSTANCED_MODEL
+brushingTarget = brushingTargets;
+#else
+brushingTarget = instanceBrushingTargets;
+#endif
+}
+bool visible;
+if (brushing_target == 3) {
+visible = brushing_arePointsInRange(brushingSource, brushingTarget);
+} else {
+visible = brushing_isPointInRange(brushingTarget);
+}
+brushing_setVisible(visible);
+`,
   "fs:DECKGL_FILTER_COLOR": `
     if (brushing_enabled && brushing_isVisible < 0.5) {
       discard;
@@ -195,7 +189,6 @@ var BrushingExtension = _BrushingExtension;
 })();
 
 // dist/data-filter/data-filter-extension.js
-var import_constants2 = require("@luma.gl/constants");
 var import_core3 = require("@deck.gl/core");
 
 // dist/data-filter/shader-module.js
@@ -208,78 +201,69 @@ uniform bool filter_useSoftMargin;
 uniform bool filter_enabled;
 uniform bool filter_transformSize;
 uniform ivec4 filter_categoryBitMask;
-
 #ifdef NON_INSTANCED_MODEL
-  #define DATAFILTER_ATTRIB filterValues
-  #define DATAFILTER_ATTRIB_64LOW filterValues64Low
-  #define DATACATEGORY_ATTRIB filterCategoryValues
+#define DATAFILTER_ATTRIB filterValues
+#define DATAFILTER_ATTRIB_64LOW filterValues64Low
+#define DATACATEGORY_ATTRIB filterCategoryValues
 #else
-  #define DATAFILTER_ATTRIB instanceFilterValues
-  #define DATAFILTER_ATTRIB_64LOW instanceFilterValues64Low
-  #define DATACATEGORY_ATTRIB instanceFilterCategoryValues
+#define DATAFILTER_ATTRIB instanceFilterValues
+#define DATAFILTER_ATTRIB_64LOW instanceFilterValues64Low
+#define DATACATEGORY_ATTRIB instanceFilterCategoryValues
 #endif
-
 in DATAFILTER_TYPE DATAFILTER_ATTRIB;
 #ifdef DATAFILTER_DOUBLE
-  in DATAFILTER_TYPE DATAFILTER_ATTRIB_64LOW;
-
-  uniform DATAFILTER_TYPE filter_min64High;
-  uniform DATAFILTER_TYPE filter_max64High;
+in DATAFILTER_TYPE DATAFILTER_ATTRIB_64LOW;
+uniform DATAFILTER_TYPE filter_min64High;
+uniform DATAFILTER_TYPE filter_max64High;
 #endif
 in DATACATEGORY_TYPE DATACATEGORY_ATTRIB;
-
 out float dataFilter_value;
-
 float dataFilter_reduceValue(float value) {
-  return value;
+return value;
 }
 float dataFilter_reduceValue(vec2 value) {
-  return min(value.x, value.y);
+return min(value.x, value.y);
 }
 float dataFilter_reduceValue(vec3 value) {
-  return min(min(value.x, value.y), value.z);
+return min(min(value.x, value.y), value.z);
 }
 float dataFilter_reduceValue(vec4 value) {
-  return min(min(value.x, value.y), min(value.z, value.w));
+return min(min(value.x, value.y), min(value.z, value.w));
 }
 void dataFilter_setValue(DATAFILTER_TYPE valueFromMin, DATAFILTER_TYPE valueFromMax, DATACATEGORY_TYPE category) {
-  if (filter_enabled) {
-    if (filter_useSoftMargin) {
-      dataFilter_value = dataFilter_reduceValue(
-        smoothstep(filter_min, filter_softMin, valueFromMin) *
-        (1.0 - smoothstep(filter_softMax, filter_max, valueFromMax))
-      );
-    } else {
-      dataFilter_value = dataFilter_reduceValue(
-        step(filter_min, valueFromMin) * step(valueFromMax, filter_max)
-      );
-    }
-
-    #if DATACATEGORY_CHANNELS == 1 // One 128-bit mask
-      int dataFilter_masks = filter_categoryBitMask[int(category / 32.0)];
-    #elif DATACATEGORY_CHANNELS == 2 // Two 64-bit masks
-      ivec2 dataFilter_masks = ivec2(
-        filter_categoryBitMask[int(category.x / 32.0)],
-        filter_categoryBitMask[int(category.y / 32.0) + 2]
-      );
-    #elif DATACATEGORY_CHANNELS == 3 // Three 32-bit masks
-      ivec3 dataFilter_masks = filter_categoryBitMask.xyz;
-    #else // Four 32-bit masks
-      ivec4 dataFilter_masks = filter_categoryBitMask;
-    #endif
-
-    // Shift mask and extract relevant bits
-    DATACATEGORY_TYPE dataFilter_bits = DATACATEGORY_TYPE(dataFilter_masks) / pow(DATACATEGORY_TYPE(2.0), mod(category, 32.0));
-    dataFilter_bits = mod(floor(dataFilter_bits), 2.0);
-
-    #if DATACATEGORY_CHANNELS == 1
-      if(dataFilter_bits == 0.0) dataFilter_value = 0.0;
-    #else
-    if(any(equal(dataFilter_bits, DATACATEGORY_TYPE(0.0)))) dataFilter_value = 0.0;
-    #endif
-  } else {
-    dataFilter_value = 1.0;
-  }
+if (filter_enabled) {
+if (filter_useSoftMargin) {
+dataFilter_value = dataFilter_reduceValue(
+smoothstep(filter_min, filter_softMin, valueFromMin) *
+(1.0 - smoothstep(filter_softMax, filter_max, valueFromMax))
+);
+} else {
+dataFilter_value = dataFilter_reduceValue(
+step(filter_min, valueFromMin) * step(valueFromMax, filter_max)
+);
+}
+#if DATACATEGORY_CHANNELS == 1
+int dataFilter_masks = filter_categoryBitMask[int(category / 32.0)];
+#elif DATACATEGORY_CHANNELS == 2
+ivec2 dataFilter_masks = ivec2(
+filter_categoryBitMask[int(category.x / 32.0)],
+filter_categoryBitMask[int(category.y / 32.0) + 2]
+);
+#elif DATACATEGORY_CHANNELS == 3
+ivec3 dataFilter_masks = filter_categoryBitMask.xyz;
+#else
+ivec4 dataFilter_masks = filter_categoryBitMask;
+#endif
+DATACATEGORY_TYPE dataFilter_bits = DATACATEGORY_TYPE(dataFilter_masks) / pow(DATACATEGORY_TYPE(2.0), mod(category, 32.0));
+dataFilter_bits = mod(floor(dataFilter_bits), 2.0);
+#if DATACATEGORY_CHANNELS == 1
+if(dataFilter_bits == 0.0) dataFilter_value = 0.0;
+#else
+if(any(equal(dataFilter_bits, DATACATEGORY_TYPE(0.0)))) dataFilter_value = 0.0;
+#endif
+} else {
+dataFilter_value = 1.0;
+}
 }
 `;
 var fs2 = `
@@ -338,32 +322,32 @@ function getUniforms64(opts) {
 }
 var inject2 = {
   "vs:#main-start": `
-    #ifdef DATAFILTER_DOUBLE
-      dataFilter_setValue(
-        DATAFILTER_ATTRIB - filter_min64High + DATAFILTER_ATTRIB_64LOW,
-        DATAFILTER_ATTRIB - filter_max64High + DATAFILTER_ATTRIB_64LOW,
-        DATACATEGORY_ATTRIB
-      );
-    #else
-      dataFilter_setValue(DATAFILTER_ATTRIB, DATAFILTER_ATTRIB, DATACATEGORY_ATTRIB);
-    #endif
-  `,
+#ifdef DATAFILTER_DOUBLE
+dataFilter_setValue(
+DATAFILTER_ATTRIB - filter_min64High + DATAFILTER_ATTRIB_64LOW,
+DATAFILTER_ATTRIB - filter_max64High + DATAFILTER_ATTRIB_64LOW,
+DATACATEGORY_ATTRIB
+);
+#else
+dataFilter_setValue(DATAFILTER_ATTRIB, DATAFILTER_ATTRIB, DATACATEGORY_ATTRIB);
+#endif
+`,
   "vs:#main-end": `
-    if (dataFilter_value == 0.0) {
-      gl_Position = vec4(0.);
-    }
-  `,
+if (dataFilter_value == 0.0) {
+gl_Position = vec4(0.);
+}
+`,
   "vs:DECKGL_FILTER_SIZE": `
-    if (filter_transformSize) {
-      size = size * dataFilter_value;
-    }
-  `,
+if (filter_transformSize) {
+size = size * dataFilter_value;
+}
+`,
   "fs:DECKGL_FILTER_COLOR": `
-    if (dataFilter_value == 0.0) discard;
-    if (filter_transformColor) {
-      color.a *= dataFilter_value;
-    }
-  `
+if (dataFilter_value == 0.0) discard;
+if (filter_transformColor) {
+color.a *= dataFilter_value;
+}
+`
 };
 var shaderModule = {
   name: "data-filter",
@@ -430,9 +414,12 @@ void main() {
   fragColor = vColor;
 }
 `;
+var FLOAT_TARGET_FEATURES = [
+  "float32-renderable-webgl",
+  "texture-blend-float-webgl"
+];
 function supportsFloatTarget(device) {
-  const gl = device.gl;
-  return Boolean(gl.getExtension("EXT_float_blend") && (gl.getExtension("EXT_color_buffer_float") || gl.getExtension("WEBGL_color_buffer_float")));
+  return FLOAT_TARGET_FEATURES.every((feature) => device.features.has(feature));
 }
 function getFramebuffer(device, useFloatTarget) {
   if (useFloatTarget) {
@@ -441,8 +428,8 @@ function getFramebuffer(device, useFloatTarget) {
       height: 1,
       colorAttachments: [
         device.createTexture({
-          format: device.info.type === "webgl2" ? "rgba32float" : "rgba8unorm",
-          type: import_constants.GL.FLOAT,
+          format: "rgba32float",
+          type: 5126,
           mipmaps: false
         })
       ]
@@ -451,7 +438,7 @@ function getFramebuffer(device, useFloatTarget) {
   return device.createFramebuffer({
     width: 256,
     height: 64,
-    colorAttachments: [device.createTexture({ format: "rgba8unorm", type: import_constants.GL.FLOAT, mipmaps: false })]
+    colorAttachments: [device.createTexture({ format: "rgba8unorm", type: 5126, mipmaps: false })]
   });
 }
 function getModel(device, shaderOptions, useFloatTarget) {
@@ -463,7 +450,7 @@ function getModel(device, shaderOptions, useFloatTarget) {
     id: "data-filter-aggregation-model",
     vertexCount: 1,
     isInstanced: false,
-    drawMode: import_constants.GL.POINTS,
+    drawMode: 0,
     vs: AGGREGATE_VS,
     fs: AGGREGATE_FS,
     ...shaderOptions
@@ -471,8 +458,8 @@ function getModel(device, shaderOptions, useFloatTarget) {
 }
 var parameters = {
   blend: true,
-  blendFunc: [import_constants.GL.ONE, import_constants.GL.ONE, import_constants.GL.ONE, import_constants.GL.ONE],
-  blendEquation: [import_constants.GL.FUNC_ADD, import_constants.GL.FUNC_ADD],
+  blendFunc: [1, 1, 1, 1],
+  blendEquation: [32774, 32774],
   depthTest: false
 };
 
@@ -488,6 +475,12 @@ var defaultProps2 = {
   filterTransformSize: true,
   filterTransformColor: true
 };
+var defaultOptions = {
+  categorySize: 1,
+  filterSize: 1,
+  fp64: false,
+  countItems: false
+};
 var DATA_TYPE_FROM_SIZE = {
   1: "float",
   2: "vec2",
@@ -495,14 +488,17 @@ var DATA_TYPE_FROM_SIZE = {
   4: "vec4"
 };
 var _DataFilterExtension = class extends import_core3.LayerExtension {
+  constructor(opts) {
+    super({ ...defaultOptions, ...opts });
+  }
   getShaders(extension) {
     const { categorySize, filterSize, fp64: fp642 } = extension.opts;
     return {
       modules: [fp642 ? shaderModule64 : shaderModule],
       defines: {
-        DATACATEGORY_TYPE: DATA_TYPE_FROM_SIZE[categorySize || 1],
+        DATACATEGORY_TYPE: DATA_TYPE_FROM_SIZE[categorySize],
         DATACATEGORY_CHANNELS: categorySize,
-        DATAFILTER_TYPE: DATA_TYPE_FROM_SIZE[filterSize || 1],
+        DATAFILTER_TYPE: DATA_TYPE_FROM_SIZE[filterSize],
         DATAFILTER_DOUBLE: Boolean(fp642)
       }
     };
@@ -514,7 +510,7 @@ var _DataFilterExtension = class extends import_core3.LayerExtension {
       attributeManager.add({
         filterValues: {
           size: filterSize,
-          type: fp642 ? import_constants2.GL.DOUBLE : import_constants2.GL.FLOAT,
+          type: fp642 ? "float64" : "float32",
           accessor: "getFilterValue",
           shaderAttributes: {
             filterValues: {
@@ -527,7 +523,6 @@ var _DataFilterExtension = class extends import_core3.LayerExtension {
         },
         filterCategoryValues: {
           size: categorySize,
-          type: import_constants2.GL.FLOAT,
           accessor: "getFilterCategory",
           transform: categorySize === 1 ? (d) => extension._getCategoryKey.call(this, d, 0) : (d) => d.map((x, i) => extension._getCategoryKey.call(this, x, i)),
           shaderAttributes: {
@@ -548,8 +543,7 @@ var _DataFilterExtension = class extends import_core3.LayerExtension {
         filterIndices: {
           size: useFloatTarget ? 1 : 2,
           vertexOffset: 1,
-          type: import_constants2.GL.UNSIGNED_BYTE,
-          normalized: true,
+          type: "unorm8",
           accessor: (object, { index }) => {
             const i = object && object.__source ? object.__source.index : index;
             return useFloatTarget ? (i + 1) % 255 : [(i + 1) % 255, Math.floor(i / 255) % 255];
@@ -680,84 +674,65 @@ var import_shadertools = require("@luma.gl/shadertools");
 var import_core4 = require("@deck.gl/core");
 
 // dist/fp64/project64.glsl.js
-var project64_glsl_default = `
-const vec2 WORLD_SCALE_FP64 = vec2(81.4873275756836, 0.0000032873668232014097);
-
+var project64_glsl_default = `const vec2 WORLD_SCALE_FP64 = vec2(81.4873275756836, 0.0000032873668232014097);
 uniform vec2 project_uViewProjectionMatrixFP64[16];
-
-// longitude: lnglat_fp64.xy; latitude: lnglat_fp64.zw
 void mercatorProject_fp64(vec4 lnglat_fp64, out vec2 out_val[2]) {
-
 #if defined(NVIDIA_FP64_WORKAROUND)
-  out_val[0] = sum_fp64(radians_fp64(lnglat_fp64.xy), PI_FP64 * ONE);
+out_val[0] = sum_fp64(radians_fp64(lnglat_fp64.xy), PI_FP64 * ONE);
 #else
-  out_val[0] = sum_fp64(radians_fp64(lnglat_fp64.xy), PI_FP64);
+out_val[0] = sum_fp64(radians_fp64(lnglat_fp64.xy), PI_FP64);
 #endif
-  out_val[1] = sum_fp64(PI_FP64,
-    log_fp64(tan_fp64(sum_fp64(PI_4_FP64, radians_fp64(lnglat_fp64.zw) / 2.0))));
-  return;
+out_val[1] = sum_fp64(PI_FP64,
+log_fp64(tan_fp64(sum_fp64(PI_4_FP64, radians_fp64(lnglat_fp64.zw) / 2.0))));
+return;
 }
-
 void project_position_fp64(vec4 position_fp64, out vec2 out_val[2]) {
-  vec2 pos_fp64[2];
-  mercatorProject_fp64(position_fp64, pos_fp64);
-  out_val[0] = mul_fp64(pos_fp64[0], WORLD_SCALE_FP64);
-  out_val[1] = mul_fp64(pos_fp64[1], WORLD_SCALE_FP64);
-
-  return;
+vec2 pos_fp64[2];
+mercatorProject_fp64(position_fp64, pos_fp64);
+out_val[0] = mul_fp64(pos_fp64[0], WORLD_SCALE_FP64);
+out_val[1] = mul_fp64(pos_fp64[1], WORLD_SCALE_FP64);
+return;
 }
-
 void project_position_fp64(vec2 position, vec2 position64xyLow, out vec2 out_val[2]) {
-  vec4 position64xy = vec4(
-    position.x, position64xyLow.x,
-    position.y, position64xyLow.y);
-
-  project_position_fp64(position64xy, out_val);
+vec4 position64xy = vec4(
+position.x, position64xyLow.x,
+position.y, position64xyLow.y);
+project_position_fp64(position64xy, out_val);
 }
-
 vec4 project_common_position_to_clipspace_fp64(vec2 vertex_pos_modelspace[4]) {
-  vec2 vertex_pos_clipspace[4];
-  mat4_vec4_mul_fp64(project_uViewProjectionMatrixFP64, vertex_pos_modelspace,
-    vertex_pos_clipspace);
-  return vec4(
-    vertex_pos_clipspace[0].x,
-    vertex_pos_clipspace[1].x,
-    vertex_pos_clipspace[2].x,
-    vertex_pos_clipspace[3].x
-    );
+vec2 vertex_pos_clipspace[4];
+mat4_vec4_mul_fp64(project_uViewProjectionMatrixFP64, vertex_pos_modelspace,
+vertex_pos_clipspace);
+return vec4(
+vertex_pos_clipspace[0].x,
+vertex_pos_clipspace[1].x,
+vertex_pos_clipspace[2].x,
+vertex_pos_clipspace[3].x
+);
 }
-
 vec4 project_position_to_clipspace(
-  vec3 position, vec3 position64xyLow, vec3 offset, out vec4 commonPosition
+vec3 position, vec3 position64xyLow, vec3 offset, out vec4 commonPosition
 ) {
-  // This is the local offset to the instance position
-  vec2 offset64[4];
-  vec4_fp64(vec4(offset, 0.0), offset64);
-
-  float z = project_size(position.z);
-
-  // Apply web mercator projection (depends on coordinate system imn use)
-  vec2 projectedPosition64xy[2];
-  project_position_fp64(position.xy, position64xyLow.xy, projectedPosition64xy);
-
-  vec2 commonPosition64[4];
-  commonPosition64[0] = sum_fp64(offset64[0], projectedPosition64xy[0]);
-  commonPosition64[1] = sum_fp64(offset64[1], projectedPosition64xy[1]);
-  commonPosition64[2] = sum_fp64(offset64[2], vec2(z, 0.0));
-  commonPosition64[3] = vec2(1.0, 0.0);
-
-  commonPosition = vec4(projectedPosition64xy[0].x, projectedPosition64xy[1].x, z, 1.0);
-
-  return project_common_position_to_clipspace_fp64(commonPosition64);
+vec2 offset64[4];
+vec4_fp64(vec4(offset, 0.0), offset64);
+float z = project_size(position.z);
+vec2 projectedPosition64xy[2];
+project_position_fp64(position.xy, position64xyLow.xy, projectedPosition64xy);
+vec2 commonPosition64[4];
+commonPosition64[0] = sum_fp64(offset64[0], projectedPosition64xy[0]);
+commonPosition64[1] = sum_fp64(offset64[1], projectedPosition64xy[1]);
+commonPosition64[2] = sum_fp64(offset64[2], vec2(z, 0.0));
+commonPosition64[3] = vec2(1.0, 0.0);
+commonPosition = vec4(projectedPosition64xy[0].x, projectedPosition64xy[1].x, z, 1.0);
+return project_common_position_to_clipspace_fp64(commonPosition64);
 }
-
 vec4 project_position_to_clipspace(
-  vec3 position, vec3 position64xyLow, vec3 offset
+vec3 position, vec3 position64xyLow, vec3 offset
 ) {
-  vec4 commonPosition;
-  return project_position_to_clipspace(
-    position, position64xyLow, offset, commonPosition
-  );
+vec4 commonPosition;
+return project_position_to_clipspace(
+position, position64xyLow, offset, commonPosition
+);
 }
 `;
 
@@ -829,41 +804,36 @@ in vec2 vDashArray;
 in float vDashOffset;
 `,
     "fs:#main-start": `
-  float solidLength = vDashArray.x;
-  float gapLength = vDashArray.y;
-  float unitLength = solidLength + gapLength;
-
-  float offset;
-
-  if (unitLength > 0.0) {
-    if (dashAlignMode == 0.0) {
-      offset = vDashOffset;
-    } else {
-      unitLength = vPathLength / round(vPathLength / unitLength);
-      offset = solidLength / 2.0;
-    }
-
-    float unitOffset = mod(vPathPosition.y + offset, unitLength);
-
-    if (gapLength > 0.0 && unitOffset > solidLength) {
-      if (capType <= 0.5) {
-        if (!(dashGapPickable && bool(picking.isActive))) {
-          discard;
-        }
-      } else {
-        // caps are rounded, test the distance to solid ends
-        float distToEnd = length(vec2(
-          min(unitOffset - solidLength, unitLength - unitOffset),
-          vPathPosition.x
-        ));
-        if (distToEnd > 1.0) {
-          if (!(dashGapPickable && bool(picking.isActive))) {
-            discard;
-          }
-        }
-      }
-    }
-  }
+float solidLength = vDashArray.x;
+float gapLength = vDashArray.y;
+float unitLength = solidLength + gapLength;
+float offset;
+if (unitLength > 0.0) {
+if (dashAlignMode == 0.0) {
+offset = vDashOffset;
+} else {
+unitLength = vPathLength / round(vPathLength / unitLength);
+offset = solidLength / 2.0;
+}
+float unitOffset = mod(vPathPosition.y + offset, unitLength);
+if (gapLength > 0.0 && unitOffset > solidLength) {
+if (capType <= 0.5) {
+if (!(dashGapPickable && bool(picking.isActive))) {
+discard;
+}
+} else {
+float distToEnd = length(vec2(
+min(unitOffset - solidLength, unitLength - unitOffset),
+vPathPosition.x
+));
+if (distToEnd > 1.0) {
+if (!(dashGapPickable && bool(picking.isActive))) {
+discard;
+}
+}
+}
+}
+}
 `
   }
 };
@@ -873,22 +843,22 @@ var offsetShaders = {
 in float instanceOffsets;
 `,
     "vs:DECKGL_FILTER_SIZE": `
-  float offsetWidth = abs(instanceOffsets * 2.0) + 1.0;
-  size *= offsetWidth;
+float offsetWidth = abs(instanceOffsets * 2.0) + 1.0;
+size *= offsetWidth;
 `,
     "vs:#main-end": `
-  float offsetWidth = abs(instanceOffsets * 2.0) + 1.0;
-  float offsetDir = sign(instanceOffsets);
-  vPathPosition.x = (vPathPosition.x + offsetDir) * offsetWidth - offsetDir;
-  vPathPosition.y *= offsetWidth;
-  vPathLength *= offsetWidth;
+float offsetWidth = abs(instanceOffsets * 2.0) + 1.0;
+float offsetDir = sign(instanceOffsets);
+vPathPosition.x = (vPathPosition.x + offsetDir) * offsetWidth - offsetDir;
+vPathPosition.y *= offsetWidth;
+vPathLength *= offsetWidth;
 `,
     "fs:#main-start": `
-  float isInside;
-  isInside = step(-1.0, vPathPosition.x) * step(vPathPosition.x, 1.0);
-  if (isInside == 0.0) {
-    discard;
-  }
+float isInside;
+isInside = step(-1.0, vPathPosition.x) * step(vPathPosition.x, 1.0);
+if (isInside == 0.0) {
+discard;
+}
 `
   }
 };
@@ -988,26 +958,23 @@ var PathStyleExtension = _PathStyleExtension;
 // dist/fill-style/fill-style-extension.js
 var import_core9 = require("@deck.gl/core");
 
-// dist/fill-style/shaders.glsl.js
+// dist/fill-style/shader-module.js
 var import_core8 = require("@deck.gl/core");
 var patternVs = `
 #ifdef NON_INSTANCED_MODEL
-  #define FILL_PATTERN_FRAME_ATTRIB fillPatternFrames
-  #define FILL_PATTERN_SCALE_ATTRIB fillPatternScales
-  #define FILL_PATTERN_OFFSET_ATTRIB fillPatternOffsets
+#define FILL_PATTERN_FRAME_ATTRIB fillPatternFrames
+#define FILL_PATTERN_SCALE_ATTRIB fillPatternScales
+#define FILL_PATTERN_OFFSET_ATTRIB fillPatternOffsets
 #else
-  #define FILL_PATTERN_FRAME_ATTRIB instanceFillPatternFrames
-  #define FILL_PATTERN_SCALE_ATTRIB instanceFillPatternScales
-  #define FILL_PATTERN_OFFSET_ATTRIB instanceFillPatternOffsets
+#define FILL_PATTERN_FRAME_ATTRIB instanceFillPatternFrames
+#define FILL_PATTERN_SCALE_ATTRIB instanceFillPatternScales
+#define FILL_PATTERN_OFFSET_ATTRIB instanceFillPatternOffsets
 #endif
-
 in vec4 FILL_PATTERN_FRAME_ATTRIB;
 in float FILL_PATTERN_SCALE_ATTRIB;
 in vec2 FILL_PATTERN_OFFSET_ATTRIB;
-
 uniform bool fill_patternEnabled;
 uniform vec2 fill_patternTextureSize;
-
 out vec2 fill_uv;
 out vec4 fill_patternBounds;
 out vec4 fill_patternPlacement;
@@ -1018,39 +985,35 @@ uniform bool fill_patternMask;
 uniform sampler2D fill_patternTexture;
 uniform vec2 fill_uvCoordinateOrigin;
 uniform vec2 fill_uvCoordinateOrigin64Low;
-
 in vec4 fill_patternBounds;
 in vec4 fill_patternPlacement;
 in vec2 fill_uv;
-
 const float FILL_UV_SCALE = 512.0 / 40000000.0;
 `;
 var inject3 = {
   "vs:DECKGL_FILTER_GL_POSITION": `
-    fill_uv = geometry.position.xy;
-  `,
+fill_uv = geometry.position.xy;
+`,
   "vs:DECKGL_FILTER_COLOR": `
-    if (fill_patternEnabled) {
-      fill_patternBounds = FILL_PATTERN_FRAME_ATTRIB / vec4(fill_patternTextureSize, fill_patternTextureSize);
-      fill_patternPlacement.xy = FILL_PATTERN_OFFSET_ATTRIB;
-      fill_patternPlacement.zw = FILL_PATTERN_SCALE_ATTRIB * FILL_PATTERN_FRAME_ATTRIB.zw;
-    }
-  `,
+if (fill_patternEnabled) {
+fill_patternBounds = FILL_PATTERN_FRAME_ATTRIB / vec4(fill_patternTextureSize, fill_patternTextureSize);
+fill_patternPlacement.xy = FILL_PATTERN_OFFSET_ATTRIB;
+fill_patternPlacement.zw = FILL_PATTERN_SCALE_ATTRIB * FILL_PATTERN_FRAME_ATTRIB.zw;
+}
+`,
   "fs:DECKGL_FILTER_COLOR": `
-    if (fill_patternEnabled) {
-      vec2 scale = FILL_UV_SCALE * fill_patternPlacement.zw;
-      vec2 patternUV = mod(mod(fill_uvCoordinateOrigin, scale) + fill_uvCoordinateOrigin64Low + fill_uv, scale) / scale;
-      patternUV = mod(fill_patternPlacement.xy + patternUV, 1.0);
-
-      vec2 texCoords = fill_patternBounds.xy + fill_patternBounds.zw * patternUV;
-
-      vec4 patternColor = texture(fill_patternTexture, texCoords);
-      color.a *= patternColor.a;
-      if (!fill_patternMask) {
-        color.rgb = patternColor.rgb;
-      }
-    }
-  `
+if (fill_patternEnabled) {
+vec2 scale = FILL_UV_SCALE * fill_patternPlacement.zw;
+vec2 patternUV = mod(mod(fill_uvCoordinateOrigin, scale) + fill_uvCoordinateOrigin64Low + fill_uv, scale) / scale;
+patternUV = mod(fill_patternPlacement.xy + patternUV, 1.0);
+vec2 texCoords = fill_patternBounds.xy + fill_patternBounds.zw * patternUV;
+vec4 patternColor = texture(fill_patternTexture, texCoords);
+color.a *= patternColor.a;
+if (!fill_patternMask) {
+color.rgb = patternColor.rgb;
+}
+}
+`
 };
 function getPatternUniforms(opts, uniforms) {
   if (!opts) {
@@ -1218,9 +1181,8 @@ var defaultProps5 = {
 };
 var shaderFunction = `
 uniform vec4 clip_bounds;
-
 bool clip_isInBounds(vec2 position) {
-  return position.x >= clip_bounds[0] && position.y >= clip_bounds[1] && position.x < clip_bounds[2] && position.y < clip_bounds[3];
+return position.x >= clip_bounds[0] && position.y >= clip_bounds[1] && position.x < clip_bounds[2] && position.y < clip_bounds[3];
 }
 `;
 var shaderModuleVs = {
@@ -1232,13 +1194,13 @@ var injectionVs = {
 out float clip_isVisible;
 `,
   "vs:DECKGL_FILTER_GL_POSITION": `
-  clip_isVisible = float(clip_isInBounds(geometry.worldPosition.xy));
+clip_isVisible = float(clip_isInBounds(geometry.worldPosition.xy));
 `,
   "fs:#decl": `
 in float clip_isVisible;
 `,
   "fs:DECKGL_FILTER_COLOR": `
-  if (clip_isVisible < 0.5) discard;
+if (clip_isVisible < 0.5) discard;
 `
 };
 var shaderModuleFs = {
@@ -1250,13 +1212,13 @@ var injectionFs = {
 out vec2 clip_commonPosition;
 `,
   "vs:DECKGL_FILTER_GL_POSITION": `
-  clip_commonPosition = geometry.position.xy;
+clip_commonPosition = geometry.position.xy;
 `,
   "fs:#decl": `
 in vec2 clip_commonPosition;
 `,
   "fs:DECKGL_FILTER_COLOR": `
-  if (!clip_isInBounds(clip_commonPosition)) discard;
+if (!clip_isInBounds(clip_commonPosition)) discard;
 `
 };
 var _ClipExtension = class extends import_core10.LayerExtension {
@@ -1309,77 +1271,65 @@ in float collisionPriorities;
 #else
 in float instanceCollisionPriorities;
 #endif
-
 uniform sampler2D collision_texture;
 uniform bool collision_sort;
 uniform bool collision_enabled;
-
 vec2 collision_getCoords(vec4 position) {
-  vec4 collision_clipspace = project_common_position_to_clipspace(position);
-  return (1.0 + collision_clipspace.xy / collision_clipspace.w) / 2.0;
+vec4 collision_clipspace = project_common_position_to_clipspace(position);
+return (1.0 + collision_clipspace.xy / collision_clipspace.w) / 2.0;
 }
-
 float collision_match(vec2 tex, vec3 pickingColor) {
-  vec4 collision_pickingColor = texture(collision_texture, tex);
-  float delta = dot(abs(collision_pickingColor.rgb - pickingColor), vec3(1.0));
-  float e = 0.001;
-  return step(delta, e);
+vec4 collision_pickingColor = texture(collision_texture, tex);
+float delta = dot(abs(collision_pickingColor.rgb - pickingColor), vec3(1.0));
+float e = 0.001;
+return step(delta, e);
 }
-
 float collision_isVisible(vec2 texCoords, vec3 pickingColor) {
-  if (!collision_enabled) {
-    return 1.0;
-  }
-
-  // Visibility test, sample area of 5x5 pixels in order to fade in/out.
-  // Due to the locality, the lookups will be cached
-  // This reduces the flicker present when objects are shown/hidden
-  const int N = 2;
-  float accumulator = 0.0;
-  vec2 step = vec2(1.0 / project_uViewportSize);
-
-  const float floatN = float(N);
-  vec2 delta = -floatN * step;
-  for(int i = -N; i <= N; i++) {
-    delta.x = -step.x * floatN;
-    for(int j = -N; j <= N; j++) {
-      accumulator += collision_match(texCoords + delta, pickingColor);
-      delta.x += step.x;
-    }
-    delta.y += step.y;
-  }
-
-  float W = 2.0 * floatN + 1.0;
-  return pow(accumulator / (W * W), 2.2);
+if (!collision_enabled) {
+return 1.0;
+}
+const int N = 2;
+float accumulator = 0.0;
+vec2 step = vec2(1.0 / project_uViewportSize);
+const float floatN = float(N);
+vec2 delta = -floatN * step;
+for(int i = -N; i <= N; i++) {
+delta.x = -step.x * floatN;
+for(int j = -N; j <= N; j++) {
+accumulator += collision_match(texCoords + delta, pickingColor);
+delta.x += step.x;
+}
+delta.y += step.y;
+}
+float W = 2.0 * floatN + 1.0;
+return pow(accumulator / (W * W), 2.2);
 }
 `;
 var inject4 = {
   "vs:#decl": `
-  float collision_fade = 1.0;
+float collision_fade = 1.0;
 `,
   "vs:DECKGL_FILTER_GL_POSITION": `
-  if (collision_sort) {
-    #ifdef NON_INSTANCED_MODEL
-    float collisionPriority = collisionPriorities;
-    #else
-    float collisionPriority = instanceCollisionPriorities;
-    #endif
-    position.z = -0.001 * collisionPriority * position.w; // Support range -1000 -> 1000
-  }
-
-  if (collision_enabled) {
-    vec4 collision_common_position = project_position(vec4(geometry.worldPosition, 1.0));
-    vec2 collision_texCoords = collision_getCoords(collision_common_position);
-    collision_fade = collision_isVisible(collision_texCoords, geometry.pickingColor / 255.0);
-    if (collision_fade < 0.0001) {
-      // Position outside clip space bounds to discard
-      position = vec4(0.0, 0.0, 2.0, 1.0);
-    }
-  }
-  `,
+if (collision_sort) {
+#ifdef NON_INSTANCED_MODEL
+float collisionPriority = collisionPriorities;
+#else
+float collisionPriority = instanceCollisionPriorities;
+#endif
+position.z = -0.001 * collisionPriority * position.w;
+}
+if (collision_enabled) {
+vec4 collision_common_position = project_position(vec4(geometry.worldPosition, 1.0));
+vec2 collision_texCoords = collision_getCoords(collision_common_position);
+collision_fade = collision_isVisible(collision_texCoords, geometry.pickingColor / 255.0);
+if (collision_fade < 0.0001) {
+position = vec4(0.0, 0.0, 2.0, 1.0);
+}
+}
+`,
   "vs:DECKGL_FILTER_COLOR": `
-  color.a *= collision_fade;
-  `
+color.a *= collision_fade;
+`
 };
 var getCollisionUniforms = (opts, uniforms) => {
   if (!opts || !("dummyCollisionMap" in opts)) {
@@ -1434,7 +1384,7 @@ var import_core15 = require("@deck.gl/core");
 var import_core16 = require("@math.gl/core");
 
 // dist/mask/mask-pass.js
-var import_constants3 = require("@luma.gl/constants");
+var import_constants2 = require("@luma.gl/constants");
 var import_core13 = require("@deck.gl/core");
 var MaskPass = class extends import_core13._LayersPass {
   constructor(device, props) {
@@ -1464,8 +1414,8 @@ var MaskPass = class extends import_core13._LayersPass {
     const clearColor = [255, 255, 255, 255];
     return this.device.withParametersWebGL({
       blend: true,
-      blendFunc: [import_constants3.GL.ZERO, import_constants3.GL.ONE],
-      blendEquation: import_constants3.GL.FUNC_SUBTRACT,
+      blendFunc: [0, 1],
+      blendEquation: 32778,
       colorMask,
       depthTest: false
     }, () => super.render({ ...options, clearColor, target: this.fbo, pass: "mask" }));
@@ -1981,7 +1931,7 @@ var vs4 = `
 uniform vec4 mask_bounds;
 uniform bool mask_maskByInstance;
 vec2 mask_getCoords(vec4 position) {
-  return (position.xy - mask_bounds.xy) / (mask_bounds.zw - mask_bounds.xy);
+return (position.xy - mask_bounds.xy) / (mask_bounds.zw - mask_bounds.xy);
 }
 `;
 var fs3 = `
@@ -1990,26 +1940,25 @@ uniform int mask_channel;
 uniform bool mask_enabled;
 uniform bool mask_inverted;
 bool mask_isInBounds(vec2 texCoords) {
-  if (!mask_enabled) {
-    return true;
-  }
-  vec4 maskColor = texture(mask_texture, texCoords);
-  float maskValue = 1.0;
-  if (mask_channel == 0) {
-    maskValue = maskColor.r;
-  } else if (mask_channel == 1) {
-    maskValue = maskColor.g;
-  } else if (mask_channel == 2) {
-    maskValue = maskColor.b;
-  } else if (mask_channel == 3) {
-    maskValue = maskColor.a;
-  }
-
-  if (mask_inverted) {
-    return maskValue >= 0.5;
-  } else {
-    return maskValue < 0.5;
-  }
+if (!mask_enabled) {
+return true;
+}
+vec4 maskColor = texture(mask_texture, texCoords);
+float maskValue = 1.0;
+if (mask_channel == 0) {
+maskValue = maskColor.r;
+} else if (mask_channel == 1) {
+maskValue = maskColor.g;
+} else if (mask_channel == 2) {
+maskValue = maskColor.b;
+} else if (mask_channel == 3) {
+maskValue = maskColor.a;
+}
+if (mask_inverted) {
+return maskValue >= 0.5;
+} else {
+return maskValue < 0.5;
+}
 }
 `;
 var inject5 = {
@@ -2017,27 +1966,23 @@ var inject5 = {
 out vec2 mask_texCoords;
 `,
   "vs:#main-end": `
-   vec4 mask_common_position;
-   if (mask_maskByInstance) {
-     mask_common_position = project_position(vec4(geometry.worldPosition, 1.0));
-   } else {
-     mask_common_position = geometry.position;
-   }
-   mask_texCoords = mask_getCoords(mask_common_position);
+vec4 mask_common_position;
+if (mask_maskByInstance) {
+mask_common_position = project_position(vec4(geometry.worldPosition, 1.0));
+} else {
+mask_common_position = geometry.position;
+}
+mask_texCoords = mask_getCoords(mask_common_position);
 `,
   "fs:#decl": `
 in vec2 mask_texCoords;
 `,
   "fs:#main-start": `
-  if (mask_enabled) {
-    bool mask = mask_isInBounds(mask_texCoords);
-
-    // Debug: show extent of render target
-    // fragColor = vec4(mask_texCoords, 0.0, 1.0);
-    fragColor = texture(mask_texture, mask_texCoords);
-
-    if (!mask) discard;
-  }
+if (mask_enabled) {
+bool mask = mask_isInBounds(mask_texCoords);
+fragColor = texture(mask_texture, mask_texCoords);
+if (!mask) discard;
+}
 `
 };
 var getMaskUniforms = (opts) => {
@@ -2138,59 +2083,56 @@ uniform float terrain_mode;
 uniform sampler2D terrain_map;
 uniform vec4 terrain_bounds;
 out vec3 commonPos;
-${TERRAIN_MODE_CONSTANTS}
-    `,
+` + TERRAIN_MODE_CONSTANTS,
     "vs:#main-start": `
 if (terrain_mode == TERRAIN_MODE_SKIP) {
-  gl_Position = vec4(0.0);
-  return;
+gl_Position = vec4(0.0);
+return;
 }
 `,
     "vs:DECKGL_FILTER_GL_POSITION": `
 commonPos = geometry.position.xyz;
 if (terrain_mode == TERRAIN_MODE_WRITE_HEIGHT_MAP) {
-  vec2 texCoords = (commonPos.xy - terrain_bounds.xy) / terrain_bounds.zw;
-  position = vec4(texCoords * 2.0 - 1.0, 0.0, 1.0);
-  commonPos.z += project_uCommonOrigin.z;
+vec2 texCoords = (commonPos.xy - terrain_bounds.xy) / terrain_bounds.zw;
+position = vec4(texCoords * 2.0 - 1.0, 0.0, 1.0);
+commonPos.z += project_uCommonOrigin.z;
 }
 if (terrain_mode == TERRAIN_MODE_USE_HEIGHT_MAP) {
-  vec3 anchor = geometry.worldPosition;
-  anchor.z = 0.0;
-  vec3 anchorCommon = project_position(anchor);
-  vec2 texCoords = (anchorCommon.xy - terrain_bounds.xy) / terrain_bounds.zw;
-  if (texCoords.x >= 0.0 && texCoords.y >= 0.0 && texCoords.x <= 1.0 && texCoords.y <= 1.0) {
-    float terrainZ = texture(terrain_map, texCoords).r;
-    geometry.position.z += terrainZ;
-    position = project_common_position_to_clipspace(geometry.position);
-  }
+vec3 anchor = geometry.worldPosition;
+anchor.z = 0.0;
+vec3 anchorCommon = project_position(anchor);
+vec2 texCoords = (anchorCommon.xy - terrain_bounds.xy) / terrain_bounds.zw;
+if (texCoords.x >= 0.0 && texCoords.y >= 0.0 && texCoords.x <= 1.0 && texCoords.y <= 1.0) {
+float terrainZ = texture(terrain_map, texCoords).r;
+geometry.position.z += terrainZ;
+position = project_common_position_to_clipspace(geometry.position);
 }
-    `,
+}
+`,
     "fs:#decl": `
 uniform float terrain_mode;
 uniform sampler2D terrain_map;
 uniform vec4 terrain_bounds;
 in vec3 commonPos;
-${TERRAIN_MODE_CONSTANTS}
-    `,
+` + TERRAIN_MODE_CONSTANTS,
     "fs:#main-start": `
 if (terrain_mode == TERRAIN_MODE_WRITE_HEIGHT_MAP) {
-  fragColor = vec4(commonPos.z, 0.0, 0.0, 1.0);
-  return;
+fragColor = vec4(commonPos.z, 0.0, 0.0, 1.0);
+return;
 }
-    `,
+`,
     "fs:DECKGL_FILTER_COLOR": `
 if ((terrain_mode == TERRAIN_MODE_USE_COVER) || (terrain_mode == TERRAIN_MODE_USE_COVER_ONLY)) {
-  vec2 texCoords = (commonPos.xy - terrain_bounds.xy) / terrain_bounds.zw;
-  vec4 pixel = texture(terrain_map, texCoords);
-  if (terrain_mode == TERRAIN_MODE_USE_COVER_ONLY) {
-    color = pixel;
-  } else {
-    // pixel is premultiplied
-    color = pixel + color * (1.0 - pixel.a);
-  }
-  return;
+vec2 texCoords = (commonPos.xy - terrain_bounds.xy) / terrain_bounds.zw;
+vec4 pixel = texture(terrain_map, texCoords);
+if (terrain_mode == TERRAIN_MODE_USE_COVER_ONLY) {
+color = pixel;
+} else {
+color = pixel + color * (1.0 - pixel.a);
 }
-    `
+return;
+}
+`
   },
   getUniforms: (opts = {}, uniforms) => {
     var _a;
@@ -2236,15 +2178,15 @@ if ((terrain_mode == TERRAIN_MODE_USE_COVER) || (terrain_mode == TERRAIN_MODE_US
 };
 
 // dist/terrain/utils.js
-var import_constants4 = require("@luma.gl/constants");
+var import_constants3 = require("@luma.gl/constants");
 function createRenderTarget(device, opts) {
   return device.createFramebuffer({
     id: opts.id,
     colorAttachments: [
       device.createTexture({
         ...opts.float && {
-          format: device.info.type === "webgl2" ? "rgba32float" : "rgba8unorm",
-          type: import_constants4.GL.FLOAT
+          format: "rgba32float",
+          type: 5126
         },
         mipmaps: false,
         sampler: {
@@ -2418,7 +2360,7 @@ function intersect(b1, b2) {
 }
 
 // dist/terrain/terrain-pass.js
-var import_constants5 = require("@luma.gl/constants");
+var import_constants4 = require("@luma.gl/constants");
 var import_core23 = require("@deck.gl/core");
 var TerrainPass = class extends import_core23._LayersPass {
   getRenderableLayers(viewport, opts) {
@@ -2443,8 +2385,8 @@ var TerrainPass = class extends import_core23._LayersPass {
     this.device.withParametersWebGL({
       clearColor: [0, 0, 0, 0],
       blend: true,
-      blendFunc: [import_constants5.GL.ONE, import_constants5.GL.ONE],
-      blendEquation: import_constants5.GL.MAX,
+      blendFunc: [1, 1],
+      blendEquation: 32776,
       depthTest: false
     }, () => this.render({
       ...opts,