@deck.gl/extensions 9.0.0-beta.5 → 9.0.0-beta.7

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";
@@ -841,261 +1035,58 @@ var __exports__ = (() => {
     GLEnum2[GLEnum2["COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR"] = 37842] = "COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR";
     GLEnum2[GLEnum2["COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR"] = 37843] = "COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR";
     GLEnum2[GLEnum2["COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR"] = 37844] = "COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR";
-    GLEnum2[GLEnum2["COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR"] = 37845] = "COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR";
-    GLEnum2[GLEnum2["COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR"] = 37846] = "COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR";
-    GLEnum2[GLEnum2["COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR"] = 37847] = "COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR";
-    GLEnum2[GLEnum2["COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR"] = 37848] = "COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR";
-    GLEnum2[GLEnum2["COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR"] = 37849] = "COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR";
-    GLEnum2[GLEnum2["COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR"] = 37850] = "COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR";
-    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";
-    GLEnum2[GLEnum2["QUERY_RESULT_AVAILABLE_EXT"] = 34919] = "QUERY_RESULT_AVAILABLE_EXT";
-    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["COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR"] = 37845] = "COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR";
+    GLEnum2[GLEnum2["COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR"] = 37846] = "COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR";
+    GLEnum2[GLEnum2["COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR"] = 37847] = "COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR";
+    GLEnum2[GLEnum2["COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR"] = 37848] = "COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR";
+    GLEnum2[GLEnum2["COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR"] = 37849] = "COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR";
+    GLEnum2[GLEnum2["COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR"] = 37850] = "COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR";
+    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["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";
+    GLEnum2[GLEnum2["QUERY_RESULT_AVAILABLE_EXT"] = 34919] = "QUERY_RESULT_AVAILABLE_EXT";
+    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";
+    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
           })
@@ -1238,7 +1230,7 @@ void main() {
         attributeManager.add({
           filterValues: {
             size: filterSize,
-            type: fp642 ? GLEnum.DOUBLE : GLEnum.FLOAT,
+            type: fp642 ? "float64" : "float32",
             accessor: "getFilterValue",
             shaderAttributes: {
               filterValues: {
@@ -1251,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: {
@@ -1272,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];
@@ -1402,13 +1392,8 @@ void main() {
   // src/fp64/fp64-extension.ts
   var import_core6 = __toESM(require_core(), 1);
 
-  // ../../node_modules/@luma.gl/shadertools/dist/lib/glsl-utils/highlight.js
-  var glsl = (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;
@@ -1429,178 +1414,143 @@ void main() {
     return matrixFP64;
   }
 
-  // ../../node_modules/@luma.gl/shadertools/dist/modules-webgl1/math/fp64/fp64-arithmetic.glsl.js
-  var fp64arithmeticShader = glsl`\
-uniform float ONE;
-
-/*
-About LUMA_FP64_CODE_ELIMINATION_WORKAROUND
-
-The purpose of this workaround is to prevent shader compilers from
-optimizing away necessary arithmetic operations by swapping their sequences
-or transform the equation to some 'equivalent' form.
-
-The method is to multiply an artifical variable, ONE, which will be known to
-the compiler to be 1 only at runtime. The whole expression is then represented
-as a polynomial with respective to ONE. In the coefficients of all terms, only one a
-and one b should appear
-
-err = (a + b) * ONE^6 - a * ONE^5 - (a + b) * ONE^4 + a * ONE^3 - b - (a + b) * ONE^2 + a * ONE
-*/
-
-// Divide float number to high and low floats to extend fraction bits
+  // ../../node_modules/@luma.gl/shadertools/dist/modules-webgl1/math/fp64/fp64-arithmetic-glsl.js
+  var fp64arithmeticShader = `uniform float ONE;
 vec2 split(float a) {
-  const float SPLIT = 4097.0;
-  float t = a * SPLIT;
+const float SPLIT = 4097.0;
+float t = a * SPLIT;
 #if defined(LUMA_FP64_CODE_ELIMINATION_WORKAROUND)
-  float a_hi = t * ONE - (t - a);
-  float a_lo = a * ONE - a_hi;
+float a_hi = t * ONE - (t - a);
+float a_lo = a * ONE - a_hi;
 #else
-  float a_hi = t - (t - a);
-  float a_lo = a - a_hi;
+float a_hi = t - (t - a);
+float a_lo = a - a_hi;
 #endif
-  return vec2(a_hi, a_lo);
+return vec2(a_hi, a_lo);
 }
-
-// Divide float number again when high float uses too many fraction bits
 vec2 split2(vec2 a) {
-  vec2 b = split(a.x);
-  b.y += a.y;
-  return b;
+vec2 b = split(a.x);
+b.y += a.y;
+return b;
 }
-
-// Special sum operation when a > b
 vec2 quickTwoSum(float a, float b) {
 #if defined(LUMA_FP64_CODE_ELIMINATION_WORKAROUND)
-  float sum = (a + b) * ONE;
-  float err = b - (sum - a) * ONE;
+float sum = (a + b) * ONE;
+float err = b - (sum - a) * ONE;
 #else
-  float sum = a + b;
-  float err = b - (sum - a);
+float sum = a + b;
+float err = b - (sum - a);
 #endif
-  return vec2(sum, err);
+return vec2(sum, err);
 }
-
-// General sum operation
 vec2 twoSum(float a, float b) {
-  float s = (a + b);
+float s = (a + b);
 #if defined(LUMA_FP64_CODE_ELIMINATION_WORKAROUND)
-  float v = (s * ONE - a) * ONE;
-  float err = (a - (s - v) * ONE) * ONE * ONE * ONE + (b - v);
+float v = (s * ONE - a) * ONE;
+float err = (a - (s - v) * ONE) * ONE * ONE * ONE + (b - v);
 #else
-  float v = s - a;
-  float err = (a - (s - v)) + (b - v);
+float v = s - a;
+float err = (a - (s - v)) + (b - v);
 #endif
-  return vec2(s, err);
+return vec2(s, err);
 }
-
 vec2 twoSub(float a, float b) {
-  float s = (a - b);
+float s = (a - b);
 #if defined(LUMA_FP64_CODE_ELIMINATION_WORKAROUND)
-  float v = (s * ONE - a) * ONE;
-  float err = (a - (s - v) * ONE) * ONE * ONE * ONE - (b + v);
+float v = (s * ONE - a) * ONE;
+float err = (a - (s - v) * ONE) * ONE * ONE * ONE - (b + v);
 #else
-  float v = s - a;
-  float err = (a - (s - v)) - (b + v);
+float v = s - a;
+float err = (a - (s - v)) - (b + v);
 #endif
-  return vec2(s, err);
+return vec2(s, err);
 }
-
 vec2 twoSqr(float a) {
-  float prod = a * a;
-  vec2 a_fp64 = split(a);
+float prod = a * a;
+vec2 a_fp64 = split(a);
 #if defined(LUMA_FP64_CODE_ELIMINATION_WORKAROUND)
-  float err = ((a_fp64.x * a_fp64.x - prod) * ONE + 2.0 * a_fp64.x *
-    a_fp64.y * ONE * ONE) + a_fp64.y * a_fp64.y * ONE * ONE * ONE;
+float err = ((a_fp64.x * a_fp64.x - prod) * ONE + 2.0 * a_fp64.x *
+a_fp64.y * ONE * ONE) + a_fp64.y * a_fp64.y * ONE * ONE * ONE;
 #else
-  float err = ((a_fp64.x * a_fp64.x - prod) + 2.0 * a_fp64.x * a_fp64.y) + a_fp64.y * a_fp64.y;
+float err = ((a_fp64.x * a_fp64.x - prod) + 2.0 * a_fp64.x * a_fp64.y) + a_fp64.y * a_fp64.y;
 #endif
-  return vec2(prod, err);
+return vec2(prod, err);
 }
-
 vec2 twoProd(float a, float b) {
-  float prod = a * b;
-  vec2 a_fp64 = split(a);
-  vec2 b_fp64 = split(b);
-  float err = ((a_fp64.x * b_fp64.x - prod) + a_fp64.x * b_fp64.y +
-    a_fp64.y * b_fp64.x) + a_fp64.y * b_fp64.y;
-  return vec2(prod, err);
+float prod = a * b;
+vec2 a_fp64 = split(a);
+vec2 b_fp64 = split(b);
+float err = ((a_fp64.x * b_fp64.x - prod) + a_fp64.x * b_fp64.y +
+a_fp64.y * b_fp64.x) + a_fp64.y * b_fp64.y;
+return vec2(prod, err);
 }
-
 vec2 sum_fp64(vec2 a, vec2 b) {
-  vec2 s, t;
-  s = twoSum(a.x, b.x);
-  t = twoSum(a.y, b.y);
-  s.y += t.x;
-  s = quickTwoSum(s.x, s.y);
-  s.y += t.y;
-  s = quickTwoSum(s.x, s.y);
-  return s;
+vec2 s, t;
+s = twoSum(a.x, b.x);
+t = twoSum(a.y, b.y);
+s.y += t.x;
+s = quickTwoSum(s.x, s.y);
+s.y += t.y;
+s = quickTwoSum(s.x, s.y);
+return s;
 }
-
 vec2 sub_fp64(vec2 a, vec2 b) {
-  vec2 s, t;
-  s = twoSub(a.x, b.x);
-  t = twoSub(a.y, b.y);
-  s.y += t.x;
-  s = quickTwoSum(s.x, s.y);
-  s.y += t.y;
-  s = quickTwoSum(s.x, s.y);
-  return s;
+vec2 s, t;
+s = twoSub(a.x, b.x);
+t = twoSub(a.y, b.y);
+s.y += t.x;
+s = quickTwoSum(s.x, s.y);
+s.y += t.y;
+s = quickTwoSum(s.x, s.y);
+return s;
 }
-
 vec2 mul_fp64(vec2 a, vec2 b) {
-  vec2 prod = twoProd(a.x, b.x);
-  // y component is for the error
-  prod.y += a.x * b.y;
+vec2 prod = twoProd(a.x, b.x);
+prod.y += a.x * b.y;
 #if defined(LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND)
-  prod = split2(prod);
+prod = split2(prod);
 #endif
-  prod = quickTwoSum(prod.x, prod.y);
-  prod.y += a.y * b.x;
+prod = quickTwoSum(prod.x, prod.y);
+prod.y += a.y * b.x;
 #if defined(LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND)
-  prod = split2(prod);
+prod = split2(prod);
 #endif
-  prod = quickTwoSum(prod.x, prod.y);
-  return prod;
+prod = quickTwoSum(prod.x, prod.y);
+return prod;
 }
-
 vec2 div_fp64(vec2 a, vec2 b) {
-  float xn = 1.0 / b.x;
+float xn = 1.0 / b.x;
 #if defined(LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND)
-  vec2 yn = mul_fp64(a, vec2(xn, 0));
+vec2 yn = mul_fp64(a, vec2(xn, 0));
 #else
-  vec2 yn = a * xn;
+vec2 yn = a * xn;
 #endif
-  float diff = (sub_fp64(a, mul_fp64(b, yn))).x;
-  vec2 prod = twoProd(xn, diff);
-  return sum_fp64(yn, prod);
+float diff = (sub_fp64(a, mul_fp64(b, yn))).x;
+vec2 prod = twoProd(xn, diff);
+return sum_fp64(yn, prod);
 }
-
 vec2 sqrt_fp64(vec2 a) {
-  if (a.x == 0.0 && a.y == 0.0) return vec2(0.0, 0.0);
-  if (a.x < 0.0) return vec2(0.0 / 0.0, 0.0 / 0.0);
-
-  float x = 1.0 / sqrt(a.x);
-  float yn = a.x * x;
+if (a.x == 0.0 && a.y == 0.0) return vec2(0.0, 0.0);
+if (a.x < 0.0) return vec2(0.0 / 0.0, 0.0 / 0.0);
+float x = 1.0 / sqrt(a.x);
+float yn = a.x * x;
 #if defined(LUMA_FP64_CODE_ELIMINATION_WORKAROUND)
-  vec2 yn_sqr = twoSqr(yn) * ONE;
+vec2 yn_sqr = twoSqr(yn) * ONE;
 #else
-  vec2 yn_sqr = twoSqr(yn);
+vec2 yn_sqr = twoSqr(yn);
 #endif
-  float diff = sub_fp64(a, yn_sqr).x;
-  vec2 prod = twoProd(x * 0.5, diff);
+float diff = sub_fp64(a, yn_sqr).x;
+vec2 prod = twoProd(x * 0.5, diff);
 #if defined(LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND)
-  return sum_fp64(split(yn), prod);
+return sum_fp64(split(yn), prod);
 #else
-  return sum_fp64(vec2(yn, 0.0), prod);
+return sum_fp64(vec2(yn, 0.0), prod);
 #endif
 }
 `;
 
-  // ../../node_modules/@luma.gl/shadertools/dist/modules-webgl1/math/fp64/fp64-functions.glsl.js
-  var fp64functionShader = glsl`\
-const vec2 E_FP64 = vec2(2.7182817459106445e+00, 8.254840366817007e-08);
+  // ../../node_modules/@luma.gl/shadertools/dist/modules-webgl1/math/fp64/fp64-functions-glsl.js
+  var fp64functionShader = `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);
 const vec2 TWO_PI_FP64 = vec2(6.2831854820251465, -1.7484556025237907e-7);
@@ -1610,664 +1560,508 @@ const vec2 PI_16_FP64 = vec2(0.19634954631328583, -5.463923757886846e-9);
 const vec2 PI_16_2_FP64 = vec2(0.39269909262657166, -1.0927847515773692e-8);
 const vec2 PI_16_3_FP64 = vec2(0.5890486240386963, -1.4906100798128818e-9);
 const vec2 PI_180_FP64 = vec2(0.01745329238474369, 1.3519960498364902e-10);
-
 const vec2 SIN_TABLE_0_FP64 = vec2(0.19509032368659973, -1.6704714833615242e-9);
 const vec2 SIN_TABLE_1_FP64 = vec2(0.3826834261417389, 6.22335089017767e-9);
 const vec2 SIN_TABLE_2_FP64 = vec2(0.5555702447891235, -1.1769521357507529e-8);
 const vec2 SIN_TABLE_3_FP64 = vec2(0.7071067690849304, 1.2101617041793133e-8);
-
 const vec2 COS_TABLE_0_FP64 = vec2(0.9807852506637573, 2.9739473106360492e-8);
 const vec2 COS_TABLE_1_FP64 = vec2(0.9238795042037964, 2.8307490351764386e-8);
 const vec2 COS_TABLE_2_FP64 = vec2(0.8314695954322815, 1.6870263741530778e-8);
 const vec2 COS_TABLE_3_FP64 = vec2(0.7071067690849304, 1.2101617152815436e-8);
-
-const vec2 INVERSE_FACTORIAL_3_FP64 = vec2(1.666666716337204e-01, -4.967053879312289e-09); // 1/3!
-const vec2 INVERSE_FACTORIAL_4_FP64 = vec2(4.16666679084301e-02, -1.2417634698280722e-09); // 1/4!
-const vec2 INVERSE_FACTORIAL_5_FP64 = vec2(8.333333767950535e-03, -4.34617203337595e-10); // 1/5!
-const vec2 INVERSE_FACTORIAL_6_FP64 = vec2(1.3888889225199819e-03, -3.3631094437103215e-11); // 1/6!
-const vec2 INVERSE_FACTORIAL_7_FP64 = vec2(1.9841270113829523e-04,  -2.725596874933456e-12); // 1/7!
-const vec2 INVERSE_FACTORIAL_8_FP64 = vec2(2.4801587642286904e-05, -3.406996025904184e-13); // 1/8!
-const vec2 INVERSE_FACTORIAL_9_FP64 = vec2(2.75573188446287533e-06, 3.7935713937038186e-14); // 1/9!
-const vec2 INVERSE_FACTORIAL_10_FP64 = vec2(2.755731998149713e-07, -7.575112367869873e-15); // 1/10!
-
+const vec2 INVERSE_FACTORIAL_3_FP64 = vec2(1.666666716337204e-01, -4.967053879312289e-09);
+const vec2 INVERSE_FACTORIAL_4_FP64 = vec2(4.16666679084301e-02, -1.2417634698280722e-09);
+const vec2 INVERSE_FACTORIAL_5_FP64 = vec2(8.333333767950535e-03, -4.34617203337595e-10);
+const vec2 INVERSE_FACTORIAL_6_FP64 = vec2(1.3888889225199819e-03, -3.3631094437103215e-11);
+const vec2 INVERSE_FACTORIAL_7_FP64 = vec2(1.9841270113829523e-04,  -2.725596874933456e-12);
+const vec2 INVERSE_FACTORIAL_8_FP64 = vec2(2.4801587642286904e-05, -3.406996025904184e-13);
+const vec2 INVERSE_FACTORIAL_9_FP64 = vec2(2.75573188446287533e-06, 3.7935713937038186e-14);
+const vec2 INVERSE_FACTORIAL_10_FP64 = vec2(2.755731998149713e-07, -7.575112367869873e-15);
 float nint(float d) {
-    if (d == floor(d)) return d;
-    return floor(d + 0.5);
+if (d == floor(d)) return d;
+return floor(d + 0.5);
 }
-
 vec2 nint_fp64(vec2 a) {
-    float hi = nint(a.x);
-    float lo;
-    vec2 tmp;
-    if (hi == a.x) {
-        lo = nint(a.y);
-        tmp = quickTwoSum(hi, lo);
-    } else {
-        lo = 0.0;
-        if (abs(hi - a.x) == 0.5 && a.y < 0.0) {
-            hi -= 1.0;
-        }
-        tmp = vec2(hi, lo);
-    }
-    return tmp;
+float hi = nint(a.x);
+float lo;
+vec2 tmp;
+if (hi == a.x) {
+lo = nint(a.y);
+tmp = quickTwoSum(hi, lo);
+} else {
+lo = 0.0;
+if (abs(hi - a.x) == 0.5 && a.y < 0.0) {
+hi -= 1.0;
+}
+tmp = vec2(hi, lo);
+}
+return tmp;
 }
-
-/* k_power controls how much range reduction we would like to have
-Range reduction uses the following method:
-assume a = k_power * r + m * log(2), k and m being integers.
-Set k_power = 4 (we can choose other k to trade accuracy with performance.
-we only need to calculate exp(r) and using exp(a) = 2^m * exp(r)^k_power;
-*/
-
 vec2 exp_fp64(vec2 a) {
-  // We need to make sure these two numbers match
-  // as bit-wise shift is not available in GLSL 1.0
-  const int k_power = 4;
-  const float k = 16.0;
-
-  const float inv_k = 1.0 / k;
-
-  if (a.x <= -88.0) return vec2(0.0, 0.0);
-  if (a.x >= 88.0) return vec2(1.0 / 0.0, 1.0 / 0.0);
-  if (a.x == 0.0 && a.y == 0.0) return vec2(1.0, 0.0);
-  if (a.x == 1.0 && a.y == 0.0) return E_FP64;
-
-  float m = floor(a.x / LOG2_FP64.x + 0.5);
-  vec2 r = sub_fp64(a, mul_fp64(LOG2_FP64, vec2(m, 0.0))) * inv_k;
-  vec2 s, t, p;
-
-  p = mul_fp64(r, r);
-  s = sum_fp64(r, p * 0.5);
-  p = mul_fp64(p, r);
-  t = mul_fp64(p, INVERSE_FACTORIAL_3_FP64);
-
-  s = sum_fp64(s, t);
-  p = mul_fp64(p, r);
-  t = mul_fp64(p, INVERSE_FACTORIAL_4_FP64);
-
-  s = sum_fp64(s, t);
-  p = mul_fp64(p, r);
-  t = mul_fp64(p, INVERSE_FACTORIAL_5_FP64);
-
-  // s = sum_fp64(s, t);
-  // p = mul_fp64(p, r);
-  // t = mul_fp64(p, INVERSE_FACTORIAL_6_FP64);
-
-  // s = sum_fp64(s, t);
-  // p = mul_fp64(p, r);
-  // t = mul_fp64(p, INVERSE_FACTORIAL_7_FP64);
-
-  s = sum_fp64(s, t);
-
-
-  // At this point, s = exp(r) - 1; but after following 4 recursions, we will get exp(r) ^ 512 - 1.
-  for (int i = 0; i < k_power; i++) {
-    s = sum_fp64(s * 2.0, mul_fp64(s, s));
-  }
-
+const int k_power = 4;
+const float k = 16.0;
+const float inv_k = 1.0 / k;
+if (a.x <= -88.0) return vec2(0.0, 0.0);
+if (a.x >= 88.0) return vec2(1.0 / 0.0, 1.0 / 0.0);
+if (a.x == 0.0 && a.y == 0.0) return vec2(1.0, 0.0);
+if (a.x == 1.0 && a.y == 0.0) return E_FP64;
+float m = floor(a.x / LOG2_FP64.x + 0.5);
+vec2 r = sub_fp64(a, mul_fp64(LOG2_FP64, vec2(m, 0.0))) * inv_k;
+vec2 s, t, p;
+p = mul_fp64(r, r);
+s = sum_fp64(r, p * 0.5);
+p = mul_fp64(p, r);
+t = mul_fp64(p, INVERSE_FACTORIAL_3_FP64);
+s = sum_fp64(s, t);
+p = mul_fp64(p, r);
+t = mul_fp64(p, INVERSE_FACTORIAL_4_FP64);
+s = sum_fp64(s, t);
+p = mul_fp64(p, r);
+t = mul_fp64(p, INVERSE_FACTORIAL_5_FP64);
+s = sum_fp64(s, t);
+for (int i = 0; i < k_power; i++) {
+s = sum_fp64(s * 2.0, mul_fp64(s, s));
+}
 #if defined(NVIDIA_FP64_WORKAROUND) || defined(INTEL_FP64_WORKAROUND)
-  s = sum_fp64(s, vec2(ONE, 0.0));
+s = sum_fp64(s, vec2(ONE, 0.0));
 #else
-  s = sum_fp64(s, vec2(1.0, 0.0));
+s = sum_fp64(s, vec2(1.0, 0.0));
 #endif
-
-  return s * pow(2.0, m);
-//   return r;
+return s * pow(2.0, m);
 }
-
 vec2 log_fp64(vec2 a)
 {
-  if (a.x == 1.0 && a.y == 0.0) return vec2(0.0, 0.0);
-  if (a.x <= 0.0) return vec2(0.0 / 0.0, 0.0 / 0.0);
-  vec2 x = vec2(log(a.x), 0.0);
-  vec2 s;
+if (a.x == 1.0 && a.y == 0.0) return vec2(0.0, 0.0);
+if (a.x <= 0.0) return vec2(0.0 / 0.0, 0.0 / 0.0);
+vec2 x = vec2(log(a.x), 0.0);
+vec2 s;
 #if defined(NVIDIA_FP64_WORKAROUND) || defined(INTEL_FP64_WORKAROUND)
-  s = vec2(ONE, 0.0);
+s = vec2(ONE, 0.0);
 #else
-  s = vec2(1.0, 0.0);
+s = vec2(1.0, 0.0);
 #endif
-
-  x = sub_fp64(sum_fp64(x, mul_fp64(a, exp_fp64(-x))), s);
-  return x;
+x = sub_fp64(sum_fp64(x, mul_fp64(a, exp_fp64(-x))), s);
+return x;
 }
-
 vec2 sin_taylor_fp64(vec2 a) {
-  vec2 r, s, t, x;
-
-  if (a.x == 0.0 && a.y == 0.0) {
-    return vec2(0.0, 0.0);
-  }
-
-  x = -mul_fp64(a, a);
-  s = a;
-  r = a;
-
-  r = mul_fp64(r, x);
-  t = mul_fp64(r, INVERSE_FACTORIAL_3_FP64);
-  s = sum_fp64(s, t);
-
-  r = mul_fp64(r, x);
-  t = mul_fp64(r, INVERSE_FACTORIAL_5_FP64);
-  s = sum_fp64(s, t);
-
-  /* keep the following commented code in case we need them
-  for extra accuracy from the Taylor expansion*/
-
-  // r = mul_fp64(r, x);
-  // t = mul_fp64(r, INVERSE_FACTORIAL_7_FP64);
-  // s = sum_fp64(s, t);
-
-  // r = mul_fp64(r, x);
-  // t = mul_fp64(r, INVERSE_FACTORIAL_9_FP64);
-  // s = sum_fp64(s, t);
-
-  return s;
+vec2 r, s, t, x;
+if (a.x == 0.0 && a.y == 0.0) {
+return vec2(0.0, 0.0);
+}
+x = -mul_fp64(a, a);
+s = a;
+r = a;
+r = mul_fp64(r, x);
+t = mul_fp64(r, INVERSE_FACTORIAL_3_FP64);
+s = sum_fp64(s, t);
+r = mul_fp64(r, x);
+t = mul_fp64(r, INVERSE_FACTORIAL_5_FP64);
+s = sum_fp64(s, t);
+return s;
 }
-
 vec2 cos_taylor_fp64(vec2 a) {
-  vec2 r, s, t, x;
-
-  if (a.x == 0.0 && a.y == 0.0) {
-    return vec2(1.0, 0.0);
-  }
-
-  x = -mul_fp64(a, a);
-  r = x;
-  s = sum_fp64(vec2(1.0, 0.0), r * 0.5);
-
-  r = mul_fp64(r, x);
-  t = mul_fp64(r, INVERSE_FACTORIAL_4_FP64);
-  s = sum_fp64(s, t);
-
-  r = mul_fp64(r, x);
-  t = mul_fp64(r, INVERSE_FACTORIAL_6_FP64);
-  s = sum_fp64(s, t);
-
-  /* keep the following commented code in case we need them
-  for extra accuracy from the Taylor expansion*/
-
-  // r = mul_fp64(r, x);
-  // t = mul_fp64(r, INVERSE_FACTORIAL_8_FP64);
-  // s = sum_fp64(s, t);
-
-  // r = mul_fp64(r, x);
-  // t = mul_fp64(r, INVERSE_FACTORIAL_10_FP64);
-  // s = sum_fp64(s, t);
-
-  return s;
+vec2 r, s, t, x;
+if (a.x == 0.0 && a.y == 0.0) {
+return vec2(1.0, 0.0);
+}
+x = -mul_fp64(a, a);
+r = x;
+s = sum_fp64(vec2(1.0, 0.0), r * 0.5);
+r = mul_fp64(r, x);
+t = mul_fp64(r, INVERSE_FACTORIAL_4_FP64);
+s = sum_fp64(s, t);
+r = mul_fp64(r, x);
+t = mul_fp64(r, INVERSE_FACTORIAL_6_FP64);
+s = sum_fp64(s, t);
+return s;
 }
-
 void sincos_taylor_fp64(vec2 a, out vec2 sin_t, out vec2 cos_t) {
-  if (a.x == 0.0 && a.y == 0.0) {
-    sin_t = vec2(0.0, 0.0);
-    cos_t = vec2(1.0, 0.0);
-  }
-
-  sin_t = sin_taylor_fp64(a);
-  cos_t = sqrt_fp64(sub_fp64(vec2(1.0, 0.0), mul_fp64(sin_t, sin_t)));
+if (a.x == 0.0 && a.y == 0.0) {
+sin_t = vec2(0.0, 0.0);
+cos_t = vec2(1.0, 0.0);
+}
+sin_t = sin_taylor_fp64(a);
+cos_t = sqrt_fp64(sub_fp64(vec2(1.0, 0.0), mul_fp64(sin_t, sin_t)));
 }
-
 vec2 sin_fp64(vec2 a) {
-    if (a.x == 0.0 && a.y == 0.0) {
-        return vec2(0.0, 0.0);
-    }
-
-    // 2pi range reduction
-    vec2 z = nint_fp64(div_fp64(a, TWO_PI_FP64));
-    vec2 r = sub_fp64(a, mul_fp64(TWO_PI_FP64, z));
-
-    vec2 t;
-    float q = floor(r.x / PI_2_FP64.x + 0.5);
-    int j = int(q);
-
-    if (j < -2 || j > 2) {
-        return vec2(0.0 / 0.0, 0.0 / 0.0);
-    }
-
-    t = sub_fp64(r, mul_fp64(PI_2_FP64, vec2(q, 0.0)));
-
-    q = floor(t.x / PI_16_FP64.x + 0.5);
-    int k = int(q);
-
-    if (k == 0) {
-        if (j == 0) {
-            return sin_taylor_fp64(t);
-        } else if (j == 1) {
-            return cos_taylor_fp64(t);
-        } else if (j == -1) {
-            return -cos_taylor_fp64(t);
-        } else {
-            return -sin_taylor_fp64(t);
-        }
-    }
-
-    int abs_k = int(abs(float(k)));
-
-    if (abs_k > 4) {
-        return vec2(0.0 / 0.0, 0.0 / 0.0);
-    } else {
-        t = sub_fp64(t, mul_fp64(PI_16_FP64, vec2(q, 0.0)));
-    }
-
-    vec2 u = vec2(0.0, 0.0);
-    vec2 v = vec2(0.0, 0.0);
-
+if (a.x == 0.0 && a.y == 0.0) {
+return vec2(0.0, 0.0);
+}
+vec2 z = nint_fp64(div_fp64(a, TWO_PI_FP64));
+vec2 r = sub_fp64(a, mul_fp64(TWO_PI_FP64, z));
+vec2 t;
+float q = floor(r.x / PI_2_FP64.x + 0.5);
+int j = int(q);
+if (j < -2 || j > 2) {
+return vec2(0.0 / 0.0, 0.0 / 0.0);
+}
+t = sub_fp64(r, mul_fp64(PI_2_FP64, vec2(q, 0.0)));
+q = floor(t.x / PI_16_FP64.x + 0.5);
+int k = int(q);
+if (k == 0) {
+if (j == 0) {
+return sin_taylor_fp64(t);
+} else if (j == 1) {
+return cos_taylor_fp64(t);
+} else if (j == -1) {
+return -cos_taylor_fp64(t);
+} else {
+return -sin_taylor_fp64(t);
+}
+}
+int abs_k = int(abs(float(k)));
+if (abs_k > 4) {
+return vec2(0.0 / 0.0, 0.0 / 0.0);
+} else {
+t = sub_fp64(t, mul_fp64(PI_16_FP64, vec2(q, 0.0)));
+}
+vec2 u = vec2(0.0, 0.0);
+vec2 v = vec2(0.0, 0.0);
 #if defined(NVIDIA_FP64_WORKAROUND) || defined(INTEL_FP64_WORKAROUND)
-    if (abs(float(abs_k) - 1.0) < 0.5) {
-        u = COS_TABLE_0_FP64;
-        v = SIN_TABLE_0_FP64;
-    } else if (abs(float(abs_k) - 2.0) < 0.5) {
-        u = COS_TABLE_1_FP64;
-        v = SIN_TABLE_1_FP64;
-    } else if (abs(float(abs_k) - 3.0) < 0.5) {
-        u = COS_TABLE_2_FP64;
-        v = SIN_TABLE_2_FP64;
-    } else if (abs(float(abs_k) - 4.0) < 0.5) {
-        u = COS_TABLE_3_FP64;
-        v = SIN_TABLE_3_FP64;
-    }
+if (abs(float(abs_k) - 1.0) < 0.5) {
+u = COS_TABLE_0_FP64;
+v = SIN_TABLE_0_FP64;
+} else if (abs(float(abs_k) - 2.0) < 0.5) {
+u = COS_TABLE_1_FP64;
+v = SIN_TABLE_1_FP64;
+} else if (abs(float(abs_k) - 3.0) < 0.5) {
+u = COS_TABLE_2_FP64;
+v = SIN_TABLE_2_FP64;
+} else if (abs(float(abs_k) - 4.0) < 0.5) {
+u = COS_TABLE_3_FP64;
+v = SIN_TABLE_3_FP64;
+}
 #else
-    if (abs_k == 1) {
-        u = COS_TABLE_0_FP64;
-        v = SIN_TABLE_0_FP64;
-    } else if (abs_k == 2) {
-        u = COS_TABLE_1_FP64;
-        v = SIN_TABLE_1_FP64;
-    } else if (abs_k == 3) {
-        u = COS_TABLE_2_FP64;
-        v = SIN_TABLE_2_FP64;
-    } else if (abs_k == 4) {
-        u = COS_TABLE_3_FP64;
-        v = SIN_TABLE_3_FP64;
-    }
+if (abs_k == 1) {
+u = COS_TABLE_0_FP64;
+v = SIN_TABLE_0_FP64;
+} else if (abs_k == 2) {
+u = COS_TABLE_1_FP64;
+v = SIN_TABLE_1_FP64;
+} else if (abs_k == 3) {
+u = COS_TABLE_2_FP64;
+v = SIN_TABLE_2_FP64;
+} else if (abs_k == 4) {
+u = COS_TABLE_3_FP64;
+v = SIN_TABLE_3_FP64;
+}
 #endif
-
-    vec2 sin_t, cos_t;
-    sincos_taylor_fp64(t, sin_t, cos_t);
-
-
-
-    vec2 result = vec2(0.0, 0.0);
-    if (j == 0) {
-        if (k > 0) {
-            result = sum_fp64(mul_fp64(u, sin_t), mul_fp64(v, cos_t));
-        } else {
-            result = sub_fp64(mul_fp64(u, sin_t), mul_fp64(v, cos_t));
-        }
-    } else if (j == 1) {
-        if (k > 0) {
-            result = sub_fp64(mul_fp64(u, cos_t), mul_fp64(v, sin_t));
-        } else {
-            result = sum_fp64(mul_fp64(u, cos_t), mul_fp64(v, sin_t));
-        }
-    } else if (j == -1) {
-        if (k > 0) {
-            result = sub_fp64(mul_fp64(v, sin_t), mul_fp64(u, cos_t));
-        } else {
-            result = -sum_fp64(mul_fp64(v, sin_t), mul_fp64(u, cos_t));
-        }
-    } else {
-        if (k > 0) {
-            result = -sum_fp64(mul_fp64(u, sin_t), mul_fp64(v, cos_t));
-        } else {
-            result = sub_fp64(mul_fp64(v, cos_t), mul_fp64(u, sin_t));
-        }
-    }
-
-    return result;
+vec2 sin_t, cos_t;
+sincos_taylor_fp64(t, sin_t, cos_t);
+vec2 result = vec2(0.0, 0.0);
+if (j == 0) {
+if (k > 0) {
+result = sum_fp64(mul_fp64(u, sin_t), mul_fp64(v, cos_t));
+} else {
+result = sub_fp64(mul_fp64(u, sin_t), mul_fp64(v, cos_t));
+}
+} else if (j == 1) {
+if (k > 0) {
+result = sub_fp64(mul_fp64(u, cos_t), mul_fp64(v, sin_t));
+} else {
+result = sum_fp64(mul_fp64(u, cos_t), mul_fp64(v, sin_t));
+}
+} else if (j == -1) {
+if (k > 0) {
+result = sub_fp64(mul_fp64(v, sin_t), mul_fp64(u, cos_t));
+} else {
+result = -sum_fp64(mul_fp64(v, sin_t), mul_fp64(u, cos_t));
+}
+} else {
+if (k > 0) {
+result = -sum_fp64(mul_fp64(u, sin_t), mul_fp64(v, cos_t));
+} else {
+result = sub_fp64(mul_fp64(v, cos_t), mul_fp64(u, sin_t));
+}
+}
+return result;
 }
-
 vec2 cos_fp64(vec2 a) {
-    if (a.x == 0.0 && a.y == 0.0) {
-        return vec2(1.0, 0.0);
-    }
-
-    // 2pi range reduction
-    vec2 z = nint_fp64(div_fp64(a, TWO_PI_FP64));
-    vec2 r = sub_fp64(a, mul_fp64(TWO_PI_FP64, z));
-
-    vec2 t;
-    float q = floor(r.x / PI_2_FP64.x + 0.5);
-    int j = int(q);
-
-    if (j < -2 || j > 2) {
-        return vec2(0.0 / 0.0, 0.0 / 0.0);
-    }
-
-    t = sub_fp64(r, mul_fp64(PI_2_FP64, vec2(q, 0.0)));
-
-    q = floor(t.x / PI_16_FP64.x + 0.5);
-    int k = int(q);
-
-    if (k == 0) {
-        if (j == 0) {
-            return cos_taylor_fp64(t);
-        } else if (j == 1) {
-            return -sin_taylor_fp64(t);
-        } else if (j == -1) {
-            return sin_taylor_fp64(t);
-        } else {
-            return -cos_taylor_fp64(t);
-        }
-    }
-
-    int abs_k = int(abs(float(k)));
-
-    if (abs_k > 4) {
-        return vec2(0.0 / 0.0, 0.0 / 0.0);
-    } else {
-        t = sub_fp64(t, mul_fp64(PI_16_FP64, vec2(q, 0.0)));
-    }
-
-    vec2 u = vec2(0.0, 0.0);
-    vec2 v = vec2(0.0, 0.0);
-
+if (a.x == 0.0 && a.y == 0.0) {
+return vec2(1.0, 0.0);
+}
+vec2 z = nint_fp64(div_fp64(a, TWO_PI_FP64));
+vec2 r = sub_fp64(a, mul_fp64(TWO_PI_FP64, z));
+vec2 t;
+float q = floor(r.x / PI_2_FP64.x + 0.5);
+int j = int(q);
+if (j < -2 || j > 2) {
+return vec2(0.0 / 0.0, 0.0 / 0.0);
+}
+t = sub_fp64(r, mul_fp64(PI_2_FP64, vec2(q, 0.0)));
+q = floor(t.x / PI_16_FP64.x + 0.5);
+int k = int(q);
+if (k == 0) {
+if (j == 0) {
+return cos_taylor_fp64(t);
+} else if (j == 1) {
+return -sin_taylor_fp64(t);
+} else if (j == -1) {
+return sin_taylor_fp64(t);
+} else {
+return -cos_taylor_fp64(t);
+}
+}
+int abs_k = int(abs(float(k)));
+if (abs_k > 4) {
+return vec2(0.0 / 0.0, 0.0 / 0.0);
+} else {
+t = sub_fp64(t, mul_fp64(PI_16_FP64, vec2(q, 0.0)));
+}
+vec2 u = vec2(0.0, 0.0);
+vec2 v = vec2(0.0, 0.0);
 #if defined(NVIDIA_FP64_WORKAROUND) || defined(INTEL_FP64_WORKAROUND)
-    if (abs(float(abs_k) - 1.0) < 0.5) {
-        u = COS_TABLE_0_FP64;
-        v = SIN_TABLE_0_FP64;
-    } else if (abs(float(abs_k) - 2.0) < 0.5) {
-        u = COS_TABLE_1_FP64;
-        v = SIN_TABLE_1_FP64;
-    } else if (abs(float(abs_k) - 3.0) < 0.5) {
-        u = COS_TABLE_2_FP64;
-        v = SIN_TABLE_2_FP64;
-    } else if (abs(float(abs_k) - 4.0) < 0.5) {
-        u = COS_TABLE_3_FP64;
-        v = SIN_TABLE_3_FP64;
-    }
+if (abs(float(abs_k) - 1.0) < 0.5) {
+u = COS_TABLE_0_FP64;
+v = SIN_TABLE_0_FP64;
+} else if (abs(float(abs_k) - 2.0) < 0.5) {
+u = COS_TABLE_1_FP64;
+v = SIN_TABLE_1_FP64;
+} else if (abs(float(abs_k) - 3.0) < 0.5) {
+u = COS_TABLE_2_FP64;
+v = SIN_TABLE_2_FP64;
+} else if (abs(float(abs_k) - 4.0) < 0.5) {
+u = COS_TABLE_3_FP64;
+v = SIN_TABLE_3_FP64;
+}
 #else
-    if (abs_k == 1) {
-        u = COS_TABLE_0_FP64;
-        v = SIN_TABLE_0_FP64;
-    } else if (abs_k == 2) {
-        u = COS_TABLE_1_FP64;
-        v = SIN_TABLE_1_FP64;
-    } else if (abs_k == 3) {
-        u = COS_TABLE_2_FP64;
-        v = SIN_TABLE_2_FP64;
-    } else if (abs_k == 4) {
-        u = COS_TABLE_3_FP64;
-        v = SIN_TABLE_3_FP64;
-    }
+if (abs_k == 1) {
+u = COS_TABLE_0_FP64;
+v = SIN_TABLE_0_FP64;
+} else if (abs_k == 2) {
+u = COS_TABLE_1_FP64;
+v = SIN_TABLE_1_FP64;
+} else if (abs_k == 3) {
+u = COS_TABLE_2_FP64;
+v = SIN_TABLE_2_FP64;
+} else if (abs_k == 4) {
+u = COS_TABLE_3_FP64;
+v = SIN_TABLE_3_FP64;
+}
 #endif
-
-    vec2 sin_t, cos_t;
-    sincos_taylor_fp64(t, sin_t, cos_t);
-
-    vec2 result = vec2(0.0, 0.0);
-    if (j == 0) {
-        if (k > 0) {
-            result = sub_fp64(mul_fp64(u, cos_t), mul_fp64(v, sin_t));
-        } else {
-            result = sum_fp64(mul_fp64(u, cos_t), mul_fp64(v, sin_t));
-        }
-    } else if (j == 1) {
-        if (k > 0) {
-            result = -sum_fp64(mul_fp64(u, sin_t), mul_fp64(v, cos_t));
-        } else {
-            result = sub_fp64(mul_fp64(v, cos_t), mul_fp64(u, sin_t));
-        }
-    } else if (j == -1) {
-        if (k > 0) {
-            result = sum_fp64(mul_fp64(u, sin_t), mul_fp64(v, cos_t));
-        } else {
-            result = sub_fp64(mul_fp64(u, sin_t), mul_fp64(v, cos_t));
-        }
-    } else {
-        if (k > 0) {
-            result = sub_fp64(mul_fp64(v, sin_t), mul_fp64(u, cos_t));
-        } else {
-            result = -sum_fp64(mul_fp64(u, cos_t), mul_fp64(v, sin_t));
-        }
-    }
-
-    return result;
+vec2 sin_t, cos_t;
+sincos_taylor_fp64(t, sin_t, cos_t);
+vec2 result = vec2(0.0, 0.0);
+if (j == 0) {
+if (k > 0) {
+result = sub_fp64(mul_fp64(u, cos_t), mul_fp64(v, sin_t));
+} else {
+result = sum_fp64(mul_fp64(u, cos_t), mul_fp64(v, sin_t));
+}
+} else if (j == 1) {
+if (k > 0) {
+result = -sum_fp64(mul_fp64(u, sin_t), mul_fp64(v, cos_t));
+} else {
+result = sub_fp64(mul_fp64(v, cos_t), mul_fp64(u, sin_t));
+}
+} else if (j == -1) {
+if (k > 0) {
+result = sum_fp64(mul_fp64(u, sin_t), mul_fp64(v, cos_t));
+} else {
+result = sub_fp64(mul_fp64(u, sin_t), mul_fp64(v, cos_t));
+}
+} else {
+if (k > 0) {
+result = sub_fp64(mul_fp64(v, sin_t), mul_fp64(u, cos_t));
+} else {
+result = -sum_fp64(mul_fp64(u, cos_t), mul_fp64(v, sin_t));
+}
+}
+return result;
 }
-
 vec2 tan_fp64(vec2 a) {
-    vec2 sin_a;
-    vec2 cos_a;
-
-    if (a.x == 0.0 && a.y == 0.0) {
-        return vec2(0.0, 0.0);
-    }
-
-    // 2pi range reduction
-    vec2 z = nint_fp64(div_fp64(a, TWO_PI_FP64));
-    vec2 r = sub_fp64(a, mul_fp64(TWO_PI_FP64, z));
-
-    vec2 t;
-    float q = floor(r.x / PI_2_FP64.x + 0.5);
-    int j = int(q);
-
-
-    if (j < -2 || j > 2) {
-        return vec2(0.0 / 0.0, 0.0 / 0.0);
-    }
-
-    t = sub_fp64(r, mul_fp64(PI_2_FP64, vec2(q, 0.0)));
-
-    q = floor(t.x / PI_16_FP64.x + 0.5);
-    int k = int(q);
-    int abs_k = int(abs(float(k)));
-
-    // We just can't get PI/16 * 3.0 very accurately.
-    // so let's just store it
-    if (abs_k > 4) {
-        return vec2(0.0 / 0.0, 0.0 / 0.0);
-    } else {
-        t = sub_fp64(t, mul_fp64(PI_16_FP64, vec2(q, 0.0)));
-    }
-
-
-    vec2 u = vec2(0.0, 0.0);
-    vec2 v = vec2(0.0, 0.0);
-
-    vec2 sin_t, cos_t;
-    vec2 s, c;
-    sincos_taylor_fp64(t, sin_t, cos_t);
-
-    if (k == 0) {
-        s = sin_t;
-        c = cos_t;
-    } else {
+vec2 sin_a;
+vec2 cos_a;
+if (a.x == 0.0 && a.y == 0.0) {
+return vec2(0.0, 0.0);
+}
+vec2 z = nint_fp64(div_fp64(a, TWO_PI_FP64));
+vec2 r = sub_fp64(a, mul_fp64(TWO_PI_FP64, z));
+vec2 t;
+float q = floor(r.x / PI_2_FP64.x + 0.5);
+int j = int(q);
+if (j < -2 || j > 2) {
+return vec2(0.0 / 0.0, 0.0 / 0.0);
+}
+t = sub_fp64(r, mul_fp64(PI_2_FP64, vec2(q, 0.0)));
+q = floor(t.x / PI_16_FP64.x + 0.5);
+int k = int(q);
+int abs_k = int(abs(float(k)));
+if (abs_k > 4) {
+return vec2(0.0 / 0.0, 0.0 / 0.0);
+} else {
+t = sub_fp64(t, mul_fp64(PI_16_FP64, vec2(q, 0.0)));
+}
+vec2 u = vec2(0.0, 0.0);
+vec2 v = vec2(0.0, 0.0);
+vec2 sin_t, cos_t;
+vec2 s, c;
+sincos_taylor_fp64(t, sin_t, cos_t);
+if (k == 0) {
+s = sin_t;
+c = cos_t;
+} else {
 #if defined(NVIDIA_FP64_WORKAROUND) || defined(INTEL_FP64_WORKAROUND)
-        if (abs(float(abs_k) - 1.0) < 0.5) {
-            u = COS_TABLE_0_FP64;
-            v = SIN_TABLE_0_FP64;
-        } else if (abs(float(abs_k) - 2.0) < 0.5) {
-            u = COS_TABLE_1_FP64;
-            v = SIN_TABLE_1_FP64;
-        } else if (abs(float(abs_k) - 3.0) < 0.5) {
-            u = COS_TABLE_2_FP64;
-            v = SIN_TABLE_2_FP64;
-        } else if (abs(float(abs_k) - 4.0) < 0.5) {
-            u = COS_TABLE_3_FP64;
-            v = SIN_TABLE_3_FP64;
-        }
+if (abs(float(abs_k) - 1.0) < 0.5) {
+u = COS_TABLE_0_FP64;
+v = SIN_TABLE_0_FP64;
+} else if (abs(float(abs_k) - 2.0) < 0.5) {
+u = COS_TABLE_1_FP64;
+v = SIN_TABLE_1_FP64;
+} else if (abs(float(abs_k) - 3.0) < 0.5) {
+u = COS_TABLE_2_FP64;
+v = SIN_TABLE_2_FP64;
+} else if (abs(float(abs_k) - 4.0) < 0.5) {
+u = COS_TABLE_3_FP64;
+v = SIN_TABLE_3_FP64;
+}
 #else
-        if (abs_k == 1) {
-            u = COS_TABLE_0_FP64;
-            v = SIN_TABLE_0_FP64;
-        } else if (abs_k == 2) {
-            u = COS_TABLE_1_FP64;
-            v = SIN_TABLE_1_FP64;
-        } else if (abs_k == 3) {
-            u = COS_TABLE_2_FP64;
-            v = SIN_TABLE_2_FP64;
-        } else if (abs_k == 4) {
-            u = COS_TABLE_3_FP64;
-            v = SIN_TABLE_3_FP64;
-        }
+if (abs_k == 1) {
+u = COS_TABLE_0_FP64;
+v = SIN_TABLE_0_FP64;
+} else if (abs_k == 2) {
+u = COS_TABLE_1_FP64;
+v = SIN_TABLE_1_FP64;
+} else if (abs_k == 3) {
+u = COS_TABLE_2_FP64;
+v = SIN_TABLE_2_FP64;
+} else if (abs_k == 4) {
+u = COS_TABLE_3_FP64;
+v = SIN_TABLE_3_FP64;
+}
 #endif
-        if (k > 0) {
-            s = sum_fp64(mul_fp64(u, sin_t), mul_fp64(v, cos_t));
-            c = sub_fp64(mul_fp64(u, cos_t), mul_fp64(v, sin_t));
-        } else {
-            s = sub_fp64(mul_fp64(u, sin_t), mul_fp64(v, cos_t));
-            c = sum_fp64(mul_fp64(u, cos_t), mul_fp64(v, sin_t));
-        }
-    }
-
-    if (j == 0) {
-        sin_a = s;
-        cos_a = c;
-    } else if (j == 1) {
-        sin_a = c;
-        cos_a = -s;
-    } else if (j == -1) {
-        sin_a = -c;
-        cos_a = s;
-    } else {
-        sin_a = -s;
-        cos_a = -c;
-    }
-    return div_fp64(sin_a, cos_a);
+if (k > 0) {
+s = sum_fp64(mul_fp64(u, sin_t), mul_fp64(v, cos_t));
+c = sub_fp64(mul_fp64(u, cos_t), mul_fp64(v, sin_t));
+} else {
+s = sub_fp64(mul_fp64(u, sin_t), mul_fp64(v, cos_t));
+c = sum_fp64(mul_fp64(u, cos_t), mul_fp64(v, sin_t));
+}
+}
+if (j == 0) {
+sin_a = s;
+cos_a = c;
+} else if (j == 1) {
+sin_a = c;
+cos_a = -s;
+} else if (j == -1) {
+sin_a = -c;
+cos_a = s;
+} else {
+sin_a = -s;
+cos_a = -c;
+}
+return div_fp64(sin_a, cos_a);
 }
-
 vec2 radians_fp64(vec2 degree) {
-  return mul_fp64(degree, PI_180_FP64);
+return mul_fp64(degree, PI_180_FP64);
 }
-
 vec2 mix_fp64(vec2 a, vec2 b, float x) {
-  vec2 range = sub_fp64(b, a);
-  return sum_fp64(a, mul_fp64(range, vec2(x, 0.0)));
+vec2 range = sub_fp64(b, a);
+return sum_fp64(a, mul_fp64(range, vec2(x, 0.0)));
 }
-
-// Vector functions
-// vec2 functions
 void vec2_sum_fp64(vec2 a[2], vec2 b[2], out vec2 out_val[2]) {
-    out_val[0] = sum_fp64(a[0], b[0]);
-    out_val[1] = sum_fp64(a[1], b[1]);
+out_val[0] = sum_fp64(a[0], b[0]);
+out_val[1] = sum_fp64(a[1], b[1]);
 }
-
 void vec2_sub_fp64(vec2 a[2], vec2 b[2], out vec2 out_val[2]) {
-    out_val[0] = sub_fp64(a[0], b[0]);
-    out_val[1] = sub_fp64(a[1], b[1]);
+out_val[0] = sub_fp64(a[0], b[0]);
+out_val[1] = sub_fp64(a[1], b[1]);
 }
-
 void vec2_mul_fp64(vec2 a[2], vec2 b[2], out vec2 out_val[2]) {
-    out_val[0] = mul_fp64(a[0], b[0]);
-    out_val[1] = mul_fp64(a[1], b[1]);
+out_val[0] = mul_fp64(a[0], b[0]);
+out_val[1] = mul_fp64(a[1], b[1]);
 }
-
 void vec2_div_fp64(vec2 a[2], vec2 b[2], out vec2 out_val[2]) {
-    out_val[0] = div_fp64(a[0], b[0]);
-    out_val[1] = div_fp64(a[1], b[1]);
+out_val[0] = div_fp64(a[0], b[0]);
+out_val[1] = div_fp64(a[1], b[1]);
 }
-
 void vec2_mix_fp64(vec2 x[2], vec2 y[2], float a, out vec2 out_val[2]) {
-  vec2 range[2];
-  vec2_sub_fp64(y, x, range);
-  vec2 portion[2];
-  portion[0] = range[0] * a;
-  portion[1] = range[1] * a;
-  vec2_sum_fp64(x, portion, out_val);
+vec2 range[2];
+vec2_sub_fp64(y, x, range);
+vec2 portion[2];
+portion[0] = range[0] * a;
+portion[1] = range[1] * a;
+vec2_sum_fp64(x, portion, out_val);
 }
-
 vec2 vec2_length_fp64(vec2 x[2]) {
-  return sqrt_fp64(sum_fp64(mul_fp64(x[0], x[0]), mul_fp64(x[1], x[1])));
+return sqrt_fp64(sum_fp64(mul_fp64(x[0], x[0]), mul_fp64(x[1], x[1])));
 }
-
 void vec2_normalize_fp64(vec2 x[2], out vec2 out_val[2]) {
-  vec2 length = vec2_length_fp64(x);
-  vec2 length_vec2[2];
-  length_vec2[0] = length;
-  length_vec2[1] = length;
-
-  vec2_div_fp64(x, length_vec2, out_val);
+vec2 length = vec2_length_fp64(x);
+vec2 length_vec2[2];
+length_vec2[0] = length;
+length_vec2[1] = length;
+vec2_div_fp64(x, length_vec2, out_val);
 }
-
 vec2 vec2_distance_fp64(vec2 x[2], vec2 y[2]) {
-  vec2 diff[2];
-  vec2_sub_fp64(x, y, diff);
-  return vec2_length_fp64(diff);
+vec2 diff[2];
+vec2_sub_fp64(x, y, diff);
+return vec2_length_fp64(diff);
 }
-
 vec2 vec2_dot_fp64(vec2 a[2], vec2 b[2]) {
-  vec2 v[2];
-
-  v[0] = mul_fp64(a[0], b[0]);
-  v[1] = mul_fp64(a[1], b[1]);
-
-  return sum_fp64(v[0], v[1]);
+vec2 v[2];
+v[0] = mul_fp64(a[0], b[0]);
+v[1] = mul_fp64(a[1], b[1]);
+return sum_fp64(v[0], v[1]);
 }
-
-// vec3 functions
 void vec3_sub_fp64(vec2 a[3], vec2 b[3], out vec2 out_val[3]) {
-  for (int i = 0; i < 3; i++) {
-    out_val[i] = sum_fp64(a[i], b[i]);
-  }
+for (int i = 0; i < 3; i++) {
+out_val[i] = sum_fp64(a[i], b[i]);
+}
 }
-
 void vec3_sum_fp64(vec2 a[3], vec2 b[3], out vec2 out_val[3]) {
-  for (int i = 0; i < 3; i++) {
-    out_val[i] = sum_fp64(a[i], b[i]);
-  }
+for (int i = 0; i < 3; i++) {
+out_val[i] = sum_fp64(a[i], b[i]);
+}
 }
-
 vec2 vec3_length_fp64(vec2 x[3]) {
-  return sqrt_fp64(sum_fp64(sum_fp64(mul_fp64(x[0], x[0]), mul_fp64(x[1], x[1])),
-    mul_fp64(x[2], x[2])));
+return sqrt_fp64(sum_fp64(sum_fp64(mul_fp64(x[0], x[0]), mul_fp64(x[1], x[1])),
+mul_fp64(x[2], x[2])));
 }
-
 vec2 vec3_distance_fp64(vec2 x[3], vec2 y[3]) {
-  vec2 diff[3];
-  vec3_sub_fp64(x, y, diff);
-  return vec3_length_fp64(diff);
+vec2 diff[3];
+vec3_sub_fp64(x, y, diff);
+return vec3_length_fp64(diff);
 }
-
-// vec4 functions
 void vec4_fp64(vec4 a, out vec2 out_val[4]) {
-  out_val[0].x = a[0];
-  out_val[0].y = 0.0;
-
-  out_val[1].x = a[1];
-  out_val[1].y = 0.0;
-
-  out_val[2].x = a[2];
-  out_val[2].y = 0.0;
-
-  out_val[3].x = a[3];
-  out_val[3].y = 0.0;
+out_val[0].x = a[0];
+out_val[0].y = 0.0;
+out_val[1].x = a[1];
+out_val[1].y = 0.0;
+out_val[2].x = a[2];
+out_val[2].y = 0.0;
+out_val[3].x = a[3];
+out_val[3].y = 0.0;
 }
-
 void vec4_scalar_mul_fp64(vec2 a[4], vec2 b, out vec2 out_val[4]) {
-  out_val[0] = mul_fp64(a[0], b);
-  out_val[1] = mul_fp64(a[1], b);
-  out_val[2] = mul_fp64(a[2], b);
-  out_val[3] = mul_fp64(a[3], b);
+out_val[0] = mul_fp64(a[0], b);
+out_val[1] = mul_fp64(a[1], b);
+out_val[2] = mul_fp64(a[2], b);
+out_val[3] = mul_fp64(a[3], b);
 }
-
 void vec4_sum_fp64(vec2 a[4], vec2 b[4], out vec2 out_val[4]) {
-  for (int i = 0; i < 4; i++) {
-    out_val[i] = sum_fp64(a[i], b[i]);
-  }
+for (int i = 0; i < 4; i++) {
+out_val[i] = sum_fp64(a[i], b[i]);
+}
 }
-
 void vec4_dot_fp64(vec2 a[4], vec2 b[4], out vec2 out_val) {
-  vec2 v[4];
-
-  v[0] = mul_fp64(a[0], b[0]);
-  v[1] = mul_fp64(a[1], b[1]);
-  v[2] = mul_fp64(a[2], b[2]);
-  v[3] = mul_fp64(a[3], b[3]);
-
-  out_val = sum_fp64(sum_fp64(v[0], v[1]), sum_fp64(v[2], v[3]));
+vec2 v[4];
+v[0] = mul_fp64(a[0], b[0]);
+v[1] = mul_fp64(a[1], b[1]);
+v[2] = mul_fp64(a[2], b[2]);
+v[3] = mul_fp64(a[3], b[3]);
+out_val = sum_fp64(sum_fp64(v[0], v[1]), sum_fp64(v[2], v[3]));
 }
-
 void mat4_vec4_mul_fp64(vec2 b[16], vec2 a[4], out vec2 out_val[4]) {
-  vec2 tmp[4];
-
-  for (int i = 0; i < 4; i++)
-  {
-    for (int j = 0; j < 4; j++)
-    {
-      tmp[j] = b[j + i * 4];
-    }
-    vec4_dot_fp64(a, tmp, out_val[i]);
-  }
+vec2 tmp[4];
+for (int i = 0; i < 4; i++)
+{
+for (int j = 0; j < 4; j++)
+{
+tmp[j] = b[j + i * 4];
+}
+vec4_dot_fp64(a, tmp, out_val[i]);
+}
 }
 `;
 
@@ -3098,9 +2892,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
@@ -3122,7 +2916,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;
@@ -3136,17 +2930,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;
@@ -3321,7 +3115,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) {
@@ -3333,16 +3127,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;
 `
   };
@@ -3351,16 +3145,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;
 `
   };
@@ -3403,7 +3197,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
@@ -3454,10 +3248,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;
@@ -3477,7 +3271,7 @@ float collision_isVisible(vec2 texCoords, vec3 pickingColor) {
     }
   }
   `,
-    "vs:DECKGL_FILTER_COLOR": `
+    "vs:DECKGL_FILTER_COLOR": glsl`
   color.a *= collision_fade;
   `
   };
@@ -4096,14 +3890,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;
@@ -4132,10 +3926,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));
@@ -4144,10 +3938,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);
 
@@ -4246,20 +4040,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;
@@ -4278,20 +4071,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);
@@ -4362,7 +4154,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,