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

package/dist/dist.dev.js

@@ -79,7 +79,12 @@ var __exports__ = (() => {
 
   // src/brushing/shader-module.ts
   var import_core2 = __toESM(require_core(), 1);
-  var vs = `
+
+  // src/utils/syntax-tags.ts
+  var glsl = (s) => `${s}`;
+
+  // src/brushing/shader-module.ts
+  var vs = glsl`
   uniform bool brushing_enabled;
   uniform int brushing_target;
   uniform vec2 brushing_mousePos;
@@ -112,7 +117,7 @@ var __exports__ = (() => {
     brushing_isVisible = float(visible);
   }
 `;
-  var fs = `
+  var fs = glsl`
   uniform bool brushing_enabled;
   in float brushing_isVisible;
 `;
@@ -123,7 +128,7 @@ var __exports__ = (() => {
     source_target: 3
   };
   var inject = {
-    "vs:DECKGL_FILTER_GL_POSITION": `
+    "vs:DECKGL_FILTER_GL_POSITION": glsl`
     vec2 brushingTarget;
     vec2 brushingSource;
     if (brushing_target == 3) {
@@ -237,8 +242,202 @@ var __exports__ = (() => {
   BrushingExtension.defaultProps = defaultProps;
   BrushingExtension.extensionName = "BrushingExtension";
 
-  // ../../node_modules/@luma.gl/constants/dist/constants-enum.js
-  var GLEnum = function(GLEnum2) {
+  // src/data-filter/data-filter-extension.ts
+  var import_core4 = __toESM(require_core(), 1);
+
+  // src/data-filter/shader-module.ts
+  var vs2 = glsl`
+uniform DATAFILTER_TYPE filter_min;
+uniform DATAFILTER_TYPE filter_softMin;
+uniform DATAFILTER_TYPE filter_softMax;
+uniform DATAFILTER_TYPE filter_max;
+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
+#else
+  #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;
+#endif
+in DATACATEGORY_TYPE DATACATEGORY_ATTRIB;
+
+out float dataFilter_value;
+
+float dataFilter_reduceValue(float value) {
+  return value;
+}
+float dataFilter_reduceValue(vec2 value) {
+  return min(value.x, value.y);
+}
+float dataFilter_reduceValue(vec3 value) {
+  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));
+}
+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;
+  }
+}
+`;
+  var fs2 = glsl`
+uniform bool filter_transformColor;
+in float dataFilter_value;
+`;
+  function getUniforms(opts) {
+    if (!opts || !("extensions" in opts)) {
+      return {};
+    }
+    const {
+      filterRange = [-1, 1],
+      filterEnabled = true,
+      filterTransformSize = true,
+      filterTransformColor = true
+    } = opts;
+    const filterSoftRange = opts.filterSoftRange || filterRange;
+    return {
+      ...Number.isFinite(filterRange[0]) ? {
+        filter_min: filterRange[0],
+        filter_softMin: filterSoftRange[0],
+        filter_softMax: filterSoftRange[1],
+        filter_max: filterRange[1]
+      } : {
+        filter_min: filterRange.map((r) => r[0]),
+        filter_softMin: filterSoftRange.map((r) => r[0]),
+        filter_softMax: filterSoftRange.map((r) => r[1]),
+        filter_max: filterRange.map((r) => r[1])
+      },
+      filter_enabled: filterEnabled,
+      filter_useSoftMargin: Boolean(opts.filterSoftRange),
+      filter_transformSize: filterEnabled && filterTransformSize,
+      filter_transformColor: filterEnabled && filterTransformColor
+    };
+  }
+  function getUniforms64(opts) {
+    if (!opts || !("extensions" in opts)) {
+      return {};
+    }
+    const uniforms = getUniforms(opts);
+    if (Number.isFinite(uniforms.filter_min)) {
+      const min64High = Math.fround(uniforms.filter_min);
+      uniforms.filter_min -= min64High;
+      uniforms.filter_softMin -= min64High;
+      uniforms.filter_min64High = min64High;
+      const max64High = Math.fround(uniforms.filter_max);
+      uniforms.filter_max -= max64High;
+      uniforms.filter_softMax -= max64High;
+      uniforms.filter_max64High = max64High;
+    } else {
+      const min64High = uniforms.filter_min.map(Math.fround);
+      uniforms.filter_min = uniforms.filter_min.map((x, i) => x - min64High[i]);
+      uniforms.filter_softMin = uniforms.filter_softMin.map((x, i) => x - min64High[i]);
+      uniforms.filter_min64High = min64High;
+      const max64High = uniforms.filter_max.map(Math.fround);
+      uniforms.filter_max = uniforms.filter_max.map((x, i) => x - max64High[i]);
+      uniforms.filter_softMax = uniforms.filter_softMax.map((x, i) => x - max64High[i]);
+      uniforms.filter_max64High = max64High;
+    }
+    return uniforms;
+  }
+  var inject2 = {
+    "vs:#main-start": glsl`
+    #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": glsl`
+    if (dataFilter_value == 0.0) {
+      gl_Position = vec4(0.);
+    }
+  `,
+    "vs:DECKGL_FILTER_SIZE": glsl`
+    if (filter_transformSize) {
+      size = size * dataFilter_value;
+    }
+  `,
+    "fs:DECKGL_FILTER_COLOR": glsl`
+    if (dataFilter_value == 0.0) discard;
+    if (filter_transformColor) {
+      color.a *= dataFilter_value;
+    }
+  `
+  };
+  var shaderModule = {
+    name: "data-filter",
+    vs: vs2,
+    fs: fs2,
+    inject: inject2,
+    getUniforms
+  };
+  var shaderModule64 = {
+    name: "data-filter-fp64",
+    vs: vs2,
+    fs: fs2,
+    inject: inject2,
+    getUniforms: getUniforms64
+  };
+
+  // src/data-filter/aggregator.ts
+  var import_engine = __toESM(require_engine(), 1);
+
+  // ../../node_modules/@luma.gl/constants/dist/webgl-constants.js
+  var GLEnum;
+  (function(GLEnum2) {
     GLEnum2[GLEnum2["DEPTH_BUFFER_BIT"] = 256] = "DEPTH_BUFFER_BIT";
     GLEnum2[GLEnum2["STENCIL_BUFFER_BIT"] = 1024] = "STENCIL_BUFFER_BIT";
     GLEnum2[GLEnum2["COLOR_BUFFER_BIT"] = 16384] = "COLOR_BUFFER_BIT";
@@ -771,15 +970,10 @@ var __exports__ = (() => {
     GLEnum2[GLEnum2["INVALID_INDEX"] = 4294967295] = "INVALID_INDEX";
     GLEnum2[GLEnum2["TIMEOUT_IGNORED"] = -1] = "TIMEOUT_IGNORED";
     GLEnum2[GLEnum2["MAX_CLIENT_WAIT_TIMEOUT_WEBGL"] = 37447] = "MAX_CLIENT_WAIT_TIMEOUT_WEBGL";
-    GLEnum2[GLEnum2["VERTEX_ATTRIB_ARRAY_DIVISOR_ANGLE"] = 35070] = "VERTEX_ATTRIB_ARRAY_DIVISOR_ANGLE";
     GLEnum2[GLEnum2["UNMASKED_VENDOR_WEBGL"] = 37445] = "UNMASKED_VENDOR_WEBGL";
     GLEnum2[GLEnum2["UNMASKED_RENDERER_WEBGL"] = 37446] = "UNMASKED_RENDERER_WEBGL";
     GLEnum2[GLEnum2["MAX_TEXTURE_MAX_ANISOTROPY_EXT"] = 34047] = "MAX_TEXTURE_MAX_ANISOTROPY_EXT";
     GLEnum2[GLEnum2["TEXTURE_MAX_ANISOTROPY_EXT"] = 34046] = "TEXTURE_MAX_ANISOTROPY_EXT";
-    GLEnum2[GLEnum2["SRGB_EXT"] = 35904] = "SRGB_EXT";
-    GLEnum2[GLEnum2["SRGB_ALPHA_EXT"] = 35906] = "SRGB_ALPHA_EXT";
-    GLEnum2[GLEnum2["SRGB8_ALPHA8_EXT"] = 35907] = "SRGB8_ALPHA8_EXT";
-    GLEnum2[GLEnum2["FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING_EXT"] = 33296] = "FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING_EXT";
     GLEnum2[GLEnum2["R16_EXT"] = 33322] = "R16_EXT";
     GLEnum2[GLEnum2["RG16_EXT"] = 33324] = "RG16_EXT";
     GLEnum2[GLEnum2["RGB16_EXT"] = 32852] = "RGB16_EXT";
@@ -850,50 +1044,6 @@ var __exports__ = (() => {
     GLEnum2[GLEnum2["COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR"] = 37851] = "COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR";
     GLEnum2[GLEnum2["COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR"] = 37852] = "COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR";
     GLEnum2[GLEnum2["COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR"] = 37853] = "COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR";
-    GLEnum2[GLEnum2["UNSIGNED_INT_24_8_WEBGL"] = 34042] = "UNSIGNED_INT_24_8_WEBGL";
-    GLEnum2[GLEnum2["HALF_FLOAT_OES"] = 36193] = "HALF_FLOAT_OES";
-    GLEnum2[GLEnum2["RGBA32F_EXT"] = 34836] = "RGBA32F_EXT";
-    GLEnum2[GLEnum2["RGB32F_EXT"] = 34837] = "RGB32F_EXT";
-    GLEnum2[GLEnum2["FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE_EXT"] = 33297] = "FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE_EXT";
-    GLEnum2[GLEnum2["UNSIGNED_NORMALIZED_EXT"] = 35863] = "UNSIGNED_NORMALIZED_EXT";
-    GLEnum2[GLEnum2["MIN_EXT"] = 32775] = "MIN_EXT";
-    GLEnum2[GLEnum2["MAX_EXT"] = 32776] = "MAX_EXT";
-    GLEnum2[GLEnum2["FRAGMENT_SHADER_DERIVATIVE_HINT_OES"] = 35723] = "FRAGMENT_SHADER_DERIVATIVE_HINT_OES";
-    GLEnum2[GLEnum2["COLOR_ATTACHMENT0_WEBGL"] = 36064] = "COLOR_ATTACHMENT0_WEBGL";
-    GLEnum2[GLEnum2["COLOR_ATTACHMENT1_WEBGL"] = 36065] = "COLOR_ATTACHMENT1_WEBGL";
-    GLEnum2[GLEnum2["COLOR_ATTACHMENT2_WEBGL"] = 36066] = "COLOR_ATTACHMENT2_WEBGL";
-    GLEnum2[GLEnum2["COLOR_ATTACHMENT3_WEBGL"] = 36067] = "COLOR_ATTACHMENT3_WEBGL";
-    GLEnum2[GLEnum2["COLOR_ATTACHMENT4_WEBGL"] = 36068] = "COLOR_ATTACHMENT4_WEBGL";
-    GLEnum2[GLEnum2["COLOR_ATTACHMENT5_WEBGL"] = 36069] = "COLOR_ATTACHMENT5_WEBGL";
-    GLEnum2[GLEnum2["COLOR_ATTACHMENT6_WEBGL"] = 36070] = "COLOR_ATTACHMENT6_WEBGL";
-    GLEnum2[GLEnum2["COLOR_ATTACHMENT7_WEBGL"] = 36071] = "COLOR_ATTACHMENT7_WEBGL";
-    GLEnum2[GLEnum2["COLOR_ATTACHMENT8_WEBGL"] = 36072] = "COLOR_ATTACHMENT8_WEBGL";
-    GLEnum2[GLEnum2["COLOR_ATTACHMENT9_WEBGL"] = 36073] = "COLOR_ATTACHMENT9_WEBGL";
-    GLEnum2[GLEnum2["COLOR_ATTACHMENT10_WEBGL"] = 36074] = "COLOR_ATTACHMENT10_WEBGL";
-    GLEnum2[GLEnum2["COLOR_ATTACHMENT11_WEBGL"] = 36075] = "COLOR_ATTACHMENT11_WEBGL";
-    GLEnum2[GLEnum2["COLOR_ATTACHMENT12_WEBGL"] = 36076] = "COLOR_ATTACHMENT12_WEBGL";
-    GLEnum2[GLEnum2["COLOR_ATTACHMENT13_WEBGL"] = 36077] = "COLOR_ATTACHMENT13_WEBGL";
-    GLEnum2[GLEnum2["COLOR_ATTACHMENT14_WEBGL"] = 36078] = "COLOR_ATTACHMENT14_WEBGL";
-    GLEnum2[GLEnum2["COLOR_ATTACHMENT15_WEBGL"] = 36079] = "COLOR_ATTACHMENT15_WEBGL";
-    GLEnum2[GLEnum2["DRAW_BUFFER0_WEBGL"] = 34853] = "DRAW_BUFFER0_WEBGL";
-    GLEnum2[GLEnum2["DRAW_BUFFER1_WEBGL"] = 34854] = "DRAW_BUFFER1_WEBGL";
-    GLEnum2[GLEnum2["DRAW_BUFFER2_WEBGL"] = 34855] = "DRAW_BUFFER2_WEBGL";
-    GLEnum2[GLEnum2["DRAW_BUFFER3_WEBGL"] = 34856] = "DRAW_BUFFER3_WEBGL";
-    GLEnum2[GLEnum2["DRAW_BUFFER4_WEBGL"] = 34857] = "DRAW_BUFFER4_WEBGL";
-    GLEnum2[GLEnum2["DRAW_BUFFER5_WEBGL"] = 34858] = "DRAW_BUFFER5_WEBGL";
-    GLEnum2[GLEnum2["DRAW_BUFFER6_WEBGL"] = 34859] = "DRAW_BUFFER6_WEBGL";
-    GLEnum2[GLEnum2["DRAW_BUFFER7_WEBGL"] = 34860] = "DRAW_BUFFER7_WEBGL";
-    GLEnum2[GLEnum2["DRAW_BUFFER8_WEBGL"] = 34861] = "DRAW_BUFFER8_WEBGL";
-    GLEnum2[GLEnum2["DRAW_BUFFER9_WEBGL"] = 34862] = "DRAW_BUFFER9_WEBGL";
-    GLEnum2[GLEnum2["DRAW_BUFFER10_WEBGL"] = 34863] = "DRAW_BUFFER10_WEBGL";
-    GLEnum2[GLEnum2["DRAW_BUFFER11_WEBGL"] = 34864] = "DRAW_BUFFER11_WEBGL";
-    GLEnum2[GLEnum2["DRAW_BUFFER12_WEBGL"] = 34865] = "DRAW_BUFFER12_WEBGL";
-    GLEnum2[GLEnum2["DRAW_BUFFER13_WEBGL"] = 34866] = "DRAW_BUFFER13_WEBGL";
-    GLEnum2[GLEnum2["DRAW_BUFFER14_WEBGL"] = 34867] = "DRAW_BUFFER14_WEBGL";
-    GLEnum2[GLEnum2["DRAW_BUFFER15_WEBGL"] = 34868] = "DRAW_BUFFER15_WEBGL";
-    GLEnum2[GLEnum2["MAX_COLOR_ATTACHMENTS_WEBGL"] = 36063] = "MAX_COLOR_ATTACHMENTS_WEBGL";
-    GLEnum2[GLEnum2["MAX_DRAW_BUFFERS_WEBGL"] = 34852] = "MAX_DRAW_BUFFERS_WEBGL";
-    GLEnum2[GLEnum2["VERTEX_ARRAY_BINDING_OES"] = 34229] = "VERTEX_ARRAY_BINDING_OES";
     GLEnum2[GLEnum2["QUERY_COUNTER_BITS_EXT"] = 34916] = "QUERY_COUNTER_BITS_EXT";
     GLEnum2[GLEnum2["CURRENT_QUERY_EXT"] = 34917] = "CURRENT_QUERY_EXT";
     GLEnum2[GLEnum2["QUERY_RESULT_EXT"] = 34918] = "QUERY_RESULT_EXT";
@@ -901,201 +1051,42 @@ var __exports__ = (() => {
     GLEnum2[GLEnum2["TIME_ELAPSED_EXT"] = 35007] = "TIME_ELAPSED_EXT";
     GLEnum2[GLEnum2["TIMESTAMP_EXT"] = 36392] = "TIMESTAMP_EXT";
     GLEnum2[GLEnum2["GPU_DISJOINT_EXT"] = 36795] = "GPU_DISJOINT_EXT";
-    return GLEnum2;
-  }(GLEnum || {});
-
-  // src/data-filter/data-filter-extension.ts
-  var import_core4 = __toESM(require_core(), 1);
-
-  // src/data-filter/shader-module.ts
-  var vs2 = `
-uniform DATAFILTER_TYPE filter_min;
-uniform DATAFILTER_TYPE filter_softMin;
-uniform DATAFILTER_TYPE filter_softMax;
-uniform DATAFILTER_TYPE filter_max;
-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
-#else
-  #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;
-#endif
-in DATACATEGORY_TYPE DATACATEGORY_ATTRIB;
-
-out float dataFilter_value;
-
-float dataFilter_reduceValue(float value) {
-  return value;
-}
-float dataFilter_reduceValue(vec2 value) {
-  return min(value.x, value.y);
-}
-float dataFilter_reduceValue(vec3 value) {
-  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));
-}
-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;
-  }
-}
-`;
-  var fs2 = `
-uniform bool filter_transformColor;
-in float dataFilter_value;
-`;
-  function getUniforms(opts) {
-    if (!opts || !("extensions" in opts)) {
-      return {};
-    }
-    const {
-      filterRange = [-1, 1],
-      filterEnabled = true,
-      filterTransformSize = true,
-      filterTransformColor = true
-    } = opts;
-    const filterSoftRange = opts.filterSoftRange || filterRange;
-    return {
-      ...Number.isFinite(filterRange[0]) ? {
-        filter_min: filterRange[0],
-        filter_softMin: filterSoftRange[0],
-        filter_softMax: filterSoftRange[1],
-        filter_max: filterRange[1]
-      } : {
-        filter_min: filterRange.map((r) => r[0]),
-        filter_softMin: filterSoftRange.map((r) => r[0]),
-        filter_softMax: filterSoftRange.map((r) => r[1]),
-        filter_max: filterRange.map((r) => r[1])
-      },
-      filter_enabled: filterEnabled,
-      filter_useSoftMargin: Boolean(opts.filterSoftRange),
-      filter_transformSize: filterEnabled && filterTransformSize,
-      filter_transformColor: filterEnabled && filterTransformColor
-    };
-  }
-  function getUniforms64(opts) {
-    if (!opts || !("extensions" in opts)) {
-      return {};
-    }
-    const uniforms = getUniforms(opts);
-    if (Number.isFinite(uniforms.filter_min)) {
-      const min64High = Math.fround(uniforms.filter_min);
-      uniforms.filter_min -= min64High;
-      uniforms.filter_softMin -= min64High;
-      uniforms.filter_min64High = min64High;
-      const max64High = Math.fround(uniforms.filter_max);
-      uniforms.filter_max -= max64High;
-      uniforms.filter_softMax -= max64High;
-      uniforms.filter_max64High = max64High;
-    } else {
-      const min64High = uniforms.filter_min.map(Math.fround);
-      uniforms.filter_min = uniforms.filter_min.map((x, i) => x - min64High[i]);
-      uniforms.filter_softMin = uniforms.filter_softMin.map((x, i) => x - min64High[i]);
-      uniforms.filter_min64High = min64High;
-      const max64High = uniforms.filter_max.map(Math.fround);
-      uniforms.filter_max = uniforms.filter_max.map((x, i) => x - max64High[i]);
-      uniforms.filter_softMax = uniforms.filter_softMax.map((x, i) => x - max64High[i]);
-      uniforms.filter_max64High = max64High;
-    }
-    return uniforms;
-  }
-  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
-  `,
-    "vs:#main-end": `
-    if (dataFilter_value == 0.0) {
-      gl_Position = vec4(0.);
-    }
-  `,
-    "vs:DECKGL_FILTER_SIZE": `
-    if (filter_transformSize) {
-      size = size * dataFilter_value;
-    }
-  `,
-    "fs:DECKGL_FILTER_COLOR": `
-    if (dataFilter_value == 0.0) discard;
-    if (filter_transformColor) {
-      color.a *= dataFilter_value;
-    }
-  `
-  };
-  var shaderModule = {
-    name: "data-filter",
-    vs: vs2,
-    fs: fs2,
-    inject: inject2,
-    getUniforms
-  };
-  var shaderModule64 = {
-    name: "data-filter-fp64",
-    vs: vs2,
-    fs: fs2,
-    inject: inject2,
-    getUniforms: getUniforms64
-  };
+    GLEnum2[GLEnum2["COMPLETION_STATUS_KHR"] = 37297] = "COMPLETION_STATUS_KHR";
+    GLEnum2[GLEnum2["DEPTH_CLAMP_EXT"] = 34383] = "DEPTH_CLAMP_EXT";
+    GLEnum2[GLEnum2["FIRST_VERTEX_CONVENTION_WEBGL"] = 36429] = "FIRST_VERTEX_CONVENTION_WEBGL";
+    GLEnum2[GLEnum2["LAST_VERTEX_CONVENTION_WEBGL"] = 36430] = "LAST_VERTEX_CONVENTION_WEBGL";
+    GLEnum2[GLEnum2["PROVOKING_VERTEX_WEBL"] = 36431] = "PROVOKING_VERTEX_WEBL";
+    GLEnum2[GLEnum2["POLYGON_MODE_WEBGL"] = 2880] = "POLYGON_MODE_WEBGL";
+    GLEnum2[GLEnum2["POLYGON_OFFSET_LINE_WEBGL"] = 10754] = "POLYGON_OFFSET_LINE_WEBGL";
+    GLEnum2[GLEnum2["LINE_WEBGL"] = 6913] = "LINE_WEBGL";
+    GLEnum2[GLEnum2["FILL_WEBGL"] = 6914] = "FILL_WEBGL";
+    GLEnum2[GLEnum2["MAX_CLIP_DISTANCES_WEBGL"] = 3378] = "MAX_CLIP_DISTANCES_WEBGL";
+    GLEnum2[GLEnum2["MAX_CULL_DISTANCES_WEBGL"] = 33529] = "MAX_CULL_DISTANCES_WEBGL";
+    GLEnum2[GLEnum2["MAX_COMBINED_CLIP_AND_CULL_DISTANCES_WEBGL"] = 33530] = "MAX_COMBINED_CLIP_AND_CULL_DISTANCES_WEBGL";
+    GLEnum2[GLEnum2["CLIP_DISTANCE0_WEBGL"] = 12288] = "CLIP_DISTANCE0_WEBGL";
+    GLEnum2[GLEnum2["CLIP_DISTANCE1_WEBGL"] = 12289] = "CLIP_DISTANCE1_WEBGL";
+    GLEnum2[GLEnum2["CLIP_DISTANCE2_WEBGL"] = 12290] = "CLIP_DISTANCE2_WEBGL";
+    GLEnum2[GLEnum2["CLIP_DISTANCE3_WEBGL"] = 12291] = "CLIP_DISTANCE3_WEBGL";
+    GLEnum2[GLEnum2["CLIP_DISTANCE4_WEBGL"] = 12292] = "CLIP_DISTANCE4_WEBGL";
+    GLEnum2[GLEnum2["CLIP_DISTANCE5_WEBGL"] = 12293] = "CLIP_DISTANCE5_WEBGL";
+    GLEnum2[GLEnum2["CLIP_DISTANCE6_WEBGL"] = 12294] = "CLIP_DISTANCE6_WEBGL";
+    GLEnum2[GLEnum2["CLIP_DISTANCE7_WEBGL"] = 12295] = "CLIP_DISTANCE7_WEBGL";
+    GLEnum2[GLEnum2["POLYGON_OFFSET_CLAMP_EXT"] = 36379] = "POLYGON_OFFSET_CLAMP_EXT";
+    GLEnum2[GLEnum2["LOWER_LEFT_EXT"] = 36001] = "LOWER_LEFT_EXT";
+    GLEnum2[GLEnum2["UPPER_LEFT_EXT"] = 36002] = "UPPER_LEFT_EXT";
+    GLEnum2[GLEnum2["NEGATIVE_ONE_TO_ONE_EXT"] = 37726] = "NEGATIVE_ONE_TO_ONE_EXT";
+    GLEnum2[GLEnum2["ZERO_TO_ONE_EXT"] = 37727] = "ZERO_TO_ONE_EXT";
+    GLEnum2[GLEnum2["CLIP_ORIGIN_EXT"] = 37724] = "CLIP_ORIGIN_EXT";
+    GLEnum2[GLEnum2["CLIP_DEPTH_MODE_EXT"] = 37725] = "CLIP_DEPTH_MODE_EXT";
+    GLEnum2[GLEnum2["SRC1_COLOR_WEBGL"] = 35065] = "SRC1_COLOR_WEBGL";
+    GLEnum2[GLEnum2["SRC1_ALPHA_WEBGL"] = 34185] = "SRC1_ALPHA_WEBGL";
+    GLEnum2[GLEnum2["ONE_MINUS_SRC1_COLOR_WEBGL"] = 35066] = "ONE_MINUS_SRC1_COLOR_WEBGL";
+    GLEnum2[GLEnum2["ONE_MINUS_SRC1_ALPHA_WEBGL"] = 35067] = "ONE_MINUS_SRC1_ALPHA_WEBGL";
+    GLEnum2[GLEnum2["MAX_DUAL_SOURCE_DRAW_BUFFERS_WEBGL"] = 35068] = "MAX_DUAL_SOURCE_DRAW_BUFFERS_WEBGL";
+    GLEnum2[GLEnum2["MIRROR_CLAMP_TO_EDGE_EXT"] = 34627] = "MIRROR_CLAMP_TO_EDGE_EXT";
+  })(GLEnum || (GLEnum = {}));
 
   // src/data-filter/aggregator.ts
-  var import_engine = __toESM(require_engine(), 1);
   var AGGREGATE_VS = `#version 300 es
 #define SHADER_NAME data-filter-vertex-shader
 
@@ -1143,11 +1134,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) {
@@ -1156,7 +1148,7 @@ void main() {
         height: 1,
         colorAttachments: [
           device.createTexture({
-            format: device.info.type === "webgl2" ? "rgba32float" : "rgba8unorm",
+            format: "rgba32float",
             type: GLEnum.FLOAT,
             mipmaps: false
           })
@@ -1203,6 +1195,12 @@ void main() {
     filterTransformSize: true,
     filterTransformColor: true
   };
+  var defaultOptions = {
+    categorySize: 1,
+    filterSize: 1,
+    fp64: false,
+    countItems: false
+  };
   var DATA_TYPE_FROM_SIZE = {
     1: "float",
     2: "vec2",
@@ -1210,14 +1208,17 @@ void main() {
     4: "vec4"
   };
   var DataFilterExtension = class extends import_core4.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)
         }
       };
@@ -1229,7 +1230,7 @@ void main() {
         attributeManager.add({
           filterValues: {
             size: filterSize,
-            type: fp642 ? GLEnum.DOUBLE : GLEnum.FLOAT,
+            type: fp642 ? "float64" : "float32",
             accessor: "getFilterValue",
             shaderAttributes: {
               filterValues: {
@@ -1242,7 +1243,6 @@ void main() {
           },
           filterCategoryValues: {
             size: categorySize,
-            type: GLEnum.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: {
@@ -1263,8 +1263,7 @@ void main() {
           filterIndices: {
             size: useFloatTarget ? 1 : 2,
             vertexOffset: 1,
-            type: GLEnum.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];
@@ -1394,12 +1393,10 @@ void main() {
   var import_core6 = __toESM(require_core(), 1);
 
   // ../../node_modules/@luma.gl/shadertools/dist/lib/glsl-utils/highlight.js
-  var glsl = (x) => `${x}`;
+  var glsl2 = (x) => `${x}`;
 
   // ../../node_modules/@luma.gl/shadertools/dist/modules-webgl1/math/fp64/fp64-utils.js
-  function fp64ify(a) {
-    let out = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : [];
-    let startIndex = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : 0;
+  function fp64ify(a, out = [], startIndex = 0) {
     const hiPart = Math.fround(a);
     const loPart = a - hiPart;
     out[startIndex] = hiPart;
@@ -1420,8 +1417,8 @@ void main() {
     return matrixFP64;
   }
 
-  // ../../node_modules/@luma.gl/shadertools/dist/modules-webgl1/math/fp64/fp64-arithmetic.glsl.js
-  var fp64arithmeticShader = glsl`\
+  // ../../node_modules/@luma.gl/shadertools/dist/modules-webgl1/math/fp64/fp64-arithmetic-glsl.js
+  var fp64arithmeticShader = glsl2`\
 uniform float ONE;
 
 /*
@@ -1589,8 +1586,8 @@ vec2 sqrt_fp64(vec2 a) {
 }
 `;
 
-  // ../../node_modules/@luma.gl/shadertools/dist/modules-webgl1/math/fp64/fp64-functions.glsl.js
-  var fp64functionShader = glsl`\
+  // ../../node_modules/@luma.gl/shadertools/dist/modules-webgl1/math/fp64/fp64-functions-glsl.js
+  var fp64functionShader = glsl2`\
 const vec2 E_FP64 = vec2(2.7182817459106445e+00, 8.254840366817007e-08);
 const vec2 LOG2_FP64 = vec2(0.6931471824645996e+00, -1.9046542121259336e-09);
 const vec2 PI_FP64 = vec2(3.1415927410125732, -8.742278012618954e-8);
@@ -3089,9 +3086,9 @@ in float instanceOffsets;
   // src/fill-style/fill-style-extension.ts
   var import_core10 = __toESM(require_core(), 1);
 
-  // src/fill-style/shaders.glsl.ts
+  // src/fill-style/shader-module.ts
   var import_core9 = __toESM(require_core(), 1);
-  var patternVs = `
+  var patternVs = glsl`
 #ifdef NON_INSTANCED_MODEL
   #define FILL_PATTERN_FRAME_ATTRIB fillPatternFrames
   #define FILL_PATTERN_SCALE_ATTRIB fillPatternScales
@@ -3113,7 +3110,7 @@ out vec2 fill_uv;
 out vec4 fill_patternBounds;
 out vec4 fill_patternPlacement;
 `;
-  var patternFs = `
+  var patternFs = glsl`
 uniform bool fill_patternEnabled;
 uniform bool fill_patternMask;
 uniform sampler2D fill_patternTexture;
@@ -3127,17 +3124,17 @@ in vec2 fill_uv;
 const float FILL_UV_SCALE = 512.0 / 40000000.0;
 `;
   var inject3 = {
-    "vs:DECKGL_FILTER_GL_POSITION": `
+    "vs:DECKGL_FILTER_GL_POSITION": glsl`
     fill_uv = geometry.position.xy;
   `,
-    "vs:DECKGL_FILTER_COLOR": `
+    "vs:DECKGL_FILTER_COLOR": glsl`
     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": `
+    "fs:DECKGL_FILTER_COLOR": glsl`
     if (fill_patternEnabled) {
       vec2 scale = FILL_UV_SCALE * fill_patternPlacement.zw;
       vec2 patternUV = mod(mod(fill_uvCoordinateOrigin, scale) + fill_uvCoordinateOrigin64Low + fill_uv, scale) / scale;
@@ -3312,7 +3309,7 @@ const float FILL_UV_SCALE = 512.0 / 40000000.0;
     clipBounds: [0, 0, 1, 1],
     clipByInstance: void 0
   };
-  var shaderFunction = `
+  var shaderFunction = glsl`
 uniform vec4 clip_bounds;
 
 bool clip_isInBounds(vec2 position) {
@@ -3324,16 +3321,16 @@ bool clip_isInBounds(vec2 position) {
     vs: shaderFunction
   };
   var injectionVs = {
-    "vs:#decl": `
+    "vs:#decl": glsl`
 out float clip_isVisible;
 `,
-    "vs:DECKGL_FILTER_GL_POSITION": `
+    "vs:DECKGL_FILTER_GL_POSITION": glsl`
   clip_isVisible = float(clip_isInBounds(geometry.worldPosition.xy));
 `,
-    "fs:#decl": `
+    "fs:#decl": glsl`
 in float clip_isVisible;
 `,
-    "fs:DECKGL_FILTER_COLOR": `
+    "fs:DECKGL_FILTER_COLOR": glsl`
   if (clip_isVisible < 0.5) discard;
 `
   };
@@ -3342,16 +3339,16 @@ in float clip_isVisible;
     fs: shaderFunction
   };
   var injectionFs = {
-    "vs:#decl": `
+    "vs:#decl": glsl`
 out vec2 clip_commonPosition;
 `,
-    "vs:DECKGL_FILTER_GL_POSITION": `
+    "vs:DECKGL_FILTER_GL_POSITION": glsl`
   clip_commonPosition = geometry.position.xy;
 `,
-    "fs:#decl": `
+    "fs:#decl": glsl`
 in vec2 clip_commonPosition;
 `,
-    "fs:DECKGL_FILTER_COLOR": `
+    "fs:DECKGL_FILTER_COLOR": glsl`
   if (!clip_isInBounds(clip_commonPosition)) discard;
 `
   };
@@ -3394,7 +3391,7 @@ in vec2 clip_commonPosition;
 
   // src/collision-filter/shader-module.ts
   var import_core12 = __toESM(require_core(), 1);
-  var vs3 = `
+  var vs3 = glsl`
 #ifdef NON_INSTANCED_MODEL
 in float collisionPriorities;
 #else
@@ -3445,10 +3442,10 @@ float collision_isVisible(vec2 texCoords, vec3 pickingColor) {
 }
 `;
   var inject4 = {
-    "vs:#decl": `
+    "vs:#decl": glsl`
   float collision_fade = 1.0;
 `,
-    "vs:DECKGL_FILTER_GL_POSITION": `
+    "vs:DECKGL_FILTER_GL_POSITION": glsl`
   if (collision_sort) {
     #ifdef NON_INSTANCED_MODEL
     float collisionPriority = collisionPriorities;
@@ -3468,7 +3465,7 @@ float collision_isVisible(vec2 texCoords, vec3 pickingColor) {
     }
   }
   `,
-    "vs:DECKGL_FILTER_COLOR": `
+    "vs:DECKGL_FILTER_COLOR": glsl`
   color.a *= collision_fade;
   `
   };
@@ -4087,14 +4084,14 @@ float collision_isVisible(vec2 texCoords, vec3 pickingColor) {
 
   // src/mask/shader-module.ts
   var import_core21 = __toESM(require_core(), 1);
-  var vs4 = `
+  var vs4 = glsl`
 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);
 }
 `;
-  var fs3 = `
+  var fs3 = glsl`
 uniform sampler2D mask_texture;
 uniform int mask_channel;
 uniform bool mask_enabled;
@@ -4123,10 +4120,10 @@ bool mask_isInBounds(vec2 texCoords) {
 }
 `;
   var inject5 = {
-    "vs:#decl": `
+    "vs:#decl": glsl`
 out vec2 mask_texCoords;
 `,
-    "vs:#main-end": `
+    "vs:#main-end": glsl`
    vec4 mask_common_position;
    if (mask_maskByInstance) {
      mask_common_position = project_position(vec4(geometry.worldPosition, 1.0));
@@ -4135,10 +4132,10 @@ out vec2 mask_texCoords;
    }
    mask_texCoords = mask_getCoords(mask_common_position);
 `,
-    "fs:#decl": `
+    "fs:#decl": glsl`
 in vec2 mask_texCoords;
 `,
-    "fs:#main-start": `
+    "fs:#main-start": glsl`
   if (mask_enabled) {
     bool mask = mask_isInBounds(mask_texCoords);
 
@@ -4237,20 +4234,19 @@ in vec2 mask_texCoords;
     name: "terrain",
     dependencies: [import_core23.project],
     inject: {
-      "vs:#decl": `
+      "vs:#decl": glsl`
 uniform float terrain_mode;
 uniform sampler2D terrain_map;
 uniform vec4 terrain_bounds;
 out vec3 commonPos;
-${TERRAIN_MODE_CONSTANTS}
-    `,
-      "vs:#main-start": `
+` + TERRAIN_MODE_CONSTANTS,
+      "vs:#main-start": glsl`
 if (terrain_mode == TERRAIN_MODE_SKIP) {
   gl_Position = vec4(0.0);
   return;
 }
 `,
-      "vs:DECKGL_FILTER_GL_POSITION": `
+      "vs:DECKGL_FILTER_GL_POSITION": glsl`
 commonPos = geometry.position.xyz;
 if (terrain_mode == TERRAIN_MODE_WRITE_HEIGHT_MAP) {
   vec2 texCoords = (commonPos.xy - terrain_bounds.xy) / terrain_bounds.zw;
@@ -4269,20 +4265,19 @@ if (terrain_mode == TERRAIN_MODE_USE_HEIGHT_MAP) {
   }
 }
     `,
-      "fs:#decl": `
+      "fs:#decl": glsl`
 uniform float terrain_mode;
 uniform sampler2D terrain_map;
 uniform vec4 terrain_bounds;
 in vec3 commonPos;
-${TERRAIN_MODE_CONSTANTS}
-    `,
-      "fs:#main-start": `
+` + TERRAIN_MODE_CONSTANTS,
+      "fs:#main-start": glsl`
 if (terrain_mode == TERRAIN_MODE_WRITE_HEIGHT_MAP) {
   fragColor = vec4(commonPos.z, 0.0, 0.0, 1.0);
   return;
 }
     `,
-      "fs:DECKGL_FILTER_COLOR": `
+      "fs:DECKGL_FILTER_COLOR": glsl`
 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);
@@ -4353,7 +4348,7 @@ if ((terrain_mode == TERRAIN_MODE_USE_COVER) || (terrain_mode == TERRAIN_MODE_US
       colorAttachments: [
         device.createTexture({
           ...opts.float && {
-            format: device.info.type === "webgl2" ? "rgba32float" : "rgba8unorm",
+            format: "rgba32float",
             type: GLEnum.FLOAT
           },
           mipmaps: false,