@vcmap/core 6.0.0-rc.9 → 6.0.1

package/src/interaction/featureAtPixelInteraction.ts

@@ -5,7 +5,6 @@ import {
   Cesium3DTileFeature,
   Cesium3DTilePointFeature,
   Entity,
-  CesiumWidget,
 } from '@vcmap-cesium/engine';
 import type { Feature } from 'ol/index.js';
 import type { Layer as OLLayer } from 'ol/layer.js';
@@ -30,9 +29,10 @@ import type CesiumMap from '../map/cesiumMap.js';
  * @group Interaction
  */
 class FeatureAtPixelInteraction extends AbstractInteraction {
-  private _pickPosition = EventType.CLICK;
-
-  private _pickPositionMask = -1;
+  /**
+   * event type for which to pick the position of the scene. this will create a second render.
+   */
+  pickPosition = EventType.CLICK;
 
   /**
    * whether to pick translucent depth or not, defaults to true
@@ -60,30 +60,8 @@ class FeatureAtPixelInteraction extends AbstractInteraction {
     this.setActive();
   }
 
-  /**
-   * Bitmask of {@link EventType} for which events to pick the position
-   */
-  get pickPosition(): EventType {
-    return this._pickPosition;
-  }
-
-  set pickPosition(position: EventType) {
-    this._pickPosition = position & this._pickPositionMask;
-  }
-
-  /**
-   * Bitmask of  for which to never pick positions.
-   */
-  get excludedPickPositionEvents(): number {
-    return ~this._pickPositionMask;
-  }
-
-  set excludedPickPositionEvents(position: number) {
-    this._pickPositionMask = ~position;
-  }
-
   async pipe(event: InteractionEvent): Promise<InteractionEvent> {
-    if (event.type & EventType.DRAG && !(this._pickPosition & EventType.DRAG)) {
+    if (event.type & EventType.DRAG && !(this.pickPosition & EventType.DRAG)) {
       if (this._draggingFeature) {
         event.feature = this._draggingFeature;
       }
@@ -209,6 +187,7 @@ class FeatureAtPixelInteraction extends AbstractInteraction {
         scratchCartesian = new Cartesian3();
         return Promise.resolve(event);
       }
+
       if (this.pullPickedPosition && event.ray) {
         scratchPullCartesian = Cartesian3.multiplyByScalar(
           event.ray.direction,
@@ -227,6 +206,7 @@ class FeatureAtPixelInteraction extends AbstractInteraction {
         scene.globe.ellipsoid,
         scratchCartographic,
       );
+
       event.position = Projection.wgs84ToMercator(
         [
           CesiumMath.toDegrees(scratchCartographic.longitude),
@@ -277,19 +257,8 @@ class FeatureAtPixelInteraction extends AbstractInteraction {
       }
 
       if (scene.pickPositionSupported) {
-        if (
-          object.primitive &&
-          this.pickTranslucent &&
-          !(
-            object.primitive.pointCloudShading &&
-            object.primitive.pointCloudShading.attenuation
-          )
-        ) {
-          // XXX should this always be on, also for non vector?
+        if (object.primitive && this.pickTranslucent) {
           scene.pickTranslucentDepth = true;
-          scene.render(
-            (cesiumMap.getCesiumWidget() as CesiumWidget).clock.currentTime,
-          );
           event.exactPosition = true;
         }
         scratchCartesian = scene.pickPosition(

package/src/layer/cesium/openStreetMapCesiumImpl.ts

@@ -13,13 +13,11 @@ class OpenStreetMapCesiumImpl extends RasterLayerCesiumImpl {
   }
 
   getCesiumLayer(): Promise<CesiumImageryLayer> {
+    const layerOptions = this.getCesiumLayerOptions();
     return Promise.resolve(
       new CesiumImageryLayer(
         new OpenStreetMapImageryProvider({ maximumLevel: this.maxLevel }),
-        {
-          alpha: this.opacity,
-          splitDirection: this.splitDirection,
-        },
+        layerOptions,
       ),
     );
   }

package/src/layer/cesium/rasterLayerCesiumImpl.ts

@@ -25,20 +25,29 @@ class RasterLayerCesiumImpl
 
   maxLevel: number;
 
+  minRenderingLevel: number | undefined;
+
+  maxRenderingLevel: number | undefined;
+
   extent: Extent | undefined;
 
   opacity: number;
 
   tilingSchema: TilingScheme;
 
+  imageryLayerOptions: ImageryLayer.ConstructorOptions | undefined;
+
   constructor(map: CesiumMap, options: RasterLayerImplementationOptions) {
     super(map, options);
     this.splitDirection = options.splitDirection;
     this.minLevel = options.minLevel;
     this.maxLevel = options.maxLevel;
+    this.minRenderingLevel = options.minRenderingLevel;
+    this.maxRenderingLevel = options.maxRenderingLevel;
     this.extent = options.extent;
     this.opacity = options.opacity;
     this.tilingSchema = options.tilingSchema;
+    this.imageryLayerOptions = options.imageryLayerOptions;
   }
 
   async initialize(): Promise<void> {
@@ -62,6 +71,16 @@ class RasterLayerCesiumImpl
     }
   }
 
+  getCesiumLayerOptions(): ImageryLayer.ConstructorOptions {
+    return {
+      ...this.imageryLayerOptions,
+      alpha: this.opacity,
+      splitDirection: this.splitDirection,
+      minimumTerrainLevel: this.minRenderingLevel,
+      maximumTerrainLevel: this.maxRenderingLevel,
+    };
+  }
+
   // eslint-disable-next-line class-methods-use-this
   getCesiumLayer(): Promise<ImageryLayer> {
     throw new Error('implementation error');

package/src/layer/cesium/singleImageCesiumImpl.ts

@@ -43,12 +43,8 @@ class SingleImageCesiumImpl extends RasterLayerCesiumImpl {
       getResourceOrUrl(this.url!, this.headers),
       options,
     );
-    const layerOptions = {
-      rectangle: options.rectangle,
-      alpha: this.opacity,
-      defaultAlpha: 1.0,
-      splitDirection: this.splitDirection,
-    };
+    const layerOptions = this.getCesiumLayerOptions();
+    layerOptions.rectangle = options.rectangle;
     return new ImageryLayer(imageryProvider, layerOptions);
   }
 }

package/src/layer/cesium/terrainCesiumImpl.ts

@@ -56,6 +56,9 @@ class TerrainCesiumImpl extends LayerImplementation<CesiumMap> {
   }
 
   destroy(): void {
+    if (this.terrainProvider) {
+      this.map.unsetTerrainProvider(this.terrainProvider);
+    }
     this.terrainProvider = undefined;
     super.destroy();
   }

package/src/layer/cesium/tmsCesiumImpl.ts

@@ -52,11 +52,8 @@ class TmsCesiumImpl extends RasterLayerCesiumImpl {
       getResourceOrUrl(this.url!, this.headers),
       options,
     );
-    const layerOptions = {
-      alpha: this.opacity,
-      splitDirection: this.splitDirection,
-    };
 
+    const layerOptions = this.getCesiumLayerOptions();
     return new CesiumImageryLayer(imageryProvider, layerOptions);
   }
 }

package/src/layer/cesium/vcsTile/vcsChildTile.ts

@@ -0,0 +1,31 @@
+import { QuadtreeTile, TileBoundingRegion } from '@vcmap-cesium/engine';
+import {
+  getTileBoundingRegion,
+  VcsTile,
+  VcsTileState,
+  VcsTileType,
+} from './vcsTileHelpers.js';
+import type CesiumMap from '../../../map/cesiumMap.js';
+
+export default class VcsChildTile implements VcsTile {
+  state = VcsTileState.LOADING;
+
+  type = VcsTileType.CHILD;
+
+  tileBoundingRegion: TileBoundingRegion;
+
+  private _tile: QuadtreeTile<VcsTile>;
+
+  constructor(tile: QuadtreeTile<VcsTile>, map: CesiumMap) {
+    this.tileBoundingRegion = getTileBoundingRegion(tile, map);
+    this.state = VcsTileState.READY;
+    this._tile = tile;
+  }
+
+  get show(): boolean {
+    return this._tile.parent?.data?.show ?? false;
+  }
+
+  // eslint-disable-next-line class-methods-use-this,@typescript-eslint/no-empty-function
+  set show(_show: boolean) {}
+}

package/src/layer/cesium/vcsTile/vcsDebugTile.ts

@@ -0,0 +1,154 @@
+import {
+  PrimitiveCollection,
+  QuadtreeTile,
+  SplitDirection,
+  TileBoundingRegion,
+} from '@vcmap-cesium/engine';
+import { getLogger } from '@vcsuite/logger';
+import { Feature } from 'ol';
+import { Point } from 'ol/geom.js';
+import { getCenter } from 'ol/extent.js';
+import { fromExtent } from 'ol/geom/Polygon.js';
+import { Style, Text as OLText } from 'ol/style.js';
+import { StyleLike } from 'ol/style/Style.js';
+import VectorContext from '../vectorContext.js';
+import { vcsLayerName } from '../../layerSymbols.js';
+import {
+  getTileBoundingRegion,
+  getTileHash,
+  getTileWgs84Extent,
+  VcsTile,
+  VcsTileOptions,
+  VcsTileState,
+  VcsTileType,
+} from './vcsTileHelpers.js';
+import Projection, {
+  mercatorProjection,
+  wgs84Projection,
+} from '../../../util/projection.js';
+import { createSync } from '../../vectorSymbols.js';
+import VectorProperties from '../../vectorProperties.js';
+import CesiumMap from '../../../map/cesiumMap.js';
+import { TileProvider } from '../../../../index.js';
+
+let vectorProperties: VectorProperties | undefined;
+function getDebugVectorProperties(): VectorProperties {
+  if (!vectorProperties) {
+    vectorProperties = new VectorProperties({});
+  }
+  return vectorProperties;
+}
+
+export default class VcsDebugTile implements VcsTile {
+  state = VcsTileState.LOADING;
+
+  type = VcsTileType.DEBUG;
+
+  tileBoundingRegion: TileBoundingRegion;
+
+  private _tile: QuadtreeTile<VcsTile>;
+
+  private _vectorContext: VectorContext;
+
+  private _rootCollection = new PrimitiveCollection();
+
+  private _extentFeature: Feature | undefined;
+
+  private _map: CesiumMap;
+
+  private _tileProvider: TileProvider;
+
+  private _style: StyleLike;
+
+  private _layerPrimitiveCollection: PrimitiveCollection;
+
+  constructor(tile: QuadtreeTile<VcsTile>, options: VcsTileOptions) {
+    this._tile = tile;
+    this._map = options.map;
+    this._tileProvider = options.tileProvider;
+    this._style = options.style;
+    this._layerPrimitiveCollection = options.primitiveCollection;
+
+    this._vectorContext = new VectorContext(
+      this._map,
+      this._rootCollection,
+      SplitDirection.NONE,
+    );
+    this._rootCollection[vcsLayerName] = options.name;
+    this._rootCollection.show = false;
+    this._layerPrimitiveCollection.add(this._rootCollection);
+
+    this.tileBoundingRegion = getTileBoundingRegion(tile, this._map);
+    this._load().catch(() => {
+      this.state = VcsTileState.FAILED;
+    });
+  }
+
+  private async _load(): Promise<void> {
+    this.state = VcsTileState.LOADING;
+    const scene = this._map.getScene()!;
+    this.state = VcsTileState.PROCESSING;
+
+    const tileExtent = getTileWgs84Extent(
+      this._tile,
+      this._tileProvider.tilingScheme,
+    );
+
+    const label = new Feature({
+      geometry: new Point(Projection.wgs84ToMercator(getCenter(tileExtent))),
+      olcs_altitudeMode: 'relativeToGround',
+      olcs_heightAboveGround: 5,
+    });
+
+    label.setStyle(
+      new Style({
+        text: new OLText({
+          text: `${this._tile.level}/${this._tile.x}/${this._tile.y}`,
+        }),
+      }),
+    );
+
+    this._extentFeature = new Feature({
+      geometry: fromExtent(tileExtent).transform(
+        wgs84Projection.proj,
+        mercatorProjection.proj,
+      ),
+    });
+    this._extentFeature[createSync] = true;
+
+    const features: Feature[] = [this._extentFeature, label];
+
+    await Promise.all(
+      features.map((f) => {
+        return this._vectorContext.addFeature(
+          f,
+          f.getStyle() ?? this._style,
+          getDebugVectorProperties(),
+          scene,
+        );
+      }),
+    );
+    this.state = VcsTileState.READY;
+  }
+
+  get show(): boolean {
+    return this._rootCollection.show;
+  }
+
+  set show(show: boolean) {
+    this._rootCollection.show = show;
+  }
+
+  freeResources(): void {
+    getLogger('VcsDebugTile').log(
+      `freeing resources: ${getTileHash(this._tile)}`,
+    );
+    this.destroy();
+  }
+
+  destroy(): void {
+    this._vectorContext.destroy();
+    this._layerPrimitiveCollection.remove(this._rootCollection);
+    this._tile.data = undefined;
+  }
+}

package/src/layer/cesium/vcsTile/vcsNoDataTile.ts

@@ -0,0 +1,30 @@
+import { QuadtreeTile, TileBoundingRegion } from '@vcmap-cesium/engine';
+import type CesiumMap from '../../../map/cesiumMap.js';
+import {
+  getTileBoundingRegion,
+  VcsTile,
+  VcsTileState,
+  VcsTileType,
+} from './vcsTileHelpers.js';
+
+export default class VcsNoDataTile implements VcsTile {
+  state = VcsTileState.LOADING;
+
+  type = VcsTileType.NO_DATA;
+
+  tileBoundingRegion: TileBoundingRegion;
+
+  constructor(tile: QuadtreeTile<VcsTile>, map: CesiumMap) {
+    this.tileBoundingRegion = getTileBoundingRegion(tile, map);
+
+    this.state = VcsTileState.READY;
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  get show(): boolean {
+    return false;
+  }
+
+  // eslint-disable-next-line class-methods-use-this,@typescript-eslint/no-empty-function
+  set show(_show: boolean) {}
+}

package/src/layer/cesium/vcsTile/vcsQuadtreeTileProvider.ts

@@ -0,0 +1,290 @@
+import {
+  Cartesian3,
+  Event as CesiumEvent,
+  FrameState,
+  Intersect,
+  Math as CesiumMath,
+  PrimitiveCollection,
+  QuadtreePrimitive,
+  QuadtreeTile,
+  QuadtreeTileLoadState,
+  QuadtreeTileProvider,
+  QuadtreeTileProviderInterface,
+  SplitDirection,
+  TilingScheme,
+  Visibility,
+} from '@vcmap-cesium/engine';
+import { intersects, Extent as OLExtent } from 'ol/extent.js';
+import { parseBoolean } from '@vcsuite/parsers';
+import { wgs84Projection } from '../../../util/projection.js';
+import {
+  getDataTiles,
+  getTileHash,
+  getTileWgs84Extent,
+  VcsTile,
+  VcsTileOptions,
+  VcsTileState,
+  VcsTileType,
+} from './vcsTileHelpers.js';
+import VcsVectorTile from './vcsVectorTile.js';
+import VcsNoDataTile from './vcsNoDataTile.js';
+import VcsDebugTile from './vcsDebugTile.js';
+import VcsChildTile from './vcsChildTile.js';
+import { VectorTileImplementationOptions } from '../../vectorTileLayer.js';
+import CesiumMap from '../../../map/cesiumMap.js';
+import StyleItem from '../../../style/styleItem.js';
+
+const tileDirectionScratch = new Cartesian3();
+
+export default class VcsQuadtreeTileProvider
+  implements QuadtreeTileProviderInterface
+{
+  // eslint-disable-next-line class-methods-use-this
+  get className(): string {
+    return 'VcsQuadtreeTileProvider';
+  }
+
+  quadtree: QuadtreePrimitive | undefined;
+
+  readonly tilingScheme: TilingScheme;
+
+  readonly errorEvent = new CesiumEvent();
+
+  private _destroyed = false;
+
+  private _levelZeroMaximumError: number;
+
+  private _tileOptions: VcsTileOptions;
+
+  private _showingTiles = new Set<string>();
+
+  private _dataLevels: Set<number>;
+
+  private _dataRange: [number, number];
+
+  private _extentWgs84: OLExtent | undefined;
+
+  private _debug = false;
+
+  constructor(
+    map: CesiumMap,
+    primitiveCollection: PrimitiveCollection,
+    layerOptions: VectorTileImplementationOptions,
+  ) {
+    this._tileOptions = {
+      map,
+      primitiveCollection,
+      style: layerOptions.style.style,
+      name: layerOptions.name,
+      tileProvider: layerOptions.tileProvider,
+      vectorProperties: layerOptions.vectorProperties,
+      splitDirection: layerOptions.splitDirection,
+    };
+
+    this._debug = parseBoolean(layerOptions.debug, false);
+
+    this.tilingScheme = layerOptions.tileProvider.tilingScheme;
+    this._levelZeroMaximumError =
+      QuadtreeTileProvider.computeDefaultLevelZeroMaximumGeometricError(
+        this.tilingScheme,
+      );
+
+    const { dataLevels, dataRange } = getDataTiles(
+      layerOptions.minLevel,
+      layerOptions.maxLevel,
+      layerOptions.tileProvider,
+    );
+    this._dataLevels = dataLevels;
+    this._dataRange = dataRange;
+    const vcsExtent = layerOptions.extent;
+
+    if (vcsExtent?.isValid()) {
+      this._extentWgs84 =
+        vcsExtent?.getCoordinatesInProjection(wgs84Projection);
+    }
+  }
+
+  private _withinDataRange(tile: QuadtreeTile): boolean {
+    if (tile.level >= this._dataRange[0] && tile.level <= this._dataRange[1]) {
+      if (this._extentWgs84) {
+        const tileExtent = getTileWgs84Extent(tile, this.tilingScheme);
+        return intersects(tileExtent, this._extentWgs84);
+      }
+      return true;
+    }
+
+    return false;
+  }
+
+  private _initializeTile(tile: QuadtreeTile<VcsTile>): void {
+    if (tile.state === QuadtreeTileLoadState.START) {
+      if (!tile.data) {
+        if (this._withinDataRange(tile)) {
+          if (this._dataLevels.has(tile.level)) {
+            tile.data = this._debug
+              ? new VcsDebugTile(tile, this._tileOptions)
+              : new VcsVectorTile(tile, this._tileOptions);
+          } else {
+            tile.data = new VcsChildTile(tile, this._tileOptions.map);
+          }
+        } else {
+          tile.data = new VcsNoDataTile(tile, this._tileOptions.map);
+        }
+      }
+
+      tile.state = QuadtreeTileLoadState.LOADING;
+    }
+  }
+
+  updateStyle(style: StyleItem): void {
+    this._tileOptions.style = style.style;
+  }
+
+  updateSplitDirection(direction: SplitDirection): void {
+    this._tileOptions.splitDirection = direction;
+  }
+
+  update(frameState: FrameState): void {
+    this.quadtree?.beginFrame(frameState);
+    this.quadtree?.render(frameState);
+    this.quadtree?.endFrame(frameState);
+  }
+
+  endUpdate(_frameState: FrameState): void {
+    this.quadtree?.forEachLoadedTile((t: QuadtreeTile<VcsTile>) => {
+      if (t.data) {
+        t.data.show = this._showingTiles.has(getTileHash(t));
+      }
+    });
+    this._showingTiles.clear();
+  }
+
+  getLevelMaximumGeometricError(level: number): number {
+    return this._levelZeroMaximumError / (1 << level);
+  }
+
+  loadTile(_frameState: FrameState, tile: QuadtreeTile<VcsTile>): void {
+    this._initializeTile(tile);
+
+    if (tile.data?.state === VcsTileState.READY) {
+      tile.renderable = true;
+      tile.state = QuadtreeTileLoadState.DONE;
+    } else if (tile.data?.state === VcsTileState.FAILED) {
+      tile.state = QuadtreeTileLoadState.FAILED;
+    }
+  }
+
+  computeTileLoadPriority(
+    tile: QuadtreeTile<VcsTile>,
+    frameState: FrameState,
+  ): number {
+    const vcsTile = tile.data;
+    if (vcsTile === undefined) {
+      return 0.0;
+    }
+
+    const obb = vcsTile.tileBoundingRegion.boundingVolume;
+    if (obb === undefined) {
+      return 0.0;
+    }
+
+    const cameraPosition = frameState.camera.positionWC;
+    const cameraDirection = frameState.camera.directionWC;
+    const tileDirection = Cartesian3.subtract(
+      obb.center,
+      cameraPosition,
+      tileDirectionScratch,
+    );
+    const magnitude = Cartesian3.magnitude(tileDirection);
+    if (magnitude < CesiumMath.EPSILON5) {
+      return 0.0;
+    }
+    Cartesian3.divideByScalar(tileDirection, magnitude, tileDirection);
+    return (
+      (1.0 - Cartesian3.dot(tileDirection, cameraDirection)) *
+      // eslint-disable-next-line no-underscore-dangle
+      (tile._distance ?? this.computeDistanceToTile(tile, frameState))
+    );
+  }
+
+  computeTileVisibility(
+    tile: QuadtreeTile<VcsTile>,
+    frameState: FrameState,
+  ): Visibility {
+    const distance = this.computeDistanceToTile(tile, frameState);
+    // eslint-disable-next-line no-underscore-dangle
+    tile._distance = distance;
+
+    if (frameState.fog) {
+      if (CesiumMath.fog(distance, frameState.fog.density) >= 1.0) {
+        // Tile is completely in fog so return that it is not visible.
+        return Visibility.NONE;
+      }
+    }
+
+    let visibility = Visibility.NONE;
+    const boundingVolume = tile.data?.tileBoundingRegion.boundingVolume;
+    if (boundingVolume) {
+      const intersection =
+        frameState.cullingVolume.computeVisibility(boundingVolume);
+
+      if (intersection === Intersect.OUTSIDE) {
+        visibility = Visibility.NONE;
+      } else if (intersection === Intersect.INTERSECTING) {
+        visibility = Visibility.PARTIAL;
+      } else if (intersection === Intersect.INSIDE) {
+        visibility = Visibility.FULL;
+      }
+    }
+
+    return visibility;
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  showTileThisFrame(tile: QuadtreeTile<VcsTile>): void {
+    let tileToShow: QuadtreeTile<VcsTile> | undefined = tile;
+    while (tileToShow?.data?.type === VcsTileType.CHILD) {
+      tileToShow = tileToShow.parent;
+    }
+
+    if (tileToShow?.data) {
+      this._showingTiles.add(getTileHash(tileToShow));
+    }
+  }
+
+  computeDistanceToTile(
+    tile: QuadtreeTile<VcsTile>,
+    frameState: FrameState,
+  ): number {
+    this._initializeTile(tile);
+
+    return (
+      tile.data?.tileBoundingRegion.distanceToCamera(frameState) ?? 9999999999.0
+    );
+  }
+
+  canRefine(tile: QuadtreeTile): boolean {
+    return tile.level < this._dataRange[1];
+  }
+
+  isDestroyed(): boolean {
+    return this._destroyed;
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  cancelReprojections(): void {}
+
+  // eslint-disable-next-line class-methods-use-this
+  initialize(_f: FrameState): void {}
+
+  // eslint-disable-next-line class-methods-use-this
+  beginUpdate(_frameState: FrameState): void {}
+
+  // eslint-disable-next-line class-methods-use-this
+  updateForPick(_frameState: FrameState): void {}
+
+  destroy(): void {
+    this._destroyed = true;
+    this._showingTiles.clear();
+  }
+}