@deck.gl/extensions 9.0.0-alpha.7 → 9.0.0-beta.10

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

@@ -1,10 +1,11 @@
 import type {ShaderModule} from '@luma.gl/shadertools';
 import type {DataFilterExtensionProps} from './data-filter-extension';
+import {glsl} from '../utils/syntax-tags';
 
 /*
  * data filter shader module
  */
-const vs = `
+const vs = glsl`
 uniform DATAFILTER_TYPE filter_min;
 uniform DATAFILTER_TYPE filter_softMin;
 uniform DATAFILTER_TYPE filter_softMax;
@@ -12,13 +13,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;
@@ -28,6 +32,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;
 
@@ -43,7 +48,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(
@@ -55,13 +60,36 @@ 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;
   }
 }
 `;
 
-const fs = `
+const fs = glsl`
 uniform bool filter_transformColor;
 in float dataFilter_value;
 `;
@@ -134,30 +162,31 @@ function getUniforms64(opts?: DataFilterModuleSettings | {}): Record<string, any
 }
 
 const inject = {
-  'vs:#main-start': `
+  'vs:#main-start': glsl`
     #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': `
+  'vs:#main-end': glsl`
     if (dataFilter_value == 0.0) {
       gl_Position = vec4(0.);
     }
   `,
 
-  'vs:DECKGL_FILTER_SIZE': `
+  'vs:DECKGL_FILTER_SIZE': glsl`
     if (filter_transformSize) {
       size = size * dataFilter_value;
     }
   `,
 
-  'fs:DECKGL_FILTER_COLOR': `
+  'fs:DECKGL_FILTER_COLOR': glsl`
     if (dataFilter_value == 0.0) discard;
     if (filter_transformColor) {
       color.a *= dataFilter_value;

package/src/fill-style/fill-style-extension.ts

@@ -1,10 +1,11 @@
 import {LayerExtension} from '@deck.gl/core';
 
-import {patternShaders} from './shaders.glsl';
+import {patternShaders} from './shader-module';
 
 import type {
   Layer,
   LayerContext,
+  DefaultProps,
   Accessor,
   AccessorFunction,
   TextureSource,
@@ -12,15 +13,13 @@ import type {
 } from '@deck.gl/core';
 import type {Texture} from '@luma.gl/core';
 
-const defaultProps = {
+const defaultProps: DefaultProps<FillStyleExtensionProps> = {
   fillPatternEnabled: true,
   fillPatternAtlas: {
     type: 'image',
     value: null,
     async: true,
-    parameters: {
-      minFilter: 'linear'
-    }
+    parameters: {lodMaxClamp: 0}
   },
   fillPatternMapping: {type: 'object', value: {}, async: true},
   fillPatternMask: true,

package/src/fill-style/{shaders.glsl.ts → shader-module.ts}

@@ -3,11 +3,12 @@ import {project, fp64LowPart} from '@deck.gl/core';
 import type {Viewport, ProjectUniforms} from '@deck.gl/core';
 
 import type {Texture} from '@luma.gl/core';
+import {glsl} from '../utils/syntax-tags';
 
 /*
  * fill pattern shader module
  */
-const patternVs = `
+const patternVs = glsl`
 #ifdef NON_INSTANCED_MODEL
   #define FILL_PATTERN_FRAME_ATTRIB fillPatternFrames
   #define FILL_PATTERN_SCALE_ATTRIB fillPatternScales
@@ -30,7 +31,7 @@ out vec4 fill_patternBounds;
 out vec4 fill_patternPlacement;
 `;
 
-const patternFs = `
+const patternFs = glsl`
 uniform bool fill_patternEnabled;
 uniform bool fill_patternMask;
 uniform sampler2D fill_patternTexture;
@@ -45,11 +46,11 @@ const float FILL_UV_SCALE = 512.0 / 40000000.0;
 `;
 
 const inject = {
-  '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;
@@ -57,7 +58,7 @@ const inject = {
     }
   `,
 
-  '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;

package/src/mask/mask-effect.ts

@@ -1,6 +1,5 @@
 import {Layer, Viewport, Effect, PreRenderOptions, CoordinateSystem, log} from '@deck.gl/core';
 import type {Device, Texture} from '@luma.gl/core';
-// import {readPixelsToArray} from '@luma.gl/webgl-legacy';
 import {equals} from '@math.gl/core';
 import MaskPass from './mask-pass';
 import {joinLayerBounds, getRenderBounds, makeViewport, Bounds} from '../utils/projection-utils';

package/src/mask/mask-pass.ts

@@ -1,5 +1,4 @@
 import type {Device, Framebuffer, Texture} from '@luma.gl/core';
-import {withGLParameters} from '@luma.gl/webgl';
 import {GL} from '@luma.gl/constants';
 import {_LayersPass as LayersPass, LayersPassRenderOptions} from '@deck.gl/core';
 
@@ -42,8 +41,7 @@ export default class MaskPass extends LayersPass {
     colorMask[options.channel] = true;
     const clearColor = [255, 255, 255, 255];
 
-    return withGLParameters(
-      this.device,
+    return this.device.withParametersWebGL(
       {
         blend: true,
         blendFunc: [GL.ZERO, GL.ONE],

package/src/mask/shader-module.ts

@@ -1,8 +1,9 @@
 import type {ShaderModule} from '@luma.gl/shadertools';
 import {project} from '@deck.gl/core';
 import type {Texture} from '@luma.gl/core';
+import {glsl} from '../utils/syntax-tags';
 
-const vs = `
+const vs = glsl`
 uniform vec4 mask_bounds;
 uniform bool mask_maskByInstance;
 vec2 mask_getCoords(vec4 position) {
@@ -10,7 +11,7 @@ vec2 mask_getCoords(vec4 position) {
 }
 `;
 
-const fs = `
+const fs = glsl`
 uniform sampler2D mask_texture;
 uniform int mask_channel;
 uniform bool mask_enabled;
@@ -40,10 +41,10 @@ bool mask_isInBounds(vec2 texCoords) {
 `;
 
 const inject = {
-  '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));
@@ -52,10 +53,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);
 

package/src/terrain/shader-module.ts

@@ -6,10 +6,11 @@ import {project} from '@deck.gl/core';
 import type {Texture} from '@luma.gl/core';
 import type {Bounds} from '../utils/projection-utils';
 import type {TerrainCover} from './terrain-cover';
+import {glsl} from '../utils/syntax-tags';
 
 /** Module parameters expected by the terrain shader module */
 export type TerrainModuleSettings = {
-  pickingActive?: boolean;
+  picking: {isActive?: boolean};
   heightMap: Texture | null;
   heightMapBounds?: Bounds | null;
   dummyHeightMap: Texture;
@@ -43,20 +44,20 @@ export const terrainModule = {
   name: 'terrain',
   dependencies: [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;
@@ -75,20 +76,20 @@ 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);
@@ -118,7 +119,7 @@ if ((terrain_mode == TERRAIN_MODE_USE_COVER) || (terrain_mode == TERRAIN_MODE_US
 
       let mode: number = terrainSkipRender ? TERRAIN_MODE.SKIP : TERRAIN_MODE.NONE;
       // height map if case USE_HEIGHT_MAP, terrain cover if USE_COVER, otherwise empty
-      let sampler = dummyHeightMap as Texture;
+      let sampler: Texture | undefined = dummyHeightMap as Texture;
       // height map bounds if case USE_HEIGHT_MAP, terrain cover bounds if USE_COVER, otherwise null
       let bounds: number[] | null = null;
       if (drawToTerrainHeightMap) {
@@ -130,11 +131,11 @@ if ((terrain_mode == TERRAIN_MODE_USE_COVER) || (terrain_mode == TERRAIN_MODE_US
         bounds = heightMapBounds!;
       } else if (terrainCover) {
         // This is a terrain layer
-        const isPicking = opts.pickingActive;
-        // @ts-expect-error
-        sampler = isPicking
+        const isPicking = opts.picking?.isActive;
+        const fbo = isPicking
           ? terrainCover.getPickingFramebuffer()
           : terrainCover.getRenderFramebuffer();
+        sampler = fbo?.colorAttachments[0].texture;
         if (isPicking) {
           // Never render the layer itself in picking pass
           mode = TERRAIN_MODE.SKIP;

package/src/terrain/terrain-effect.ts

@@ -65,7 +65,8 @@ export class TerrainEffect implements Effect {
       return;
     }
 
-    const {viewports, isPicking = false} = opts;
+    const {viewports} = opts;
+    const isPicking = opts.pass.startsWith('picking');
     this.isPicking = isPicking;
     this.isDrapingEnabled = true;
 
@@ -92,12 +93,11 @@ export class TerrainEffect implements Effect {
     this._updateTerrainCovers(terrainLayers, drapeLayers, viewport, opts);
   }
 
-  getModuleParameters(layer: Layer): TerrainModuleSettings {
+  getModuleParameters(layer: Layer): Omit<TerrainModuleSettings, 'picking'> {
     const {terrainDrawMode} = layer.state;
 
     return {
-      // @ts-expect-error
-      heightMap: this.heightMap?.getRenderFramebuffer(),
+      heightMap: this.heightMap?.getRenderFramebuffer()?.colorAttachments[0].texture || null,
       heightMapBounds: this.heightMap?.bounds,
       dummyHeightMap: this.dummyHeightMap!,
       terrainCover: this.isDrapingEnabled ? this.terrainCovers.get(layer.id) : null,
@@ -121,6 +121,8 @@ export class TerrainEffect implements Effect {
       terrainCover.delete();
     }
     this.terrainCovers.clear();
+
+    getShaderAssembler().removeDefaultModule(terrainModule);
   }
 
   private _updateHeightMap(terrainLayers: Layer[], viewport: Viewport, opts: PreRenderOptions) {
@@ -201,7 +203,12 @@ export class TerrainEffect implements Effect {
             devicePixelRatio: 1
           }
         });
-        terrainCover.isDirty = false;
+
+        if (!this.isPicking) {
+          // IsDirty refers to the normal fbo, not the picking fbo.
+          // Only mark it as not dirty if the normal fbo was updated.
+          terrainCover.isDirty = false;
+        }
       }
     } catch (err) {
       terrainLayer.raiseError(err as Error, `Error rendering terrain cover ${terrainCover.id}`);

package/src/terrain/terrain-pass.ts

@@ -1,4 +1,3 @@
-import {withGLParameters} from '@luma.gl/webgl';
 import {GL} from '@luma.gl/constants';
 import {Layer, Viewport, _LayersPass as LayersPass, LayersPassRenderOptions} from '@deck.gl/core';
 import type {HeightMapBuilder} from './height-map-builder';
@@ -33,8 +32,7 @@ export class TerrainPass extends LayersPass {
 
     target.resize(viewport);
 
-    withGLParameters(
-      this.device,
+    this.device.withParametersWebGL(
       {
         clearColor: [0, 0, 0, 0],
         blend: true,
@@ -66,8 +64,7 @@ export class TerrainPass extends LayersPass {
     const layers = terrainCover.filterLayers(opts.layers!);
     target.resize(viewport);
 
-    withGLParameters(
-      this.device,
+    this.device.withParametersWebGL(
       {
         clearColor: [0, 0, 0, 0],
         depthTest: false

package/src/terrain/terrain-picking-pass.ts

@@ -4,7 +4,6 @@ import {
   LayersPassRenderOptions,
   _PickLayersPass as PickLayersPass
 } from '@deck.gl/core';
-import {withGLParameters} from '@luma.gl/webgl';
 import type {TerrainCover} from './terrain-cover';
 
 export type TerrainPickingPassRenderOptions = LayersPassRenderOptions & {
@@ -54,8 +53,7 @@ export class TerrainPickingPass extends PickLayersPass {
     }
     target.resize(viewport);
 
-    withGLParameters(
-      this.device,
+    this.device.withParametersWebGL(
       {
         depthTest: false
       },

package/src/terrain/utils.ts

@@ -13,7 +13,7 @@ export function createRenderTarget(
     colorAttachments: [
       device.createTexture({
         ...(opts.float && {
-          format: device.info.type === 'webgl2' ? 'rgba32float' : 'rgba8unorm',
+          format: 'rgba32float',
           type: GL.FLOAT
         }),
         mipmaps: false,

package/src/utils/debug.ts

@@ -1,7 +1,6 @@
 /* global document */
 
 import {Framebuffer} from '@luma.gl/core';
-import {readPixelsToArray} from '@luma.gl/webgl';
 
 /** Debug utility to draw FBO contents onto screen */
 // eslint-disable-next-line
@@ -9,7 +8,7 @@ export const debugFBO = function (
   fbo: Framebuffer,
   {minimap, opaque}: {minimap?: boolean; opaque?: boolean} = {}
 ) {
-  const color = readPixelsToArray(fbo);
+  const color = fbo.device.readPixelsToArrayWebGL(fbo);
   let canvas = document.getElementById('fbo-canvas') as HTMLCanvasElement;
   const canvasHeight = (minimap ? 2 : 1) * fbo.height;
   if (!canvas) {

package/src/utils/syntax-tags.ts

@@ -0,0 +1,5 @@
+/**
+ * Marks GLSL shaders for syntax highlighting: glsl`...`
+ * Install https://marketplace.visualstudio.com/items?itemName=boyswan.glsl-literal
+ */
+export const glsl = (s: TemplateStringsArray) => `${s}`;

package/dist/es5/brushing/brushing-extension.js

@@ -1,108 +0,0 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-
-var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
-
-var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
-
-var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
-
-var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
-
-var _core = require("@deck.gl/core");
-
-var _shaderModule = _interopRequireDefault(require("./shader-module"));
-
-function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2.default)(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2.default)(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2.default)(this, result); }; }
-
-function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
-
-var defaultProps = {
-  getBrushingTarget: {
-    type: 'accessor',
-    value: [0, 0]
-  },
-  brushingTarget: 'source',
-  brushingEnabled: true,
-  brushingRadius: 10000
-};
-
-var BrushingExtension = function (_LayerExtension) {
-  (0, _inherits2.default)(BrushingExtension, _LayerExtension);
-
-  var _super = _createSuper(BrushingExtension);
-
-  function BrushingExtension() {
-    (0, _classCallCheck2.default)(this, BrushingExtension);
-    return _super.apply(this, arguments);
-  }
-
-  var _proto = BrushingExtension.prototype;
-
-  _proto.getShaders = function getShaders() {
-    return {
-      modules: [_shaderModule.default]
-    };
-  };
-
-  _proto.initializeState = function initializeState(context, extension) {
-    var _this = this;
-
-    var attributeManager = this.getAttributeManager();
-
-    if (attributeManager) {
-      attributeManager.add({
-        brushingTargets: {
-          size: 2,
-          accessor: 'getBrushingTarget',
-          shaderAttributes: {
-            brushingTargets: {
-              divisor: 0
-            },
-            instanceBrushingTargets: {
-              divisor: 1
-            }
-          }
-        }
-      });
-    }
-
-    var onMouseMove = function onMouseMove() {
-      var _this$getCurrentLayer;
-
-      (_this$getCurrentLayer = _this.getCurrentLayer()) === null || _this$getCurrentLayer === void 0 ? void 0 : _this$getCurrentLayer.setNeedsRedraw();
-    };
-
-    this.state.onMouseMove = onMouseMove;
-
-    if (context.deck) {
-      context.deck.eventManager.on({
-        pointermove: onMouseMove,
-        pointerleave: onMouseMove
-      });
-    }
-  };
-
-  _proto.finalizeState = function finalizeState(context, extension) {
-    if (context.deck) {
-      var onMouseMove = this.state.onMouseMove;
-      context.deck.eventManager.off({
-        pointermove: onMouseMove,
-        pointerleave: onMouseMove
-      });
-    }
-  };
-
-  return BrushingExtension;
-}(_core.LayerExtension);
-
-exports.default = BrushingExtension;
-BrushingExtension.defaultProps = defaultProps;
-BrushingExtension.extensionName = 'BrushingExtension';
-//# sourceMappingURL=brushing-extension.js.map

package/dist/es5/brushing/brushing-extension.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/brushing/brushing-extension.ts"],"names":["defaultProps","getBrushingTarget","type","value","brushingTarget","brushingEnabled","brushingRadius","BrushingExtension","getShaders","modules","shaderModule","initializeState","context","extension","attributeManager","getAttributeManager","add","brushingTargets","size","accessor","shaderAttributes","divisor","instanceBrushingTargets","onMouseMove","getCurrentLayer","setNeedsRedraw","state","deck","eventManager","on","pointermove","pointerleave","finalizeState","off","LayerExtension","extensionName"],"mappings":";;;;;;;;;;;;;;;;;AAoBA;;AACA;;;;;;AAIA,IAAMA,YAAY,GAAG;AACnBC,EAAAA,iBAAiB,EAAE;AAACC,IAAAA,IAAI,EAAE,UAAP;AAAmBC,IAAAA,KAAK,EAAE,CAAC,CAAD,EAAI,CAAJ;AAA1B,GADA;AAGnBC,EAAAA,cAAc,EAAE,QAHG;AAInBC,EAAAA,eAAe,EAAE,IAJE;AAKnBC,EAAAA,cAAc,EAAE;AALG,CAArB;;IA8BqBC,iB;;;;;;;;;;;;SAInBC,U,GAAA,sBAAkB;AAChB,WAAO;AACLC,MAAAA,OAAO,EAAE,CAACC,qBAAD;AADJ,KAAP;AAGD,G;;SAEDC,e,GAAA,yBAAqDC,OAArD,EAA4EC,SAA5E,EAA6F;AAAA;;AAC3F,QAAMC,gBAAgB,GAAG,KAAKC,mBAAL,EAAzB;;AACA,QAAID,gBAAJ,EAAsB;AACpBA,MAAAA,gBAAgB,CAACE,GAAjB,CAAqB;AACnBC,QAAAA,eAAe,EAAE;AACfC,UAAAA,IAAI,EAAE,CADS;AAEfC,UAAAA,QAAQ,EAAE,mBAFK;AAGfC,UAAAA,gBAAgB,EAAE;AAChBH,YAAAA,eAAe,EAAE;AACfI,cAAAA,OAAO,EAAE;AADM,aADD;AAIhBC,YAAAA,uBAAuB,EAAE;AACvBD,cAAAA,OAAO,EAAE;AADc;AAJT;AAHH;AADE,OAArB;AAcD;;AAGD,QAAME,WAAW,GAAG,SAAdA,WAAc,GAAM;AAAA;;AACxB,+BAAA,KAAI,CAACC,eAAL,kFAAwBC,cAAxB;AACD,KAFD;;AAIA,SAAKC,KAAL,CAAWH,WAAX,GAAyBA,WAAzB;;AACA,QAAIX,OAAO,CAACe,IAAZ,EAAkB;AAEhBf,MAAAA,OAAO,CAACe,IAAR,CAAaC,YAAb,CAA0BC,EAA1B,CAA6B;AAC3BC,QAAAA,WAAW,EAAEP,WADc;AAE3BQ,QAAAA,YAAY,EAAER;AAFa,OAA7B;AAID;AACF,G;;SAEDS,a,GAAA,uBAAmDpB,OAAnD,EAA0EC,SAA1E,EAA2F;AAEzF,QAAID,OAAO,CAACe,IAAZ,EAAkB;AAChB,UAAMJ,WAAW,GAAG,KAAKG,KAAL,CAAWH,WAA/B;AAEAX,MAAAA,OAAO,CAACe,IAAR,CAAaC,YAAb,CAA0BK,GAA1B,CAA8B;AAC5BH,QAAAA,WAAW,EAAEP,WADe;AAE5BQ,QAAAA,YAAY,EAAER;AAFc,OAA9B;AAID;AACF,G;;;EAtD4CW,oB;;;AAA1B3B,iB,CACZP,Y,GAAeA,Y;AADHO,iB,CAEZ4B,a,GAAgB,mB","sourcesContent":["// Copyright (c) 2015 - 2017 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\nimport {LayerExtension} from '@deck.gl/core';\nimport shaderModule from './shader-module';\n\nimport type {Layer, LayerContext, Accessor} from '@deck.gl/core';\n\nconst defaultProps = {\n  getBrushingTarget: {type: 'accessor', value: [0, 0]},\n\n  brushingTarget: 'source',\n  brushingEnabled: true,\n  brushingRadius: 10000\n};\n\nexport type BrushingExtensionProps<DataT = any> = {\n  /**\n   * Called to retrieve an arbitrary position for each object that it will be filtered by.\n   * Only effective if `brushingTarget` is set to `custom`.\n   */\n  getBrushingTarget?: Accessor<DataT, [number, number]>;\n  /**\n   * Enable/disable brushing. If brushing is disabled, all objects are rendered.\n   * @default true\n   */\n  brushingEnabled?: boolean;\n  /**\n   * The position used to filter each object by.\n   */\n  brushingTarget?: 'source' | 'target' | 'source_target' | 'custom';\n  /** The brushing radius centered at the pointer, in meters. If a data object is within this circle, it is rendered; otherwise it is hidden.\n   * @default 10000\n   */\n  brushingRadius?: number;\n};\n\n/** Adds GPU-based data brushing functionalities to layers. It allows the layer to show/hide objects based on the current pointer position. */\nexport default class BrushingExtension extends LayerExtension {\n  static defaultProps = defaultProps;\n  static extensionName = 'BrushingExtension';\n\n  getShaders(): any {\n    return {\n      modules: [shaderModule]\n    };\n  }\n\n  initializeState(this: Layer<BrushingExtensionProps>, context: LayerContext, extension: this) {\n    const attributeManager = this.getAttributeManager();\n    if (attributeManager) {\n      attributeManager.add({\n        brushingTargets: {\n          size: 2,\n          accessor: 'getBrushingTarget',\n          shaderAttributes: {\n            brushingTargets: {\n              divisor: 0\n            },\n            instanceBrushingTargets: {\n              divisor: 1\n            }\n          }\n        }\n      });\n    }\n\n    // Trigger redraw when mouse moves\n    const onMouseMove = () => {\n      this.getCurrentLayer()?.setNeedsRedraw();\n    };\n    // TODO - expose this in a better way\n    this.state.onMouseMove = onMouseMove;\n    if (context.deck) {\n      // @ts-expect-error (2446) accessing protected property\n      context.deck.eventManager.on({\n        pointermove: onMouseMove,\n        pointerleave: onMouseMove\n      });\n    }\n  }\n\n  finalizeState(this: Layer<BrushingExtensionProps>, context: LayerContext, extension: this) {\n    // Remove event listeners\n    if (context.deck) {\n      const onMouseMove = this.state.onMouseMove as () => void;\n      // @ts-expect-error (2446) accessing protected property\n      context.deck.eventManager.off({\n        pointermove: onMouseMove,\n        pointerleave: onMouseMove\n      });\n    }\n  }\n}\n"],"file":"brushing-extension.js"}

package/dist/es5/brushing/shader-module.js

@@ -1,50 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-
-var _core = require("@deck.gl/core");
-
-var vs = "\n  uniform bool brushing_enabled;\n  uniform int brushing_target;\n  uniform vec2 brushing_mousePos;\n  uniform float brushing_radius;\n\n  #ifdef NON_INSTANCED_MODEL\n  in vec2 brushingTargets;\n  #else\n  in vec2 instanceBrushingTargets;\n  #endif\n\n  out float brushing_isVisible;\n\n  bool brushing_isPointInRange(vec2 position) {\n    if (!brushing_enabled) {\n      return true;\n    }\n    vec2 source_commonspace = project_position(position);\n    vec2 target_commonspace = project_position(brushing_mousePos);\n    float distance = length((target_commonspace - source_commonspace) / project_uCommonUnitsPerMeter.xy);\n\n    return distance <= brushing_radius;\n  }\n\n  bool brushing_arePointsInRange(vec2 sourcePos, vec2 targetPos) {\n    return brushing_isPointInRange(sourcePos) || brushing_isPointInRange(targetPos);\n  }\n\n  void brushing_setVisible(bool visible) {\n    brushing_isVisible = float(visible);\n  }\n";
-var fs = "\n  uniform bool brushing_enabled;\n  in float brushing_isVisible;\n";
-var TARGET = {
-  source: 0,
-  target: 1,
-  custom: 2,
-  source_target: 3
-};
-var inject = {
-  'vs:DECKGL_FILTER_GL_POSITION': "\n    vec2 brushingTarget;\n    vec2 brushingSource;\n    if (brushing_target == 3) {\n      brushingTarget = geometry.worldPositionAlt.xy;\n      brushingSource = geometry.worldPosition.xy;\n    } else if (brushing_target == 0) {\n      brushingTarget = geometry.worldPosition.xy;\n    } else if (brushing_target == 1) {\n      brushingTarget = geometry.worldPositionAlt.xy;\n    } else {\n      #ifdef NON_INSTANCED_MODEL\n      brushingTarget = brushingTargets;\n      #else\n      brushingTarget = instanceBrushingTargets;\n      #endif\n    }\n    bool visible;\n    if (brushing_target == 3) {\n      visible = brushing_arePointsInRange(brushingSource, brushingTarget);\n    } else {\n      visible = brushing_isPointInRange(brushingTarget);\n    }\n    brushing_setVisible(visible);\n  ",
-  'fs:DECKGL_FILTER_COLOR': "\n    if (brushing_enabled && brushing_isVisible < 0.5) {\n      discard;\n    }\n  "
-};
-var _default = {
-  name: 'brushing',
-  dependencies: [_core.project],
-  vs: vs,
-  fs: fs,
-  inject: inject,
-  getUniforms: function getUniforms(opts) {
-    if (!opts || !('viewport' in opts)) {
-      return {};
-    }
-
-    var _opts$brushingEnabled = opts.brushingEnabled,
-        brushingEnabled = _opts$brushingEnabled === void 0 ? true : _opts$brushingEnabled,
-        _opts$brushingRadius = opts.brushingRadius,
-        brushingRadius = _opts$brushingRadius === void 0 ? 10000 : _opts$brushingRadius,
-        _opts$brushingTarget = opts.brushingTarget,
-        brushingTarget = _opts$brushingTarget === void 0 ? 'source' : _opts$brushingTarget,
-        mousePosition = opts.mousePosition,
-        viewport = opts.viewport;
-    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]
-    };
-  }
-};
-exports.default = _default;
-//# sourceMappingURL=shader-module.js.map