@vcmap/core 5.0.0-rc.30 → 5.0.0-rc.32

package/index.d.ts

@@ -685,7 +685,7 @@ export const cesiumTilesetLastUpdated: unique symbol;
 /**
  * @returns in mercator
  */
-export function getExtentFromTileset(cesium3DTileset: import("@vcmap-cesium/engine").Cesium3DTileset): import("ol/extent").Extent;
+export function getExtentFromTileset(cesium3DTileset: import("@vcmap-cesium/engine").Cesium3DTileset | undefined): import("ol/extent").Extent;
 
 
 
@@ -959,8 +959,8 @@ export class VectorTileImageryProvider {
     minLevel: number;
     maxLevel: number;
 
+
     ready: any;
-    readyPromise: any;
     rectangle: any;
     tileWidth: any;
     tileHeight: any;
@@ -3237,12 +3237,11 @@ export class SingleImageLayer extends RasterLayer {
 }
 
 export interface TerrainProviderOptions {
-    url: string;
     requestVertexNormals?: boolean | undefined;
     requestWaterMask?: boolean | undefined;
 }
 
-export function getTerrainProviderForUrl(options: TerrainProviderOptions): import("@vcmap-cesium/engine").CesiumTerrainProvider;
+export function getTerrainProviderForUrl(url: string, options: TerrainProviderOptions): Promise<import("@vcmap-cesium/engine").CesiumTerrainProvider>;
 
 /**
  * changes input coordinate Array in place, new height can also be accessed by coordinates[x][2]
@@ -5789,10 +5788,14 @@ export interface ObliqueVersion {
     buildNumber: number;
 }
 
+export interface ObliqueDataSetTerrainProviderOptions extends TerrainProviderOptions {
+    url: string;
+}
+
 export interface ObliqueDataSetOptions {
     url: string;
     projection?: ProjectionOptions;
-    terrainProvider?: TerrainProviderOptions;
+    terrainProvider?: ObliqueDataSetTerrainProviderOptions;
 }
 
 export interface ObliqueCollectionOptions extends VcsObjectOptions {
@@ -5937,7 +5940,7 @@ export enum DataState {
 export function getStateFromStatesArray(states: DataState[]): DataState;
 
 export class ObliqueDataSet {
-    constructor(url: string, projection: Projection | ProjectionOptions, terrainProviderOptions?: TerrainProviderOptions);
+    constructor(url: string, projection: Projection | ProjectionOptions, terrainProviderOptions?: ObliqueDataSetTerrainProviderOptions);
     url: string;
     baseUrl: string;
     projection: Projection;
@@ -5958,7 +5961,6 @@ export class ObliqueDataSet {
      * reflect the state of loaded tiles.
      */
     readonly state: DataState;
-    readonly terrainProvider: import("@vcmap-cesium/engine").CesiumTerrainProvider | undefined;
     /**
      * Loads the data set.
      */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vcmap/core",
-  "version": "5.0.0-rc.30",
+  "version": "5.0.0-rc.32",
   "description": "",
   "main": "index.js",
   "type": "module",
@@ -61,8 +61,8 @@
     "typescript": "^4.9.3"
   },
   "peerDependencies": {
-    "@vcmap-cesium/engine": "~1.1.2",
-    "ol": "~7.2.2"
+    "@vcmap-cesium/engine": "~2.3.2",
+    "ol": "~7.3.0"
   },
   "eslintConfig": {
     "extends": [

package/src/layer/cesium/cesiumTilesetCesiumImpl.js

@@ -21,11 +21,11 @@ import { circleFromCenterRadius } from '../../util/geometryHelpers.js';
 export const cesiumTilesetLastUpdated = Symbol('cesiumTilesetLastUpdated');
 
 /**
- * @param {import("@vcmap-cesium/engine").Cesium3DTileset} cesium3DTileset
+ * @param {import("@vcmap-cesium/engine").Cesium3DTileset|undefined} cesium3DTileset
  * @returns {import("ol/extent").Extent} in mercator
  */
 export function getExtentFromTileset(cesium3DTileset) {
-  if (!cesium3DTileset.ready) {
+  if (!cesium3DTileset) {
     return createEmpty();
   }
   const { rectangle } = cesium3DTileset.root.boundingVolume;
@@ -121,8 +121,12 @@ class CesiumTilesetCesiumImpl extends LayerImplementation {
    */
   async initialize() {
     if (!this._initializedPromise) {
+      this._initializedPromise = Cesium3DTileset.fromUrl(
+        this.url,
+        this.tilesetOptions,
+      );
       /** @type {import("@vcmap-cesium/engine").Cesium3DTileset} */
-      this.cesium3DTileset = new Cesium3DTileset(this.tilesetOptions);
+      this.cesium3DTileset = await this._initializedPromise;
       if (this.tilesetProperties) {
         this.tilesetProperties.forEach(({ key, value }) => {
           this.cesium3DTileset[key] = value;
@@ -136,9 +140,6 @@ class CesiumTilesetCesiumImpl extends LayerImplementation {
         delete tile[cesiumTilesetLastUpdated];
       });
 
-      this._initializedPromise = this.cesium3DTileset.readyPromise;
-
-      await this._initializedPromise;
       this._originalOrigin = Cartesian3.clone(
         this.cesium3DTileset.boundingSphere.center,
       );
@@ -249,24 +250,22 @@ class CesiumTilesetCesiumImpl extends LayerImplementation {
         },
       );
       this._styleLastUpdated = Date.now();
-      this.cesium3DTileset.readyPromise.then(() => {
-        if (this.cesium3DTileset.colorBlendMode !== this.style.colorBlendMode) {
-          // we only support replace and mix mode if the _3DTILESDIFFUSE Flag is set in the tileset
+      if (this.cesium3DTileset.colorBlendMode !== this.style.colorBlendMode) {
+        // we only support replace and mix mode if the _3DTILESDIFFUSE Flag is set in the tileset
+        if (
+          this.style.colorBlendMode !== Cesium3DTileColorBlendMode.HIGHLIGHT
+        ) {
           if (
-            this.style.colorBlendMode !== Cesium3DTileColorBlendMode.HIGHLIGHT
+            this.cesium3DTileset.extras &&
+            // eslint-disable-next-line no-underscore-dangle
+            this.cesium3DTileset.extras._3DTILESDIFFUSE
           ) {
-            if (
-              this.cesium3DTileset.extras &&
-              // eslint-disable-next-line no-underscore-dangle
-              this.cesium3DTileset.extras._3DTILESDIFFUSE
-            ) {
-              this.cesium3DTileset.colorBlendMode = this.style.colorBlendMode;
-            }
-          } else {
             this.cesium3DTileset.colorBlendMode = this.style.colorBlendMode;
           }
+        } else {
+          this.cesium3DTileset.colorBlendMode = this.style.colorBlendMode;
         }
-      });
+      }
     }
   }
 
@@ -284,12 +283,14 @@ class CesiumTilesetCesiumImpl extends LayerImplementation {
    * @param {import("@vcmap-cesium/engine").Cesium3DTile} tile
    */
   applyStyle(tile) {
-    if (tile.content instanceof Composite3DTileContent) {
-      for (let i = 0; i < tile.content.innerContents.length; i++) {
-        this.styleContent(tile.content.innerContents[i]);
+    if (tile.contentReady) {
+      if (tile.content instanceof Composite3DTileContent) {
+        for (let i = 0; i < tile.content.innerContents.length; i++) {
+          this.styleContent(tile.content.innerContents[i]);
+        }
+      } else {
+        this.styleContent(tile.content);
       }
-    } else {
-      this.styleContent(tile.content);
     }
   }
 

package/src/layer/cesium/terrainCesiumImpl.js

@@ -35,10 +35,9 @@ class TerrainCesiumImpl extends LayerImplementation {
    * @inheritDoc
    * @returns {Promise<void>}
    */
-  initialize() {
+  async initialize() {
     if (!this.initialized) {
-      this.terrainProvider = getTerrainProviderForUrl({
-        url: this.url,
+      this.terrainProvider = await getTerrainProviderForUrl(this.url, {
         requestVertexNormals: this.requestVertexNormals,
         requestWaterMask: this.requestWaterMask,
       });

package/src/layer/cesium/vectorTileImageryProvider.js

@@ -128,12 +128,6 @@ class VectorTileImageryProvider {
      */
     this._errorEvent = new CesiumEvent();
 
-    /**
-     * @type {Promise<boolean>}
-     * @private
-     */
-    this._readyPromise = Promise.resolve(true);
-
     /**
      * @type {HTMLCanvasElement}
      */
@@ -154,33 +148,22 @@ class VectorTileImageryProvider {
      * @type {Function}
      */
     this._reload = undefined;
-
-    // Necessary to satisfy Cesium ImageryProvider Interface
-    this.defaultAlpha = undefined;
-    this.defaultNightAlpha = undefined;
-    this.defaultDayAlpha = undefined;
-    this.defaultBrightness = undefined;
-    this.defaultContrast = undefined;
-    this.defaultHue = undefined;
-    this.defaultSaturation = undefined;
-    this.defaultGamma = undefined;
-    this.defaultMinificationFilter = undefined;
-    this.defaultMagnificationFilter = undefined;
   }
 
   /**
    * @returns {boolean}
    */
   // eslint-disable-next-line class-methods-use-this
-  get ready() {
+  get _ready() {
     return true;
   }
 
   /**
-   * @returns {Promise<boolean>}
+   * @returns {boolean}
    */
-  get readyPromise() {
-    return this._readyPromise;
+  // eslint-disable-next-line class-methods-use-this
+  get ready() {
+    return true;
   }
 
   /**

package/src/layer/cesiumTilesetLayer.js

@@ -113,7 +113,6 @@ class CesiumTilesetLayer extends FeatureLayer {
 
     /** @type {!Object} */
     this.tilesetOptions = {
-      url: this.url,
       maximumScreenSpaceError: isMobile()
         ? this.screenSpaceErrorMobile
         : this.screenSpaceError,
@@ -297,9 +296,6 @@ class CesiumTilesetLayer extends FeatureLayer {
     }
 
     const tilesetOptions = { ...this.tilesetOptions };
-    if (tilesetOptions.url === this.url) {
-      delete tilesetOptions.url;
-    }
 
     const usedScreenSpaceError = isMobile()
       ? this.screenSpaceErrorMobile

package/src/layer/terrainHelpers.js

@@ -9,7 +9,6 @@ import { wgs84Projection } from '../util/projection.js';
 
 /**
  * @typedef {Object} TerrainProviderOptions
- * @property {!string} url
  * @property {boolean|undefined} requestVertexNormals
  * @property {boolean|undefined} requestWaterMask
  * @api
@@ -21,23 +20,24 @@ import { wgs84Projection } from '../util/projection.js';
 const terrainProviders = {};
 
 /**
+ * @param {string} url
  * @param {TerrainProviderOptions} options
- * @returns {import("@vcmap-cesium/engine").CesiumTerrainProvider}
+ * @returns {Promise<import("@vcmap-cesium/engine").CesiumTerrainProvider>}
  */
-export function getTerrainProviderForUrl(options) {
-  if (!terrainProviders[options.url]) {
-    terrainProviders[options.url] = new CesiumTerrainProvider(options);
-    return terrainProviders[options.url];
+export async function getTerrainProviderForUrl(url, options) {
+  if (!terrainProviders[url]) {
+    terrainProviders[url] = await CesiumTerrainProvider.fromUrl(url, options);
+    return terrainProviders[url];
   }
-  let terrainProvider = terrainProviders[options.url];
+  let terrainProvider = terrainProviders[url];
   if (
     (options.requestVertexNormals !== undefined &&
       terrainProvider.requestVertexNormals !== options.requestVertexNormals) ||
     (options.requestWaterMask !== undefined &&
       terrainProvider.requestWaterMask !== options.requestWaterMask)
   ) {
-    terrainProviders[options.url] = new CesiumTerrainProvider(options);
-    terrainProvider = terrainProviders[options.url];
+    terrainProviders[url] = await CesiumTerrainProvider.fromUrl(url, options);
+    terrainProvider = terrainProviders[url];
   }
   return terrainProvider;
 }
@@ -86,9 +86,6 @@ export function getHeightFromTerrainProvider(
  * @returns {boolean}
  */
 export function isTerrainTileAvailable(terrainProvider, level, position) {
-  if (!terrainProvider.ready) {
-    return false;
-  }
   const tileXY = terrainProvider.tilingScheme.positionToTileXY(
     position,
     level,

package/src/layer/terrainLayer.js

@@ -100,9 +100,8 @@ class TerrainLayer extends Layer {
    * @returns {Promise<Array<import("ol/coordinate").Coordinate>>}
    * @api stable
    */
-  getHeightForWGS84Coordinates(coords) {
-    const terrainProvider = getTerrainProviderForUrl({
-      url: this.url,
+  async getHeightForWGS84Coordinates(coords) {
+    const terrainProvider = await getTerrainProviderForUrl(this.url, {
       requestVertexNormals: this.requestVertexNormals,
       requestWaterMask: this.requestWaterMask,
     });

package/src/map/cameraLimiter.js

@@ -74,13 +74,6 @@ class CameraLimiter {
      * @private
      */
     this._terrainUrl = options.terrainUrl || defaultOptions.terrainUrl;
-    /**
-     * @type {import("@vcmap-cesium/engine").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}
@@ -131,9 +124,6 @@ class CameraLimiter {
 
     if (this._terrainUrl !== url) {
       this._terrainUrl = url;
-      this._terrainProvider = this._terrainUrl
-        ? getTerrainProviderForUrl({ url: this._terrainUrl })
-        : null;
     }
   }
 
@@ -142,17 +132,12 @@ class CameraLimiter {
    * @returns {Promise<Array<import("@vcmap-cesium/engine").Cartographic>>}
    * @private
    */
-  _limitWithLevel(cameraCartographic) {
+  async _limitWithLevel(cameraCartographic) {
+    const terrainProvider = await getTerrainProviderForUrl(this.terrainUrl, {});
     if (
-      isTerrainTileAvailable(
-        this._terrainProvider,
-        this.level,
-        cameraCartographic,
-      )
+      isTerrainTileAvailable(terrainProvider, this.level, cameraCartographic)
     ) {
-      return sampleTerrain(this._terrainProvider, this.level, [
-        cameraCartographic,
-      ]);
+      return sampleTerrain(terrainProvider, this.level, [cameraCartographic]);
     }
     return this._limitMostDetailed(cameraCartographic);
   }
@@ -162,10 +147,9 @@ class CameraLimiter {
    * @returns {Promise<Array<import("@vcmap-cesium/engine").Cartographic>>}
    * @private
    */
-  _limitMostDetailed(cameraCartographic) {
-    return sampleTerrainMostDetailed(this._terrainProvider, [
-      cameraCartographic,
-    ]);
+  async _limitMostDetailed(cameraCartographic) {
+    const terrainProvider = await getTerrainProviderForUrl(this.terrainUrl, {});
+    return sampleTerrainMostDetailed(terrainProvider, [cameraCartographic]);
   }
 
   /**
@@ -202,7 +186,7 @@ class CameraLimiter {
     let promise = Promise.resolve();
     const cameraCartographic = Cartographic.fromCartesian(camera.position);
     if (cameraCartographic) {
-      if (this.mode === CameraLimiterMode.DISTANCE && this._terrainProvider) {
+      if (this.mode === CameraLimiterMode.DISTANCE && this.terrainUrl) {
         promise = this._updateTerrainHeight(cameraCartographic);
         if (
           this._terrainHeight &&

package/src/map/cesiumMap.js

@@ -552,7 +552,8 @@ class CesiumMap extends VcsMap {
       this._cesiumWidget = new CesiumWidget(this.mapElement, {
         requestRenderMode: false,
         scene3DOnly: true,
-        imageryProvider: false,
+        // @ts-ignore // error in Cesium, recheck on next cesium update
+        baseLayer: false,
         shadows: false,
         terrainShadows: ShadowMode.ENABLED,
         contextOptions: {
@@ -675,19 +676,17 @@ class CesiumMap extends VcsMap {
    */
   getHeightFromTerrain(positions) {
     const { terrainProvider } = this._cesiumWidget.scene;
-    return terrainProvider.readyPromise.then(() => {
-      if (terrainProvider.availability) {
-        return getHeightFromTerrainProvider(
-          /** @type {import("@vcmap-cesium/engine").CesiumTerrainProvider} */ (
-            terrainProvider
-          ),
-          positions,
-          mercatorProjection,
-          positions,
-        );
-      }
-      return Promise.resolve(positions);
-    });
+    if (terrainProvider.availability) {
+      return getHeightFromTerrainProvider(
+        /** @type {import("@vcmap-cesium/engine").CesiumTerrainProvider} */ (
+          terrainProvider
+        ),
+        positions,
+        mercatorProjection,
+        positions,
+      );
+    }
+    return Promise.resolve(positions);
   }
 
   /**

package/src/oblique/obliqueCollection.js

@@ -61,11 +61,16 @@ import VcsObject from '../vcsObject.js';
  * @api
  */
 
+/**
+ * @typedef {TerrainProviderOptions} ObliqueDataSetTerrainProviderOptions
+ * @property {string} url
+ */
+
 /**
  * @typedef {Object} ObliqueDataSetOptions
  * @property {string} url
  * @property {ProjectionOptions} [projection]
- * @property {TerrainProviderOptions} [terrainProvider]
+ * @property {ObliqueDataSetTerrainProviderOptions} [terrainProvider]
  */
 
 /**

package/src/oblique/obliqueDataSet.js

@@ -54,7 +54,7 @@ class ObliqueDataSet {
   /**
    * @param {string} url
    * @param {import("@vcmap/core").Projection|ProjectionOptions=} projection
-   * @param {TerrainProviderOptions=} terrainProviderOptions
+   * @param {ObliqueDataSetTerrainProviderOptions=} terrainProviderOptions
    */
   constructor(url, projection, terrainProviderOptions) {
     /** @type {string} */
@@ -75,7 +75,7 @@ class ObliqueDataSet {
       projectionObject
     );
     /**
-     * @type {TerrainProviderOptions}
+     * @type {ObliqueDataSetTerrainProviderOptions|undefined}
      * @private
      */
     this._terrainProviderOptions = terrainProviderOptions
@@ -85,9 +85,7 @@ class ObliqueDataSet {
      * @type {import("@vcmap-cesium/engine").CesiumTerrainProvider|undefined}
      * @private
      */
-    this._terrainProvider = this._terrainProviderOptions
-      ? getTerrainProviderForUrl(this._terrainProviderOptions)
-      : undefined;
+    this._terrainProvider = undefined;
     /**
      * @type {Array<import("@vcmap/core").ObliqueImageMeta>}
      * @private
@@ -146,25 +144,18 @@ class ObliqueDataSet {
     return this._state;
   }
 
-  /**
-   * @type {import("@vcmap-cesium/engine").CesiumTerrainProvider|undefined}
-   * @readonly
-   */
-  get terrainProvider() {
-    return this._terrainProvider;
-  }
-
   /**
    * Loads the data set.
    * @returns {Promise<void>}
    * @api
    */
-  load() {
+  async load() {
     if (!this._loadingPromise) {
       this._state = DataState.LOADING;
-
       this._loadingPromise = requestJson(this.url)
-        .then((data) => this._initialize(data))
+        .then((data) => {
+          return this._initialize(data);
+        })
         .catch((err) => {
           return Promise.reject(err);
         });
@@ -192,19 +183,29 @@ class ObliqueDataSet {
    * @param {ObliqueImageJson} json
    * @api
    */
-  initialize(json) {
+  async initialize(json) {
     if (this._state !== DataState.PENDING) {
       throw new Error('DataSet has already been loaded');
     }
     this._loadingPromise = Promise.resolve();
-    this._initialize(json);
+    await this._initialize(json);
   }
 
   /**
    * @param {ObliqueImageJson} json
    * @private
    */
-  _initialize(json) {
+  async _initialize(json) {
+    if (this._terrainProviderOptions?.url) {
+      const terrainProviderOptions = {
+        requestVertexNormals: this._terrainProviderOptions.requestVertexNormals,
+        requestWaterMask: this._terrainProviderOptions.requestWaterMask,
+      };
+      this._terrainProvider = await getTerrainProviderForUrl(
+        this._terrainProviderOptions.url,
+        terrainProviderOptions,
+      );
+    }
     this._parseMetaData(json);
     this._state = DataState.READY;
   }
@@ -218,7 +219,7 @@ class ObliqueDataSet {
       json,
       this.baseUrl,
       this.projection,
-      this.terrainProvider,
+      this._terrainProvider,
     );
     const { version, buildNumber } = getVersionFromImageJson(json);
 

package/src/util/clipping/clippingObject.js

@@ -215,12 +215,10 @@ class ClippingObject {
               /** @param {import("@vcmap-cesium/engine").Cesium3DTileset} tileset */ (
                 tileset,
               ) => {
-                tileset.readyPromise.then((cesium3DTileset) => {
-                  if (this.layerNames.includes(layer.name) && layer.active) {
-                    this.targets.set(layer.name, cesium3DTileset);
-                    this.targetsUpdated.raiseEvent();
-                  }
-                });
+                if (this.layerNames.includes(layer.name) && layer.active) {
+                  this.targets.set(layer.name, tileset);
+                  this.targetsUpdated.raiseEvent();
+                }
               },
             );
           } else {

package/tests/unit/helpers/obliqueHelpers.js

@@ -47,7 +47,7 @@ function getStartingViewpoint() {
  * @param {Scope=} scope if provided the dataset is initialized with a terrainProvider
  * @returns {vcs-oblique/ObliqueDataSet}
  */
-export function getObliqueDataSet(scope) {
+export async function getObliqueDataSet(scope) {
   if (!obliqueProjection) {
     obliqueProjection = new Projection({
       epsg: 'EPSG:25833',
@@ -56,7 +56,7 @@ export function getObliqueDataSet(scope) {
   }
   let terrainProvider;
   if (scope) {
-    getTerrainProvider(scope);
+    await getTerrainProvider(scope);
     terrainProvider = {
       url: 'http://localhost/terrain/',
     };
@@ -66,7 +66,7 @@ export function getObliqueDataSet(scope) {
     obliqueProjection,
     terrainProvider,
   );
-  obliqueDataSet.initialize(imageJson);
+  await obliqueDataSet.initialize(imageJson);
   return obliqueDataSet;
 }
 
@@ -74,8 +74,8 @@ export function getObliqueDataSet(scope) {
  * @param {Array<ObliqueDataSet>=} obliqueDataSets
  * @returns {ObliqueCollection}
  */
-export function getObliqueCollection(obliqueDataSets) {
-  const dataSets = obliqueDataSets || [getObliqueDataSet()];
+export async function getObliqueCollection(obliqueDataSets) {
+  const dataSets = obliqueDataSets || [await getObliqueDataSet()];
   const obliqueCollection = new ObliqueCollection({
     name: 'obliqueCollection',
     dataSets,
@@ -89,8 +89,8 @@ export function getObliqueCollection(obliqueDataSets) {
  * @returns {Promise<ObliqueMap>}
  */
 export async function getObliqueMap(mapOptions = {}, scope = undefined) {
-  const obliqueDataSet = getObliqueDataSet(scope);
-  const obliqueCollection = getObliqueCollection([obliqueDataSet]);
+  const obliqueDataSet = await getObliqueDataSet(scope);
+  const obliqueCollection = await getObliqueCollection([obliqueDataSet]);
   const map = new ObliqueMap(mapOptions);
   await map.initialize();
   await map.setCollection(obliqueCollection);

package/tests/unit/helpers/terrain/terrainData.js

@@ -37,11 +37,9 @@ export function setTerrainServer(scope) {
 
 /**
  * @param {Scope} scope
- * @returns {cesium/CesiumTerrainProvider}
+ * @returns {Promise<cesium/CesiumTerrainProvider>}
  */
-export function getTerrainProvider(scope) {
+export async function getTerrainProvider(scope) {
   setTerrainServer(scope);
-  return new CesiumTerrainProvider({
-    url: 'http://localhost/terrain/',
-  });
+  return CesiumTerrainProvider.fromUrl('http://localhost/terrain/', {});
 }