@vcmap/core 6.0.0-rc.4 → 6.0.0-rc.6

package/src/util/featureconverter/circleToCesium.ts

@@ -1,9 +1,6 @@
 import { circular } from 'ol/geom/Polygon.js';
 import type { Style } from 'ol/style.js';
 import type { Circle } from 'ol/geom.js';
-import type { Coordinate } from 'ol/coordinate.js';
-import type { Feature } from 'ol/index.js';
-
 import {
   Cartesian3,
   CircleGeometry,
@@ -12,57 +9,106 @@ import {
   Math as CesiumMath,
   Cartographic,
   PolylineGeometry,
-  type Scene,
 } from '@vcmap-cesium/engine';
 import { parseNumber } from '@vcsuite/parsers';
-import { addPrimitivesToContext } from './featureconverterHelper.js';
-import Projection from '../projection.js';
-import type { VectorGeometryFactoryType } from '../../layer/vectorLayer.js';
-import type VectorProperties from '../../layer/vectorProperties.js';
-import type { AsyncCesiumVectorContext } from '../../layer/cesium/vectorContext.js';
-
-export function createSolidGeometries(
-  options: ConstructorParameters<typeof CircleGeometry>[0],
+import {
+  mercatorToCartesianTransformerForHeightInfo,
+  VectorHeightInfo,
+} from './vectorHeightInfo.js';
+import {
+  CesiumGeometryOption,
+  CircleGeometryOptions,
+  VectorGeometryFactory,
+} from './vectorGeometryFactory.js';
+
+function createCircleGeometry(
+  options: CircleGeometryOptions,
+  height: number,
+  perPositionHeight: boolean,
+  extrudedHeight?: number,
+): CircleGeometry {
+  const geometryOptions = {
+    ...options,
+    granularity: 0.02,
+    extrudedHeight,
+  };
+
+  if (!perPositionHeight) {
+    geometryOptions.height = height;
+  } else {
+    const cartographic = Cartographic.fromCartesian(options.center);
+    geometryOptions.height = cartographic.height;
+  }
+
+  return new CircleGeometry(geometryOptions);
+}
+
+function createSolidGeometries(
+  options: CircleGeometryOptions,
+  heightInfo: VectorHeightInfo,
   height: number,
-  _perPositionHeight: boolean,
+  perPositionHeight: boolean,
   extrudedHeight?: number,
-): CircleGeometry[] {
+): CesiumGeometryOption<'solid'>[] {
   return [
-    new CircleGeometry({
-      ...options,
-      height,
-      granularity: 0.02,
-      extrudedHeight,
-    }),
+    {
+      type: 'solid',
+      geometry: createCircleGeometry(
+        options,
+        height,
+        perPositionHeight,
+        extrudedHeight,
+      ),
+      heightInfo,
+    },
   ];
 }
 
-export function createOutlineGeometries(
-  options: ConstructorParameters<typeof CircleGeometry>[0],
+function createOutlineGeometries(
+  options: CircleGeometryOptions,
+  heightInfo: VectorHeightInfo,
   height: number,
-  _perPositionHeight: boolean,
+  perPositionHeight: boolean,
   extrudedHeight?: number,
-): CircleOutlineGeometry[] {
+): CesiumGeometryOption<'outline'>[] {
+  const geometryOptions = {
+    ...options,
+    granularity: 0.02,
+    extrudedHeight,
+  };
+
+  if (!perPositionHeight) {
+    geometryOptions.height = height;
+  } else {
+    const cartographic = Cartographic.fromCartesian(options.center);
+    geometryOptions.height = cartographic.height;
+  }
   return [
-    new CircleOutlineGeometry({
-      ...options,
-      height,
-      extrudedHeight,
-      granularity: 0.02,
-    }),
+    {
+      type: 'outline',
+      geometry: new CircleOutlineGeometry(geometryOptions),
+      heightInfo,
+    },
   ];
 }
 
-export function createFillGeometries(
-  options: ConstructorParameters<typeof CircleGeometry>[0],
+function createFillGeometries(
+  options: CircleGeometryOptions,
+  heightInfo: VectorHeightInfo,
   height: number,
   perPositionHeight: boolean,
-): CircleGeometry[] {
-  return createSolidGeometries(options, height, perPositionHeight, undefined);
+): CesiumGeometryOption<'fill'>[] {
+  return [
+    {
+      type: 'fill',
+      geometry: createCircleGeometry(options, height, perPositionHeight),
+      heightInfo,
+    },
+  ];
 }
 
-export function getLineGeometryOptions(
-  options: ConstructorParameters<typeof CircleGeometry>[0],
+function getLineGeometryOptions(
+  options: CircleGeometryOptions,
   style: Style,
 ): { width: number; positions: Cartesian3[] } {
   const width = parseNumber(style.getStroke()?.getWidth(), 1.0);
@@ -85,61 +131,58 @@ export function getLineGeometryOptions(
   };
 }
 
-export function createGroundLineGeometries(
-  options: ConstructorParameters<typeof CircleGeometry>[0],
+function createGroundLineGeometries(
+  options: CircleGeometryOptions,
+  heightInfo: VectorHeightInfo,
   style: Style,
-): GroundPolylineGeometry[] {
+): CesiumGeometryOption<'groundLine'>[] {
   const lineOptions = getLineGeometryOptions(options, style);
-  return [new GroundPolylineGeometry(lineOptions)];
+  return [
+    {
+      type: 'groundLine',
+      geometry: new GroundPolylineGeometry(lineOptions),
+      heightInfo,
+    },
+  ];
 }
 
-export function createLineGeometries(
-  options: ConstructorParameters<typeof CircleGeometry>[0],
+function createLineGeometries(
+  options: CircleGeometryOptions,
+  heightInfo: VectorHeightInfo,
   style: Style,
-): PolylineGeometry[] {
+): CesiumGeometryOption<'line'>[] {
   const lineOptions = getLineGeometryOptions(options, style);
-  return [new PolylineGeometry(lineOptions)];
+  return [
+    {
+      type: 'line',
+      geometry: new PolylineGeometry(lineOptions),
+      heightInfo,
+    },
+  ];
 }
 
 /**
  * extracts the center and radius from the CircleGeometry and converts it to Cartesian3/radius in m
  * @param  geometry
- * @param  positionHeightAdjustment
- * @param  perPositionHeight
- * @param  groundLevelOrMinHeight
+ * @param heightInfo
  * @returns
  * @private
  */
-export function getGeometryOptions(
+function getGeometryOptions(
   geometry: Circle,
-  positionHeightAdjustment: number,
-  perPositionHeight: boolean,
-  groundLevelOrMinHeight: number,
-): ConstructorParameters<typeof CircleGeometry>[0] {
+  heightInfo: VectorHeightInfo,
+): CircleGeometryOptions {
   // olCoordinates of center and radius in WGS84
   const olCenter = geometry.getCenter();
   const olPoint = olCenter.slice();
   olPoint[0] += geometry.getRadius();
-  const wgs84Center = Projection.mercatorToWgs84(olCenter, true);
-  if (!perPositionHeight && groundLevelOrMinHeight) {
-    wgs84Center[2] = groundLevelOrMinHeight;
-  } else if (wgs84Center[2] != null) {
-    wgs84Center[2] += positionHeightAdjustment;
-  }
 
-  const wgs84Point = Projection.mercatorToWgs84(olPoint, true);
+  const coordinateTransformer =
+    mercatorToCartesianTransformerForHeightInfo(heightInfo);
 
   // Cesium coordinates of center and radius
-  const center = Cartesian3.fromDegrees(
-    wgs84Center[0],
-    wgs84Center[1],
-    wgs84Center[2],
-  );
-  const point = Cartesian3.fromDegrees(
-    wgs84Point[0],
-    wgs84Point[1],
-    wgs84Center[2],
-  );
+  const center = coordinateTransformer(olCenter);
+  const point = coordinateTransformer(olPoint);
 
   // Computation of radius in Cesium 3D
   const radius = Cartesian3.distance(center, point);
@@ -149,29 +192,6 @@ export function getGeometryOptions(
   };
 }
 
-export function getCoordinates(geometries: Circle[]): Coordinate[] {
-  return geometries.map((circle) => {
-    return circle.getCenter();
-  });
-}
-
-let geometryFactory: VectorGeometryFactoryType | null = null;
-
-function getGeometryFactory(): VectorGeometryFactoryType {
-  if (!geometryFactory) {
-    geometryFactory = {
-      getCoordinates,
-      getGeometryOptions,
-      createSolidGeometries,
-      createOutlineGeometries,
-      createFillGeometries,
-      createGroundLineGeometries,
-      createLineGeometries,
-    };
-  }
-  return geometryFactory;
-}
-
 /**
  * validates if a point is renderable
  */
@@ -192,26 +212,20 @@ export function validateCircle(circle: Circle): boolean {
   return false;
 }
 
-export default function circleToCesium(
-  feature: Feature,
-  style: Style,
-  geometries: Circle[],
-  vectorProperties: VectorProperties,
-  scene: Scene,
-  context: AsyncCesiumVectorContext,
-): void {
-  if (!style.getFill() && !style.getStroke()) {
-    return;
+let geometryFactory: VectorGeometryFactory<'circle'> | undefined;
+
+export function getCircleGeometryFactory(): VectorGeometryFactory<'circle'> {
+  if (!geometryFactory) {
+    geometryFactory = {
+      type: 'circle',
+      getGeometryOptions,
+      createSolidGeometries,
+      createOutlineGeometries,
+      createFillGeometries,
+      createGroundLineGeometries,
+      createLineGeometries,
+      validateGeometry: validateCircle,
+    };
   }
-  const circleGeometryFactory = getGeometryFactory();
-  const validGeometries = geometries.filter((circle) => validateCircle(circle));
-  addPrimitivesToContext(
-    feature,
-    style,
-    validGeometries,
-    vectorProperties,
-    scene,
-    circleGeometryFactory,
-    context,
-  );
+  return geometryFactory;
 }

package/src/util/featureconverter/clampedPrimitive.ts

@@ -0,0 +1,70 @@
+import {
+  Cartesian3,
+  Cartographic,
+  HeightReference,
+  Matrix4,
+  Model,
+  Primitive,
+  Scene,
+} from '@vcmap-cesium/engine';
+import { mercatorToCartographic } from '../math.js';
+
+const scratchUpdateHeightCartesian = new Cartesian3();
+
+function getUpdateHeightCallback(
+  primitive: Primitive | Model,
+  originalPosition: Cartesian3,
+): (cartographic: Cartographic) => void {
+  return function updatePrimitiveHeight(clampedPosition: Cartographic) {
+    Cartographic.toCartesian(
+      clampedPosition,
+      undefined,
+      scratchUpdateHeightCartesian,
+    );
+
+    Cartesian3.subtract(
+      scratchUpdateHeightCartesian,
+      originalPosition,
+      scratchUpdateHeightCartesian,
+    );
+
+    const { modelMatrix } = primitive;
+    primitive.modelMatrix = Matrix4.setTranslation(
+      modelMatrix,
+      scratchUpdateHeightCartesian,
+      new Matrix4(),
+    );
+  };
+}
+
+// eslint-disable-next-line import/prefer-default-export
+export function setupClampedPrimitive(
+  scene: Scene,
+  primitive: Primitive | Model,
+  origin: [number, number],
+  heightReference: HeightReference,
+): void {
+  const destroy = primitive.destroy.bind(primitive);
+  const originCartographic = mercatorToCartographic(origin);
+  const callback = getUpdateHeightCallback(
+    primitive,
+    Cartographic.toCartesian(originCartographic),
+  );
+  const callbackHandler = scene.updateHeight(
+    originCartographic,
+    callback,
+    heightReference,
+  );
+
+  const height = scene.getHeight(originCartographic, heightReference);
+  if (height) {
+    const updatedHeightCarto = originCartographic.clone();
+    updatedHeightCarto.height = height;
+    callback(updatedHeightCarto);
+  }
+
+  primitive.destroy = (): void => {
+    callbackHandler();
+    destroy();
+  };
+}