itowns 2.36.2 → 2.38.1

package/lib/Core/MainLoop.js

@@ -1,12 +1,42 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports["default"] = exports.MAIN_LOOP_EVENTS = exports.RENDERING_SCHEDULED = exports.RENDERING_PAUSED = void 0;
+exports["default"] = exports.RENDERING_SCHEDULED = exports.RENDERING_PAUSED = exports.MAIN_LOOP_EVENTS = void 0;
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime/helpers/assertThisInitialized"));
+
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+
+var _classPrivateFieldSet2 = _interopRequireDefault(require("@babel/runtime/helpers/classPrivateFieldSet"));
+
+var _classPrivateFieldGet2 = _interopRequireDefault(require("@babel/runtime/helpers/classPrivateFieldGet"));
 
 var _three = require("three");
 
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function () { 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; } }
+
+function _classPrivateMethodInitSpec(obj, privateSet) { _checkPrivateRedeclaration(obj, privateSet); privateSet.add(obj); }
+
+function _classPrivateFieldInitSpec(obj, privateMap, value) { _checkPrivateRedeclaration(obj, privateMap); privateMap.set(obj, value); }
+
+function _checkPrivateRedeclaration(obj, privateCollection) { if (privateCollection.has(obj)) { throw new TypeError("Cannot initialize the same private elements twice on an object"); } }
+
+function _classPrivateMethodGet(receiver, privateSet, fn) { if (!privateSet.has(receiver)) { throw new TypeError("attempted to get private field on non-instance"); } return fn; }
+
 function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
 
 function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
@@ -43,42 +73,17 @@ var MAIN_LOOP_EVENTS = {
 };
 exports.MAIN_LOOP_EVENTS = MAIN_LOOP_EVENTS;
 
-function MainLoop(scheduler, engine) {
-  this.renderingState = RENDERING_PAUSED;
-  this.needsRedraw = false;
-  this.scheduler = scheduler;
-  this.gfxEngine = engine; // TODO: remove me
-
-  this._updateLoopRestarted = true;
-}
-
-MainLoop.prototype = Object.create(_three.EventDispatcher.prototype);
-MainLoop.prototype.constructor = MainLoop;
-
-MainLoop.prototype.scheduleViewUpdate = function (view, forceRedraw) {
-  var _this = this;
-
-  this.needsRedraw |= forceRedraw;
-
-  if (this.renderingState !== RENDERING_SCHEDULED) {
-    this.renderingState = RENDERING_SCHEDULED;
-    requestAnimationFrame(function (timestamp) {
-      _this._step(view, timestamp);
-    });
-  }
-};
-
 function updateElements(context, geometryLayer, elements) {
   if (!elements) {
     return;
   }
 
   var _iterator = _createForOfIteratorHelper(elements),
-      _step2;
+      _step;
 
   try {
-    for (_iterator.s(); !(_step2 = _iterator.n()).done;) {
-      var element = _step2.value;
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var element = _step.value;
       // update element
       // TODO find a way to notify attachedLayers when geometryLayer deletes some elements
       // and then update Debug.js:addGeometryLayerDebugFeatures
@@ -89,11 +94,11 @@ function updateElements(context, geometryLayer, elements) {
         if (sub.element) {
           // update attached layers
           var _iterator2 = _createForOfIteratorHelper(geometryLayer.attachedLayers),
-              _step3;
+              _step2;
 
           try {
-            for (_iterator2.s(); !(_step3 = _iterator2.n()).done;) {
-              var attachedLayer = _step3.value;
+            for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+              var attachedLayer = _step2.value;
 
               if (attachedLayer.ready) {
                 attachedLayer.update(context, attachedLayer, sub.element, sub.parent);
@@ -113,11 +118,11 @@ function updateElements(context, geometryLayer, elements) {
 
 
             var _iterator3 = _createForOfIteratorHelper(geometryLayer.attachedLayers),
-                _step4;
+                _step3;
 
             try {
-              for (_iterator3.s(); !(_step4 = _iterator3.n()).done;) {
-                var _attachedLayer = _step4.value;
+              for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+                var _attachedLayer = _step3.value;
 
                 if (_attachedLayer.ready) {
                   _attachedLayer.update(context, _attachedLayer, sub.elements[i], sub.parent);
@@ -157,7 +162,76 @@ function filterChangeSources(updateSources, geometryLayer) {
   return fullUpdate ? new Set([geometryLayer]) : filtered;
 }
 
-MainLoop.prototype._update = function (view, updateSources, dt) {
+var _needsRedraw = /*#__PURE__*/new WeakMap();
+
+var _updateLoopRestarted = /*#__PURE__*/new WeakMap();
+
+var _lastTimestamp = /*#__PURE__*/new WeakMap();
+
+var _update = /*#__PURE__*/new WeakSet();
+
+var _step4 = /*#__PURE__*/new WeakSet();
+
+var _renderView = /*#__PURE__*/new WeakSet();
+
+var MainLoop = /*#__PURE__*/function (_EventDispatcher) {
+  (0, _inherits2["default"])(MainLoop, _EventDispatcher);
+
+  var _super = _createSuper(MainLoop);
+
+  function MainLoop(scheduler, engine) {
+    var _this;
+
+    (0, _classCallCheck2["default"])(this, MainLoop);
+    _this = _super.call(this);
+
+    _classPrivateMethodInitSpec((0, _assertThisInitialized2["default"])(_this), _renderView);
+
+    _classPrivateMethodInitSpec((0, _assertThisInitialized2["default"])(_this), _step4);
+
+    _classPrivateMethodInitSpec((0, _assertThisInitialized2["default"])(_this), _update);
+
+    _classPrivateFieldInitSpec((0, _assertThisInitialized2["default"])(_this), _needsRedraw, {
+      writable: true,
+      value: false
+    });
+
+    _classPrivateFieldInitSpec((0, _assertThisInitialized2["default"])(_this), _updateLoopRestarted, {
+      writable: true,
+      value: true
+    });
+
+    _classPrivateFieldInitSpec((0, _assertThisInitialized2["default"])(_this), _lastTimestamp, {
+      writable: true,
+      value: 0
+    });
+
+    _this.renderingState = RENDERING_PAUSED;
+    _this.scheduler = scheduler;
+    _this.gfxEngine = engine; // TODO: remove me
+
+    return _this;
+  }
+
+  (0, _createClass2["default"])(MainLoop, [{
+    key: "scheduleViewUpdate",
+    value: function scheduleViewUpdate(view, forceRedraw) {
+      var _this2 = this;
+
+      (0, _classPrivateFieldSet2["default"])(this, _needsRedraw, (0, _classPrivateFieldGet2["default"])(this, _needsRedraw) | forceRedraw);
+
+      if (this.renderingState !== RENDERING_SCHEDULED) {
+        this.renderingState = RENDERING_SCHEDULED;
+        requestAnimationFrame(function (timestamp) {
+          _classPrivateMethodGet(_this2, _step4, _step5).call(_this2, view, timestamp);
+        });
+      }
+    }
+  }]);
+  return MainLoop;
+}(_three.EventDispatcher);
+
+function _update2(view, updateSources, dt) {
   var context = {
     camera: view.camera,
     engine: this.gfxEngine,
@@ -176,26 +250,26 @@ MainLoop.prototype._update = function (view, updateSources, dt) {
   var _iterator4 = _createForOfIteratorHelper(view.getLayers(function (x, y) {
     return !y;
   })),
-      _step5;
+      _step6;
 
   try {
-    for (_iterator4.s(); !(_step5 = _iterator4.n()).done;) {
-      var geometryLayer = _step5.value;
+    for (_iterator4.s(); !(_step6 = _iterator4.n()).done;) {
+      var geometryLayer = _step6.value;
       context.geometryLayer = geometryLayer;
 
       if (geometryLayer.ready && geometryLayer.visible && !geometryLayer.frozen) {
-        view.execFrameRequesters(MAIN_LOOP_EVENTS.BEFORE_LAYER_UPDATE, dt, this._updateLoopRestarted, geometryLayer); // Filter updateSources that are relevant for the geometryLayer
+        view.execFrameRequesters(MAIN_LOOP_EVENTS.BEFORE_LAYER_UPDATE, dt, (0, _classPrivateFieldGet2["default"])(this, _updateLoopRestarted), geometryLayer); // Filter updateSources that are relevant for the geometryLayer
 
         var srcs = filterChangeSources(updateSources, geometryLayer);
 
         if (srcs.size > 0) {
           // pre update attached layer
           var _iterator5 = _createForOfIteratorHelper(geometryLayer.attachedLayers),
-              _step6;
+              _step7;
 
           try {
-            for (_iterator5.s(); !(_step6 = _iterator5.n()).done;) {
-              var attachedLayer = _step6.value;
+            for (_iterator5.s(); !(_step7 = _iterator5.n()).done;) {
+              var attachedLayer = _step7.value;
 
               if (attachedLayer.ready && attachedLayer.preUpdate) {
                 attachedLayer.preUpdate(context, srcs);
@@ -217,7 +291,7 @@ MainLoop.prototype._update = function (view, updateSources, dt) {
 
 
         geometryLayer.cache.flush();
-        view.execFrameRequesters(MAIN_LOOP_EVENTS.AFTER_LAYER_UPDATE, dt, this._updateLoopRestarted, geometryLayer);
+        view.execFrameRequesters(MAIN_LOOP_EVENTS.AFTER_LAYER_UPDATE, dt, (0, _classPrivateFieldGet2["default"])(this, _updateLoopRestarted), geometryLayer);
       }
     }
   } catch (err) {
@@ -225,19 +299,19 @@ MainLoop.prototype._update = function (view, updateSources, dt) {
   } finally {
     _iterator4.f();
   }
-};
+}
 
-MainLoop.prototype._step = function (view, timestamp) {
-  var dt = timestamp - this._lastTimestamp;
+function _step5(view, timestamp) {
+  var dt = timestamp - (0, _classPrivateFieldGet2["default"])(this, _lastTimestamp);
 
   view._executeFrameRequestersRemovals();
 
-  view.execFrameRequesters(MAIN_LOOP_EVENTS.UPDATE_START, dt, this._updateLoopRestarted);
-  var willRedraw = this.needsRedraw;
-  this._lastTimestamp = timestamp; // Reset internal state before calling _update (so future calls to View.notifyChange()
+  view.execFrameRequesters(MAIN_LOOP_EVENTS.UPDATE_START, dt, (0, _classPrivateFieldGet2["default"])(this, _updateLoopRestarted));
+  var willRedraw = (0, _classPrivateFieldGet2["default"])(this, _needsRedraw);
+  (0, _classPrivateFieldSet2["default"])(this, _lastTimestamp, timestamp); // Reset internal state before calling _update (so future calls to View.notifyChange()
   // can properly change it)
 
-  this.needsRedraw = false;
+  (0, _classPrivateFieldSet2["default"])(this, _needsRedraw, false);
   this.renderingState = RENDERING_PAUSED;
   var updateSources = new Set(view._changeSources);
 
@@ -245,9 +319,9 @@ MainLoop.prototype._step = function (view, timestamp) {
 
 
   var dim = this.gfxEngine.getWindowSize();
-  view.execFrameRequesters(MAIN_LOOP_EVENTS.BEFORE_CAMERA_UPDATE, dt, this._updateLoopRestarted);
+  view.execFrameRequesters(MAIN_LOOP_EVENTS.BEFORE_CAMERA_UPDATE, dt, (0, _classPrivateFieldGet2["default"])(this, _updateLoopRestarted));
   view.camera.update(dim.x, dim.y);
-  view.execFrameRequesters(MAIN_LOOP_EVENTS.AFTER_CAMERA_UPDATE, dt, this._updateLoopRestarted); // Disable camera's matrix auto update to make sure the camera's
+  view.execFrameRequesters(MAIN_LOOP_EVENTS.AFTER_CAMERA_UPDATE, dt, (0, _classPrivateFieldGet2["default"])(this, _updateLoopRestarted)); // Disable camera's matrix auto update to make sure the camera's
   // world matrix is never updated mid-update.
   // Otherwise inconsistencies can appear because object visibility
   // testing and object drawing could be performed using different
@@ -258,31 +332,31 @@ MainLoop.prototype._step = function (view, timestamp) {
   var oldAutoUpdate = view.camera.camera3D.matrixAutoUpdate;
   view.camera.camera3D.matrixAutoUpdate = false; // update data-structure
 
-  this._update(view, updateSources, dt);
+  _classPrivateMethodGet(this, _update, _update2).call(this, view, updateSources, dt);
 
   if (this.scheduler.commandsWaitingExecutionCount() == 0) {
     this.dispatchEvent({
       type: 'command-queue-empty'
     });
   } // Redraw *only* if needed.
-  // (redraws only happen when this.needsRedraw is true, which in turn only happens when
+  // (redraws only happen when this.#needsRedraw is true, which in turn only happens when
   // view.notifyChange() is called with redraw=true)
   // As such there's no continuous update-loop, instead we use a ad-hoc update/render
   // mechanism.
 
 
   if (willRedraw) {
-    this._renderView(view, dt);
+    _classPrivateMethodGet(this, _renderView, _renderView2).call(this, view, dt);
   } // next time, we'll consider that we've just started the loop if we are still PAUSED now
 
 
-  this._updateLoopRestarted = this.renderingState === RENDERING_PAUSED;
+  (0, _classPrivateFieldSet2["default"])(this, _updateLoopRestarted, this.renderingState === RENDERING_PAUSED);
   view.camera.camera3D.matrixAutoUpdate = oldAutoUpdate;
-  view.execFrameRequesters(MAIN_LOOP_EVENTS.UPDATE_END, dt, this._updateLoopRestarted);
-};
+  view.execFrameRequesters(MAIN_LOOP_EVENTS.UPDATE_END, dt, (0, _classPrivateFieldGet2["default"])(this, _updateLoopRestarted));
+}
 
-MainLoop.prototype._renderView = function (view, dt) {
-  view.execFrameRequesters(MAIN_LOOP_EVENTS.BEFORE_RENDER, dt, this._updateLoopRestarted);
+function _renderView2(view, dt) {
+  view.execFrameRequesters(MAIN_LOOP_EVENTS.BEFORE_RENDER, dt, (0, _classPrivateFieldGet2["default"])(this, _updateLoopRestarted));
 
   if (view.render) {
     view.render();
@@ -291,8 +365,8 @@ MainLoop.prototype._renderView = function (view, dt) {
     this.gfxEngine.renderView(view);
   }
 
-  view.execFrameRequesters(MAIN_LOOP_EVENTS.AFTER_RENDER, dt, this._updateLoopRestarted);
-};
+  view.execFrameRequesters(MAIN_LOOP_EVENTS.AFTER_RENDER, dt, (0, _classPrivateFieldGet2["default"])(this, _updateLoopRestarted));
+}
 
 var _default = MainLoop;
 exports["default"] = _default;

package/lib/Core/Math/Ellipsoid.js

@@ -7,7 +7,7 @@ var _typeof = require("@babel/runtime/helpers/typeof");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports["default"] = exports.ellipsoidSizes = void 0;
+exports.ellipsoidSizes = exports["default"] = void 0;
 
 var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
 

package/lib/Core/Prefab/Globe/SkyShader.js

@@ -9,6 +9,8 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports["default"] = void 0;
 
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
 var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
 
 var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
@@ -87,7 +89,7 @@ var Sky = /*#__PURE__*/function (_THREE$Mesh) {
     return _super.call(this, skyGeo, skyMat);
   }
 
-  return Sky;
+  return (0, _createClass2["default"])(Sky);
 }(THREE.Mesh);
 
 var _default = Sky;

package/lib/Core/Prefab/Planar/PlanarLayer.js

@@ -9,6 +9,8 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports["default"] = void 0;
 
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
 var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
 
 var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
@@ -96,7 +98,7 @@ var PlanarLayer = /*#__PURE__*/function (_TiledGeometryLayer) {
     return _this;
   }
 
-  return PlanarLayer;
+  return (0, _createClass2["default"])(PlanarLayer);
 }(_TiledGeometryLayer2["default"]);
 
 var _default = PlanarLayer;

package/lib/Core/Style.js

@@ -7,8 +7,8 @@ var _typeof = require("@babel/runtime/helpers/typeof");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.readExpression = readExpression;
 exports["default"] = exports.cacheStyle = void 0;
+exports.readExpression = readExpression;
 
 var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
 

package/lib/Core/TileGeometry.js

@@ -9,6 +9,8 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports["default"] = void 0;
 
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
 var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
 
 var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
@@ -75,7 +77,7 @@ var TileGeometry = /*#__PURE__*/function (_THREE$BufferGeometry) {
     return _this;
   }
 
-  return TileGeometry;
+  return (0, _createClass2["default"])(TileGeometry);
 }(THREE.BufferGeometry);
 
 var _default = TileGeometry;

package/lib/Core/TileMesh.js

@@ -13,16 +13,22 @@ var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/cl
 
 var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
 
+var _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime/helpers/assertThisInitialized"));
+
 var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
 
 var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
 
 var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
 
+var _classPrivateFieldGet2 = _interopRequireDefault(require("@babel/runtime/helpers/classPrivateFieldGet"));
+
 var THREE = _interopRequireWildcard(require("three"));
 
 var _Crs = _interopRequireDefault(require("./Geographic/Crs"));
 
+var _GeoidLayer = require("../Layer/GeoidLayer");
+
 function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
 
 function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
@@ -37,6 +43,12 @@ 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; } }
 
+function _classPrivateFieldInitSpec(obj, privateMap, value) { _checkPrivateRedeclaration(obj, privateMap); privateMap.set(obj, value); }
+
+function _checkPrivateRedeclaration(obj, privateCollection) { if (privateCollection.has(obj)) { throw new TypeError("Cannot initialize the same private elements twice on an object"); } }
+
+var _tms = /*#__PURE__*/new WeakMap();
+
 /**
  * A TileMesh is a THREE.Mesh with a geometricError and an OBB
  * The objectId property of the material is the with the id of the TileMesh
@@ -59,6 +71,11 @@ var TileMesh = /*#__PURE__*/function (_THREE$Mesh) {
     (0, _classCallCheck2["default"])(this, TileMesh);
     _this = _super.call(this, geometry, material);
 
+    _classPrivateFieldInitSpec((0, _assertThisInitialized2["default"])(_this), _tms, {
+      writable: true,
+      value: new Map()
+    });
+
     if (!extent) {
       throw new Error('extent is mandatory to build a TileMesh');
     }
@@ -73,16 +90,13 @@ var TileMesh = /*#__PURE__*/function (_THREE$Mesh) {
 
     _this.obb.box3D.getBoundingSphere(_this.boundingSphere);
 
-    _this._tms = new Map();
-
     var _iterator = _createForOfIteratorHelper(layer.tileMatrixSets),
         _step;
 
     try {
       for (_iterator.s(); !(_step = _iterator.n()).done;) {
         var tms = _step.value;
-
-        _this._tms.set(tms, _this.extent.tiledCovering(tms));
+        (0, _classPrivateFieldGet2["default"])((0, _assertThisInitialized2["default"])(_this), _tms).set(tms, _this.extent.tiledCovering(tms));
       }
     } catch (err) {
       _iterator.e(err);
@@ -96,41 +110,37 @@ var TileMesh = /*#__PURE__*/function (_THREE$Mesh) {
     _this.layerUpdateState = {};
     _this.isTileMesh = true;
     _this.domElements = {};
+    _this.geoidHeight = 0;
+    _this.link = [];
     return _this;
   }
   /**
    * If specified, update the min and max elevation of the OBB
    * and updates accordingly the bounding sphere and the geometric error
    *
-   * @param {?number} min
-   * @param {?number} max
-   * @param {?number} scale
+   * @param {Object}  elevation
+   * @param {number}  [elevation.min]
+   * @param {number}  [elevation.max]
+   * @param {number}  [elevation.scale]
    */
 
 
   (0, _createClass2["default"])(TileMesh, [{
     key: "setBBoxZ",
-    value: function setBBoxZ(min, max, scale) {
-      if (min == null && max == null) {
-        return;
-      } // update bbox if min or max have changed by at least one decimal
-      // or if scale changed
-
-
-      if (min.toFixed(1) !== this.obb.z.min.toFixed(1) || max.toFixed(1) !== this.obb.z.max.toFixed(1) || scale != this.obb.z.scale) {
-        this.obb.updateZ(min, max, scale);
+    value: function setBBoxZ(elevation) {
+      elevation.geoidHeight = (0, _GeoidLayer.geoidLayerIsVisible)(this.layer) ? this.geoidHeight : 0;
+      this.obb.updateZ(elevation);
 
-        if (this.horizonCullingPointElevationScaled) {
-          this.horizonCullingPointElevationScaled.setLength(this.obb.z.delta + this.horizonCullingPoint.length());
-        }
-
-        this.obb.box3D.getBoundingSphere(this.boundingSphere);
+      if (this.horizonCullingPointElevationScaled) {
+        this.horizonCullingPointElevationScaled.setLength(this.obb.z.delta + this.horizonCullingPoint.length());
       }
+
+      this.obb.box3D.getBoundingSphere(this.boundingSphere);
     }
   }, {
     key: "getExtentsByProjection",
     value: function getExtentsByProjection(crs) {
-      return this._tms.get(_Crs["default"].formatToTms(crs));
+      return (0, _classPrivateFieldGet2["default"])(this, _tms).get(_Crs["default"].formatToTms(crs));
     }
     /**
      * Search for a common ancestor between this tile and another one. It goes