@vcmap/core 5.0.0-rc.3 → 5.0.0-rc.31

package/src/{vcs/vcm/maps → map}/cameraLimiter.js

@@ -1,9 +1,13 @@
-import { Cartographic, Ellipsoid, Math as CesiumMath } from '@vcmap/cesium';
+import {
+  Cartographic,
+  Ellipsoid,
+  Math as CesiumMath,
+  sampleTerrain,
+  sampleTerrainMostDetailed,
+} from '@vcmap-cesium/engine';
 import { checkMaybe } from '@vcsuite/check';
 import { parseInteger, parseNumber, parseEnumValue } from '@vcsuite/parsers';
 import {
-  sampleCesiumTerrain,
-  sampleCesiumTerrainMostDetailed,
   getTerrainProviderForUrl,
   isTerrainTileAvailable,
 } from '../layer/terrainHelpers.js';
@@ -23,7 +27,7 @@ import {
  * @property {string} HEIGHT
  * @property {string} DISTANCE
  */
-export const Mode = {
+export const CameraLimiterMode = {
   HEIGHT: 'height',
   DISTANCE: 'distance',
 };
@@ -31,18 +35,19 @@ export const Mode = {
 /**
  * Can limit a Cesium.Cameras position based on absolute height or distance to a given terrain
  * @class
- * @export
  * @api
  */
 class CameraLimiter {
-  static get className() { return 'vcs.vcm.maps.CameraLimiter'; }
+  static get className() {
+    return 'CameraLimiter';
+  }
 
   /**
    * @returns {CameraLimiterOptions}
    */
   static getDefaultOptions() {
     return {
-      mode: Mode.HEIGHT,
+      mode: CameraLimiterMode.HEIGHT,
       terrainUrl: undefined,
       limit: 200,
       level: 12,
@@ -56,20 +61,19 @@ class CameraLimiter {
     const defaultOptions = CameraLimiter.getDefaultOptions();
     /**
      * The mode to use. When using DISTANCE mode, be sure to have a terrainProvider set.
-     * @type {Mode}
+     * @type {CameraLimiterMode}
      * @api
      */
-    this.mode = parseEnumValue(options.mode, Mode, defaultOptions.mode);
+    this.mode = parseEnumValue(
+      options.mode,
+      CameraLimiterMode,
+      defaultOptions.mode,
+    );
     /**
      * @type {string|null}
      * @private
      */
     this._terrainUrl = options.terrainUrl || defaultOptions.terrainUrl;
-    /**
-     * @type {import("@vcmap/cesium").CesiumTerrainProvider|null}
-     * @private
-     */
-    this._terrainProvider = this._terrainUrl ? getTerrainProviderForUrl({ url: this._terrainUrl }) : null;
     /**
      * The minimum height/distance to the terrain the camera must maintain
      * @type {number}
@@ -81,10 +85,13 @@ class CameraLimiter {
      * @type {number|null}
      * @api
      */
-    this.level = options.level === null ? null : parseInteger(options.level, defaultOptions.level);
+    this.level =
+      options.level === null
+        ? null
+        : parseInteger(options.level, defaultOptions.level);
     /**
      * last checked camera position
-     * @type {import("@vcmap/cesium").Cartographic}
+     * @type {import("@vcmap-cesium/engine").Cartographic}
      */
     this.lastCheckedPosition = new Cartographic();
     /**
@@ -117,43 +124,52 @@ class CameraLimiter {
 
     if (this._terrainUrl !== url) {
       this._terrainUrl = url;
-      this._terrainProvider = this._terrainUrl ? getTerrainProviderForUrl({ url: this._terrainUrl }) : null;
     }
   }
 
   /**
-   * @param {import("@vcmap/cesium").Cartographic} cameraCartographic
-   * @returns {Promise<Array<import("@vcmap/cesium").Cartographic>>}
+   * @param {import("@vcmap-cesium/engine").Cartographic} cameraCartographic
+   * @returns {Promise<Array<import("@vcmap-cesium/engine").Cartographic>>}
    * @private
    */
-  _limitWithLevel(cameraCartographic) {
-    if (isTerrainTileAvailable(this._terrainProvider, this.level, cameraCartographic)) {
-      return sampleCesiumTerrain(this._terrainProvider, this.level, [cameraCartographic]);
+  async _limitWithLevel(cameraCartographic) {
+    const terrainProvider = await getTerrainProviderForUrl(this.terrainUrl, {});
+    if (
+      isTerrainTileAvailable(terrainProvider, this.level, cameraCartographic)
+    ) {
+      return sampleTerrain(terrainProvider, this.level, [cameraCartographic]);
     }
     return this._limitMostDetailed(cameraCartographic);
   }
 
   /**
-   * @param {import("@vcmap/cesium").Cartographic} cameraCartographic
-   * @returns {Promise<Array<import("@vcmap/cesium").Cartographic>>}
+   * @param {import("@vcmap-cesium/engine").Cartographic} cameraCartographic
+   * @returns {Promise<Array<import("@vcmap-cesium/engine").Cartographic>>}
    * @private
    */
-  _limitMostDetailed(cameraCartographic) {
-    return sampleCesiumTerrainMostDetailed(this._terrainProvider, [cameraCartographic]);
+  async _limitMostDetailed(cameraCartographic) {
+    const terrainProvider = await getTerrainProviderForUrl(this.terrainUrl, {});
+    return sampleTerrainMostDetailed(terrainProvider, [cameraCartographic]);
   }
 
   /**
-   * @param {import("@vcmap/cesium").Cartographic} cameraCartographic
+   * @param {import("@vcmap-cesium/engine").Cartographic} cameraCartographic
    * @returns {Promise<void>}
    * @private
    */
   async _updateTerrainHeight(cameraCartographic) {
-    if (!this._updatingTerrainHeight &&
-      !cameraCartographic.equalsEpsilon(this.lastCheckedPosition, CesiumMath.EPSILON5)) {
+    if (
+      !this._updatingTerrainHeight &&
+      !cameraCartographic.equalsEpsilon(
+        this.lastCheckedPosition,
+        CesiumMath.EPSILON5,
+      )
+    ) {
       this._updatingTerrainHeight = true;
-      const [updatedPosition] = this.level != null ?
-        await this._limitWithLevel(cameraCartographic.clone()) :
-        await this._limitMostDetailed(cameraCartographic.clone());
+      const [updatedPosition] =
+        this.level != null
+          ? await this._limitWithLevel(cameraCartographic.clone())
+          : await this._limitMostDetailed(cameraCartographic.clone());
       this._terrainHeight = updatedPosition.height;
       this.lastCheckedPosition = cameraCartographic;
       this._updatingTerrainHeight = false;
@@ -162,7 +178,7 @@ class CameraLimiter {
 
   /**
    * Limits the given camera based on this limiters specs.
-   * @param {import("@vcmap/cesium").Camera} camera
+   * @param {import("@vcmap-cesium/engine").Camera} camera
    * @api
    * @returns {Promise<void>}
    */
@@ -170,19 +186,30 @@ class CameraLimiter {
     let promise = Promise.resolve();
     const cameraCartographic = Cartographic.fromCartesian(camera.position);
     if (cameraCartographic) {
-      if (this.mode === Mode.DISTANCE && this._terrainProvider) {
+      if (this.mode === CameraLimiterMode.DISTANCE && this.terrainUrl) {
         promise = this._updateTerrainHeight(cameraCartographic);
-        if (this._terrainHeight && (cameraCartographic.height - this._terrainHeight) < this.limit) {
+        if (
+          this._terrainHeight &&
+          cameraCartographic.height - this._terrainHeight < this.limit
+        ) {
           const newHeight = this._terrainHeight + this.limit;
           Cartographic.toCartesian(
-            new Cartographic(cameraCartographic.longitude, cameraCartographic.latitude, newHeight),
+            new Cartographic(
+              cameraCartographic.longitude,
+              cameraCartographic.latitude,
+              newHeight,
+            ),
             Ellipsoid.WGS84,
             camera.position,
           );
         }
       } else if (cameraCartographic.height < this.limit) {
         Cartographic.toCartesian(
-          new Cartographic(cameraCartographic.longitude, cameraCartographic.latitude, this.limit),
+          new Cartographic(
+            cameraCartographic.longitude,
+            cameraCartographic.latitude,
+            this.limit,
+          ),
           Ellipsoid.WGS84,
           camera.position,
         );