@deck.gl/extensions 9.0.5 → 9.0.7

package/src/data-filter/shader-module.ts

@@ -5,34 +5,80 @@ import {glsl} from '../utils/syntax-tags';
 /*
  * data filter shader module
  */
+export type Defines = {
+  // Defines passed externally
+  /**
+   * Primitive type of parameter used for category filtering. If undefined, category filtering disabled.
+   */
+  DATACATEGORY_TYPE?: 'float' | 'vec2' | 'vec3' | 'vec4';
+  /**
+   * Number of category filtering channels. Must match dimension of `DATACATEGORY_TYPE`
+   */
+  DATACATEGORY_CHANNELS?: 1 | 2 | 3 | 4;
+
+  /**
+   * Primitive type of parameter used for numeric filtering. If undefined, numeric filtering disabled.
+   */
+  DATAFILTER_TYPE?: 'float' | 'vec2' | 'vec3' | 'vec4';
+
+  /**
+   * Enable 64-bit precision in numeric filter.
+   */
+  DATAFILTER_DOUBLE?: boolean;
+
+  // Defines derived in shader
+  /**
+   * Numeric filter attribute
+   */
+  DATAFILTER_ATTRIB?: 'filterValues' | 'instanceFilterValues';
+  /**
+   * Numeric filter attribute (low bits). Only used when `DATAFILTER_DOUBLE = true`
+   */
+  DATAFILTER_ATTRIB_64LOW?: 'filterValues64Low' | 'instanceFilterValues64Low';
+  /**
+   * Category filter attribute
+   */
+  DATACATEGORY_ATTRIB?: 'filterCategoryValues' | 'instanceFilterCategoryValues';
+};
+
 const vs = 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
+#ifdef DATAFILTER_TYPE
+  uniform DATAFILTER_TYPE filter_min;
+  uniform DATAFILTER_TYPE filter_softMin;
+  uniform DATAFILTER_TYPE filter_softMax;
+  uniform DATAFILTER_TYPE filter_max;
+
+  #ifdef NON_INSTANCED_MODEL
+    #define DATAFILTER_ATTRIB filterValues
+    #define DATAFILTER_ATTRIB_64LOW filterValues64Low
+  #else
+    #define DATAFILTER_ATTRIB instanceFilterValues
+    #define DATAFILTER_ATTRIB_64LOW instanceFilterValues64Low
+  #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
 #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;
+#ifdef DATACATEGORY_TYPE
+  #ifdef NON_INSTANCED_MODEL
+    #define DATACATEGORY_ATTRIB filterCategoryValues
+  #else
+    #define DATACATEGORY_ATTRIB instanceFilterCategoryValues
+  #endif
+  in DATACATEGORY_TYPE DATACATEGORY_ATTRIB;
 #endif
-in DATACATEGORY_TYPE DATACATEGORY_ATTRIB;
 
 out float dataFilter_value;
 
@@ -48,30 +94,35 @@ 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, DATACATEGORY_TYPE category) {
-  if (filter_enabled) {
+
+#ifdef DATAFILTER_ATTRIB
+  void dataFilter_setValue(DATAFILTER_TYPE valueFromMin, DATAFILTER_TYPE valueFromMax) {
     if (filter_useSoftMargin) {
       dataFilter_value = dataFilter_reduceValue(
         smoothstep(filter_min, filter_softMin, valueFromMin) *
-        (1.0 - smoothstep(filter_softMax, filter_max, valueFromMax))
+          (1.0 - smoothstep(filter_softMax, filter_max, valueFromMax))
       );
     } else {
       dataFilter_value = dataFilter_reduceValue(
         step(filter_min, valueFromMin) * step(valueFromMax, filter_max)
       );
     }
+  }
+#endif
 
+#ifdef DATACATEGORY_ATTRIB
+  void dataFilter_setCategoryValue(DATACATEGORY_TYPE category) {
     #if DATACATEGORY_CHANNELS == 1 // One 128-bit mask
-      int dataFilter_masks = filter_categoryBitMask[int(category / 32.0)];
+    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]
-      );
+    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;
+    ivec3 dataFilter_masks = filter_categoryBitMask.xyz;
     #else // Four 32-bit masks
-      ivec4 dataFilter_masks = filter_categoryBitMask;
+    ivec4 dataFilter_masks = filter_categoryBitMask;
     #endif
 
     // Shift mask and extract relevant bits
@@ -79,14 +130,12 @@ void dataFilter_setValue(DATAFILTER_TYPE valueFromMin, DATAFILTER_TYPE valueFrom
     dataFilter_bits = mod(floor(dataFilter_bits), 2.0);
 
     #if DATACATEGORY_CHANNELS == 1
-      if(dataFilter_bits == 0.0) dataFilter_value = 0.0;
+    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;
   }
-}
+#endif
 `;
 
 const fs = glsl`
@@ -163,15 +212,23 @@ function getUniforms64(opts?: DataFilterModuleSettings | {}): Record<string, any
 
 const inject = {
   '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
+    dataFilter_value = 1.0;
+    if (filter_enabled) {
+      #ifdef DATAFILTER_ATTRIB
+        #ifdef DATAFILTER_DOUBLE
+          dataFilter_setValue(
+            DATAFILTER_ATTRIB - filter_min64High + DATAFILTER_ATTRIB_64LOW,
+            DATAFILTER_ATTRIB - filter_max64High + DATAFILTER_ATTRIB_64LOW
+          );
+        #else
+          dataFilter_setValue(DATAFILTER_ATTRIB, DATAFILTER_ATTRIB);
+        #endif
+      #endif
+
+      #ifdef DATACATEGORY_ATTRIB
+        dataFilter_setCategoryValue(DATACATEGORY_ATTRIB);
+      #endif
+    }
   `,
 
   'vs:#main-end': glsl`

package/src/terrain/terrain-cover.ts

@@ -174,7 +174,8 @@ export class TerrainCover {
     }
     if (!this.pickingFbo) {
       this.pickingFbo = createRenderTarget(this.targetLayer.context.device, {
-        id: `${this.id}-picking`
+        id: `${this.id}-picking`,
+        interpolate: false
       });
     }
     return this.pickingFbo;

package/src/terrain/utils.ts

@@ -6,6 +6,7 @@ export function createRenderTarget(
   opts: {
     id: string;
     float?: boolean;
+    interpolate?: boolean;
   }
 ) {
   return device.createFramebuffer({
@@ -18,12 +19,16 @@ export function createRenderTarget(
           type: GL.FLOAT
         }),
         mipmaps: false,
-        sampler: {
-          minFilter: 'linear',
-          magFilter: 'linear',
-          addressModeU: 'clamp-to-edge',
-          addressModeV: 'clamp-to-edge'
-        }
+        sampler:
+          opts.interpolate === false
+            ? {
+                minFilter: 'nearest',
+                magFilter: 'nearest'
+              }
+            : {
+                minFilter: 'linear',
+                magFilter: 'linear'
+              }
       })
     ]
   });