@deck.gl/extensions 8.9.0-beta.2 → 8.9.0-beta.3

package/dist/es5/{collide/collide-effect.js → collision-filter/collision-filter-effect.js}

@@ -19,7 +19,7 @@ var _core2 = require("@math.gl/core");
 
 var _core3 = require("@deck.gl/core");
 
-var _collidePass = _interopRequireDefault(require("./collide-pass"));
+var _collisionFilterPass = _interopRequireDefault(require("./collision-filter-pass"));
 
 var _maskEffect = _interopRequireDefault(require("../mask/mask-effect"));
 
@@ -31,21 +31,21 @@ function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len
 
 var DOWNSCALE = 2;
 
-var CollideEffect = function () {
-  function CollideEffect() {
-    (0, _classCallCheck2.default)(this, CollideEffect);
-    (0, _defineProperty2.default)(this, "id", 'collide-effect');
+var CollisionFilterEffect = function () {
+  function CollisionFilterEffect() {
+    (0, _classCallCheck2.default)(this, CollisionFilterEffect);
+    (0, _defineProperty2.default)(this, "id", 'collision-filter-effect');
     (0, _defineProperty2.default)(this, "props", null);
     (0, _defineProperty2.default)(this, "useInPicking", true);
     (0, _defineProperty2.default)(this, "order", 1);
     (0, _defineProperty2.default)(this, "channels", {});
-    (0, _defineProperty2.default)(this, "collidePass", void 0);
-    (0, _defineProperty2.default)(this, "collideFBOs", {});
-    (0, _defineProperty2.default)(this, "dummyCollideMap", void 0);
+    (0, _defineProperty2.default)(this, "collisionFilterPass", void 0);
+    (0, _defineProperty2.default)(this, "collisionFBOs", {});
+    (0, _defineProperty2.default)(this, "dummyCollisionMap", void 0);
     (0, _defineProperty2.default)(this, "lastViewport", void 0);
   }
 
-  (0, _createClass2.default)(CollideEffect, [{
+  (0, _createClass2.default)(CollisionFilterEffect, [{
     key: "preRender",
     value: function preRender(gl, _ref) {
       var _preRenderStats$mask;
@@ -60,8 +60,8 @@ var CollideEffect = function () {
           _ref$preRenderStats = _ref.preRenderStats,
           preRenderStats = _ref$preRenderStats === void 0 ? {} : _ref$preRenderStats;
 
-      if (!this.dummyCollideMap) {
-        this.dummyCollideMap = new _core.Texture2D(gl, {
+      if (!this.dummyCollisionMap) {
+        this.dummyCollisionMap = new _core.Texture2D(gl, {
           width: 1,
           height: 1
         });
@@ -71,21 +71,21 @@ var CollideEffect = function () {
         return;
       }
 
-      var collideLayers = layers.filter(function (_ref2) {
+      var collisionLayers = layers.filter(function (_ref2) {
         var _ref2$props = _ref2.props,
             visible = _ref2$props.visible,
-            collideEnabled = _ref2$props.collideEnabled;
-        return visible && collideEnabled;
+            collisionEnabled = _ref2$props.collisionEnabled;
+        return visible && collisionEnabled;
       });
 
-      if (collideLayers.length === 0) {
+      if (collisionLayers.length === 0) {
         this.channels = {};
         return;
       }
 
-      if (!this.collidePass) {
-        this.collidePass = new _collidePass.default(gl, {
-          id: 'default-collide'
+      if (!this.collisionFilterPass) {
+        this.collisionFilterPass = new _collisionFilterPass.default(gl, {
+          id: 'default-collision-filter'
         });
       }
 
@@ -94,15 +94,15 @@ var CollideEffect = function () {
       });
       var maskEffectRendered = (_preRenderStats$mask = preRenderStats['mask-effect']) === null || _preRenderStats$mask === void 0 ? void 0 : _preRenderStats$mask.didRender;
 
-      var channels = this._groupByCollideGroup(gl, collideLayers);
+      var channels = this._groupByCollisionGroup(gl, collisionLayers);
 
       var viewport = viewports[0];
       var viewportChanged = !this.lastViewport || !this.lastViewport.equals(viewport) || maskEffectRendered;
 
-      for (var collideGroup in channels) {
-        var collideFBO = this.collideFBOs[collideGroup];
-        var renderInfo = channels[collideGroup];
-        collideFBO.resize({
+      for (var collisionGroup in channels) {
+        var collisionFBO = this.collisionFBOs[collisionGroup];
+        var renderInfo = channels[collisionGroup];
+        collisionFBO.resize({
           width: gl.canvas.width / DOWNSCALE,
           height: gl.canvas.height / DOWNSCALE
         });
@@ -126,8 +126,8 @@ var CollideEffect = function () {
           views = _ref3.views,
           viewport = _ref3.viewport,
           viewportChanged = _ref3.viewportChanged;
-      var collideGroup = renderInfo.collideGroup;
-      var oldRenderInfo = this.channels[collideGroup];
+      var collisionGroup = renderInfo.collisionGroup;
+      var oldRenderInfo = this.channels[collisionGroup];
 
       if (!oldRenderInfo) {
         return;
@@ -135,14 +135,16 @@ var CollideEffect = function () {
 
       var needsRender = viewportChanged || renderInfo === oldRenderInfo || !(0, _core3._deepEqual)(oldRenderInfo.layers, renderInfo.layers, 0) || renderInfo.layerBounds.some(function (b, i) {
         return !(0, _core2.equals)(b, oldRenderInfo.layerBounds[i]);
+      }) || renderInfo.allLayersLoaded !== oldRenderInfo.allLayersLoaded || renderInfo.layers.some(function (layer) {
+        return layer.props.transitions;
       });
-      this.channels[collideGroup] = renderInfo;
+      this.channels[collisionGroup] = renderInfo;
 
       if (needsRender) {
         this.lastViewport = viewport;
-        var collideFBO = this.collideFBOs[collideGroup];
-        this.collidePass.renderCollideMap(collideFBO, {
-          pass: 'collide',
+        var collisionFBO = this.collisionFBOs[collisionGroup];
+        this.collisionFilterPass.renderCollisionMap(collisionFBO, {
+          pass: 'collision-filter',
           isPicking: true,
           layers: renderInfo.layers,
           effects: effects,
@@ -151,37 +153,42 @@ var CollideEffect = function () {
           onViewportActive: onViewportActive,
           views: views,
           moduleParameters: {
-            dummyCollideMap: this.dummyCollideMap,
-            devicePixelRatio: (0, _core.cssToDeviceRatio)(collideFBO.gl) / DOWNSCALE
+            dummyCollisionMap: this.dummyCollisionMap,
+            devicePixelRatio: (0, _core.cssToDeviceRatio)(collisionFBO.gl) / DOWNSCALE
           }
         });
       }
     }
   }, {
-    key: "_groupByCollideGroup",
-    value: function _groupByCollideGroup(gl, collideLayers) {
+    key: "_groupByCollisionGroup",
+    value: function _groupByCollisionGroup(gl, collisionLayers) {
       var channelMap = {};
 
-      var _iterator = _createForOfIteratorHelper(collideLayers),
+      var _iterator = _createForOfIteratorHelper(collisionLayers),
           _step;
 
       try {
         for (_iterator.s(); !(_step = _iterator.n()).done;) {
           var layer = _step.value;
-          var _collideGroup2 = layer.props.collideGroup;
-          var channelInfo = channelMap[_collideGroup2];
+          var _collisionGroup2 = layer.props.collisionGroup;
+          var channelInfo = channelMap[_collisionGroup2];
 
           if (!channelInfo) {
             channelInfo = {
-              collideGroup: _collideGroup2,
+              collisionGroup: _collisionGroup2,
               layers: [],
-              layerBounds: []
+              layerBounds: [],
+              allLayersLoaded: true
             };
-            channelMap[_collideGroup2] = channelInfo;
+            channelMap[_collisionGroup2] = channelInfo;
           }
 
           channelInfo.layers.push(layer);
           channelInfo.layerBounds.push(layer.getBounds());
+
+          if (!layer.isLoaded) {
+            channelInfo.allLayersLoaded = false;
+          }
         }
       } catch (err) {
         _iterator.e(err);
@@ -190,22 +197,22 @@ var CollideEffect = function () {
       }
 
       for (var _i = 0, _Object$keys = Object.keys(channelMap); _i < _Object$keys.length; _i++) {
-        var collideGroup = _Object$keys[_i];
+        var collisionGroup = _Object$keys[_i];
 
-        if (!this.collideFBOs[collideGroup]) {
-          this.createFBO(gl, collideGroup);
+        if (!this.collisionFBOs[collisionGroup]) {
+          this.createFBO(gl, collisionGroup);
         }
 
-        if (!this.channels[collideGroup]) {
-          this.channels[collideGroup] = channelMap[collideGroup];
+        if (!this.channels[collisionGroup]) {
+          this.channels[collisionGroup] = channelMap[collisionGroup];
         }
       }
 
-      for (var _i2 = 0, _Object$keys2 = Object.keys(this.collideFBOs); _i2 < _Object$keys2.length; _i2++) {
-        var _collideGroup = _Object$keys2[_i2];
+      for (var _i2 = 0, _Object$keys2 = Object.keys(this.collisionFBOs); _i2 < _Object$keys2.length; _i2++) {
+        var _collisionGroup = _Object$keys2[_i2];
 
-        if (!channelMap[_collideGroup]) {
-          this.destroyFBO(_collideGroup);
+        if (!channelMap[_collisionGroup]) {
+          this.destroyFBO(_collisionGroup);
         }
       }
 
@@ -214,41 +221,41 @@ var CollideEffect = function () {
   }, {
     key: "getModuleParameters",
     value: function getModuleParameters(layer) {
-      var collideGroup = layer.props.collideGroup;
-      var collideFBOs = this.collideFBOs,
-          dummyCollideMap = this.dummyCollideMap;
+      var collisionGroup = layer.props.collisionGroup;
+      var collisionFBOs = this.collisionFBOs,
+          dummyCollisionMap = this.dummyCollisionMap;
       return {
-        collideFBO: collideFBOs[collideGroup],
-        dummyCollideMap: dummyCollideMap
+        collisionFBO: collisionFBOs[collisionGroup],
+        dummyCollisionMap: dummyCollisionMap
       };
     }
   }, {
     key: "cleanup",
     value: function cleanup() {
-      if (this.dummyCollideMap) {
-        this.dummyCollideMap.delete();
-        this.dummyCollideMap = undefined;
+      if (this.dummyCollisionMap) {
+        this.dummyCollisionMap.delete();
+        this.dummyCollisionMap = undefined;
       }
 
       this.channels = {};
 
-      for (var _i3 = 0, _Object$keys3 = Object.keys(this.collideFBOs); _i3 < _Object$keys3.length; _i3++) {
-        var collideGroup = _Object$keys3[_i3];
-        this.destroyFBO(collideGroup);
+      for (var _i3 = 0, _Object$keys3 = Object.keys(this.collisionFBOs); _i3 < _Object$keys3.length; _i3++) {
+        var collisionGroup = _Object$keys3[_i3];
+        this.destroyFBO(collisionGroup);
       }
 
-      this.collideFBOs = {};
+      this.collisionFBOs = {};
       this.lastViewport = undefined;
     }
   }, {
     key: "createFBO",
-    value: function createFBO(gl, collideGroup) {
+    value: function createFBO(gl, collisionGroup) {
       var _parameters, _attachments;
 
       var _gl$canvas = gl.canvas,
           width = _gl$canvas.width,
           height = _gl$canvas.height;
-      var collideMap = new _core.Texture2D(gl, {
+      var collisionMap = new _core.Texture2D(gl, {
         width: width,
         height: height,
         parameters: (_parameters = {}, (0, _defineProperty2.default)(_parameters, 10241, 9728), (0, _defineProperty2.default)(_parameters, 10240, 9728), (0, _defineProperty2.default)(_parameters, 10242, 33071), (0, _defineProperty2.default)(_parameters, 10243, 33071), _parameters)
@@ -258,17 +265,17 @@ var CollideEffect = function () {
         width: width,
         height: height
       });
-      this.collideFBOs[collideGroup] = new _core.Framebuffer(gl, {
-        id: "Collide-".concat(collideGroup),
+      this.collisionFBOs[collisionGroup] = new _core.Framebuffer(gl, {
+        id: "Collision-".concat(collisionGroup),
         width: width,
         height: height,
-        attachments: (_attachments = {}, (0, _defineProperty2.default)(_attachments, 36064, collideMap), (0, _defineProperty2.default)(_attachments, 36096, depthBuffer), _attachments)
+        attachments: (_attachments = {}, (0, _defineProperty2.default)(_attachments, 36064, collisionMap), (0, _defineProperty2.default)(_attachments, 36096, depthBuffer), _attachments)
       });
     }
   }, {
     key: "destroyFBO",
-    value: function destroyFBO(collideGroup) {
-      var fbo = this.collideFBOs[collideGroup];
+    value: function destroyFBO(collisionGroup) {
+      var fbo = this.collisionFBOs[collisionGroup];
 
       for (var _i4 = 0, _Object$values = Object.values(fbo.attachments); _i4 < _Object$values.length; _i4++) {
         var attachment = _Object$values[_i4];
@@ -276,11 +283,11 @@ var CollideEffect = function () {
       }
 
       fbo.delete();
-      delete this.collideFBOs[collideGroup];
+      delete this.collisionFBOs[collisionGroup];
     }
   }]);
-  return CollideEffect;
+  return CollisionFilterEffect;
 }();
 
-exports.default = CollideEffect;
-//# sourceMappingURL=collide-effect.js.map
+exports.default = CollisionFilterEffect;
+//# sourceMappingURL=collision-filter-effect.js.map

package/dist/es5/collision-filter/collision-filter-effect.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/collision-filter/collision-filter-effect.ts"],"names":["DOWNSCALE","CollisionFilterEffect","gl","allEffects","effects","layers","layerFilter","viewports","onViewportActive","views","isPicking","preRenderStats","dummyCollisionMap","Texture2D","width","height","collisionLayers","filter","props","visible","collisionEnabled","length","channels","collisionFilterPass","CollisionFilterPass","id","e","constructor","MaskEffect","maskEffectRendered","didRender","_groupByCollisionGroup","viewport","viewportChanged","lastViewport","equals","collisionGroup","collisionFBO","collisionFBOs","renderInfo","resize","canvas","_render","oldRenderInfo","needsRender","layerBounds","some","b","i","allLayersLoaded","layer","transitions","renderCollisionMap","pass","moduleParameters","devicePixelRatio","channelMap","channelInfo","push","getBounds","isLoaded","Object","keys","createFBO","destroyFBO","delete","undefined","collisionMap","parameters","depthBuffer","Renderbuffer","format","Framebuffer","attachments","fbo","values","attachment"],"mappings":";;;;;;;;;;;;;;;AAAA;;AACA;;AACA;;AAEA;;AACA;;;;;;;;AASA,IAAMA,SAAS,GAAG,CAAlB;;IASqBC,qB;;;8CACd,yB;iDACG,I;wDACO,I;iDACP,C;oDAEuC,E;;yDAEM,E;;;;;;;WAIrD,mBACEC,EADF,QAYQ;AAAA;;AAAA,UATKC,UASL,QATJC,OASI;AAAA,UARJC,MAQI,QARJA,MAQI;AAAA,UAPJC,WAOI,QAPJA,WAOI;AAAA,UANJC,SAMI,QANJA,SAMI;AAAA,UALJC,gBAKI,QALJA,gBAKI;AAAA,UAJJC,KAII,QAJJA,KAII;AAAA,UAHJC,SAGI,QAHJA,SAGI;AAAA,qCAFJC,cAEI;AAAA,UAFJA,cAEI,oCAFa,EAEb;;AACN,UAAI,CAAC,KAAKC,iBAAV,EAA6B;AAC3B,aAAKA,iBAAL,GAAyB,IAAIC,eAAJ,CAAcX,EAAd,EAAkB;AAACY,UAAAA,KAAK,EAAE,CAAR;AAAWC,UAAAA,MAAM,EAAE;AAAnB,SAAlB,CAAzB;AACD;;AAED,UAAIL,SAAJ,EAAe;AAEb;AACD;;AAED,UAAMM,eAAe,GAAGX,MAAM,CAACY,MAAP,CAEtB;AAAA,gCAAEC,KAAF;AAAA,YAAUC,OAAV,eAAUA,OAAV;AAAA,YAAmBC,gBAAnB,eAAmBA,gBAAnB;AAAA,eAA0CD,OAAO,IAAIC,gBAArD;AAAA,OAFsB,CAAxB;;AAIA,UAAIJ,eAAe,CAACK,MAAhB,KAA2B,CAA/B,EAAkC;AAChC,aAAKC,QAAL,GAAgB,EAAhB;AACA;AACD;;AAED,UAAI,CAAC,KAAKC,mBAAV,EAA+B;AAC7B,aAAKA,mBAAL,GAA2B,IAAIC,4BAAJ,CAAwBtB,EAAxB,EAA4B;AAACuB,UAAAA,EAAE,EAAE;AAAL,SAA5B,CAA3B;AACD;;AAGD,UAAMrB,OAAO,GAAGD,UAAH,aAAGA,UAAH,uBAAGA,UAAU,CAAEc,MAAZ,CAAmB,UAAAS,CAAC;AAAA,eAAIA,CAAC,CAACC,WAAF,KAAkBC,mBAAtB;AAAA,OAApB,CAAhB;AACA,UAAMC,kBAAkB,2BAAIlB,cAAc,CAAC,aAAD,CAAlB,yDAAG,qBAAuDmB,SAAlF;;AAGA,UAAMR,QAAQ,GAAG,KAAKS,sBAAL,CAA4B7B,EAA5B,EAAgCc,eAAhC,CAAjB;;AAEA,UAAMgB,QAAQ,GAAGzB,SAAS,CAAC,CAAD,CAA1B;AACA,UAAM0B,eAAe,GACnB,CAAC,KAAKC,YAAN,IAAsB,CAAC,KAAKA,YAAL,CAAkBC,MAAlB,CAAyBH,QAAzB,CAAvB,IAA6DH,kBAD/D;;AAIA,WAAK,IAAMO,cAAX,IAA6Bd,QAA7B,EAAuC;AACrC,YAAMe,YAAY,GAAG,KAAKC,aAAL,CAAmBF,cAAnB,CAArB;AACA,YAAMG,UAAU,GAAGjB,QAAQ,CAACc,cAAD,CAA3B;AACAC,QAAAA,YAAY,CAACG,MAAb,CAAoB;AAClB1B,UAAAA,KAAK,EAAEZ,EAAE,CAACuC,MAAH,CAAU3B,KAAV,GAAkBd,SADP;AAElBe,UAAAA,MAAM,EAAEb,EAAE,CAACuC,MAAH,CAAU1B,MAAV,GAAmBf;AAFT,SAApB;;AAIA,aAAK0C,OAAL,CAAaH,UAAb,EAAyB;AACvBnC,UAAAA,OAAO,EAAPA,OADuB;AAEvBE,UAAAA,WAAW,EAAXA,WAFuB;AAGvBE,UAAAA,gBAAgB,EAAhBA,gBAHuB;AAIvBC,UAAAA,KAAK,EAALA,KAJuB;AAKvBuB,UAAAA,QAAQ,EAARA,QALuB;AAMvBC,UAAAA,eAAe,EAAfA;AANuB,SAAzB;AAQD;AAGF;;;WAED,iBACEM,UADF,SAiBE;AAAA,UAdEnC,OAcF,SAdEA,OAcF;AAAA,UAbEE,WAaF,SAbEA,WAaF;AAAA,UAZEE,gBAYF,SAZEA,gBAYF;AAAA,UAXEC,KAWF,SAXEA,KAWF;AAAA,UAVEuB,QAUF,SAVEA,QAUF;AAAA,UATEC,eASF,SATEA,eASF;AACA,UAAOG,cAAP,GAAyBG,UAAzB,CAAOH,cAAP;AACA,UAAMO,aAAa,GAAG,KAAKrB,QAAL,CAAcc,cAAd,CAAtB;;AACA,UAAI,CAACO,aAAL,EAAoB;AAClB;AACD;;AAED,UAAMC,WAAW,GACfX,eAAe,IAEfM,UAAU,KAAKI,aAFf,IAIA,CAAC,uBAAUA,aAAa,CAACtC,MAAxB,EAAgCkC,UAAU,CAAClC,MAA3C,EAAmD,CAAnD,CAJD,IAMAkC,UAAU,CAACM,WAAX,CAAuBC,IAAvB,CAA4B,UAACC,CAAD,EAAIC,CAAJ;AAAA,eAAU,CAAC,mBAAOD,CAAP,EAAUJ,aAAa,CAACE,WAAd,CAA0BG,CAA1B,CAAV,CAAX;AAAA,OAA5B,CANA,IAQAT,UAAU,CAACU,eAAX,KAA+BN,aAAa,CAACM,eAR7C,IAUAV,UAAU,CAAClC,MAAX,CAAkByC,IAAlB,CAAuB,UAAAI,KAAK;AAAA,eAAIA,KAAK,CAAChC,KAAN,CAAYiC,WAAhB;AAAA,OAA5B,CAXF;AAaA,WAAK7B,QAAL,CAAcc,cAAd,IAAgCG,UAAhC;;AAEA,UAAIK,WAAJ,EAAiB;AACf,aAAKV,YAAL,GAAoBF,QAApB;AACA,YAAMK,YAAY,GAAG,KAAKC,aAAL,CAAmBF,cAAnB,CAArB;AAGA,aAAKb,mBAAL,CAA0B6B,kBAA1B,CAA6Cf,YAA7C,EAA2D;AACzDgB,UAAAA,IAAI,EAAE,kBADmD;AAEzD3C,UAAAA,SAAS,EAAE,IAF8C;AAGzDL,UAAAA,MAAM,EAAEkC,UAAU,CAAClC,MAHsC;AAIzDD,UAAAA,OAAO,EAAPA,OAJyD;AAKzDE,UAAAA,WAAW,EAAXA,WALyD;AAMzDC,UAAAA,SAAS,EAAEyB,QAAQ,GAAG,CAACA,QAAD,CAAH,GAAgB,EANsB;AAOzDxB,UAAAA,gBAAgB,EAAhBA,gBAPyD;AAQzDC,UAAAA,KAAK,EAALA,KARyD;AASzD6C,UAAAA,gBAAgB,EAAE;AAEhB1C,YAAAA,iBAAiB,EAAE,KAAKA,iBAFR;AAGhB2C,YAAAA,gBAAgB,EAAE,4BAAiBlB,YAAY,CAACnC,EAA9B,IAAoCF;AAHtC;AATuC,SAA3D;AAeD;AACF;;;WAMD,gCACEE,EADF,EAEEc,eAFF,EAG8B;AAC5B,UAAMwC,UAAU,GAAG,EAAnB;;AAD4B,iDAERxC,eAFQ;AAAA;;AAAA;AAE5B,4DAAqC;AAAA,cAA1BkC,KAA0B;AACnC,cAAOd,gBAAP,GAAyBc,KAAK,CAAChC,KAA/B,CAAOkB,cAAP;AACA,cAAIqB,WAAW,GAAGD,UAAU,CAACpB,gBAAD,CAA5B;;AACA,cAAI,CAACqB,WAAL,EAAkB;AAChBA,YAAAA,WAAW,GAAG;AAACrB,cAAAA,cAAc,EAAdA,gBAAD;AAAiB/B,cAAAA,MAAM,EAAE,EAAzB;AAA6BwC,cAAAA,WAAW,EAAE,EAA1C;AAA8CI,cAAAA,eAAe,EAAE;AAA/D,aAAd;AACAO,YAAAA,UAAU,CAACpB,gBAAD,CAAV,GAA6BqB,WAA7B;AACD;;AACDA,UAAAA,WAAW,CAACpD,MAAZ,CAAmBqD,IAAnB,CAAwBR,KAAxB;AACAO,UAAAA,WAAW,CAACZ,WAAZ,CAAwBa,IAAxB,CAA6BR,KAAK,CAACS,SAAN,EAA7B;;AACA,cAAI,CAACT,KAAK,CAACU,QAAX,EAAqB;AACnBH,YAAAA,WAAW,CAACR,eAAZ,GAA8B,KAA9B;AACD;AACF;AAd2B;AAAA;AAAA;AAAA;AAAA;;AAiB5B,sCAA6BY,MAAM,CAACC,IAAP,CAAYN,UAAZ,CAA7B,kCAAsD;AAAjD,YAAMpB,cAAc,mBAApB;;AACH,YAAI,CAAC,KAAKE,aAAL,CAAmBF,cAAnB,CAAL,EAAyC;AACvC,eAAK2B,SAAL,CAAe7D,EAAf,EAAmBkC,cAAnB;AACD;;AACD,YAAI,CAAC,KAAKd,QAAL,CAAcc,cAAd,CAAL,EAAoC;AAClC,eAAKd,QAAL,CAAcc,cAAd,IAAgCoB,UAAU,CAACpB,cAAD,CAA1C;AACD;AACF;;AACD,wCAA6ByB,MAAM,CAACC,IAAP,CAAY,KAAKxB,aAAjB,CAA7B,qCAA8D;AAAzD,YAAMF,eAAc,qBAApB;;AACH,YAAI,CAACoB,UAAU,CAACpB,eAAD,CAAf,EAAiC;AAC/B,eAAK4B,UAAL,CAAgB5B,eAAhB;AACD;AACF;;AAED,aAAOoB,UAAP;AACD;;;WAED,6BAAoBN,KAApB,EAGE;AACA,UAAOd,cAAP,GAA0Bc,KAAD,CAAgDhC,KAAzE,CAAOkB,cAAP;AACA,UAAOE,aAAP,GAA2C,IAA3C,CAAOA,aAAP;AAAA,UAAsB1B,iBAAtB,GAA2C,IAA3C,CAAsBA,iBAAtB;AACA,aAAO;AAACyB,QAAAA,YAAY,EAAEC,aAAa,CAACF,cAAD,CAA5B;AAA8CxB,QAAAA,iBAAiB,EAAjBA;AAA9C,OAAP;AACD;;;WAED,mBAAgB;AACd,UAAI,KAAKA,iBAAT,EAA4B;AAC1B,aAAKA,iBAAL,CAAuBqD,MAAvB;AACA,aAAKrD,iBAAL,GAAyBsD,SAAzB;AACD;;AACD,WAAK5C,QAAL,GAAgB,EAAhB;;AACA,wCAA6BuC,MAAM,CAACC,IAAP,CAAY,KAAKxB,aAAjB,CAA7B,qCAA8D;AAAzD,YAAMF,cAAc,qBAApB;AACH,aAAK4B,UAAL,CAAgB5B,cAAhB;AACD;;AACD,WAAKE,aAAL,GAAqB,EAArB;AACA,WAAKJ,YAAL,GAAoBgC,SAApB;AACD;;;WAED,mBAAUhE,EAAV,EAAqCkC,cAArC,EAA6D;AAAA;;AAC3D,uBAAwBlC,EAAE,CAACuC,MAA3B;AAAA,UAAO3B,KAAP,cAAOA,KAAP;AAAA,UAAcC,MAAd,cAAcA,MAAd;AACA,UAAMoD,YAAY,GAAG,IAAItD,eAAJ,CAAcX,EAAd,EAAkB;AACrCY,QAAAA,KAAK,EAALA,KADqC;AAErCC,QAAAA,MAAM,EAANA,MAFqC;AAGrCqD,QAAAA,UAAU;AAH2B,OAAlB,CAArB;AAWA,UAAMC,WAAW,GAAG,IAAIC,kBAAJ,CAAiBpE,EAAjB,EAAqB;AAACqE,QAAAA,MAAM,OAAP;AAA+BzD,QAAAA,KAAK,EAALA,KAA/B;AAAsCC,QAAAA,MAAM,EAANA;AAAtC,OAArB,CAApB;AACA,WAAKuB,aAAL,CAAmBF,cAAnB,IAAqC,IAAIoC,iBAAJ,CAAgBtE,EAAhB,EAAoB;AACvDuB,QAAAA,EAAE,sBAAeW,cAAf,CADqD;AAEvDtB,QAAAA,KAAK,EAALA,KAFuD;AAGvDC,QAAAA,MAAM,EAANA,MAHuD;AAIvD0D,QAAAA,WAAW,yEACeN,YADf,sDAEcE,WAFd;AAJ4C,OAApB,CAArC;AASD;;;WAED,oBAAWjC,cAAX,EAAmC;AACjC,UAAMsC,GAAG,GAAG,KAAKpC,aAAL,CAAmBF,cAAnB,CAAZ;;AACA,yCAAyByB,MAAM,CAACc,MAAP,CAAcD,GAAG,CAACD,WAAlB,CAAzB,sCAAwE;AAAnE,YAAMG,UAAU,sBAAhB;AACHA,QAAAA,UAAU,CAACX,MAAX;AACD;;AACDS,MAAAA,GAAG,CAACT,MAAJ;AACA,aAAO,KAAK3B,aAAL,CAAmBF,cAAnB,CAAP;AACD","sourcesContent":["import {Framebuffer, Renderbuffer, Texture2D, cssToDeviceRatio} from '@luma.gl/core';\nimport {equals} from '@math.gl/core';\nimport {_deepEqual as deepEqual} from '@deck.gl/core';\nimport type {Effect, Layer, PreRenderOptions, Viewport} from '@deck.gl/core';\nimport CollisionFilterPass from './collision-filter-pass';\nimport MaskEffect, {MaskPreRenderStats} from '../mask/mask-effect';\n// import {debugFBO} from '../utils/debug';\n\ntype CollisionFilterExtensionProps = {\n  collisionTestProps?: {};\n  collisionGroup: string;\n};\n\n// Factor by which to downscale Collision FBO relative to canvas\nconst DOWNSCALE = 2;\n\ntype RenderInfo = {\n  collisionGroup: string;\n  layers: Layer<CollisionFilterExtensionProps>[];\n  layerBounds: ([number[], number[]] | null)[];\n  allLayersLoaded: boolean;\n};\n\nexport default class CollisionFilterEffect implements Effect {\n  id = 'collision-filter-effect';\n  props = null;\n  useInPicking = true;\n  order = 1;\n\n  private channels: Record<string, RenderInfo> = {};\n  private collisionFilterPass?: CollisionFilterPass;\n  private collisionFBOs: Record<string, Framebuffer> = {};\n  private dummyCollisionMap?: Texture2D;\n  private lastViewport?: Viewport;\n\n  preRender(\n    gl: WebGLRenderingContext,\n    {\n      effects: allEffects,\n      layers,\n      layerFilter,\n      viewports,\n      onViewportActive,\n      views,\n      isPicking,\n      preRenderStats = {}\n    }: PreRenderOptions\n  ): void {\n    if (!this.dummyCollisionMap) {\n      this.dummyCollisionMap = new Texture2D(gl, {width: 1, height: 1});\n    }\n\n    if (isPicking) {\n      // Do not update on picking pass\n      return;\n    }\n\n    const collisionLayers = layers.filter(\n      // @ts-ignore\n      ({props: {visible, collisionEnabled}}) => visible && collisionEnabled\n    ) as Layer<CollisionFilterExtensionProps>[];\n    if (collisionLayers.length === 0) {\n      this.channels = {};\n      return;\n    }\n\n    if (!this.collisionFilterPass) {\n      this.collisionFilterPass = new CollisionFilterPass(gl, {id: 'default-collision-filter'});\n    }\n\n    // Detect if mask has rendered. TODO: better dependency system for Effects\n    const effects = allEffects?.filter(e => e.constructor === MaskEffect);\n    const maskEffectRendered = (preRenderStats['mask-effect'] as MaskPreRenderStats)?.didRender;\n\n    // Collect layers to render\n    const channels = this._groupByCollisionGroup(gl, collisionLayers);\n\n    const viewport = viewports[0];\n    const viewportChanged =\n      !this.lastViewport || !this.lastViewport.equals(viewport) || maskEffectRendered;\n\n    // Resize framebuffers to match canvas\n    for (const collisionGroup in channels) {\n      const collisionFBO = this.collisionFBOs[collisionGroup];\n      const renderInfo = channels[collisionGroup];\n      collisionFBO.resize({\n        width: gl.canvas.width / DOWNSCALE,\n        height: gl.canvas.height / DOWNSCALE\n      });\n      this._render(renderInfo, {\n        effects,\n        layerFilter,\n        onViewportActive,\n        views,\n        viewport,\n        viewportChanged\n      });\n    }\n\n    // debugFBO(this.collisionFBOs[Object.keys(channels)[0]], {minimap: true});\n  }\n\n  private _render(\n    renderInfo: RenderInfo,\n    {\n      effects,\n      layerFilter,\n      onViewportActive,\n      views,\n      viewport,\n      viewportChanged\n    }: {\n      effects: PreRenderOptions['effects'];\n      layerFilter: PreRenderOptions['layerFilter'];\n      onViewportActive: PreRenderOptions['onViewportActive'];\n      views: PreRenderOptions['views'];\n      viewport: Viewport;\n      viewportChanged: boolean;\n    }\n  ) {\n    const {collisionGroup} = renderInfo;\n    const oldRenderInfo = this.channels[collisionGroup];\n    if (!oldRenderInfo) {\n      return;\n    }\n\n    const needsRender =\n      viewportChanged ||\n      // If render info is new\n      renderInfo === oldRenderInfo ||\n      // If sublayers have changed\n      !deepEqual(oldRenderInfo.layers, renderInfo.layers, 0) ||\n      // If a sublayer's bounds have been updated\n      renderInfo.layerBounds.some((b, i) => !equals(b, oldRenderInfo.layerBounds[i])) ||\n      // If a sublayer's isLoaded state has been updated\n      renderInfo.allLayersLoaded !== oldRenderInfo.allLayersLoaded ||\n      // Some prop is in transition\n      renderInfo.layers.some(layer => layer.props.transitions);\n\n    this.channels[collisionGroup] = renderInfo;\n\n    if (needsRender) {\n      this.lastViewport = viewport;\n      const collisionFBO = this.collisionFBOs[collisionGroup];\n\n      // Rerender collision FBO\n      this.collisionFilterPass!.renderCollisionMap(collisionFBO, {\n        pass: 'collision-filter',\n        isPicking: true,\n        layers: renderInfo.layers,\n        effects,\n        layerFilter,\n        viewports: viewport ? [viewport] : [],\n        onViewportActive,\n        views,\n        moduleParameters: {\n          // To avoid feedback loop forming between Framebuffer and active Texture.\n          dummyCollisionMap: this.dummyCollisionMap,\n          devicePixelRatio: cssToDeviceRatio(collisionFBO.gl) / DOWNSCALE\n        }\n      });\n    }\n  }\n\n  /**\n   * Group layers by collisionGroup\n   * Returns a map from collisionGroup to render info\n   */\n  private _groupByCollisionGroup(\n    gl: WebGLRenderingContext,\n    collisionLayers: Layer<CollisionFilterExtensionProps>[]\n  ): Record<string, RenderInfo> {\n    const channelMap = {};\n    for (const layer of collisionLayers) {\n      const {collisionGroup} = layer.props;\n      let channelInfo = channelMap[collisionGroup];\n      if (!channelInfo) {\n        channelInfo = {collisionGroup, layers: [], layerBounds: [], allLayersLoaded: true};\n        channelMap[collisionGroup] = channelInfo;\n      }\n      channelInfo.layers.push(layer);\n      channelInfo.layerBounds.push(layer.getBounds());\n      if (!layer.isLoaded) {\n        channelInfo.allLayersLoaded = false;\n      }\n    }\n\n    // Create any new passes and remove any old ones\n    for (const collisionGroup of Object.keys(channelMap)) {\n      if (!this.collisionFBOs[collisionGroup]) {\n        this.createFBO(gl, collisionGroup);\n      }\n      if (!this.channels[collisionGroup]) {\n        this.channels[collisionGroup] = channelMap[collisionGroup];\n      }\n    }\n    for (const collisionGroup of Object.keys(this.collisionFBOs)) {\n      if (!channelMap[collisionGroup]) {\n        this.destroyFBO(collisionGroup);\n      }\n    }\n\n    return channelMap;\n  }\n\n  getModuleParameters(layer: Layer): {\n    collisionFBO: Framebuffer;\n    dummyCollisionMap: Texture2D;\n  } {\n    const {collisionGroup} = (layer as Layer<CollisionFilterExtensionProps>).props;\n    const {collisionFBOs, dummyCollisionMap} = this;\n    return {collisionFBO: collisionFBOs[collisionGroup], dummyCollisionMap};\n  }\n\n  cleanup(): void {\n    if (this.dummyCollisionMap) {\n      this.dummyCollisionMap.delete();\n      this.dummyCollisionMap = undefined;\n    }\n    this.channels = {};\n    for (const collisionGroup of Object.keys(this.collisionFBOs)) {\n      this.destroyFBO(collisionGroup);\n    }\n    this.collisionFBOs = {};\n    this.lastViewport = undefined;\n  }\n\n  createFBO(gl: WebGLRenderingContext, collisionGroup: string) {\n    const {width, height} = gl.canvas;\n    const collisionMap = new Texture2D(gl, {\n      width,\n      height,\n      parameters: {\n        [gl.TEXTURE_MIN_FILTER]: gl.NEAREST,\n        [gl.TEXTURE_MAG_FILTER]: gl.NEAREST,\n        [gl.TEXTURE_WRAP_S]: gl.CLAMP_TO_EDGE,\n        [gl.TEXTURE_WRAP_T]: gl.CLAMP_TO_EDGE\n      }\n    });\n\n    const depthBuffer = new Renderbuffer(gl, {format: gl.DEPTH_COMPONENT16, width, height});\n    this.collisionFBOs[collisionGroup] = new Framebuffer(gl, {\n      id: `Collision-${collisionGroup}`,\n      width,\n      height,\n      attachments: {\n        [gl.COLOR_ATTACHMENT0]: collisionMap,\n        [gl.DEPTH_ATTACHMENT]: depthBuffer\n      }\n    });\n  }\n\n  destroyFBO(collisionGroup: string) {\n    const fbo = this.collisionFBOs[collisionGroup];\n    for (const attachment of Object.values(fbo.attachments as Texture2D[])) {\n      attachment.delete();\n    }\n    fbo.delete();\n    delete this.collisionFBOs[collisionGroup];\n  }\n}\n"],"file":"collision-filter-effect.js"}

package/dist/es5/{collide/collide-pass.js → collision-filter/collision-filter-pass.js}

@@ -31,19 +31,19 @@ function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflec
 
 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 CollidePass = function (_LayersPass) {
-  (0, _inherits2.default)(CollidePass, _LayersPass);
+var CollisionFilterPass = function (_LayersPass) {
+  (0, _inherits2.default)(CollisionFilterPass, _LayersPass);
 
-  var _super = _createSuper(CollidePass);
+  var _super = _createSuper(CollisionFilterPass);
 
-  function CollidePass() {
-    (0, _classCallCheck2.default)(this, CollidePass);
+  function CollisionFilterPass() {
+    (0, _classCallCheck2.default)(this, CollisionFilterPass);
     return _super.apply(this, arguments);
   }
 
-  (0, _createClass2.default)(CollidePass, [{
-    key: "renderCollideMap",
-    value: function renderCollideMap(target, options) {
+  (0, _createClass2.default)(CollisionFilterPass, [{
+    key: "renderCollisionMap",
+    value: function renderCollisionMap(target, options) {
       var _this = this;
 
       var gl = this.gl;
@@ -58,7 +58,7 @@ var CollidePass = function (_LayersPass) {
       }, function () {
         return _this.render(_objectSpread(_objectSpread({}, options), {}, {
           target: target,
-          pass: 'collide'
+          pass: 'collision'
         }));
       });
     }
@@ -66,15 +66,15 @@ var CollidePass = function (_LayersPass) {
     key: "getModuleParameters",
     value: function getModuleParameters() {
       return {
-        drawToCollideMap: true,
+        drawToCollisionMap: true,
         pickingActive: 1,
         pickingAttribute: false,
         lightSources: {}
       };
     }
   }]);
-  return CollidePass;
+  return CollisionFilterPass;
 }(_core2._LayersPass);
 
-exports.default = CollidePass;
-//# sourceMappingURL=collide-pass.js.map
+exports.default = CollisionFilterPass;
+//# sourceMappingURL=collision-filter-pass.js.map

package/dist/es5/collision-filter/collision-filter-pass.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/collision-filter/collision-filter-pass.ts"],"names":["CollisionFilterPass","target","options","gl","padding","scissorTest","scissor","width","height","clearColor","blend","depthTest","depthRange","render","pass","drawToCollisionMap","pickingActive","pickingAttribute","lightSources","LayersPass"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAAA;;AACA;;;;;;;;;;IAIqBA,mB;;;;;;;;;;;;WACnB,4BAAmBC,MAAnB,EAAwCC,OAAxC,EAAmF;AAAA;;AACjF,UAAMC,EAAE,GAAG,KAAKA,EAAhB;AAEA,UAAMC,OAAO,GAAG,CAAhB;AAEA,aAAO,0BACLD,EADK,EAEL;AACEE,QAAAA,WAAW,EAAE,IADf;AAEEC,QAAAA,OAAO,EAAE,CAACF,OAAD,EAAUA,OAAV,EAAmBH,MAAM,CAACM,KAAP,GAAe,IAAIH,OAAtC,EAA+CH,MAAM,CAACO,MAAP,GAAgB,IAAIJ,OAAnE,CAFX;AAGEK,QAAAA,UAAU,EAAE,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV,CAHd;AAIEC,QAAAA,KAAK,EAAE,KAJT;AAKEC,QAAAA,SAAS,EAAE,IALb;AAMEC,QAAAA,UAAU,EAAE,CAAC,CAAD,EAAI,CAAJ;AANd,OAFK,EAUL;AAAA,eAAM,KAAI,CAACC,MAAL,iCAAgBX,OAAhB;AAAyBD,UAAAA,MAAM,EAANA,MAAzB;AAAiCa,UAAAA,IAAI,EAAE;AAAvC,WAAN;AAAA,OAVK,CAAP;AAYD;;;WAED,+BAAsB;AAEpB,aAAO;AACLC,QAAAA,kBAAkB,EAAE,IADf;AAELC,QAAAA,aAAa,EAAE,CAFV;AAGLC,QAAAA,gBAAgB,EAAE,KAHb;AAILC,QAAAA,YAAY,EAAE;AAJT,OAAP;AAMD;;;EA5B8CC,kB","sourcesContent":["import {Framebuffer, withParameters} from '@luma.gl/core';\nimport {_LayersPass as LayersPass, LayersPassRenderOptions} from '@deck.gl/core';\n\ntype CollisionFilterPassRenderOptions = LayersPassRenderOptions & {};\n\nexport default class CollisionFilterPass extends LayersPass {\n  renderCollisionMap(target: Framebuffer, options: CollisionFilterPassRenderOptions) {\n    const gl = this.gl;\n\n    const padding = 1;\n\n    return withParameters(\n      gl,\n      {\n        scissorTest: true,\n        scissor: [padding, padding, target.width - 2 * padding, target.height - 2 * padding],\n        clearColor: [0, 0, 0, 0],\n        blend: false,\n        depthTest: true,\n        depthRange: [0, 1]\n      },\n      () => this.render({...options, target, pass: 'collision'})\n    );\n  }\n\n  getModuleParameters() {\n    // Draw picking colors into collision FBO\n    return {\n      drawToCollisionMap: true,\n      pickingActive: 1,\n      pickingAttribute: false,\n      lightSources: {}\n    };\n  }\n}\n"],"file":"collision-filter-pass.js"}

package/dist/es5/{collide/collide.js → collision-filter/collision-filter.js}

@@ -23,36 +23,36 @@ var _core = require("@deck.gl/core");
 
 var _shaderModule = _interopRequireDefault(require("./shader-module"));
 
-var _collideEffect = _interopRequireDefault(require("./collide-effect"));
+var _collisionFilterEffect = _interopRequireDefault(require("./collision-filter-effect"));
 
 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 = {
-  getCollidePriority: {
+  getCollisionPriority: {
     type: 'accessor',
     value: 0
   },
-  collideEnabled: true,
-  collideGroup: {
+  collisionEnabled: true,
+  collisionGroup: {
     type: 'string',
     value: 'default'
   },
-  collideTestProps: {}
+  collisionTestProps: {}
 };
 
-var CollideExtension = function (_LayerExtension) {
-  (0, _inherits2.default)(CollideExtension, _LayerExtension);
+var CollisionFilterExtension = function (_LayerExtension) {
+  (0, _inherits2.default)(CollisionFilterExtension, _LayerExtension);
 
-  var _super = _createSuper(CollideExtension);
+  var _super = _createSuper(CollisionFilterExtension);
 
-  function CollideExtension() {
-    (0, _classCallCheck2.default)(this, CollideExtension);
+  function CollisionFilterExtension() {
+    (0, _classCallCheck2.default)(this, CollisionFilterExtension);
     return _super.apply(this, arguments);
   }
 
-  (0, _createClass2.default)(CollideExtension, [{
+  (0, _createClass2.default)(CollisionFilterExtension, [{
     key: "getShaders",
     value: function getShaders() {
       return {
@@ -65,14 +65,14 @@ var CollideExtension = function (_LayerExtension) {
       var uniforms = _ref.uniforms,
           context = _ref.context,
           moduleParameters = _ref.moduleParameters;
-      var collideEnabled = this.props.collideEnabled;
-      var collideFBO = moduleParameters.collideFBO,
-          drawToCollideMap = moduleParameters.drawToCollideMap;
-      var enabled = collideEnabled && Boolean(collideFBO);
-      uniforms.collide_enabled = enabled;
-
-      if (drawToCollideMap) {
-        this.props = this.clone(this.props.collideTestProps).props;
+      var collisionEnabled = this.props.collisionEnabled;
+      var collisionFBO = moduleParameters.collisionFBO,
+          drawToCollisionMap = moduleParameters.drawToCollisionMap;
+      var enabled = collisionEnabled && Boolean(collisionFBO);
+      uniforms.collision_enabled = enabled;
+
+      if (drawToCollisionMap) {
+        this.props = this.clone(this.props.collisionTestProps).props;
       }
     }
   }, {
@@ -84,17 +84,17 @@ var CollideExtension = function (_LayerExtension) {
         return;
       }
 
-      (_this$context$deck = this.context.deck) === null || _this$context$deck === void 0 ? void 0 : _this$context$deck._addDefaultEffect(new _collideEffect.default());
+      (_this$context$deck = this.context.deck) === null || _this$context$deck === void 0 ? void 0 : _this$context$deck._addDefaultEffect(new _collisionFilterEffect.default());
       var attributeManager = this.getAttributeManager();
       attributeManager.add({
-        collidePriorities: {
+        collisionPriorities: {
           size: 1,
-          accessor: 'getCollidePriority',
+          accessor: 'getCollisionPriority',
           shaderAttributes: {
-            collidePriorities: {
+            collisionPriorities: {
               divisor: 0
             },
-            instanceCollidePriorities: {
+            instanceCollisionPriorities: {
               divisor: 1
             }
           }
@@ -104,13 +104,13 @@ var CollideExtension = function (_LayerExtension) {
   }, {
     key: "getNeedsPickingBuffer",
     value: function getNeedsPickingBuffer() {
-      return this.props.collideEnabled;
+      return this.props.collisionEnabled;
     }
   }]);
-  return CollideExtension;
+  return CollisionFilterExtension;
 }(_core.LayerExtension);
 
-exports.default = CollideExtension;
-(0, _defineProperty2.default)(CollideExtension, "defaultProps", defaultProps);
-(0, _defineProperty2.default)(CollideExtension, "extensionName", 'CollideExtension');
-//# sourceMappingURL=collide.js.map
+exports.default = CollisionFilterExtension;
+(0, _defineProperty2.default)(CollisionFilterExtension, "defaultProps", defaultProps);
+(0, _defineProperty2.default)(CollisionFilterExtension, "extensionName", 'CollisionFilterExtension');
+//# sourceMappingURL=collision-filter.js.map

package/dist/es5/collision-filter/collision-filter.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/collision-filter/collision-filter.ts"],"names":["defaultProps","getCollisionPriority","type","value","collisionEnabled","collisionGroup","collisionTestProps","CollisionFilterExtension","modules","collision","uniforms","context","moduleParameters","props","collisionFBO","drawToCollisionMap","enabled","Boolean","collision_enabled","clone","extension","getAttributeManager","deck","_addDefaultEffect","CollisionFilterEffect","attributeManager","add","collisionPriorities","size","accessor","shaderAttributes","divisor","instanceCollisionPriorities","LayerExtension"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAAA;;AACA;;AACA;;;;;;AAEA,IAAMA,YAAY,GAAG;AACnBC,EAAAA,oBAAoB,EAAE;AAACC,IAAAA,IAAI,EAAE,UAAP;AAAmBC,IAAAA,KAAK,EAAE;AAA1B,GADH;AAEnBC,EAAAA,gBAAgB,EAAE,IAFC;AAGnBC,EAAAA,cAAc,EAAE;AAACH,IAAAA,IAAI,EAAE,QAAP;AAAiBC,IAAAA,KAAK,EAAE;AAAxB,GAHG;AAInBG,EAAAA,kBAAkB,EAAE;AAJD,CAArB;;IA+BqBC,wB;;;;;;;;;;;;WAInB,sBAA4D;AAC1D,aAAO;AAACC,QAAAA,OAAO,EAAE,CAACC,qBAAD;AAAV,OAAP;AACD;;;WAGD,oBAA6F;AAAA,UAA3CC,QAA2C,QAA3CA,QAA2C;AAAA,UAAjCC,OAAiC,QAAjCA,OAAiC;AAAA,UAAxBC,gBAAwB,QAAxBA,gBAAwB;AAC3F,UAAOR,gBAAP,GAA2B,KAAKS,KAAhC,CAAOT,gBAAP;AACA,UAAOU,YAAP,GAA2CF,gBAA3C,CAAOE,YAAP;AAAA,UAAqBC,kBAArB,GAA2CH,gBAA3C,CAAqBG,kBAArB;AACA,UAAMC,OAAO,GAAGZ,gBAAgB,IAAIa,OAAO,CAACH,YAAD,CAA3C;AACAJ,MAAAA,QAAQ,CAACQ,iBAAT,GAA6BF,OAA7B;;AAEA,UAAID,kBAAJ,EAAwB;AAGtB,aAAKF,KAAL,GAAa,KAAKM,KAAL,CAAW,KAAKN,KAAL,CAAWP,kBAAtB,EAA0CO,KAAvD;AACD;AACF;;;WAED,yBAEEF,OAFF,EAGES,SAHF,EAIE;AAAA;;AACA,UAAI,KAAKC,mBAAL,OAA+B,IAAnC,EAAyC;AACvC;AACD;;AACD,iCAAKV,OAAL,CAAaW,IAAb,0EAAmBC,iBAAnB,CAAqC,IAAIC,8BAAJ,EAArC;AACA,UAAMC,gBAAgB,GAAG,KAAKJ,mBAAL,EAAzB;AACAI,MAAAA,gBAAgB,CAAEC,GAAlB,CAAsB;AACpBC,QAAAA,mBAAmB,EAAE;AACnBC,UAAAA,IAAI,EAAE,CADa;AAEnBC,UAAAA,QAAQ,EAAE,sBAFS;AAGnBC,UAAAA,gBAAgB,EAAE;AAChBH,YAAAA,mBAAmB,EAAE;AAACI,cAAAA,OAAO,EAAE;AAAV,aADL;AAEhBC,YAAAA,2BAA2B,EAAE;AAACD,cAAAA,OAAO,EAAE;AAAV;AAFb;AAHC;AADD,OAAtB;AAUD;;;WAED,iCAA2E;AACzE,aAAO,KAAKlB,KAAL,CAAWT,gBAAlB;AACD;;;EA9CmD6B,oB;;;8BAAjC1B,wB,kBACGP,Y;8BADHO,wB,mBAEI,0B","sourcesContent":["import {Accessor, Layer, LayerContext, LayerExtension} from '@deck.gl/core';\nimport collision from './shader-module';\nimport CollisionFilterEffect from './collision-filter-effect';\n\nconst defaultProps = {\n  getCollisionPriority: {type: 'accessor', value: 0},\n  collisionEnabled: true,\n  collisionGroup: {type: 'string', value: 'default'},\n  collisionTestProps: {}\n};\n\nexport type CollisionFilterExtensionProps<DataT = any> = {\n  /**\n   * Accessor for collision priority. Must return a number in the range -1000 -> 1000. Features with higher values are shown preferentially.\n   */\n  getCollisionPriority?: Accessor<DataT, number>;\n\n  /**\n   * Enable/disable collisions. If collisions are disabled, all objects are rendered.\n   * @default true\n   */\n  collisionEnabled: boolean;\n\n  /**\n   * Collision group this layer belongs to. If it is not set, the 'default' collision group is used\n   */\n  collisionGroup?: string;\n\n  /**\n   * Props to override when rendering collision map\n   */\n  collisionTestProps?: {};\n};\n\n/** Allows layers to hide overlapping objects. */\nexport default class CollisionFilterExtension extends LayerExtension {\n  static defaultProps = defaultProps;\n  static extensionName = 'CollisionFilterExtension';\n\n  getShaders(this: Layer<CollisionFilterExtensionProps>): any {\n    return {modules: [collision]};\n  }\n\n  /* eslint-disable camelcase */\n  draw(this: Layer<CollisionFilterExtensionProps>, {uniforms, context, moduleParameters}: any) {\n    const {collisionEnabled} = this.props;\n    const {collisionFBO, drawToCollisionMap} = moduleParameters;\n    const enabled = collisionEnabled && Boolean(collisionFBO);\n    uniforms.collision_enabled = enabled;\n\n    if (drawToCollisionMap) {\n      // Override any props with those defined in collisionTestProps\n      // @ts-ignore\n      this.props = this.clone(this.props.collisionTestProps).props;\n    }\n  }\n\n  initializeState(\n    this: Layer<CollisionFilterExtensionProps>,\n    context: LayerContext,\n    extension: this\n  ) {\n    if (this.getAttributeManager() === null) {\n      return;\n    }\n    this.context.deck?._addDefaultEffect(new CollisionFilterEffect());\n    const attributeManager = this.getAttributeManager();\n    attributeManager!.add({\n      collisionPriorities: {\n        size: 1,\n        accessor: 'getCollisionPriority',\n        shaderAttributes: {\n          collisionPriorities: {divisor: 0},\n          instanceCollisionPriorities: {divisor: 1}\n        }\n      }\n    });\n  }\n\n  getNeedsPickingBuffer(this: Layer<CollisionFilterExtensionProps>): boolean {\n    return this.props.collisionEnabled;\n  }\n}\n"],"file":"collision-filter.js"}

package/dist/es5/collision-filter/shader-module.js

@@ -0,0 +1,39 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _core = require("@deck.gl/core");
+
+var vs = "\n#ifdef NON_INSTANCED_MODEL\nattribute float collisionPriorities;\n#else\nattribute float instanceCollisionPriorities;\n#endif\n\nuniform sampler2D collision_texture;\nuniform bool collision_sort;\nuniform bool collision_enabled;\n\nvec2 collision_getCoords(vec4 position) {\n  vec4 collision_clipspace = project_common_position_to_clipspace(position);\n  return (1.0 + collision_clipspace.xy / collision_clipspace.w) / 2.0;\n}\n\nfloat collision_match(vec2 tex, vec3 pickingColor) {\n  vec4 collision_pickingColor = texture2D(collision_texture, tex);\n  float delta = dot(abs(collision_pickingColor.rgb - pickingColor), vec3(1.0));\n  float e = 0.001;\n  return step(delta, e);\n}\n\nfloat collision_isVisible(vec2 texCoords, vec3 pickingColor) {\n  if (!collision_enabled) {\n    return 1.0;\n  }\n\n  // Visibility test, sample area of 5x5 pixels in order to fade in/out.\n  // Due to the locality, the lookups will be cached\n  // This reduces the flicker present when objects are shown/hidden\n  const int N = 2;\n  float accumulator = 0.0;\n  vec2 step = vec2(1.0 / project_uViewportSize);\n\n  const float floatN = float(N);\n  vec2 delta = -floatN * step;\n  for(int i = -N; i <= N; i++) {\n    delta.x = -step.x * floatN;\n    for(int j = -N; j <= N; j++) {\n      accumulator += collision_match(texCoords + delta, pickingColor);\n      delta.x += step.x;\n    }\n    delta.y += step.y;\n  }\n\n  float W = 2.0 * floatN + 1.0;\n  return pow(accumulator / (W * W), 2.2);\n}\n";
+var inject = {
+  'vs:#decl': "\n  float collision_fade = 1.0;\n",
+  'vs:DECKGL_FILTER_GL_POSITION': "\n  if (collision_sort) {\n    #ifdef NON_INSTANCED_MODEL\n    float collisionPriority = collisionPriorities;\n    #else\n    float collisionPriority = instanceCollisionPriorities;\n    #endif\n    position.z = -0.001 * collisionPriority * position.w; // Support range -1000 -> 1000\n  }\n\n  if (collision_enabled) {\n    vec4 collision_common_position = project_position(vec4(geometry.worldPosition, 1.0));\n    vec2 collision_texCoords = collision_getCoords(collision_common_position);\n    collision_fade = collision_isVisible(collision_texCoords, geometry.pickingColor / 255.0);\n    if (collision_fade < 0.0001) {\n      position = vec4(0.);\n    }\n  }\n  ",
+  'vs:DECKGL_FILTER_COLOR': "\n  color.a *= collision_fade;\n  "
+};
+
+var getCollisionUniforms = function getCollisionUniforms(opts, uniforms) {
+  if (!opts || !('dummyCollisionMap' in opts)) {
+    return {};
+  }
+
+  var collisionFBO = opts.collisionFBO,
+      drawToCollisionMap = opts.drawToCollisionMap,
+      dummyCollisionMap = opts.dummyCollisionMap;
+  return {
+    collision_sort: Boolean(drawToCollisionMap),
+    collision_texture: !drawToCollisionMap && collisionFBO ? collisionFBO : dummyCollisionMap
+  };
+};
+
+var _default = {
+  name: 'collision',
+  dependencies: [_core.project],
+  vs: vs,
+  inject: inject,
+  getUniforms: getCollisionUniforms
+};
+exports.default = _default;
+//# sourceMappingURL=shader-module.js.map

package/dist/es5/collision-filter/shader-module.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/collision-filter/shader-module.ts"],"names":["vs","inject","getCollisionUniforms","opts","uniforms","collisionFBO","drawToCollisionMap","dummyCollisionMap","collision_sort","Boolean","collision_texture","name","dependencies","project","getUniforms"],"mappings":";;;;;;;AACA;;AAGA,IAAMA,EAAE,i9CAAR;AAmDA,IAAMC,MAAM,GAAG;AACb,iDADa;AAIb,2rBAJa;AAuBb;AAvBa,CAAf;;AAqCA,IAAMC,oBAAoB,GAAG,SAAvBA,oBAAuB,CAC3BC,IAD2B,EAE3BC,QAF2B,EAGL;AACtB,MAAI,CAACD,IAAD,IAAS,EAAE,uBAAuBA,IAAzB,CAAb,EAA6C;AAC3C,WAAO,EAAP;AACD;;AACD,MAAOE,YAAP,GAA8DF,IAA9D,CAAOE,YAAP;AAAA,MAAqBC,kBAArB,GAA8DH,IAA9D,CAAqBG,kBAArB;AAAA,MAAyCC,iBAAzC,GAA8DJ,IAA9D,CAAyCI,iBAAzC;AACA,SAAO;AACLC,IAAAA,cAAc,EAAEC,OAAO,CAACH,kBAAD,CADlB;AAELI,IAAAA,iBAAiB,EAAE,CAACJ,kBAAD,IAAuBD,YAAvB,GAAsCA,YAAtC,GAAqDE;AAFnE,GAAP;AAID,CAZD;;eAce;AACbI,EAAAA,IAAI,EAAE,WADO;AAEbC,EAAAA,YAAY,EAAE,CAACC,aAAD,CAFD;AAGbb,EAAAA,EAAE,EAAFA,EAHa;AAIbC,EAAAA,MAAM,EAANA,MAJa;AAKba,EAAAA,WAAW,EAAEZ;AALA,C","sourcesContent":["import {Framebuffer, Texture2D} from '@luma.gl/core';\nimport {project} from '@deck.gl/core';\nimport type {_ShaderModule as ShaderModule} from '@deck.gl/core';\n\nconst vs = `\n#ifdef NON_INSTANCED_MODEL\nattribute float collisionPriorities;\n#else\nattribute float instanceCollisionPriorities;\n#endif\n\nuniform sampler2D collision_texture;\nuniform bool collision_sort;\nuniform bool collision_enabled;\n\nvec2 collision_getCoords(vec4 position) {\n  vec4 collision_clipspace = project_common_position_to_clipspace(position);\n  return (1.0 + collision_clipspace.xy / collision_clipspace.w) / 2.0;\n}\n\nfloat collision_match(vec2 tex, vec3 pickingColor) {\n  vec4 collision_pickingColor = texture2D(collision_texture, tex);\n  float delta = dot(abs(collision_pickingColor.rgb - pickingColor), vec3(1.0));\n  float e = 0.001;\n  return step(delta, e);\n}\n\nfloat collision_isVisible(vec2 texCoords, vec3 pickingColor) {\n  if (!collision_enabled) {\n    return 1.0;\n  }\n\n  // Visibility test, sample area of 5x5 pixels in order to fade in/out.\n  // Due to the locality, the lookups will be cached\n  // This reduces the flicker present when objects are shown/hidden\n  const int N = 2;\n  float accumulator = 0.0;\n  vec2 step = vec2(1.0 / project_uViewportSize);\n\n  const float floatN = float(N);\n  vec2 delta = -floatN * step;\n  for(int i = -N; i <= N; i++) {\n    delta.x = -step.x * floatN;\n    for(int j = -N; j <= N; j++) {\n      accumulator += collision_match(texCoords + delta, pickingColor);\n      delta.x += step.x;\n    }\n    delta.y += step.y;\n  }\n\n  float W = 2.0 * floatN + 1.0;\n  return pow(accumulator / (W * W), 2.2);\n}\n`;\n\nconst inject = {\n  'vs:#decl': `\n  float collision_fade = 1.0;\n`,\n  'vs:DECKGL_FILTER_GL_POSITION': `\n  if (collision_sort) {\n    #ifdef NON_INSTANCED_MODEL\n    float collisionPriority = collisionPriorities;\n    #else\n    float collisionPriority = instanceCollisionPriorities;\n    #endif\n    position.z = -0.001 * collisionPriority * position.w; // Support range -1000 -> 1000\n  }\n\n  if (collision_enabled) {\n    vec4 collision_common_position = project_position(vec4(geometry.worldPosition, 1.0));\n    vec2 collision_texCoords = collision_getCoords(collision_common_position);\n    collision_fade = collision_isVisible(collision_texCoords, geometry.pickingColor / 255.0);\n    if (collision_fade < 0.0001) {\n      position = vec4(0.);\n    }\n  }\n  `,\n  'vs:DECKGL_FILTER_COLOR': `\n  color.a *= collision_fade;\n  `\n};\n\ntype CollisionModuleSettings = {\n  collisionFBO?: Framebuffer;\n  drawToCollisionMap?: boolean;\n  dummyCollisionMap?: Texture2D;\n};\n\n/* eslint-disable camelcase */\ntype CollisionUniforms = {collision_sort?: boolean; collision_texture?: Framebuffer | Texture2D};\n\nconst getCollisionUniforms = (\n  opts: CollisionModuleSettings | {},\n  uniforms: Record<string, any>\n): CollisionUniforms => {\n  if (!opts || !('dummyCollisionMap' in opts)) {\n    return {};\n  }\n  const {collisionFBO, drawToCollisionMap, dummyCollisionMap} = opts;\n  return {\n    collision_sort: Boolean(drawToCollisionMap),\n    collision_texture: !drawToCollisionMap && collisionFBO ? collisionFBO : dummyCollisionMap\n  };\n};\n\nexport default {\n  name: 'collision',\n  dependencies: [project],\n  vs,\n  inject,\n  getUniforms: getCollisionUniforms\n} as ShaderModule;\n"],"file":"shader-module.js"}

package/dist/es5/index.js

@@ -41,10 +41,10 @@ Object.defineProperty(exports, "ClipExtension", {
     return _clip.default;
   }
 });
-Object.defineProperty(exports, "CollideExtension", {
+Object.defineProperty(exports, "CollisionFilterExtension", {
   enumerable: true,
   get: function get() {
-    return _collide.default;
+    return _collisionFilter.default;
   }
 });
 Object.defineProperty(exports, "MaskExtension", {
@@ -53,7 +53,7 @@ Object.defineProperty(exports, "MaskExtension", {
     return _mask.default;
   }
 });
-Object.defineProperty(exports, "TerrainExtension", {
+Object.defineProperty(exports, "_TerrainExtension", {
   enumerable: true,
   get: function get() {
     return _terrain.default;
@@ -78,7 +78,7 @@ var _fillStyle = _interopRequireDefault(require("./fill-style/fill-style"));
 
 var _clip = _interopRequireDefault(require("./clip/clip"));
 
-var _collide = _interopRequireDefault(require("./collide/collide"));
+var _collisionFilter = _interopRequireDefault(require("./collision-filter/collision-filter"));
 
 var _mask = _interopRequireDefault(require("./mask/mask"));
 

package/dist/es5/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AAGA","sourcesContent":["export {default as BrushingExtension} from './brushing/brushing';\nexport {default as DataFilterExtension} from './data-filter/data-filter';\nexport {default as Fp64Extension} from './fp64/fp64';\nexport {default as PathStyleExtension} from './path-style/path-style';\nexport {default as FillStyleExtension} from './fill-style/fill-style';\nexport {default as ClipExtension} from './clip/clip';\nexport {default as CollideExtension} from './collide/collide';\nexport {default as MaskExtension} from './mask/mask';\nexport {default as TerrainExtension} from './terrain/terrain';\n\n// Shader module\nexport {default as project64} from './fp64/project64';\n\n// Types\nexport type {BrushingExtensionProps} from './brushing/brushing';\nexport type {DataFilterExtensionProps} from './data-filter/data-filter';\nexport type {PathStyleExtensionProps} from './path-style/path-style';\nexport type {FillStyleExtensionProps} from './fill-style/fill-style';\nexport type {ClipExtensionProps} from './clip/clip';\nexport type {CollideExtensionProps} from './collide/collide';\nexport type {MaskExtensionProps} from './mask/mask';\nexport type {TerrainExtensionProps} from './terrain/terrain';\n"],"file":"index.js"}
+{"version":3,"sources":["../../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AAGA","sourcesContent":["export {default as BrushingExtension} from './brushing/brushing';\nexport {default as DataFilterExtension} from './data-filter/data-filter';\nexport {default as Fp64Extension} from './fp64/fp64';\nexport {default as PathStyleExtension} from './path-style/path-style';\nexport {default as FillStyleExtension} from './fill-style/fill-style';\nexport {default as ClipExtension} from './clip/clip';\nexport {default as CollisionFilterExtension} from './collision-filter/collision-filter';\nexport {default as MaskExtension} from './mask/mask';\nexport {default as _TerrainExtension} from './terrain/terrain';\n\n// Shader module\nexport {default as project64} from './fp64/project64';\n\n// Types\nexport type {BrushingExtensionProps} from './brushing/brushing';\nexport type {DataFilterExtensionProps} from './data-filter/data-filter';\nexport type {PathStyleExtensionProps} from './path-style/path-style';\nexport type {FillStyleExtensionProps} from './fill-style/fill-style';\nexport type {ClipExtensionProps} from './clip/clip';\nexport type {CollisionFilterExtensionProps} from './collision-filter/collision-filter';\nexport type {MaskExtensionProps} from './mask/mask';\nexport type {TerrainExtensionProps} from './terrain/terrain';\n"],"file":"index.js"}