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

package/dist/index.cjs

@@ -207,13 +207,16 @@ 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;
@@ -223,6 +226,7 @@ in DATAFILTER_TYPE DATAFILTER_ATTRIB;
   uniform DATAFILTER_TYPE filter_min64High;
   uniform DATAFILTER_TYPE filter_max64High;
 #endif
+in DATACATEGORY_TYPE DATACATEGORY_ATTRIB;
 
 out float dataFilter_value;
 
@@ -238,7 +242,7 @@ float dataFilter_reduceValue(vec3 value) {
 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) {
+void dataFilter_setValue(DATAFILTER_TYPE valueFromMin, DATAFILTER_TYPE valueFromMax, DATACATEGORY_TYPE category) {
   if (filter_enabled) {
     if (filter_useSoftMargin) {
       dataFilter_value = dataFilter_reduceValue(
@@ -250,6 +254,29 @@ void dataFilter_setValue(DATAFILTER_TYPE valueFromMin, DATAFILTER_TYPE valueFrom
         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;
   }
@@ -314,10 +341,11 @@ var inject2 = {
     #ifdef DATAFILTER_DOUBLE
       dataFilter_setValue(
         DATAFILTER_ATTRIB - filter_min64High + DATAFILTER_ATTRIB_64LOW,
-        DATAFILTER_ATTRIB - filter_max64High + DATAFILTER_ATTRIB_64LOW
+        DATAFILTER_ATTRIB - filter_max64High + DATAFILTER_ATTRIB_64LOW,
+        DATACATEGORY_ATTRIB
       );
     #else
-      dataFilter_setValue(DATAFILTER_ATTRIB, DATAFILTER_ATTRIB);
+      dataFilter_setValue(DATAFILTER_ATTRIB, DATAFILTER_ATTRIB, DATACATEGORY_ATTRIB);
     #endif
   `,
   "vs:#main-end": `
@@ -451,13 +479,21 @@ var parameters = {
 // dist/data-filter/data-filter-extension.js
 var defaultProps2 = {
   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
 };
+var defaultOptions = {
+  categorySize: 1,
+  filterSize: 1,
+  fp64: false,
+  countItems: false
+};
 var DATA_TYPE_FROM_SIZE = {
   1: "float",
   2: "vec2",
@@ -465,17 +501,16 @@ var DATA_TYPE_FROM_SIZE = {
   4: "vec4"
 };
 var _DataFilterExtension = class extends import_core3.LayerExtension {
-  constructor({ filterSize = 1, fp64: fp642 = false, countItems = false } = {}) {
-    if (!DATA_TYPE_FROM_SIZE[filterSize]) {
-      throw new Error("filterSize out of range");
-    }
-    super({ filterSize, fp64: fp642, countItems });
+  constructor(opts) {
+    super({ ...defaultOptions, ...opts });
   }
   getShaders(extension) {
-    const { filterSize, fp64: fp642 } = extension.opts;
+    const { categorySize, filterSize, fp64: fp642 } = extension.opts;
     return {
       modules: [fp642 ? shaderModule64 : shaderModule],
       defines: {
+        DATACATEGORY_TYPE: DATA_TYPE_FROM_SIZE[categorySize],
+        DATACATEGORY_CHANNELS: categorySize,
         DATAFILTER_TYPE: DATA_TYPE_FROM_SIZE[filterSize],
         DATAFILTER_DOUBLE: Boolean(fp642)
       }
@@ -483,11 +518,12 @@ var _DataFilterExtension = class extends import_core3.LayerExtension {
   }
   initializeState(context, extension) {
     const attributeManager = this.getAttributeManager();
+    const { categorySize, filterSize, fp64: fp642 } = extension.opts;
     if (attributeManager) {
       attributeManager.add({
         filterValues: {
-          size: extension.opts.filterSize,
-          type: extension.opts.fp64 ? import_constants2.GL.DOUBLE : import_constants2.GL.FLOAT,
+          size: filterSize,
+          type: fp642 ? import_constants2.GL.DOUBLE : import_constants2.GL.FLOAT,
           accessor: "getFilterValue",
           shaderAttributes: {
             filterValues: {
@@ -497,6 +533,20 @@ var _DataFilterExtension = class extends import_core3.LayerExtension {
               divisor: 1
             }
           }
+        },
+        filterCategoryValues: {
+          size: categorySize,
+          type: import_constants2.GL.FLOAT,
+          accessor: "getFilterCategory",
+          transform: categorySize === 1 ? (d) => extension._getCategoryKey.call(this, d, 0) : (d) => d.map((x, i) => extension._getCategoryKey.call(this, x, i)),
+          shaderAttributes: {
+            filterCategoryValues: {
+              divisor: 0
+            },
+            instanceFilterCategoryValues: {
+              divisor: 1
+            }
+          }
         }
       });
     }
@@ -528,29 +578,50 @@ var _DataFilterExtension = class extends import_core3.LayerExtension {
       this.setState({ filterFBO, filterModel });
     }
   }
-  updateState({ props, oldProps }) {
+  updateState({ props, oldProps, changeFlags }, extension) {
+    var _a;
+    const attributeManager = this.getAttributeManager();
+    const { categorySize } = extension.opts;
     if (this.state.filterModel) {
-      const attributeManager = this.getAttributeManager();
-      const filterNeedsUpdate = attributeManager.attributes.filterValues.needsUpdate() || props.filterEnabled !== oldProps.filterEnabled || props.filterRange !== oldProps.filterRange || props.filterSoftRange !== oldProps.filterSoftRange;
+      const filterNeedsUpdate = attributeManager.attributes.filterValues.needsUpdate() || ((_a = attributeManager.attributes.filterCategoryValues) == null ? void 0 : _a.needsUpdate()) || props.filterEnabled !== oldProps.filterEnabled || props.filterRange !== oldProps.filterRange || props.filterSoftRange !== oldProps.filterSoftRange || props.filterCategories !== oldProps.filterCategories;
       if (filterNeedsUpdate) {
         this.setState({ filterNeedsUpdate });
       }
     }
+    if (attributeManager == null ? void 0 : attributeManager.attributes.filterCategoryValues) {
+      const categoryBitMaskNeedsUpdate = attributeManager.attributes.filterCategoryValues.needsUpdate() || !(0, import_core3._deepEqual)(props.filterCategories, oldProps.filterCategories, 2);
+      if (categoryBitMaskNeedsUpdate) {
+        this.setState({ categoryBitMaskNeedsUpdate });
+      }
+      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, filterIndices } } = this.getAttributeManager();
+      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);
       filterModel.setAttributes({
         ...filterValues.getValue(),
+        ...filterCategoryValues == null ? void 0 : filterCategoryValues.getValue(),
         ...filterIndices == null ? void 0 : filterIndices.getValue()
       });
+      filterModel.setUniforms(params.uniforms);
       filterModel.device.withParametersWebGL({
         framebuffer: filterFBO,
         ...parameters,
@@ -573,6 +644,34 @@ var _DataFilterExtension = class extends import_core3.LayerExtension {
     filterFBO == null ? void 0 : filterFBO.destroy();
     filterModel == null ? void 0 : filterModel.destroy();
   }
+  _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);
+        } else {
+          import_core3.log.warn(`Exceeded maximum number of categories (${maxCategories})`)();
+        }
+      }
+    }
+    params.uniforms.filter_categoryBitMask = categoryBitMask;
+    this.state.categoryBitMaskNeedsUpdate = false;
+  }
+  _getCategoryKey(category, channel) {
+    const categoryMap = this.state.categoryMap[channel];
+    if (!(category in categoryMap)) {
+      categoryMap[category] = Object.keys(categoryMap).length;
+    }
+    return categoryMap[category];
+  }
 };
 var DataFilterExtension = _DataFilterExtension;
 (() => {