@xgis/xgis3d 0.3.23 → 0.3.35

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/dist/index.js CHANGED
@@ -1,18 +1,23 @@
1
1
  import { jsx } from 'react/jsx-runtime';
2
2
  import 'cesium/Build/Cesium/Widgets/widgets.css';
3
- import { epsg3301ToWgs84 as epsg3301ToWgs84$1, resolutionForZoom, wrapToRange, TWO_PI, ZOOM_0_RESOLUTION, wgs84ToEpsg3301 as wgs84ToEpsg3301$1, asExtent3301, RADIANS_TO_DEGREES, extentCenter, zoomForExtent, createEngineErrorChannel, WEBGL_CONTEXT_LOST_ERROR_NAME, zoomToFit, clampExtentToBounds, MIN_ZOOM, KML_DEFAULT_COLOR, KML_LABEL_OUTLINE_COLOR, kmlExtractStyles, KML_LABEL_FONT, KML_MARKER_SIZE_PX, KML_LABEL_OUTLINE_PX, KML_LABEL_FONT_SIZE_PX, ogcMapsCesiumCrs, withQuery, ogcMapsMapUrl, ogcMapsQuery, parseTmsTileMap, tmsCesiumSchemeFor, tmsLevelRange, tmsTileBase, tmsTileSuffix, parseWmsCaps, parseWmtsCapabilities, toAlpha, useBasemapStore, useActiveBasemapPlan, useBasemapServiceError, useMapViewStore, useTerrainStore, useUserMarkerStore, MAX_ZOOM } from '@xgis/xgis-common';
4
- import { Cartesian3, HeadingPitchRange, Matrix4, Rectangle, Cartesian2, Transforms, Matrix3, Math as Math$1, EllipsoidTerrainProvider, Ellipsoid, Cartographic, sampleTerrainMostDetailed, Cesium3DTileStyle, I3SDataProvider, Cesium3DTileset, Color, ImageMaterialProperty, ColorMaterialProperty, ConstantProperty, Iso8601, ArcType, PointGraphics, Resource, HeightReference, PolygonHierarchy, KmlDataSource, UrlTemplateImageryProvider, WebMercatorTilingScheme, GeographicTilingScheme, WebMercatorProjection, WebMapServiceImageryProvider, WebMapTileServiceImageryProvider, CesiumTerrainProvider, ConstantPositionProperty } from 'cesium';
3
+ import { epsg3301ToWgs84 as epsg3301ToWgs84$1, resolutionForZoom, wrapToRange, TWO_PI, ZOOM_0_RESOLUTION, wgs84ToEpsg3301 as wgs84ToEpsg3301$1, asExtent3301, RADIANS_TO_DEGREES, extentCenter, zoomForExtent, createEngineErrorChannel, WEBGL_CONTEXT_LOST_ERROR_NAME, zoomToFit, clampExtentToBounds, MIN_ZOOM, SHALLOWEST_PITCH, platformModifierOnly, KML_DEFAULT_COLOR, KML_LABEL_OUTLINE_COLOR, kmlExtractStyles, KML_LABEL_FONT, KML_MARKER_SIZE_PX, KML_LABEL_OUTLINE_PX, KML_LABEL_FONT_SIZE_PX, ogcMapsCesiumCrs, withQuery, ogcMapsMapUrl, ogcMapsQuery, parseTmsTileMap, tmsCesiumSchemeFor, tmsLevelRange, tmsTileBase, tmsTileSuffix, parseWmsCaps, parseWmtsCapabilities, toAlpha, useBasemapStore, useActiveBasemapPlan, useMapViewStore, useTerrainStore, useUserMarkerStore, MAX_ZOOM } from '@xgis/xgis-common';
4
+ import { BoundingSphere, Cartesian3, HeadingPitchRange, Matrix4, Rectangle, Cartesian2, Transforms, Matrix3, Math as Math$1, EllipsoidTerrainProvider, Ellipsoid, Cartographic, sampleTerrainMostDetailed, CameraEventType, KeyboardEventModifier, Cesium3DTileStyle, I3SDataProvider, Cesium3DTileset, Color, ImageMaterialProperty, ColorMaterialProperty, ConstantProperty, Iso8601, ArcType, PointGraphics, Resource, HeightReference, PolygonHierarchy, KmlDataSource, UrlTemplateImageryProvider, WebMercatorTilingScheme, GeographicTilingScheme, WebMercatorProjection, WebMapServiceImageryProvider, WebMapTileServiceImageryProvider, CesiumTerrainProvider, ConstantPositionProperty } from 'cesium';
5
5
  import { useRef, useMemo, useEffect, useState, useCallback } from 'react';
6
6
  import { Viewer } from 'resium';
7
7
 
8
+ const META_NAME = "xgis-cesium-base-url";
9
+ let resolved;
10
+ function fromMeta() {
11
+ return document.querySelector(`meta[name="${META_NAME}"]`)?.content.trim() ?? "";
12
+ }
8
13
  function ensureCesiumBaseUrl() {
9
14
  if (typeof window === "undefined") {
10
15
  return;
11
16
  }
12
- if (window.CESIUM_BASE_URL) {
13
- return;
17
+ if (resolved === void 0) {
18
+ resolved = fromMeta() || `/cesium-${"1.143.0"}`;
14
19
  }
15
- window.CESIUM_BASE_URL = `/cesium-${"1.143.0"}`;
20
+ window.CESIUM_BASE_URL = resolved;
16
21
  }
17
22
  ensureCesiumBaseUrl();
18
23
 
@@ -53,12 +58,12 @@ function cameraFallbackExtent3301(centerLon, centerLat, zoom, viewportWidthPx, v
53
58
  return [cx - halfWidth, cy - halfHeight, cx + halfWidth, cy + halfHeight];
54
59
  }
55
60
 
56
- const DEFAULT_FOV = Math.PI / 3;
61
+ const DEFAULT_FOV$1 = Math.PI / 3;
57
62
  const FALLBACK_SPAN_PX = 1e3;
58
63
  function opticsOf(viewer) {
59
64
  const canvas = viewer.scene.canvas;
60
65
  const frustum = viewer.camera.frustum;
61
- const fov = "fov" in frustum && frustum.fov !== void 0 ? frustum.fov : DEFAULT_FOV;
66
+ const fov = "fov" in frustum && frustum.fov !== void 0 ? frustum.fov : DEFAULT_FOV$1;
62
67
  const spanPx = fovSpanPx(canvas.clientWidth, canvas.clientHeight);
63
68
  return { spanPx: spanPx > 0 ? spanPx : FALLBACK_SPAN_PX, fov };
64
69
  }
@@ -157,6 +162,24 @@ function focusAtHeight(viewer, height) {
157
162
  onTerrain: false
158
163
  };
159
164
  }
165
+ async function sampleTerrainHeight(provider, position) {
166
+ if (provider instanceof EllipsoidTerrainProvider) {
167
+ return void 0;
168
+ }
169
+ const [sampled] = await sampleTerrainMostDetailed(
170
+ provider,
171
+ [Cartographic.fromDegrees(position.lon, position.lat)],
172
+ true
173
+ );
174
+ return sampled?.height;
175
+ }
176
+ async function destinationTerrainHeight(viewer, lon, lat) {
177
+ try {
178
+ return await sampleTerrainHeight(viewer.terrainProvider, { lon, lat }) ?? 0;
179
+ } catch {
180
+ return 0;
181
+ }
182
+ }
160
183
  const ROTATION_EPSILON = 1e-4;
161
184
  function createCesiumCameraCapability(viewer) {
162
185
  const listeners = /* @__PURE__ */ new Set();
@@ -333,16 +356,18 @@ function createCesiumCameraCapability(viewer) {
333
356
  );
334
357
  camera.lookAtTransform(Matrix4.IDENTITY);
335
358
  },
336
- flyToPosition(position, zoom) {
359
+ async flyToPosition(position, zoom) {
337
360
  const camera = viewer.camera;
338
361
  const focus = focusForPlacement();
339
362
  const { heading, pitch } = orientationAtFocus(camera, focus);
340
- const newHeight = jumpTargetHeight(focus) + rangeForZoom(viewer, zoom);
341
- camera.flyTo({
342
- destination: Cartesian3.fromDegrees(position.lon, position.lat, newHeight),
343
- orientation: { heading, pitch, roll: 0 },
344
- duration: 1
345
- });
363
+ const terrainHeight = await destinationTerrainHeight(viewer, position.lon, position.lat);
364
+ camera.flyToBoundingSphere(
365
+ new BoundingSphere(Cartesian3.fromDegrees(position.lon, position.lat, terrainHeight), 0),
366
+ {
367
+ offset: new HeadingPitchRange(heading, pitch, rangeForZoom(viewer, zoom)),
368
+ duration: 1
369
+ }
370
+ );
346
371
  },
347
372
  getCenter() {
348
373
  const carto = viewer.camera.positionCartographic;
@@ -460,7 +485,6 @@ function createCesiumViewLimitsCapability(viewer) {
460
485
  };
461
486
  }
462
487
 
463
- const MAX_ENTRY_PITCH = Math$1.toRadians(-5);
464
488
  const ELLIPSOID_HEIGHT = 0;
465
489
  function entryTarget(viewer, view) {
466
490
  const [centerX, centerY] = extentCenter(view.bbox);
@@ -469,7 +493,10 @@ function entryTarget(viewer, view) {
469
493
  lon,
470
494
  lat,
471
495
  heading: rotationToCesiumHeading(view.rotation),
472
- pitch: Math.min(view.pitch, MAX_ENTRY_PITCH),
496
+ // `lookAt` offsets the camera by -range*sin(pitch), so a pitch at or above the horizon would
497
+ // place it on or under the ground plane. Free-look (SHIFT-drag) can leave the store's pitch
498
+ // there and it survives a mode switch, so entry clamps to the same tilt the gestures stop at.
499
+ pitch: Math.min(view.pitch, SHALLOWEST_PITCH),
473
500
  range: rangeForZoom(viewer, view.zoom)
474
501
  };
475
502
  }
@@ -491,17 +518,6 @@ function raiseEntryCameraToTerrain(viewer, target, height) {
491
518
  );
492
519
  camera.lookAtTransform(Matrix4.IDENTITY);
493
520
  }
494
- async function sampleEntryHeight(provider, target) {
495
- if (provider instanceof EllipsoidTerrainProvider) {
496
- return void 0;
497
- }
498
- const [sampled] = await sampleTerrainMostDetailed(
499
- provider,
500
- [Cartographic.fromDegrees(target.lon, target.lat)],
501
- true
502
- );
503
- return sampled?.height;
504
- }
505
521
 
506
522
  function createCanvasPressRelay(viewer) {
507
523
  const canvas = viewer.canvas;
@@ -524,6 +540,125 @@ function createCanvasPressRelay(viewer) {
524
540
  };
525
541
  }
526
542
 
543
+ const ROTATE_RATE = 1.77;
544
+ const RADIANS_PER_PIXEL = 25e-4;
545
+ const LEFT_BUTTON = 0;
546
+ const MIDDLE_BUTTON = 1;
547
+ const LEFT_BUTTON_MASK = 1;
548
+ const MIDDLE_BUTTON_MASK = 4;
549
+ function isReplacedTilt(entry) {
550
+ if (entry === CameraEventType.MIDDLE_DRAG) {
551
+ return true;
552
+ }
553
+ return typeof entry === "object" && (entry.eventType === CameraEventType.LEFT_DRAG || entry.eventType === CameraEventType.RIGHT_DRAG) && entry.modifier === KeyboardEventModifier.CTRL;
554
+ }
555
+ function buttonMaskFor(button) {
556
+ return button === MIDDLE_BUTTON ? MIDDLE_BUTTON_MASK : LEFT_BUTTON_MASK;
557
+ }
558
+ function startsGesture(event) {
559
+ if (event.button === MIDDLE_BUTTON) {
560
+ return !event.altKey && !event.shiftKey && !event.ctrlKey && !event.metaKey;
561
+ }
562
+ return event.button === LEFT_BUTTON && platformModifierOnly(event);
563
+ }
564
+ function createCentroidTilt(viewer) {
565
+ const { scene, camera } = viewer;
566
+ const controller = scene.screenSpaceCameraController;
567
+ const canvas = scene.canvas;
568
+ const originalTiltEventTypes = controller.tiltEventTypes;
569
+ const entries = Array.isArray(originalTiltEventTypes) ? originalTiltEventTypes : originalTiltEventTypes === void 0 ? [] : [originalTiltEventTypes];
570
+ controller.tiltEventTypes = entries.filter((entry) => !isReplacedTilt(entry));
571
+ let anchorTransform;
572
+ let activePointerId;
573
+ let activeButtonMask = LEFT_BUTTON_MASK;
574
+ let suspendedRotate;
575
+ let lastX = 0;
576
+ let lastY = 0;
577
+ function finishGesture() {
578
+ const pointerId = activePointerId;
579
+ activePointerId = void 0;
580
+ anchorTransform = void 0;
581
+ if (suspendedRotate !== void 0) {
582
+ controller.enableRotate = suspendedRotate;
583
+ suspendedRotate = void 0;
584
+ }
585
+ if (pointerId !== void 0 && canvas.hasPointerCapture(pointerId)) {
586
+ canvas.releasePointerCapture(pointerId);
587
+ }
588
+ }
589
+ function handlePointerDown(event) {
590
+ if (activePointerId !== void 0 || event.pointerType !== "mouse" || !startsGesture(event) || !controller.enableInputs || !controller.enableTilt) {
591
+ return;
592
+ }
593
+ const picked = pickGroundPoint(
594
+ viewer,
595
+ new Cartesian2(canvas.clientWidth / 2, canvas.clientHeight / 2)
596
+ );
597
+ if (!picked) {
598
+ return;
599
+ }
600
+ anchorTransform = Transforms.eastNorthUpToFixedFrame(picked.point);
601
+ activePointerId = event.pointerId;
602
+ activeButtonMask = buttonMaskFor(event.button);
603
+ suspendedRotate = controller.enableRotate;
604
+ controller.enableRotate = false;
605
+ lastX = event.clientX;
606
+ lastY = event.clientY;
607
+ canvas.setPointerCapture(event.pointerId);
608
+ }
609
+ function handlePointerMove(event) {
610
+ if (!anchorTransform || event.pointerId !== activePointerId) {
611
+ return;
612
+ }
613
+ if (!(event.buttons & activeButtonMask) || !controller.enableInputs || !controller.enableTilt) {
614
+ finishGesture();
615
+ return;
616
+ }
617
+ const dx = event.clientX - lastX;
618
+ const dy = event.clientY - lastY;
619
+ lastX = event.clientX;
620
+ lastY = event.clientY;
621
+ if (dx === 0 && dy === 0) {
622
+ return;
623
+ }
624
+ const previousTransform = Matrix4.clone(camera.transform);
625
+ try {
626
+ camera.lookAtTransform(anchorTransform);
627
+ camera.rotateLeft(ROTATE_RATE * (dx / canvas.clientWidth) * Math.PI * 2);
628
+ const tilt = Math$1.asinClamped(camera.direction.z);
629
+ const allowedUp = Math.min(-dy * RADIANS_PER_PIXEL, SHALLOWEST_PITCH - tilt);
630
+ if (allowedUp !== 0) {
631
+ camera.rotateUp(allowedUp);
632
+ }
633
+ } finally {
634
+ camera.lookAtTransform(previousTransform);
635
+ }
636
+ scene.requestRender();
637
+ }
638
+ function handlePointerEnd(event) {
639
+ if (event.pointerId !== activePointerId) {
640
+ return;
641
+ }
642
+ finishGesture();
643
+ }
644
+ canvas.addEventListener("pointerdown", handlePointerDown);
645
+ canvas.addEventListener("pointermove", handlePointerMove);
646
+ canvas.addEventListener("pointerup", handlePointerEnd);
647
+ canvas.addEventListener("pointercancel", handlePointerEnd);
648
+ canvas.addEventListener("lostpointercapture", handlePointerEnd);
649
+ window.addEventListener("blur", finishGesture);
650
+ return () => {
651
+ finishGesture();
652
+ controller.tiltEventTypes = originalTiltEventTypes;
653
+ canvas.removeEventListener("pointerdown", handlePointerDown);
654
+ canvas.removeEventListener("pointermove", handlePointerMove);
655
+ canvas.removeEventListener("pointerup", handlePointerEnd);
656
+ canvas.removeEventListener("pointercancel", handlePointerEnd);
657
+ canvas.removeEventListener("lostpointercapture", handlePointerEnd);
658
+ window.removeEventListener("blur", finishGesture);
659
+ };
660
+ }
661
+
527
662
  const KEYBOARD_MOVE_DIVISOR = 10;
528
663
  function horizontalDirection(vec, normal) {
529
664
  const [vecX, vecY, vecZ] = vec;
@@ -1163,9 +1298,7 @@ function useCesiumBasemapAttachments(viewer) {
1163
1298
 
1164
1299
  function useCesiumBasemapReconciler(viewer) {
1165
1300
  const basemapOpacity = useBasemapStore((s) => s.opacity3d);
1166
- const plan = useActiveBasemapPlan("3d");
1167
- const { entries, ready } = plan;
1168
- const reportServiceError = useBasemapServiceError("3d", plan);
1301
+ const { entries, ready } = useActiveBasemapPlan("3d");
1169
1302
  const attachments = useCesiumBasemapAttachments(viewer);
1170
1303
  useEffect(() => {
1171
1304
  attachments.setOpacity(basemapOpacity);
@@ -1176,11 +1309,6 @@ function useCesiumBasemapReconciler(viewer) {
1176
1309
  }
1177
1310
  attachments.detachAll();
1178
1311
  let cancelled = false;
1179
- const removeListeners = [];
1180
- const addImagery = (provider) => {
1181
- attachments.addImagery(provider);
1182
- removeListeners.push(provider.errorEvent.addEventListener(reportServiceError));
1183
- };
1184
1312
  const attachAsync = (load, attach, failure) => {
1185
1313
  void (async () => {
1186
1314
  try {
@@ -1190,7 +1318,6 @@ function useCesiumBasemapReconciler(viewer) {
1190
1318
  }
1191
1319
  } catch (error) {
1192
1320
  console.warn(failure, error);
1193
- reportServiceError();
1194
1321
  }
1195
1322
  })();
1196
1323
  };
@@ -1200,7 +1327,7 @@ function useCesiumBasemapReconciler(viewer) {
1200
1327
  continue;
1201
1328
  }
1202
1329
  if (created.kind === "imagery") {
1203
- addImagery(created.provider);
1330
+ attachments.addImagery(created.provider);
1204
1331
  } else if (created.kind === "tileset") {
1205
1332
  attachAsync(created.tileset, attachments.addTileset, "Failed to load 3D tileset basemap");
1206
1333
  } else {
@@ -1209,11 +1336,8 @@ function useCesiumBasemapReconciler(viewer) {
1209
1336
  }
1210
1337
  return () => {
1211
1338
  cancelled = true;
1212
- for (const remove of removeListeners) {
1213
- remove();
1214
- }
1215
1339
  };
1216
- }, [viewer, attachments, entries, ready, reportServiceError]);
1340
+ }, [viewer, attachments, entries, ready]);
1217
1341
  useEffect(() => attachments.detachAll, [attachments]);
1218
1342
  }
1219
1343
 
@@ -1244,7 +1368,7 @@ function useCesiumEntryCamera(viewer, view) {
1244
1368
  return;
1245
1369
  }
1246
1370
  try {
1247
- const height = await sampleEntryHeight(viewer.terrainProvider, entryTarget(viewer, view));
1371
+ const height = await sampleTerrainHeight(viewer.terrainProvider, entryTarget(viewer, view));
1248
1372
  if (done || height === void 0) {
1249
1373
  return;
1250
1374
  }
@@ -1292,9 +1416,37 @@ function useCesiumTerrainReconciler(viewer) {
1292
1416
  }, [viewer, terrainUrl]);
1293
1417
  }
1294
1418
 
1419
+ const HALF_SPAN = 35 * Math.PI / 180;
1420
+ const ARC_SEGMENTS = 16;
1421
+ const CONE_SCREEN_RADIUS_PX = 40;
1422
+ const MIN_RADIUS_METERS = 1;
1423
+ function coneRadiusForScreenSize(range, fov, spanPx) {
1424
+ const metersPerPixel = 2 * range * Math.tan(fov / 2) / spanPx;
1425
+ return Math.max(MIN_RADIUS_METERS, metersPerPixel * CONE_SCREEN_RADIUS_PX);
1426
+ }
1427
+ function coneHierarchy(lon, lat, heading, radiusMeters) {
1428
+ const origin = Cartesian3.fromDegrees(lon, lat);
1429
+ const enuFrame = Transforms.eastNorthUpToFixedFrame(origin);
1430
+ const positions = [origin];
1431
+ for (let i = 0; i <= ARC_SEGMENTS; i++) {
1432
+ const angle = heading - HALF_SPAN + 2 * HALF_SPAN * i / ARC_SEGMENTS;
1433
+ const local = new Cartesian3(radiusMeters * Math.sin(angle), radiusMeters * Math.cos(angle), 0);
1434
+ positions.push(Matrix4.multiplyByPoint(enuFrame, local, new Cartesian3()));
1435
+ }
1436
+ return new PolygonHierarchy(positions);
1437
+ }
1438
+
1439
+ const DEFAULT_FOV = Math.PI / 3;
1295
1440
  function useCesiumUserMarker(viewer) {
1296
1441
  const marker = useUserMarkerStore((s) => s.marker);
1442
+ const heading = useUserMarkerStore((s) => s.heading);
1297
1443
  const entityRef = useRef(null);
1444
+ const coneEntityRef = useRef(null);
1445
+ const markerRef = useRef(marker);
1446
+ const headingRef = useRef(heading);
1447
+ markerRef.current = marker;
1448
+ headingRef.current = heading;
1449
+ const updateConeRef = useRef(null);
1298
1450
  useEffect(() => {
1299
1451
  const entity = viewer.entities.add({
1300
1452
  point: {
@@ -1308,24 +1460,59 @@ function useCesiumUserMarker(viewer) {
1308
1460
  show: false
1309
1461
  });
1310
1462
  entityRef.current = entity;
1463
+ const coneEntity = viewer.entities.add({
1464
+ polygon: {
1465
+ material: Color.fromCssColorString("#2563EB").withAlpha(0.35)
1466
+ },
1467
+ show: false
1468
+ });
1469
+ coneEntityRef.current = coneEntity;
1470
+ function updateCone() {
1471
+ const currentMarker = markerRef.current;
1472
+ const currentHeading = headingRef.current;
1473
+ if (currentMarker === null || currentHeading === null || !coneEntity.polygon) {
1474
+ return;
1475
+ }
1476
+ const camera = viewer.camera;
1477
+ const markerPosition = Cartesian3.fromDegrees(currentMarker.lon, currentMarker.lat);
1478
+ const range = Cartesian3.distance(camera.position, markerPosition);
1479
+ const frustum = camera.frustum;
1480
+ const fov = "fov" in frustum && frustum.fov !== void 0 ? frustum.fov : DEFAULT_FOV;
1481
+ const canvas = viewer.scene.canvas;
1482
+ const spanPx = fovSpanPx(canvas.clientWidth, canvas.clientHeight);
1483
+ const radius = coneRadiusForScreenSize(range, fov, spanPx);
1484
+ coneEntity.polygon.hierarchy = new ConstantProperty(
1485
+ coneHierarchy(currentMarker.lon, currentMarker.lat, currentHeading, radius)
1486
+ );
1487
+ }
1488
+ updateConeRef.current = updateCone;
1489
+ const removeCameraListener = viewer.camera.changed.addEventListener(updateCone);
1311
1490
  return () => {
1491
+ removeCameraListener();
1312
1492
  viewer.entities.remove(entity);
1493
+ viewer.entities.remove(coneEntity);
1313
1494
  entityRef.current = null;
1495
+ coneEntityRef.current = null;
1496
+ updateConeRef.current = null;
1314
1497
  };
1315
1498
  }, [viewer]);
1316
1499
  useEffect(() => {
1317
1500
  const entity = entityRef.current;
1318
- if (!entity) {
1501
+ const coneEntity = coneEntityRef.current;
1502
+ if (!entity || !coneEntity) {
1319
1503
  return;
1320
1504
  }
1321
1505
  if (marker === null) {
1322
1506
  entity.show = false;
1507
+ coneEntity.show = false;
1323
1508
  } else {
1324
1509
  entity.position = new ConstantPositionProperty(Cartesian3.fromDegrees(marker.lon, marker.lat));
1325
1510
  entity.show = true;
1511
+ coneEntity.show = heading !== null;
1512
+ updateConeRef.current?.();
1326
1513
  }
1327
1514
  viewer.scene.requestRender();
1328
- }, [marker, viewer]);
1515
+ }, [marker, heading, viewer]);
1329
1516
  }
1330
1517
 
1331
1518
  function useCesiumViewBounds(viewer) {
@@ -1343,12 +1530,17 @@ function applyZoomDistanceLimits(viewer) {
1343
1530
  viewer.scene.screenSpaceCameraController.maximumZoomDistance = rangeForZoom(viewer, MIN_ZOOM);
1344
1531
  viewer.scene.screenSpaceCameraController.minimumZoomDistance = rangeForZoom(viewer, MAX_ZOOM);
1345
1532
  }
1533
+ function applyRotationPermission(viewer, rotationAllowed) {
1534
+ viewer.scene.screenSpaceCameraController.enableTilt = rotationAllowed;
1535
+ viewer.scene.screenSpaceCameraController.enableLook = rotationAllowed;
1536
+ }
1346
1537
  const MSAA = 1;
1347
1538
  function applyGlobeSettings(viewer) {
1348
1539
  const globe = viewer.scene.globe;
1349
1540
  globe.baseColor = Color.BLACK;
1350
1541
  globe.showGroundAtmosphere = false;
1351
- globe.maximumScreenSpaceError = 2.5;
1542
+ globe.maximumScreenSpaceError = 2.2;
1543
+ globe.depthTestAgainstTerrain = true;
1352
1544
  }
1353
1545
  function CesiumLayerSync({ viewer, entry }) {
1354
1546
  useCesiumBasemapReconciler(viewer);
@@ -1362,6 +1554,7 @@ function Map3D({ onEngineReady }) {
1362
1554
  ensureCesiumBaseUrl();
1363
1555
  const [cesiumViewer, setCesiumViewer] = useState(null);
1364
1556
  const [entry, setEntry] = useState(null);
1557
+ const rotationAllowed = useMapViewStore((s) => s.rotationAllowed);
1365
1558
  const onViewerInit = useCallback((ref) => {
1366
1559
  if (!ref?.cesiumElement) {
1367
1560
  return;
@@ -1371,7 +1564,7 @@ function Map3D({ onEngineReady }) {
1371
1564
  placeEntryCamera(viewer, entryTarget(viewer, view), ELLIPSOID_HEIGHT);
1372
1565
  applyZoomDistanceLimits(viewer);
1373
1566
  applyGlobeSettings(viewer);
1374
- viewer.scene.screenSpaceCameraController.minimumCollisionTerrainHeight = Number.POSITIVE_INFINITY;
1567
+ applyRotationPermission(viewer, view.rotationAllowed);
1375
1568
  viewer.scene.screenSpaceCameraController.inertiaSpin = CAMERA_INERTIA;
1376
1569
  viewer.scene.screenSpaceCameraController.inertiaZoom = CAMERA_INERTIA;
1377
1570
  setEntry(view);
@@ -1417,6 +1610,12 @@ function Map3D({ onEngineReady }) {
1417
1610
  }
1418
1611
  return createNadirLimit(cesiumViewer);
1419
1612
  }, [cesiumViewer]);
1613
+ useEffect(() => {
1614
+ if (!cesiumViewer) {
1615
+ return;
1616
+ }
1617
+ return createCentroidTilt(cesiumViewer);
1618
+ }, [cesiumViewer]);
1420
1619
  useEffect(() => {
1421
1620
  if (!cesiumViewer) {
1422
1621
  return;
@@ -1427,6 +1626,12 @@ function Map3D({ onEngineReady }) {
1427
1626
  observer.disconnect();
1428
1627
  };
1429
1628
  }, [cesiumViewer]);
1629
+ useEffect(() => {
1630
+ if (!cesiumViewer) {
1631
+ return;
1632
+ }
1633
+ applyRotationPermission(cesiumViewer, rotationAllowed);
1634
+ }, [cesiumViewer, rotationAllowed]);
1430
1635
  return /* @__PURE__ */ jsx(
1431
1636
  Viewer,
1432
1637
  {