@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/README.md +26 -90
- package/dist/Map3D.d.ts +2 -0
- package/dist/capabilities/cesiumCamera.d.ts +5 -1
- package/dist/cesiumBaseUrl.d.ts +5 -0
- package/dist/entryCamera.d.ts +2 -3
- package/dist/index.js +251 -46
- package/dist/index.js.map +1 -1
- package/dist/interactions/centroidTilt.d.ts +12 -0
- package/dist/reconcilers/userMarkerCone.d.ts +5 -0
- package/package.json +5 -5
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,
|
|
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 (
|
|
13
|
-
|
|
17
|
+
if (resolved === void 0) {
|
|
18
|
+
resolved = fromMeta() || `/cesium-${"1.143.0"}`;
|
|
14
19
|
}
|
|
15
|
-
window.CESIUM_BASE_URL =
|
|
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
|
|
341
|
-
camera.
|
|
342
|
-
|
|
343
|
-
|
|
344
|
-
|
|
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
|
-
|
|
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
|
|
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
|
|
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
|
|
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
|
-
|
|
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.
|
|
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
|
|
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
|
{
|