@deck.gl/extensions 8.9.8 → 8.9.10

package/src/terrain/shader-module.ts

@@ -60,6 +60,7 @@ commonPos = geometry.position.xyz;
 if (terrain_mode == TERRAIN_MODE_WRITE_HEIGHT_MAP) {
   vec2 texCoords = (commonPos.xy - terrain_bounds.xy) / terrain_bounds.zw;
   position = vec4(texCoords * 2.0 - 1.0, 0.0, 1.0);
+  commonPos.z += project_uCommonOrigin.z;
 }
 if (terrain_mode == TERRAIN_MODE_USE_HEIGHT_MAP) {
   vec3 anchor = geometry.worldPosition;

package/src/terrain/terrain-cover.ts

@@ -5,11 +5,8 @@ import type {Layer, Viewport} from '@deck.gl/core';
 import {createRenderTarget} from './utils';
 import {joinLayerBounds, makeViewport, getRenderBounds, Bounds} from '../utils/projection-utils';
 
-// TODO - import from loaders when Tileset2D is split out
-type GeoBoundingBox = {west: number; north: number; east: number; south: number};
-type NonGeoBoundingBox = {left: number; top: number; right: number; bottom: number};
-type Tile2DHeader = {
-  bbox: GeoBoundingBox | NonGeoBoundingBox;
+type TileHeader = {
+  boundingBox: [min: number[], max: number[]];
 };
 
 /**
@@ -31,7 +28,7 @@ export class TerrainCover {
   private fbo?: Framebuffer;
   private pickingFbo?: Framebuffer;
   private layers: string[] = [];
-  private tile: Tile2DHeader | null;
+  private tile: TileHeader | null;
   /** Cached version of targetLayer.getBounds() */
   private targetBounds: [number[], number[]] | null = null;
   /** targetBounds in cartesian space */
@@ -111,7 +108,21 @@ export class TerrainCover {
     const targetLayer = this.targetLayer;
     let shouldRedraw = false;
 
-    if (this.targetBounds !== targetLayer.getBounds()) {
+    if (this.tile && 'boundingBox' in this.tile) {
+      if (!this.targetBounds) {
+        shouldRedraw = true;
+        this.targetBounds = this.tile.boundingBox;
+
+        const bottomLeftCommon = viewport.projectPosition(this.targetBounds[0]);
+        const topRightCommon = viewport.projectPosition(this.targetBounds[1]);
+        this.targetBoundsCommon = [
+          bottomLeftCommon[0],
+          bottomLeftCommon[1],
+          topRightCommon[0],
+          topRightCommon[1]
+        ];
+      }
+    } else if (this.targetBounds !== targetLayer.getBounds()) {
       // console.log('bounds changed', this.bounds, '>>', newBounds);
       shouldRedraw = true;
       this.targetBounds = targetLayer.getBounds();
@@ -188,18 +199,18 @@ export class TerrainCover {
  * Remove layers that do not overlap with the current terrain cover.
  * This implementation only has effect when a TileLayer is overlaid on top of a TileLayer
  */
-function getIntersectingLayers(sourceTile: Tile2DHeader, layers: Layer[]): Layer[] {
+function getIntersectingLayers(sourceTile: TileHeader, layers: Layer[]): Layer[] {
   return layers.filter(layer => {
     const tile = getTile(layer);
     if (tile) {
-      return intersect(sourceTile.bbox, tile.bbox);
+      return intersect(sourceTile.boundingBox, tile.boundingBox);
     }
     return true;
   });
 }
 
 /** If layer is the descendent of a TileLayer, return the corresponding tile. */
-function getTile(layer: Layer): Tile2DHeader | null {
+function getTile(layer: Layer): TileHeader | null {
   while (layer) {
     // @ts-expect-error tile may not exist
     const {tile} = layer.props;
@@ -211,15 +222,9 @@ function getTile(layer: Layer): Tile2DHeader | null {
   return null;
 }
 
-function intersect(
-  b1: GeoBoundingBox | NonGeoBoundingBox,
-  b2: GeoBoundingBox | NonGeoBoundingBox
-): boolean {
-  if ('west' in b1 && 'west' in b2) {
-    return b1.west < b2.east && b2.west < b1.east && b1.south < b2.north && b2.south < b1.north;
-  }
-  if ('left' in b1 && 'left' in b2) {
-    return b1.left < b2.right && b2.left < b1.right && b1.top < b2.bottom && b2.top < b1.bottom;
+function intersect(b1?: [number[], number[]], b2?: [number[], number[]]): boolean {
+  if (b1 && b2) {
+    return b1[0][0] < b2[1][0] && b2[0][0] < b1[1][0] && b1[0][1] < b2[1][1] && b2[0][1] < b1[1][1];
   }
   return false;
 }

package/src/utils/projection-utils.ts

@@ -90,6 +90,7 @@ export function makeViewport(opts: {
   // Geospatial viewports may not be web-mercator
   return isGeospatial
     ? new WebMercatorViewport({
+        id: viewport.id,
         x: border,
         y: border,
         width,
@@ -100,6 +101,7 @@ export function makeViewport(opts: {
         orthographic: true
       })
     : new OrthographicViewport({
+        id: viewport.id,
         x: border,
         y: border,
         width,

package/typed/brushing/brushing.js

@@ -0,0 +1,83 @@
+// 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 { LayerExtension } from '@deck.gl/core';
+import shaderModule from './shader-module';
+const defaultProps = {
+    getBrushingTarget: { type: 'accessor', value: [0, 0] },
+    brushingTarget: 'source',
+    brushingEnabled: true,
+    brushingRadius: 10000
+};
+export default class BrushingExtension extends LayerExtension {
+    getShaders(extension) {
+        return {
+            modules: [shaderModule]
+        };
+    }
+    initializeState(context, extension) {
+        const attributeManager = this.getAttributeManager();
+        if (attributeManager) {
+            attributeManager.add({
+                brushingTargets: {
+                    size: 2,
+                    accessor: 'getBrushingTarget',
+                    // Hack: extension's defaultProps is not merged with the layer's defaultProps,
+                    // So we can't use the standard accessor when the prop is undefined
+                    update: !this.props.getBrushingTarget && extension.useConstantTargetPositions,
+                    shaderAttributes: {
+                        brushingTargets: {
+                            divisor: 0
+                        },
+                        instanceBrushingTargets: {
+                            divisor: 1
+                        }
+                    }
+                }
+            });
+        }
+        // Trigger redraw when mouse moves
+        // TODO - expose this in a better way
+        extension.onMouseMove = () => {
+            this.getCurrentLayer().setNeedsRedraw();
+        };
+        if (this.context.deck) {
+            this.context.deck.eventManager.on({
+                pointermove: extension.onMouseMove,
+                pointerleave: extension.onMouseMove
+            });
+        }
+    }
+    finalizeState(extension) {
+        // Remove event listeners
+        if (this.context.deck) {
+            this.context.deck.eventManager.off({
+                pointermove: extension.onMouseMove,
+                pointerleave: extension.onMouseMove
+            });
+        }
+    }
+    useConstantTargetPositions(attribute) {
+        attribute.constant = true;
+        attribute.value = new Float32Array(2);
+        return;
+    }
+}
+BrushingExtension.extensionName = 'BrushingExtension';
+BrushingExtension.defaultProps = defaultProps;

package/typed/brushing/shader-module.js

@@ -0,0 +1,116 @@
+// 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 { project } from '@deck.gl/core';
+const vs = `
+  uniform bool brushing_enabled;
+  uniform int brushing_target;
+  uniform vec2 brushing_mousePos;
+  uniform float brushing_radius;
+
+  #ifdef NON_INSTANCED_MODEL
+  attribute vec2 brushingTargets;
+  #else
+  attribute vec2 instanceBrushingTargets;
+  #endif
+
+  varying float brushing_isVisible;
+
+  bool brushing_isPointInRange(vec2 position) {
+    if (!brushing_enabled) {
+      return true;
+    }
+    vec2 source_commonspace = project_position(position);
+    vec2 target_commonspace = project_position(brushing_mousePos);
+    float distance = length((target_commonspace - source_commonspace) / project_uCommonUnitsPerMeter.xy);
+
+    return distance <= brushing_radius;
+  }
+
+  bool brushing_arePointsInRange(vec2 sourcePos, vec2 targetPos) {
+    return brushing_isPointInRange(sourcePos) || brushing_isPointInRange(targetPos);
+  }
+
+  void brushing_setVisible(bool visible) {
+    brushing_isVisible = float(visible);
+  }
+`;
+const fs = `
+  uniform bool brushing_enabled;
+  varying float brushing_isVisible;
+`;
+const TARGET = {
+    source: 0,
+    target: 1,
+    custom: 2,
+    source_target: 3
+};
+const inject = {
+    'vs:DECKGL_FILTER_GL_POSITION': `
+    vec2 brushingTarget;
+    vec2 brushingSource;
+    if (brushing_target == 3) {
+      brushingTarget = geometry.worldPositionAlt.xy;
+      brushingSource = geometry.worldPosition.xy;
+    } else if (brushing_target == 0) {
+      brushingTarget = geometry.worldPosition.xy;
+    } else if (brushing_target == 1) {
+      brushingTarget = geometry.worldPositionAlt.xy;
+    } else {
+      #ifdef NON_INSTANCED_MODEL
+      brushingTarget = brushingTargets;
+      #else
+      brushingTarget = instanceBrushingTargets;
+      #endif
+    }
+    bool visible;
+    if (brushing_target == 3) {
+      visible = brushing_arePointsInRange(brushingSource, brushingTarget);
+    } else {
+      visible = brushing_isPointInRange(brushingTarget);
+    }
+    brushing_setVisible(visible);
+  `,
+    'fs:DECKGL_FILTER_COLOR': `
+    if (brushing_enabled && brushing_isVisible < 0.5) {
+      discard;
+    }
+  `
+};
+export default {
+    name: 'brushing',
+    dependencies: [project],
+    vs,
+    fs,
+    inject,
+    getUniforms: opts => {
+        if (!opts || !opts.viewport) {
+            return {};
+        }
+        const { brushingEnabled = true, brushingRadius = 10000, brushingTarget = 'source', mousePosition, viewport } = opts;
+        return {
+            brushing_enabled: Boolean(brushingEnabled && mousePosition && viewport.containsPixel(mousePosition)),
+            brushing_radius: brushingRadius,
+            brushing_target: TARGET[brushingTarget] || 0,
+            brushing_mousePos: mousePosition
+                ? viewport.unproject([mousePosition.x - viewport.x, mousePosition.y - viewport.y])
+                : [0, 0]
+        };
+    }
+};

package/typed/clip/clip.js

@@ -0,0 +1,114 @@
+// 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 { LayerExtension } from '@deck.gl/core';
+const defaultProps = {
+    clipBounds: [0, 0, 1, 1]
+};
+const shaderFunction = `
+uniform vec4 clip_bounds;
+
+bool clip_isInBounds(vec2 position) {
+  return position.x >= clip_bounds[0] && position.y >= clip_bounds[1] && position.x < clip_bounds[2] && position.y < clip_bounds[3];
+}
+`;
+/*
+ * The vertex-shader version clips geometries by their anchor position
+ * e.g. ScatterplotLayer - show if the center of a circle is within bounds
+ */
+const shaderModuleVs = {
+    name: 'clip-vs',
+    vs: shaderFunction
+};
+const injectionVs = {
+    'vs:#decl': `
+varying float clip_isVisible;
+`,
+    'vs:DECKGL_FILTER_GL_POSITION': `
+  clip_isVisible = float(clip_isInBounds(geometry.worldPosition.xy));
+`,
+    'fs:#decl': `
+varying float clip_isVisible;
+`,
+    'fs:DECKGL_FILTER_COLOR': `
+  if (clip_isVisible < 0.5) discard;
+`
+};
+/*
+ * The fragment-shader version clips pixels at the bounds
+ * e.g. PolygonLayer - show the part of the polygon that intersect with the bounds
+ */
+const shaderModuleFs = {
+    name: 'clip-fs',
+    fs: shaderFunction
+};
+const injectionFs = {
+    'vs:#decl': `
+varying vec2 clip_commonPosition;
+`,
+    'vs:DECKGL_FILTER_GL_POSITION': `
+  clip_commonPosition = geometry.position.xy;
+`,
+    'fs:#decl': `
+varying vec2 clip_commonPosition;
+`,
+    'fs:DECKGL_FILTER_COLOR': `
+  if (!clip_isInBounds(clip_commonPosition)) discard;
+`
+};
+export default class ClipExtension extends LayerExtension {
+    getShaders() {
+        // If `clipByInstance: true`, the entire object is shown/hidden based on its anchor position (done by vertex shader)
+        // Otherwise, the object is trimmed by the clip bounds (done by fragment shader)
+        // Default behavior: consider a layer instanced if it has attribute `instancePositions`
+        let clipByInstance = 'instancePositions' in this.getAttributeManager().attributes;
+        // Users can override by setting the `clipByInstance` prop
+        if ('clipByInstance' in this.props) {
+            clipByInstance = this.props.clipByInstance;
+        }
+        this.state.clipByInstance = clipByInstance;
+        return clipByInstance
+            ? {
+                modules: [shaderModuleVs],
+                inject: injectionVs
+            }
+            : {
+                modules: [shaderModuleFs],
+                inject: injectionFs
+            };
+    }
+    draw({ uniforms }) {
+        const { clipBounds = defaultProps.clipBounds } = this.props;
+        if (this.state.clipByInstance) {
+            uniforms.clip_bounds = clipBounds;
+        }
+        else {
+            const corner0 = this.projectPosition([clipBounds[0], clipBounds[1], 0]);
+            const corner1 = this.projectPosition([clipBounds[2], clipBounds[3], 0]);
+            uniforms.clip_bounds = [
+                Math.min(corner0[0], corner1[0]),
+                Math.min(corner0[1], corner1[1]),
+                Math.max(corner0[0], corner1[0]),
+                Math.max(corner0[1], corner1[1])
+            ];
+        }
+    }
+}
+ClipExtension.extensionName = 'ClipExtension';
+ClipExtension.defaultProps = defaultProps;

package/typed/collide/collide-effect.d.ts

@@ -10,7 +10,7 @@ export default class CollideEffect implements Effect {
     private collideFBOs;
     private dummyCollideMap?;
     private lastViewport?;
-    preRender(gl: WebGLRenderingContext, { effects: allEffects, layers, layerFilter, viewports, onViewportActive, views, pass, preRenderStats }: PreRenderOptions): void;
+    preRender(gl: WebGLRenderingContext, { effects: allEffects, layers, layerFilter, viewports, onViewportActive, views, isPicking, preRenderStats }: PreRenderOptions): void;
     private _render;
     /**
      * Group layers by collideGroup

package/typed/collide/collide-effect.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"collide-effect.d.ts","sourceRoot":"","sources":["../../src/collide/collide-effect.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,WAAW,EAAgB,SAAS,EAAmB,MAAM,eAAe,CAAC;AAGrF,OAAO,KAAK,EAAC,MAAM,EAAE,KAAK,EAAE,gBAAgB,EAAW,MAAM,eAAe,CAAC;AAoB7E,MAAM,CAAC,OAAO,OAAO,aAAc,YAAW,MAAM;IAClD,EAAE,SAAoB;IACtB,KAAK,OAAQ;IACb,YAAY,UAAQ;IACpB,KAAK,SAAK;IAEV,OAAO,CAAC,QAAQ,CAAkC;IAClD,OAAO,CAAC,WAAW,CAAC,CAAc;IAClC,OAAO,CAAC,WAAW,CAAmC;IACtD,OAAO,CAAC,eAAe,CAAC,CAAY;IACpC,OAAO,CAAC,YAAY,CAAC,CAAW;IAEhC,SAAS,CACP,EAAE,EAAE,qBAAqB,EACzB,EACE,OAAO,EAAE,UAAU,EACnB,MAAM,EACN,WAAW,EACX,SAAS,EACT,gBAAgB,EAChB,KAAK,EACL,IAAI,EACJ,cAAmB,EACpB,EAAE,gBAAgB,GAClB,IAAI;IAuDP,OAAO,CAAC,OAAO;IAyDf;;;OAGG;IACH,OAAO,CAAC,oBAAoB;IAsC5B,mBAAmB,CAAC,KAAK,EAAE,KAAK,GAAG;QACjC,UAAU,EAAE,WAAW,CAAC;QACxB,eAAe,EAAE,SAAS,CAAC;KAC5B;IAMD,OAAO,IAAI,IAAI;IAaf,SAAS,CAAC,EAAE,EAAE,qBAAqB,EAAE,YAAY,EAAE,MAAM;IAyBzD,UAAU,CAAC,YAAY,EAAE,MAAM;CAQhC"}
+{"version":3,"file":"collide-effect.d.ts","sourceRoot":"","sources":["../../src/collide/collide-effect.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,WAAW,EAAgB,SAAS,EAAmB,MAAM,eAAe,CAAC;AAGrF,OAAO,KAAK,EAAC,MAAM,EAAE,KAAK,EAAE,gBAAgB,EAAW,MAAM,eAAe,CAAC;AAoB7E,MAAM,CAAC,OAAO,OAAO,aAAc,YAAW,MAAM;IAClD,EAAE,SAAoB;IACtB,KAAK,OAAQ;IACb,YAAY,UAAQ;IACpB,KAAK,SAAK;IAEV,OAAO,CAAC,QAAQ,CAAkC;IAClD,OAAO,CAAC,WAAW,CAAC,CAAc;IAClC,OAAO,CAAC,WAAW,CAAmC;IACtD,OAAO,CAAC,eAAe,CAAC,CAAY;IACpC,OAAO,CAAC,YAAY,CAAC,CAAW;IAEhC,SAAS,CACP,EAAE,EAAE,qBAAqB,EACzB,EACE,OAAO,EAAE,UAAU,EACnB,MAAM,EACN,WAAW,EACX,SAAS,EACT,gBAAgB,EAChB,KAAK,EACL,SAAS,EACT,cAAmB,EACpB,EAAE,gBAAgB,GAClB,IAAI;IAuDP,OAAO,CAAC,OAAO;IA0Df;;;OAGG;IACH,OAAO,CAAC,oBAAoB;IAsC5B,mBAAmB,CAAC,KAAK,EAAE,KAAK,GAAG;QACjC,UAAU,EAAE,WAAW,CAAC;QACxB,eAAe,EAAE,SAAS,CAAC;KAC5B;IAMD,OAAO,IAAI,IAAI;IAaf,SAAS,CAAC,EAAE,EAAE,qBAAqB,EAAE,YAAY,EAAE,MAAM;IAyBzD,UAAU,CAAC,YAAY,EAAE,MAAM;CAQhC"}

package/typed/collide/collide-pass.d.ts

@@ -3,7 +3,6 @@ import { _LayersPass as LayersPass, LayersPassRenderOptions } from '@deck.gl/cor
 declare type CollidePassRenderOptions = LayersPassRenderOptions & {};
 export default class CollidePass extends LayersPass {
     renderCollideMap(target: Framebuffer, options: CollidePassRenderOptions): any;
-    shouldDrawLayer(layer: any): any;
     getModuleParameters(): {
         drawToCollideMap: boolean;
         pickingActive: number;

package/typed/collide/collide-pass.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"collide-pass.d.ts","sourceRoot":"","sources":["../../src/collide/collide-pass.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,WAAW,EAAiB,MAAM,eAAe,CAAC;AAC1D,OAAO,EAAC,WAAW,IAAI,UAAU,EAAE,uBAAuB,EAAC,MAAM,eAAe,CAAC;AAEjF,aAAK,wBAAwB,GAAG,uBAAuB,GAAG,EAAE,CAAC;AAE7D,MAAM,CAAC,OAAO,OAAO,WAAY,SAAQ,UAAU;IACjD,gBAAgB,CAAC,MAAM,EAAE,WAAW,EAAE,OAAO,EAAE,wBAAwB;IAqBvE,eAAe,CAAC,KAAK,KAAA;IAQrB,mBAAmB;;;;;;CASpB"}
+{"version":3,"file":"collide-pass.d.ts","sourceRoot":"","sources":["../../src/collide/collide-pass.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,WAAW,EAAiB,MAAM,eAAe,CAAC;AAC1D,OAAO,EAAC,WAAW,IAAI,UAAU,EAAE,uBAAuB,EAAC,MAAM,eAAe,CAAC;AAEjF,aAAK,wBAAwB,GAAG,uBAAuB,GAAG,EAAE,CAAC;AAE7D,MAAM,CAAC,OAAO,OAAO,WAAY,SAAQ,UAAU;IACjD,gBAAgB,CAAC,MAAM,EAAE,WAAW,EAAE,OAAO,EAAE,wBAAwB;IAmBvE,mBAAmB;;;;;;CASpB"}

package/typed/collide/collide.d.ts

@@ -33,7 +33,6 @@ export default class CollideExtension extends LayerExtension {
         collideTestProps: {};
     };
     static extensionName: string;
-    isEnabled(layer: Layer<CollideExtensionProps>): boolean;
     getShaders(this: Layer<CollideExtensionProps>): any;
     draw(this: Layer<CollideExtensionProps>, { uniforms, context, moduleParameters }: any): void;
     initializeState(this: Layer<CollideExtensionProps>, context: LayerContext, extension: this): void;

package/typed/collide/collide.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"collide.d.ts","sourceRoot":"","sources":["../../src/collide/collide.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,QAAQ,EAAE,KAAK,EAAE,YAAY,EAAE,cAAc,EAAC,MAAM,eAAe,CAAC;AAW5E,oBAAY,qBAAqB,CAAC,KAAK,GAAG,GAAG,IAAI;IAC/C;;OAEG;IACH,kBAAkB,CAAC,EAAE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;IAE7C;;;OAGG;IACH,cAAc,EAAE,OAAO,CAAC;IAExB;;OAEG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IAEtB;;OAEG;IACH,gBAAgB,CAAC,EAAE,EAAE,CAAC;CACvB,CAAC;AAEF,iDAAiD;AACjD,MAAM,CAAC,OAAO,OAAO,gBAAiB,SAAQ,cAAc;IAC1D,MAAM,CAAC,YAAY;;;;;;;;;;;MAAgB;IACnC,MAAM,CAAC,aAAa,SAAsB;IAE1C,SAAS,CAAC,KAAK,EAAE,KAAK,CAAC,qBAAqB,CAAC,GAAG,OAAO;IAIvD,UAAU,CAAC,IAAI,EAAE,KAAK,CAAC,qBAAqB,CAAC,GAAG,GAAG;IAKnD,IAAI,CAAC,IAAI,EAAE,KAAK,CAAC,qBAAqB,CAAC,EAAE,EAAC,QAAQ,EAAE,OAAO,EAAE,gBAAgB,EAAC,EAAE,GAAG;IAanF,eAAe,CAAC,IAAI,EAAE,KAAK,CAAC,qBAAqB,CAAC,EAAE,OAAO,EAAE,YAAY,EAAE,SAAS,EAAE,IAAI;IAkB1F,qBAAqB,CAAC,IAAI,EAAE,KAAK,CAAC,qBAAqB,CAAC,GAAG,OAAO;CAGnE"}
+{"version":3,"file":"collide.d.ts","sourceRoot":"","sources":["../../src/collide/collide.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,QAAQ,EAAE,KAAK,EAAE,YAAY,EAAE,cAAc,EAAC,MAAM,eAAe,CAAC;AAW5E,oBAAY,qBAAqB,CAAC,KAAK,GAAG,GAAG,IAAI;IAC/C;;OAEG;IACH,kBAAkB,CAAC,EAAE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;IAE7C;;;OAGG;IACH,cAAc,EAAE,OAAO,CAAC;IAExB;;OAEG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IAEtB;;OAEG;IACH,gBAAgB,CAAC,EAAE,EAAE,CAAC;CACvB,CAAC;AAEF,iDAAiD;AACjD,MAAM,CAAC,OAAO,OAAO,gBAAiB,SAAQ,cAAc;IAC1D,MAAM,CAAC,YAAY;;;;;;;;;;;MAAgB;IACnC,MAAM,CAAC,aAAa,SAAsB;IAE1C,UAAU,CAAC,IAAI,EAAE,KAAK,CAAC,qBAAqB,CAAC,GAAG,GAAG;IAKnD,IAAI,CAAC,IAAI,EAAE,KAAK,CAAC,qBAAqB,CAAC,EAAE,EAAC,QAAQ,EAAE,OAAO,EAAE,gBAAgB,EAAC,EAAE,GAAG;IAanF,eAAe,CAAC,IAAI,EAAE,KAAK,CAAC,qBAAqB,CAAC,EAAE,OAAO,EAAE,YAAY,EAAE,SAAS,EAAE,IAAI;IAkB1F,qBAAqB,CAAC,IAAI,EAAE,KAAK,CAAC,qBAAqB,CAAC,GAAG,OAAO;CAGnE"}

package/typed/collide/shader-module.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader-module.d.ts","sourceRoot":"","sources":["../../src/collide/shader-module.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAC,aAAa,IAAI,YAAY,EAAC,MAAM,eAAe,CAAC;;AAuGjE,wBAMkB"}
+{"version":3,"file":"shader-module.d.ts","sourceRoot":"","sources":["../../src/collide/shader-module.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAC,aAAa,IAAI,YAAY,EAAC,MAAM,eAAe,CAAC;;AAwGjE,wBAMkB"}

package/typed/data-filter/aggregator.js

@@ -0,0 +1,98 @@
+import { Model, Texture2D, Framebuffer, isWebGL2 } from '@luma.gl/core';
+import GL from '@luma.gl/constants';
+const AGGREGATE_VS = `\
+#define SHADER_NAME data-filter-vertex-shader
+
+#ifdef FLOAT_TARGET
+  attribute float filterIndices;
+  attribute float filterPrevIndices;
+#else
+  attribute vec2 filterIndices;
+  attribute vec2 filterPrevIndices;
+#endif
+
+varying 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 = `\
+#define SHADER_NAME data-filter-fragment-shader
+precision highp float;
+
+varying vec4 vColor;
+
+void main() {
+  if (dataFilter_value < 0.5) {
+    discard;
+  }
+  gl_FragColor = vColor;
+}
+`;
+export function supportsFloatTarget(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 (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(gl, useFloatTarget) {
+    if (useFloatTarget) {
+        return new Framebuffer(gl, {
+            width: 1,
+            height: 1,
+            attachments: {
+                [GL.COLOR_ATTACHMENT0]: new Texture2D(gl, {
+                    format: isWebGL2(gl) ? GL.RGBA32F : GL.RGBA,
+                    type: GL.FLOAT,
+                    mipmaps: false
+                })
+            }
+        });
+    }
+    return new Framebuffer(gl, {
+        width: 256,
+        height: 64,
+        depth: false
+    });
+}
+// Increments the counter based on dataFilter_value
+export function getModel(gl, shaderOptions, useFloatTarget) {
+    shaderOptions.defines.NON_INSTANCED_MODEL = 1;
+    if (useFloatTarget) {
+        shaderOptions.defines.FLOAT_TARGET = 1;
+    }
+    return new Model(gl, {
+        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
+};