@vcmap/core 5.0.3 → 5.1.0-rc.2

package/src/layer/vectorLayer.ts

@@ -16,7 +16,7 @@ import type {
 } from '@vcmap-cesium/engine';
 
 import { v4 as uuidv4 } from 'uuid';
-import { check } from '@vcsuite/check';
+import { check, oneOf } from '@vcsuite/check';
 import { parseBoolean } from '@vcsuite/parsers';
 import Projection, {
   getDefaultProjection,
@@ -78,7 +78,12 @@ export type VectorOptions = FeatureLayerOptions & {
 
 export type VectorGeometryFactoryType = {
   getCoordinates(geom: SimpleGeometry[]): Coordinate[];
-  getGeometryOptions(geom: SimpleGeometry, num: number): unknown;
+  getGeometryOptions(
+    geom: SimpleGeometry,
+    num: number,
+    perPositionHeight: boolean,
+    groundLevelOrMinHeight: number,
+  ): unknown;
   createSolidGeometries(
     obj: unknown,
     num: number,
@@ -101,11 +106,6 @@ export type VectorGeometryFactoryType = {
     style: Style,
   ): GroundPolylineGeometry[];
   createLineGeometries(obj: unknown, style: Style): PolylineGeometry[];
-  createLineGeometries(
-    obj: unknown,
-    style: Style,
-    groundLevel?: number,
-  ): PolylineGeometry[];
 };
 
 export type VectorHeightInfo = {
@@ -415,7 +415,7 @@ class VectorLayer
    * sets the highlightstyle of this layer
    */
   setHighlightStyle(style: Style | StyleFunction | VectorStyleItem): void {
-    check(style, [Style, VectorStyleItem, Function]);
+    check(style, oneOf(Style, VectorStyleItem, Function));
     if (style instanceof VectorStyleItem) {
       this.highlightStyle = style;
     } else {
@@ -500,7 +500,7 @@ class VectorLayer
    * feature geometries are always in EPSG 3857 mercator coordinate system
    */
   getFeaturesById(ids: (string | number)[]): Feature[] {
-    check(ids, [[String, Number]]);
+    check(ids, [oneOf(String, Number)]);
     return ids
       .map((id) => this.getFeatureById(id))
       .filter((f) => f != null) as Feature[];

package/src/layer/vectorProperties.ts

@@ -10,7 +10,7 @@ import {
   NearFarScalar,
   type SphereGeometry,
 } from '@vcmap-cesium/engine';
-import { check, checkMaybe } from '@vcsuite/check';
+import { check, maybe, ofEnum } from '@vcsuite/check';
 import type { Coordinate } from 'ol/coordinate.js';
 import type { Color } from 'ol/color.js';
 import type { ColorLike } from 'ol/colorlike.js';
@@ -24,10 +24,12 @@ import { getLogger as getLoggerByName, type Logger } from '@vcsuite/logger';
 import VcsEvent from '../vcsEvent.js';
 import { DeclarativeStyleItemOptions } from '../style/declarativeStyleItem.js';
 import { VectorStyleItemOptions } from '../style/vectorStyleItem.js';
+import type { FlightInstanceMeta } from '../util/flight/flightInstance.js';
 
 function getLogger(): Logger {
   return getLoggerByName('VectorProperties');
 }
+
 export enum PrimitiveOptionsType {
   CYLINDER = 'cylinder',
   SPHERE = 'sphere',
@@ -72,11 +74,18 @@ export function vectorPropertiesOfType<T extends PrimitiveOptionsType>(
   return options.type === type;
 }
 
+export type AltitudeModeType =
+  | 'absolute'
+  | 'relativeToGround'
+  | 'clampToGround';
+
+export type ClassificationTypeType = 'both' | 'terrain' | 'cesium3DTile';
+
 export type VectorPropertiesOptions = {
   /**
    * (3D) Either "relativeToGround", "clampToGround" or 'absolute'
    */
-  altitudeMode?: string;
+  altitudeMode?: AltitudeModeType;
   /**
    * if the features are pickable
    */
@@ -84,7 +93,7 @@ export type VectorPropertiesOptions = {
   /**
    * (3D) the cesium classification type for this layer. one of 'both', 'terrain' or 'cesium3DTile'
    */
-  classificationType?: string;
+  classificationType?: ClassificationTypeType;
   /**
    * (3D) Array with 4 numbers by which features are being scaled based on distance see <a href="https://cesium.com/docs/cesiumjs-ref-doc/Billboard.html#scaleByDistance"> here </a>
    */
@@ -152,7 +161,7 @@ export type VcsMeta = VectorPropertiesOptions & {
   style?: VectorStyleItemOptions | DeclarativeStyleItemOptions;
   embeddedIcons?: string[];
   screenSpaceError?: number;
-  flightOptions?: unknown;
+  flightOptions?: FlightInstanceMeta;
   baseUrl?: string;
   /**
    * the layers properties bag
@@ -181,13 +190,16 @@ export type VectorPropertiesPrimitive = VectorPropertiesBaseOptions & {
  */
 export const vcsMetaVersion = '2.1';
 
-export const AltitudeModeCesium = {
+export const AltitudeModeCesium: Record<AltitudeModeType, HeightReference> = {
   clampToGround: HeightReference.CLAMP_TO_GROUND,
   absolute: HeightReference.NONE,
   relativeToGround: HeightReference.RELATIVE_TO_GROUND,
 };
 
-export const ClassificationTypeCesium = {
+export const ClassificationTypeCesium: Record<
+  ClassificationTypeType,
+  ClassificationType
+> = {
   both: ClassificationType.BOTH,
   cesium3DTile: ClassificationType.CESIUM_3D_TILE,
   terrain: ClassificationType.TERRAIN,
@@ -246,19 +258,27 @@ export function parseStoreyHeights(
   return defaultStoreyHeights;
 }
 
-export function getAltitudeModeOptions(altitudeMode: HeightReference): string {
-  for (const [key, mode] of Object.entries(AltitudeModeCesium)) {
+export function getAltitudeModeOptions(
+  altitudeMode: HeightReference,
+): AltitudeModeType {
+  for (const [key, mode] of Object.entries(AltitudeModeCesium) as [
+    AltitudeModeType,
+    HeightReference,
+  ][]) {
     if (mode === altitudeMode) {
       return key;
     }
   }
-  throw new Error(`Unkown altitude mode ${altitudeMode}`);
+  throw new Error(`Unknown altitude mode ${altitudeMode}`);
 }
 
 export function getClassificationTypeOptions(
   classificationType?: ClassificationType,
-): string | undefined {
-  for (const [key, mode] of Object.entries(ClassificationTypeCesium)) {
+): ClassificationTypeType | undefined {
+  for (const [key, mode] of Object.entries(ClassificationTypeCesium) as [
+    ClassificationTypeType,
+    ClassificationType,
+  ][]) {
     if (mode === classificationType) {
       return key;
     }
@@ -484,7 +504,7 @@ class VectorProperties {
 
   set altitudeMode(altitudeMode: HeightReference) {
     if (altitudeMode !== this._altitudeMode) {
-      check(altitudeMode, Object.values(HeightReference));
+      check(altitudeMode, ofEnum(HeightReference));
       this._altitudeMode = altitudeMode;
       this.propertyChanged.raiseEvent(['altitudeMode']);
     }
@@ -521,7 +541,7 @@ class VectorProperties {
 
   set classificationType(classificationType: ClassificationType | undefined) {
     if (classificationType !== this._classificationType) {
-      checkMaybe(classificationType, Object.values(ClassificationType));
+      check(classificationType, maybe(ofEnum(ClassificationType)));
       this._classificationType = classificationType;
       this.propertyChanged.raiseEvent(['classificationType']);
     }
@@ -541,7 +561,7 @@ class VectorProperties {
 
   set scaleByDistance(value: NearFarScalar | undefined) {
     if (!NearFarScalar.equals(value, this._scaleByDistance)) {
-      checkMaybe(value, NearFarScalar);
+      check(value, maybe(NearFarScalar));
       this._scaleByDistance = value;
       this.propertyChanged.raiseEvent(['scaleByDistance']);
     }
@@ -560,7 +580,7 @@ class VectorProperties {
 
   set eyeOffset(value: Cartesian3 | undefined) {
     if (!Cartesian3.equals(this.eyeOffset, value)) {
-      checkMaybe(value, Cartesian3);
+      check(value, maybe(Cartesian3));
       this._eyeOffset = value;
       this.propertyChanged.raiseEvent(['eyeOffset']);
     }
@@ -624,7 +644,7 @@ class VectorProperties {
 
   set groundLevel(value: number | undefined) {
     if (value !== this._groundLevel) {
-      checkMaybe(value, Number);
+      check(value, maybe(Number));
       this._groundLevel = value;
       this.propertyChanged.raiseEvent(['groundLevel']);
     }
@@ -731,7 +751,7 @@ class VectorProperties {
   }
 
   set modelUrl(value: string | undefined) {
-    checkMaybe(value, String);
+    check(value, maybe(String));
 
     if (this._modelUrl !== value) {
       this._modelUrl = value;
@@ -855,7 +875,7 @@ class VectorProperties {
   }
 
   set modelOptions(modelOptions: Record<string, unknown> | undefined) {
-    checkMaybe(modelOptions, Object);
+    check(modelOptions, maybe(Object));
 
     if (this._modelOptions !== modelOptions) {
       this._modelOptions = modelOptions;
@@ -885,7 +905,7 @@ class VectorProperties {
   }
 
   set modelAutoScale(value: boolean) {
-    checkMaybe(value, Boolean);
+    check(value, maybe(Boolean));
 
     const booleanValue = !!value;
     if (this._modelAutoScale !== booleanValue) {
@@ -906,7 +926,7 @@ class VectorProperties {
   }
 
   set baseUrl(value: string | undefined) {
-    checkMaybe(value, String);
+    check(value, maybe(String));
 
     if (this._baseUrl !== value) {
       this._baseUrl = value;
@@ -924,7 +944,7 @@ class VectorProperties {
   }
 
   set primitiveOptions(value: VectorPropertiesPrimitiveOptions | undefined) {
-    checkMaybe(value, Object);
+    check(value, maybe(Object));
 
     if (this._primitiveOptions !== value) {
       this._primitiveOptions = value;
@@ -1282,11 +1302,15 @@ class VectorProperties {
   /**
    * The common vector properties for the input features.
    * @param features Features for which the vector property values should be returned.
-   * @returns The common vector properties for the features. When a/all feature(s) does not has a property set, the layer or, if not set, the default value is returned. If features have different values for a property, the property key is not added to the returned obeject.
+   * @returns The common vector properties for the features. When a/all feature(s) does not has a property set, the layer or, if not set, the default value is returned. If features have different values for a property, the property key is not added to the returned obeject. If feature array is empty, an empty object is returned.
    */
   getValuesForFeatures(features: Feature[]): VectorPropertiesOptions {
     const values: VectorPropertiesOptions = {};
 
+    if (!features.length) {
+      return values;
+    }
+
     /**
      * Checks if all the values of the array are equal using fast-deep-equal.
      * @param propertyValues An array of values for a specific property from different features.

package/src/layer/wfsLayer.ts

@@ -2,7 +2,7 @@ import WFSFormat from 'ol/format/WFS.js';
 import VectorLayer, { VectorOptions } from './vectorLayer.js';
 import Projection from '../util/projection.js';
 import { layerClassRegistry } from '../classRegistry.js';
-import { requestUrl } from '../util/fetch.js';
+import { getInitForUrl, requestUrl } from '../util/fetch.js';
 
 export type WFSOptions = VectorOptions & {
   /**
@@ -125,13 +125,16 @@ class WFSLayer extends VectorLayer {
         ...this.getFeaturesOptions,
       });
       const postData = new XMLSerializer().serializeToString(requestDocument);
-      this._dataFetchedPromise = requestUrl(this.url, {
-        method: 'POST',
-        headers: {
+      const init = getInitForUrl(this.url, this.headers);
+      init.method = 'POST';
+      init.body = postData;
+      init.headers = {
+        ...init.headers,
+        ...{
           'Content-Type': 'application/text+xml',
         },
-        body: postData,
-      })
+      };
+      this._dataFetchedPromise = requestUrl(this.url, init)
         .then((response) => response.text())
         .then((data) => this._parseWFSData(data))
         .catch((err) => {

package/src/layer/wmsHelpers.ts

@@ -1,5 +1,11 @@
+import { TrustedServers } from '@vcmap-cesium/engine';
+import { getLogger } from '@vcsuite/logger';
 import type { Size } from 'ol/size.js';
 import TileWMS, { type Options as TileWMSOptions } from 'ol/source/TileWMS.js';
+import ImageWMS, {
+  type Options as ImageWMSOptions,
+} from 'ol/source/ImageWMS.js';
+
 import { getTopLeft, getWidth } from 'ol/extent.js';
 import TileGrid, {
   type Options as TileGridOptions,
@@ -8,6 +14,8 @@ import { mercatorProjection, wgs84Projection } from '../util/projection.js';
 import { isSameOrigin } from '../util/urlHelpers.js';
 import type Extent from '../util/extent.js';
 import { TilingScheme } from './rasterLayer.js';
+import { getTileLoadFunction } from './openlayers/loadFunctionHelpers.js';
+import { getInitForUrl, requestObjectUrl } from '../util/fetch.js';
 
 export type WMSSourceOptions = {
   url: string;
@@ -18,9 +26,23 @@ export type WMSSourceOptions = {
   extent?: Extent;
   parameters: Record<string, string>;
   version: string;
+  headers?: Record<string, string>;
 };
 
-// eslint-disable-next-line import/prefer-default-export
+export function getProjectionFromWMSSourceOptions(
+  tilingSchema: TilingScheme,
+  version: string,
+): string {
+  if (tilingSchema === 'geographic') {
+    if (version === '1.3.0') {
+      return 'CRS:84';
+    } else {
+      return 'EPSG:4326';
+    }
+  }
+  return 'EPSG:3857';
+}
+
 export function getWMSSource(options: WMSSourceOptions): TileWMS {
   const projection =
     options.tilingSchema === 'geographic'
@@ -55,18 +77,64 @@ export function getWMSSource(options: WMSSourceOptions): TileWMS {
     url: options.url,
     tileGrid: new TileGrid(tilingOptions),
     params: options.parameters,
+    projection: getProjectionFromWMSSourceOptions(
+      options.tilingSchema,
+      options.version,
+    ),
   };
-  if (!isSameOrigin(options.url)) {
+
+  if (TrustedServers.contains(options.url)) {
+    sourceOptions.crossOrigin = 'use-credentials';
+  } else if (!isSameOrigin(options.url)) {
     sourceOptions.crossOrigin = 'anonymous';
   }
-  if (options.tilingSchema === 'geographic') {
-    if (options.version === '1.3.0') {
-      sourceOptions.projection = 'CRS:84';
-    } else {
-      sourceOptions.projection = 'EPSG:4326';
-    }
-  } else {
-    sourceOptions.projection = 'EPSG:3857';
+  if (options.headers) {
+    sourceOptions.tileLoadFunction = getTileLoadFunction(options.headers);
   }
   return new TileWMS(sourceOptions);
 }
+
+export function getImageWMSSource(options: {
+  url: string;
+  parameters: Record<string, string>;
+  tilingSchema: TilingScheme;
+  version: string;
+  headers?: Record<string, string>;
+}): ImageWMS {
+  const sourceOptions: ImageWMSOptions = {
+    url: options.url,
+    params: options.parameters,
+    projection: getProjectionFromWMSSourceOptions(
+      options.tilingSchema,
+      options.version,
+    ),
+  };
+
+  if (TrustedServers.contains(options.url)) {
+    sourceOptions.crossOrigin = 'use-credentials';
+  } else if (!isSameOrigin(options.url)) {
+    sourceOptions.crossOrigin = 'anonymous';
+  }
+
+  if (options.headers) {
+    sourceOptions.imageLoadFunction = function imageLoadFunction(
+      image,
+      src,
+    ): void {
+      const img = image.getImage() as HTMLImageElement;
+      const init = getInitForUrl(src, options.headers);
+      requestObjectUrl(src, init)
+        .then((blobUrl) => {
+          img.src = blobUrl;
+          img.onload = (): void => {
+            URL.revokeObjectURL(blobUrl);
+          };
+        })
+        .catch(() => {
+          getLogger('ImageWMSSource').error(`Could not load image: ${src}`);
+        });
+    };
+  }
+
+  return new ImageWMS(sourceOptions);
+}

package/src/layer/wmsLayer.ts

@@ -1,4 +1,4 @@
-import { check } from '@vcsuite/check';
+import { check, oneOf } from '@vcsuite/check';
 import { parseBoolean } from '@vcsuite/parsers';
 import type { Size } from 'ol/size.js';
 
@@ -22,6 +22,7 @@ export type WMSImplementationOptions = RasterLayerImplementationOptions & {
   highResolution: boolean;
   tileSize: import('ol/size.js').Size;
   version: string;
+  singleImage2d: boolean;
 };
 
 export type WMSOptions = RasterLayerOptions & {
@@ -50,6 +51,10 @@ export type WMSOptions = RasterLayerOptions & {
    * use higher resolution images (sofar only in 3D)
    */
   highResolution?: boolean;
+  /**
+   * Use a single image in 2D
+   */
+  singleImage2d?: boolean;
 };
 
 /**
@@ -81,6 +86,8 @@ class WMSLayer extends RasterLayer<WmsCesiumImpl | WmsOpenlayersImpl> {
 
   highResolution: boolean;
 
+  singleImage2d: boolean;
+
   private _featureInfoOptions: Partial<WMSFeatureProviderOptions> | undefined;
 
   /**
@@ -127,6 +134,7 @@ class WMSLayer extends RasterLayer<WmsCesiumImpl | WmsOpenlayersImpl> {
     this._featureInfoOptions =
       options.featureInfo || defaultOptions.featureInfo;
     this._supportedMaps = [CesiumMap.className, OpenlayersMap.className];
+    this.singleImage2d = parseBoolean(options.singleImage2d, false);
   }
 
   initialize(): Promise<void> {
@@ -171,6 +179,7 @@ class WMSLayer extends RasterLayer<WmsCesiumImpl | WmsOpenlayersImpl> {
       parameters: this.parameters,
       highResolution: this.highResolution,
       tileSize: this.tileSize,
+      singleImage2d: this.singleImage2d,
     };
   }
 
@@ -190,7 +199,7 @@ class WMSLayer extends RasterLayer<WmsCesiumImpl | WmsOpenlayersImpl> {
    * @param  layers - a layer name or an array of layer names
    */
   async setLayers(layers: string | string[]): Promise<void> {
-    check(layers, [String, [String]]);
+    check(layers, oneOf(String, [String]));
     const layersArray = Array.isArray(layers) ? layers : [layers];
     this.parameters.LAYERS = layersArray.join(',');
     await this.forceRedraw();

package/src/map/cameraLimiter.ts

@@ -1,3 +1,4 @@
+import deepEqual from 'fast-deep-equal';
 import {
   Camera,
   Cartographic,
@@ -6,7 +7,7 @@ import {
   sampleTerrain,
   sampleTerrainMostDetailed,
 } from '@vcmap-cesium/engine';
-import { checkMaybe } from '@vcsuite/check';
+import { check, maybe } from '@vcsuite/check';
 import { parseInteger, parseNumber, parseEnumValue } from '@vcsuite/parsers';
 import {
   getTerrainProviderForUrl,
@@ -26,6 +27,10 @@ export type CameraLimiterOptions = {
    *  required if mode is distance.
    */
   terrainUrl?: string;
+  /**
+   * if mode is distance this can be used to send headers with each request to the terrainUrl
+   */
+  terrainRequestHeaders?: Record<string, string>;
   /**
    * @default 'height'
    */
@@ -53,6 +58,7 @@ class CameraLimiter {
     return {
       mode: CameraLimiterMode.HEIGHT,
       terrainUrl: undefined,
+      terrainRequestHeaders: undefined,
       limit: 200,
       level: 12,
     };
@@ -80,6 +86,8 @@ class CameraLimiter {
    */
   lastCheckedPosition = new Cartographic();
 
+  terrainRequestHeaders?: Record<string, string>;
+
   /**
    * last updated terrain height
    */
@@ -101,6 +109,7 @@ class CameraLimiter {
       options.level === null
         ? null
         : parseInteger(options.level, defaultOptions.level as number);
+    this.terrainRequestHeaders = options.terrainRequestHeaders;
   }
 
   /**
@@ -111,7 +120,7 @@ class CameraLimiter {
   }
 
   set terrainUrl(url: string | undefined) {
-    checkMaybe(url, String);
+    check(url, maybe(String));
 
     if (this._terrainUrl !== url) {
       this._terrainUrl = url;
@@ -124,6 +133,7 @@ class CameraLimiter {
     const terrainProvider = await getTerrainProviderForUrl(
       this.terrainUrl as string,
       {},
+      this.terrainRequestHeaders,
     );
     if (
       this.level &&
@@ -140,6 +150,7 @@ class CameraLimiter {
     const terrainProvider = await getTerrainProviderForUrl(
       this.terrainUrl as string,
       {},
+      this.terrainRequestHeaders,
     );
     return sampleTerrainMostDetailed(terrainProvider, [cameraCartographic]);
   }
@@ -222,6 +233,14 @@ class CameraLimiter {
     if (this.level !== defaultOptions.level) {
       config.level = this.level;
     }
+    if (
+      !deepEqual(
+        this.terrainRequestHeaders,
+        defaultOptions.terrainRequestHeaders,
+      )
+    ) {
+      config.terrainRequestHeaders = this.terrainRequestHeaders;
+    }
     return config;
   }
 }

package/src/map/cesiumMap.ts

@@ -36,10 +36,11 @@ import {
   type EntityCluster,
   type DataSource,
   type Visualizer,
+  type ShadowMap,
 } from '@vcmap-cesium/engine';
 import type { Coordinate } from 'ol/coordinate.js';
 
-import { checkMaybe } from '@vcsuite/check';
+import { check, maybe } from '@vcsuite/check';
 import { parseBoolean, parseInteger, parseNumber } from '@vcsuite/parsers';
 import VcsMap, { type VcsMapOptions } from './vcsMap.js';
 import Viewpoint from '../util/viewpoint.js';
@@ -55,6 +56,7 @@ import CameraLimiter, { CameraLimiterOptions } from './cameraLimiter.js';
 import { mapClassRegistry } from '../classRegistry.js';
 import type LayerCollection from '../util/layerCollection.js';
 import type Layer from '../layer/layer.js';
+import VcsEvent from '../vcsEvent.js';
 
 export type CesiumMapOptions = VcsMapOptions & {
   /**
@@ -327,6 +329,18 @@ class CesiumMap extends VcsMap<CesiumVisualisationType> {
 
   defaultJDate: JulianDate;
 
+  /**
+   * The defaultShadowMap which is created when calling the constructor of the CesiumWidet in {@link initialize}. This is a reference, not a clone.
+   */
+  private _defaultShadowMap: ShadowMap | null;
+
+  /**
+   * A cache of the shadowMap that is set, before {@link initialize} is called. It is applied as soon the instance is initialized.
+   */
+  private _initialShadowMap: ShadowMap | null;
+
+  shadowMapChanged: VcsEvent<ShadowMap>;
+
   webGLaa: boolean;
 
   globeColor: Color;
@@ -383,6 +397,12 @@ class CesiumMap extends VcsMap<CesiumVisualisationType> {
 
     this.defaultJDate = JulianDate.fromDate(new Date(2014, 6, 20, 13, 0, 0, 0));
 
+    this._defaultShadowMap = null;
+
+    this._initialShadowMap = null;
+
+    this.shadowMapChanged = new VcsEvent();
+
     this.webGLaa = parseBoolean(options.webGLaa, defaultOptions.webGLaa);
 
     this.useOriginalCesiumShader = parseBoolean(
@@ -459,7 +479,7 @@ class CesiumMap extends VcsMap<CesiumVisualisationType> {
   }
 
   set cameraLimiter(limiter: CameraLimiter | null) {
-    checkMaybe(limiter, CameraLimiter);
+    check(limiter, maybe(CameraLimiter));
 
     if (this._cameraLimiter !== limiter) {
       this._cameraLimiter = limiter;
@@ -732,6 +752,13 @@ class CesiumMap extends VcsMap<CesiumVisualisationType> {
           },
         ),
       );
+
+      this._defaultShadowMap = this._cesiumWidget.scene.shadowMap;
+
+      if (this._initialShadowMap) {
+        this.setShadowMap(this._initialShadowMap);
+        this._initialShadowMap = null;
+      }
     }
     return Promise.resolve();
   }
@@ -1023,6 +1050,40 @@ class CesiumMap extends VcsMap<CesiumVisualisationType> {
     }
   }
 
+  /**
+   * Sets a shadow map on the scene of the cesiumMaps cesiumWidget. Raises an event if the shadow map changes. This function should be used to set the shadowMap instead of setting it directly on the scene.
+   * @param shadowMap The shadowMap to assign to the scene of the cesium widget.
+   */
+  setShadowMap(shadowMap: ShadowMap): void {
+    if (!shadowMap) {
+      return;
+    }
+
+    if (!this._cesiumWidget) {
+      this._initialShadowMap = shadowMap;
+      return;
+    }
+
+    const { scene } = this._cesiumWidget;
+
+    if (scene.shadowMap !== shadowMap) {
+      scene.shadowMap = shadowMap;
+      this.shadowMapChanged.raiseEvent(shadowMap);
+    }
+  }
+
+  /**
+   * Sets the default shadow map.
+   */
+  setDefaultShadowMap(): void {
+    if (!this._cesiumWidget || !this._defaultShadowMap) {
+      this._initialShadowMap = null;
+      return;
+    }
+
+    this.setShadowMap(this._defaultShadowMap);
+  }
+
   /**
    * returns the cesium Widget Object
    */
@@ -1380,6 +1441,10 @@ class CesiumMap extends VcsMap<CesiumVisualisationType> {
       this._cesiumWidget = null;
     }
 
+    this._initialShadowMap = null;
+    this._defaultShadowMap = null;
+    this.shadowMapChanged.destroy();
+
     super.destroy();
   }
 }