Merge main through #1591 into the renderer seam

Brings in the wildlife sightings layer (#1591, iNaturalist and Acartia
sightings). Its badges, density glow and privacy cells draw through the
draw port: the badges and the glow are icons sets (iconCollection.js
batches point writes into one upsert per task), and the privacy cells are
ground-clamped shapes and lines sets swapped whole. The eye, the view
rectangle, clicks, projection, ground readiness and frames come from the
camera, query, input, globe and frame ports, so the layer, its card and
its placement no longer import Cesium.

Differences from main: the density glow is drawn as pixel-sized splats
(56 px) instead of metre-sized ones with a near fade; the card's pan eases
with cubicOut, the contract's nearest ease-out; ground heights are
resampled when the globe's load progress settles or its surface changes,
rather than on tileset load events.

Also fixes two things the last merge left: a double-click that starts on
the followed track and ends off it reaches the renderer's own follow again
(a press that cannot end a double-click on the track gives its hold back
at its release), and the Active Fires heat drapes under the weather
imagery, so weather turned on after it stacks above. CURRENT-STATE notes
that the 2D and Columbus scene-mode checks are gone.
This commit is contained in:
Sameh Khamis committed 2026-11-09 23:06:26 -08:00
commit 020a433b51
129 files changed
+22143 -336

No files matched your search

+263
View File
@@ -0,0 +1,263 @@
import { fromDegrees, toLonLatH } from '../geo/ellipsoid.js';
import { horizonFrom } from '../geo/horizon.js';
import { add, sub } from '../geo/vector.js';
import { canvasOf, findCamera, findQuery } from '../render/rendererOf.js';
import { WORLD_OVERLAY_OCCLUDER_SELECTORS } from '../overlays/worldOverlayChrome.js';
// DOM cards also avoid the HUD edges and responsive sheet containers.
export const WILDLIFE_CARD_CHROME_SELECTORS = Object.freeze([
...WORLD_OVERLAY_OCCLUDER_SELECTORS,
'.hud-left-edge',
'.hud-right-edge',
'#right-panel-stack',
'.gev-panel-rail',
'#location-bar',
'#control-panel',
'#param-slider-panel',
'#cockpit-hud .cockpit-topline',
'[data-mobile-sheet]',
]);
const GAP = 12;
const EDGE = 6;
export const WILDLIFE_SELECTED_CARD_WIDTH = 258;
const overlaps = (a, b) =>
a.left < b.right && a.right > b.left && a.top < b.bottom && a.bottom > b.top;
const contains = (r, p) =>
p.x >= r.left && p.x <= r.right && p.y >= r.top && p.y <= r.bottom;
const clamp = (value, low, high) => Math.max(low, Math.min(high, value));
const rectAt = (left, top, width, height) => ({
left,
top,
right: left + width,
bottom: top + height,
width,
height,
});
/** Read visible chrome rectangles inside the viewer's usable screen area. */
export function readWildlifeCardSafeArea({
documentRef,
viewer,
windowRef = globalThis.window,
}) {
const canvasRect = canvasOf(viewer)?.getBoundingClientRect?.();
const width =
windowRef?.innerWidth || documentRef.documentElement.clientWidth;
const height =
windowRef?.innerHeight || documentRef.documentElement.clientHeight;
const left = Math.max(0, canvasRect?.left || 0) + EDGE;
const top = Math.max(0, canvasRect?.top || 0) + EDGE;
const right =
Math.min(width, canvasRect?.width > 0 ? canvasRect.right : width) - EDGE;
const bottom =
Math.min(height, canvasRect?.height > 0 ? canvasRect.bottom : height) -
EDGE;
const bounds = rectAt(
left,
top,
Math.max(0, right - left),
Math.max(0, bottom - top),
);
const obstacles = [];
const elements = [
...documentRef.querySelectorAll(WILDLIFE_CARD_CHROME_SELECTORS.join(',')),
];
for (const element of elements) {
let hidden = false;
for (
let node = element;
node && node !== documentRef.body;
node = node.parentElement
) {
const style = windowRef?.getComputedStyle?.(node);
if (
node.hidden ||
style?.display === 'none' ||
style?.visibility === 'hidden' ||
style?.opacity === '0'
) {
hidden = true;
break;
}
}
if (hidden) continue;
const rect = element.getBoundingClientRect();
if (!(rect.width > 0 && rect.height > 0) || !overlaps(rect, bounds))
continue;
obstacles.push(
rectAt(
rect.left - EDGE,
rect.top - EDGE,
rect.width + EDGE * 2,
rect.height + EDGE * 2,
),
);
}
return { bounds, obstacles, elements };
}
function nearestSafeAnchor(point, { bounds, obstacles }) {
const xs = [clamp(point.x, bounds.left + GAP, bounds.right - GAP)];
const ys = [clamp(point.y, bounds.top + GAP, bounds.bottom - GAP)];
for (const rect of obstacles) {
xs.push(
clamp(rect.left - GAP, bounds.left + GAP, bounds.right - GAP),
clamp(rect.right + GAP, bounds.left + GAP, bounds.right - GAP),
);
ys.push(
clamp(rect.top - GAP, bounds.top + GAP, bounds.bottom - GAP),
clamp(rect.bottom + GAP, bounds.top + GAP, bounds.bottom - GAP),
);
}
return (
xs
.flatMap((x) => ys.map((y) => ({ x, y })))
.filter(
(p) => contains(bounds, p) && !obstacles.some((r) => contains(r, p)),
)
.sort(
(a, b) =>
Math.hypot(a.x - point.x, a.y - point.y) -
Math.hypot(b.x - point.x, b.y - point.y),
)[0] || null
);
}
/** Four anchored placements, clamped along their free axis. Chrome is a set of
* actual DOM rectangles, so corner HUDs do not erase otherwise clear lanes. */
export function placeWildlifeSightingCard(point, size, safeArea) {
const { bounds, obstacles } = safeArea;
const anchor =
contains(bounds, point) && !obstacles.some((r) => contains(r, point))
? point
: nearestSafeAnchor(point, safeArea);
if (!anchor) return null;
const width = Math.min(size.width, bounds.width);
const height = Math.min(size.height, bounds.height);
const centeredX = clamp(
anchor.x - width / 2,
bounds.left,
bounds.right - width,
);
const centeredY = clamp(
anchor.y - height / 2,
bounds.top,
bounds.bottom - height,
);
const candidates = [
{
placement: 'above',
...rectAt(centeredX, anchor.y - GAP - height, width, height),
},
{ placement: 'below', ...rectAt(centeredX, anchor.y + GAP, width, height) },
{ placement: 'right', ...rectAt(anchor.x + GAP, centeredY, width, height) },
{
placement: 'left',
...rectAt(anchor.x - GAP - width, centeredY, width, height),
},
];
const fits = (rect) =>
rect.left >= bounds.left &&
rect.right <= bounds.right &&
rect.top >= bounds.top &&
rect.bottom <= bounds.bottom &&
!obstacles.some((r) => overlaps(rect, r));
let chosen = candidates.find(fits);
if (!chosen) {
// Crowded chrome may require sliding a side placement farther from its
// anchor. Search only obstacle/bounds edges; no pixels or idle frame loop.
const xs = [bounds.left, bounds.right - width, centeredX];
const ys = [bounds.top, bounds.bottom - height, centeredY];
for (const r of obstacles) {
xs.push(r.left - width, r.right);
ys.push(r.top - height, r.bottom);
}
const alternatives = xs
.flatMap((x) =>
ys.map((y) => ({
placement:
y + height <= anchor.y
? 'above'
: y >= anchor.y
? 'below'
: x >= anchor.x
? 'right'
: 'left',
...rectAt(x, y, width, height),
})),
)
.filter((r) => fits(r) && !contains(r, anchor));
alternatives.sort(
(a, b) =>
Math.hypot(
clamp(anchor.x, a.left, a.right) - anchor.x,
clamp(anchor.y, a.top, a.bottom) - anchor.y,
) -
Math.hypot(
clamp(anchor.x, b.left, b.right) - anchor.x,
clamp(anchor.y, b.top, b.bottom) - anchor.y,
),
);
chosen = alternatives[0];
}
return chosen
? {
...chosen,
anchor,
pan: { x: anchor.x - point.x, y: anchor.y - point.y },
}
: null;
}
/** Project a front-side sighting into viewport coordinates. */
export function projectWildlifeSighting(viewer, row, layer) {
const camera = viewer ? findCamera(viewer) : null;
const query = viewer ? findQuery(viewer) : null;
if (
!camera ||
!query ||
!Number.isFinite(row?.lat) ||
!Number.isFinite(row?.lon)
)
return null;
const position =
layer?.getSightingPosition?.(row.stableId) || fromDegrees(row.lon, row.lat);
if (horizonFrom(camera.pose().position).isPointVisible(position) !== true)
return null;
const point = query.project(position);
if (!point) return null;
const rect = canvasOf(viewer)?.getBoundingClientRect?.();
return { x: point.x + (rect?.left || 0), y: point.y + (rect?.top || 0) };
}
/** Translate the camera by the smallest screen correction and preserve its
* altitude/orientation. A card must never zoom merely to reveal its anchor. */
export function panWildlifeSighting(viewer, from, to, reducedMotion = false) {
const camera = viewer ? findCamera(viewer) : null;
const query = viewer ? findQuery(viewer) : null;
const canvas = canvasOf(viewer);
if (!camera || !query || !canvas) return false;
const rect = canvas.getBoundingClientRect();
const pick = (p) => query.pickEllipsoid(p.x - rect.left, p.y - rect.top);
const start = pick(from);
const finish = pick(to);
if (!start || !finish) return false;
const pose = camera.pose();
const destination = toLonLatH(add(pose.position, sub(start, finish)));
if (!destination) return false;
camera.flyTo(
{ lon: destination.lon, lat: destination.lat, height: pose.height },
{
orientation: {
heading: pose.heading,
pitch: pose.pitch,
roll: pose.roll,
},
durationS: reducedMotion ? 0 : 0.22,
// The contract's nearest ease-out to a quadratic one.
easing: 'cubicOut',
},
);
return true;
}