@loaders.gl/tiles 3.0.9 → 3.0.13

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

@@ -7,14 +7,6 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 
-var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
-
-var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
-
-var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
-
-var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
-
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
 
 var _core = require("@math.gl/core");
@@ -35,20 +27,14 @@ var _dTilesOptions = require("./helpers/3d-tiles-options");
 
 var _tilesetTraverser = _interopRequireDefault(require("./traversers/tileset-traverser"));
 
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
-
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
-
-var scratchVector = new _core.Vector3();
+const scratchVector = new _core.Vector3();
 
 function defined(x) {
   return x !== undefined && x !== null;
 }
 
-var TileHeader = function () {
-  function TileHeader(tileset, header, parentHeader) {
-    var extendedId = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : '';
-    (0, _classCallCheck2.default)(this, TileHeader);
+class TileHeader {
+  constructor(tileset, header, parentHeader, extendedId = '') {
     (0, _defineProperty2.default)(this, "tileset", void 0);
     (0, _defineProperty2.default)(this, "header", void 0);
     (0, _defineProperty2.default)(this, "id", void 0);
@@ -150,454 +136,375 @@ var TileHeader = function () {
     Object.seal(this);
   }
 
-  (0, _createClass2.default)(TileHeader, [{
-    key: "destroy",
-    value: function destroy() {
-      this.header = null;
-    }
-  }, {
-    key: "isDestroyed",
-    value: function isDestroyed() {
-      return this.header === null;
-    }
-  }, {
-    key: "selected",
-    get: function get() {
-      return this._selectedFrame === this.tileset._frameNumber;
-    }
-  }, {
-    key: "isVisible",
-    get: function get() {
-      return this._visible;
-    }
-  }, {
-    key: "isVisibleAndInRequestVolume",
-    get: function get() {
-      return this._visible && this._inRequestVolume;
-    }
-  }, {
-    key: "hasRenderContent",
-    get: function get() {
-      return !this.hasEmptyContent && !this.hasTilesetContent;
-    }
-  }, {
-    key: "hasChildren",
-    get: function get() {
-      return this.children.length > 0 || this.header.children && this.header.children.length > 0;
-    }
-  }, {
-    key: "contentReady",
-    get: function get() {
-      return this.contentState === _constants.TILE_CONTENT_STATE.READY || this.hasEmptyContent;
-    }
-  }, {
-    key: "contentAvailable",
-    get: function get() {
-      return Boolean(this.contentReady && this.hasRenderContent || this._expiredContent && !this.contentFailed);
-    }
-  }, {
-    key: "hasUnloadedContent",
-    get: function get() {
-      return this.hasRenderContent && this.contentUnloaded;
-    }
-  }, {
-    key: "contentUnloaded",
-    get: function get() {
-      return this.contentState === _constants.TILE_CONTENT_STATE.UNLOADED;
+  destroy() {
+    this.header = null;
+  }
+
+  isDestroyed() {
+    return this.header === null;
+  }
+
+  get selected() {
+    return this._selectedFrame === this.tileset._frameNumber;
+  }
+
+  get isVisible() {
+    return this._visible;
+  }
+
+  get isVisibleAndInRequestVolume() {
+    return this._visible && this._inRequestVolume;
+  }
+
+  get hasRenderContent() {
+    return !this.hasEmptyContent && !this.hasTilesetContent;
+  }
+
+  get hasChildren() {
+    return this.children.length > 0 || this.header.children && this.header.children.length > 0;
+  }
+
+  get contentReady() {
+    return this.contentState === _constants.TILE_CONTENT_STATE.READY || this.hasEmptyContent;
+  }
+
+  get contentAvailable() {
+    return Boolean(this.contentReady && this.hasRenderContent || this._expiredContent && !this.contentFailed);
+  }
+
+  get hasUnloadedContent() {
+    return this.hasRenderContent && this.contentUnloaded;
+  }
+
+  get contentUnloaded() {
+    return this.contentState === _constants.TILE_CONTENT_STATE.UNLOADED;
+  }
+
+  get contentExpired() {
+    return this.contentState === _constants.TILE_CONTENT_STATE.EXPIRED;
+  }
+
+  get contentFailed() {
+    return this.contentState === _constants.TILE_CONTENT_STATE.FAILED;
+  }
+
+  getScreenSpaceError(frameState, useParentLodMetric) {
+    switch (this.tileset.type) {
+      case _constants.TILESET_TYPE.I3S:
+        return (0, _i3sLod.getI3ScreenSize)(this, frameState);
+
+      case _constants.TILESET_TYPE.TILES3D:
+        return (0, _tiles3dLod.getTiles3DScreenSpaceError)(this, frameState, useParentLodMetric);
+
+      default:
+        throw new Error('Unsupported tileset type');
     }
-  }, {
-    key: "contentExpired",
-    get: function get() {
-      return this.contentState === _constants.TILE_CONTENT_STATE.EXPIRED;
+  }
+
+  _getPriority() {
+    const traverser = this.tileset._traverser;
+    const {
+      skipLevelOfDetail
+    } = traverser.options;
+    const maySkipTile = this.refine === _constants.TILE_REFINEMENT.ADD || skipLevelOfDetail;
+
+    if (maySkipTile && !this.isVisible && this._visible !== undefined) {
+      return -1;
     }
-  }, {
-    key: "contentFailed",
-    get: function get() {
-      return this.contentState === _constants.TILE_CONTENT_STATE.FAILED;
+
+    if (this.tileset._frameNumber - this._touchedFrame >= 1) {
+      return -1;
     }
-  }, {
-    key: "getScreenSpaceError",
-    value: function getScreenSpaceError(frameState, useParentLodMetric) {
-      switch (this.tileset.type) {
-        case _constants.TILESET_TYPE.I3S:
-          return (0, _i3sLod.getI3ScreenSize)(this, frameState);
-
-        case _constants.TILESET_TYPE.TILES3D:
-          return (0, _tiles3dLod.getTiles3DScreenSpaceError)(this, frameState, useParentLodMetric);
-
-        default:
-          throw new Error('Unsupported tileset type');
-      }
+
+    if (this.contentState === _constants.TILE_CONTENT_STATE.UNLOADED) {
+      return -1;
     }
-  }, {
-    key: "_getPriority",
-    value: function _getPriority() {
-      var traverser = this.tileset._traverser;
-      var skipLevelOfDetail = traverser.options.skipLevelOfDetail;
-      var maySkipTile = this.refine === _constants.TILE_REFINEMENT.ADD || skipLevelOfDetail;
-
-      if (maySkipTile && !this.isVisible && this._visible !== undefined) {
-        return -1;
-      }
 
-      if (this.tileset._frameNumber - this._touchedFrame >= 1) {
-        return -1;
-      }
+    const parent = this.parent;
+    const useParentScreenSpaceError = parent && (!maySkipTile || this._screenSpaceError === 0.0 || parent.hasTilesetContent);
+    const screenSpaceError = useParentScreenSpaceError ? parent._screenSpaceError : this._screenSpaceError;
+    const rootScreenSpaceError = traverser.root ? traverser.root._screenSpaceError : 0.0;
+    return Math.max(rootScreenSpaceError - screenSpaceError, 0);
+  }
 
-      if (this.contentState === _constants.TILE_CONTENT_STATE.UNLOADED) {
-        return -1;
-      }
+  async loadContent() {
+    if (this.hasEmptyContent) {
+      return false;
+    }
 
-      var parent = this.parent;
-      var useParentScreenSpaceError = parent && (!maySkipTile || this._screenSpaceError === 0.0 || parent.hasTilesetContent);
-      var screenSpaceError = useParentScreenSpaceError ? parent._screenSpaceError : this._screenSpaceError;
-      var rootScreenSpaceError = traverser.root ? traverser.root._screenSpaceError : 0.0;
-      return Math.max(rootScreenSpaceError - screenSpaceError, 0);
+    if (this.content) {
+      return true;
     }
-  }, {
-    key: "loadContent",
-    value: function () {
-      var _loadContent = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee() {
-        var expired, requestToken, contentUrl, loader, options;
-        return _regenerator.default.wrap(function _callee$(_context) {
-          while (1) {
-            switch (_context.prev = _context.next) {
-              case 0:
-                if (!this.hasEmptyContent) {
-                  _context.next = 2;
-                  break;
-                }
-
-                return _context.abrupt("return", false);
-
-              case 2:
-                if (!this.content) {
-                  _context.next = 4;
-                  break;
-                }
-
-                return _context.abrupt("return", true);
-
-              case 4:
-                expired = this.contentExpired;
-
-                if (expired) {
-                  this._expireDate = null;
-                }
-
-                this.contentState = _constants.TILE_CONTENT_STATE.LOADING;
-                _context.next = 9;
-                return this.tileset._requestScheduler.scheduleRequest(this.id, this._getPriority.bind(this));
-
-              case 9:
-                requestToken = _context.sent;
-
-                if (requestToken) {
-                  _context.next = 13;
-                  break;
-                }
-
-                this.contentState = _constants.TILE_CONTENT_STATE.UNLOADED;
-                return _context.abrupt("return", false);
-
-              case 13:
-                _context.prev = 13;
-                contentUrl = this.tileset.getTileUrl(this.contentUrl);
-                loader = this.tileset.loader;
-                options = _objectSpread(_objectSpread({}, this.tileset.loadOptions), {}, (0, _defineProperty2.default)({}, loader.id, _objectSpread(_objectSpread({}, this.tileset.loadOptions[loader.id]), {}, {
-                  isTileset: this.type === 'json'
-                }, this._getLoaderSpecificOptions(loader.id))));
-                _context.next = 19;
-                return (0, _core2.load)(contentUrl, loader, options);
-
-              case 19:
-                this.content = _context.sent;
-
-                if (!this.tileset.options.contentLoader) {
-                  _context.next = 23;
-                  break;
-                }
-
-                _context.next = 23;
-                return this.tileset.options.contentLoader(this);
-
-              case 23:
-                if (this._isTileset()) {
-                  this.tileset._initializeTileHeaders(this.content, this);
-                }
-
-                this.contentState = _constants.TILE_CONTENT_STATE.READY;
-
-                this._onContentLoaded();
-
-                return _context.abrupt("return", true);
-
-              case 29:
-                _context.prev = 29;
-                _context.t0 = _context["catch"](13);
-                this.contentState = _constants.TILE_CONTENT_STATE.FAILED;
-                throw _context.t0;
-
-              case 33:
-                _context.prev = 33;
-                requestToken.done();
-                return _context.finish(33);
-
-              case 36:
-              case "end":
-                return _context.stop();
-            }
-          }
-        }, _callee, this, [[13, 29, 33, 36]]);
-      }));
-
-      function loadContent() {
-        return _loadContent.apply(this, arguments);
-      }
 
-      return loadContent;
-    }()
-  }, {
-    key: "unloadContent",
-    value: function unloadContent() {
-      if (this.content && this.content.destroy) {
-        this.content.destroy();
-      }
+    const expired = this.contentExpired;
 
-      this.content = null;
+    if (expired) {
+      this._expireDate = null;
+    }
 
-      if (this.header.content && this.header.content.destroy) {
-        this.header.content.destroy();
-      }
+    this.contentState = _constants.TILE_CONTENT_STATE.LOADING;
+    const requestToken = await this.tileset._requestScheduler.scheduleRequest(this.id, this._getPriority.bind(this));
 
-      this.header.content = null;
+    if (!requestToken) {
       this.contentState = _constants.TILE_CONTENT_STATE.UNLOADED;
-      return true;
+      return false;
     }
-  }, {
-    key: "updateVisibility",
-    value: function updateVisibility(frameState, viewportIds) {
-      if (this._frameNumber === frameState.frameNumber) {
-        return;
-      }
 
-      var parent = this.parent;
-      var parentVisibilityPlaneMask = parent ? parent._visibilityPlaneMask : _culling.CullingVolume.MASK_INDETERMINATE;
+    try {
+      const contentUrl = this.tileset.getTileUrl(this.contentUrl);
+      const loader = this.tileset.loader;
+      const options = { ...this.tileset.loadOptions,
+        [loader.id]: { ...this.tileset.loadOptions[loader.id],
+          isTileset: this.type === 'json',
+          ...this._getLoaderSpecificOptions(loader.id)
+        }
+      };
+      this.content = await (0, _core2.load)(contentUrl, loader, options);
 
-      if (this.tileset._traverser.options.updateTransforms) {
-        var parentTransform = parent ? parent.computedTransform : this.tileset.modelMatrix;
+      if (this.tileset.options.contentLoader) {
+        await this.tileset.options.contentLoader(this);
+      }
 
-        this._updateTransform(parentTransform);
+      if (this._isTileset()) {
+        this.tileset._initializeTileHeaders(this.content, this);
       }
 
-      this._distanceToCamera = this.distanceToTile(frameState);
-      this._screenSpaceError = this.getScreenSpaceError(frameState, false);
-      this._visibilityPlaneMask = this.visibility(frameState, parentVisibilityPlaneMask);
-      this._visible = this._visibilityPlaneMask !== _culling.CullingVolume.MASK_OUTSIDE;
-      this._inRequestVolume = this.insideViewerRequestVolume(frameState);
-      this._frameNumber = frameState.frameNumber;
-      this.viewportIds = viewportIds;
-    }
-  }, {
-    key: "visibility",
-    value: function visibility(frameState, parentVisibilityPlaneMask) {
-      var cullingVolume = frameState.cullingVolume;
-      var boundingVolume = this.boundingVolume;
-      return cullingVolume.computeVisibilityWithPlaneMask(boundingVolume, parentVisibilityPlaneMask);
-    }
-  }, {
-    key: "contentVisibility",
-    value: function contentVisibility() {
+      this.contentState = _constants.TILE_CONTENT_STATE.READY;
+
+      this._onContentLoaded();
+
       return true;
+    } catch (error) {
+      this.contentState = _constants.TILE_CONTENT_STATE.FAILED;
+      throw error;
+    } finally {
+      requestToken.done();
     }
-  }, {
-    key: "distanceToTile",
-    value: function distanceToTile(frameState) {
-      var boundingVolume = this.boundingVolume;
-      return Math.sqrt(Math.max(boundingVolume.distanceSquaredTo(frameState.camera.position), 0));
-    }
-  }, {
-    key: "cameraSpaceZDepth",
-    value: function cameraSpaceZDepth(_ref) {
-      var camera = _ref.camera;
-      var boundingVolume = this.boundingVolume;
-      scratchVector.subVectors(boundingVolume.center, camera.position);
-      return camera.direction.dot(scratchVector);
+  }
+
+  unloadContent() {
+    if (this.content && this.content.destroy) {
+      this.content.destroy();
     }
-  }, {
-    key: "insideViewerRequestVolume",
-    value: function insideViewerRequestVolume(frameState) {
-      var viewerRequestVolume = this._viewerRequestVolume;
-      return !viewerRequestVolume || viewerRequestVolume.distanceSquaredTo(frameState.camera.position) <= 0;
+
+    this.content = null;
+
+    if (this.header.content && this.header.content.destroy) {
+      this.header.content.destroy();
     }
-  }, {
-    key: "updateExpiration",
-    value: function updateExpiration() {
-      if (defined(this._expireDate) && this.contentReady && !this.hasEmptyContent) {
-        var now = Date.now();
-
-        if (Date.lessThan(this._expireDate, now)) {
-          this.contentState = _constants.TILE_CONTENT_STATE.EXPIRED;
-          this._expiredContent = this.content;
-        }
-      }
+
+    this.header.content = null;
+    this.contentState = _constants.TILE_CONTENT_STATE.UNLOADED;
+    return true;
+  }
+
+  updateVisibility(frameState, viewportIds) {
+    if (this._frameNumber === frameState.frameNumber) {
+      return;
     }
-  }, {
-    key: "extras",
-    get: function get() {
-      return this.header.extras;
+
+    const parent = this.parent;
+    const parentVisibilityPlaneMask = parent ? parent._visibilityPlaneMask : _culling.CullingVolume.MASK_INDETERMINATE;
+
+    if (this.tileset._traverser.options.updateTransforms) {
+      const parentTransform = parent ? parent.computedTransform : this.tileset.modelMatrix;
+
+      this._updateTransform(parentTransform);
     }
-  }, {
-    key: "_initializeLodMetric",
-    value: function _initializeLodMetric(header) {
-      if ('lodMetricType' in header) {
-        this.lodMetricType = header.lodMetricType;
-      } else {
-        this.lodMetricType = this.parent && this.parent.lodMetricType || this.tileset.lodMetricType;
-        console.warn("3D Tile: Required prop lodMetricType is undefined. Using parent lodMetricType");
-      }
 
-      if ('lodMetricValue' in header) {
-        this.lodMetricValue = header.lodMetricValue;
-      } else {
-        this.lodMetricValue = this.parent && this.parent.lodMetricValue || this.tileset.lodMetricValue;
-        console.warn('3D Tile: Required prop lodMetricValue is undefined. Using parent lodMetricValue');
+    this._distanceToCamera = this.distanceToTile(frameState);
+    this._screenSpaceError = this.getScreenSpaceError(frameState, false);
+    this._visibilityPlaneMask = this.visibility(frameState, parentVisibilityPlaneMask);
+    this._visible = this._visibilityPlaneMask !== _culling.CullingVolume.MASK_OUTSIDE;
+    this._inRequestVolume = this.insideViewerRequestVolume(frameState);
+    this._frameNumber = frameState.frameNumber;
+    this.viewportIds = viewportIds;
+  }
+
+  visibility(frameState, parentVisibilityPlaneMask) {
+    const {
+      cullingVolume
+    } = frameState;
+    const {
+      boundingVolume
+    } = this;
+    return cullingVolume.computeVisibilityWithPlaneMask(boundingVolume, parentVisibilityPlaneMask);
+  }
+
+  contentVisibility() {
+    return true;
+  }
+
+  distanceToTile(frameState) {
+    const boundingVolume = this.boundingVolume;
+    return Math.sqrt(Math.max(boundingVolume.distanceSquaredTo(frameState.camera.position), 0));
+  }
+
+  cameraSpaceZDepth({
+    camera
+  }) {
+    const boundingVolume = this.boundingVolume;
+    scratchVector.subVectors(boundingVolume.center, camera.position);
+    return camera.direction.dot(scratchVector);
+  }
+
+  insideViewerRequestVolume(frameState) {
+    const viewerRequestVolume = this._viewerRequestVolume;
+    return !viewerRequestVolume || viewerRequestVolume.distanceSquaredTo(frameState.camera.position) <= 0;
+  }
+
+  updateExpiration() {
+    if (defined(this._expireDate) && this.contentReady && !this.hasEmptyContent) {
+      const now = Date.now();
+
+      if (Date.lessThan(this._expireDate, now)) {
+        this.contentState = _constants.TILE_CONTENT_STATE.EXPIRED;
+        this._expiredContent = this.content;
       }
     }
-  }, {
-    key: "_initializeTransforms",
-    value: function _initializeTransforms(tileHeader) {
-      this.transform = tileHeader.transform ? new _core.Matrix4(tileHeader.transform) : new _core.Matrix4();
-      var parent = this.parent;
-      var tileset = this.tileset;
-      var parentTransform = parent && parent.computedTransform ? parent.computedTransform.clone() : tileset.modelMatrix.clone();
-      this.computedTransform = new _core.Matrix4(parentTransform).multiplyRight(this.transform);
-      var parentInitialTransform = parent && parent._initialTransform ? parent._initialTransform.clone() : new _core.Matrix4();
-      this._initialTransform = new _core.Matrix4(parentInitialTransform).multiplyRight(this.transform);
-    }
-  }, {
-    key: "_initializeBoundingVolumes",
-    value: function _initializeBoundingVolumes(tileHeader) {
-      this._contentBoundingVolume = null;
-      this._viewerRequestVolume = null;
+  }
 
-      this._updateBoundingVolume(tileHeader);
+  get extras() {
+    return this.header.extras;
+  }
+
+  _initializeLodMetric(header) {
+    if ('lodMetricType' in header) {
+      this.lodMetricType = header.lodMetricType;
+    } else {
+      this.lodMetricType = this.parent && this.parent.lodMetricType || this.tileset.lodMetricType;
+      console.warn("3D Tile: Required prop lodMetricType is undefined. Using parent lodMetricType");
     }
-  }, {
-    key: "_initializeContent",
-    value: function _initializeContent(tileHeader) {
-      this.content = {
-        _tileset: this.tileset,
-        _tile: this
-      };
-      this.hasEmptyContent = true;
-      this.contentState = _constants.TILE_CONTENT_STATE.UNLOADED;
-      this.hasTilesetContent = false;
 
-      if (tileHeader.contentUrl) {
-        this.content = null;
-        this.hasEmptyContent = false;
-      }
+    if ('lodMetricValue' in header) {
+      this.lodMetricValue = header.lodMetricValue;
+    } else {
+      this.lodMetricValue = this.parent && this.parent.lodMetricValue || this.tileset.lodMetricValue;
+      console.warn('3D Tile: Required prop lodMetricValue is undefined. Using parent lodMetricValue');
     }
-  }, {
-    key: "_initializeRenderingState",
-    value: function _initializeRenderingState(header) {
-      this.depth = header.level || (this.parent ? this.parent.depth + 1 : 0);
-      this._shouldRefine = false;
-      this._distanceToCamera = 0;
-      this._centerZDepth = 0;
-      this._screenSpaceError = 0;
-      this._visibilityPlaneMask = _culling.CullingVolume.MASK_INDETERMINATE;
-      this._visible = undefined;
-      this._inRequestVolume = false;
-      this._stackLength = 0;
-      this._selectionDepth = 0;
-      this._frameNumber = 0;
-      this._touchedFrame = 0;
-      this._visitedFrame = 0;
-      this._selectedFrame = 0;
-      this._requestedFrame = 0;
-      this._priority = 0.0;
+  }
+
+  _initializeTransforms(tileHeader) {
+    this.transform = tileHeader.transform ? new _core.Matrix4(tileHeader.transform) : new _core.Matrix4();
+    const parent = this.parent;
+    const tileset = this.tileset;
+    const parentTransform = parent && parent.computedTransform ? parent.computedTransform.clone() : tileset.modelMatrix.clone();
+    this.computedTransform = new _core.Matrix4(parentTransform).multiplyRight(this.transform);
+    const parentInitialTransform = parent && parent._initialTransform ? parent._initialTransform.clone() : new _core.Matrix4();
+    this._initialTransform = new _core.Matrix4(parentInitialTransform).multiplyRight(this.transform);
+  }
+
+  _initializeBoundingVolumes(tileHeader) {
+    this._contentBoundingVolume = null;
+    this._viewerRequestVolume = null;
+
+    this._updateBoundingVolume(tileHeader);
+  }
+
+  _initializeContent(tileHeader) {
+    this.content = {
+      _tileset: this.tileset,
+      _tile: this
+    };
+    this.hasEmptyContent = true;
+    this.contentState = _constants.TILE_CONTENT_STATE.UNLOADED;
+    this.hasTilesetContent = false;
+
+    if (tileHeader.contentUrl) {
+      this.content = null;
+      this.hasEmptyContent = false;
     }
-  }, {
-    key: "_getRefine",
-    value: function _getRefine(refine) {
-      return refine || this.parent && this.parent.refine || _constants.TILE_REFINEMENT.REPLACE;
+  }
+
+  _initializeRenderingState(header) {
+    this.depth = header.level || (this.parent ? this.parent.depth + 1 : 0);
+    this._shouldRefine = false;
+    this._distanceToCamera = 0;
+    this._centerZDepth = 0;
+    this._screenSpaceError = 0;
+    this._visibilityPlaneMask = _culling.CullingVolume.MASK_INDETERMINATE;
+    this._visible = undefined;
+    this._inRequestVolume = false;
+    this._stackLength = 0;
+    this._selectionDepth = 0;
+    this._frameNumber = 0;
+    this._touchedFrame = 0;
+    this._visitedFrame = 0;
+    this._selectedFrame = 0;
+    this._requestedFrame = 0;
+    this._priority = 0.0;
+  }
+
+  _getRefine(refine) {
+    return refine || this.parent && this.parent.refine || _constants.TILE_REFINEMENT.REPLACE;
+  }
+
+  _isTileset() {
+    return this.contentUrl.indexOf('.json') !== -1;
+  }
+
+  _onContentLoaded() {
+    switch (this.content && this.content.type) {
+      case 'vctr':
+      case 'geom':
+        this.tileset._traverser.disableSkipLevelOfDetail = true;
+        break;
+
+      default:
     }
-  }, {
-    key: "_isTileset",
-    value: function _isTileset() {
-      return this.contentUrl.indexOf('.json') !== -1;
+
+    if (this._isTileset()) {
+      this.hasTilesetContent = true;
     }
-  }, {
-    key: "_onContentLoaded",
-    value: function _onContentLoaded() {
-      switch (this.content && this.content.type) {
-        case 'vctr':
-        case 'geom':
-          this.tileset._traverser.disableSkipLevelOfDetail = true;
-          break;
-
-        default:
-      }
+  }
 
-      if (this._isTileset()) {
-        this.hasTilesetContent = true;
-      }
+  _updateBoundingVolume(header) {
+    this.boundingVolume = (0, _boundingVolume.createBoundingVolume)(header.boundingVolume, this.computedTransform, this.boundingVolume);
+    const content = header.content;
+
+    if (!content) {
+      return;
     }
-  }, {
-    key: "_updateBoundingVolume",
-    value: function _updateBoundingVolume(header) {
-      this.boundingVolume = (0, _boundingVolume.createBoundingVolume)(header.boundingVolume, this.computedTransform, this.boundingVolume);
-      var content = header.content;
-
-      if (!content) {
-        return;
-      }
 
-      if (content.boundingVolume) {
-        this._contentBoundingVolume = (0, _boundingVolume.createBoundingVolume)(content.boundingVolume, this.computedTransform, this._contentBoundingVolume);
-      }
+    if (content.boundingVolume) {
+      this._contentBoundingVolume = (0, _boundingVolume.createBoundingVolume)(content.boundingVolume, this.computedTransform, this._contentBoundingVolume);
+    }
 
-      if (header.viewerRequestVolume) {
-        this._viewerRequestVolume = (0, _boundingVolume.createBoundingVolume)(header.viewerRequestVolume, this.computedTransform, this._viewerRequestVolume);
-      }
+    if (header.viewerRequestVolume) {
+      this._viewerRequestVolume = (0, _boundingVolume.createBoundingVolume)(header.viewerRequestVolume, this.computedTransform, this._viewerRequestVolume);
     }
-  }, {
-    key: "_updateTransform",
-    value: function _updateTransform() {
-      var parentTransform = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : new _core.Matrix4();
-      var computedTransform = parentTransform.clone().multiplyRight(this.transform);
-      var didTransformChange = !computedTransform.equals(this.computedTransform);
-
-      if (!didTransformChange) {
-        return;
-      }
+  }
 
-      this.computedTransform = computedTransform;
+  _updateTransform(parentTransform = new _core.Matrix4()) {
+    const computedTransform = parentTransform.clone().multiplyRight(this.transform);
+    const didTransformChange = !computedTransform.equals(this.computedTransform);
 
-      this._updateBoundingVolume(this.header);
+    if (!didTransformChange) {
+      return;
     }
-  }, {
-    key: "_getLoaderSpecificOptions",
-    value: function _getLoaderSpecificOptions(loaderId) {
-      switch (loaderId) {
-        case 'i3s':
-          return _objectSpread(_objectSpread({}, this.tileset.options.i3s), {}, {
-            tile: this.header,
-            tileset: this.tileset.tileset,
-            isTileHeader: false
-          });
-
-        case '3d-tiles':
-        case 'cesium-ion':
-        default:
-          return (0, _dTilesOptions.get3dTilesOptions)(this.tileset.tileset);
-      }
+
+    this.computedTransform = computedTransform;
+
+    this._updateBoundingVolume(this.header);
+  }
+
+  _getLoaderSpecificOptions(loaderId) {
+    switch (loaderId) {
+      case 'i3s':
+        return { ...this.tileset.options.i3s,
+          tile: this.header,
+          tileset: this.tileset.tileset,
+          isTileHeader: false
+        };
+
+      case '3d-tiles':
+      case 'cesium-ion':
+      default:
+        return (0, _dTilesOptions.get3dTilesOptions)(this.tileset.tileset);
     }
-  }]);
-  return TileHeader;
-}();
+  }
+
+}
 
 exports.default = TileHeader;
 //# sourceMappingURL=tile-3d.js.map