mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-16 16:22:20 +00:00
Normalize GeoJSON ground footprints, preserve explicit KML track heights, and tessellate ground paths before native loading. Validate coordinates, geometry types and decoded image budgets before allocating native resources; strip loader-sensitive metadata and settle deferred failures and cancellation. Render static pins in owned billboard collections instead of walking tens of thousands of point entities each frame. Refine nearby ground heights in batches, isolate imported pins from height picks, and release owned resources and point selections on removal. Use safe ray origins above a hidden coarse globe and retain valid mesh heights outside the current footprint. Frame complete geometry with viewport-aware nadir arrivals, including walls and rotated overlays; respect camera gestures and accept document file drops. Strengthen real-loader, native 3D Tiles, paint, clock and lifecycle coverage. Addresses both P1 and all 25 P2 findings in the follow-up review of #1122.
123 lines
4.2 KiB
JavaScript
123 lines
4.2 KiB
JavaScript
/** Frame the complete finite footprint of a session-local file. */
|
|
import * as Cesium from 'cesium';
|
|
import { guardCameraAboveGround } from '../cameraGroundGuard.js';
|
|
import { rangeForBoundingSphere } from '../data/cameraFraming.js';
|
|
import { cancelCameraArrival } from '../data/cameraArrival.js';
|
|
|
|
/** All visible positions, path vertices, polygon rings, walls and overlay bounds. */
|
|
export function dataSourcePoints(dataSource, time = Cesium.JulianDate.now()) {
|
|
const points = [];
|
|
const add = (position, grounded = false) => {
|
|
if (
|
|
!position ||
|
|
![position.x, position.y, position.z].every(Number.isFinite)
|
|
)
|
|
return;
|
|
const c = Cesium.Cartographic.fromCartesian(position);
|
|
if (c && Number.isFinite(c.longitude) && Number.isFinite(c.latitude))
|
|
points.push([
|
|
Cesium.Math.toDegrees(c.longitude),
|
|
Cesium.Math.toDegrees(c.latitude),
|
|
grounded ? 0 : c.height,
|
|
]);
|
|
};
|
|
if (dataSource?.show === false) return points;
|
|
for (const entity of dataSource?.importedEntities ??
|
|
dataSource?.entities?.values ??
|
|
[]) {
|
|
if (entity.isShowing === false) continue;
|
|
add(
|
|
entity.position?.getValue?.(time),
|
|
entity.billboard?.heightReference?.getValue?.(time) ===
|
|
Cesium.HeightReference.CLAMP_TO_GROUND,
|
|
);
|
|
for (const graphic of [entity.polyline, entity.wall])
|
|
for (const position of graphic?.positions?.getValue?.(time) || [])
|
|
add(position, graphic.clampToGround?.getValue?.(time) === true);
|
|
const rings = [entity.polygon?.hierarchy?.getValue?.(time)];
|
|
while (rings.length) {
|
|
const ring = rings.pop();
|
|
for (const position of ring?.positions || [])
|
|
add(
|
|
position,
|
|
entity.polygon?.perPositionHeight?.getValue?.(time) !== true,
|
|
);
|
|
for (const hole of ring?.holes || []) rings.push(hole);
|
|
}
|
|
const rectangle = entity.rectangle?.coordinates?.getValue?.(time);
|
|
if (rectangle) {
|
|
const bounds = Cesium.RectangleGeometry.computeRectangle({
|
|
rectangle,
|
|
rotation: entity.rectangle.rotation?.getValue?.(time) || 0,
|
|
});
|
|
for (const corner of [
|
|
'southwest',
|
|
'southeast',
|
|
'northwest',
|
|
'northeast',
|
|
]) {
|
|
const c = Cesium.Rectangle[corner](bounds);
|
|
if (Number.isFinite(c.longitude) && Number.isFinite(c.latitude))
|
|
points.push([
|
|
Cesium.Math.toDegrees(c.longitude),
|
|
Cesium.Math.toDegrees(c.latitude),
|
|
entity.rectangle.height?.getValue?.(time) || 0,
|
|
]);
|
|
}
|
|
}
|
|
}
|
|
return points;
|
|
}
|
|
|
|
/** Fly synchronously to the footprint; later navigation always owns its camera. */
|
|
export function flyToDataSource(
|
|
viewer,
|
|
dataSource,
|
|
{ duration = 1.5, ground = null } = {},
|
|
) {
|
|
const points = dataSourcePoints(dataSource);
|
|
if (!points.length) return false;
|
|
cancelCameraArrival(viewer);
|
|
const positions = points.map(([lon, lat, height]) =>
|
|
Cesium.Cartesian3.fromDegrees(lon, lat, height),
|
|
);
|
|
const sphere = Cesium.BoundingSphere.fromPoints(positions);
|
|
const center =
|
|
Cesium.Cartographic.fromCartesian(sphere.center) ||
|
|
Cesium.Cartographic.fromDegrees(points[0][0], points[0][1]);
|
|
const lat = Cesium.Math.toDegrees(center.latitude),
|
|
lon = Cesium.Math.toDegrees(center.longitude);
|
|
const terrain = viewer.scene?.globe?.getHeight?.(center);
|
|
const cached = ground?.cachedGroundFloor?.(lat, lon);
|
|
const height =
|
|
Number.isFinite(terrain) && terrain > 0
|
|
? terrain
|
|
: Number.isFinite(cached)
|
|
? cached
|
|
: Number.isFinite(terrain)
|
|
? terrain
|
|
: 0;
|
|
ground?.warmGroundFloor?.([{ lat, lon }]);
|
|
sphere.center = Cesium.Cartesian3.fromRadians(
|
|
center.longitude,
|
|
center.latitude,
|
|
Math.max(0, height, center.height),
|
|
);
|
|
sphere.radius = 0;
|
|
for (const position of positions)
|
|
sphere.radius = Math.max(
|
|
sphere.radius,
|
|
Cesium.Cartesian3.distance(sphere.center, position),
|
|
);
|
|
viewer.camera?.flyToBoundingSphere?.(sphere, {
|
|
offset: new Cesium.HeadingPitchRange(
|
|
viewer.camera.heading || 0,
|
|
-Math.PI / 2,
|
|
Math.max(800, rangeForBoundingSphere(viewer, sphere.radius)),
|
|
),
|
|
duration,
|
|
complete: () => guardCameraAboveGround(viewer, { lat, lon }),
|
|
});
|
|
return true;
|
|
}
|