@vcmap/core 5.3.3 → 6.0.0-rc.10

package/src/layer/cesium/clusterContext.ts

@@ -1,131 +1,135 @@
-import type {
+import {
   CustomDataSource,
   EntityCollection,
   Entity,
-  Cartesian3,
   SplitDirection,
+  Scene,
+  ConstantProperty,
 } from '@vcmap-cesium/engine';
+import { StyleLike } from 'ol/style/Style.js';
 import type { Feature } from 'ol/index.js';
 import {
-  ClassificationPrimitive,
-  GroundPolylinePrimitive,
-  GroundPrimitive,
-  Model,
-  Primitive,
-} from '@vcmap-cesium/engine';
-import {
-  removeFeatureFromMap,
-  addPrimitiveToContext,
-  removeArrayFromCollection,
-  VectorContextFeatureCache,
   CesiumVectorContext,
+  setReferenceForPicking,
 } from './vectorContext.js';
+import VectorProperties from '../vectorProperties.js';
+import convert, { ConvertedItem } from '../../util/featureconverter/convert.js';
 
 class ClusterContext implements CesiumVectorContext {
   entities: EntityCollection;
 
-  featureToBillboardMap: Map<Feature, Array<Entity>> = new Map();
+  splitDirection: SplitDirection;
+
+  private _splitDirectionProperty: ConstantProperty;
+
+  private _featureItems = new Map<Feature, (() => void)[]>();
 
-  featureToLabelMap: Map<Feature, Array<Entity>> = new Map();
+  private _convertingFeatures: Map<Feature, () => void> = new Map();
 
-  constructor(dataSource: CustomDataSource) {
+  constructor(dataSource: CustomDataSource, splitDirection: SplitDirection) {
     this.entities = dataSource.entities;
+    this.splitDirection = splitDirection;
+    this._splitDirectionProperty = new ConstantProperty(splitDirection);
   }
 
-  // eslint-disable-next-line class-methods-use-this
-  addPrimitives(
-    _primitives: (
-      | Primitive
-      | GroundPrimitive
-      | GroundPolylinePrimitive
-      | ClassificationPrimitive
-      | Model
-    )[],
-    _feature: Feature,
-    _allowPicking: boolean,
-  ): void {}
-
-  // eslint-disable-next-line class-methods-use-this
-  addScaledPrimitives(
-    _primitives: (
-      | Primitive
-      | GroundPrimitive
-      | GroundPolylinePrimitive
-      | ClassificationPrimitive
-      | Model
-    )[],
-    _feature: Feature,
-    _allowPicking: boolean,
-  ): void {}
-
-  addBillboards(
-    billboardOptions: object[],
+  private _addConvertedItems(
     feature: Feature,
-    allowPicking = false,
+    allowPicking: boolean,
+    items: ConvertedItem[],
   ): void {
-    addPrimitiveToContext(
-      billboardOptions.map((billboard) => ({
-        billboard,
-        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-        // @ts-ignore
-        position: billboard.position as Cartesian3,
-      })),
-      feature,
-      allowPicking,
-      this.entities,
-      this.featureToBillboardMap,
-    );
+    const removeItems = items
+      .map((item) => {
+        let instance: Entity | undefined;
+        let removeItem: (() => void) | undefined;
+        if (item.type === 'billboard') {
+          instance = this.entities.add({
+            billboard: {
+              ...item.item,
+              splitDirection: this._splitDirectionProperty,
+            },
+            position: item.item.position,
+          });
+        } else if (item.type === 'label') {
+          instance = this.entities.add({
+            label: item.item,
+            position: item.item.position,
+          });
+        }
+
+        if (instance) {
+          removeItem = (): void => {
+            this.entities.remove(instance);
+          };
+        }
+
+        if (instance) {
+          if (allowPicking) {
+            setReferenceForPicking(feature, instance);
+          }
+        }
+        return removeItem;
+      })
+      .filter((i): i is () => void => i != null);
+
+    this._featureItems.set(feature, removeItems);
   }
 
-  addLabels(
-    labelOptions: object[],
+  async addFeature(
     feature: Feature,
-    allowPicking = false,
-  ): void {
-    addPrimitiveToContext(
-      labelOptions.map((label) => ({
-        label,
-        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-        // @ts-ignore
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-        position: label.position,
-      })),
+    style: StyleLike,
+    vectorProperties: VectorProperties,
+    scene: Scene,
+  ): Promise<void> {
+    this._convertingFeatures.get(feature)?.();
+    let deleted = false;
+    this._convertingFeatures.set(feature, () => {
+      deleted = true;
+    });
+
+    const convertedItems = await convert(
       feature,
-      allowPicking,
-      this.entities,
-      this.featureToLabelMap,
+      style,
+      vectorProperties,
+      scene,
     );
-  }
 
-  removeFeature(feature: Feature): void {
-    removeFeatureFromMap(feature, this.featureToBillboardMap, this.entities);
-    removeFeatureFromMap(feature, this.featureToLabelMap, this.entities);
-  }
+    this._featureItems.get(feature)?.forEach((removeItem) => removeItem());
 
-  /**
-   * Caches the current cesium resources for a feature, removing them from the feature map
-   */
-  createFeatureCache(feature: Feature): VectorContextFeatureCache {
-    const cache: VectorContextFeatureCache = {};
-    cache.billboards = this.featureToBillboardMap.get(feature);
-    this.featureToBillboardMap.delete(feature);
-    cache.labels = this.featureToLabelMap.get(feature);
-    this.featureToLabelMap.delete(feature);
-    return cache;
+    if (deleted) {
+      convertedItems.forEach((item) => {
+        if (item.type === 'primitive') {
+          item.item.destroy();
+        }
+      });
+    } else {
+      this._addConvertedItems(
+        feature,
+        vectorProperties.getAllowPicking(feature),
+        convertedItems,
+      );
+    }
   }
 
-  clearFeatureCache(cache: VectorContextFeatureCache): void {
-    removeArrayFromCollection(this.entities, cache.billboards);
-    removeArrayFromCollection(this.entities, cache.labels);
+  removeFeature(feature: Feature): void {
+    this._convertingFeatures.get(feature)?.();
+    this._convertingFeatures.delete(feature);
+    this._featureItems.get(feature)?.forEach((removeItem) => removeItem());
+    this._featureItems.delete(feature);
   }
 
   // eslint-disable-next-line class-methods-use-this,no-unused-vars
-  updateSplitDirection(_splitDirection: SplitDirection): void {}
+  updateSplitDirection(splitDirection: SplitDirection): void {
+    this.splitDirection = splitDirection;
+    this._splitDirectionProperty.setValue(this.splitDirection);
+  }
 
   clear(): void {
     this.entities.removeAll();
-    this.featureToBillboardMap.clear();
-    this.featureToLabelMap.clear();
+    this._featureItems.clear();
+    this._convertingFeatures.forEach((destroy) => {
+      destroy();
+    });
+    this._convertingFeatures.clear();
   }
 
   destroy(): void {

package/src/layer/cesium/vectorCesiumImpl.ts

@@ -7,7 +7,6 @@ import {
 import type VectorSource from 'ol/source/Vector.js';
 import type { EventsKey } from 'ol/events.js';
 import type { Feature } from 'ol/index.js';
-import VectorContext from './vectorContext.js';
 import { vcsLayerName } from '../layerSymbols.js';
 import LayerImplementation from '../layerImplementation.js';
 import { synchronizeFeatureVisibilityWithSource } from '../vectorHelpers.js';
@@ -18,6 +17,7 @@ import type VectorProperties from '../vectorProperties.js';
 import type StyleItem from '../../style/styleItem.js';
 import type FeatureVisibility from '../featureVisibility.js';
 import type GlobalHider from '../globalHider.js';
+import VectorContext from './vectorContext.js';
 
 /**
  * represents a specific vector layer for cesium.
@@ -77,7 +77,9 @@ class VectorCesiumImpl
   private _addListeners(): void {
     this._olListeners.push(
       this.source.on('addfeature', (event) => {
-        this._addFeature(event.feature as Feature);
+        this._addFeature(event.feature as Feature).catch(() => {
+          this.getLogger().error('failed to convert feature');
+        });
       }),
     );
 
@@ -89,7 +91,9 @@ class VectorCesiumImpl
 
     this._olListeners.push(
       this.source.on('changefeature', (event) => {
-        this._featureChanged(event.feature as Feature);
+        this._featureChanged(event.feature as Feature).catch(() => {
+          this.getLogger().error('failed to convert feature');
+        });
       }),
     );
 
@@ -123,18 +127,22 @@ class VectorCesiumImpl
     }
   }
 
-  _addFeatures(features: Feature[]): void {
+  private _addFeatures(features: Feature[]): void {
     // TODO we should make this non-blocking to better handle larger data sets check in RIWA Impl
-    features.forEach((f) => this._addFeature(f));
+    features.forEach((f) => {
+      this._addFeature(f).catch((err) => {
+        this.getLogger().error('failed to convert feature', f, err);
+      });
+    });
   }
 
   /**
    * converts a feature and adds the associated primitives to the collection of primitives
    */
-  private _addFeature(feature: Feature): void {
+  private async _addFeature(feature: Feature): Promise<void> {
     if (this.active) {
       // XXX cluster check here? or on init?
-      this._context!.convertFeature(
+      await this._context!.addFeature(
         feature,
         this.style.style,
         this.vectorProperties,
@@ -164,11 +172,9 @@ class VectorCesiumImpl
   /**
    * called when a features property have changed
    */
-  private _featureChanged(feature: Feature): void {
-    const cache = this._context!.createFeatureCache(feature);
+  private async _featureChanged(feature: Feature): Promise<void> {
     this._featureToAdd.delete(feature);
-    this._addFeature(feature);
-    this._context!.clearFeatureCache(cache);
+    await this._addFeature(feature);
   }
 
   async activate(): Promise<void> {