Draw the card previews through the renderer, and show vessel photos too

- The route globe, turning model and cockpit view are the renderer's: the
  Cesium plugin hands them over as its `cardPreviews` application hook
  (src/render/cesium/cardPreviews.js), and the card's tiles keep only the
  words, figures and HUD laid over them. Nothing in the UI reaches Cesium,
  and a renderer without the hook leaves the card its photo and figures.
- The turning model is the fleet model the globe draws for the aircraft's
  type, from the set loaded at startup, so opening a card fetches nothing.
  The flights layer's record now carries the type code and emitter category
  that pick it.
- The photo comes from the item's own layer: the flights layer's
  Planespotters photo for the plane it tracks, and the vessels layer's Open
  Vessel Photos photo for the vessel selected, with its credit. It no longer
  waits for Contacts to follow the same aircraft.
- The satellite models are left out: the card shows a satellite's ground
  view and graphs its altitude and speed.
- The route globe's airport codes are drawn into its own small scene, the
  compass reads its course in the active language, the callouts no longer
  speak to screen readers every six seconds, and figures use the app's
  number format. Esri's tile address and credit live in one place.

Co-authored-by: Manjunath Paparaju <[email protected]>
This commit is contained in:
Sameh KhamisandManjunath Paparaju committed 2026-11-16 15:44:35 -08:00
1 parent c6bdd38b61
commit 3a0842c103
26 files changed
+1347 -676

No files matched your search

+4 -1
View File
@@ -6,7 +6,8 @@ import {
isTrackingClickGesture,
isTrackingSelectionGesture,
} from '../data/trackingClickGesture.js';
import { findCamera } from '../render/rendererOf.js';
import { applicationHooksOf } from '../render/applicationHooks.js';
import { findCamera, rendererOf } from '../render/rendererOf.js';
import { useCockpitStore } from './stores/cockpit.js';
import { useEntityCardStore } from './stores/entityCard.js';
import { useOmnibarStore } from './stores/omnibar.js';
@@ -200,6 +201,8 @@ export function installEntityContext({
letGo,
isOpen,
regionalBrief,
// The renderer's card previews, when it has them.
previews: () => applicationHooksOf(rendererOf(viewer)).cardPreviews ?? null,
ask,
askText,
cockpit,
-30
View File
@@ -1,30 +0,0 @@
// The card previews (the turning model, the route globe) each draw in a
// small Cesium scene of their own, so each holds a WebGL context. A browser
// keeps only a handful of those open, and when there are too many it drops
// the oldest, which is the main globe's. A destroyed widget's context is
// otherwise freed only when garbage is collected, so flicking through cards
// can push the globe's context out. Losing a preview's context on purpose as
// it closes frees it at once.
/**
* Destroy a preview's Cesium widget and free its WebGL context.
* @param {object|null} widget a Cesium CesiumWidget
*/
export function destroyPreviewWidget(widget) {
if (!widget || widget.isDestroyed?.()) return;
let gl = null;
try {
gl =
widget.scene?.context?._gl ??
widget.canvas?.getContext?.('webgl2') ??
null;
} catch {
gl = null;
}
widget.destroy();
try {
gl?.getExtension?.('WEBGL_lose_context')?.loseContext();
} catch {
// Nothing more can be done; the context goes when it is collected.
}
}
+3
View File
@@ -304,6 +304,8 @@ export const useEntityCardStore = defineStore('gev-entity-card', () => {
? shell.value.regionalBrief(lat, lon)
: Promise.resolve(null);
const canFollow = () => Boolean(shell.value?.canFollow?.(card.value));
/** The renderer's card previews (`CardPreviews`), or null without them. */
const previews = () => shell.value?.previews?.() ?? null;
/** Loaded items whose name or id matches typed text, for the omnibar. */
const search = (query, options) =>
shell.value
@@ -325,6 +327,7 @@ export const useEntityCardStore = defineStore('gev-entity-card', () => {
follow,
ask,
readBrief,
previews,
canFollow,
isFollowing,
following,
+1 -1
View File
@@ -2187,7 +2187,7 @@
border-radius: 3px;
}
.entity-hero:is([data-hero='flight'], [data-hero='satellite']) {
.entity-hero:is([data-hero='flight'], [data-hero='satellite'], [data-hero='photo']) {
height: 168px;
background: radial-gradient(
ellipse 55% 60% at 50% 55%,
+1 -1
View File
@@ -248,7 +248,7 @@ watch(
</div>
</section>
<div v-if="contextOpen" v-show="activeTab === 'view'" id="context-tab-view" role="tabpanel" aria-labelledby="context-tab-btn-view" :class="{ 'context-searching': contextSearchOpen && contextSearchText.trim() }">
<EntityCard :with-contacts="contactsMatchCard" :aircraft-photo="contactsMatchCard ? awareness?.photo : null">
<EntityCard :with-contacts="contactsMatchCard">
<AwarenessPanel v-if="contactsMatchCard" compact />
</EntityCard>
<ViewContext v-if="!entityCard" />
+54 -208
View File
@@ -1,26 +1,16 @@
<script setup>
import { destroyPreviewWidget } from '../../previewWidget.js';
import * as Cesium from 'cesium';
import { computed, onBeforeUnmount, onMounted, ref, watch } from 'vue';
import { CLASS_MODEL_REAL, CLASS_MODEL_URL } from '../../../data/aircraftClass.js';
import PreviewHud from './PreviewHud.vue';
import { aircraftModelSpec, fleetModelSet } from '../../../data/fleetModels.js';
import { t } from '../../../i18n/index.js';
import { useEntityCardStore } from '../../stores/entityCard.js';
import PreviewHud from './PreviewHud.vue';
// The selected aircraft's own model, turning slowly at the top of its card:
// the same per-class mesh the globe draws (a Cessna for light aircraft, a
// 787 for widebodies, the shared airliner otherwise). It renders in a small
// Cesium scene of its own with no globe, sky or imagery, and is torn down
// with the card. A satellite's card uses it too, with a NASA model in place
// of the aircraft class's (`modelUrl`).
//
// Its look changes as it turns: a whole rotation as it is, then a short
// wireframe scan (under a third of a turn, about six seconds), then round
// again. The change each way is a reveal: a bright ring grows from the
// craft's centre out to its edges, turning it to white wire inside it on the
// way in and back to the model on the way out. In wire the body goes near-black with its own
// colours faintly showing (solar panels stay blue).
// One custom shader does it all, driven by a uniform, because a shader set on
// a model after it is ready does nothing in this Cesium.
// the same fleet model the globe draws for its type, from the bytes loaded at
// startup, so nothing is fetched when a card opens. The renderer draws it in
// a small scene of its own (the `cardPreviews` hook); this tile lays the
// callouts and HUD over it. As it turns it changes look: a whole rotation as
// it is, then a short wireframe scan, then round again.
//
// While it turns, one callout at a time sits in the frame's top-left corner,
// HUD-style, telling something worked out about the flight (phase, flight
@@ -29,14 +19,8 @@ import { t } from '../../../i18n/index.js';
// hold 2.3-5.2 s a thin timer under the value fills;
// exit 5.2-6.2 s the text fades; a short gap, then the next one.
const props = defineProps({
/** Aircraft class from the record (light, airliner, widebody...). */
aircraftClass: { type: String, default: '' },
/** A model to show instead of the class's own (a satellite's, say). */
modelUrl: { type: String, default: '' },
/** Degrees to turn that model about its east axis to lie level. */
modelTilt: { type: Number, default: 0 },
/** How far the camera stands, in bounding radii. */
viewRange: { type: Number, default: 1.9 },
/** `{typeCode, category, callsign}`: what picks the aircraft's fleet model. */
aircraft: { type: Object, default: null },
/** The aircraft's heading, so the turntable starts facing its way. */
heading: { type: Number, default: 0 },
/** `[{label, value}]` figures to call out, in order. */
@@ -45,68 +29,13 @@ const props = defineProps({
active: { type: Boolean, default: true },
});
const emit = defineEmits(['failed', 'cycle']);
const store = useEntityCardStore();
const host = ref(null);
const failed = ref(false);
watch(failed, (now) => now && emit('failed'));
// A hidden tile keeps drawing until its model has loaded, then rests on its
// last frame; shown again, it draws once straight away so there is no gap.
let ready = false;
function syncLoop() {
if (!widget || widget.isDestroyed()) return;
const run = props.active || !ready;
if (run && !widget.useDefaultRenderLoop) {
widget.resize();
widget.render();
}
widget.useDefaultRenderLoop = run;
}
watch(() => props.active, syncLoop);
let widget = null;
let model = null;
let removeTick = null;
/** How long each look lasts, and each reveal between them, in turns. */
const PLAIN_TURNS = 1;
const SCAN_TURNS = 0.3;
const REVEAL_TURNS = 0.07;
/** How long (ms) the plain model holds after the reveal before a cycle ends. */
const HOLD_MS = 700;
const phase = ref('plain');
// Model space, normalised so the craft reaches about 1.7 from its centre.
// u_reveal runs 0 to 2: from 0 to 1 the edge grows from the centre and
// leaves wire inside it; at 1 it is all wire; from 1 to 2 it grows again and
// leaves the model inside it. Outside that range the model draws as it is.
const LOOK_SHADER = `
void fragmentMain(FragmentInput fsInput, inout czm_modelMaterial material) {
if (u_reveal <= 0.0 || u_reveal >= 2.0) return;
vec3 p = fsInput.attributes.positionMC / u_half;
bool entering = u_reveal < 1.0;
float r = length(p);
float front = mix(0.0, 1.8, entering ? u_reveal : u_reveal - 1.0);
float edge = 1.0 - smoothstep(0.0, 0.05, abs(r - front));
vec3 white = vec3(0.9, 0.96, 1.0);
bool wire = entering ? r < front : r > front;
if (!wire) {
material.emissive += white * edge * 1.4;
return;
}
// A fine grid: many small cells, hairline lines.
vec3 q = p * 18.0;
vec3 g = abs(fract(q - 0.5) - 0.5) / max(fwidth(q), vec3(1e-4));
float line = (1.0 - clamp(min(min(g.x, g.y), g.z) * 2.4, 0.0, 1.0)) * 0.7;
vec3 base = material.diffuse;
// Opaque: a near-black body with white lines on it and its own colour
// faintly through, which reads as a wireframe against the dark card (a
// translucent model does not blend onto this scene's transparent canvas).
material.diffuse = base * 0.12 + vec3(0.015, 0.02, 0.03);
material.specular = vec3(0.0);
material.emissive = white * line + base * 0.35 + white * edge * 1.4;
}`;
let lookShader = null;
const classModelUrl = (cls) => CLASS_MODEL_REAL[cls]?.url || CLASS_MODEL_URL[cls] || '/models/airplane.glb';
let preview = null;
// One callout's whole life: enter 2.3 s + hold 2.9 s + exit 1.0 s + 0.3 s gap.
const CYCLE_MS = 6500;
@@ -121,141 +50,58 @@ const shown = computed(() => {
});
const pad = (n) => String(n).padStart(2, '0');
async function show(cls) {
if (!widget) return;
ready = false;
syncLoop();
const scene = widget.scene;
if (model) {
scene.primitives.remove(model);
model = null;
}
const origin = Cesium.Cartesian3.fromDegrees(0, 0, 0);
lookShader = new Cesium.CustomShader({
uniforms: {
u_reveal: { type: Cesium.UniformType.FLOAT, value: 0 },
u_half: { type: Cesium.UniformType.FLOAT, value: 20 },
},
fragmentShaderText: LOOK_SHADER,
});
try {
model = await Cesium.Model.fromGltfAsync({
url: props.modelUrl || classModelUrl(cls),
customShader: lookShader,
modelMatrix: Cesium.Matrix4.multiplyByMatrix3(
Cesium.Transforms.eastNorthUpToFixedFrame(origin),
Cesium.Matrix3.fromRotationX(Cesium.Math.toRadians(props.modelTilt)),
new Cesium.Matrix4(),
),
// A light rim so the mesh reads against the dark card.
silhouetteColor: Cesium.Color.WHITE.withAlpha(0.3),
silhouetteSize: 1,
});
} catch {
/** The fleet model's spec and bytes, or null before the set has loaded. */
function fleetModel(aircraft) {
const set = fleetModelSet();
if (!set || !aircraft) return null;
const spec = aircraftModelSpec(set, aircraft);
const gltf = set.bytes.get(spec.model);
return gltf ? { gltf, basePath: spec.url } : null;
}
function show() {
preview?.destroy();
preview = null;
phase.value = 'plain';
const previews = store.previews();
const model = fleetModel(props.aircraft);
if (!previews?.model || !model || !host.value) {
failed.value = true;
return;
}
if (!widget) return;
scene.primitives.add(model);
model.readyEvent.addEventListener(() => {
if (!widget) return;
const sphere = model.boundingSphere;
// The craft reaches about 0.6 of its bounding radius from the centre.
lookShader.setUniform('u_half', sphere.radius * 0.6);
const start = Cesium.Math.toRadians(props.heading + 140);
let heading = start;
const began = performance.now();
let cycleMs = 0;
let lastFrame = began;
let holdMs = null;
const still = globalThis.matchMedia?.('(prefers-reduced-motion: reduce)')?.matches;
const range = sphere.radius * props.viewRange;
const frame = () => {
heading += 0.005;
const turns = (heading - start) / (2 * Math.PI);
// Where in the scan it is, and from that how far each reveal has gone.
const into = (turns % (PLAIN_TURNS + SCAN_TURNS)) - PLAIN_TURNS;
const ease = (x) => x * x * (3 - 2 * x);
let reveal = 0;
if (!still && into >= 0) {
if (into < REVEAL_TURNS) reveal = ease(into / REVEAL_TURNS);
else if (into > SCAN_TURNS - REVEAL_TURNS) reveal = 1 + ease((into - (SCAN_TURNS - REVEAL_TURNS)) / REVEAL_TURNS);
else reveal = 1;
}
const next = reveal > 0 && reveal < 2 ? 'scan' : 'plain';
// One look and its scan make a cycle; say when one ends, and how long
// it took, so a card can give something else the same time.
// Only time spent drawing counts: a hidden preview stops drawing.
const now = performance.now();
const drawn = now - lastFrame < 250 ? now - lastFrame : 0;
cycleMs += drawn;
lastFrame = now;
// The cycle ends once the reveal back to the model has finished and the
// plain model has held a moment, never mid-reveal.
if (phase.value === 'scan' && next === 'plain') holdMs = 0;
if (holdMs !== null && next === 'plain') {
holdMs += drawn;
if (holdMs >= HOLD_MS) {
emit('cycle', cycleMs);
cycleMs = 0;
holdMs = null;
}
}
if (next !== phase.value) phase.value = next;
lookShader.setUniform('u_reveal', reveal);
widget.camera.lookAt(sphere.center, new Cesium.HeadingPitchRange(heading, Cesium.Math.toRadians(-18), range));
};
frame();
removeTick?.();
removeTick = scene.preRender.addEventListener(frame);
widget.render();
ready = true;
syncLoop();
});
preview = previews.model(
host.value,
{ ...model, heading: props.heading },
{
onPhase: (next) => (phase.value = next),
onCycle: (ms) => emit('cycle', ms),
onFailed: () => (failed.value = true),
},
);
preview.setActive(props.active);
}
onMounted(() => {
try {
widget = new Cesium.CesiumWidget(host.value, {
globe: false,
skyBox: false,
skyAtmosphere: false,
baseLayer: false,
scene3DOnly: true,
shadows: false,
showRenderLoopErrors: false,
contextOptions: { webgl: { alpha: true, antialias: true } },
// The globe's own credits already show; this scene has none to add.
creditContainer: document.createElement('div'),
});
const scene = widget.scene;
scene.backgroundColor = Cesium.Color.TRANSPARENT;
scene.light = new Cesium.DirectionalLight({
direction: Cesium.Cartesian3.normalize(new Cesium.Cartesian3(-0.4, -0.6, -0.7), new Cesium.Cartesian3()),
intensity: 2.4,
});
scene.screenSpaceCameraController.enableInputs = false;
void show(props.aircraftClass);
// Under reduced motion the first set of callouts stays.
const still = globalThis.matchMedia?.('(prefers-reduced-motion: reduce)')?.matches;
if (!still) cycle = setInterval(() => page.value++, CYCLE_MS);
} catch {
failed.value = true;
}
show();
// Under reduced motion the first set of callouts stays.
const still = globalThis.matchMedia?.('(prefers-reduced-motion: reduce)')?.matches;
if (!still) cycle = setInterval(() => page.value++, CYCLE_MS);
});
watch(
() => [props.aircraftClass, props.modelUrl],
() => void show(props.aircraftClass),
() => {
const a = props.aircraft;
return `${a?.typeCode ?? ''}|${a?.category ?? ''}|${a?.callsign ?? ''}`;
},
show,
);
watch(
() => props.active,
(active) => preview?.setActive(active),
);
onBeforeUnmount(() => {
clearInterval(cycle);
removeTick?.();
removeTick = null;
destroyPreviewWidget(widget);
widget = null;
model = null;
preview?.destroy();
preview = null;
});
</script>
@@ -267,7 +113,7 @@ onBeforeUnmount(() => {
<p v-if="phase === 'scan'" class="aircraft-hero__scan" aria-hidden="true">{{ t('Scanning') }}</p>
</Transition>
<Transition name="aircraft-hero-callout" mode="out-in" :duration="CALLOUT_TIMING">
<div v-if="shown" :key="page" class="aircraft-hero__callout" role="status">
<div v-if="shown" :key="page" class="aircraft-hero__callout">
<span class="aircraft-hero__label">{{ shown.label }}<em>{{ pad(shown.index + 1) }} / {{ pad(shown.total) }}</em></span>
<strong class="aircraft-hero__value">{{ shown.value }}</strong>
<i class="aircraft-hero__timer" aria-hidden="true"></i>
+34 -14
View File
@@ -21,8 +21,6 @@ import { countryName, nearestCity } from '../../../data/wikidataCities.js';
const props = defineProps({
/** Contacts follows this same aircraft, and its list sits inside the card. */
withContacts: Boolean,
/** The aircraft's photo from Contacts (`{src, link, credit}`), when it has one. */
aircraftPhoto: { type: Object, default: null },
});
const store = useEntityCardStore();
const { card, lost, tick } = storeToRefs(store);
@@ -203,9 +201,10 @@ watch(
{ immediate: true },
);
// The hero tile at the top of every card. A flight shows its photo (from
// Contacts), its route on a small globe, its 3D model and the view from its
// cockpit; a satellite, the ground beneath it; a camera, its latest frame.
// The hero tile at the top of every card. A flight shows its photo, its route
// on a small globe, its 3D model and the view from its cockpit; a vessel, its
// photo; a satellite, the ground beneath it; a camera, its latest frame.
// The globe, model and cockpit view are the renderer's (`store.previews()`).
// Anything else gets a quiet placeholder with its icon and its headline
// figures until it has imagery of its own. Previews stay mounted so switching
// shows the next one at once.
@@ -214,10 +213,26 @@ const modelFailed = ref(false);
const cockpitFailed = ref(false);
const hasPosition = computed(() => Number.isFinite(card.value?.lat) && Number.isFinite(card.value?.lon));
const cockpitKnown = computed(() => card.value?.kind === 'aircraft' && hasPosition.value && !cockpitFailed.value);
const modelKnown = computed(() => Boolean(card.value?.aircraftClass) && !modelFailed.value);
const modelKnown = computed(() => Boolean(card.value?.aircraftModel) && !modelFailed.value);
const preview = ref(null);
// The photo the item's layer looked up (Planespotters for a tracked
// airliner, Open Vessel Photos for a selected vessel), with its credit.
const failedPhoto = ref('');
const photoAvailable = computed(() => Boolean(props.aircraftPhoto?.src && props.aircraftPhoto.src !== failedPhoto.value));
const photo = computed(() => {
const found = card.value?.photo;
if (!found?.src || found.src === failedPhoto.value) return null;
const { photographer, licence } = found;
const credit = licence
? photographer
? t('Photo: {photographer} · {licence}', { photographer, licence })
: t('Photo · {licence}', { licence })
: photographer
? t('Photo © {photographer}', { photographer })
: '';
return { ...found, credit };
});
const photoAvailable = computed(() => Boolean(photo.value));
const onPhotoError = (event) => (failedPhoto.value = event.currentTarget.getAttribute('src'));
watch(() => props.withContacts, () => (preview.value = null));
// The model and the cockpit view take turns: after each of the model's
// cycles, the view ahead from the cockpit shows for as long as that cycle
@@ -250,7 +265,8 @@ function showOtherView(ms) {
}
const heroKind = computed(() => {
if (photoAvailable.value || routeKnown.value || modelKnown.value) return 'flight';
if (card.value?.kind === 'aircraft' && (photoAvailable.value || routeKnown.value || modelKnown.value)) return 'flight';
if (card.value?.kind === 'vessel' && photoAvailable.value) return 'photo';
if (card.value?.layerId === 'satellites' && hasPosition.value) return 'satellite';
if (card.value?.layerId === 'cctv') return 'camera';
return 'none';
@@ -332,18 +348,18 @@ watch(
<template v-if="heroKind === 'flight'">
<a
v-if="photoAvailable"
:key="aircraftPhoto.src"
:key="photo.src"
class="entity-hero__layer entity-hero__photo"
:class="{ 'is-shown': activeFlightPreview === 'photo' }"
:href="aircraftPhoto.link"
:href="photo.link || undefined"
target="_blank"
rel="noopener"
>
<img :src="aircraftPhoto.src" :alt="t('Photo of {name}', { name: shownTitle })" @error="failedPhoto = $event.currentTarget.getAttribute('src')" />
<small v-if="aircraftPhoto.credit">{{ aircraftPhoto.credit }}</small>
<img :src="photo.src" :alt="t('Photo of {name}', { name: shownTitle })" v-on="{ error: onPhotoError }" />
<small v-if="photo.credit">{{ photo.credit }}</small>
</a>
<RouteGlobe v-if="routeKnown" :key="`route-${card.key}`" class="entity-hero__layer" :class="{ 'is-shown': activeFlightPreview === 'route' }" :active="activeFlightPreview === 'route'" :from="card.route.fromAt" :to="card.route.toAt" :at="{ lat: card.lat, lon: card.lon }" :heading="card.heading" />
<AircraftModelHero v-if="card.aircraftClass && !modelFailed" :key="card.key" class="entity-hero__layer" :class="{ 'is-shown': activeFlightPreview === 'model' }" :active="activeFlightPreview === 'model'" :aircraft-class="card.aircraftClass" :heading="card.heading || 0" :callouts="callouts" @failed="modelFailed = true" @cycle="showOtherView" />
<RouteGlobe v-if="routeKnown" :key="`route-${card.key}`" class="entity-hero__layer" :class="{ 'is-shown': activeFlightPreview === 'route' }" :active="activeFlightPreview === 'route'" :from="card.route.fromAt" :to="card.route.toAt" :at="{ lat: card.lat, lon: card.lon }" />
<AircraftModelHero v-if="modelKnown" :key="card.key" class="entity-hero__layer" :class="{ 'is-shown': activeFlightPreview === 'model' }" :active="activeFlightPreview === 'model'" :aircraft="card.aircraftModel" :heading="card.heading || 0" :callouts="callouts" @failed="modelFailed = true" @cycle="showOtherView" />
<FlightCockpitView v-if="cockpitMade && cockpitKnown" :key="`cockpit-${card.key}`" class="entity-hero__layer" :class="{ 'is-shown': activeFlightPreview === 'cockpit' }" :active="activeFlightPreview === 'cockpit'" :lat="card.lat" :lon="card.lon" :altitude-m="card.altitudeM" :heading="card.heading" :speed-mps="card.speedMps" @failed="onCockpitFailed" />
<div v-if="cockpitKnown || (routeKnown && modelKnown) || (photoAvailable && (routeKnown || modelKnown))" class="entity-card__preview-switch" role="group" :aria-label="t('Preview')">
<button v-if="photoAvailable" type="button" :class="{ active: activeFlightPreview === 'photo' }" :aria-pressed="String(activeFlightPreview === 'photo')" :aria-label="t('Photos')" :title="t('Photos')" @click="choosePreview('photo')"><span class="material-symbols-outlined" aria-hidden="true">photo_camera</span></button>
@@ -352,6 +368,10 @@ watch(
<button v-if="cockpitKnown" type="button" :class="{ active: activeFlightPreview === 'cockpit' }" :aria-pressed="String(activeFlightPreview === 'cockpit')" :aria-label="t('Cockpit view')" :title="t('Cockpit view')" @click="choosePreview('cockpit')"><span class="material-symbols-outlined" aria-hidden="true">visibility</span></button>
</div>
</template>
<a v-else-if="heroKind === 'photo'" :key="photo.src" class="entity-hero__layer entity-hero__photo is-shown" :href="photo.link || undefined" target="_blank" rel="noopener">
<img :src="photo.src" :alt="t('Photo of {name}', { name: shownTitle })" v-on="{ error: onPhotoError }" />
<small v-if="photo.credit">{{ photo.credit }}</small>
</a>
<SatelliteGroundView v-else-if="heroKind === 'satellite'" :key="`ground-${card.key}`" class="entity-hero__layer is-shown" active :lat="card.lat" :lon="card.lon" />
<CctvPreview v-else-if="heroKind === 'camera'" :camera-id="card.identity?.id || ''" />
<!-- No imagery for it yet: its icon, with its headline figures beside it. -->
+29 -67
View File
@@ -1,19 +1,17 @@
<script setup>
import * as Cesium from 'cesium';
import { computed, onBeforeUnmount, onMounted, ref, watch } from 'vue';
import { t } from '../../../i18n/index.js';
import { ESRI_IMAGERY_CREDIT, createEsriImagery } from '../../../maps/imagery.js';
import { destroyPreviewWidget } from '../../previewWidget.js';
import { formatNumber, t } from '../../../i18n/index.js';
import { ESRI_IMAGERY_CREDIT } from '../../../maps/attribution.js';
import { useEntityCardStore } from '../../stores/entityCard.js';
import PreviewHud from './PreviewHud.vue';
// What the crew sees: the view ahead from the aircraft's own position,
// height and heading, a little nose down, over Esri World Imagery (the
// app's keyless basemap) on a plain ellipsoid with the sky's haze. It takes
// turns with the turning model, as a satellite's ground view does. It draws
// only when asked (a still, moved along with the craft while it shows) and
// holds still while hidden. Its credit line sits in the corner. Speed and
// altitude ride on tapes either side, as on a head-up display: the ticks
// roll as the figures change, with the figure boxed in the middle.
// height and heading, a little nose down, over Esri World Imagery. The
// renderer draws it (the `cardPreviews` hook) only when asked: a still,
// moved along with the craft while it shows. It takes turns with the turning
// model. Speed and altitude ride on tapes either side, as on a head-up
// display: the ticks roll as the figures change, with the figure boxed in
// the middle. Its credit line sits in the corner.
const props = defineProps({
lat: { type: Number, default: null },
lon: { type: Number, default: null },
@@ -27,77 +25,41 @@ const props = defineProps({
active: { type: Boolean, default: false },
});
const emit = defineEmits(['failed']);
const store = useEntityCardStore();
const host = ref(null);
let widget = null;
let preview = null;
const craft = () => ({ lat: props.lat, lon: props.lon, altitudeM: props.altitudeM, heading: props.heading });
/** A ground floor for the eye, so a landed or taxiing craft is not underground. */
const MIN_EYE_M = 60;
function place() {
if (!widget || !Number.isFinite(props.lat) || !Number.isFinite(props.lon)) return;
const height = Math.max(MIN_EYE_M, Number.isFinite(props.altitudeM) ? props.altitudeM : 0);
widget.camera.setView({
destination: Cesium.Cartesian3.fromDegrees(props.lon, props.lat, height),
orientation: {
heading: Cesium.Math.toRadians(Number.isFinite(props.heading) ? props.heading : 0),
pitch: Cesium.Math.toRadians(-9),
roll: 0,
},
});
widget.scene.requestRender();
}
onMounted(async () => {
try {
widget = new Cesium.CesiumWidget(host.value, {
baseLayer: false,
skyBox: false,
scene3DOnly: true,
shadows: false,
requestRenderMode: true,
maximumRenderTimeChange: Infinity,
showRenderLoopErrors: false,
contextOptions: { webgl: { alpha: false, antialias: true } },
creditContainer: document.createElement('div'),
});
const scene = widget.scene;
scene.screenSpaceCameraController.enableInputs = false;
scene.globe.baseColor = Cesium.Color.fromCssColorString('#0b1820');
scene.globe.showGroundAtmosphere = true;
scene.fog.enabled = true;
scene.camera.frustum.fov = Cesium.Math.toRadians(70);
// Tiles arriving ask for a frame, so the still fills in as they load.
scene.globe.tileLoadProgressEvent.addEventListener(() => scene.requestRender());
place();
const imagery = await createEsriImagery();
if (!widget) return;
scene.imageryLayers.addImageryProvider(imagery);
scene.requestRender();
} catch {
onMounted(() => {
const previews = store.previews();
if (!previews?.cockpit || !host.value) {
emit('failed');
return;
}
preview = previews.cockpit(host.value, craft(), { onFailed: () => emit('failed') });
preview.setActive(props.active);
});
// While it shows, the view keeps up with the craft as the card refreshes.
watch(
() => [props.active, props.lat, props.lon, props.altitudeM, props.heading],
() => props.active && place(),
() => [props.lat, props.lon, props.altitudeM, props.heading],
() => preview?.update(craft()),
);
watch(
() => props.active,
(active) => preview?.setActive(active),
);
onBeforeUnmount(() => {
destroyPreviewWidget(widget);
widget = null;
preview?.destroy();
preview = null;
});
const feet = computed(() =>
Number.isFinite(props.altitudeM) ? `${(Math.round((props.altitudeM * 3.28084) / 100) * 100).toLocaleString('en-US')} ft` : '',
);
// The tapes: one tick every 10 kt and every 100 ft, 8 px apart; the ticks
// roll by the remainder, so a change in the figure moves them.
const TICK_PX = 8;
const knots = computed(() => (Number.isFinite(props.speedMps) ? Math.round(props.speedMps * 1.94384) : null));
const altFeet = computed(() => (Number.isFinite(props.altitudeM) ? Math.round(props.altitudeM * 3.28084) : null));
const feet = computed(() => (altFeet.value === null ? '' : t('{n} ft', { n: formatNumber(Math.round(altFeet.value / 100) * 100) })));
const roll = (value, per) => (value === null ? 0 : ((value % per) / per) * TICK_PX);
const speedRoll = computed(() => `${roll(knots.value, 10)}px`);
const altRoll = computed(() => `${roll(altFeet.value, 100)}px`);
@@ -111,11 +73,11 @@ const course = computed(() => (Number.isFinite(props.heading) ? `${String(Math.r
<span class="flight-cockpit__horizon"><i></i></span>
<span v-if="knots !== null" class="flight-cockpit__tape flight-cockpit__tape--speed">
<i class="flight-cockpit__ticks" :style="{ backgroundPositionY: speedRoll }"></i>
<b>{{ knots }}</b><em>{{ t('KT') }}</em>
<b>{{ formatNumber(knots) }}</b><em>{{ t('KT') }}</em>
</span>
<span v-if="altFeet !== null" class="flight-cockpit__tape flight-cockpit__tape--alt">
<i class="flight-cockpit__ticks" :style="{ backgroundPositionY: altRoll }"></i>
<b>{{ altFeet.toLocaleString('en-US') }}</b><em>{{ t('FT') }}</em>
<b>{{ formatNumber(altFeet) }}</b><em>{{ t('FT') }}</em>
</span>
<span class="flight-cockpit__label">{{ t('Cockpit view') }}<strong>{{ [feet, course].filter(Boolean).join(' · ') }}</strong></span>
<span class="flight-cockpit__credit">{{ ESRI_IMAGERY_CREDIT }}</span>
+31 -268
View File
@@ -1,16 +1,14 @@
<script setup>
import { destroyPreviewWidget } from '../../previewWidget.js';
import * as Cesium from 'cesium';
import { computed, onBeforeUnmount, onMounted, ref, watch } from 'vue';
import { msg, t } from '../../../i18n/index.js';
import { useEntityCardStore } from '../../stores/entityCard.js';
// A flight's route on a small globe of its own at the top of its card: the
// great circle from origin to destination, solid where it has flown and
// dashed ahead, the two airports marked with their codes, and a plane icon
// where the craft is now, pointing the way it is flying. On opening, the flown part draws out from the
// origin to the craft. The globe uses Cesium's bundled Natural Earth image,
// so it fetches no map tiles. It holds still, north up and framed on the
// route; the plane points at the destination. The card names the airports'
// cities under its progress bar.
// dashed ahead, the two airports marked with their codes, and a plane where
// the craft is now, pointing at the destination. The renderer draws it (the
// `cardPreviews` hook); this tile lays the compass over it. The card names
// the airports' cities under its progress bar.
const props = defineProps({
/** `{code, lat, lon}` of the origin airport. */
from: { type: Object, required: true },
@@ -18,303 +16,68 @@ const props = defineProps({
to: { type: Object, required: true },
/** The craft's position now. */
at: { type: Object, default: null },
/** Its heading in degrees; without one the icon points along the route. */
heading: { type: Number, default: null },
/** Whether the tile is the one showing; a hidden one stops drawing. */
active: { type: Boolean, default: true },
});
const store = useEntityCardStore();
const host = ref(null);
const failed = ref(false);
let widget = null;
let removeTick = null;
let entities = null;
let plane = null;
let flownLine = null;
let aheadLine = null;
/** True while the plane flies in from the origin; position updates wait. */
let flyingIn = false;
let preview = null;
const CYAN = Cesium.Color.fromCssColorString('#36dcff');
// The plane: the Material "flight" silhouette, nose up (north), white with a
// cyan glow, drawn once as an image.
const PLANE_ICON = `data:image/svg+xml;utf8,${encodeURIComponent(
'<svg xmlns="http://www.w3.org/2000/svg" viewBox="-4 -4 32 32" width="64" height="64">' +
'<defs><filter id="g" x="-50%" y="-50%" width="200%" height="200%"><feGaussianBlur stdDeviation="1.4"/></filter></defs>' +
'<path filter="url(#g)" fill="#36dcff" d="M21 16v-2l-8-5V3.5c0-.83-.67-1.5-1.5-1.5S10 2.67 10 3.5V9l-8 5v2l8-2.5V19l-2 1.5V22l3.5-1 3.5 1v-1.5L13 19v-5.5l8 2.5z"/>' +
'<path fill="#ffffff" stroke="#0b1820" stroke-width="0.6" d="M21 16v-2l-8-5V3.5c0-.83-.67-1.5-1.5-1.5S10 2.67 10 3.5V9l-8 5v2l8-2.5V19l-2 1.5V22l3.5-1 3.5 1v-1.5L13 19v-5.5l8 2.5z"/>' +
'</svg>',
)}`;
const place = (p) => ({ code: p?.code || '', lat: Number(p?.lat), lon: Number(p?.lon) });
const at = () =>
props.at && Number.isFinite(props.at.lat) && Number.isFinite(props.at.lon) ? { lat: props.at.lat, lon: props.at.lon } : null;
const route = () => ({ from: place(props.from), to: place(props.to), at: at() });
/** The initial bearing (degrees from north) of the great circle a → b. */
function bearing(a, b) {
const rad = Math.PI / 180;
const y = Math.sin((b.lon - a.lon) * rad) * Math.cos(b.lat * rad);
const x =
Math.cos(a.lat * rad) * Math.sin(b.lat * rad) -
Math.sin(a.lat * rad) * Math.cos(b.lat * rad) * Math.cos((b.lon - a.lon) * rad);
const x = Math.cos(a.lat * rad) * Math.sin(b.lat * rad) - Math.sin(a.lat * rad) * Math.cos(b.lat * rad) * Math.cos((b.lon - a.lon) * rad);
return (Math.atan2(y, x) / rad + 360) % 360;
}
/**
* Billboard placement for the plane, nose along `deg` from north: the icon's
* up is tied to the local north direction on the globe and turned from there,
* so it points the right way in this tilted view too.
*/
function planePose(at, deg) {
const position = Cesium.Cartesian3.fromDegrees(at.lon, at.lat, 30_000);
const frame = Cesium.Transforms.eastNorthUpToFixedFrame(position);
const north = Cesium.Matrix4.getColumn(frame, 1, new Cesium.Cartesian4());
return {
position,
rotation: -Cesium.Math.toRadians(deg),
alignedAxis: new Cesium.Cartesian3(north.x, north.y, north.z),
};
}
/**
* The point on the route (the great circle from origin to destination)
* nearest the craft. The craft is drawn there and the route split there, so
* the path stays one smooth arc: a craft a little off the direct line
* (vectors, airways, a detour) would otherwise bend it into a sharp corner.
*/
function onRoute(at) {
if (!at || !Number.isFinite(at.lat)) return null;
const route = new Cesium.EllipsoidGeodesic(
Cesium.Cartographic.fromDegrees(props.from.lon, props.from.lat),
Cesium.Cartographic.fromDegrees(props.to.lon, props.to.lat),
);
const here = Cesium.Cartesian3.fromDegrees(at.lon, at.lat);
let best = null;
let bestDistance = Infinity;
const STEPS = 200;
for (let i = 0; i <= STEPS; i++) {
const c = route.interpolateUsingFraction(i / STEPS);
const d = Cesium.Cartesian3.distanceSquared(here, Cesium.Cartesian3.fromRadians(c.longitude, c.latitude));
if (d < bestDistance) {
bestDistance = d;
best = { lat: Cesium.Math.toDegrees(c.latitude), lon: Cesium.Math.toDegrees(c.longitude) };
}
}
return best;
}
// The nose points at the destination: along the great circle from here.
const planeHeading = (at) => bearing(at, props.to);
// The compass: the view is north up, so N sits at the top; a cyan needle
// shows the course to the destination, with its bearing in degrees.
const course = computed(() => {
const at = props.at && Number.isFinite(props.at.lat) ? props.at : props.from;
return Math.round(bearing(at, props.to));
});
const courseLabel = computed(() => {
const points = ['N', 'NE', 'E', 'SE', 'S', 'SW', 'W', 'NW'];
return `${String(course.value).padStart(3, '0')}° ${points[Math.round(course.value / 45) % 8]}`;
});
const AMBER = Cesium.Color.fromCssColorString('#ffb86b');
const course = computed(() => Math.round(bearing(at() || props.from, props.to)) % 360);
const POINTS = [msg('N'), msg('NE'), msg('E'), msg('SE'), msg('S'), msg('SW'), msg('W'), msg('NW')];
const courseLabel = computed(() => `${String(course.value).padStart(3, '0')}° ${t(POINTS[Math.round(course.value / 45) % 8])}`);
/** Points along the great circle from a to b, `t` from 0 to 1. */
function arc(a, b, steps = 64, upTo = 1) {
const start = Cesium.Cartographic.fromDegrees(a.lon, a.lat);
const end = Cesium.Cartographic.fromDegrees(b.lon, b.lat);
const geodesic = new Cesium.EllipsoidGeodesic(start, end);
const out = [];
const n = Math.max(2, Math.round(steps * upTo));
for (let i = 0; i <= n; i++) {
const c = geodesic.interpolateUsingFraction((i / n) * upTo);
out.push(Cesium.Cartesian3.fromRadians(c.longitude, c.latitude, 30_000));
}
return out;
}
function draw() {
if (!widget) return;
const { from, to } = props;
const at = onRoute(props.at);
entities?.removeAll();
entities = widget.entities;
const pin = (place, color) =>
entities.add({
position: Cesium.Cartesian3.fromDegrees(place.lon, place.lat),
point: { pixelSize: 7, color, outlineColor: Cesium.Color.BLACK.withAlpha(0.6), outlineWidth: 1 },
label: {
text: place.code || '',
font: '600 11px ui-monospace, monospace',
fillColor: Cesium.Color.WHITE,
outlineColor: Cesium.Color.BLACK,
outlineWidth: 3,
style: Cesium.LabelStyle.FILL_AND_OUTLINE,
pixelOffset: new Cesium.Cartesian2(0, -14),
},
});
pin(from, CYAN.withAlpha(0.9));
pin(to, AMBER);
// Ahead of the craft, dashed; behind it, solid, drawing out on open.
aheadLine = entities.add({
polyline: {
positions: arc(at || from, to),
width: 1.5,
material: new Cesium.PolylineDashMaterialProperty({ color: AMBER.withAlpha(0.8), dashLength: 10 }),
arcType: Cesium.ArcType.NONE,
},
});
if (at) {
let progress = 0;
const flown = (flownLine = entities.add({
polyline: {
positions: new Cesium.CallbackProperty(() => arc(from, at, 48, Math.max(0.02, progress)), false),
width: 2.5,
material: new Cesium.PolylineGlowMaterialProperty({ color: CYAN, glowPower: 0.25 }),
arcType: Cesium.ArcType.NONE,
},
}));
// The fly-in waits until the globe has drawn (its imagery loads a moment
// after the card opens), at most 1.5 s, so it is seen from the start.
let began = null;
const opened = performance.now();
// The plane starts at the origin and flies out along the flown line as it
// draws, arriving where the craft is now; it points at the destination
// all the way.
const start = planePose(from, planeHeading(from));
plane = entities.add({
position: start.position,
billboard: {
image: PLANE_ICON,
width: 26,
height: 26,
rotation: start.rotation,
alignedAxis: start.alignedAxis,
},
});
const leg = new Cesium.EllipsoidGeodesic(
Cesium.Cartographic.fromDegrees(from.lon, from.lat),
Cesium.Cartographic.fromDegrees(at.lon, at.lat),
);
const ease = (x) => 1 - (1 - x) ** 3;
flyingIn = true;
const grow = () => {
if (began === null) {
if (!widget.scene.globe.tilesLoaded && performance.now() - opened < 1500) return;
began = performance.now();
}
const raw = Math.min(1, (performance.now() - began) / 1600);
progress = ease(raw);
const c = leg.interpolateUsingFraction(progress);
const where = { lat: Cesium.Math.toDegrees(c.latitude), lon: Cesium.Math.toDegrees(c.longitude) };
const pose = planePose(where, planeHeading(where));
plane.position = pose.position;
plane.billboard.rotation = pose.rotation;
plane.billboard.alignedAxis = pose.alignedAxis;
if (raw >= 1) {
flyingIn = false;
flown.polyline.positions = arc(from, at, 48);
widget?.scene.preRender.removeEventListener(grow);
}
};
widget.scene.preRender.addEventListener(grow);
}
// Frame the whole route, north up, looking down at a slight tilt; the view
// holds still so the plane and labels keep their bearings.
const points = [from, to, ...(at ? [at] : [])].map((p) => Cesium.Cartesian3.fromDegrees(p.lon, p.lat));
const sphere = Cesium.BoundingSphere.fromPoints(points);
const range = Math.max(1_800_000, sphere.radius * 3.2);
removeTick?.();
removeTick = null;
const center = Cesium.Ellipsoid.WGS84.scaleToGeodeticSurface(sphere.center) || sphere.center;
widget.camera.lookAt(center, new Cesium.HeadingPitchRange(0, Cesium.Math.toRadians(-62), range));
widget.scene.requestRender();
}
onMounted(async () => {
try {
widget = new Cesium.CesiumWidget(host.value, {
baseLayer: false,
skyBox: false,
skyAtmosphere: false,
scene3DOnly: true,
shadows: false,
showRenderLoopErrors: false,
contextOptions: { webgl: { alpha: true, antialias: true } },
creditContainer: document.createElement('div'),
});
const scene = widget.scene;
scene.backgroundColor = Cesium.Color.TRANSPARENT;
scene.globe.baseColor = Cesium.Color.fromCssColorString('#0b1820');
scene.globe.showGroundAtmosphere = false;
scene.globe.enableLighting = false;
scene.screenSpaceCameraController.enableInputs = false;
const imagery = await Cesium.TileMapServiceImageryProvider.fromUrl(
Cesium.buildModuleUrl('Assets/Textures/NaturalEarthII'),
);
if (!widget) return;
const layer = scene.imageryLayers.addImageryProvider(imagery);
// Dimmed and cooled, so the route reads over it.
layer.brightness = 0.55;
layer.saturation = 0.35;
layer.contrast = 1.1;
draw();
} catch {
onMounted(() => {
const previews = store.previews();
if (!previews?.route || !host.value) {
failed.value = true;
return;
}
preview = previews.route(host.value, route(), { onFailed: () => (failed.value = true) });
preview.setActive(props.active);
});
// A new route redraws; the craft moving along it only moves its marker and
// the two lines, without replaying the opening draw.
// Watched as strings: a fresh array each card refresh would count as a change
// every two seconds and restart the drawing and the turn.
// Watched as strings: a fresh object each card refresh would count as a
// change every two seconds.
watch(
() => `${props.from?.code}|${props.to?.code}`,
() => draw(),
() => `${props.from?.code}|${props.to?.code}|${props.at?.lat?.toFixed?.(4)}|${props.at?.lon?.toFixed?.(4)}`,
() => preview?.update(route()),
);
watch(
() => `${props.at?.lat?.toFixed?.(4)}|${props.at?.lon?.toFixed?.(4)}|${Math.round(props.heading ?? -1)}`,
() => {
const at = onRoute(props.at);
if (!widget || !at || !plane || flyingIn) return;
const pose = planePose(at, planeHeading(at));
plane.position = pose.position;
plane.billboard.rotation = pose.rotation;
plane.billboard.alignedAxis = pose.alignedAxis;
if (flownLine) flownLine.polyline.positions = arc(props.from, at, 48);
if (aheadLine) aheadLine.polyline.positions = arc(at, props.to);
},
);
// Hidden, the globe rests on its last frame; shown again, it draws once
// straight away so there is no gap.
watch(
() => props.active,
(active) => {
if (!widget || widget.isDestroyed()) return;
if (active && !widget.useDefaultRenderLoop) {
widget.resize();
widget.render();
}
widget.useDefaultRenderLoop = active;
},
(active) => preview?.setActive(active),
);
onBeforeUnmount(() => {
removeTick?.();
removeTick = null;
destroyPreviewWidget(widget);
widget = null;
preview?.destroy();
preview = null;
});
</script>
<template>
<div v-if="!failed" class="route-globe">
<div ref="host" class="route-globe__scene" aria-hidden="true"></div>
<div class="route-globe__compass" :title="`Course to ${to.code}: ${courseLabel}`">
<div class="route-globe__compass" :title="t('Course to {code}: {course}', { code: to.code, course: courseLabel })">
<svg viewBox="-24 -24 48 48" aria-hidden="true">
<circle r="19" class="route-globe__compass-ring" />
<g class="route-globe__compass-ticks">
<line v-for="deg in [0, 45, 90, 135, 180, 225, 270, 315]" :key="deg" :transform="`rotate(${deg})`" y1="-19" :y2="deg % 90 ? -16.5 : -15" />
</g>
<text y="-9.5" class="route-globe__compass-n">N</text>
<text y="-9.5" class="route-globe__compass-n">{{ t('N') }}</text>
<g :transform="`rotate(${course})`" class="route-globe__compass-needle">
<path d="M0 -14 L3 2 L0 0 L-3 2 Z" />
</g>
+2 -3
View File
@@ -2,7 +2,7 @@
import { computed, ref, watch } from 'vue';
import { t } from '../../../i18n/index.js';
import { nearestCity } from '../../../data/wikidataCities.js';
import { ESRI_IMAGERY_CREDIT, ESRI_IMAGERY_URL } from '../../../maps/imagery.js';
import { ESRI_IMAGERY_CREDIT, ESRI_TILES } from '../../../maps/attribution.js';
import PreviewHud from './PreviewHud.vue';
// What lies under a satellite: a dark, grey top-down image of the ground at
@@ -21,7 +21,6 @@ const props = defineProps({
active: { type: Boolean, default: false },
});
const TILE_URL = `${ESRI_IMAGERY_URL}/tile`;
const CLOSE_ZOOM = 13;
const WIDE_ZOOM = 4;
const TILE = 256;
@@ -75,7 +74,7 @@ const tiles = computed(() => {
const x = (((cx + dx) % here.n) + here.n) % here.n;
list.push({
key: `${x}/${y}`,
src: `${TILE_URL}/${here.zoom}/${y}/${x}`,
src: ESRI_TILES.replace('{z}', here.zoom).replace('{y}', y).replace('{x}', x),
left: (cx + dx - here.x) * TILE,
top: (cy + dy - here.y) * TILE,
});