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

package/dist/data-filter/aggregator.js

@@ -0,0 +1,104 @@
+import { Model } from '@luma.gl/engine';
+import { GL } from '@luma.gl/constants';
+const AGGREGATE_VS = `\
+#version 300 es
+#define SHADER_NAME data-filter-vertex-shader
+
+#ifdef FLOAT_TARGET
+  in float filterIndices;
+  in float filterPrevIndices;
+#else
+  in vec2 filterIndices;
+  in vec2 filterPrevIndices;
+#endif
+
+out vec4 vColor;
+const float component = 1.0 / 255.0;
+
+void main() {
+  #ifdef FLOAT_TARGET
+    dataFilter_value *= float(filterIndices != filterPrevIndices);
+    gl_Position = vec4(0.0, 0.0, 0.0, 1.0);
+    vColor = vec4(0.0, 0.0, 0.0, 1.0);
+  #else
+    // Float texture is not supported: pack result into 4 channels x 256 px x 64px
+    dataFilter_value *= float(filterIndices.x != filterPrevIndices.x);
+    float col = filterIndices.x;
+    float row = filterIndices.y * 4.0;
+    float channel = floor(row);
+    row = fract(row);
+    vColor = component * vec4(bvec4(channel == 0.0, channel == 1.0, channel == 2.0, channel == 3.0));
+    gl_Position = vec4(col * 2.0 - 1.0, row * 2.0 - 1.0, 0.0, 1.0);
+  #endif
+  gl_PointSize = 1.0;
+}
+`;
+const AGGREGATE_FS = `\
+#version 300 es
+#define SHADER_NAME data-filter-fragment-shader
+precision highp float;
+
+in vec4 vColor;
+
+out vec4 fragColor;
+
+void main() {
+  if (dataFilter_value < 0.5) {
+    discard;
+  }
+  fragColor = vColor;
+}
+`;
+export function supportsFloatTarget(device) {
+    // @ts-expect-error
+    const gl = device.gl;
+    // https://developer.mozilla.org/en-US/docs/Web/API/WebGL_API/WebGL_best_practices#Support_for_float_textures_doesnt_mean_you_can_render_into_them!
+    return Boolean(gl.getExtension('EXT_float_blend') &&
+        // WebGL 2
+        (gl.getExtension('EXT_color_buffer_float') ||
+            // WebGL 1
+            gl.getExtension('WEBGL_color_buffer_float')));
+}
+// A 1x1 framebuffer object that encodes the total count of filtered items
+export function getFramebuffer(device, useFloatTarget) {
+    if (useFloatTarget) {
+        return device.createFramebuffer({
+            width: 1,
+            height: 1,
+            colorAttachments: [
+                device.createTexture({
+                    format: device.info.type === 'webgl2' ? 'rgba32float' : 'rgba8unorm',
+                    type: GL.FLOAT,
+                    mipmaps: false
+                })
+            ]
+        });
+    }
+    return device.createFramebuffer({
+        width: 256,
+        height: 64,
+        colorAttachments: [device.createTexture({ format: 'rgba8unorm', type: GL.FLOAT, mipmaps: false })]
+    });
+}
+// Increments the counter based on dataFilter_value
+export function getModel(device, shaderOptions, useFloatTarget) {
+    shaderOptions.defines.NON_INSTANCED_MODEL = 1;
+    if (useFloatTarget) {
+        shaderOptions.defines.FLOAT_TARGET = 1;
+    }
+    return new Model(device, {
+        id: 'data-filter-aggregation-model',
+        vertexCount: 1,
+        isInstanced: false,
+        drawMode: GL.POINTS,
+        vs: AGGREGATE_VS,
+        fs: AGGREGATE_FS,
+        ...shaderOptions
+    });
+}
+export const parameters = {
+    blend: true,
+    blendFunc: [GL.ONE, GL.ONE, GL.ONE, GL.ONE],
+    blendEquation: [GL.FUNC_ADD, GL.FUNC_ADD],
+    depthTest: false
+};

package/{typed → dist}/data-filter/data-filter-extension.d.ts

@@ -1,11 +1,17 @@
 import type { Layer, LayerContext, Accessor, UpdateParameters } from '@deck.gl/core';
 import { LayerExtension } from '@deck.gl/core';
+type FilterCategory = number | string;
 export type DataFilterExtensionProps<DataT = any> = {
     /**
      * Accessor to retrieve the value for each object that it will be filtered by.
      * Returns either a number (if `filterSize: 1`) or an array of numbers.
      */
     getFilterValue?: Accessor<DataT, number | number[]>;
+    /**
+     * Accessor to retrieve the category (`number | string`) for each object that it will be filtered by.
+     * Returns either a single category (if `filterSize: 1`) or an array of categories.
+     */
+    getFilterCategory?: Accessor<DataT, FilterCategory | FilterCategory[]>;
     /**
      * Enable/disable the data filter. If the data filter is disabled, all objects are rendered.
      * @default true
@@ -33,6 +39,11 @@ export type DataFilterExtensionProps<DataT = any> = {
      * @default true
      */
     filterTransformColor?: boolean;
+    /**
+     * The categories which define whether an object should be rendered.
+     * @default []
+     */
+    filterCategories: FilterCategory[] | FilterCategory[][];
     /**
      * Only called if the `countItems` option is enabled.
      */
@@ -44,21 +55,26 @@ export type DataFilterExtensionProps<DataT = any> = {
     }) => void;
 };
 type DataFilterExtensionOptions = {
+    /**
+     * The size of the category filter (number of columns to filter by). The category filter can show/hide data based on 1-4 properties of each object.
+     * @default 1
+     */
+    categorySize?: 1 | 2 | 3 | 4;
     /**
      * The size of the filter (number of columns to filter by). The data filter can show/hide data based on 1-4 numeric properties of each object.
      * @default 1
      */
-    filterSize: number;
+    filterSize?: 1 | 2 | 3 | 4;
     /**
      * Use 64-bit precision instead of 32-bit.
      * @default false
      */
-    fp64: boolean;
+    fp64?: boolean;
     /**
      * If `true`, reports the number of filtered objects with the `onFilteredItemsChange` callback.
      * @default `false`.
      */
-    countItems: boolean;
+    countItems?: boolean;
 };
 /** Adds GPU-based data filtering functionalities to layers. It allows the layer to show/hide objects based on user-defined properties. */
 export default class DataFilterExtension extends LayerExtension<DataFilterExtensionOptions> {
@@ -67,6 +83,10 @@ export default class DataFilterExtension extends LayerExtension<DataFilterExtens
             type: string;
             value: number;
         };
+        getFilterCategory: {
+            type: string;
+            value: number;
+        };
         onFilteredItemsChange: {
             type: string;
             value: null;
@@ -75,16 +95,27 @@ export default class DataFilterExtension extends LayerExtension<DataFilterExtens
         filterEnabled: boolean;
         filterRange: number[];
         filterSoftRange: null;
+        filterCategories: number[];
         filterTransformSize: boolean;
         filterTransformColor: boolean;
     };
     static extensionName: string;
-    constructor({ filterSize, fp64, countItems }?: Partial<DataFilterExtensionOptions>);
     getShaders(this: Layer<DataFilterExtensionProps>, extension: this): any;
     initializeState(this: Layer<DataFilterExtensionProps>, context: LayerContext, extension: this): void;
-    updateState(this: Layer<DataFilterExtensionProps>, { props, oldProps }: UpdateParameters<Layer<DataFilterExtensionProps>>): void;
+    updateState(this: Layer<DataFilterExtensionProps>, { props, oldProps, changeFlags }: UpdateParameters<Layer<DataFilterExtensionProps>>, extension: this): void;
     draw(this: Layer<DataFilterExtensionProps>, params: any, extension: this): void;
     finalizeState(this: Layer<DataFilterExtensionProps>): void;
+    /**
+     * Updates the bitmask used on the GPU to perform the filter based on the
+     * `filterCategories` prop. The mapping between categories and bit in the bitmask
+     * is performed by `_getCategoryKey()`
+     */
+    _updateCategoryBitMask(this: Layer<DataFilterExtensionProps>, params: any, extension: this): void;
+    /**
+     * Returns an index of bit in the bitmask for a given category. If the category has
+     * not yet been assigned a bit, a new one is assigned.
+     */
+    _getCategoryKey(this: Layer<DataFilterExtensionProps>, category: FilterCategory, channel: number): number;
 }
 export {};
 //# sourceMappingURL=data-filter-extension.d.ts.map

package/dist/data-filter/data-filter-extension.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-filter-extension.d.ts","sourceRoot":"","sources":["../../src/data-filter/data-filter-extension.ts"],"names":[],"mappings":"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"}

package/dist/data-filter/data-filter-extension.js

@@ -0,0 +1,243 @@
+// Copyright (c) 2015 - 2017 Uber Technologies, Inc.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+import { GL } from '@luma.gl/constants';
+import { _deepEqual as deepEqual, LayerExtension, log } from '@deck.gl/core';
+import { shaderModule, shaderModule64 } from "./shader-module.js";
+import * as aggregator from "./aggregator.js";
+const defaultProps = {
+    getFilterValue: { type: 'accessor', value: 0 },
+    getFilterCategory: { type: 'accessor', value: 0 },
+    onFilteredItemsChange: { type: 'function', value: null, optional: true },
+    filterEnabled: true,
+    filterRange: [-1, 1],
+    filterSoftRange: null,
+    filterCategories: [0],
+    filterTransformSize: true,
+    filterTransformColor: true
+};
+const DATA_TYPE_FROM_SIZE = {
+    1: 'float',
+    2: 'vec2',
+    3: 'vec3',
+    4: 'vec4'
+};
+/** Adds GPU-based data filtering functionalities to layers. It allows the layer to show/hide objects based on user-defined properties. */
+export default class DataFilterExtension extends LayerExtension {
+    static { this.defaultProps = defaultProps; }
+    static { this.extensionName = 'DataFilterExtension'; }
+    getShaders(extension) {
+        const { categorySize, filterSize, fp64 } = extension.opts;
+        return {
+            modules: [fp64 ? shaderModule64 : shaderModule],
+            defines: {
+                DATACATEGORY_TYPE: DATA_TYPE_FROM_SIZE[categorySize || 1],
+                DATACATEGORY_CHANNELS: categorySize,
+                DATAFILTER_TYPE: DATA_TYPE_FROM_SIZE[filterSize || 1],
+                DATAFILTER_DOUBLE: Boolean(fp64)
+            }
+        };
+    }
+    initializeState(context, extension) {
+        const attributeManager = this.getAttributeManager();
+        const { categorySize, filterSize, fp64 } = extension.opts;
+        if (attributeManager) {
+            attributeManager.add({
+                filterValues: {
+                    size: filterSize,
+                    type: fp64 ? GL.DOUBLE : GL.FLOAT,
+                    accessor: 'getFilterValue',
+                    shaderAttributes: {
+                        filterValues: {
+                            divisor: 0
+                        },
+                        instanceFilterValues: {
+                            divisor: 1
+                        }
+                    }
+                },
+                filterCategoryValues: {
+                    size: categorySize,
+                    type: GL.FLOAT,
+                    accessor: 'getFilterCategory',
+                    transform: categorySize === 1
+                        ? d => extension._getCategoryKey.call(this, d, 0)
+                        : d => d.map((x, i) => extension._getCategoryKey.call(this, x, i)),
+                    shaderAttributes: {
+                        filterCategoryValues: {
+                            divisor: 0
+                        },
+                        instanceFilterCategoryValues: {
+                            divisor: 1
+                        }
+                    }
+                }
+            });
+        }
+        const { device } = this.context;
+        if (attributeManager && extension.opts.countItems) {
+            const useFloatTarget = aggregator.supportsFloatTarget(device);
+            // This attribute is needed for variable-width data, e.g. Path, SolidPolygon, Text
+            // The vertex shader checks if a vertex has the same "index" as the previous vertex
+            // so that we only write one count cross multiple vertices of the same object
+            attributeManager.add({
+                filterIndices: {
+                    size: useFloatTarget ? 1 : 2,
+                    vertexOffset: 1,
+                    type: GL.UNSIGNED_BYTE,
+                    normalized: true,
+                    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];
+                    },
+                    shaderAttributes: {
+                        filterPrevIndices: {
+                            vertexOffset: 0
+                        },
+                        filterIndices: {
+                            vertexOffset: 1
+                        }
+                    }
+                }
+            });
+            const filterFBO = aggregator.getFramebuffer(device, useFloatTarget);
+            const filterModel = aggregator.getModel(device, extension.getShaders.call(this, extension), useFloatTarget);
+            this.setState({ filterFBO, filterModel });
+        }
+    }
+    updateState({ props, oldProps, changeFlags }, extension) {
+        const attributeManager = this.getAttributeManager();
+        const { categorySize } = extension.opts;
+        if (this.state.filterModel) {
+            const filterNeedsUpdate = 
+            // attributeManager must be defined for filterModel to be set
+            attributeManager.attributes.filterValues.needsUpdate() ||
+                attributeManager.attributes.filterCategoryValues?.needsUpdate() ||
+                props.filterEnabled !== oldProps.filterEnabled ||
+                props.filterRange !== oldProps.filterRange ||
+                props.filterSoftRange !== oldProps.filterSoftRange ||
+                props.filterCategories !== oldProps.filterCategories;
+            if (filterNeedsUpdate) {
+                this.setState({ filterNeedsUpdate });
+            }
+        }
+        if (attributeManager?.attributes.filterCategoryValues) {
+            // Update bitmask if accessor or selected categories has changed
+            const categoryBitMaskNeedsUpdate = attributeManager.attributes.filterCategoryValues.needsUpdate() ||
+                !deepEqual(props.filterCategories, oldProps.filterCategories, 2);
+            if (categoryBitMaskNeedsUpdate) {
+                this.setState({ categoryBitMaskNeedsUpdate });
+            }
+            // Need to recreate category map if categorySize has changed
+            const resetCategories = changeFlags.dataChanged;
+            if (resetCategories) {
+                this.setState({
+                    categoryMap: Array(categorySize)
+                        .fill(0)
+                        .map(() => ({}))
+                });
+                attributeManager.attributes.filterCategoryValues.setNeedsUpdate('categoryMap');
+            }
+        }
+    }
+    draw(params, extension) {
+        const filterFBO = this.state.filterFBO;
+        const filterModel = this.state.filterModel;
+        const filterNeedsUpdate = this.state.filterNeedsUpdate;
+        const categoryBitMaskNeedsUpdate = this.state.categoryBitMaskNeedsUpdate;
+        const { onFilteredItemsChange } = this.props;
+        if (categoryBitMaskNeedsUpdate) {
+            extension._updateCategoryBitMask.call(this, params, extension);
+        }
+        if (filterNeedsUpdate && onFilteredItemsChange && filterModel) {
+            const { attributes: { filterValues, filterCategoryValues, filterIndices } } = this.getAttributeManager();
+            filterModel.setVertexCount(this.getNumInstances());
+            this.context.device.clearWebGL({ framebuffer: filterFBO, color: [0, 0, 0, 0] });
+            filterModel.updateModuleSettings(params.moduleParameters);
+            // @ts-expect-error filterValue and filterIndices should always have buffer value
+            filterModel.setAttributes({
+                ...filterValues.getValue(),
+                ...filterCategoryValues?.getValue(),
+                ...filterIndices?.getValue()
+            });
+            filterModel.setUniforms(params.uniforms);
+            filterModel.device.withParametersWebGL({
+                framebuffer: filterFBO,
+                // ts-ignore 'readonly' cannot be assigned to the mutable type '[GLBlendEquation, GLBlendEquation]'
+                ...aggregator.parameters,
+                viewport: [0, 0, filterFBO.width, filterFBO.height]
+            }, () => {
+                filterModel.draw(this.context.renderPass);
+            });
+            const color = filterModel.device.readPixelsToArrayWebGL(filterFBO);
+            let count = 0;
+            for (let i = 0; i < color.length; i++) {
+                count += color[i];
+            }
+            onFilteredItemsChange({ id: this.id, count });
+            this.state.filterNeedsUpdate = false;
+        }
+    }
+    finalizeState() {
+        const filterFBO = this.state.filterFBO;
+        const filterModel = this.state.filterModel;
+        // filterFBO.color.delete();
+        filterFBO?.destroy();
+        filterModel?.destroy();
+    }
+    /**
+     * Updates the bitmask used on the GPU to perform the filter based on the
+     * `filterCategories` prop. The mapping between categories and bit in the bitmask
+     * is performed by `_getCategoryKey()`
+     */
+    _updateCategoryBitMask(params, extension) {
+        const { categorySize } = extension.opts;
+        const { filterCategories } = this.props;
+        const categoryBitMask = new Uint32Array([0, 0, 0, 0]);
+        const categoryFilters = (categorySize === 1 ? [filterCategories] : filterCategories);
+        const maxCategories = categorySize === 1 ? 128 : categorySize === 2 ? 64 : 32;
+        for (let c = 0; c < categoryFilters.length; c++) {
+            const categoryFilter = categoryFilters[c];
+            for (const category of categoryFilter) {
+                const key = extension._getCategoryKey.call(this, category, c);
+                if (key < maxCategories) {
+                    const channel = c * (maxCategories / 32) + Math.floor(key / 32);
+                    categoryBitMask[channel] += Math.pow(2, key % 32); // 1 << key fails for key > 30
+                }
+                else {
+                    log.warn(`Exceeded maximum number of categories (${maxCategories})`)();
+                }
+            }
+        }
+        /* eslint-disable-next-line camelcase */
+        params.uniforms.filter_categoryBitMask = categoryBitMask;
+        this.state.categoryBitMaskNeedsUpdate = false;
+    }
+    /**
+     * Returns an index of bit in the bitmask for a given category. If the category has
+     * not yet been assigned a bit, a new one is assigned.
+     */
+    _getCategoryKey(category, channel) {
+        const categoryMap = this.state.categoryMap[channel];
+        if (!(category in categoryMap)) {
+            categoryMap[category] = Object.keys(categoryMap).length;
+        }
+        return categoryMap[category];
+    }
+}

package/{typed → dist}/data-filter/shader-module.d.ts

@@ -1,5 +1,5 @@
 import type { ShaderModule } from '@luma.gl/shadertools';
-import type { DataFilterExtensionProps } from './data-filter-extension';
+import type { DataFilterExtensionProps } from "./data-filter-extension.js";
 type DataFilterModuleSettings = {
     extensions: any[];
 } & DataFilterExtensionProps;

package/dist/data-filter/shader-module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shader-module.d.ts","sourceRoot":"","sources":["../../src/data-filter/shader-module.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,sBAAsB,CAAC;AACvD,OAAO,KAAK,EAAC,wBAAwB,EAAC,mCAAgC;AA8FtE,KAAK,wBAAwB,GAAG;IAC9B,UAAU,EAAE,GAAG,EAAE,CAAC;CACnB,GAAG,wBAAwB,CAAC;AAkG7B,eAAO,MAAM,YAAY,EAAE,YAAY,CAAC,wBAAwB,CAM/D,CAAC;AAEF,eAAO,MAAM,cAAc,EAAE,YAAY,CAAC,wBAAwB,CAMjE,CAAC"}

package/dist/data-filter/shader-module.js

@@ -0,0 +1,187 @@
+/*
+ * data filter shader module
+ */
+const vs = `
+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;
+  }
+}
+`;
+const fs = `
+uniform bool filter_transformColor;
+in float dataFilter_value;
+`;
+/* eslint-disable camelcase */
+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;
+}
+const inject = {
+    '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;
+    }
+  `
+};
+export const shaderModule = {
+    name: 'data-filter',
+    vs,
+    fs,
+    inject,
+    getUniforms
+};
+export const shaderModule64 = {
+    name: 'data-filter-fp64',
+    vs,
+    fs,
+    inject,
+    getUniforms: getUniforms64
+};