While a selected vessel, aircraft or military aircraft is off screen, behind
the globe or out of its layer's feed, its Context card shows Find it. One
still in its feed is flown to (an aircraft followed). One out of its feed is
looked up on its own track at the layer's time (the world clock's while the
layer follows it), the card moves to that reading and says how old it is, and
the camera flies there; once the feed has it again its layer selects it again.
With no reading at or before the time the card says so and the camera stays.
A vessel its layer announces is named by its own id, as a click names it,
not by the context store's.
Main's single click rule (the card or label on top takes the click, read
once per click through clickCard and isUnderOtherCard in
src/data/pickRegistry.js) covers a click on a Space Missions label: a
mission marker label is an interactive world-overlay entry, so the
host's hit test names it as the card on top for every other layer. The
per-layer label guards in CCTV, Drone Airspace, FIRMS, Ghost Maps, News,
Perimeters, Shipwrecks, Vessels, Wildlife Sightings, ALPR, Local ADS-B
and the cockpit orbital focus are dropped for main's versions.
The mission-label tests are kept on main's API: fakeInputUnderLabel now
also names the label as the card on top, and each test shows a click on
the label never acts on the card, camera, vessel, fire, reader, aircraft
or report under it, and leaves the selection as it is. A launches test
checks that a mission label is interactive and is the card on top for
every other layer. Docs, changelog and the dispatcher's `overlay` note
describe the merged behaviour.
Co-authored-by: Manjunath Paparaju <[email protected]>
Resolves conflicts with main: a world focus target's own range past its
framed radius replaces the kind's range (#1832), so a quake asks for its
own range only past M6 and the earthquake framing stays its floor; FIRMS
keeps main's marker stand-in under the card-on-top rule; launches keep
main's label click and also read the card on top through the pick
registry.
Review fixes for #1781:
- One rule for cards: the world-overlay host hands its hit test to the
pick registry, and every click handler reads the topmost interactive
card or label once per click (`clickCard`, `isUnderOtherCard` in
src/data/pickRegistry.js), so all handlers agree in any listener order.
A layer whose own card or label is on top acts on it whatever is drawn
under it; a layer under another layer's card neither acts nor treats
the click as empty space (a tracked aircraft stays tracked, a selection
stays selected); Context names nothing under a card. A selected news
card over a vessel no longer opens the link and selects the vessel.
- With one rule, the per-owner arbitration options are no longer read
and are removed: `passive`, `expanded` and `declinesClick` pick owners,
`rememberClickPickActions`, `isActedOnByOtherLayer`, card backgrounds
and `cardKeepsClick`. The dispatcher is unchanged from main.
- A drag that ends on a quake disc, label or card does nothing; opening
the USGS page or clearing the selection needs a clean click.
- A click on the map under another layer's card opens no Street Level
ground image.
- A CCTV card that is going away is still not the scene under it.
- Docs and changelog describe the new rule.
A click on a Space Missions label reaches every click subscriber so they can
let go of their selection, but the layers that test their own painted cards
or pick the scene themselves still found what lay under the label: CCTV
turned that camera on, FIRMS and Vessels selected and flew to theirs, News
and Wildlife Sightings opened their item, Perimeters, Ghost Maps and
Shipwrecks opened the card's link, ALPR selected its reader, and Local ADS-B
drilled the scene itself and selected the aircraft. Each now skips its own
test on such a click, and Local ADS-B drills through the click, so the click
only releases selections, as a click on empty map or another layer's
contact does. Ordinary clicks behave as before.
Co-authored-by: Manjunath Paparaju <[email protected]>
A tracked aircraft's icon and 3D model keep the colours they have
untracked in Flights and Military Flights (no cyan, no lighter amber);
only the icon's alpha changes (stale fade, clear while its model draws).
A selected vessel or aid keeps its type colour instead of white, and a
tracked satellite's dot keeps its class colour instead of yellow. An
emergency stays red while tracked.
Turning vessels on returned what the first live poll answered, so a
failing feed (such as a missing AIS key) made enable() resolve false and
the layer reported it could not be turned on. loadLivePositions again
resolves with nothing once the poll is done; going back to live reads the
poll's answer through its own path.
Aircraft icons are one size; helicopters turn a three-frame rotor while
airborne or moving; ADS-B ground vehicles share one amber sprite and
stations/obstacles one mast; vessels get hull sprites by type and one buoy.
Going live keeps contacts until the first live answer and replaces them by
id; fast playback holds before the loaded positions end and prefetches
ahead. Cesium models move their parts from the optional model part state.
An aircraft, vessel, transit or rail vehicle now draws as its 3D model only
when it is within 3 km of the camera, and as its icon farther away. A model
already drawn is kept out to 3.6 km, so a vehicle on the edge does not flicker.
Proximity and All use the same distance and still differ by how many models
they allow (150 and 350). Models are drawn at their true size: the minimum
pixel size that inflated distant models is gone.
The camera altitude above which no model is considered is now the highest
aircraft the layers draw (30 km) plus the 3.6 km, so a camera high above the
ground still models an aircraft close to it. Cockpit's aircraft silhouettes
keep their own 150/185 km and 400/450 km bands, since they are icons.
The flights and military layers treat the aircraft they already track as
a passive pick, but they start tracking during the click itself. A card
handler running later in the same click then saw the plane as passive and
acted too: a quake card opened its source while the plane started
tracking, and fire, CCTV and vessel cards could do the same.
The pick registry now records the acting owners of a click's exact hit and
touch contact when the dispatcher first resolves them, and the quake,
FIRMS, CCTV, vessel and Context checks read that record for the rest of
the click. Calls without a click keep the live lookup.
On a coarse pointer the dispatcher can name a contact near the tap instead
of the exact pick. Only flights, military, vessels, radio and Street Level
act on such a contact, so they now register as expanded pick owners, and a
quake card or label yields only to them. A FIRMS fire or CCTV camera reached
only as a nearby contact no longer swallows a quake card, a quake label or
a vessel's own card tap, and FIRMS and CCTV cards yield to a contact whose
layer does act on it.
Radio and Street Level also pick through their own windows. A station or
Street Level item found only there, not as the touch contact, yields to
another layer's card painted over it, and Street Level takes its own touch
contact beyond its narrower window.
Fire, CCTV and vessel cards now act over a passive owner's pick (a flight
trail, the directions route), as the quake card does. The Context panel
leaves a passive route, or a fire or camera reached only as a nearby
contact, to the card painted over it.
Three fixes to how the globe draws and reports loading.
**The idle frame rate is the app's rule.** The Cesium frame port capped the loop at `IDLE_FRAME_RATE` whenever nothing held it, so the rule lived inside the renderer. The render governor now sets the rate: the display's own while the loop is held, `IDLE_FRAME_RATE` while not. The frame port gains `onHeldChange(cb)`, which says when its first hold is taken and its last released (animated visual styles included), so the governor hears every hold. The quality setting's frame-rate cap is kept apart from the governor's rate, and the loop draws at the lower of the two, so neither overwrites the other.
**Line batching is timed.** A line set waited 30 drawn frames before its unchanged lines settled into a static batch (300 for the long wait), so the batch built twice as fast at 120 Hz as at 60 Hz, and took seconds at the idle rate. It now waits `SETTLE_MS` (500 ms) and `LONG_SETTLE_MS` (5 s), and moved shapes go back into their batches on the same timing.
**KEY REQUIRED.** A layer that cannot load without a provider key ended the global status chip LOAD FAILED. The chip now has a KEY REQUIRED outcome, ranked below a real failure: a layer whose stats say `keyRequired` ends KEY REQUIRED, any other failure still ends LOAD FAILED. Vessels report a missing AISStream key as `keyRequired` and name the key in the panel; a later outage clears it, as it is no longer the key that is missing.
Checked: the full suite (new tests for `onHeldChange`, the quality cap against the governor's rate, timed settling, and the chip with and without a key), format, boundaries, build, the stub renderer boot and the Cesium conformance run; in the browser, the idle and held frame rates; and the first-run check now asserts that with no keys set the chip never says LOAD FAILED.
The selected vessel's track drew every fix it held. Following the world
clock, it ran ahead of the icon to the vessel's newest fix; live, it
stopped at the last fix while the icon moved on from it. A change of time
restarted it from a single point until the track at the new time arrived,
so it went blank at every step.
- The track draws the fixes at or before the time the vessel is drawn at;
live, every fix.
- Each frame a head joins its last drawn fix to the icon where it is drawn,
as flight tracks do; none past TRAIL_HEAD_MAX_M (20 km), where the clock
has moved beyond the fixes the track holds.
- A change of time keeps the track, drawn up to the new time, until the
track at that time replaces it.
Pressing Live while a timed snapshot load was in flight left the live poll
waiting on that load. The live poll returned early, so the map showed no
vessels until the next refresh. The live poll now drops a timed load still
in flight, and loadAt shares the same dropLoad helper.
Card handlers hit-tested only their own source, so a card buried under
another layer's card still acted, and a click on a selected quake card over
a vessel or fire card made both layers act. Vessels, FIRMS, wildlife, news,
ghost maps and shipwrecks now read the unfiltered topmost painted entry:
their own card acts only when it is on top, and a click on another layer's
card is that layer's, so it neither acts here nor clears a selection.
A top news or wildlife card still acts over another layer's scene item, so
it never goes dead over a flight trail or a directions route; a registered
marker under a foreign card is still its layer's to select.
While the timeline plays or is scrubbed, each vessel icon is handed to the
renderer as a motion segment along its track (a straight piece of at most
10 km between two fixes, on the scene clock), as aircraft already are. The
layer writes an icon again only when its segment runs out or the time
moves back before it, instead of moving every icon on the CPU every frame.
Behaviour is kept:
- Icons follow the same great-circle track between fixes (a 10 km chord
stays within 2 m of it) with the same course.
- A vessel still appears TIMELINE_UNSEEN_MS before its first fix and
hides again when the time moves back before that.
- Cards, the selected vessel, ship models and the vessel the bridge camera
rides are read where they are every frame; the rest within
HIDDEN_FOLLOW_MS, as before.
- Position reads (getAllPositions, getNearby, the focus pass, the
detection overlay, single-vessel lookups) return where the icon is drawn
at the world time.
- Going live, each icon holds where its segment last drew it, unless a
live update has drawn it since.
- Trails are unchanged: they are built from the feed's fixes, not from the
per-frame position.
- Live mode and renderers without the motionSegments capability take the
previous path unchanged.
A profile of about 9,000 vessels following a playing world clock spent
~13 ms of every frame in the clock pass, moving every drawn vessel a
fraction of a pixel, and ~4 ms more re-uploading their billboards.
- Drawn vessels move again once the fastest would have moved half a pixel
on screen at the speed each last moved (measured from the world time it
was drawn at), at least once a second, and at once when the camera moves
or changes height by a tenth of its height or the view zooms. A pass that
holds them back asks for a frame, so a paused clock settles on the time.
- Hidden vessels move a share of them each pass, each within 250 ms, rather
than all of them in one frame; the visibility pass moves one coming into
view to the time first.
- A vessel's three positions are written from one surface point and normal
(Cesium's own formula) instead of three fromDegrees calls; the unused
normal is dropped. The great-circle step builds no arrays.
The pass falls from 4.6 ms to 0.37 ms a frame on average in a benchmark of
9,000 vessels (3,000 drawn) at 240 frames a second.
Main brings satellites and vessels moving every frame, smooth rewind for
contacts, global clouds drawn to the level a feed names, and search for
degrees-minutes-seconds, UTM, MGRS and plus codes. They keep this branch's
renderer work: satellites write their reckoned positions into the points set
once a frame; vessels move every frame and ask for frames from the camera pose
and canvas, and a vessel not there yet is hidden through its icon; flights and
military keep the branch's rendering, with main's timeline fixes, trail top-up
and grounded lift; the cloud tiles keep their infrared transfer. The timeline
history module uses the geo helpers instead of Cesium, and main's new tests
use the draw port's items.
A snapshot timeline may declare spanMs: each record of a snapshot at a
time then carries its own fixes from spanMs before the time to spanMs
after it. Flights, military flights and vessels following the clock are
placed on those fixes, so a seek or a move back within the fixes loaded
is no jump: nothing is cleared and play does not wait. The step there is
asked for once and stands in for every contact; those it has keep their
place. Fixes are merged across snapshots at least 20 s apart, at most
240 a contact, and a contact is not drawn more than a minute before its
first fix.
Vessels out of view move on every 250 ms so one coming into view is current;
vessels at the end of their fixes ask for no frames; nothing moves while the
layer is off; 2D views judge the half-pixel step across the view's width; a
re-floor redraws vessels where they are on the next pass.
Vessels between two fixes, and live vessels a host placement places, were
redrawn at most every 250 ms, and a frame was asked for only once a second.
With nothing else asking for frames the scene drew vessels at about 1 to
2 fps live, and none at all while the world clock played at 1x.
They are now redrawn every frame the scene draws, moved in place without
new allocations. After each pass the layer works out how far the fastest
drawn vessel moved on screen and asks for the next frame for when it will
have moved another half pixel, at least once a second while any drawn
vessel moves. A vessel crossing the view close up therefore glides, and
one far away lets the scene idle. A frame already asked for later is
brought forward when a vessel speeds up.
createApplicationCatalog takes an optional placement provider. Its
layer(kind) hands Flights, Military Flights, AIS Vessels, Transit and Rail
a place(id, wallMs), and optionally observe(id, fix) and forget(id). While
live, each layer tells it every fix it accepts and draws a contact where it
places it: position, height (the layer's own when none is given), course
and speed. A null answer, a provider that throws, a kind it leaves out, or
no provider at all keeps the layer's own motion unchanged, and following
the world clock the layers never ask it. A transit vehicle or train it
holds still lets the render loop idle and is asked again each second;
vessels ask for frames only while it places one, and stop when the layer
turns off.
Tests show the layers draw and reconcile exactly as before without a
provider and with one that places nothing, draw where a provider places
them, and idle while it holds them still.
A virtual aid (AIS message 21's VirtualAtoN flag) is a mark broadcast
where nothing physical stands, so drawing it as a buoy showed a mark
that is not there. The vessel source record now carries `virtual`
(false unless a source says true; any source may set it), AISStream
sets it from VirtualAtoN, and the vessel layer keeps such an aid's
disc: vesselModelSpec returns null for it and the layer gathers no
model item for it. Its card, selected card and readout add VIRTUAL
after its kind.
A buoy's card, selected card and HUD readout showed "0.0KT · 135°" from
whatever its source reported. A fixed mark has neither, so they now show
its kind alone, whole ("CARDINAL MARK N", which the 14-character type cut
read as "CARDINAL MARK "), in the bone white of its disc.
isAidToNavigation now knows every kind an aid report names ("Light, with
sectors", "Fixed structure off shore" had no aid word), leaves out a
"Buoy Layer" as it does a tender, and matches each type text once: the
vessel layer asks per vessel on its rotation pass, which now skips the
aid discs it never turns.
Aid rows no longer cost ships their place: aisStreamRows lists every
vessel ahead of every aid, so the layer's 12,000-row request never drops
a ship for a buoy, and vessels_in_area (and the brief built on it)
counts ships only. An aid's name runs on into its NameExtension.
A buoy, beacon, RACON, light or IALA mark in the vessel feed was drawn
as a ship. A vessel record whose type names one, or whose MMSI is an
aid-to-navigation station's (99MIDxxxx), is now isAidToNavigation and
vesselModelSpec draws it as the fleet set's buoy of its mark (cardinal
N/E/S/W, port or starboard hand, safe water, isolated danger, special
mark; a red can when the type names no mark), at its built size and
flagged fixed so its model does not turn to a heading. Its icon is a
disc instead of a chevron.
AISStream now subscribes to AidsToNavigationReport by default, and the
server names each report's aid type code (0 to 31) as its kind instead
of reading it as a ship type.
In-view scanning skipped a vessel whose chevron was hidden and not drawn
as its model, which covered the ship the bridge camera rides. It now
skipped only vessels past the horizon, so the ridden ship was reported,
at the camera's own position. It is skipped again unless its model draws
it.
Aircraft, military, local ADS-B, vessel, transit and rail models come from
the fleet model set, loaded up front and drawn life size through the draw
port's models sets; no layer touches the viewer or Cesium outside
src/render/cesium/. The models capability gains glTF bytes (gltf), a
per-axis stretch (axisScale), a colour for tinted parts (maskColor) and a
cut below the origin (clip: 'belowOrigin'), with conformance checks.
Main's rail layer and Data Library are ported to the ports; the CCTV
footprint probe keeps the globe-terrain clamp through the query port.
- a vehicle drawn as a model keeps its selected card and stays in the detection overlay
- transit and rail models drop the 1.5 m floor lift their icons carry
- vessel models are clipped below the waterline
- models switch to an unlit white look under NVG/FLIR and back
- unknown transit modes keep their icon
- aircraft model specs are cached per set; no key-array copies per frame
Vessels, Transit and Rail turn nearby icons into fleet models at the
aircraft layers' distances. A vessel is drawn at its AIS length and beam
(static dimensions now reach vessel rows), standing at the sea surface; a
transit vehicle or train stands on its road or rail, raised by its type's
elevation, and is painted in its mode or category colour where the model
marks it.
Selecting a vessel asks Open Vessel Photos (a free, keyless API) for its
photo by MMSI, once per MMSI. The CONTACTS view shows it under the vessel's
name and MMSI with the photographer, the photo's open licence and a link to
the vessel's page; only images on Open Vessel Photos' own host are shown, and
an answer about another MMSI is no photo. The vessel source exposes the lookup
as getEnrichment({kind: 'photo'}) and fetchOpenVesselPhoto for applications
with their own vessel source.
A GPU icon set whose blend is translucent draws every row in one
alpha-blended pass in row order (LEQUAL, depth written), as
BlendOption.TRANSLUCENT billboards do, in place of the opaque and
translucent passes the set's blend only re-blended: overlapping icons
kept the first row's fill and lost the outlines of those over it. The
vessels, shipwrecks and FIRMS sets ask for that blend again, as their
billboard collections did.
Upstream's layers and changes are carried onto the ports, with no Cesium
outside src/render and no reach into the viewer:
- Shipwrecks draw as one icon set, clicked through the input dispatcher.
- News draws through draw sets, the camera port and the input dispatcher;
its beacons pulse each frame through the frame port.
- The scene occlusion probe moves into src/render/cesium and reaches
detection through a new application hook, createOcclusionProbe; its
private Cesium reads go through internals.js.
- Flight and military trails, the stale and SIGNAL LOST cue, coasting and
following the world clock run on the draw and frame ports. GPU icons
follow the scene clock while the world clock is followed, and fade when
stale. A report that holds is not planned again every tick.
- Vessels are keyed by their record id.
The stub boot now enables military, shipwrecks and news as well.
AIS Vessels are keyed by the id their live source gives, with the MMSI as an
attribute: an MMSI can be shared, spoofed or reused, so two vessels with one
MMSI are now two vessels. Looking a vessel up or selecting it by MMSI still
finds it.
A share link made while a vessel is selected opens that vessel. A UUID vessel
id travels as 16 bytes in a new thing field (13). A shared thing that is not
reporting now says so in a sentence per kind, with its id (ICAO, NORAD, MMSI
or vessel UUID) on a second line.
A live source may now declare a timeline: it can answer a snapshot at a
given time (source.timeline = { coverage(), stepMs, subscribe? }, read by
readSnapshotTimeline). While such a layer is on it follows the world clock
and registers the coverage. At the live edge it polls exactly as before;
away from it the layer asks for getSnapshot({ ...query, atMs }) at the step
at or before the clock time and shows that snapshot instead of polling.
src/time/snapshotTimeline.js owns the following: a seek, time going
backwards or leaving live replaces every contact with the snapshot at the
new time (play waits on it, for at most 8 s); playing on keeps one
snapshot ahead and gates play on it, applying those snapshots as polls so
contacts move smoothly; outside coverage the layer is empty; back at live
it is cleared and polls at once. One load at a time, and a load the
source drops for a newer one is not a failure.
While following, aircraft are drawn at the clock time with no render
delay, records and absences are judged at the clock, track requests carry
atMs, and vessels move between fixes along the great circle. The world
clock counts jumps (seeks and returns to live) in getState().
A source with no timeline never follows the clock, and every layer stays
live, unchanged.
- What the camera follows is the camera port's target only: no layer
tracks an entity of its own any more, so followed.js stops reading and
writing viewer.trackedEntity and the viewer's clock.
- Draped imagery's host is the globe port's imagery while the globe is
shown (isGlobeVisible, or no shown base tileset where a renderer cannot
say), else the shown base tileset; weather uses the same resolver.
- The World Packet reads the eye from the camera port's pose, and vessels
ask again for the view on the camera port's moveEnd.
- The stub's canvas takes event listeners, and in a page is a real canvas
filling the container it is given; createStubRendererPlugin makes it a
renderer plugin.
The viewer access record is now empty.
Ports the cockpit bridge view, the orbital view riding a satellite with
ground-site focus, satellite classes and draw-mark row actions onto the
renderer contract. The orbital view's imagery look-ahead pre-load is
dropped (no contract member); tiles load as they come on screen.
Brings in fire intensity and the draped heatmap (#1426), provider labels
(#1521), Rio transit (#1481), chat autocomplete and provider switching
(#1561, #1546) and Cockpit entry by the ridden layer alone (#1556).
What main added that reached Cesium or the viewer:
- The fires heatmap drapes as one image through the globe port's imagery
(heatImagery.js), above the port's other imagery, and drapes again when
the map stack's surface changes. The far bands no longer draw heat
rectangles; the layer's shape set stays as its initialized marker and
the visibility the context store reads.
- The hand-off between heatmap and markers fades the glow icons' own
alpha and the icon set's visibility. Markers keep their glows across
rebuilds; the set culls the horizon itself.
- A double-click on the followed track enters the Cockpit through the
input dispatcher. The renderer's own double-click follow would let go
of the track first and cannot be refused from a subscriber, so a press
on the followed track holds that behaviour off for the press.
- Cockpit entry and the ridden layer read the follow service; the camera
takes its eye offsets from a profile.
Each sprite layer's icon or dot set is now made at a draw order taken
from SPRITE_LAYER_ORDER through the renderer's per-set drawOrder:
flights over military, vessels, directions, transit, bikeshare, FIRMS
and CCTV, whichever layer was turned on first. Picks name the topmost
first. The orders are negative, so selection highlights, route
endpoints, the tracked plane and every other set at the default order
still draw over all sprite layers, as they did before.
The raise-to-top restorer, the sprite registry and the primitive-name
lookups are gone, which takes spriteOrder.js off the viewer-access list.
Before, the restorer raised the layers to the bottom of the scene in the
order they were enabled, so flights usually ended up under the others.
The vessel layer draws other ships at their last AIS fix and does not
advance them, so dead-reckoning radar contacts moved the mismatch from own
ship to everyone else: a 15 kn ferry reported 90 s ago showed ~700 m ahead
of the ship out of the window. Own ship stays centred where the camera
rides; contacts go back to their last fixes, and the query drops the extra
reach and candidates (which could also cut the nearest ship in a crowd).
The sprite and card were hidden from the bridge but the selected-vessel
trail was not: at sea it ran astern from under the eye, and on a raised
river it lay buried under the water. It is now hidden while the bridge
holds its ship, keeping its history, and shown again on release.
The radar centred on the ship's last AIS fix while the camera rode that fix
dead-reckoned up to 180 s ahead: at 20 kn about a nautical mile apart, so a
ship already passed still showed ahead. Own ship now sits where the camera
rides and each contact is dead-reckoned to the same moment; the query reaches
past the range for ships that have since moved into it.
Ships with no MMSI each get a key of their own instead of all sharing an
empty one on the scope.
Files off the Cesium list sized themselves by, listened on and set the
cursor of `viewer.scene.canvas`. They now read `canvasOf(viewer)` from
src/render/rendererOf.js: the bound renderer's canvas, else the viewer's
own, the same element. Recent Imagery's divider moves the split through the
globe port (`globeSplitTarget`, moved from the flood event into
src/ui/imagerySplit.js), and traffic flow passes the viewer to the listed
surface module (`viewerRoadSurface`) instead of reaching for its scene.
The test fakes give their viewers a canvas, and the fake renderers report
it, as the Cesium renderer reports the viewer's.