Merge main through #1637 into the renderer seam

Ports the cockpit bridge view, the orbital view riding a satellite with
ground-site focus, satellite classes and draw-mark row actions onto the
renderer contract. The orbital view's imagery look-ahead pre-load is
dropped (no contract member); tiles load as they come on screen.
This commit is contained in:
Sameh Khamis committed 2026-11-10 01:35:00 -08:00
commit e48ed3eb9e
169 files changed
+22415 -681

No files matched your search

+243 -12
View File
@@ -1,6 +1,7 @@
/** Camera placement, ground acquisition and motion correction for the Cockpit controller. */
import { cameraOf, findFrame } from '../render/rendererOf.js';
import { followedPosition } from '../data/followed.js';
import { cameraOf, findFrame, findQuery } from '../render/rendererOf.js';
import { heightsOf } from '../queries/heights.js';
import { followedPosition, isFollowing } from '../data/followed.js';
import { readEntityRecord } from '../data/entityRecords.js';
import { trackedEntityDrawn } from './cockpitTrackingController.js';
import {
@@ -8,6 +9,7 @@ import {
clone,
eastNorthUp,
frameVector,
fromDegrees,
fromRadians,
magnitude,
normalize,
@@ -25,6 +27,15 @@ import {
cockpitUiUpdateDue,
slewHeading,
} from '../cockpitMath.js';
import {
VESSEL_DEAD_RECKON_MAX_S,
VESSEL_WATERLINE_REFRESH_MS,
deadReckonVesselFix,
vesselCameraProfile,
vesselWaterlineM,
waterlineProbePoints,
} from '../cockpitSubjects.js';
import { easeLook } from '../cockpitLook.js';
import {
COCKPIT_HEADING_SLEW_DPS,
COCKPIT_FORWARD_OFFSET_M,
@@ -73,6 +84,14 @@ export function update() {
}
const nowMs = performance.now();
if (this.subjectKind === 'vessel') {
updateVessel.call(this, nowMs);
return;
}
if (this.subjectKind === 'satellite') {
this.updateOrbital(nowMs);
return;
}
const info = this.readAircraftInfo();
// Adopt a newly selected track before the camera cadence gate. A context
@@ -112,17 +131,214 @@ export function update() {
placeCamera.call(this, target, info, nowMs, dtSec, AIRCRAFT_CAMERA_PROFILE);
}
/**
* The surface the ridden ship floats on: the layer's geoid sea surface, or
* the water read off the rendered scene when that sits higher (a river or
* lake above sea level). The read runs in the background every
* VESSEL_WATERLINE_REFRESH_MS. The full-detail read can take many seconds
* from cold tiles, so a new ship's first read starts from the tiles already
* on screen; until any read lands the sea surface stands. Only one
* full-detail read runs at a time (each is nine picks Cesium traverses
* every frame until it settles): while one is still running, a refresh
* reads the loaded tiles instead, and the slow read applies whenever it
* lands. Once a full-detail read has answered, only full-detail reads
* change the height; before then a loaded-tile read may find raised water
* but never takes a raised height back to the sea. One coarse probe cannot
* drop a river bridge to the sea, and a read that sampled nothing keeps
* the height it had.
* @param {{latitude: number, longitude: number}} [at] Where to read the
* water: the dead-reckoned position the camera rides.
* @returns {number} Ellipsoidal metres.
*/
function vesselSurfaceM(info, nowMs, at = info) {
const seaM = Number.isFinite(info.seaSurfaceHeightM)
? info.seaSurfaceHeightM
: 0;
const query = findQuery(this.viewer) ? heightsOf(this.viewer) : null;
let read =
this.vesselWaterline?.mmsi === info.mmsi ? this.vesselWaterline : null;
if (
query &&
(!read || nowMs - read.sampledMs >= VESSEL_WATERLINE_REFRESH_MS)
) {
const probes = waterlineProbePoints(at.latitude, at.longitude).map(
({ lat, lon }) => ({ lon, lat }),
);
if (!read) {
read = {
mmsi: info.mmsi,
heightM: loadedWaterlineM(query, probes, seaM),
sampledMs: nowMs,
// Whether a full-detail read has answered for this ship.
landed: false,
inFlight: false,
};
this.vesselWaterline = read;
} else {
read.sampledMs = nowMs;
if (read.inFlight && !read.landed) {
const loadedM = loadedWaterlineM(query, probes, seaM);
// Taking a river back to the sea is the full-detail read's to say.
const lowers =
Number.isFinite(read.heightM) &&
read.heightM > seaM &&
!(loadedM > seaM);
if (Number.isFinite(loadedM) && !lowers) read.heightM = loadedM;
}
}
if (!read.inFlight) readWaterline.call(this, read, query, probes, seaM);
}
return read && Number.isFinite(read.heightM)
? Math.max(seaM, read.heightM)
: seaM;
}
/** Start one full-detail water read for `read`; its answer lands on it. */
function readWaterline(read, query, probes, seaM) {
read.inFlight = true;
// An async read: a failure arrives as a rejection, never a throw here.
query.batch(probes, { against: 'tiles' }).then(
(samples) => {
if (this.vesselWaterline !== read) return;
read.inFlight = false;
// However late it lands, it applies; one that sampled nothing (tiles
// not loaded yet) is no answer and keeps the height already read.
const heights = samples || [];
if (!heights.some(Number.isFinite)) return;
read.landed = true;
read.heightM = vesselWaterlineM(seaM, heights);
},
() => {
if (this.vesselWaterline === read) read.inFlight = false;
},
);
}
/**
* The waterline from the tiles already loaded, read at once: a first answer
* while the full-detail read loads. Null when the scene cannot sample or no
* probe met loaded geometry: nothing sampled is no answer, not the sea, so it
* never undoes a river height a full read set.
*/
function loadedWaterlineM(query, probes, seaM) {
try {
const heights = probes.map((probe) =>
query.now(probe, { against: 'tiles' }),
);
if (!heights.some(Number.isFinite)) return null;
return vesselWaterlineM(seaM, heights);
} catch {
return null;
}
}
/**
* Drive the bridge camera from the selected vessel. The vessel layer redraws
* a ship only when its feed refreshes, so the target is the last fix advanced
* along course over ground; the shared anchor smoothing then absorbs the
* correction each new fix brings.
*/
function updateVessel(nowMs) {
// Tracking anything from the bridge (an aircraft, a satellite, a site)
// takes the camera: entry stopped every follow, so any follow now is
// another's. End the bridge and leave the camera following it.
if (isFollowing(this.viewer)) {
this.exit({ restoreTracking: false });
return;
}
const info = this.readVesselInfo();
if (!info || info.mmsi !== this.subjectId) {
this.exit({ restoreTracking: false });
return;
}
if (
!cockpitUiUpdateDue(
nowMs,
this.lastCameraUpdateMs,
COCKPIT_CAMERA_UPDATE_MS,
)
)
return;
this.lastCameraUpdateMs = nowMs;
const fix = deadReckonVesselFix(
{
latitude: info.latitude,
longitude: info.longitude,
courseDeg: info.motionCourse,
speedMps: info.velocityMps,
fixEpochMs: info.fixEpochMs,
receivedAtMs: info.receivedAtMs,
feedEpochMs: info.feedEpochMs,
},
Date.now(),
);
// The radar centres here too, so it agrees with the view out the window.
this.vesselFix = fix;
const target = fromDegrees(
fix.longitude,
fix.latitude,
// Read the water where the ship is now, not at its last report.
vesselSurfaceM.call(this, info, nowMs, fix),
);
// The target advances in wall-clock time, so the anchor must too: the
// aircraft path's 0.1 s step cap would leave a slow-frame or hitching bridge
// falling ever further behind its own ship.
const dtSec = Math.min(
VESSEL_DEAD_RECKON_MAX_S,
Math.max(0, (nowMs - this.lastFrameMs) / 1000),
);
this.lastFrameMs = nowMs;
if (Number.isFinite(info.track)) {
this.heading = slewHeading(
this.heading ?? info.track,
info.track,
COCKPIT_HEADING_SLEW_DPS * dtSec,
);
}
// Past the projection limit the target stops advancing; hold on it rather
// than let the inertial anchor sail on alone.
const projectionExpired =
Number.isFinite(fix.ageSec) && fix.ageSec > VESSEL_DEAD_RECKON_MAX_S;
// The look eases on its own clock: the anchor's step is capped differently.
this.lookView = easeLook(
this.lookView,
this.lookTarget,
nowMs - (this.lookLastMs || nowMs),
);
this.lookLastMs = nowMs;
// A ship reporting neither course nor heading has no direction to move
// in: its anchor stays on the fix, as the dead reckoning does.
const ridden = Number.isFinite(info.motionCourse)
? info
: { ...info, velocityMps: 0 };
placeCamera.call(
this,
target,
projectionExpired ? { ...ridden, stale: true } : ridden,
nowMs,
dtSec,
vesselCameraProfile(info),
this.lookView,
);
}
/**
* Place the camera for one update: advance the inertial anchor, clamp it and
* the eye against the rendered surface, and look along the slewed heading.
* @param {{x: number, y: number, z: number}} target Authoritative subject position.
* @param {object} info Subject info.
* @param {object} info Subject info; `motionCourse` (when present) is the
* direction the subject moves, otherwise it moves where it faces.
* @param {number} nowMs Frame time.
* @param {number} dtSec Seconds since the previous camera update.
* @param {{forwardM: number, upM: number, pitchDeg: number,
* minClearanceM: number}} profile Eye offsets for the subject kind.
* @param {?{yawDeg: number, pitchDeg: number}} [look] A bridge view turned
* off the bow: yaw relative to the heading and absolute pitch. It turns
* only the view; the eye and its motion keep the heading and course.
* Aircraft pass none and look along the heading at the profile pitch.
*/
function placeCamera(target, info, nowMs, dtSec, profile) {
function placeCamera(target, info, nowMs, dtSec, profile, look = null) {
if (!this.cockpitAnchorValid) {
this.cockpitAnchor = clone(target);
this.cockpitAnchorValid = true;
@@ -136,7 +352,13 @@ function placeCamera(target, info, nowMs, dtSec, profile) {
// 15/30-second interpolation and per-frame cache without exposing its
// sample-boundary corrections to the camera.
const headingRad = toRadians(this.heading ?? 0);
const pitchRad = toRadians(profile.pitchDeg);
const courseRad = Number.isFinite(info.motionCourse)
? toRadians(info.motionCourse)
: headingRad;
const pitchRad = toRadians(look ? look.pitchDeg : profile.pitchDeg);
const viewHeadingRad = look
? toRadians((this.heading ?? 0) + look.yawDeg)
: headingRad;
const speedMps = Number.isFinite(info.velocityMps)
? Math.max(0, info.velocityMps)
: 0;
@@ -150,7 +372,7 @@ function placeCamera(target, info, nowMs, dtSec, profile) {
const horizontal = normalize(
frameVector(
eastNorthUp(this.cockpitAnchor),
vec(Math.sin(headingRad), Math.cos(headingRad), 0),
vec(Math.sin(courseRad), Math.cos(courseRad), 0),
),
);
this.cockpitAnchor = add(
@@ -179,9 +401,18 @@ function placeCamera(target, info, nowMs, dtSec, profile) {
// its already-clamped render position is a conservative temporary floor.
const anchorCartographic = toCartographicRadians(this.cockpitAnchor);
const targetCartographic = toCartographicRadians(target);
// A bridge's target is its fix dead-reckoned up to minutes ahead: read
// the floor where the ship is now, as its water is.
const floorAt =
info.kind === 'vessel' && targetCartographic
? {
latitude: toDegrees(targetCartographic.lat),
longitude: toDegrees(targetCartographic.lon),
}
: info;
let cockpitFloorM = this.services.cachedGroundFloor(
info.latitude,
info.longitude,
floorAt.latitude,
floorAt.longitude,
);
if (info.onGround === true) {
const groundPoint = [{ lat: info.latitude, lon: info.longitude }];
@@ -281,8 +512,8 @@ function placeCamera(target, info, nowMs, dtSec, profile) {
frameVector(
enu,
vec(
Math.sin(headingRad) * Math.cos(pitchRad),
Math.cos(headingRad) * Math.cos(pitchRad),
Math.sin(viewHeadingRad) * Math.cos(pitchRad),
Math.cos(viewHeadingRad) * Math.cos(pitchRad),
Math.sin(pitchRad),
),
),
@@ -291,8 +522,8 @@ function placeCamera(target, info, nowMs, dtSec, profile) {
frameVector(
enu,
vec(
-Math.sin(headingRad) * Math.sin(pitchRad),
-Math.cos(headingRad) * Math.sin(pitchRad),
-Math.sin(viewHeadingRad) * Math.sin(pitchRad),
-Math.cos(viewHeadingRad) * Math.sin(pitchRad),
Math.cos(pitchRad),
),
),