diff --git a/changelog.d/1774-card-previews.md b/changelog.d/1774-card-previews.md new file mode 100644 index 000000000..8a7a24c0e --- /dev/null +++ b/changelog.d/1774-card-previews.md @@ -0,0 +1,4 @@ +- Preview what Context's card shows: a flight's photo, its route on a small + globe, its fleet model turning and the view from its cockpit; a vessel's + photo; and the ground beneath a satellite, with its altitude and speed + graphed (manjunath22466, samehkhamis, #1774). diff --git a/docs/CURRENT-STATE.md b/docs/CURRENT-STATE.md index 166e537b9..285ff5a88 100644 --- a/docs/CURRENT-STATE.md +++ b/docs/CURRENT-STATE.md @@ -933,6 +933,19 @@ come through the regional brief service; earthquakes, tropical storms and fire perimeters come from the same feeds as their layers, cached for five minutes; satellite fire hits only while the FIRMS layer is on. +The card's top tile previews what is picked. A flight shows its +Planespotters photo once the flights layer has looked one up for the plane +it tracks, its route on a small globe (origin to destination, flown part +solid, the plane on it), its fleet model turning with callouts of what can +be worked out about the flight, and the view ahead from its cockpit with +speed and altitude tapes; the model and the cockpit view take turns. A +vessel shows its Open Vessel Photos photo, a satellite the ground beneath it +from Esri World Imagery with its altitude and speed graphed. The globe, model +and cockpit view are drawn by the renderer through its `cardPreviews` +application hook (`src/render/cesium/cardPreviews.js`), each in a small scene +of its own that frees its graphics context as it closes; the model comes from +the fleet set loaded at startup, so opening a card fetches no model. + ## Wikidata cities pack — November 15, 2026 `src/data/local_data/wikidata_cities/cities.json` bundles 31,827 settlements of diff --git a/index.html b/index.html index fcc5f79cf..c159503c1 100644 --- a/index.html +++ b/index.html @@ -26,7 +26,7 @@ with the sources: src/materialSymbolsSubset.test.mjs fails when a source names a glyph this list is missing, because a missing glyph does not draw a box — the ligature never forms and the element renders the literal word. --> - +
diff --git a/scripts/package-boundaries.json b/scripts/package-boundaries.json index 8db0d6c70..a5a719033 100644 --- a/scripts/package-boundaries.json +++ b/scripts/package-boundaries.json @@ -276,7 +276,16 @@ "src/ui/views/panels/EntityCard.vue", "src/data/aircraftEmergency.js", "src/data/aircraftClass.js", - "src/data/entityRecords.js" + "src/data/entityRecords.js", + "src/ui/views/panels/RouteGlobe.vue", + "src/maps/attribution.js", + "src/ui/views/panels/FlightCockpitView.vue", + "src/ui/views/panels/PreviewHud.vue", + "src/data/fleetTrailAnchors.js", + "src/ui/views/panels/SatelliteGroundView.vue", + "src/data/vesselTypes.js", + "src/data/fleetModels.js", + "src/ui/views/panels/AircraftModelHero.vue" ], "external": ["vue", "pinia", "vue-i18n"] }, @@ -1636,7 +1645,8 @@ "src/ui/stores/entityCard.js", "src/ui/entityContextBridge.js", "src/data/trackingClickGesture.js", - "src/ui/stores/sceneSharing.js" + "src/ui/stores/sceneSharing.js", + "src/maps/attribution.js" ], "external": [ "cesium", @@ -2422,7 +2432,8 @@ "src/render/vectorBase/paint.js", "src/layers/wind/streamlines.js", "src/layers/wind/model.js", - "src/sky/assets.js" + "src/sky/assets.js", + "src/render/cesium/cardPreviews.js" ], "external": ["cesium", "pbf", "@mapbox/vector-tile", "kdbush"] }, @@ -2571,7 +2582,8 @@ "src/render/applicationHooks.js", "src/maps/globeEngine.js", "src/maps/engine.js", - "src/maps/keylessTerrain.js" + "src/maps/keylessTerrain.js", + "src/maps/attribution.js" ], "external": ["cesium"] }, @@ -5216,37 +5228,13 @@ "src/library/entries/wri-global-power-plants.json", "src/library/entries/wv-statewide-imagery.json", "src/library/formats.js", - "src/library/entries/gvp-holocene-volcanoes.json", - "src/library/entries/nasa-black-marble.json", - "src/library/entries/nasa-eonet-events.json", "src/library/catalog.js", "src/library/source.js", "src/library/layers.js", "src/library/controller.js", "src/library/extent.js", "src/library/camera.js", - "src/library/entries/imf-portwatch-disruptions.json", - "src/library/entries/imf-portwatch-chokepoints.json", - "src/library/entries/noaa-tide-stations.json", - "src/library/entries/nws-active-alerts.json", - "src/library/entries/wri-global-power-plants.json", - "src/library/entries/fema-usa-structures.json", - "src/library/entries/epc-england-wales.json", "src/library/parquet.js", - "src/library/entries/bkg-topplus-open.json", - "src/library/entries/epa-superfund-sites.json", - "src/library/entries/epa-toxic-release-facilities.json", - "src/library/entries/gbif-occurrence-density.json", - "src/library/entries/gdacs-disaster-alerts.json", - "src/library/entries/gsi-japan-map.json", - "src/library/entries/ign-orthophotos-france.json", - "src/library/entries/gsi-japan-photo.json", - "src/library/entries/jrc-surface-water.json", - "src/library/entries/ntad-national-bridges.json", - "src/library/entries/usgs-hydrography.json", - "src/library/entries/macrostrat-geology.json", - "src/library/entries/swisstopo-swissimage.json", - "src/library/entries/usgs-topo.json", "src/library/outlines.js", "src/library/relief.js", "src/sceneCommandRelease.js", @@ -5444,7 +5432,8 @@ "src/ui/stores/omnibar.js", "src/data/entityContext.js", "src/ui/stores/entityCard.js", - "src/ui/entityContextBridge.js" + "src/ui/entityContextBridge.js", + "src/render/cesium/cardPreviews.js" ], "external": [ "hls.js", @@ -6213,8 +6202,6 @@ "src/layers/osmPlaces/index.js", "src/app/layers/osmPlaces.js", "src/layers/awareness/rangeRing.js", - "src/data/feedState.js", - "src/loadingFeedback.js", "src/data/firmsIntensity.js", "src/data/firmsHeatRaster.js", "src/layers/firms/heatImagery.js", @@ -6272,7 +6259,8 @@ "src/layers/flights/placed.js", "src/data/placementProvider.js", "src/data/courseFromFixes.js", - "src/time/frameWait.js" + "src/time/frameWait.js", + "src/maps/attribution.js" ], "external": [ "hls.js", diff --git a/src/data/entityContext.js b/src/data/entityContext.js index dd38908e9..065d06188 100644 --- a/src/data/entityContext.js +++ b/src/data/entityContext.js @@ -949,6 +949,36 @@ export function aircraftInsights(record, { nowMs = Date.now() } = {}) { return out; } +/** + * The item's photo, once its layer has looked one up: the tracked airliner's + * Planespotters photo, or the selected vessel's Open Vessel Photos photo. + * @returns {{src: string, link: string, photographer: string, + * licence: string}|null} + */ +function cardPhoto(dataManager, layerId, record) { + let photo = null; + try { + const layer = dataManager?.layers?.get?.(layerId)?.module; + if (layerId === 'ais-live-vessels') + photo = layer?.getVesselPhoto?.(text(record?.vesselId)); + else if (layerId === 'flights') { + // Looked up only for the plane the layer tracks. + const tracked = layer?.getTrackedSubject?.(); + if (tracked && text(tracked.id) === text(record?.icao24)) + photo = tracked.photo; + } + } catch { + photo = null; + } + if (!text(photo?.src)) return null; + return { + src: text(photo.src), + link: text(photo.link), + photographer: text(photo.photographer), + licence: text(photo.licence), + }; +} + export function describeEntity( dataManager, identity, @@ -1024,6 +1054,16 @@ export function describeEntity( warningWords: warnings.map((entry) => entry.words), // For the aircraft card's model and route line. aircraftClass, + // What picks the fleet model the globe draws this aircraft with. + aircraftModel: + kind.kind === 'aircraft' && record + ? { + typeCode: text(record.typeCode ?? record.type) || null, + category: record.category ?? null, + callsign: text(record.callsign) || null, + } + : null, + photo: cardPhoto(dataManager, layerId, record), // Its class's English name, for the UI to translate; null when unknown. aircraftClassName: AIRCRAFT_CLASS_LABELS[aircraftClass] || null, insights: diff --git a/src/data/entityContext.test.mjs b/src/data/entityContext.test.mjs index 8a04c7294..c18d76c39 100644 --- a/src/data/entityContext.test.mjs +++ b/src/data/entityContext.test.mjs @@ -37,8 +37,20 @@ const flights = Array.from({ length: 2500 }, (_, i) => ({ altitudeM: 10000, })); const dams = [ - { id: 'Grand Coulee Dam', name: 'Grand Coulee Dam', lat: 47.957, lon: -118.981, operator: 'Bureau of Reclamation' }, - { id: '123456', name: null, lat: 47.9, lon: -118.9, operator: 'Some Utility' }, + { + id: 'Grand Coulee Dam', + name: 'Grand Coulee Dam', + lat: 47.957, + lon: -118.981, + operator: 'Bureau of Reclamation', + }, + { + id: '123456', + name: null, + lat: 47.9, + lon: -118.9, + operator: 'Some Utility', + }, ]; const dm = manager({ flights: { name: 'Live Flights', records: flights }, @@ -46,7 +58,12 @@ const dm = manager({ }); test('a click identity finds its record by key, past the first 2000 records', () => { - const record = findRecord(dm, { layerId: 'flights', id: 'a02400', lat: 0, lon: 0 }); + const record = findRecord(dm, { + layerId: 'flights', + id: 'a02400', + lat: 0, + lon: 0, + }); assert.equal(record?.callsign, 'FLT2400'); }); @@ -74,7 +91,9 @@ test('a transit click finds its vehicle by the layer key and reads its state', ( lon: -97.71, }); assert.equal(card?.title, 'M634'); - const facts = Object.fromEntries(card.facts.map((fact) => [fact.label, fact.value])); + const facts = Object.fromEntries( + card.facts.map((fact) => [fact.label, fact.value]), + ); assert.equal(facts.Operator, 'CapMetro'); assert.equal(facts.Status, 'Heading to next stop'); assert.equal(facts.Key, undefined, 'the layer key is not shown'); @@ -86,8 +105,20 @@ test('transit vehicles break down by motion, mode and reported state', () => { transit: { name: 'Transit', records: [ - { id: '1', mode: 'bus', motion: 'moving', status: 'IN_TRANSIT_TO', ...at }, - { id: '2', mode: 'bus', motion: 'stopped', status: 'STOPPED_AT', ...at }, + { + id: '1', + mode: 'bus', + motion: 'moving', + status: 'IN_TRANSIT_TO', + ...at, + }, + { + id: '2', + mode: 'bus', + motion: 'stopped', + status: 'STOPPED_AT', + ...at, + }, { id: '3', mode: 'rail', motion: 'moving', occupancy: 'FULL', ...at }, ], }, @@ -95,15 +126,28 @@ test('transit vehicles break down by motion, mode and reported state', () => { const breakdown = layerBreakdown(buses, 'transit'); assert.equal(breakdown.total, 3); const split = (title) => - Object.fromEntries(breakdown.splits.find((item) => item.title === title).parts.map((part) => [part.label, part.count])); + Object.fromEntries( + breakdown.splits + .find((item) => item.title === title) + .parts.map((part) => [part.label, part.count]), + ); assert.deepEqual(split('Motion'), { Moving: 2, Stopped: 1 }); assert.deepEqual(split('Mode'), { Bus: 2, Rail: 1 }); - assert.deepEqual(split('Last reported'), { 'Heading to next stop': 1, 'Stopped at a stop': 1 }); + assert.deepEqual(split('Last reported'), { + 'Heading to next stop': 1, + 'Stopped at a stop': 1, + }); assert.deepEqual(split('Crowding'), { Full: 1 }); }); test('a moving item never borrows a nearby craft when its key is unknown', () => { - const record = findRecord(dm, { layerId: 'flights', id: 'zzzzzz', label: 'NOPE', lat: 34.0004, lon: -118.05 }); + const record = findRecord(dm, { + layerId: 'flights', + id: 'zzzzzz', + label: 'NOPE', + lat: 34.0004, + lon: -118.05, + }); assert.equal(record, null); }); @@ -115,12 +159,19 @@ test('a card lists facts with units and keeps the title out of them', () => { const card = describeEntity(dm, { layerId: 'flights', id: 'a00001' }); assert.equal(card.title, 'FLT1'); assert.equal(card.kind, 'aircraft'); - assert.ok(card.facts.some((fact) => fact.label === 'Altitude' && fact.value === '32,808 ft')); + assert.ok( + card.facts.some( + (fact) => fact.label === 'Altitude' && fact.value === '32,808 ft', + ), + ); assert.ok(!card.facts.some((fact) => fact.value === 'FLT1')); }); test('nearby lists the closest of the same kind and one of each other layer', () => { - const card = describeEntity(dm, { layerId: 'local-dams', id: 'Grand Coulee Dam' }); + const card = describeEntity(dm, { + layerId: 'local-dams', + id: 'Grand Coulee Dam', + }); const { same, other } = nearbyEntities(dm, card, { radiusKm: 2000 }); assert.equal(same[0].title, 'Some Utility'); assert.equal(other.length, 1); @@ -138,7 +189,10 @@ test('fact formatting follows the field suffix', () => { assert.equal(formatFact('speedMps', 100).value, '194 kt'); // Orbital speeds read in km/s, road and rail in km/h. assert.equal(formatFact('speedMps', 7670).value, '7.67 km/s'); - assert.equal(formatFact('speedMps', 10, { kind: 'vehicle' }).value, '36 km/h'); + assert.equal( + formatFact('speedMps', 10, { kind: 'vehicle' }).value, + '36 km/h', + ); // Units follow the field's suffix; feed codes and bare words read as words. assert.equal(formatFact('containedPct', 96).value, '96%'); assert.equal(formatFact('windKt', 30).value, '30 kt'); @@ -148,21 +202,54 @@ test('fact formatting follows the field suffix', () => { assert.equal(formatFact('icao24', 'abcdef').value, 'abcdef'); assert.equal(formatFact('shipType', 70).value, 'Cargo'); assert.equal(formatFact('shipType', 'Tanker').value, 'Tanker'); - assert.equal(formatFact('discoveredTime', Date.UTC(2026, 5, 29)).value, '29 Jun 2026'); - assert.equal(formatFact('updatedTime', 1_700_000_000_000, { nowMs: 1_700_000_060_000 }).age, 60_000); + assert.equal( + formatFact('discoveredTime', Date.UTC(2026, 5, 29)).value, + '29 Jun 2026', + ); + assert.equal( + formatFact('updatedTime', 1_700_000_000_000, { nowMs: 1_700_000_060_000 }) + .age, + 60_000, + ); assert.equal(formatFact('altitudeM', 420000).value, '420 km'); assert.equal(formatFact('confidence', 0.82).value, '82%'); assert.equal(formatFact('onGround', false), null); - assert.equal(formatFact('lastContactAtMs', 1_700_000_000_000, { nowMs: 1_700_000_060_000 }).age, 60_000); + assert.equal( + formatFact('lastContactAtMs', 1_700_000_000_000, { + nowMs: 1_700_000_060_000, + }).age, + 60_000, + ); }); test('warnings lead with an emergency, then the squawk code, and stay out of the facts', () => { - assert.deepEqual(recordWarnings({ emergency: true, emergencyKind: 'medical' }), ['Emergency: medical']); - assert.deepEqual(recordWarnings({ squawk: '7600' }), ['Radio failure (squawk 7600)']); - assert.deepEqual(recordWarnings({ squawk: '1200', emergencyKind: 'none' }), []); + assert.deepEqual( + recordWarnings({ emergency: true, emergencyKind: 'medical' }), + ['Emergency: medical'], + ); + assert.deepEqual(recordWarnings({ squawk: '7600' }), [ + 'Radio failure (squawk 7600)', + ]); + assert.deepEqual( + recordWarnings({ squawk: '1200', emergencyKind: 'none' }), + [], + ); assert.deepEqual(recordWarnings({ tsunami: 1 }), ['Tsunami warning issued']); const urgent = manager({ - flights: { name: 'Live Flights', records: [{ id: 'X1', icao24: 'x00001', callsign: 'X1', lat: 1, lon: 1, emergency: true, emergencyKind: 'fuel' }] }, + flights: { + name: 'Live Flights', + records: [ + { + id: 'X1', + icao24: 'x00001', + callsign: 'X1', + lat: 1, + lon: 1, + emergency: true, + emergencyKind: 'fuel', + }, + ], + }, }); const card = describeEntity(urgent, { layerId: 'flights', id: 'x00001' }); assert.deepEqual(card.warnings, ['Emergency: fuel']); @@ -184,7 +271,13 @@ test('the view summary counts each layer inside the view, closest to the middle test('flight insights work out phase, flight level, Mach, squawk meaning and signal age', () => { const insights = aircraftInsights( - { altitudeM: 10668, verticalRateMps: 0, speedMps: 230, squawk: '7000', lastContactAtMs: 1_000_000 }, + { + altitudeM: 10668, + verticalRateMps: 0, + speedMps: 230, + squawk: '7000', + lastContactAtMs: 1_000_000, + }, { nowMs: 1_012_000 }, ); const value = (label) => insights.find((item) => item.label === label)?.value; @@ -192,20 +285,57 @@ test('flight insights work out phase, flight level, Mach, squawk meaning and sig assert.equal(value('Flight level'), 'FL350'); assert.equal(value('Mach'), 'M 0.78'); assert.equal(value('Squawk {code}'), 'VFR conspicuity'); - assert.deepEqual(insights.find((item) => item.label === 'Squawk {code}').labelValues, { code: '7000' }); + assert.deepEqual( + insights.find((item) => item.label === 'Squawk {code}').labelValues, + { code: '7000' }, + ); assert.equal(value('Signal'), '12 s ago'); assert.equal(aircraftInsights({ onGround: true })[0].value, 'On the ground'); - assert.match(aircraftInsights({ verticalRateMps: -8 })[0].value, /^Descending 1600 ft\/min$/); + assert.match( + aircraftInsights({ verticalRateMps: -8 })[0].value, + /^Descending 1600 ft\/min$/, + ); }); test('a layer breakdown splits aircraft by status and type, inside a view when given', () => { const craft = [ - { id: 'A', lat: 10, lon: 10, onGround: false, military: false, aircraftClass: 'airliner' }, - { id: 'B', lat: 10, lon: 11, onGround: false, military: true, aircraftClass: 'fastjet' }, - { id: 'C', lat: 10, lon: 12, onGround: true, military: true, aircraftClass: 'airliner' }, - { id: 'D', lat: 60, lon: 12, onGround: false, military: false, aircraftClass: 'airliner' }, + { + id: 'A', + lat: 10, + lon: 10, + onGround: false, + military: false, + aircraftClass: 'airliner', + }, + { + id: 'B', + lat: 10, + lon: 11, + onGround: false, + military: true, + aircraftClass: 'fastjet', + }, + { + id: 'C', + lat: 10, + lon: 12, + onGround: true, + military: true, + aircraftClass: 'airliner', + }, + { + id: 'D', + lat: 60, + lon: 12, + onGround: false, + military: false, + aircraftClass: 'airliner', + }, ]; - const data = manager({ flights: { name: 'Live Flights', records: craft }, 'local-dams': { name: 'Dams', records: dams } }); + const data = manager({ + flights: { name: 'Live Flights', records: craft }, + 'local-dams': { name: 'Dams', records: dams }, + }); const all = layerBreakdown(data, 'flights'); assert.equal(all.total, 4); assert.deepEqual(all.splits[0].parts, [ @@ -217,23 +347,52 @@ test('a layer breakdown splits aircraft by status and type, inside a view when g { label: 'Airliners', count: 3 }, { label: 'Fast jets', count: 1 }, ]); - const near = layerBreakdown(data, 'flights', { rect: { west: 9, east: 13, south: 9, north: 11 } }); + const near = layerBreakdown(data, 'flights', { + rect: { west: 9, east: 13, south: 9, north: 11 }, + }); assert.equal(near.total, 3); assert.equal(layerBreakdown(data, 'local-dams'), null); }); test('a moving item with an unknown key is not matched to a craft right beside it', () => { // About 110 m from FLT0: well inside any nearest-item reach. - assert.equal(findRecord(dm, { layerId: 'flights', id: 'zzzzzz', label: 'NOPE', lat: 34.001, lon: -118 }), null); + assert.equal( + findRecord(dm, { + layerId: 'flights', + id: 'zzzzzz', + label: 'NOPE', + lat: 34.001, + lon: -118, + }), + null, + ); }); test('sites that share a key are told apart by where the identity says they are', () => { const sites = [ - { id: 'Amazon Web Services', name: 'Amazon Web Services', lat: -52.942, lon: -70.849 }, - { id: 'Amazon Web Services', name: 'Amazon Web Services', lat: -33.557, lon: -70.813 }, + { + id: 'Amazon Web Services', + name: 'Amazon Web Services', + lat: -52.942, + lon: -70.849, + }, + { + id: 'Amazon Web Services', + name: 'Amazon Web Services', + lat: -33.557, + lon: -70.813, + }, ]; - const data = manager({ 'local-datacenters': { name: 'Datacenters', records: sites } }); - const identity = { layerId: 'local-datacenters', id: 'Amazon Web Services', label: 'Amazon Web Services', lat: -33.557, lon: -70.813 }; + const data = manager({ + 'local-datacenters': { name: 'Datacenters', records: sites }, + }); + const identity = { + layerId: 'local-datacenters', + id: 'Amazon Web Services', + label: 'Amazon Web Services', + lat: -33.557, + lon: -70.813, + }; assert.equal(findRecord(data, identity), sites[1]); const card = describeEntity(data, identity); assert.equal(card.lat, -33.557); @@ -242,16 +401,106 @@ test('sites that share a key are told apart by where the identity says they are' }); test('a link is built only from a language code, and a level is not a warning', () => { - const site = { id: 'X', name: 'X', lat: 1, lon: 1, wikipedia: 'evil.example/a#:Y' }; + const site = { + id: 'X', + name: 'X', + lat: 1, + lon: 1, + wikipedia: 'evil.example/a#:Y', + }; const data = manager({ 'local-dams': { name: 'Dams', records: [site] } }); - assert.deepEqual(describeEntity(data, { layerId: 'local-dams', id: 'X', lat: 1, lon: 1 }).links, []); + assert.deepEqual( + describeEntity(data, { layerId: 'local-dams', id: 'X', lat: 1, lon: 1 }) + .links, + [], + ); assert.deepEqual(recordWarnings({ alert: 'green' }), []); }); test('a breakdown names "Other" once', () => { - const ships = [30, 30, 70, 70, 70, 80, 80, 60, 37, 52, 52, 90, 90, 90].map((shipType, i) => ({ id: `S${i}`, mmsi: String(i), lat: 1, lon: 1 + i * 0.01, shipType })); - const data = manager({ 'ais-live-vessels': { name: 'Vessels', records: ships } }); - const labels = layerBreakdown(data, 'ais-live-vessels').splits[0].parts.map((part) => part.label); + const ships = [30, 30, 70, 70, 70, 80, 80, 60, 37, 52, 52, 90, 90, 90].map( + (shipType, i) => ({ + id: `S${i}`, + mmsi: String(i), + lat: 1, + lon: 1 + i * 0.01, + shipType, + }), + ); + const data = manager({ + 'ais-live-vessels': { name: 'Vessels', records: ships }, + }); + const labels = layerBreakdown(data, 'ais-live-vessels').splits[0].parts.map( + (part) => part.label, + ); assert.equal(labels.filter((label) => label === 'Other').length <= 1, true); assert.equal(new Set(labels).size, labels.length); }); + +test('a card shows the photo its layer looked up: the tracked airliner, the selected vessel', () => { + const photo = { + src: 'https://cdn.example/p.jpg', + link: 'https://example/p', + photographer: 'A. Spotter', + width: 640, + }; + const planes = manager({ + flights: { + name: 'Live Flights', + records: [ + { + id: 'DAL1', + icao24: 'aa0001', + callsign: 'DAL1', + lat: 34, + lon: -118, + typeCode: 'B739', + category: 'A3', + }, + { id: 'DAL2', icao24: 'aa0002', callsign: 'DAL2', lat: 35, lon: -118 }, + ], + }, + 'ais-live-vessels': { + name: 'Vessels', + records: [ + { + id: 'EVER GIVEN', + vesselId: 'v1', + mmsi: '353136000', + lat: 30, + lon: 32, + }, + ], + }, + }); + planes.layers.get('flights').module.getTrackedSubject = () => ({ + id: 'aa0001', + photo, + }); + planes.layers.get('ais-live-vessels').module.getVesselPhoto = (id) => + id === 'v1' ? { ...photo, licence: 'CC BY 4.0' } : null; + + const tracked = describeEntity(planes, { layerId: 'flights', id: 'aa0001' }); + assert.deepEqual(tracked.photo, { + src: photo.src, + link: photo.link, + photographer: 'A. Spotter', + licence: '', + }); + // What picks the globe's fleet model for it. + assert.deepEqual(tracked.aircraftModel, { + typeCode: 'B739', + category: 'A3', + callsign: 'DAL1', + }); + // Photos are looked up for the tracked plane only. + assert.equal( + describeEntity(planes, { layerId: 'flights', id: 'aa0002' }).photo, + null, + ); + assert.equal( + describeEntity(planes, { layerId: 'ais-live-vessels', id: 'EVER GIVEN' }) + .photo.licence, + 'CC BY 4.0', + ); +}); diff --git a/src/data/fleetModels.js b/src/data/fleetModels.js index 69ab2a678..de0a894eb 100644 --- a/src/data/fleetModels.js +++ b/src/data/fleetModels.js @@ -538,6 +538,15 @@ export function fleetModelSet() { return loaded; } +/** + * The load a layer has started (resolving to the set), or null when none + * has: for a view that needs the set but does not fetch it itself. + * @returns {Promise|null} + */ +export function fleetModelSetLoading() { + return loading; +} + /** * Fetch the model set once for every layer: `catalog.json`, `types.json` and * every GLB the catalog names, all up front, so no model is fetched while a diff --git a/src/data/flights.test.mjs b/src/data/flights.test.mjs index 72fa1ea18..81e8e5f71 100644 --- a/src/data/flights.test.mjs +++ b/src/data/flights.test.mjs @@ -91,6 +91,8 @@ const FULL_INFO = { verticalRate: -4.5, onGround: false, klass: 'airliner', + typeCode: 'B738', + category: 'A3', originCountry: 'United States', airline: 'Southwest Airlines', route: { origin: { code: 'AUS' }, destination: { code: 'LAX' } }, @@ -114,6 +116,8 @@ test('flights analyst record: full record maps every contract field', () => { onGround: false, military: false, aircraftClass: 'airliner', + typeCode: 'B738', + category: 'A3', originCountry: 'United States', operator: 'Southwest Airlines', squawk: null, diff --git a/src/data/inputOwnership.test.mjs b/src/data/inputOwnership.test.mjs index aaa0cd8cd..c5c22fa82 100644 --- a/src/data/inputOwnership.test.mjs +++ b/src/data/inputOwnership.test.mjs @@ -167,8 +167,10 @@ test('pointer input, camera holds and the stock clicks go through the one dispat [ /\.enableInputs\s*=(?!=)/, 'writes enableInputs instead of suspendCamera()', - // The scene's camera-input holds, which own the flag. - ['src/render/cesium/cameraInput.js'], + // The scene's camera-input holds, which own the flag; the Context + // card's previews turn it off in their own small scenes, which take + // no input at all. + ['src/render/cesium/cameraInput.js', 'src/render/cesium/cardPreviews.js'], ], [ /(?:screenSpaceEventHandler|stockHandler)\??\.removeInputAction\(/, diff --git a/src/i18n/locales/ar.json b/src/i18n/locales/ar.json index d68e7fca7..d8c32ba3d 100644 --- a/src/i18n/locales/ar.json +++ b/src/i18n/locales/ar.json @@ -4458,5 +4458,14 @@ "{h} h {m} min": "{h} س {m} د", "{n} min": "{n} د", "{speed} {direction}": "{speed} {direction}", - "{n} mm": "{n} مم" + "{n} mm": "{n} مم", + "Scanning": "جارٍ المسح", + "Route": "المسار", + "3D model": "نموذج ثلاثي الأبعاد", + "3D": "3D", + "Cockpit view": "منظر قمرة القيادة", + "KT": "عقدة", + "Course to {code}: {course}": "المسار إلى {code}: {course}", + "Over {place}": "فوق {place}", + "Below": "في الأسفل" } diff --git a/src/i18n/locales/de.json b/src/i18n/locales/de.json index d0bb1928a..4e80ebba3 100644 --- a/src/i18n/locales/de.json +++ b/src/i18n/locales/de.json @@ -4086,5 +4086,14 @@ "{h} h {m} min": "{h} Std. {m} Min.", "{n} min": "{n} Min.", "{speed} {direction}": "{speed} aus {direction}", - "{n} mm": "{n} mm" + "{n} mm": "{n} mm", + "Scanning": "Scan läuft", + "Route": "Route", + "3D model": "3D-Modell", + "3D": "3D", + "Cockpit view": "Cockpitsicht", + "KT": "KT", + "Course to {code}: {course}": "Kurs nach {code}: {course}", + "Over {place}": "Über {place}", + "Below": "Darunter" } diff --git a/src/i18n/locales/es.json b/src/i18n/locales/es.json index 1c9d0bf59..cd59e6f97 100644 --- a/src/i18n/locales/es.json +++ b/src/i18n/locales/es.json @@ -4179,5 +4179,14 @@ "{h} h {m} min": "{h} h {m} min", "{n} min": "{n} min", "{speed} {direction}": "{speed} del {direction}", - "{n} mm": "{n} mm" + "{n} mm": "{n} mm", + "Scanning": "Escaneando", + "Route": "Ruta", + "3D model": "Modelo 3D", + "3D": "3D", + "Cockpit view": "Vista de cabina", + "KT": "KT", + "Course to {code}: {course}": "Rumbo a {code}: {course}", + "Over {place}": "Sobre {place}", + "Below": "Debajo" } diff --git a/src/i18n/locales/fr.json b/src/i18n/locales/fr.json index cdea54c25..ecbb2eb63 100644 --- a/src/i18n/locales/fr.json +++ b/src/i18n/locales/fr.json @@ -4179,5 +4179,14 @@ "{h} h {m} min": "{h} h {m} min", "{n} min": "{n} min", "{speed} {direction}": "{speed} de {direction}", - "{n} mm": "{n} mm" + "{n} mm": "{n} mm", + "Scanning": "Balayage", + "Route": "Itinéraire", + "3D model": "Modèle 3D", + "3D": "3D", + "Cockpit view": "Vue cockpit", + "KT": "KT", + "Course to {code}: {course}": "Cap vers {code} : {course}", + "Over {place}": "Au-dessus de {place}", + "Below": "En dessous" } diff --git a/src/i18n/locales/he.json b/src/i18n/locales/he.json index b8f2e2457..55ec11684 100644 --- a/src/i18n/locales/he.json +++ b/src/i18n/locales/he.json @@ -4179,5 +4179,14 @@ "{h} h {m} min": "{h} שע׳ {m} דק׳", "{n} min": "{n} דק׳", "{speed} {direction}": "{speed} מ־{direction}", - "{n} mm": "{n} מ״מ" + "{n} mm": "{n} מ״מ", + "Scanning": "סורק", + "Route": "מסלול", + "3D model": "דגם תלת־ממדי", + "3D": "3D", + "Cockpit view": "מבט מתא הטייס", + "KT": "KT", + "Course to {code}: {course}": "כיוון אל {code}: {course}", + "Over {place}": "מעל {place}", + "Below": "מתחת" } diff --git a/src/i18n/locales/it.json b/src/i18n/locales/it.json index 8cf511043..5f7f14787 100644 --- a/src/i18n/locales/it.json +++ b/src/i18n/locales/it.json @@ -4179,5 +4179,14 @@ "{h} h {m} min": "{h} h {m} min", "{n} min": "{n} min", "{speed} {direction}": "{speed} da {direction}", - "{n} mm": "{n} mm" + "{n} mm": "{n} mm", + "Scanning": "Scansione", + "Route": "Rotta", + "3D model": "Modello 3D", + "3D": "3D", + "Cockpit view": "Vista dalla cabina", + "KT": "KT", + "Course to {code}: {course}": "Rotta verso {code}: {course}", + "Over {place}": "Sopra {place}", + "Below": "Sotto" } diff --git a/src/i18n/locales/ja.json b/src/i18n/locales/ja.json index e21c8b56e..1ad167a3e 100644 --- a/src/i18n/locales/ja.json +++ b/src/i18n/locales/ja.json @@ -3993,5 +3993,14 @@ "{h} h {m} min": "{h}時間{m}分", "{n} min": "{n}分", "{speed} {direction}": "{direction}の風 {speed}", - "{n} mm": "{n} mm" + "{n} mm": "{n} mm", + "Scanning": "スキャン中", + "Route": "ルート", + "3D model": "3Dモデル", + "3D": "3D", + "Cockpit view": "コックピット視点", + "KT": "KT", + "Course to {code}: {course}": "{code}への針路: {course}", + "Over {place}": "{place}上空", + "Below": "直下" } diff --git a/src/i18n/locales/pt.json b/src/i18n/locales/pt.json index 1251650c6..9701b55ee 100644 --- a/src/i18n/locales/pt.json +++ b/src/i18n/locales/pt.json @@ -4179,5 +4179,14 @@ "{h} h {m} min": "{h} h {m} min", "{n} min": "{n} min", "{speed} {direction}": "{speed} de {direction}", - "{n} mm": "{n} mm" + "{n} mm": "{n} mm", + "Scanning": "Escaneando", + "Route": "Rota", + "3D model": "Modelo 3D", + "3D": "3D", + "Cockpit view": "Vista da cabine", + "KT": "KT", + "Course to {code}: {course}": "Rumo para {code}: {course}", + "Over {place}": "Sobre {place}", + "Below": "Abaixo" } diff --git a/src/i18n/locales/ru.json b/src/i18n/locales/ru.json index 320d079d2..64fbd8153 100644 --- a/src/i18n/locales/ru.json +++ b/src/i18n/locales/ru.json @@ -4272,5 +4272,14 @@ "{h} h {m} min": "{h} ч {m} мин", "{n} min": "{n} мин", "{speed} {direction}": "{speed}, {direction}", - "{n} mm": "{n} мм" + "{n} mm": "{n} мм", + "Scanning": "Сканирование", + "Route": "Маршрут", + "3D model": "3D-модель", + "3D": "3D", + "Cockpit view": "Вид из кабины", + "KT": "УЗ", + "Course to {code}: {course}": "Курс на {code}: {course}", + "Over {place}": "Над: {place}", + "Below": "Под спутником" } diff --git a/src/i18n/locales/sv.json b/src/i18n/locales/sv.json index e8039e6d4..a1c9c13e6 100644 --- a/src/i18n/locales/sv.json +++ b/src/i18n/locales/sv.json @@ -4086,5 +4086,14 @@ "{h} h {m} min": "{h} h {m} min", "{n} min": "{n} min", "{speed} {direction}": "{speed} från {direction}", - "{n} mm": "{n} mm" + "{n} mm": "{n} mm", + "Scanning": "Skannar", + "Route": "Rutt", + "3D model": "3D-modell", + "3D": "3D", + "Cockpit view": "Cockpitvy", + "KT": "KT", + "Course to {code}: {course}": "Kurs mot {code}: {course}", + "Over {place}": "Över {place}", + "Below": "Nedanför" } diff --git a/src/i18n/locales/uk.json b/src/i18n/locales/uk.json index f33f4a999..fe0a0dd20 100644 --- a/src/i18n/locales/uk.json +++ b/src/i18n/locales/uk.json @@ -4272,5 +4272,14 @@ "{h} h {m} min": "{h} год {m} хв", "{n} min": "{n} хв", "{speed} {direction}": "{speed}, {direction}", - "{n} mm": "{n} мм" + "{n} mm": "{n} мм", + "Scanning": "Сканування", + "Route": "Маршрут", + "3D model": "3D-модель", + "3D": "3D", + "Cockpit view": "Вигляд з кабіни", + "KT": "ВУЗ", + "Course to {code}: {course}": "Курс на {code}: {course}", + "Over {place}": "Над: {place}", + "Below": "Під супутником" } diff --git a/src/i18n/locales/zh-CN.json b/src/i18n/locales/zh-CN.json index 7a638025b..9ff0de98b 100644 --- a/src/i18n/locales/zh-CN.json +++ b/src/i18n/locales/zh-CN.json @@ -3993,5 +3993,14 @@ "{h} h {m} min": "{h} 小时 {m} 分钟", "{n} min": "{n} 分钟", "{speed} {direction}": "{direction}风 {speed}", - "{n} mm": "{n} 毫米" + "{n} mm": "{n} 毫米", + "Scanning": "扫描中", + "Route": "航线", + "3D model": "3D 模型", + "3D": "3D", + "Cockpit view": "驾驶舱视角", + "KT": "kt", + "Course to {code}: {course}": "前往 {code} 的航向:{course}", + "Over {place}": "{place}上空", + "Below": "下方" } diff --git a/src/i18n/locales/zh-Hant.json b/src/i18n/locales/zh-Hant.json index 837243f94..af2b1f963 100644 --- a/src/i18n/locales/zh-Hant.json +++ b/src/i18n/locales/zh-Hant.json @@ -3993,5 +3993,14 @@ "{h} h {m} min": "{h} 小時 {m} 分鐘", "{n} min": "{n} 分鐘", "{speed} {direction}": "{direction}風 {speed}", - "{n} mm": "{n} 毫米" + "{n} mm": "{n} 毫米", + "Scanning": "掃描中", + "Route": "航線", + "3D model": "3D 模型", + "3D": "3D", + "Cockpit view": "駕駛艙視角", + "KT": "kt", + "Course to {code}: {course}": "前往 {code} 的航向:{course}", + "Over {place}": "{place}上空", + "Below": "下方" } diff --git a/src/i18n/same-as-english.json b/src/i18n/same-as-english.json index fc856def9..43872f806 100644 --- a/src/i18n/same-as-english.json +++ b/src/i18n/same-as-english.json @@ -55,7 +55,8 @@ "{n}%", "{n} hPa", "{kind} {name}", - "{speed} {direction}" + "{speed} {direction}", + "3D" ], "de": [ "1090 MHz", @@ -292,7 +293,10 @@ "{n} hPa", "Turboprops", "{kind} {name}", - "{n} mm" + "{n} mm", + "Route", + "3D", + "KT" ], "es": [ "1 min/s", @@ -484,7 +488,9 @@ "{kind} {name}", "{h} h {m} min", "{n} min", - "{n} mm" + "{n} mm", + "3D", + "KT" ], "fr": [ "1 min/s", @@ -740,7 +746,9 @@ "{kind} {name}", "{h} h {m} min", "{n} min", - "{n} mm" + "{n} mm", + "3D", + "KT" ], "it": [ "1 min/s", @@ -972,7 +980,9 @@ "{kind} {name}", "{h} h {m} min", "{n} min", - "{n} mm" + "{n} mm", + "3D", + "KT" ], "ja": [ "1090 MHz", @@ -1054,7 +1064,9 @@ "{n} MW", "{n}%", "{n} hPa", - "{n} mm" + "{n} mm", + "3D", + "KT" ], "pt": [ "1 min/s", @@ -1246,7 +1258,9 @@ "{kind} {name}", "{h} h {m} min", "{n} min", - "{n} mm" + "{n} mm", + "3D", + "KT" ], "ru": [ "1900–1945", @@ -1290,7 +1304,8 @@ "{n}°", "M {n}", "{n}%", - "{kind} {name}" + "{kind} {name}", + "3D" ], "sv": [ "STATION", @@ -1481,7 +1496,9 @@ "{kind} {name}", "{h} h {m} min", "{n} min", - "{n} mm" + "{n} mm", + "3D", + "KT" ], "uk": [ "1900–1945", @@ -1519,7 +1536,8 @@ "{n}°", "M {n}", "{n}%", - "{kind} {name}" + "{kind} {name}", + "3D" ], "zh-CN": [ "1090 MHz", @@ -1603,7 +1621,8 @@ "M {n}", "{n} MW", "{n}%", - "{n} hPa" + "{n} hPa", + "3D" ], "zh-Hant": [ "1090 MHz", @@ -1687,7 +1706,8 @@ "M {n}", "{n} MW", "{n}%", - "{n} hPa" + "{n} hPa", + "3D" ], "he": [ "{speed} kn", @@ -1802,6 +1822,8 @@ "{n} MW", "{n}%", "{n} hPa", - "{kind} {name}" + "{kind} {name}", + "3D", + "KT" ] } diff --git a/src/layers/flights/queries.js b/src/layers/flights/queries.js index 3e3074f95..365af11db 100644 --- a/src/layers/flights/queries.js +++ b/src/layers/flights/queries.js @@ -288,6 +288,9 @@ export function createQueries({ // A converted contact reports the class it RENDERS as, so an analyst // filter/superlative agrees with the triangle on screen. aircraftClass: tr3bAircraftClass(icao24, text(info?.klass)), + // What picks its fleet model, for the context card's turning model. + typeCode: text(info?.typeCode), + category: info?.category ?? null, originCountry: text(info?.originCountry), operator: text(info?.airline), squawk: text(info?.squawk), diff --git a/src/maps/attribution.js b/src/maps/attribution.js index 71f5a201e..38fa50eed 100644 --- a/src/maps/attribution.js +++ b/src/maps/attribution.js @@ -1,8 +1,15 @@ /** * @module maps/attribution - * @description The on-map credits of the map stacks' sources. + * @description The on-map credits of the map stacks' sources, and Esri + * World Imagery's tile address, which the globe and the card previews share. */ // Attribution and service rights are documented in DATA_SOURCES.md. +/** Esri World Imagery's tiles; Stories' card images draw from the same. */ +export const ESRI_TILES = + 'https://services.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer/tile/{z}/{y}/{x}'; +/** Esri World Imagery's credit line, as plain text. */ +export const ESRI_IMAGERY_CREDIT = + 'Powered by Esri — Source: Esri, Maxar, Earthstar Geographics, and the GIS User Community'; export const ESRI_ATTRIBUTION_HTML = 'Powered by Esri'; diff --git a/src/maps/globeEngine.js b/src/maps/globeEngine.js index a2088973e..76bad33ef 100644 --- a/src/maps/globeEngine.js +++ b/src/maps/globeEngine.js @@ -13,13 +13,9 @@ * photoreal base is turned off through the port and on again when shown. */ import { findFrame, findGlobe, rendererOf } from '../render/rendererOf.js'; +import { ESRI_IMAGERY_CREDIT, ESRI_TILES } from './attribution.js'; import { KEYLESS_TERRAIN_URL } from './keylessTerrain.js'; -/** Esri World Imagery's tiles; Stories' card images draw from the same. */ -export const ESRI_TILES = - 'https://services.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer/tile/{z}/{y}/{x}'; -const ESRI_CREDIT = - 'Powered by Esri — Source: Esri, Maxar, Earthstar Geographics, and the GIS User Community'; const OSM_TILES = 'https://tile.openstreetmap.org/{z}/{x}/{y}.png'; const OSM_CREDIT = '© OpenStreetMap contributors'; /** Cesium ion's world imagery assets (`MAP_STACKS`' `style`). */ @@ -136,7 +132,7 @@ export const globeMapEngine = Object.freeze({ url: ESRI_TILES, tiling: 'webMercator', maxLevel: 19, - credit: credit(ESRI_CREDIT), + credit: credit(ESRI_IMAGERY_CREDIT), }), ion(style, accessToken) { if (!String(accessToken || '').trim()) diff --git a/src/render/applicationHooks.js b/src/render/applicationHooks.js index 7f0cf0e73..c989d4801 100644 --- a/src/render/applicationHooks.js +++ b/src/render/applicationHooks.js @@ -20,6 +20,11 @@ * - `renderFailureNotice({allowReload, store})`: a recoverable notice, * published to `store`, when the renderer stops drawing * (`src/render/cesium/renderFailure.js`); returns its removal. + * - `cardPreviews`: the Context card's previews of a picked aircraft (its + * model turning, its route on a small globe, the view from its cockpit), + * each drawn into an element the card gives it + * (`src/render/cesium/cardPreviews.js`); without it the card shows its + * photo and figures only. * * A plugin hands them as its `applicationHooks(renderer)` * (`ApplicationHooks`, `contract/renderer.d.ts`); the application scene diff --git a/src/render/cesium/appRenderer.js b/src/render/cesium/appRenderer.js index 49cb009f4..94dfc8afc 100644 --- a/src/render/cesium/appRenderer.js +++ b/src/render/cesium/appRenderer.js @@ -37,6 +37,7 @@ import { configureCreditKeyboardAccess } from './creditKeyboard.js'; import { onLocaleChange } from '../../i18n/index.js'; import { cesiumViewerOf, recordViewer } from './viewers.js'; import { installRenderFailureNotice } from './renderFailure.js'; +import { cesiumCardPreviews } from './cardPreviews.js'; export { cesiumViewerOf }; @@ -226,6 +227,9 @@ export function createCesiumRendererPlugin({ // (renderFailure.js). renderFailureNotice: (options) => installRenderFailureNotice(viewer, options), + // The Context card's previews, each in a small scene of its own + // (cardPreviews.js). + cardPreviews: cesiumCardPreviews, }; }, }); diff --git a/src/render/cesium/cardPreviews.js b/src/render/cesium/cardPreviews.js new file mode 100644 index 000000000..ae2cdcd51 --- /dev/null +++ b/src/render/cesium/cardPreviews.js @@ -0,0 +1,753 @@ +/** + * @module render/cesium/cardPreviews + * @description The Context card's previews on the Cesium renderer: an + * aircraft's model turning on its own, its route on a small globe, and the + * view ahead from its cockpit. Each draws in a small Cesium scene of its own + * inside the element it is given, and is torn down with the card. The + * application reaches them through the `cardPreviews` application hook + * (`render/applicationHooks.js`); the card's words, figures and HUD stay + * the application's. + * + * Every preview is `{setActive(active), update(values), destroy()}`: a + * hidden one stops drawing and rests on its last frame, and shown again it + * draws once straight away so there is no gap. A preview that cannot be + * made calls its `onFailed`. + */ +import * as Cesium from 'cesium'; +import { webglContext } from './internals.js'; +import { createEsriImagery } from './mapImagery.js'; + +/** + * Destroy a preview's widget and free its WebGL context. A browser keeps + * only a handful of contexts open and drops the oldest, the main globe's, + * when there are too many; a destroyed widget's context is otherwise freed + * only when garbage is collected, so flicking through cards could push the + * globe's out. + * @param {Cesium.CesiumWidget|null} widget + */ +function destroyWidget(widget) { + if (!widget || widget.isDestroyed()) return; + let gl = null; + try { + gl = webglContext(widget.scene) ?? 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. + } +} + +/** A small widget with no input, credits or render-loop error panel. */ +function createWidget(container, options) { + const widget = new Cesium.CesiumWidget(container, { + skyBox: false, + scene3DOnly: true, + shadows: false, + showRenderLoopErrors: false, + // The globe's own credits already show; a preview's go in its corner. + creditContainer: document.createElement('div'), + ...options, + }); + widget.scene.screenSpaceCameraController.enableInputs = false; + return widget; +} + +/** + * Stops a hidden widget's render loop once `ready()` says it has something + * to rest on; shown again, it draws once at once. + */ +function renderLoopSwitch(widget, ready = () => true) { + let active = true; + const sync = () => { + if (widget.isDestroyed()) return; + const run = active || !ready(); + if (run && !widget.useDefaultRenderLoop) { + widget.resize(); + widget.render(); + } + widget.useDefaultRenderLoop = run; + }; + return { + sync, + set(next) { + active = Boolean(next); + sync(); + }, + }; +} + +const reducedMotion = () => + globalThis.matchMedia?.('(prefers-reduced-motion: reduce)')?.matches === true; + +// ── The turning model ────────────────────────────────────────────────── + +/** 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; +/** How fast the model turns, in radians a millisecond (about 0.3 a second). */ +const TURN_PER_MS = 0.0003; + +// 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; +}`; + +/** + * An aircraft's model turning slowly, with no globe, sky or imagery. Its + * look changes as it turns: a whole rotation as it is, then a short + * wireframe scan (under a third of a turn), then round again; each change is + * a reveal, a bright ring growing from the craft's centre to its edges. One + * custom shader does it, driven by a uniform, because a shader set on a + * model after it is ready does nothing in this Cesium. Under reduced motion + * there is no scan. + * + * `onPhase('plain'|'scan')` says when the look changes; `onCycle(ms)` when a + * look and its scan end, with the drawing time they took, so the card can + * give another view the same time. + * @param {HTMLElement} container + * @param {{gltf: Uint8Array|ArrayBuffer, basePath?: string, heading?: number, + * viewRange?: number}} model The GLB's bytes; the heading (degrees) it + * starts facing; how far the camera stands, in bounding radii. + * @param {{onPhase?: (phase: string) => void, onCycle?: (ms: number) => void, + * onFailed?: () => void}} [events] + */ +function modelPreview( + container, + { gltf, basePath, heading = 0, viewRange = 1.9 }, + { onPhase = () => {}, onCycle = () => {}, onFailed = () => {} } = {}, +) { + let widget = null; + let model = null; + let loaded = false; + let removeTick = null; + let loop = null; + const fail = () => { + if (!widget) return; + onFailed(); + }; + try { + widget = createWidget(container, { + globe: false, + skyAtmosphere: false, + baseLayer: false, + contextOptions: { webgl: { alpha: true, antialias: true } }, + }); + const { scene } = widget; + 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, + }); + loop = renderLoopSwitch(widget, () => loaded); + } catch { + onFailed(); + return { setActive() {}, update() {}, destroy() {} }; + } + + const shader = new Cesium.CustomShader({ + uniforms: { + u_reveal: { type: Cesium.UniformType.FLOAT, value: 0 }, + u_half: { type: Cesium.UniformType.FLOAT, value: 20 }, + }, + fragmentShaderText: LOOK_SHADER, + }); + const origin = Cesium.Cartesian3.fromDegrees(0, 0, 0); + + const start = (sphere) => { + // The craft reaches about 0.6 of its bounding radius from the centre. + shader.setUniform('u_half', sphere.radius * 0.6); + const first = Cesium.Math.toRadians(heading + 140); + let turn = first; + let phase = 'plain'; + let cycleMs = 0; + let lastFrame = performance.now(); + let holdMs = null; + const still = reducedMotion(); + const range = sphere.radius * viewRange; + const pitch = Cesium.Math.toRadians(-18); + const ease = (x) => x * x * (3 - 2 * x); + const frame = () => { + // Only time spent drawing counts: a hidden preview stops drawing. + const now = performance.now(); + const drawn = now - lastFrame < 250 ? now - lastFrame : 0; + lastFrame = now; + // A steady turn whatever the display's refresh rate; still under + // reduced motion. + if (!still) turn += TURN_PER_MS * drawn; + const turns = (turn - first) / (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; + 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'; + cycleMs += drawn; + // 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 === 'scan' && next === 'plain') holdMs = 0; + if (holdMs !== null && next === 'plain') { + holdMs += drawn; + if (holdMs >= HOLD_MS) { + onCycle(cycleMs); + cycleMs = 0; + holdMs = null; + } + } + if (next !== phase) { + phase = next; + onPhase(phase); + } + shader.setUniform('u_reveal', reveal); + widget.camera.lookAt( + sphere.center, + new Cesium.HeadingPitchRange(turn, pitch, range), + ); + }; + frame(); + removeTick = widget.scene.preRender.addEventListener(frame); + widget.render(); + loaded = true; + loop.sync(); + }; + + Cesium.Model.fromGltfAsync({ + gltf, + basePath, + customShader: shader, + modelMatrix: Cesium.Transforms.eastNorthUpToFixedFrame(origin), + // A light rim so the mesh reads against the dark card. + silhouetteColor: Cesium.Color.WHITE.withAlpha(0.3), + silhouetteSize: 1, + }).then((made) => { + if (!widget) { + made.destroy(); + return; + } + model = widget.scene.primitives.add(made); + model.readyEvent.addEventListener(() => { + if (widget) start(model.boundingSphere); + }); + model.errorEvent?.addEventListener?.(fail); + }, fail); + + function move(atNow) { + const at = onRoute(from, to, atNow); + if (!widget || !at || !plane || flyingIn) return; + pose(plane, at); + if (flownLine) flownLine.polyline.positions = arc(from, at, 48); + if (aheadLine) aheadLine.polyline.positions = arc(at, to); + widget.scene.requestRender(); + } + + return { + setActive: (active) => loop.set(active), + update() {}, + destroy() { + removeTick?.(); + removeTick = null; + const gone = widget; + widget = null; + model = null; + destroyWidget(gone); + }, + }; +} + +// ── The route globe ──────────────────────────────────────────────────── + +const CYAN = Cesium.Color.fromCssColorString('#36dcff'); +const AMBER = Cesium.Color.fromCssColorString('#ffb86b'); +/** Height (m) the route and the plane are drawn at, clear of the globe. */ +const ROUTE_HEIGHT_M = 30_000; + +// 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( + '' + + '' + + '' + + '' + + '', +)}`; + +/** + * An airport's code as an image, white with a dark outline, at the page's + * pixel ratio. The preview is a small scene of its own, so its two codes are + * drawn into it rather than on the world overlay, which belongs to the globe. + * @param {string} code + * @returns {{image: HTMLCanvasElement, width: number, height: number}} + * the image and its size on screen, CSS pixels + */ +function codeImage(code) { + const ratio = Math.min(3, Math.max(1, globalThis.devicePixelRatio || 1)); + const font = `600 ${11 * ratio}px ui-monospace, monospace`; + const canvas = document.createElement('canvas'); + const context = canvas.getContext('2d'); + context.font = font; + const pad = 3 * ratio; + canvas.width = Math.ceil(context.measureText(code).width + pad * 2); + canvas.height = Math.ceil(15 * ratio); + context.font = font; + context.textBaseline = 'middle'; + context.lineJoin = 'round'; + context.lineWidth = 3 * ratio; + context.strokeStyle = '#000'; + context.fillStyle = '#fff'; + context.strokeText(code, pad, canvas.height / 2); + context.fillText(code, pad, canvas.height / 2); + return { + image: canvas, + width: canvas.width / ratio, + height: canvas.height / ratio, + }; +} + +/** 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); + return (Math.atan2(y, x) / rad + 360) % 360; +} + +const geodesic = (a, b) => + new Cesium.EllipsoidGeodesic( + Cesium.Cartographic.fromDegrees(a.lon, a.lat), + Cesium.Cartographic.fromDegrees(b.lon, b.lat), + ); + +/** Points along the great circle from a to b, as far as `upTo` (0 to 1). */ +function arc(a, b, steps = 64, upTo = 1) { + const line = geodesic(a, b); + const out = []; + const n = Math.max(2, Math.round(steps * upTo)); + for (let i = 0; i <= n; i++) { + const c = line.interpolateUsingFraction((i / n) * upTo); + out.push( + Cesium.Cartesian3.fromRadians(c.longitude, c.latitude, ROUTE_HEIGHT_M), + ); + } + return out; +} + +/** + * The point on the great circle from `from` to `to` 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(from, to, at) { + if (!at || !Number.isFinite(at.lat) || !Number.isFinite(at.lon)) return null; + const route = geodesic(from, to); + const here = Cesium.Cartesian3.fromDegrees(at.lon, at.lat); + const point = new Cesium.Cartesian3(); + let best = null; + let bestDistance = Infinity; + const STEPS = 200; + for (let i = 0; i <= STEPS; i++) { + const c = route.interpolateUsingFraction(i / STEPS); + Cesium.Cartesian3.fromRadians( + c.longitude, + c.latitude, + 0, + Cesium.Ellipsoid.WGS84, + point, + ); + const d = Cesium.Cartesian3.distanceSquared(here, point); + if (d < bestDistance) { + bestDistance = d; + best = { + lat: Cesium.Math.toDegrees(c.latitude), + lon: Cesium.Math.toDegrees(c.longitude), + }; + } + } + return best; +} + +/** + * The plane's billboard pose, nose along `deg` from north: the icon's up is + * tied to the local north 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, + ROUTE_HEIGHT_M, + ); + 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), + }; +} + +/** + * A flight's route on a small globe: 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 where the craft is now, pointing at + * the destination. 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. + * @param {HTMLElement} container + * @param {{from: {code?: string, lat: number, lon: number}, + * to: {code?: string, lat: number, lon: number}, + * at?: {lat: number, lon: number}|null}} route + * @param {{onFailed?: () => void}} [events] + */ +function routePreview(container, route, { onFailed = () => {} } = {}) { + let widget = null; + let loop = null; + let { from, to } = route; + let plane = null; + let flownLine = null; + let aheadLine = null; + let removeGrow = null; + /** True while the plane flies in from the origin; moves wait for it. */ + let flyingIn = false; + /** The craft's latest position, kept through the fly-in and the load. */ + let latest = route.at; + + const pose = (entity, where) => { + const next = planePose(where, bearing(where, to)); + entity.position = next.position; + entity.billboard.rotation = next.rotation; + entity.billboard.alignedAxis = next.alignedAxis; + }; + + const draw = (atNow) => { + if (!widget) return; + const at = onRoute(from, to, atNow); + const { entities, scene } = widget; + removeGrow?.(); + removeGrow = null; + entities.removeAll(); + plane = flownLine = null; + 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, + }, + ...(place.code + ? { + billboard: { + ...codeImage(place.code), + verticalOrigin: Cesium.VerticalOrigin.BOTTOM, + pixelOffset: new Cesium.Cartesian2(0, -6), + }, + } + : {}), + }); + 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 plane starts at the origin and flies out along the flown line + // as it draws, arriving where the craft is now. + const first = planePose(from, bearing(from, to)); + plane = entities.add({ + position: first.position, + billboard: { + image: PLANE_ICON, + width: 26, + height: 26, + rotation: first.rotation, + alignedAxis: first.alignedAxis, + }, + }); + const leg = geodesic(from, at); + const ease = (x) => 1 - (1 - x) ** 3; + // 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. Under reduced motion it is there at once. + let began = reducedMotion() ? -Infinity : null; + const opened = performance.now(); + flyingIn = true; + const grow = () => { + if (began === null) { + if (!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); + pose(plane, { + lat: Cesium.Math.toDegrees(c.latitude), + lon: Cesium.Math.toDegrees(c.longitude), + }); + if (raw >= 1) { + flyingIn = false; + flown.polyline.positions = arc(from, at, 48); + removeGrow?.(); + removeGrow = null; + // The craft may have moved on while the plane flew in. + move(latest); + } + }; + removeGrow = 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); + const center = + Cesium.Ellipsoid.WGS84.scaleToGeodeticSurface(sphere.center) || + sphere.center; + widget.camera.lookAt( + center, + new Cesium.HeadingPitchRange(0, Cesium.Math.toRadians(-62), range), + ); + scene.requestRender(); + }; + + try { + widget = createWidget(container, { + baseLayer: false, + skyAtmosphere: false, + contextOptions: { webgl: { alpha: true, antialias: true } }, + }); + const { scene } = widget; + scene.backgroundColor = Cesium.Color.TRANSPARENT; + scene.globe.baseColor = Cesium.Color.fromCssColorString('#0b1820'); + scene.globe.showGroundAtmosphere = false; + scene.globe.enableLighting = false; + loop = renderLoopSwitch(widget); + } catch { + onFailed(); + return { setActive() {}, update() {}, destroy() {} }; + } + Cesium.TileMapServiceImageryProvider.fromUrl( + Cesium.buildModuleUrl('Assets/Textures/NaturalEarthII'), + ).then( + (imagery) => { + if (!widget) return; + const layer = widget.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(latest); + }, + () => widget && onFailed(), + ); + + function move(atNow) { + const at = onRoute(from, to, atNow); + if (!widget || !at || !plane || flyingIn) return; + pose(plane, at); + if (flownLine) flownLine.polyline.positions = arc(from, at, 48); + if (aheadLine) aheadLine.polyline.positions = arc(at, to); + widget.scene.requestRender(); + } + + return { + setActive: (active) => loop.set(active), + /** + * A new route redraws; the craft moving along it only moves its plane + * and the two lines, without replaying the opening draw. + */ + update(next) { + if (!widget) return; + latest = next.at; + if (next.from?.code !== from.code || next.to?.code !== to.code) { + ({ from, to } = next); + draw(latest); + return; + } + move(latest); + }, + destroy() { + removeGrow?.(); + removeGrow = null; + const gone = widget; + widget = null; + destroyWidget(gone); + }, + }; +} + +// ── The cockpit view ─────────────────────────────────────────────────── + +/** A floor for the eye, so a landed or taxiing craft is not underground. */ +const MIN_EYE_M = 60; + +/** + * 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 draws + * only when asked: a still, moved along with the craft while it shows. + * @param {HTMLElement} container + * @param {{lat: number, lon: number, altitudeM?: number|null, + * heading?: number|null}} craft + * @param {{onFailed?: () => void}} [events] + */ +function cockpitPreview(container, craft, { onFailed = () => {} } = {}) { + let widget = null; + let loop = null; + let active = false; + let at = craft; + const place = () => { + if (!widget || !Number.isFinite(at?.lat) || !Number.isFinite(at?.lon)) + return; + const height = Math.max( + MIN_EYE_M, + Number.isFinite(at.altitudeM) ? at.altitudeM : 0, + ); + widget.camera.setView({ + destination: Cesium.Cartesian3.fromDegrees(at.lon, at.lat, height), + orientation: { + heading: Cesium.Math.toRadians( + Number.isFinite(at.heading) ? at.heading : 0, + ), + pitch: Cesium.Math.toRadians(-9), + roll: 0, + }, + }); + widget.scene.requestRender(); + }; + try { + widget = createWidget(container, { + baseLayer: false, + requestRenderMode: true, + maximumRenderTimeChange: Infinity, + contextOptions: { webgl: { alpha: false, antialias: true } }, + }); + const { scene } = widget; + 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(); + // Hidden, it draws nothing at all, not even as tiles arrive. + loop = renderLoopSwitch(widget); + loop.set(active); + } catch { + onFailed(); + return { setActive() {}, update() {}, destroy() {} }; + } + createEsriImagery().then( + (imagery) => { + if (!widget) return; + widget.scene.imageryLayers.addImageryProvider(imagery); + widget.scene.requestRender(); + }, + () => widget && onFailed(), + ); + return { + setActive(next) { + active = Boolean(next); + if (!widget) return; + loop.set(active); + if (active) place(); + }, + /** While it shows, the view keeps up with the craft. */ + update(next) { + at = next; + if (active) place(); + }, + destroy() { + const gone = widget; + widget = null; + destroyWidget(gone); + }, + }; +} + +/** + * The card previews, as the `cardPreviews` application hook hands them. + * @type {Readonly<{model: typeof modelPreview, route: typeof routePreview, + * cockpit: typeof cockpitPreview}>} + */ +export const cesiumCardPreviews = Object.freeze({ + model: modelPreview, + route: routePreview, + cockpit: cockpitPreview, +}); diff --git a/src/render/cesium/mapImagery.js b/src/render/cesium/mapImagery.js index bd07a4ea4..217606b09 100644 --- a/src/render/cesium/mapImagery.js +++ b/src/render/cesium/mapImagery.js @@ -4,6 +4,7 @@ * World Imagery and Cesium ion's world imagery (Bing over HTTPS). */ import * as Cesium from 'cesium'; +import { ESRI_IMAGERY_CREDIT } from '../../maps/attribution.js'; export { ESRI_ATTRIBUTION_HTML } from '../../maps/attribution.js'; @@ -18,8 +19,7 @@ export function createEsriImagery() { return Cesium.ArcGisMapServerImageryProvider.fromUrl( 'https://services.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer', { - credit: - 'Powered by Esri — Source: Esri, Maxar, Earthstar Geographics, and the GIS User Community', + credit: ESRI_IMAGERY_CREDIT, enablePickFeatures: false, }, ); diff --git a/src/render/contract/renderer.d.ts b/src/render/contract/renderer.d.ts index a8ce9f499..5d8da3c44 100644 --- a/src/render/contract/renderer.d.ts +++ b/src/render/contract/renderer.d.ts @@ -67,6 +67,75 @@ export interface ApplicationHooks { allowReload: boolean; store: RenderFailureStore; }): () => void; + /** The Context card's previews of a picked aircraft. */ + cardPreviews?: CardPreviews; +} + +/** + * Previews the Context card draws into an element of its own. Each returns + * at once; one that cannot be made calls its `onFailed`. + */ +export interface CardPreviews { + /** + * A model turning on its own, from its GLB's bytes, starting to face + * `heading` (degrees); `viewRange` is the camera's distance in bounding + * radii. `onPhase` says when it turns to wire for its scan and back; + * `onCycle` when a look and its scan end, with the drawing time they took. + */ + model( + container: HTMLElement, + model: { + gltf: Uint8Array | ArrayBuffer; + basePath?: string; + heading?: number; + viewRange?: number; + }, + events?: { + onPhase?(phase: 'plain' | 'scan'): void; + onCycle?(ms: number): void; + onFailed?(): void; + }, + ): CardPreview; + /** A flight's route from `from` to `to` on a small globe, the craft `at`. */ + route( + container: HTMLElement, + route: CardRoute, + events?: { onFailed?(): void }, + ): CardPreview; + /** The view ahead from an aircraft's position, height and heading. */ + cockpit( + container: HTMLElement, + craft: CardCraft, + events?: { onFailed?(): void }, + ): CardPreview; +} + +/** A place on a card's route: an airport's code and position, degrees. */ +export interface CardPlace { + code?: string; + lat: number; + lon: number; +} + +export interface CardRoute { + from: CardPlace; + to: CardPlace; + at?: { lat: number; lon: number } | null; +} + +/** An aircraft's position (degrees), height (metres) and heading (degrees). */ +export interface CardCraft { + lat: number; + lon: number; + altitudeM?: number | null; + heading?: number | null; +} + +/** One preview: hidden, it rests on its last frame. */ +export interface CardPreview { + setActive(active: boolean): void; + update(values: Values): void; + destroy(): void; } /** Where a renderer's failure notice is published for the application to show. */ diff --git a/src/stories/thumbs.js b/src/stories/thumbs.js index a024c4989..5c79fe3d7 100644 --- a/src/stories/thumbs.js +++ b/src/stories/thumbs.js @@ -4,7 +4,7 @@ * the same tiles, from the same host, that GEV's Esri map draws (and credits * on screen); no other host is asked. */ -import { ESRI_TILES } from '../maps/globeEngine.js'; +import { ESRI_TILES } from '../maps/attribution.js'; const WIDTH = 320; const HEIGHT = 180; diff --git a/src/ui/entityContextBridge.js b/src/ui/entityContextBridge.js index 6bfa6b24f..eea7e72c2 100644 --- a/src/ui/entityContextBridge.js +++ b/src/ui/entityContextBridge.js @@ -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, diff --git a/src/ui/stores/entityCard.js b/src/ui/stores/entityCard.js index fa8a148ec..611065ac2 100644 --- a/src/ui/stores/entityCard.js +++ b/src/ui/stores/entityCard.js @@ -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, diff --git a/src/ui/styles/entity-card.css b/src/ui/styles/entity-card.css index 2f8f09840..640c0670f 100644 --- a/src/ui/styles/entity-card.css +++ b/src/ui/styles/entity-card.css @@ -1768,3 +1768,1085 @@ .view-context__live { margin: 0.6rem 0 0.7rem; } + +/* ── Card previews: the photo, route globe, turning model, cockpit view and + satellite ground view in the hero tile ─────────────────────────────── */ + +.aircraft-hero { + position: relative; + height: 150px; + margin: 0.55rem -0.25rem 0.2rem; + overflow: hidden; + background: + radial-gradient( + ellipse 60% 55% at 50% 58%, + rgba(54, 220, 255, 0.14), + transparent 70% + ), + linear-gradient(180deg, rgba(255, 255, 255, 0.025), rgba(255, 255, 255, 0)); + border-radius: 8px; +} + +.aircraft-hero__scene, +.aircraft-hero__scene .cesium-widget, +.aircraft-hero__scene canvas { + width: 100% !important; + height: 100% !important; +} + +.aircraft-hero__scene canvas { + display: block; +} +.aircraft-hero__callout { + position: absolute; + top: 8px; + left: 10px; + z-index: 1; + display: grid; + gap: 1px; + max-width: 62%; + pointer-events: none; +} + +.aircraft-hero__label, +.aircraft-hero__value { + opacity: 0; + animation: aircraft-hero-text 700ms ease-out 200ms forwards; +} + +.aircraft-hero__value { + animation-delay: 1650ms; +} + +.aircraft-hero__label { + color: rgba(54, 220, 255, 0.75); + font-family: var(--font-mono); + font-size: 0.5rem; + letter-spacing: 0.1rem; + text-transform: uppercase; +} + +.aircraft-hero__value { + overflow: hidden; + color: #e8fbff; + font-family: var(--font-mono); + font-size: 0.74rem; + font-weight: 600; + text-overflow: ellipsis; + white-space: nowrap; + text-shadow: 0 1px 2px rgba(0, 0, 0, 0.6); +} + +.aircraft-hero-callout-leave-active { + transition: + opacity 600ms ease-in, + filter 600ms ease-in; +} + +.aircraft-hero-callout-leave-to { + opacity: 0; + filter: blur(2px); +} + +@keyframes aircraft-hero-draw { + to { + stroke-dashoffset: 0; + } +} + +@keyframes aircraft-hero-dot { + from { + opacity: 0; + transform: scale(0); + } + to { + opacity: 1; + transform: scale(1); + } +} + +@keyframes aircraft-hero-text { + from { + opacity: 0; + transform: translateX(-4px); + } + to { + opacity: 1; + transform: none; + } +} + +@media (prefers-reduced-motion: reduce) { + .aircraft-hero__label, + .aircraft-hero__value { + animation: none; + opacity: 1; + stroke-dashoffset: 0; + } + .aircraft-hero-callout-leave-active { + transition: none; + } +} +.aircraft-hero__scan { + position: absolute; + right: 10px; + bottom: 8px; + z-index: 1; + margin: 0; + pointer-events: none; +} + +.aircraft-hero__scan { + color: #36dcff; + font-family: var(--font-mono); + font-size: 0.52rem; + letter-spacing: 0.14rem; + text-transform: uppercase; + animation: aircraft-hero-blink 1.1s steps(1, end) infinite; +} + +@keyframes aircraft-hero-blink { + 50% { + opacity: 0.35; + } +} + +.aircraft-hero-legend-enter-active, +.aircraft-hero-legend-leave-active { + transition: opacity 500ms ease; +} + +.aircraft-hero-legend-enter-from, +.aircraft-hero-legend-leave-to { + opacity: 0; +} +#entity-card .aircraft-hero { + height: 168px; + margin: 0.55rem 0 0.6rem; + border-top: 1px solid rgba(255, 255, 255, 0.05); + border-bottom: 1px solid rgba(255, 255, 255, 0.05); + border-radius: 0; +} +.aircraft-hero__label { + display: flex; + align-items: baseline; + gap: 0.45rem; +} + +.aircraft-hero__label em { + color: rgba(199, 214, 222, 0.4); + font-style: normal; + letter-spacing: 0.04rem; +} + +.aircraft-hero__timer { + display: block; + width: 100%; + height: 1px; + margin-top: 4px; + background: + linear-gradient(90deg, rgba(54, 220, 255, 0.7), rgba(54, 220, 255, 0.7)) + left / 0 100% no-repeat, + rgba(255, 255, 255, 0.08); + opacity: 0; + animation: + aircraft-hero-text 300ms ease-out 2000ms forwards, + aircraft-hero-timer 2900ms linear 2300ms forwards; +} + +.aircraft-hero__label, +.aircraft-hero__value { + animation-name: aircraft-hero-slide; +} +.aircraft-hero-callout-leave-active .aircraft-hero__label, +.aircraft-hero-callout-leave-active .aircraft-hero__value, +.aircraft-hero-callout-leave-active .aircraft-hero__timer { + opacity: 1; + animation: aircraft-hero-fade-out 350ms ease-in forwards; +} + +.aircraft-hero-callout-leave-active .aircraft-hero__timer { + background-size: + 100% 100%, + auto; +} + +.aircraft-hero-callout-leave-active, +.aircraft-hero-callout-leave-to { + transition: none; + opacity: 1; + filter: none; +} + +@keyframes aircraft-hero-slide { + from { + opacity: 0; + transform: translateX(-6px); + } + to { + opacity: 1; + transform: none; + } +} + +@keyframes aircraft-hero-timer { + to { + background-size: + 100% 100%, + auto; + } +} + +@keyframes aircraft-hero-breathe { + 50% { + opacity: 0.45; + } +} + +@keyframes aircraft-hero-fade-out { + to { + opacity: 0; + transform: translateX(-4px); + } +} + +@keyframes aircraft-hero-retract { + from { + stroke-dashoffset: 0; + } + to { + stroke-dashoffset: 1; + } +} + +@keyframes aircraft-hero-dot-out { + to { + opacity: 0; + transform: scale(0); + } +} + +@media (prefers-reduced-motion: reduce) { + .aircraft-hero__timer, + .aircraft-hero-callout-leave-active .aircraft-hero__label, + .aircraft-hero-callout-leave-active .aircraft-hero__value { + animation: none; + } + .aircraft-hero__timer { + opacity: 1; + } +} +.route-globe { + position: relative; + height: 168px; + margin: 0.35rem 0 0.6rem; + overflow: hidden; + background: radial-gradient( + ellipse 55% 60% at 50% 55%, + rgba(54, 220, 255, 0.1), + transparent 70% + ); + border-top: 1px solid rgba(255, 255, 255, 0.05); + border-bottom: 1px solid rgba(255, 255, 255, 0.05); +} + +.route-globe__scene, +.route-globe__scene .cesium-widget, +.route-globe__scene canvas { + width: 100% !important; + height: 100% !important; +} + +.route-globe__codes { + position: absolute; + top: 8px; + left: 10px; + display: flex; + gap: 0.4rem; + align-items: baseline; + color: rgba(199, 214, 222, 0.6); + font-family: var(--font-mono); + font-size: 0.62rem; + pointer-events: none; +} + +.route-globe__codes strong { + color: #e8fbff; + font-size: 0.8rem; +} + +.entity-card__preview-switch { + display: inline-flex; + gap: 2px; + margin-top: 0.55rem; + padding: 2px; + background: rgba(255, 255, 255, 0.04); + border: 1px solid rgba(255, 255, 255, 0.07); + border-radius: 7px; +} + +.entity-card__preview-switch button { + padding: 0.22rem 0.6rem; + color: rgba(199, 214, 222, 0.65); + font-size: 0.6rem; + letter-spacing: 0.06rem; + text-transform: uppercase; + background: none; + border: 0; + border-radius: 5px; + cursor: pointer; +} + +.entity-card__preview-switch button.active { + color: #36dcff; + background: rgba(54, 220, 255, 0.12); +} +.route-globe__codes { + align-items: flex-start; + gap: 0.5rem; + padding: 0.3rem 0.5rem 0.35rem; + background: rgba(6, 12, 16, 0.62); + border: 1px solid rgba(255, 255, 255, 0.06); + border-radius: 6px; + backdrop-filter: blur(6px); + -webkit-backdrop-filter: blur(6px); +} + +.route-globe__end { + display: grid; + gap: 1px; +} + +.route-globe__end small { + max-width: 7.5rem; + overflow: hidden; + color: rgba(199, 214, 222, 0.7); + font-family: var(--font-sans, inherit); + font-size: 0.56rem; + text-overflow: ellipsis; + white-space: nowrap; +} + +.route-globe__arrow { + padding-top: 0.05rem; + color: rgba(54, 220, 255, 0.8); +} +.route-globe__compass { + position: absolute; + top: 8px; + right: 8px; + display: grid; + justify-items: center; + gap: 2px; + pointer-events: auto; +} + +.route-globe__compass svg { + width: 46px; + height: 46px; + overflow: visible; + filter: drop-shadow(0 1px 3px rgba(0, 0, 0, 0.6)); +} + +.route-globe__compass-ring { + fill: rgba(6, 12, 16, 0.6); + stroke: rgba(199, 214, 222, 0.35); + stroke-width: 1; +} + +.route-globe__compass-ticks line { + stroke: rgba(199, 214, 222, 0.55); + stroke-width: 1; +} + +.route-globe__compass-n { + fill: #ff6b5e; + font: 700 7px var(--font-mono); + text-anchor: middle; +} + +.route-globe__compass-needle path { + fill: #36dcff; + filter: drop-shadow(0 0 2px rgba(54, 220, 255, 0.8)); +} + +.route-globe__compass-needle { + transition: transform 600ms ease; +} + +.route-globe__compass-hub { + fill: #e8fbff; +} + +.route-globe__compass span { + padding: 0 0.3rem; + color: rgba(225, 236, 242, 0.85); + font-family: var(--font-mono); + font-size: 0.52rem; + background: rgba(6, 12, 16, 0.6); + border-radius: 3px; +} + +.entity-hero:is([data-hero='flight'], [data-hero='satellite'], [data-hero='photo']) { + height: 168px; + background: radial-gradient( + ellipse 55% 60% at 50% 55%, + rgba(54, 220, 255, 0.1), + rgba(255, 255, 255, 0.02) 70% + ); + border: 1px solid rgba(255, 255, 255, 0.07); +} +.entity-hero .entity-hero__layer { + position: absolute; + inset: 0; + height: auto; + margin: 0; + border: 0; + border-radius: 0; + visibility: hidden; +} + +.entity-hero .entity-hero__layer.is-shown { + visibility: visible; +} + +.entity-hero__photo img { + display: block; + width: 100%; + height: 100%; + object-fit: cover; +} + +.entity-hero__photo small { + position: absolute; + inset-block-start: 6px; + inset-inline-end: 6px; + max-width: calc(100% - 12px); + padding: 2px 5px; + border-radius: 4px; + background: rgba(10, 14, 20, 0.86); + color: #fff; + font-size: 0.6875rem; + line-height: 1.2; + overflow-wrap: anywhere; +} + +.entity-hero__photo:focus-visible { + outline: 2px solid currentColor; + outline-offset: -2px; +} + +.entity-hero .entity-card__preview-switch { + position: absolute; + z-index: 2; + bottom: 6px; + left: 6px; + margin: 0; + background: rgba(10, 14, 20, 0.78); + border-color: rgba(255, 255, 255, 0.12); + backdrop-filter: blur(8px); + -webkit-backdrop-filter: blur(8px); +} +.satellite-ground { + overflow: hidden; + background: #05080b; +} + +.satellite-ground__map { + position: absolute; + top: 50%; + left: 50%; + width: 0; + height: 0; + filter: grayscale(1) brightness(0.78) contrast(1.2); + transform-origin: 0 0; +} + +.satellite-ground__map.is-drifting { + animation: satellite-ground-drift 9s ease-out both; +} + +@keyframes satellite-ground-drift { + from { + transform: scale(1.18); + } + to { + transform: scale(1); + } +} + +.satellite-ground__tile { + position: absolute; + top: 0; + left: 0; + width: 256px; + height: 256px; + max-width: none; + user-select: none; +} + +.satellite-ground__rings { + position: absolute; + top: 50%; + left: 50%; + width: 150px; + height: 150px; + overflow: visible; + transform: translate(-50%, -50%); + pointer-events: none; +} + +.satellite-ground__ring { + fill: none; + stroke: rgba(150, 236, 220, 0.85); + vector-effect: non-scaling-stroke; +} + +.satellite-ground__ring--inner { + fill: rgba(150, 236, 220, 0.06); + stroke-width: 1.5; + animation: satellite-ground-pulse 2.4s ease-in-out infinite; +} + +.satellite-ground__ring--middle, +.satellite-ground__ring--outer { + stroke: rgba(150, 236, 220, 0.5); + stroke-dasharray: 1 4; + stroke-linecap: round; + stroke-width: 1.5; + transform-origin: 0 0; + animation: satellite-ground-turn 40s linear infinite; +} + +.satellite-ground__ring--outer { + stroke: rgba(150, 236, 220, 0.3); + animation-direction: reverse; +} + +@keyframes satellite-ground-pulse { + 50% { + stroke: rgba(150, 236, 220, 0.5); + } +} + +@keyframes satellite-ground-turn { + to { + transform: rotate(360deg); + } +} + +.satellite-ground__label { + position: absolute; + top: 8px; + left: 10px; + display: grid; + gap: 1px; + color: rgba(54, 220, 255, 0.75); + font-family: var(--font-mono); + font-size: 0.5rem; + letter-spacing: 0.1rem; + text-transform: uppercase; +} + +.satellite-ground__label strong { + color: #e8fbff; + font-size: 0.74rem; + font-weight: 600; + letter-spacing: 0.04rem; + text-shadow: 0 1px 2px rgba(0, 0, 0, 0.6); +} + +.satellite-ground__credit { + position: absolute; + right: 8px; + bottom: 5px; + color: rgba(225, 236, 242, 0.5); + font-size: 0.48rem; +} + +@media (prefers-reduced-motion: reduce) { + .satellite-ground__map.is-drifting, + .satellite-ground__ring { + animation: none; + } +} +.preview-hud { + position: absolute; + inset: 0; + z-index: 1; + pointer-events: none; + --hud-line: rgba(200, 236, 248, 0.55); + --hud-dim: rgba(200, 236, 248, 0.22); +} + +.preview-hud__corner { + position: absolute; + width: 10px; + height: 10px; + border: 0 solid var(--hud-line); + animation: preview-hud-breathe 3.2s ease-in-out infinite; +} + +.preview-hud__corner--tl { + top: 5px; + left: 5px; + border-top-width: 1px; + border-left-width: 1px; +} +.preview-hud__corner--tr { + top: 5px; + right: 5px; + border-top-width: 1px; + border-right-width: 1px; +} +.preview-hud__corner--bl { + bottom: 5px; + left: 5px; + border-bottom-width: 1px; + border-left-width: 1px; +} +.preview-hud__corner--br { + right: 5px; + bottom: 5px; + border-right-width: 1px; + border-bottom-width: 1px; + animation-delay: 1.6s; +} +.preview-hud__ruler { + position: absolute; + top: 34%; + right: 9px; + width: 5px; + height: 40%; + background: repeating-linear-gradient( + to bottom, + var(--hud-dim) 0 1px, + transparent 1px 6px + ); +} + +.preview-hud__ruler i { + position: absolute; + right: -3px; + width: 8px; + height: 1px; + background: #e8fbff; + box-shadow: 0 0 4px rgba(200, 236, 248, 0.8); + animation: preview-hud-ride 5.5s ease-in-out infinite alternate; +} +.preview-hud__scale { + position: absolute; + bottom: 9px; + left: 12px; + width: 38%; + height: 4px; + background: + repeating-linear-gradient( + to right, + var(--hud-dim) 0 1px, + transparent 1px 5px + ), + repeating-linear-gradient( + to right, + var(--hud-line) 0 1px, + transparent 1px 25px + ); + background-size: + 100% 3px, + 100% 4px; + background-repeat: repeat-x; + background-position: + 0 bottom, + 0 bottom; + mask-image: linear-gradient( + to right, + transparent, + #000 20%, + #000 80%, + transparent + ); + animation: preview-hud-crawl 6s linear infinite; +} +.preview-hud__meter { + position: absolute; + top: 9px; + right: 12px; + display: flex; + align-items: flex-end; + gap: 2px; + height: 9px; +} + +.preview-hud__meter i { + width: 2px; + height: 100%; + background: var(--hud-line); + transform-origin: bottom; + animation: preview-hud-level 1.4s ease-in-out infinite; +} + +.preview-hud__meter i:nth-child(2) { + animation-delay: 0.2s; +} +.preview-hud__meter i:nth-child(3) { + animation-delay: 0.45s; +} +.preview-hud__meter i:nth-child(4) { + animation-delay: 0.7s; +} + +.preview-hud__meter b { + width: 4px; + height: 4px; + margin: 0 0 3px 4px; + border-radius: 50%; + background: #ff5a5a; + animation: preview-hud-blink 1.2s steps(1, end) infinite; +} +.preview-hud__ring { + position: absolute; + top: 50%; + left: 50%; + width: 132px; + height: 132px; + overflow: visible; + transform: translate(-50%, -50%); +} + +.preview-hud__dash { + fill: none; + stroke: var(--hud-dim); + stroke-dasharray: 2 6; + stroke-width: 1; + vector-effect: non-scaling-stroke; + transform-origin: 0 0; + animation: preview-hud-turn 30s linear infinite; +} + +.preview-hud__ticks { + stroke: var(--hud-line); + stroke-width: 1; + vector-effect: non-scaling-stroke; +} + +.preview-hud--ground .preview-hud__ring { + display: none; +} +.preview-hud__sweep { + position: absolute; + right: 0; + left: 0; + height: 22px; + background: linear-gradient( + to bottom, + transparent, + rgba(150, 236, 220, 0.08) 80%, + rgba(150, 236, 220, 0.5) 100% + ); + animation: preview-hud-sweep 4.5s linear infinite; +} + +@keyframes preview-hud-breathe { + 50% { + opacity: 0.45; + } +} +@keyframes preview-hud-ride { + from { + top: 8%; + } + to { + top: 88%; + } +} +@keyframes preview-hud-crawl { + to { + background-position: + -25px bottom, + -25px bottom; + } +} +@keyframes preview-hud-level { + 0%, + 100% { + transform: scaleY(0.35); + } + 50% { + transform: scaleY(1); + } +} +@keyframes preview-hud-blink { + 50% { + opacity: 0.15; + } +} +@keyframes preview-hud-turn { + to { + transform: rotate(360deg); + } +} +@keyframes preview-hud-sweep { + from { + top: -22px; + } + to { + top: 100%; + } +} + +@media (prefers-reduced-motion: reduce) { + .preview-hud *, + .preview-hud__dash { + animation: none !important; + } + + .preview-hud__sweep { + display: none; + } +} +.preview-hud__grid { + position: absolute; + border: 1px solid rgba(200, 236, 248, 0.14); + background: + repeating-linear-gradient( + to right, + rgba(200, 236, 248, 0.14) 0 1px, + transparent 1px 22px + ), + repeating-linear-gradient( + to bottom, + rgba(200, 236, 248, 0.14) 0 1px, + transparent 1px 22px + ); +} + +.preview-hud__cell { + position: absolute; + top: 0; + left: 0; + width: 23px; + height: 23px; + border: 1px solid rgba(150, 236, 220, 0.85); + background: rgba(150, 236, 220, 0.16); + box-shadow: 0 0 6px rgba(150, 236, 220, 0.35); + transition: opacity 160ms linear; +} +.preview-hud--ground { + opacity: 0.4; +} + +.preview-hud--ground .preview-hud__grid { + opacity: 0.6; +} + +.preview-hud--ground .preview-hud__cell { + border-color: rgba(150, 236, 220, 0.5); + background: rgba(150, 236, 220, 0.08); + box-shadow: none; +} + +.satellite-ground__rings { + opacity: 0.45; +} +.flight-cockpit { + overflow: hidden; + background: #05080b; +} + +.flight-cockpit__scene, +.flight-cockpit__scene .cesium-widget, +.flight-cockpit__scene canvas { + position: absolute; + inset: 0; + width: 100%; + height: 100%; +} +.flight-cockpit__horizon { + position: absolute; + top: 50%; + left: 50%; + width: 46px; + height: 1px; + transform: translate(-50%, -50%); + background: linear-gradient( + to right, + rgba(232, 251, 255, 0.7) 0 16px, + transparent 16px 30px, + rgba(232, 251, 255, 0.7) 30px + ); +} + +.flight-cockpit__horizon i { + position: absolute; + top: 50%; + left: 50%; + width: 10px; + height: 10px; + border: 1px solid rgba(232, 251, 255, 0.75); + border-radius: 50%; + transform: translate(-50%, -50%); +} + +.flight-cockpit__label { + position: absolute; + top: 8px; + left: 10px; + z-index: 2; + display: grid; + gap: 1px; + color: rgba(54, 220, 255, 0.85); + font-family: var(--font-mono); + font-size: 0.5rem; + letter-spacing: 0.1rem; + text-transform: uppercase; + text-shadow: 0 1px 2px rgba(0, 0, 0, 0.7); +} + +.flight-cockpit__label strong { + color: #e8fbff; + font-size: 0.74rem; + font-weight: 600; + letter-spacing: 0.04rem; +} + +.flight-cockpit__credit { + position: absolute; + right: 8px; + bottom: 5px; + z-index: 2; + color: rgba(225, 236, 242, 0.6); + font-size: 0.48rem; + text-shadow: 0 1px 2px rgba(0, 0, 0, 0.7); +} +.preview-hud--cockpit { + opacity: 0.45; +} + +.preview-hud--cockpit .preview-hud__ring { + display: none; +} +.flight-cockpit__tape { + position: absolute; + top: 50%; + z-index: 2; + display: grid; + justify-items: center; + width: 44px; + height: 92px; + transform: translateY(-50%); + pointer-events: none; +} + +.flight-cockpit__tape--speed { + left: 12px; +} + +.flight-cockpit__tape--alt { + right: 12px; + width: 52px; +} + +.flight-cockpit__ticks { + position: absolute; + inset: 0; + background-image: repeating-linear-gradient( + to bottom, + rgba(232, 251, 255, 0.55) 0 1px, + transparent 1px 8px + ); + background-size: 9px 100%; + background-repeat: repeat-y; + mask-image: linear-gradient( + to bottom, + transparent, + #000 25%, + #000 75%, + transparent + ); + transition: background-position-y 1.2s linear; + animation: flight-cockpit-jitter 2.6s ease-in-out infinite; +} + +.flight-cockpit__tape--speed .flight-cockpit__ticks { + background-position-x: right; + border-right: 1px solid rgba(232, 251, 255, 0.35); +} + +.flight-cockpit__tape--alt .flight-cockpit__ticks { + border-left: 1px solid rgba(232, 251, 255, 0.35); +} + +.flight-cockpit__tape b { + position: relative; + align-self: center; + grid-row: 1; + grid-column: 1; + min-width: 34px; + padding: 1px 4px; + border: 1px solid rgba(232, 251, 255, 0.8); + background: rgba(5, 8, 11, 0.7); + color: #e8fbff; + font-family: var(--font-mono); + font-size: 0.6rem; + font-weight: 600; + text-align: center; + font-variant-numeric: tabular-nums; +} + +.flight-cockpit__tape em { + position: absolute; + bottom: -12px; + color: rgba(54, 220, 255, 0.85); + font-family: var(--font-mono); + font-size: 0.45rem; + font-style: normal; + letter-spacing: 0.1rem; +} + +@keyframes flight-cockpit-jitter { + 50% { + transform: translateY(2px); + } +} + +.preview-hud--cockpit .preview-hud__ruler { + display: none; +} + +@media (prefers-reduced-motion: reduce) { + .flight-cockpit__ticks { + animation: none; + transition: none; + } +} +.entity-card__preview-switch button { + display: grid; + place-items: center; + width: 26px; + height: 22px; + padding: 0; +} + +.entity-card__preview-switch button .material-symbols-outlined { + font-size: 15px; +} + +.entity-card__preview-switch button:not(:has(.material-symbols-outlined)) { + width: auto; + padding: 0 0.5rem; + font-family: var(--font-mono); + font-size: 0.62rem; + font-weight: 600; +} +.satellite-ground__credit, +.flight-cockpit__credit { + left: 8px; + max-width: none; + line-height: 1.25; + text-align: right; +} +.satellite-ground__credit, +.flight-cockpit__credit { + left: auto; + max-width: calc(100% - 110px); +} diff --git a/src/ui/views/panels/AircraftModelHero.vue b/src/ui/views/panels/AircraftModelHero.vue new file mode 100644 index 000000000..3f14313d8 --- /dev/null +++ b/src/ui/views/panels/AircraftModelHero.vue @@ -0,0 +1,130 @@ + + + diff --git a/src/ui/views/panels/AltitudeGraph.vue b/src/ui/views/panels/AltitudeGraph.vue index bf2719b79..ca9c29ba0 100644 --- a/src/ui/views/panels/AltitudeGraph.vue +++ b/src/ui/views/panels/AltitudeGraph.vue @@ -2,7 +2,8 @@ import { computed, ref, watch } from 'vue'; import { formatNumber, t } from '../../../i18n/index.js'; -// A height as a filled graph (an aircraft's altitude, the camera's height): +// A figure as a filled graph (an aircraft's altitude, the camera's height, a +// satellite's altitude and speed): // each reading since it opened, left to right. The scale fits the readings (never less than about // 2,000 ft tall), so a climb or descent shows as a slope, and the fill // fades from the line down to the baseline. @@ -13,7 +14,11 @@ const props = defineProps({ tick: { type: Number, default: 0 }, /** The caption; 'Altitude' when not given. */ label: { type: String, default: '' }, - /** 'feet' for aircraft; 'metric' reads in metres and kilometres. */ + /** + * 'feet' for aircraft; 'metric' reads in metres and kilometres on a log + * scale (the camera); 'km' is a height in kilometres and 'km/s' a speed + * (given in m/s), both on a straight scale (a satellite). + */ unit: { type: String, default: 'feet' }, /** Only the caption, the current figure and the line: no scale or change. */ compact: { type: Boolean, default: false }, @@ -43,7 +48,14 @@ const metric = (m) => : m >= 1000 ? t('{n} km', { n: formatNumber(m / 1000, { minimumFractionDigits: 1, maximumFractionDigits: 1 }) }) : t('{n} m', { n: number(Math.round(m)) }); -const shown = (m) => (props.unit === 'metric' ? metric(m) : t('{n} ft', { n: number(feet(m)) })); +const SHOW = { + metric, + km: (m) => t('{n} km', { n: number(Math.round(m / 100) / 10) }), + 'km/s': (m) => t('{n} km/s', { n: formatNumber(m / 1000, { minimumFractionDigits: 2, maximumFractionDigits: 2 }) }), +}; +const shown = (m) => (SHOW[props.unit] || ((value) => t('{n} ft', { n: number(feet(value)) })))(m); +/** The least each scale spans, so a steady figure still reads as a line. */ +const LEAST = { feet: MIN_RANGE_M, km: 2000, 'km/s': 20 }; const graph = computed(() => { const list = readings.value; @@ -60,7 +72,7 @@ const graph = computed(() => { const low = Math.min(...heights); // The least the scale spans: about 2,000 ft for aircraft, half a decade // for the camera. - const least = log ? 0.5 : MIN_RANGE_M; + const least = log ? 0.5 : LEAST[props.unit] || MIN_RANGE_M; const pad = Math.max((least - (high - low)) / 2, (high - low) * 0.15); const bottom = Math.max(0, low - pad); const top = Math.max(high + pad, bottom + least); @@ -71,8 +83,9 @@ const graph = computed(() => { const points = list.length > 1 ? list.map((item) => [x(item.at), y(item.m)]) : [[0, y(first.m)], [WIDTH, y(first.m)]]; const line = points.map(([px, py], index) => `${index ? 'L' : 'M'}${px.toFixed(2)} ${py.toFixed(2)}`).join(' '); const moved = last.m - first.m; - const change = props.unit === 'metric' ? (Math.abs(moved) >= Math.max(1, last.m * 0.005) ? moved : 0) : feet(last.m) - feet(first.m); - const changeText = props.unit === 'metric' ? metric(Math.abs(moved)) : t('{n} ft', { n: number(Math.abs(change)) }); + const feetScale = !SHOW[props.unit]; + const change = feetScale ? feet(last.m) - feet(first.m) : Math.abs(moved) >= Math.max(1, last.m * (props.unit === 'metric' ? 0.005 : 0.0005)) ? moved : 0; + const changeText = feetScale ? t('{n} ft', { n: number(Math.abs(change)) }) : shown(Math.abs(moved)); const minutes = Math.floor((last.at - first.at) / 60_000); return { line, diff --git a/src/ui/views/panels/EntityCard.vue b/src/ui/views/panels/EntityCard.vue index 9c05adbbd..3ca7087c2 100644 --- a/src/ui/views/panels/EntityCard.vue +++ b/src/ui/views/panels/EntityCard.vue @@ -1,10 +1,14 @@ + + diff --git a/src/ui/views/panels/PreviewHud.vue b/src/ui/views/panels/PreviewHud.vue new file mode 100644 index 000000000..4ff0599e1 --- /dev/null +++ b/src/ui/views/panels/PreviewHud.vue @@ -0,0 +1,93 @@ + + + diff --git a/src/ui/views/panels/RouteGlobe.vue b/src/ui/views/panels/RouteGlobe.vue new file mode 100644 index 000000000..0f45c792c --- /dev/null +++ b/src/ui/views/panels/RouteGlobe.vue @@ -0,0 +1,97 @@ + + + diff --git a/src/ui/views/panels/SatelliteGroundView.vue b/src/ui/views/panels/SatelliteGroundView.vue new file mode 100644 index 000000000..b485d24fb --- /dev/null +++ b/src/ui/views/panels/SatelliteGroundView.vue @@ -0,0 +1,106 @@ + + +