@loaders.gl/tiles 3.1.8 → 3.2.0-alpha.3

package/dist/es5/tileset/tileset-3d.js

@@ -9,6 +9,8 @@ exports.default = void 0;
 
 var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
 
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+
 var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
 
 var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
@@ -60,6 +62,8 @@ var DEFAULT_PROPS = {
   throttleRequests: true,
   maxRequests: 64,
   maximumMemoryUsage: 32,
+  maximumTilesSelected: 0,
+  debounceTime: 0,
   onTileLoad: function onTileLoad() {},
   onTileUnload: function onTileUnload() {},
   onTileError: function onTileError() {},
@@ -87,7 +91,7 @@ var TILES_LOADED = 'Tiles Loaded';
 var TILES_LOADING = 'Tiles Loading';
 var TILES_UNLOADED = 'Tiles Unloaded';
 var TILES_LOAD_FAILED = 'Failed Tile Loads';
-var POINTS_COUNT = 'Points';
+var POINTS_COUNT = 'Points/Vertices';
 var TILES_GPU_MEMORY = 'Tile Memory Use';
 
 var Tileset3D = function () {
@@ -117,6 +121,8 @@ var Tileset3D = function () {
     (0, _defineProperty2.default)(this, "traverseCounter", void 0);
     (0, _defineProperty2.default)(this, "geometricError", void 0);
     (0, _defineProperty2.default)(this, "selectedTiles", void 0);
+    (0, _defineProperty2.default)(this, "updatePromise", null);
+    (0, _defineProperty2.default)(this, "tilesetInitializationPromise", void 0);
     (0, _defineProperty2.default)(this, "cartographicCenter", void 0);
     (0, _defineProperty2.default)(this, "cartesianCenter", void 0);
     (0, _defineProperty2.default)(this, "zoom", void 0);
@@ -188,8 +194,7 @@ var Tileset3D = function () {
     this.asset = {};
     this.credits = {};
     this.description = this.options.description || '';
-
-    this._initializeTileSet(json);
+    this.tilesetInitializationPromise = this._initializeTileSet(json);
   }
 
   (0, _createClass2.default)(Tileset3D, [{
@@ -249,7 +254,73 @@ var Tileset3D = function () {
     }
   }, {
     key: "update",
-    value: function update(viewports) {
+    value: function update() {
+      var _this = this;
+
+      var viewports = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
+      this.tilesetInitializationPromise.then(function () {
+        if (!viewports && _this.lastUpdatedVieports) {
+          viewports = _this.lastUpdatedVieports;
+        } else {
+          _this.lastUpdatedVieports = viewports;
+        }
+
+        _this.doUpdate(viewports);
+      });
+    }
+  }, {
+    key: "selectTiles",
+    value: function () {
+      var _selectTiles = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee() {
+        var _this2 = this;
+
+        var viewports,
+            _args = arguments;
+        return _regenerator.default.wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                viewports = _args.length > 0 && _args[0] !== undefined ? _args[0] : null;
+                _context.next = 3;
+                return this.tilesetInitializationPromise;
+
+              case 3:
+                if (viewports) {
+                  this.lastUpdatedVieports = viewports;
+                }
+
+                if (!this.updatePromise) {
+                  this.updatePromise = new Promise(function (resolve) {
+                    setTimeout(function () {
+                      _this2.doUpdate(_this2.lastUpdatedVieports);
+
+                      resolve(_this2._frameNumber);
+                      _this2.updatePromise = null;
+                    }, _this2.options.debounceTime);
+                  });
+                }
+
+                return _context.abrupt("return", this.updatePromise);
+
+              case 6:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee, this);
+      }));
+
+      function selectTiles() {
+        return _selectTiles.apply(this, arguments);
+      }
+
+      return selectTiles;
+    }()
+  }, {
+    key: "doUpdate",
+    value: function doUpdate() {
+      var viewports = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
+
       if ('loadTiles' in this.options && !this.options.loadTiles) {
         return;
       }
@@ -258,12 +329,6 @@ var Tileset3D = function () {
         return;
       }
 
-      if (!viewports && this.lastUpdatedVieports) {
-        viewports = this.lastUpdatedVieports;
-      } else {
-        this.lastUpdatedVieports = viewports;
-      }
-
       if (!(viewports instanceof Array)) {
         viewports = [viewports];
       }
@@ -350,7 +415,29 @@ var Tileset3D = function () {
 
       var currentFrameStateData = this.frameStateData[id];
       var selectedTiles = Object.values(this._traverser.selectedTiles);
-      currentFrameStateData.selectedTiles = selectedTiles;
+
+      var _limitSelectedTiles = (0, _frameState.limitSelectedTiles)(selectedTiles, frameState, this.options.maximumTilesSelected),
+          _limitSelectedTiles2 = (0, _slicedToArray2.default)(_limitSelectedTiles, 2),
+          filteredSelectedTiles = _limitSelectedTiles2[0],
+          unselectedTiles = _limitSelectedTiles2[1];
+
+      currentFrameStateData.selectedTiles = filteredSelectedTiles;
+
+      var _iterator3 = _createForOfIteratorHelper(unselectedTiles),
+          _step3;
+
+      try {
+        for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+          var _tile = _step3.value;
+
+          _tile.unselect();
+        }
+      } catch (err) {
+        _iterator3.e(err);
+      } finally {
+        _iterator3.f();
+      }
+
       currentFrameStateData._requestedTiles = Object.values(this._traverser.requestedTiles);
       currentFrameStateData._emptyTiles = Object.values(this._traverser.emptyTiles);
       this.traverseCounter--;
@@ -377,18 +464,18 @@ var Tileset3D = function () {
 
       this.selectedTiles = this.options.onTraversalComplete(this.selectedTiles);
 
-      var _iterator3 = _createForOfIteratorHelper(this.selectedTiles),
-          _step3;
+      var _iterator4 = _createForOfIteratorHelper(this.selectedTiles),
+          _step4;
 
       try {
-        for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
-          var _tile = _step3.value;
-          this._tiles[_tile.id] = _tile;
+        for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+          var _tile2 = _step4.value;
+          this._tiles[_tile2.id] = _tile2;
         }
       } catch (err) {
-        _iterator3.e(err);
+        _iterator4.e(err);
       } finally {
-        _iterator3.f();
+        _iterator4.f();
       }
 
       this._loadTiles();
@@ -421,21 +508,21 @@ var Tileset3D = function () {
   }, {
     key: "_loadTiles",
     value: function _loadTiles() {
-      var _iterator4 = _createForOfIteratorHelper(this._requestedTiles),
-          _step4;
+      var _iterator5 = _createForOfIteratorHelper(this._requestedTiles),
+          _step5;
 
       try {
-        for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
-          var _tile2 = _step4.value;
+        for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+          var _tile3 = _step5.value;
 
-          if (_tile2.contentUnloaded) {
-            this._loadTile(_tile2);
+          if (_tile3.contentUnloaded) {
+            this._loadTile(_tile3);
           }
         }
       } catch (err) {
-        _iterator4.e(err);
+        _iterator5.e(err);
       } finally {
-        _iterator4.f();
+        _iterator5.f();
       }
     }
   }, {
@@ -451,25 +538,27 @@ var Tileset3D = function () {
       var tilesRenderable = 0;
       var pointsRenderable = 0;
 
-      var _iterator5 = _createForOfIteratorHelper(this.selectedTiles),
-          _step5;
+      var _iterator6 = _createForOfIteratorHelper(this.selectedTiles),
+          _step6;
 
       try {
-        for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
-          var _tile3 = _step5.value;
+        for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
+          var _tile4 = _step6.value;
 
-          if (_tile3.contentAvailable && _tile3.content) {
+          if (_tile4.contentAvailable && _tile4.content) {
             tilesRenderable++;
 
-            if (_tile3.content.pointCount) {
-              pointsRenderable += _tile3.content.pointCount;
+            if (_tile4.content.pointCount) {
+              pointsRenderable += _tile4.content.pointCount;
+            } else {
+              pointsRenderable += _tile4.content.vertexCount;
             }
           }
         }
       } catch (err) {
-        _iterator5.e(err);
+        _iterator6.e(err);
       } finally {
-        _iterator5.f();
+        _iterator6.f();
       }
 
       this.stats.get(TILES_IN_VIEW).count = this.selectedTiles.length;
@@ -478,22 +567,94 @@ var Tileset3D = function () {
     }
   }, {
     key: "_initializeTileSet",
-    value: function _initializeTileSet(tilesetJson) {
-      this.root = this._initializeTileHeaders(tilesetJson, null);
+    value: function () {
+      var _initializeTileSet2 = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee2(tilesetJson) {
+        return _regenerator.default.wrap(function _callee2$(_context2) {
+          while (1) {
+            switch (_context2.prev = _context2.next) {
+              case 0:
+                if (!(this.type === _constants.TILESET_TYPE.I3S)) {
+                  _context2.next = 5;
+                  break;
+                }
 
-      if (this.type === _constants.TILESET_TYPE.TILES3D) {
-        this._initializeCesiumTileset(tilesetJson);
+                this.calculateViewPropsI3S();
+                _context2.next = 4;
+                return tilesetJson.root;
+
+              case 4:
+                tilesetJson.root = _context2.sent;
+
+              case 5:
+                this.root = this._initializeTileHeaders(tilesetJson, null);
+
+                if (this.type === _constants.TILESET_TYPE.TILES3D) {
+                  this._initializeTiles3DTileset(tilesetJson);
+
+                  this.calculateViewPropsTiles3D();
+                }
+
+                if (this.type === _constants.TILESET_TYPE.I3S) {
+                  this._initializeI3STileset();
+                }
+
+              case 8:
+              case "end":
+                return _context2.stop();
+            }
+          }
+        }, _callee2, this);
+      }));
+
+      function _initializeTileSet(_x) {
+        return _initializeTileSet2.apply(this, arguments);
+      }
+
+      return _initializeTileSet;
+    }()
+  }, {
+    key: "calculateViewPropsI3S",
+    value: function calculateViewPropsI3S() {
+      var _this$tileset$store;
+
+      var fullExtent = this.tileset.fullExtent;
+
+      if (fullExtent) {
+        var xmin = fullExtent.xmin,
+            xmax = fullExtent.xmax,
+            ymin = fullExtent.ymin,
+            ymax = fullExtent.ymax,
+            zmin = fullExtent.zmin,
+            zmax = fullExtent.zmax;
+        this.cartographicCenter = new _core.Vector3(xmin + (xmax - xmin) / 2, ymin + (ymax - ymin) / 2, zmin + (zmax - zmin) / 2);
+        this.cartesianCenter = _geospatial.Ellipsoid.WGS84.cartographicToCartesian(this.cartographicCenter, new _core.Vector3());
+        this.zoom = (0, _zoom.getZoomFromFullExtent)(fullExtent, this.cartographicCenter, this.cartesianCenter);
+        return;
       }
 
-      if (this.type === _constants.TILESET_TYPE.I3S) {
-        this._initializeI3STileset();
+      var extent = (_this$tileset$store = this.tileset.store) === null || _this$tileset$store === void 0 ? void 0 : _this$tileset$store.extent;
+
+      if (extent) {
+        var _extent = (0, _slicedToArray2.default)(extent, 4),
+            _xmin = _extent[0],
+            _ymin = _extent[1],
+            _xmax = _extent[2],
+            _ymax = _extent[3];
+
+        this.cartographicCenter = new _core.Vector3(_xmin + (_xmax - _xmin) / 2, _ymin + (_ymax - _ymin) / 2, 0);
+        this.cartesianCenter = _geospatial.Ellipsoid.WGS84.cartographicToCartesian(this.cartographicCenter, new _core.Vector3());
+        this.zoom = (0, _zoom.getZoomFromExtent)(extent, this.cartographicCenter, this.cartesianCenter);
+        return;
       }
 
-      this._calculateViewProps();
+      console.warn('Extent is not defined in the tileset header');
+      this.cartographicCenter = new _core.Vector3();
+      this.zoom = 1;
+      return;
     }
   }, {
-    key: "_calculateViewProps",
-    value: function _calculateViewProps() {
+    key: "calculateViewPropsTiles3D",
+    value: function calculateViewPropsTiles3D() {
       var root = this.root;
       (0, _loaderUtils.assert)(root);
       var center = root.boundingVolume.center;
@@ -538,28 +699,28 @@ var Tileset3D = function () {
         stack.push(rootTile);
 
         while (stack.length > 0) {
-          var _tile4 = stack.pop();
+          var _tile5 = stack.pop();
 
           this.stats.get(TILES_TOTAL).incrementCount();
-          var children = _tile4.header.children || [];
+          var children = _tile5.header.children || [];
 
-          var _iterator6 = _createForOfIteratorHelper(children),
-              _step6;
+          var _iterator7 = _createForOfIteratorHelper(children),
+              _step7;
 
           try {
-            for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
-              var childHeader = _step6.value;
-              var childTile = new _tile3d.default(this, childHeader, _tile4);
+            for (_iterator7.s(); !(_step7 = _iterator7.n()).done;) {
+              var childHeader = _step7.value;
+              var childTile = new _tile3d.default(this, childHeader, _tile5);
 
-              _tile4.children.push(childTile);
+              _tile5.children.push(childTile);
 
-              childTile.depth = _tile4.depth + 1;
+              childTile.depth = _tile5.depth + 1;
               stack.push(childTile);
             }
           } catch (err) {
-            _iterator6.e(err);
+            _iterator7.e(err);
           } finally {
-            _iterator6.f();
+            _iterator7.f();
           }
         }
       }
@@ -598,48 +759,48 @@ var Tileset3D = function () {
   }, {
     key: "_loadTile",
     value: function () {
-      var _loadTile2 = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee(tile) {
+      var _loadTile2 = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee3(tile) {
         var loaded;
-        return _regenerator.default.wrap(function _callee$(_context) {
+        return _regenerator.default.wrap(function _callee3$(_context3) {
           while (1) {
-            switch (_context.prev = _context.next) {
+            switch (_context3.prev = _context3.next) {
               case 0:
-                _context.prev = 0;
+                _context3.prev = 0;
 
                 this._onStartTileLoading();
 
-                _context.next = 4;
+                _context3.next = 4;
                 return tile.loadContent();
 
               case 4:
-                loaded = _context.sent;
-                _context.next = 10;
+                loaded = _context3.sent;
+                _context3.next = 10;
                 break;
 
               case 7:
-                _context.prev = 7;
-                _context.t0 = _context["catch"](0);
+                _context3.prev = 7;
+                _context3.t0 = _context3["catch"](0);
 
-                this._onTileLoadError(tile, _context.t0);
+                this._onTileLoadError(tile, _context3.t0);
 
               case 10:
-                _context.prev = 10;
+                _context3.prev = 10;
 
                 this._onEndTileLoading();
 
                 this._onTileLoad(tile, loaded);
 
-                return _context.finish(10);
+                return _context3.finish(10);
 
               case 14:
               case "end":
-                return _context.stop();
+                return _context3.stop();
             }
           }
-        }, _callee, this, [[0, 7, 10, 14]]);
+        }, _callee3, this, [[0, 7, 10, 14]]);
       }));
 
-      function _loadTile(_x) {
+      function _loadTile(_x2) {
         return _loadTile2.apply(this, arguments);
       }
 
@@ -716,23 +877,23 @@ var Tileset3D = function () {
       }
 
       while (stack.length > 0) {
-        var _tile5 = stack.pop();
+        var _tile6 = stack.pop();
 
-        var _iterator7 = _createForOfIteratorHelper(_tile5.children),
-            _step7;
+        var _iterator8 = _createForOfIteratorHelper(_tile6.children),
+            _step8;
 
         try {
-          for (_iterator7.s(); !(_step7 = _iterator7.n()).done;) {
-            var child = _step7.value;
+          for (_iterator8.s(); !(_step8 = _iterator8.n()).done;) {
+            var child = _step8.value;
             stack.push(child);
           }
         } catch (err) {
-          _iterator7.e(err);
+          _iterator8.e(err);
         } finally {
-          _iterator7.f();
+          _iterator8.f();
         }
 
-        this._destroyTile(_tile5);
+        this._destroyTile(_tile6);
       }
 
       this.root = null;
@@ -747,18 +908,18 @@ var Tileset3D = function () {
       while (stack.length > 0) {
         tile = stack.pop();
 
-        var _iterator8 = _createForOfIteratorHelper(tile.children),
-            _step8;
+        var _iterator9 = _createForOfIteratorHelper(tile.children),
+            _step9;
 
         try {
-          for (_iterator8.s(); !(_step8 = _iterator8.n()).done;) {
-            var child = _step8.value;
+          for (_iterator9.s(); !(_step9 = _iterator9.n()).done;) {
+            var child = _step9.value;
             stack.push(child);
           }
         } catch (err) {
-          _iterator8.e(err);
+          _iterator9.e(err);
         } finally {
-          _iterator8.f();
+          _iterator9.f();
         }
 
         if (tile !== root) {
@@ -778,8 +939,8 @@ var Tileset3D = function () {
       tile.destroy();
     }
   }, {
-    key: "_initializeCesiumTileset",
-    value: function _initializeCesiumTileset(tilesetJson) {
+    key: "_initializeTiles3DTileset",
+    value: function _initializeTiles3DTileset(tilesetJson) {
       this.asset = tilesetJson.asset;
 
       if (!this.asset) {