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.
On Node 26 the engine inlined the projection pass's helpers in another order and left distanceScale out, so every label's paint scale allocated a number: 158 B per candidate per frame against the 154 B budget, where main measures 136 B. The curve now sits beside the altitude curve in snapshotAndProject, with the same arithmetic.
Grounded aircraft turn 3D on the first settled frame: streaming tiles are not a miss. groundSnap's tests keep main's cases against the branch's query port; trackedModelForm.test.mjs (the branch's form of trackedModelRegime.test.mjs) takes main's edits.
Turning CONTACTS on with a vessel selected made the nearest flight to the view the subject and followed it. The selected vessel is now adopted as if it had been selected while CONTACTS was on; a followed flight still comes first, and with nothing selected the nearest flight is still focused.
- Scratch and marker positions are a Cesium-free Vec3 (src/geo/vector.js), so writing a coordinate does not allocate.
- The dirty set and the upsert lists are kept between frames instead of rebuilt; patchDrawnIcons reuses its lookup arrays.
- measureFrames and stopFrameProbe live in src/layers/transit/testing.js again.
- Tests: 3000 moving vehicles stay under 8 KiB per frame of layer allocation; moving 500 icons allocates under 256 B per upsert.
Tiles still streaming no longer count as a failed ground sample: they leave
the retry backoff alone and return the last measured ground, if any, so the
first tick after the tiles settle samples and hands the icon to the model.
- Clicks: when two tools want the globe's clicks, the newest takes them and the older is told and turns itself off; a click is decided when it arrives, and ambient selection fires only when no tool holds the pointer. The "map is busy" paths and their strings are removed.
- Recession: the limb fade is shared (src/render/recession.js) and reaches icon and model sets through SetSpec.recede; tuning applies on the next frame.
- Display panel groups are published through src/ui/displayGroups.js; the Weather group and src/viewWeather.js are removed.
- Draw port: a set whose icons only move is moved in place, and models that did not change are not restyled each frame, so moving fleets cost what they did when drawn directly; an untinted, fully opaque model is drawn without a colour.
- Conformance: input.lease.lost checks the new lease inside onLost and reports a throwing onLost; draw.sets.recede covers model sets.
- QA scripts read the renderer host instead of internals the seam replaced.
mergeTimelineRuns read an entry's time again on every comparison, and the
vessel layer passed a new arrow for every vessel. Times are now read once
into arrays, the leading older entries the loop would keep one by one are
sliced in one step, and the layer passes one function. The result is the
same entries in the same order; a test checks 3,000 random merges against
the previous algorithm.
Measured in the browser, one implementation per page, 9,000 vessels with
240 kept fixes each, 5 alternating pairs: 65-87 ms -> 57-61 ms per snapshot.
The label pass projects every vessel in view each time it runs. It asked
Cesium for each one, which reads the camera and allocates for every point.
createWindowProjector reads the camera's matrices and the canvas size once
and runs the same arithmetic in the same order, so the window positions are
the same numbers (a test compares them bit for bit with Cesium); outside a
3D perspective view it asks Cesium as before.
Grid cells are keyed by number, a cell's candidate is made only for its
first vessel and updated in place, and whether a name is worth a card is
kept per vessel until its name, MMSI or id changes.
Measured in the browser (perf harness, 9,000 vessels, 1 min/s): the label
pass 33 ms -> 11 ms, the forced visibility pass 42 ms -> 27 ms.
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.
Playback moves something every frame, so it draws at the display's rate
rather than the parked scene's 60 FPS cap. followWorldTime reports when the
clock starts and stops playing (not live, not stepped, not waiting for data).
The top of the README now matches godseyeview.ai: official-site line, hero clip, a twelve-tile feature
grid and the video series. Docker, Codespaces, the layer table, Street Level and the voice provider
notes are folded into collapsed sections with their text unchanged. The Field Missions and Cockpit
showcase sections and the 17 launch-era GIFs are removed (68 MB of media down to under 8 MB).
package.json homepage points at godseyeview.ai.
Co-Authored-By: Claude <[email protected]>
A fix that is not a second newer (a repeat, or an older position from another
feed) never gives a course, so a source switch cannot turn an aircraft
around. The course runs from an anchor fix that moves only when a course is
read, so frequent short steps add up, and a contact reported under 2 m/s
reads none. The helper moves to src/data/courseFromFixes.js and the military
records use it as well.
Some feed rows carry neither a ground track nor a true heading for an
aircraft on the ground. Its course then fell back to 0, and an aircraft
taxiing south was drawn facing north, moving backwards or sideways. With
neither reported, the course is now read from its last fix to this one when
they are at least 30 m apart; nearer fixes are position noise and keep the
last course.
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.
Remove the fixed 60 FPS cap. The render governor caps a parked scene at
60 ticks a second, since Cesium still runs the clock, data sources and update
listeners on every animation frame when it skips the draw, and holds
continuous render while the camera moves (moveStart to moveEnd, with pose
sampling for cameras that drift by rounding errors and never raise moveEnd).
Waits that counted frames (a tracked contact's first position, a shared
follow view, a trail's temporary copy) now count drawn time through
src/time/frameWait.js, so they last the same at any refresh rate.
Aircraft are binned into H3 resolution-4 cells (h3-js) and each cell is
drawn as its hexagon instead of a 0.5 degree square. As on gpsjam.org,
every hexagon with an aircraft is shown: the three-aircraft minimum is
gone, and discounting one bad aircraft is the only small-sample guard.
Cells are keyed by their H3 index and carry their centre and boundary.
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.
A weather feed that supplies its own tiles may name, per product, the
deepest level of the geographic tiling its tiles hold detail at
(frameMaximumLevel, 0-12). Global infrared is then drawn from those tiles
to that level, each given the regional infrared display transfer, rather
than from one 2048x1024 image cut to level 3. Other tiled products take
the named level in place of 6. A feed naming no usable level keeps the
layer's own detail.
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.
Satellite points were propagated once a second and held still in between,
so while the world clock plays faster than real time they jumped: at
1 min/s, about 45 px once a second at globe scale.
Each SGP4 call now keeps a sample of the satellite's inertial position,
velocity, gravity and its rate of change (src/layers/satellites/motion.js).
Every frame each shown point is reckoned from its sample to the world time
and turned into the Earth-fixed frame by the sidereal angle, so points
glide at any play speed. Core satellites still take a fresh sample every
second, and at once when the world time is 30 s from it (fast play, a
seek), which keeps every point within about 10 m of SGP4. Starlink extras
take their first sample as they load and are resampled round-robin, more
per frame the faster time plays (up to 2,000 a frame); a point more than
two minutes from its sample waits for the next one. Hidden points are
moved when shown again, and the tracked satellite keeps its per-frame path.
Measured at globe scale: at 1 min/s points move on every frame, 0.4 px a
frame and at most 1.4 px (before: once a second, 45 px). With 11,880
satellites (Starlink on) the scene holds 60 fps, frames 16.7 ms median and
19.7 ms p95; reckoning costs 0.02 ms a frame for 1,342 points.
Main brings the reviewed one-time-control and timeline-mark changes. They
keep this branch's renderer work: earthquakes draw through the draw port and
register their strong quakes as marks; the weather clock keeps `follows` beside
`world`; the weather layer measures ages and delays from the timeline time;
the Visual panel keeps its sky and weather groups under Effects. Tests that
moved time through the weather clock now move it on the world clock.
5150279cc, 97bd61711, 900c76425 and 4f23ad330 went to main, reviewed and
changed, as #1745. They are taken out here so main brings them in as
merged, rather than as two copies of the same changes in conflict.
A weather row's play started the world clock even with no time to show,
where there is no timeline; it now does nothing then, as the timeline's
own Play cannot be reached. A weather layer made without a weather clock
does nothing once destroyed, so enabling it after builds no clock.
The timeline's speed follows the world clock's rate whoever set it, and
its Play runs at that rate, so it and a row's play never run at different
rates; a rate not offered shows as the nearest offered speed. Choosing a
speed sets the clock's rate first, also while a driver steps.
Marks merge on their whole label and are cut for showing after, so two
whose labels only differ past the cut stay two, and the cut counts
graphemes (code points where the runtime cannot tell them), so an emoji is
never split.
Tests that compared a DOM element with null built an assertion message
from the element when they failed, which hung the run; they compare plain
values now, so they fail at once. The timeline tests put the clock back to
real time after each.
A weather row's play ran the world clock at whatever rate it had, and
going live set that back to 1, so the speed chosen on the timeline was
lost. The world clock now keeps its rate while paused and live, and the
timeline's speed sets it whenever it is chosen, so any play runs at it.
A row's play starts from the start of the covered time when live or at
its end, as the timeline's does, and does nothing while every product the
row shows is suspended, as its reduced-motion note says.
Live, the Weather panel's frame time is the newest of each product's
frames, suspended or not, so it no longer goes away under reduced motion,
on a hidden page or without an imagery host.
A weather layer made without a weather clock builds its own when first
enabled rather than when made, so a layer never turned on leaves the
world clock alone, and its own clock (createWeatherClock({ shared: false }))
leaves the world's time where it is when destroyed; only the last shared
weather clock sends the world live.
On the timeline, a zoom or a pan clears the hovered tick's label, a label
is never wider than the track and ends in an ellipsis, and a mark's label
is cut to 60 characters (WORLD_CLOCK_MARK_LABEL_LENGTH).
The changelog entry says what a row's step does, names the earthquake
layer's new exports and says it registers with the world clock.
A layer's world clock coverage may now give each mark as an object,
{ time, label?, id?, kind? }, as well as a bare epoch ms number, and the
two may be mixed. worldClock.coverage() keeps marks as the sorted list of
distinct times, so existing readers are unchanged, and adds markDetails:
the merged marks in time order (then kind, label and id), each frozen and
holding only the fields given. Marks given alike by several sources appear
once, a bare time is dropped where a labelled mark shares it, and a mark
with no finite time is ignored. The contract is documented in the
worldClock JSDoc and docs/APPLICATION.md.
Launches label their marks with the mission's name (the launch's where it
has none), cut to 27 characters in capitals as the mission index shows
names. Earthquakes of magnitude 6 and up label theirs with the magnitude
as the map shows it and the feed's place cut to 40 characters, such as
"M6.4 · 113 km SSE of Lata, Solomon Islands"; the layer now tells the clock
when the labels change as well as the times.
On the timeline, a pointer within 6 px of a tick shows its label over the
track (nothing for an unlabelled mark), and a tap there goes exactly to
the mark's time instead of the point tapped. A tap elsewhere and a drag
work as before, and ticks stay ticks. The arrow keys still step from mark
to mark; with the handle on a mark, its labels follow the time in the
handle's aria-valuetext, and show over the track while it has focus.
The timeline drew a tick for every registered mark, and the weather clock
registered every radar, satellite and lightning frame, which come every few
minutes, so the track was a wall of dashes and the arrow keys crept from
frame to frame.
Weather products now register only the span of their frames (start and
end, as before) with no marks. Holds, the gate and the next-frame wait
while the world plays are unchanged. A weather row's step param goes to
the previous or next weather frame (every shown product's frames, and the
row's own while it is suspended) rather than to the timeline's marks.
The Earthquakes layer registers with the world clock once, at init, and
unregisters on destroy. While on, its quakes of magnitude 6 and up
(EARTHQUAKE_MARK_MAGNITUDE) are marks, and its coverage is their own span,
or none without any, so it never stretches the timeline beyond the feed.
Off, it has none. It tells the clock when the set of marks changes. The
map still draws every M2.5+ quake.
Launches stay marks. With no mark ahead or behind, the arrow keys step
along the track as shown.
Built without a weather clock, the weather layer still ran a frame replay
of its own: params.play stepped its frames every two seconds and went round
from the last to the first, params.step and params.latest picked frames
locally, and the layer tracked whether it followed the newest frame. That
was a second way to move time.
The layer now builds a weather clock on the page's world clock when none
is passed, and destroys it with the layer, so every layer follows the world
clock and its params move the world clock as the timeline does. The local
replay, its timer, the follow-latest flag, the wrap to the first frame, the
timerActive diagnostic and the reduced-motion "manual history available"
message are removed.
The Weather panel kept a second time transport of its own: a slider, step
buttons, Latest and Play, backed by a replay in the weather clock that
stepped the observed frames every two seconds and went round from the last
to the first. The weather clock also attached itself to the world clock as
a driver, so the timeline's Play became that replay whenever weather was on.
The panel now shows the frame time only: the newest frame and its age while
live, the timeline time alone at a past time. The weather clock no longer
has setTarget, step, latest, play, pause or togglePlay, its state no longer
has playing, and it no longer drives the world clock. It still follows the
world time, registers each product's frames as marks the timeline's arrow
keys step to, holds its products, and gates the world's continuous play at
each next frame until it loads. weatherClock.world names the world clock it
follows.
A weather row's play, latest and step params move the world clock as the
timeline does: play toggles continuous play (from the start of the covered
time when live), latest goes live, and step goes to the previous or next
mark. The rail timeline component, which only the panel used, is removed,
along with its unused messages in every locale.
A layer's world clock coverage may now give each mark as an object,
{ time, label?, id?, kind? }, as well as a bare epoch ms number, and the
two may be mixed. worldClock.coverage() keeps marks as the sorted list of
distinct times, so existing readers are unchanged, and adds markDetails:
the merged marks in time order (then kind, label and id), each frozen and
holding only the fields given. Marks given alike by several sources appear
once, a bare time is dropped where a labelled mark shares it, and a mark
with no finite time is ignored. The contract is documented in the
worldClock JSDoc and docs/APPLICATION.md.
Launches label their marks with the mission's name (the launch's where it
has none), cut to 27 characters in capitals as the mission index shows
names. Earthquakes of magnitude 6 and up label theirs with the magnitude
as the map shows it and the feed's place cut to 40 characters, such as
"M6.4 · 113 km SSE of Lata, Solomon Islands"; the layer now tells the clock
when the labels change as well as the times.
On the timeline, a pointer within 6 px of a tick shows its label over the
track (nothing for an unlabelled mark), and a tap there goes exactly to
the mark's time instead of the point tapped. A tap elsewhere and a drag
work as before, and ticks stay ticks. The arrow keys still step from mark
to mark; with the handle on a mark, its labels follow the time in the
handle's aria-valuetext, and show over the track while it has focus.
The timeline drew a tick for every registered mark, and the weather clock
registered every radar, satellite and lightning frame, which come every few
minutes, so the track was a wall of dashes and the arrow keys crept from
frame to frame.
Weather products now register only the span of their frames (start and
end, as before) with no marks. Holds, the gate and the next-frame wait
while the world plays are unchanged. A weather row's step param goes to
the previous or next weather frame (every shown product's frames, and the
row's own while it is suspended) rather than to the timeline's marks.
The Earthquakes layer registers with the world clock once, at init, and
unregisters on destroy. While on, its quakes of magnitude 6 and up
(EARTHQUAKE_MARK_MAGNITUDE) are marks, and its coverage is their own span,
or none without any, so it never stretches the timeline beyond the feed.
Off, it has none. It tells the clock when the set of marks changes. The
map still draws every M2.5+ quake.
Launches stay marks. With no mark ahead or behind, the arrow keys step
along the track as shown.
A pack of the world's settlements of 15,000 people or more (31,827 places,
1.6 MB, CC0) built from the Wikidata Query Service by
scripts/build-wikidata-cities.mjs. src/data/wikidataCities.js reads it on the
first lookup and answers the nearest city to a point, the cities around it,
a city by name ("Paris, France", or the nearest namesake in view) and a
country's name in the page language. Names match without accents or case.
The build leaves out groupings of settlements (metropolitan areas,
agglomerations) and places that no longer stand, keeps a city that is also a
narrower grouping kind (Istanbul) or a unit dissolved where nothing else
names the spot (the Vietnamese provincial cities of 2025), fills a country
from the area a place lies in, splits a population band the service cannot
answer in time, and fails if well-known cities are missing or a known
grouping gets in. The app never calls Wikidata itself.
Co-authored-by: Sameh Khamis <[email protected]>
The Rain radar, Lightning density and Satellite clouds rows named NOAA
nowCOAST until a manifest named its own source, whatever the source read.
A weather source may now supply sourceName(kind), kind being radar,
lightning or satellite; the row shows that name until a manifest names one.
The name is read once when the layer is built and held to the same rule as
a manifest's display.source. A source without names, or one whose name is
refused or fails, still shows NOAA nowCOAST.
Built without a weather clock, the weather layer still ran a frame replay
of its own: params.play stepped its frames every two seconds and went round
from the last to the first, params.step and params.latest picked frames
locally, and the layer tracked whether it followed the newest frame. That
was a second way to move time.
The layer now builds a weather clock on the page's world clock when none
is passed, and destroys it with the layer, so every layer follows the world
clock and its params move the world clock as the timeline does. The local
replay, its timer, the follow-latest flag, the wrap to the first frame, the
timerActive diagnostic and the reduced-motion message are removed.
The Weather panel kept a second time transport of its own: a slider, step
buttons, Latest and Play, backed by a replay in the weather clock that
stepped the observed frames every two seconds and went round from the last
to the first. The weather clock also attached itself to the world clock as
a driver, so the timeline's Play became that replay whenever weather was on.
The panel now shows the frame time only: the newest frame and its age while
live, the timeline time alone at a past time. The weather clock no longer
has setTarget, step, latest, play, pause or togglePlay, its state no longer
has playing, and it no longer drives the world clock. It still follows the
world time, registers each product's frames as marks the timeline's arrow
keys step to, holds its products, and gates the world's continuous play at
each next frame until it loads. weatherClock.world names the world clock it
follows.
A weather row's play, latest and step params move the world clock as the
timeline does: play toggles continuous play (from the start of the covered
time when live), latest goes live, and step goes to the previous or next
mark. The rail timeline component, which only the panel used, is removed,
along with its unused messages in every locale.
The ./i18n entry exports t, tn, msg, translateKnown and the number and date
formatters. setMessageOverrides({ en: {...}, de: {...} }) shows the
application's text for any catalog key: in the active locale, else its
English, else Core's translation.
At a past time the radar, lightning and satellite cards aged the shown
frame and judged the source delayed against the wall clock, so a frame
from years back read "Source observations delayed" and an age in the
millions of minutes. Frame ages, the delayed status and the stale stat
now count from the timeline time at a past time, and from now while
live, as before. The observed timeline's readout and preview show the
time alone at a past time, since its age from the timeline time is
always zero.
The wind card noted that it does not follow the timeline whenever the
observed clock was at a past time, even when a host follows the world
clock for wind. The weather clock now reports whether a layer follows the world
clock (weatherClock.follows(id), the world clock's follows), and the
wind row and card drop that note when its source follows the timeline.
The world overlay drew on desynchronized 2D contexts. After a frame that
only clears, Chrome could present an earlier buffer, so storm cards and
forecast lead-hour labels stayed on screen when a snapshot without storms
(or an unavailable one) replaced them, although the overlay held no entries
and cleared every frame. Both overlay surfaces now use ordinary contexts.
The storm readout no longer prints "Unavailable" for a null value: an
advisory without pressure shows only its maximum sustained wind, one
without wind only its pressure, and one without either has no intensity
line. The advisory link stays hidden when an advisory has no link.
Live counts repaint the rows many times a second; the index now reads its
headings at most once a frame, and only when a heading changes. The label
goes before the tick when there is no room after it, as in a right-to-left
language, and the ticks sit at the panel's inline end.
Co-authored-by: Manjunath Paparaju <[email protected]>
- Escape in the field closes the search alone, focus back on its button,
without folding the panel or leaving the cockpit.
- The category is the group's key (LayerRows' data-group), so a language
change keeps it; a group that goes away clears it.
- On and Off follow whether the layer is enabled, not its feed's state.
- The filter is a disclosure of two groups of toggle buttons: opening it
focuses the chosen option, the arrows, Home and End move, Escape closes
it, and it stays inside the panel.
- No layers match is translated, the search matches names only, and the
rows are filtered once per frame at most.
- A voice request to show a layer the finder hides clears the finder.
Co-authored-by: Manjunath Paparaju <[email protected]>
The finder matched only the English name, so a search in another language
found nothing. Its header buttons and its bar share state through the
component's module rather than a global.
Co-authored-by: Manjunath Paparaju <[email protected]>
The group label is drawn on the page just outside the panel's edge instead
of over the rows; the panel clips what leaves it, so the label is teleported
to the body and placed from the tick. The finder shows focus as a soft ring
on the field's frame in place of the hard outline round the bare input.
Co-authored-by: Sameh Khamis <[email protected]>
The Data Layers panel gains a search field, an All / On / Off and category
filter, and a tick index down its side for jumping between sections. Both
sit beside the Data Library browse control.
Co-authored-by: Sameh Khamis <[email protected]>
The rail's buttons are disclosures (aria-expanded, aria-controls) and go
through one toggleCockpitUtility action, which already keeps one panel open.
Collapsing returns focus to the rail when the launcher's toggle is hidden.
The edge switch is gone: edge mode does not apply in the cockpit.
Co-authored-by: Manjunath Paparaju <[email protected]>
Cyber and the phone keep their own cockpit layouts. Display and Radio take
their top from the layout pass, whose floor now matches the left rail, so the
panel's height still stops short of the briefing. The rail keeps its physical
side in a right-to-left language, the Live Signals rows use logical sides,
and rules for the launchers' old strips, which the rail hides, are gone.
Co-authored-by: Manjunath Paparaju <[email protected]>
The restyle had dropped the page and its tab while the news section, its
fetch and the briefing tests still use it.
Co-authored-by: Manjunath Paparaju <[email protected]>
In cockpit the left rail now shows Data Layers only: Visual's rail item
and panel are hidden there, as Authoring and Utilities are, and the
cockpit's own Display panel stands in for it. The rules that trimmed
Visual's groups in cockpit are removed as no longer reachable. If Visual
was open on entering cockpit, the rail's sliding highlight no longer
stays where its hidden icon was.
Co-authored-by: Sameh Khamis <[email protected]>
In cockpit, the Visual panel hides the HUD, detection, parameters and
3D-model groups, which the cockpit's Display panel already offers, and
the celestial ring toggle. It keeps Look, Map source, Scope, Bloom and
Sharpen.
Co-authored-by: Sameh Khamis <[email protected]>
Live Signals rows drop from 43.5 px to 36 px with less padding. The local
weather tiles lose the lit grid that showed between them, stand 5 px apart
as cards and shrink from 60 px to 53 px, so all four fit the shorter
window.
Co-authored-by: Sameh Khamis <[email protected]>
- The left rail shows Data Layers and Visual in cockpit view; Authoring and
Utilities are hidden along with their slots and panels, so no empty
pieces are left behind.
- With a panel open there, each icon left is its own island; a hidden
panel still open underneath leaves the rail in one piece.
- The cockpit's Display and Radio rail uses the main rails' 12 px spacing
and draws each icon as its own island while a panel is open.
- Contact and Live Signals stand shorter (min(27vh, 260px)); Contact's
buttons share the kicker's row and its subject runs full width on at
most two lines.
- Edge scrolling skips rail items that are not shown.
Co-authored-by: Sameh Khamis <[email protected]>
The cockpit's Display and Radio panels get the compact dark styling of the
rest of the shell, a header with the edge switch and collapse, and a rail.
Co-authored-by: Sameh Khamis <[email protected]>
The card skin stands aside under the Cyber HUD; the pills are decoration
for screen readers, the buttons carry aria-pressed, and Clean UI, an action,
has no pill. A collapsed Visual hides its new parts too.
Co-authored-by: Manjunath Paparaju <[email protected]>
A fainter mask reads as Scope off while labels still fade outside the
keyhole and the HUD gets no backplates.
Co-authored-by: Manjunath Paparaju <[email protected]>
Contacts lends detection for the session and puts back the earlier state
on leaving; a share link carries that earlier state. A reset in Visual is
the user's choice, so it becomes both.
Co-authored-by: Manjunath Paparaju <[email protected]>
The More sheet already shows the dock's Visual Presets tray right above
Visual, so the panel's own copy is hidden on the phone shell.
Co-authored-by: Manjunath Paparaju <[email protected]>
The panel is headed VISUAL, and Clean UI now sits with the overlay
controls, above the Effects group.
Co-authored-by: Manjunath Paparaju <[email protected]>
CURRENT-STATE covers the panel's groups, the opacity slider and what the
reset restores; the share link format lists field 30.
Co-authored-by: Manjunath Paparaju <[email protected]>
The share codec carries field 30 and still encodes a link made before it
to the same code; the long form writes sco only below full opacity; the
mask fades without repainting; the panel shows and sets the opacity, and
the reset and the presets call their actions.
Co-authored-by: Manjunath Paparaju <[email protected]>
The share state took the opacity the slider last showed, which a
show-only update can leave apart from the mask; it now reads the mask
itself, as the feather does. The test reset also restores full opacity.
Co-authored-by: Manjunath Paparaju <[email protected]>
The panel's new headings, the scope opacity slider and the reset are
translated in every language, and the presets' names and descriptions use
the dock's translations. The cards' on/off pills take their words from the
locale instead of fixed English. VISUAL, the panel's name on the rail and in
its header, gets its own translation context: several languages had it as
"visible", from the satellite class of the same English word.
Co-authored-by: Manjunath Paparaju <[email protected]>
The application shell passes the scope opacity setter and the global post
defaults through to the Display bindings, the stylesheet imports the Visual
panel and Scope-off styles, and the icon subset gains the reset icon.
Co-authored-by: Sameh Khamis <[email protected]>
The Display panel is regrouped as Visual (Look, Overlay, Effects) with style
presets, a scope opacity slider and a reset to the default look. Scope
opacity is carried in share links as field 30 and as the legacy sco
parameter; 100 is the default and is left out of a link.
Co-authored-by: Sameh Khamis <[email protected]>
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.
- World timeline: a scrub counts as at now within a share of the track
(0.5%), now held to at most two minutes. A layer whose source covers
years made the window weeks wide, so most of the last month snapped to
live. Short tracks keep their window.
- Fires: card and detail ages count back from the end of the 24 hours the
layer shows when its snapshot ends at a set time, and from now only when
it runs to now. A window that ended months ago read "new 105d" on fires
three hours old at the time shown.
- Weather: a product's max gap and the delay after which its latest frame
reads late are at least one and a half of its feed's median frame
spacing (over its latest frames). A regional cloud feed with frames an
hour apart drew nothing for the second half of every hour while
scrubbing and read late after twenty minutes; feeds with frames minutes
apart keep their gaps.
CCTV and Context take the full right column when open, so the hysteresis
tests use a content-sized panel, and a test covers the full-height rule.
Co-authored-by: Manjunath Paparaju <[email protected]>
Phones and Cockpit keep their own layouts and do not show the switch. The
rails' name panels and edge mode run toward the middle in a right-to-left
language, and the switch reads its side again after the layout moves it.
Co-authored-by: Manjunath Paparaju <[email protected]>
Hidden rails (clean view, recording), sideways or empty moves, dialogs and
the world timeline keep their wheel; coasting after a step is swallowed for
at most 800 ms; line-based wheels step a panel per notch; the strip follows
where each rail is in a right-to-left language; a held step is dropped when
the pointer leaves the strip; nothing runs after removal.
Co-authored-by: Manjunath Paparaju <[email protected]>
Nothing replaces them on this branch yet, so the dock keeps them. The credit
pill and the HUD spacing built on it are left for a change of their own.
Co-authored-by: Manjunath Paparaju <[email protected]>
- The right rail now starts level with the left one whether or not a panel
is open on it. It used to rise to 4% of the screen when one was open,
which in Tactical and Cyber a top-right readout pushed back down, but in
Minimal (which has none) left it about 35 px above the left rail.
- Minimal no longer shows its full-width coordinate strip above the corner
coordinates block, which showed the same position twice; it keeps the
corner block, where the other layouts have it. This changes upstream's
Minimal layout.
Co-authored-by: Sameh Khamis <[email protected]>
The highlight was placed only when an item was pressed or released, the
window resized, or the pointer moved through an edge strip. A rail hidden
and shown again (Context docked and undocked) was left with its open item
unmarked, and a rail turned from a column to a row (panels moved to the
screen edge) kept its highlight where the icon had been. Each rail is now
watched for size changes, and its highlight placed again when it changes.
Co-authored-by: Sameh Khamis <[email protected]>
When a panel opened or closed, the rails' labels eased their width, which
stretched and shrank every button in the rail. On the side rails the
labels now fold away and come back at once; only their fade eases.
Co-authored-by: Sameh Khamis <[email protected]>
Opening a panel from the labelled rail folds its pills to icons over a few
frames, and the highlight faded in at a pill's width and then shrank, as
did the open button's own fill. The highlight now appears only once the
open button is an icon again (square), its size changes at once rather
than easing, and the open button carries no fill of its own.
Co-authored-by: Sameh Khamis <[email protected]>
A scroll that reached a step within 500 ms of the last one was used up
without stepping, so mouse wheel notches 300 ms apart stepped only every
other notch and a second swipe inside the gap did nothing. Such a step now
waits and fires once the gap has passed (one held at most, skipped if the
pointer has left the strip), and the held timer is cleared on teardown.
A comment naming the items cockpit hides is corrected.
Co-authored-by: Sameh Khamis <[email protected]>
With a panel open, a rail's glass is drawn in pieces: one around the open
icon and one for each run of icons above and below it, with a small break
between them. The icons keep their places; the rail's icon spacing grows
from 2 px to 12 px to leave room for the break. The shadow rule for the
old lifted icon is removed.
Co-authored-by: Sameh Khamis <[email protected]>
A scroll that would step a rail again within 500 ms of the last step is
used up without stepping, so panels never switch back to back.
Co-authored-by: Sameh Khamis <[email protected]>
The left rail no longer lifts its open icon out beside the panel title or
reorders the rest behind it. Every icon keeps its place, open or not, and
the rail's shared highlight slides to the open one, on both rails.
The rail also holds one height whichever panel is open: its offset now
allows for the stack rising by a different amount for a tall panel than at
rest.
Co-authored-by: Sameh Khamis <[email protected]>
A swipe is still speeding up when it first steps, and that rise in speed was
read as a fresh flick, so one swipe could step two panels. A flick now
counts only after the gesture has clearly slowed and a short moment after a
step; a mouse wheel notch still steps each time.
The rest of a gesture that has stepped is used up even when the pointer is
no longer in the strip, so its coasting does not zoom the globe or scroll
what opened under it. The strip is never wider than a rail's own column, a
panel in either stack keeps its own scrolling, and the slide classes come
off without an animation to end them (reduced motion).
Co-authored-by: Sameh Khamis <[email protected]>
The left rail holds Data Layers, Utilities, Authoring and Visual; the right
rail holds Context, CCTV and Street Level. A button in each panel header
moves that side's panels to the screen edge, with the rail as a row above
them, and scrolling at a screen edge steps through a rail's panels. An open
right panel starts just under the HUD readouts, and Context and CCTV take
the column's full height. The right rail stays level with the left column's
top whichever left panel is open, in both layouts.
Co-authored-by: Sameh Khamis <[email protected]>
The icon set was created shown, and the pass that hides cameras beyond the
horizon and thins crowded areas runs only from enable(), after init has
waited on the health check. Every frame drawn in that wait showed the whole
catalogue. The set now starts hidden; enable() culls, then shows it.
A click keeps the camera's view of the contact it follows (keptViewFrom),
but a follow frames the eye from its offset alone, its heading the way the
offset leans. Seen from straight down, the eye's view at a contact off the
centre leans only as far as the Earth curves between them, towards the eye,
so the follow turned the camera to face the contact's bearing (from north
to 298 degrees on a click 40 km out from 60 km up). followViewFrom keeps the
range and the tilt to the contact's horizon and turns them to the pose's
heading, a view straight down kept a hair off vertical so its heading holds.
Flights, Military Flights and trains follow from it; a world-focus fly-to,
which sets its orientation itself, keeps the view as it was.
The seam drew the head as two stacked translucent lanes (a 5 px dark
backing under a 3 px colour line), which darkened its centre by up to 40
of 255 over light ground. It is now one 5 px line with a 2 px dark
outline in the same pass, as the head's own material drew it before.
Conformance gains draw.lines.outlineDraped: a draped, translucent,
revealed outlined line, its centre as bright as a plain line of the
colour, its edges dark, nothing past the reveal.
PID's routes.txt types lines 51, 52, 53, 58, 59, 232 and 275 as
trolleybuses (route type 11); the rest of 50 to 59 stay buses, as before.
Voice now also knows trolleybuses, gondolas, cable cars, funiculars and
monorails.
The transit layer knew five modes, so a trolleybus drew as a bus, a
funicular as a train and a coach as a city bus. The GTFS basic route types
are now modes of their own (trolleybus, cable_tram, monorail, funicular,
aerial_lift), each with an icon, colour, detection tier, card word, voice
name, speed ceiling and fleet model.
A vehicle record may carry its route's GTFS route_type as routeType. It
settles the mode after the feed's fleet hint and before its route hint, and
picks the finer model (a coach for 200, a high-speed set for 101) when the
type is a kind of the vehicle's mode. Retained history classifies epochs
through transitModeFor too, so trails join the live vehicle.
Route hints from each operator's routes.txt: Prague's trolleybus lines
(51-59, 232, 275) and Petrin funicular, and the trams, trolleybuses and
metro lines of Bucharest, Cluj-Napoca and Turin. A feed may also name
route corrections that outrank the route type: Le Havre's routes.txt types
its funicular (8-FUNI) as a bus, so it is corrected to a funicular.
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.
Brings in main up to f24abfc88: cockpit subject providers, the render
failure notice, aircraft drawn in their own mesh colours, airport ground
vehicles, and an aircraft with no ground track facing its true heading.
Under the seam:
- The render failure notice lives in the Cesium adapter
(src/render/cesium/renderFailure.js) and is the application hook
renderFailureNotice({allowReload, store}); its private Cesium fields
(Event's raise queue, the widget's render loop flag) are read through
internals.js. The inline panel's timer waits while the frame port reports
the loop stopped, and goes on after a Retry.
- Ordinary aircraft models draw white with the 'highlight' colour blend
through the draw port; tracked and emergency colours tint the mesh.
- Held trains and transit vehicles hide their route set and markers through
the draw port; the fleet model test fakes answer loads through the fake
draw port instead of Cesium's glTF loader.
- The Cockpit's subject view follows and places the camera through the
camera port.
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.
The globe viewer's own double-click tracked a picked entity with a
position or zoomed to one without. Layers moving onto the draw port had it
re-created one by one (data/stockFollow.js); following is a click in GEV,
so the viewer's handler is removed where the viewer is made and every
re-creation goes: earthquakes, cyclones, air quality, news, perimeters,
drone airspace, ghost maps, places, radio, cables, CCTV, ALPR, launches,
bikeshare, Local ADS-B, installations, directions, trails, data packs,
annotations, the library's view and local GeoJSON. The Cockpit's own
double-click and the draw tool's finishing double-click stay.
readsb rows (adsb.lol and a local dump1090 receiver) often send no track for
an aircraft on the ground, only its true heading. The track then read as
missing and the aircraft was drawn facing north, so one taxiing south looked
like it was moving backwards. Each normalizer now falls back to true_heading,
never the magnetic heading.
Before, the route was one clamped polyline whose material coloured it
ahead of the train and dimmer behind it, split exactly where the train is,
with a dark rim at its edges. Through the draw port it became per-segment
colours chosen by each segment's midpoint (the split jumped from vertex to
vertex) and lost its rim.
The contract gains a draped line style `split`: `color` from `at` (a
fraction of its length) on, `behind` before it (`reverse`: the other way),
and an optional `rim` (the outer `widthFraction` of its width at `shade` of
each colour). `at`, `reverse` and the colours change in place. The Cesium
renderer draws it with one material; the rail route uses it, measuring its
split in metres on the ground (one per vertex where the scene draws over
the surface). New conformance check draw.lines.split.
Every aircraft model (Flights, Military Flights, Local ADS-B) mixed 94% of a
flat class colour over its mesh, so airliners drew as white silhouettes and
military ones as amber. Models now use HIGHLIGHT: white leaves the mesh's own
colours as built, and the tracked and emergency colours tint the mesh without
hiding its paint. The IR boost still draws them flat white.
The two slots share one small request budget through one admit hook.
When one slot held it, the other's deferred tiles asked the Cesium globe
for a redraw every 250 ms, about four extra frames a second while tiles
loaded; before, they waited for the holder's tile, whose settling draws
the frame that asks again. Layers given the same admit now share their
waits: with one of their tiles in flight, nothing more is asked for. A
layer deferring while an unrelated layer loads still retries after 250 ms.
The two dense entries (cadastre from z14, sea depths from z11) were drawn
by Cesium only on globe tiles as fine as their minimum zoom, with their
minimum zoom tiles filling the coarsest of those. Through the globe port
they dropped the minimum level and refused every tile below it, so the
far band of a tilted view, one globe level coarser, was blank.
The imagery contract gains hiddenBelowMinLevel: a layer drawn nowhere the
surface is coarser than its minLevel. Cesium gives such a layer
minimumTerrainLevel as the library set it before (minLevel - 1 for Web
Mercator tiles on the geographic globe); the entries keep their minimum
level and drop the admit hook.
Cesium's KML loader shrank an icon's hot-spot offset with the icon and
turned a heading about the Earth's axis. The drawn pins kept the full
offset at globe distance (up to ~14 px off for the Google Earth pushpin)
and turned about local north, which differs in a tilted view. They now
scale the offset with the icon and turn about the Earth's axis by the
heading.
The contract gains offsetScalesByDistance: the pixel offset grows and
shrinks with scaleByDistance, as Cesium's pixelOffsetScaleByDistance does
with the same curve. rotationMode 'axis' now also turns by rotation, as a
Cesium billboard with an aligned axis and a rotation does. Cesium draws
both on its billboards; its GPU icons take the rotation and refuse a
scaled offset; the stub picks both. New conformance check
draw.icons.offsetTurn.
The double-click follow asked for the scene's input when a set was first
drawn. On a headless scene Cesium's event handler needs a document, so
drawing a trail or a pack threw there. Asking is guarded, as Directions
does: a scene that cannot take input has no double-click.
A click read the scene's exact pick at the tap. Through the input
dispatcher it read the click's id, which on a touch screen comes from the
wider contact search: a tap near a sighting selected it, and one near
another layer's contact kept the selection. It reads the exact top hit
again, as the shipwrecks and Local ADS-B layers do.
A click read the scene's exact pick and a drill at the tap. Through the
input dispatcher it read the click's id, which on a touch screen comes
from the wider contact search: a tap near a local aircraft selected it,
and one near another layer's contact kept the selection. It reads the
exact top hit again, as the shipwrecks layer does.
The coverage lines were one primitive per sequence, picked as the
sequence's id. Drawn in parts, a part after the first carries its own
#n id, which point-and-ask passed on. A hit whose item names the id its
parts pick as (meta.pick) resolves as that id, as the line's click
already does.
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.
Cesium's fov was saved and put back when the orbital view closed, so a
later resize or rotation kept Cesium's own behaviour. The exit held the
saved vertical angle through setFov instead, which the camera port kept
for the rest of the session: rotated to portrait, the view stayed
zoomed in. setFov(null) gives the field of view back: Cesium's fov as it
was before the first hold, the stub's own angle.
When a host stops animation frames, the panel drew from a timer with the
viewer's render(): the camera's flight and input, the clock's tick, then a
draw if due. Through the frame port it called renderNow(), which on Cesium
only forced a draw, so flights stood still, drags and zooms did nothing
and the clock stopped. renderNow takes {ifDue: true}: one tick of the
loop as its own would run it, drawing only a frame that is due (the
widget's render() on Cesium; the stub's tick without a forced request).
Each route was a primitive added when it was drawn, so it sat over the
networks of feeds loaded until then. Its draw set was made once and kept
the slot of the first route, so a feed's network loaded after that drew
over later routes. Each route is drawn in a set made for it.
The head was a polyline entity whose positions were read each frame. Its
draw-port line was redrawn at most every 100 ms while the aircraft flew,
so its end lagged the icon. It is drawn each frame the aircraft moves, as
the Flights trail head is; the trail still skips a head that has not
moved.
The 978 MHz ring was a point on the aircraft's own entity, so a pick on
it was a pick on the aircraft. As a separate points set it was drawn
unpickable and a click there fell through to what is under it. The rings
are picked again and read as their aircraft.
The pan used Cesium's QUADRATIC_OUT; through the camera port it took
cubicOut, the contract's nearest ease. The contract gains quadraticOut,
which Cesium maps to QUADRATIC_OUT and the stub camera computes.
The lines were one ground primitive per bucket, added free, slow, jam for
flow lines and jam, slow for heat-lines, so where roads cross the later
bucket drew on top. Through the draw port they were one set in kept order
(jam first), and its glow lines draw after its solid ones, which turned
both stackings over. Flow lines are now set free, slow, jam; slow
heat-lines go in a set made after the jam lines' set.
A view-bounded layer's features and a tile entry's coverage outline were
entities, which the default renderer's double-click followed (points) or
zoomed to (lines and areas); a new view replaced them and ended the
follow. As draw-port items they took no part in it, and the outline was
drawn unpickable. It is picked again, as its entities were.
The coverage rays and cap were polyline entities, which the default
renderer's double-click zoomed to, and the monitor plane a plane entity
with a position, which it followed until the plane was removed. As
draw-port items they took no part in it. The camera icons were billboards
before, so they still take none.
The selected station's highlight was a point entity, which the default
renderer's double-click followed; deselecting removed it and ended the
follow. As a draw-port point it took no part in it. The station dots were
point primitives before, so they still take none.
A pack's points and media marker were point entities, which the default
renderer's double-click followed; removing the pack ended the follow. As
draw-port points they took no part in it. Lines, polygons and images were
primitives before, so they still take none.
A trail was polyline entities, which the default renderer's double-click
zoomed to. As draw-port lines they took no part in it. Every trail on a
viewer shares one double-click handler, let go with the last trail.
A mark's ring, marker, areas and lines were entities, which the default
renderer's double-click followed (ring and marker) or zoomed to (the rest)
until the mark was removed. As draw-port items they took no part in it.
The cables, landing points and references were entities, which the default
renderer's double-click followed (a point, or a reference at its tip) or
zoomed to (a cable or area) until the sources were replaced or hidden. As
draw-port items they took no part in it.
The markers and outlines were entities, which the default renderer's
double-click followed (a marker, until the markers were drawn anew) or
zoomed to (an outline or hotspot box). As draw-port items they took no part
in it.
Each station, and the selected one's dot, was an entity, which the default
renderer's double-click followed until the stations or the selection were
drawn anew. As draw-port items they took no part in it.
Each camera was an entity, which the default renderer's double-click
followed, showing its card; a camera no longer shown, or a hidden layer,
took the follow with it. As a draw-port icon it took no part in it.
The stations were entities, which the default renderer's double-click
followed, framed to fit the disc; one no longer reported took the follow
with it. As draw-port items they took no part in it.
Removing a followed entity ended the default renderer's follow. A disc gone
from the feed, or a storm point gone from the advisory (or a cleared one),
now ends it too.
Each edition was drawn as entities, which the default renderer's
double-click followed (a pin) or zoomed to (a line or polygon); an expired
report or a replaced edition took the follow with it. drawnItemTarget reads
that rule off a draw item, for every layer that drew entities before.
Each aircraft was an entity, which the default renderer's double-click
followed, showing its tracked card; an aircraft that expired took the
follow with it. As a draw-port icon it took no part in it. A double-click
follow can now carry the holder whose entity record shows the card.
The places were entities, which the default renderer's double-click
followed; new results replaced them all, which ended the follow. As
draw-port items they took no part in it.
The advisory was drawn as entities, which the default renderer's
double-click followed (centre and forecast points) or zoomed to (tracks,
cones, outlines). As draw-port items they took no part in it.
Aircraft layers move their display delay a little every frame. Every frame
already reads the clock from the set, so a delay-only change now just asks
for a frame instead of restyling every row.
A fix that moves while the reported speed is 0 or stale used to leave the
aircraft frozen, then jump it kilometres at once. The step between fixes now
measures a jump, and the drawn speed bounds the recovery.
Selecting a ship re-centres the camera, so by the second press of a
double-click the ship is drawn elsewhere. The Cockpit remembers where it
was and still enters there. On Cesium it then kept the stock double-click
follow from running; on the input port the hold was taken only for a press
where the ship is drawn now, so the stock follow ran first and could let
go of the ship. A press where the ship was as the gesture began now holds
it off too.
The waterline probes read Cesium's scene sample, which takes the globe's
terrain as well as 3D tiles. On the ports they asked for tiles alone,
which hides the globe, so on a globe map a lake or river above sea level
went unread and the eye fell back to the sea. They now ask for the drawn
surface, as before.
Cesium raised moveEnd 500 ms after the camera last moved, following or
not: a followed target that moves keeps the eye moving, and one that
stands still (a marker, a parked aircraft) lets the move end once
the user stops orbiting it. The port never raised moveEnd while
following, so Weather, Recent Imagery, the share link and every other
moveEnd listener stopped catching up around a still target. The rule is
now the eye's alone, through the shared camera events.
The markers and the route were entities, which the default renderer's
double-click followed (a marker) or zoomed to (the route). As draw-port
items they took no part in it. Directions now joins the stock double-click
as launches and imported pins do.
A pick resolves to its context record through the drawn item's meta. The
ALPR and local ADS-B icons carried none, so point-and-ask got the layer
name and no position instead of the camera or aircraft and where it is.
Each icon now carries its context carrier, as before the draw port, when
the pick was the registered entity itself.
On Cesium the overlay sampled the drawn surface only where the scene
supported height sampling (depth textures), and fell back to the globe's
terrain only while the globe was shown. On the ports, a renderer without
sampling spent the paint's sample budget on misses and the refine pass
kept asking every paint, and a hidden globe's stale terrain could anchor a
marker under photoreal tiles. Both rules are back, through the renderer's
sampleHeight capability and the globe's visibility.
The overlay replaced floor anchors with sampled surface heights only once
the surface had settled. On Cesium that was the globe's terrain while the
globe was shown, otherwise every shown 3D tileset; on the globe port it
became the terrain and the drawn base tileset together. It now asks the
globe port for 'surface', the same rule.
On the draw port, a Data Library dataset's polygon and line edges were
drawn as geodesics and every feature took the entry's colour. The loader
drew ground edges along rhumb lines and honoured a feature's own
simplestyle fill, fill-opacity, stroke, stroke-opacity and stroke-width,
with a colorBy fill over them. The library now uses local GeoJSON's
rhumb densifying and simplestyle reading for the same result.
Civil and military aircraft were drawn a fixed 30 s (15 s) behind real time
while anonymous feed reports arrive about 90 s old every 30 s, so every
contact dead reckoned about a minute past its newest report and snapped
when the next one landed (several km on a turn), and the tracked trail,
recorded from those drawn positions and patched as reports arrived, kinked.
- The display delay (data/displayDelay.js) is the 90th percentile of the
newest 256 report lags plus 5 s, between the layer's floor (30 s, 15 s)
and five minutes, slewed at most 0.2 s/s up and 0.05 s/s down. Icons,
the renderer's live motion clock, labels, HUD, detection, the tracked
camera and the trail read the one delay; following the world clock
draws with none and deliveries leave it alone.
- Between two reports an aircraft flies a biarc (data/fixCurve.js) that
passes through both and leaves each along its track, sent as contract
arc segments; the trail is the reports joined along the same curve, so
the icon sits on it. Nothing drawn between reports is kept.
- A report a coasting contact missed is eased onto from where it would
have been that frame (at least 3 s, at most 30% over its speed, within
20 s); over 5 km it jumps. Past its newest report a contact coasts
straight on: a turn rate averaged over earlier reports outlived the turn.
- Forward synthetic fixes no longer block real reports older than them,
and a history keeps 24 fixes.
- A feed simulation (testSupport/aircraftFeedSim.mjs) checks both layers
against a 90 s late feed, a fallback switch, repeated reports, outages
and the world clock.
Points too close together on screen are grouped by
geo/screenCluster.js as the default renderer's entity clustering grouped
them. Its range queries ran on a uniform grid sorted by index, while the
reference queries a KDBush tree, so a cluster kept as the eye came lower
could list its stations in another order, and a click on it played a
different station. The index is now KDBush, built as the reference builds
it, and kdbush is a declared dependency (it already came with the globe).
The package boundaries list kdbush as external wherever screenCluster is
owned, and own src/viewSky.js beside src/viewWeather.js.
Voice's in-view scan projects each context record's targetPosition. News
and Wildlife Sightings still set only the entity's base position, so both
dropped out of "what am I looking at". They now pass it as targetPosition,
as GeoJSON and FIRMS do.
The loader's entities drew a polygon with per-position heights through a
lit appearance; through the draw port it went flat. Local GeoJSON and
submarine cable fills with heights pass lit: true, as file import does.
The car, van, fire truck and pushback tug were stacked boxes. The car is now an
operations SUV (rounded body, glass house with a sloped windscreen, roof light
bar, grille and lamps), the van a high-roof panel van, the fire truck an airport
crash tender with roof and bumper turrets on three axles, and the pushback a low
chamfered tug with a glazed cab. All stand on the ground at their built size.
Their trail anchors are measured again.
Feeds carry many airport ground vehicles (type ZVEH) and ground stations
(GRND) that were drawn as the generic plane, some at the 10 km airborne
default.
- types.json gains aircraft_callsign rules: a ZVEH callsign starting FIRE is
a fire truck, PUSH/TUG a pushback tug, DEICER/SQUID/SQB a van, else a car.
GRND draws a new 11.8 m radio mast (other/radio_mast.glb).
- resolveAircraft and aircraftModelSpec take the callsign; a matched rule
names the model outright, ahead of the type's class model.
- The layer spec cache keys such types by the rule matched, so it holds at
most one entry per rule.
- These models (catalog category `other`) draw at their built size, as such
models already do, and a
contact with no altitude whose model is one now stands on the ground; the
feed's own type is kept for such contacts, as no airframe lookup knows it.
- Local ADS-B passes the callsign too.
createViewSky sets globe.sky from the panel's switches and Milky Way
slider and keeps the choice for the next visit; what the user has not set
stays as the renderer draws it. Distance fog stays with the styles that
switch it.
The session snapshot recorded a user's switch only after the CCTV panel had
already rendered the layer off, so a first switch-off by the user inside
Contacts, or after a partly failed restore, still kept the panel open.
Context controls now hold the layers _clearLayersOutsideContextMode is
switching off while its transitions run; suspendsLayer reads that set, and
the snapshot is no longer consulted.
- A frame with no speedMps gets an exact anchor: an inertial one ran on at
zero speed and closed at 0.75 m/s, so the camera fell kilometres behind a
moving train. The docs example now passes speedMps and anchor: 'exact',
a name for its HUD, and isEntryAllowed for a train bound to its line.
- Transit's snapshot height is the floor where playback draws the vehicle,
not the newest report's floor uphill, and null while that floor is cold,
so a view waits for the surface instead of standing on the ellipsoid.
- Rail's direction follows playback once it has placed the train: a report
that runs back (a reversal, or GPS jitter) no longer turns the view
while the drawn train still runs forward.
- A frame's id is trimmed as the candidate's is.
- A double-click on the selected vessel no longer enters an application's
subject that took entry after it.
- The docs import from gods-eye-view/..., the package's name.
An inline panel that lost its WebGL context showed the panel runtime's own
notice and, over it, an alert dialog with no buttons that it could not act
on. With allowReload false a lost context now clears the notice and shows
none, as the docs already said. keepPanelRendering no longer logs render
errors itself: the render failure notice logs each one. Name the Cesium
private fields finishRaise and reportThrown rely on, and the version they
were checked against.
Turning a layer on does not leave Contacts, so a user could turn CCTV back
on inside the mode and off again; the layer was still in the session
snapshot and the panel stayed open on an empty frame. The snapshot now
records every layer the user switched during the session, and
suspendsLayer is true only for a layer isolation switched off that the
user has not touched since.
With atmosphere, fog and lighting off and clear weather a renderer applies
none of its look, so draw.models.tint, draw.models.blend, globe.base.vector
and globe.imagery.video set that sky first and test what they draw, not a
renderer's sky light or tone mapping.
globe.sky switches parts of the sky on and off; how the sky, atmosphere,
haze, lighting, tone mapping and exposure look is the renderer's own, and
no check compares colours. globe.weather's clouds is the fraction of the
sky covered; clouds are placed by scene time and the wind and shade the
ground under them where the sun lights it. New conformance check
globe.weather.sceneTime.
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.
Contacts and Space Missions switch CCTV off to isolate themselves and restore
it on the way out: the panel and its share preference now stay as they are for
that round trip, as they do for Clear selected data layers. The controls no
longer read the collapsed class before asking: the panel chrome tells a panel
the accordion folded from one whose saved state is closed.
The camera controls gate asserts the collapse, reopens CCTV from the right
rail before switching it back on, and runs a Contacts entry and exit with the
panel open.
The panel opened itself when a camera became active, but nothing closed it
when the layer went off: it stayed expanded, empty, and its meta line still
described the last camera. The collapse runs only on the on-to-off change, so a
panel opened by hand while the layer is off stays open, and a context-mode
layer clear keeps the panel as Radio does.
Four test files built the same widget on CesiumWidget.prototype, viewer
proxy, store and notice; renderLoopFixture.mjs now does it once. The notice
test drives Cesium.Event instead of a hand-made double. frameEvents() drops
tileset.tileLoad, which Cesium raises inside its own error handling, and the
notice no longer guards a viewer without a canvas or requestRender.
The fleet models (#1714) draw nearby trains and vehicles under the 3D toggle. A
held one now leaves out its model as it does its icon, as the Vessels layer does
for its bridge subject: its model item is hidden, and handing the visual back
to its icon keeps the icon hidden while held. Tests drive each layer with the
real fleet-model layer and a stubbed glTF loader; both fail without the fix.
Most live vessel feeds send no length, and the resolver then fell through
every length rule to the range's last model drawn as built, so a cruise
ship or a container ship showed as the smallest model of its range.
types.json gives each passenger, cargo, tanker, fishing and service range
a typical_len (cargo 300 m, tanker 250 m, passenger 140 m, fishing 40 m,
...); a vessel with no usable length is chosen and drawn at it.
Comments keep only the why: the loop-running flag, the mid-raise events and
the one-time canvas focus. The CURRENT-STATE section lists behaviour and
pitfalls instead of retelling the code, and no longer says every tileset
event is raised outside Scene's error handling.
- 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.
Flights, Military Flights and Local ADS-B draw each aircraft with the fleet
model its ICAO type, class or emitter category selects, scaled to the type's
length, built from the up-front loaded bytes. The eight third-party aircraft
models and their attribution are removed; every shipped model is now the
project's own.
121 GLBs under public/models/fleet (about 2 MB, MIT like the code) with
catalog.json and types.json. src/data/fleetModels.js picks a model by ICAO
type, aircraft class, emitter category, AIS ship type and size, GTFS route
type, transit mode or rail category, and sizes it life size; the set loads
once, up front. Trail anchors are measured from the meshes.
Reviews the 474 strings that 27 pull requests added since the last
review, in all twelve catalogs, and fixes what the review confirmed:
wrong agreement when a placeholder takes a neutral value, plural-less
counts that read "1 sightings", terms that differ from the glossaries,
and typography the language guides set. Also applies most of the
findings earlier reviews left open.
zh-Hant is converted from zh-CN again. The new strings had been
translated separately with Taiwan vocabulary. The zh-Hant guide lists
two more characters OpenCC picks wrongly.
Three tests expected the old German and Spanish wording.
The camera starts with the whole Earth in view, looking straight down,
instead of flying in to Austin. A shared link flies on from there. A
different start, a city for instance, is set with the startView option
of createApplicationControls. The Cesium renderer and the test stub now
start from the same pose, so state that carries over from the first
frames (screen clusters, marker selection, label placement) no longer
depends on which of them drew it.
- Cesium's own tweens (its flights) step on the renderer's clock, so the
flight traces compare frame by frame; dispose gives the scene its own
clock back.
- moveStart and moveEnd are measured each tick on that clock, by the
shared move detection, a change of the field of view or aspect
included; Cesium's own events timed them by the system clock.
- A follow of a drawn item tracks where the draw port draws it.
- Pick rays are summed from the eye's axes: Cesium's lose about 1e-9 of
direction at a near plane of 0.1 m. Ellipsoid picks and the view
rectangle use them; a canvas with no size has none, as in Cesium.
- The harness always runs the virtual clock and claims 120 checks: 119
pass on the page and query.heights skips. The five pointer traces
need a camera controller there, and are recorded from Cesium's own
controller in Node.
- The package boundaries list the cesium plugin export and the modules
its groups now import.
Cesium draws BlendOption.TRANSLUCENT billboards in the opaque pass,
blended, LESS_OR_EQUAL with depth written, so overlapping ones stack in
their order, the last on top; in the translucent pass the scene's
order-independent blend averages them. A translucent GPU icon set now
draws its one pass there too, with the depth function Cesium names
LESS_OR_EQUAL (LEQUAL is not one of its names, and fell back to LESS: the
first row won). A set's blend no longer moves the commands of a
collection built translucent into the translucent pass.
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.
createCesiumRendererPlugin({cameraController}) (render/cesium/plugin) puts
the camera port on the shared camera controller over a native camera on
Cesium's (controlledCamera.js): poses written exactly, out of any lookAt
transform, the vertical field of view as Cesium's wide-side fov and kept
on a resize. Cesium's own controls hold their input off and their
collision off while it drives; the controller runs before and after the
preUpdate listeners, and what it throws is reported. A followed item's
position is where its GPU icon set draws it (drawnPosition), and the
input port's camera holds are the controller's.
The conformance harness, given a controller, steps a virtual clock 1/60 s
a frame for ticks and pointer events, so flights and pointer scripts are
compared frame by frame.
An application subject's camera step is now capped at its own update
interval plus 0.1 s rather than at 0.1 s, so at 500 ms its heading slew,
ground lift and anchor correction run at their configured rates; a long
stall still moves it no further than one late update. The built-in
views keep their 0.1 s cap.
When groundClamp turns false the lift the floor gave goes at the rate
it came, not at once. A HUD view with no speed has no speed readout,
and a progress line with no summary is hidden from assistive
technology instead of being an unnamed image.
A ride let go with restore focuses its train again. When the train's
category was turned off during the ride, or for a copy another feed draws,
focusTrain selected and followed a train with no marker. It now returns
false for a train in a category turned off or hidden as another feed's
copy, and leaves the selection and the camera as they are.
The duplicate filter hid a held copy when another feed's copy outranked it
and moved the selection away, so the held train stopped playing and the
other copy's marker and card came back over the view. A copy a first-person
view holds is now drawn whatever the scores until the view lets go; the
better copy takes over at the next poll after the release. Holding a copy
that another feed drew draws it at once.
A category toggle no longer deselects a held train, and a held train keeps
playing, its marker hidden, while its category is off. Released, it is
deselected and stops as the toggle leaves any other train.
Says so where the cockpit subject section names them, together with
path.line, and that a snapshot read again while nothing changed is the one
read before, so a provider may read one on every update.
The copy keeps the path's fields with its number arrays as frozen arrays,
so pointAtS and projectOnPath read it as they read the path and nothing
written to it reaches the layer. It is built once per line and shared by
every snapshot on that line, so reading it on every frame costs nothing.
getSelectedTrain, getSelectedVehicle and getCockpitSubject fill drafts and
freeze a new object only for a part whose values changed, so a view that
reads them on every frame builds nothing while the train or vehicle stands
still, and a moving one keeps its feed, stop and provenance objects. A
train's stops are copied once per list the stops provider returns, each
stop a frozen copy, instead of on every call.
Provider methods and worded members are called on the provider itself,
so a class-based provider works. A hold that answers false refuses entry
and is released; any answer but true or false refuses it too, released,
with one warning. An answer whose `then` getter throws is handled as a
throw, and a text cut at its cap never leaves half an emoji.
- A subject with no height at all waits at most
COCKPIT_GROUND_WAIT_TIMEOUT_MS for the floor, its HUD updating and
reading ACQUIRING SURFACE; then the view ends and the provider gets its
subject back (there is no height of its own to fall back to).
- A hold that returns a promise is refused as before and released again
once it settles, unless that subject is being ridden by then; release
must tolerate a second call.
- Rail and Transit stamp selectedAtMs only for a user's selection (a click,
focusTrain or focusVehicle); a deselection clears it, and a train or
vehicle selected only by a hold reads null.
- Labels, entry face and look may be functions, read again on every use
and on a locale change; a failing read keeps the last good value.
- A frame with no height keeps the eye's last height, or waits
(surfaceAcquiring) until the floor is known; heights outside
-1,000..50,000 m read as null.
- Provider methods are synchronous: a returned promise is refused like a
throw, and a hold that fails is released.
- A candidate may carry selectedAt; Rail and Transit stamp selectedAtMs
on every selection, so re-selecting moves a subject to the front.
- A released Transit vehicle leaves the visible set at once.
- docs/CURRENT-STATE.md states the new entry order; docs/APPLICATION.md
documents cockpit subjects, ./i18n/locale and ./layers/rail/paths.
GEV itself registers no new subject: with no provider, the Cockpit offers
aircraft, satellites and vessels as before, except that the most recently
selected of them now wins entry.
- services.cockpitSubjects: providers ({kind, layerId, entryFace, priority,
isEntryAllowed, read, hold, release, hud}) are checked once by the
coordinator; frames and HUD views on every update; a throwing provider
ends its view or keeps the last HUD.
- Entry: the most recently selected subject wins, across all kinds.
- Camera: a frame may turn the ground clamp off, anchor exactly on the
subject and update every frame.
- A generic HUD: kicker, title, cards, always-visible source rows, banner,
a veil with light streaks (off under reduced motion) and a bottom
progress line whose close ticks merge.
- Text comes from the provider, already in the page's language
(./i18n/locale: getLocale, onLocaleChange).
- Rail and Transit read and hold APIs (getSelectedTrain/Vehicle,
getCockpitSubject, setCockpitSubject, focusTrain/Vehicle); a held
train's marker, card and route line are hidden, and its feed keeps
polling while held.
- ./layers/rail/paths is exported.
An image material loads its image on its first draw, and an atlas slot
given a new image no longer holds the old blob, so a hidden fill, pattern
or quad built from a slot could lose its blob to collection, its URL
revoked, before it was ever drawn. Each material built from a blob (shape
and ground image fills, line patterns) and each quad now holds the blob it
draws while it lives.
A video whose seeks never ended stayed seeking, so every frame seeked it
again and waited out the timeout behind the others, and it was never
replaced. A seek that times out now lets the video go, so the next frame
loads a fresh one. A video that failed to load or to give its length
fails its frames at once for 3 minutes instead of being downloaded again
for every tile.
A colour the canvas cannot read, a keyword its property does not take, or
a number given as a string was handed to the canvas, which ignored it and
drew the last feature's style. Colours now go through parseColor (which
now knows every CSS colour name), keywords are checked against their
property's values, and only finite numbers are numbers; anything else is
the property's default, as MapLibre coerces it. The style's background is
read the same way, so a value it cannot use is black at opacity 1 rather
than no background.
A grey block 300 m tall, seen from 3.3 km south and 1.5 km up looking
north: the wall facing the eye must be brighter than half its colour, as
the renderer's own lit solids draw it, and its top must shade unlike its
wall. It reads pixels, so the stub skips it.
Cesium cancels none of an imagery layer's requests itself; the port's
layer cancels its requests in flight as it is removed, which is what the
provider's cancelled check sees. A test now goes through that path.
A paint or layout value that throws for a feature (a type that does not
fit, step or interpolate over what is not a number) or comes to null,
undefined or NaN is now the property's default, and a legacy function's
miss is its default, else the property's; only a filter that cannot be
evaluated leaves the feature out. The canvas still never keeps the last
feature's colour or width. A background colour given as rgba numbers is
the style's background rather than none.
After a seek timed out its video already had the target time, so the next
frame skipped seeking and drew whatever showed as a finished tile; a video
still seeking is now seeked again. The seek past its end that learns a
video's length waits 60 s, not the 10 s of a frame's seek, and a video whose
load or length probe failed is dropped, so the next frame starts over
instead of failing until the video is evicted.
Revoking a URL idle for a minute broke two things: the icon atlas, keyed by
URL and never freeing a slot, took a new slot each time a blob was drawn
again until it had no room; and an image material, which loads on its first
draw, made hidden and shown later fetched a revoked URL and never drew. A
blob now keeps one URL, revoked by a FinalizationRegistry once the blob
itself is collected: anything that can still draw it holds it.
An unawaited setBase with photoreal and imagery, followed by another,
added its imagery after the later call had set its own, leaving both.
The imagery now goes in before anything is awaited, as the Cesium port
adds it, and an overtaken call resolves settled: false.
draw.shapes.clamped picked only the outlined rectangle and the extruded
ellipse; it now also picks the outline-only rectangle on its rim and the
wall on its face, seen from the south. The stub picks both: a clamped
outline along its ring as a draped line of its outline width, a wall where
its panels cover the pixel.
globe.base.vector also draws roads whose join and cap are legacy zoom
functions of strings, checks that a style with no background shows the
globe through rather than black, and ends by switching to a base without
the vector style, which must draw none of it and drop its credit.
The object URL store keeps its blob alive, so a blob image's URL, never
revoked, kept every blob ever drawn. A blob's URL is now revoked once it has
not been asked for in a minute with two frames drawn since (so a material,
which loads in the next frame, has started its load); images already
loading or loaded are unaffected, and a blob drawn again gets a new URL.
An evicted (or cleared) tile video is emptied, so it never loads or seeks
again, and every frame queued on it waited forever, leaving its tiles
never finished. Letting a video go now fails what waits on it, and a seek
that does not end within 10 s fails its frame.
The wrapper that marks a clustered set for clustering again ran before
setColumns was assigned, so column changes never reclustered; with no rows
moving, positions or shown written by columns left the old clusters drawn.
setColumns is now assigned first and wrapped with the rest.
The provider said it had no alpha channel, so a style with no or a
translucent background drew black there. And its requestImage ignored the
Cesium request, so tiles of a removed layer were still painted once their
source tiles arrived; a cancelled request now aborts the paint.
- A legacy function without a type is exponential only on a property that
interpolates and interval on any other (line-join, text-transform, ...);
a property function with string outputs is no longer categorical.
- step over what is not a number fails, leaving the feature out.
- has, get and legacy filters see a feature's own properties, never
inherited names such as toString.
- A value that comes to null, undefined or NaN leaves the feature out
instead of being written to the canvas, which ignored it and drew the
last feature's colour or width.
- A layer's labels are placed in their features' order, as MapLibre
places them, not reversed.
A vector setBase awaited its style before changing anything, with no
generation guard, so a slow earlier call landed over a later one, and one
in flight at disposal rejected. Cesium and the stub now count calls like
setPhotoreal and setTerrain, abort the overtaken style load, and resolve
an overtaken call with imagery: [] and settled: false.
src/render/vectorBase/ is a Cesium-free painter: loadVectorStyle loads
a style and its TileJSON sources and compiles its layers (skipping, with a
reason, what it does not draw), and paintVectorTile paints a Web Mercator
tile on a canvas: background, fill, line and circle layers with filters in
both syntaxes, legacy functions and a listed subset of expressions, and
symbol text labels placed clear of each other inside the tile. Sources are
decoded with pbf and @mapbox/vector-tile, already dependencies. The Cesium
port loads the style before changing the base, draws it as Web Mercator
imagery under the base's other imagery, credits its sources, and claims
vectorBase; the stub loads the style. globe.base.vector serves a style and
tile from data URLs and reads the drawn fill.
clusterScreenPoints over each GPU set's shown rows at the frame's
motion-clock time (on their ground when clamped), the members' rows hidden
and one icon a cluster drawn at its seed's size in the set's cluster
billboards, picked as each member. Clustered again after the camera moves
or the set changes (setColumns included), and every frame while rows still
move. Conformance checks take several capabilities; draw.motion.cluster
clusters members that come to rest on their segments.
Each row reads its extras from a float texture by instance (texelFetch on
gl_InstanceID), so the 16 vertex attributes hold: pixel offset, vertical
anchor, screen rotation and aligned axis (turned as billboards turn),
fadeByDistance, displayRange, and a ground mode with the heights under its
segment's two ends. Clamped rows are sampled after a frame draws, budgeted
across the port's sets (terrain first, then the drawn surface), and again
when the globe's tiles finish loading. WebGL 1 still refuses these; GPU sets
still refuse clustering. The stub picks icons offset, anchored, turned and
clamped to its ellipsoid, and draw.motion.look checks each on a moving icon.
The icon moves past its own width in about a quarter of a second, and a
new renderer's first frame can come that late: the check now reads where
it should be from the wall time after that frame, its delay and its
'not at wall time' unchanged.
The tiles the globe last drew are a private Cesium field: read through
globeTilesDrawn, whose field the internals test checks the installed
Cesium still declares.
A shape with an image fill and animate is no longer refused: the fill's
alpha pulses through its image material's colour, on the surface or
clamped, as colour fills pulse.
A windStreamlines grid short of 360 degrees of longitude is no longer
refused: the paths seed inside its rectangle, equal-area, and stop at its
edges. The baker takes the rectangle as optional bounds; a grid round the
globe bakes as it did.
A draped line in the inertial frame is no longer refused: it is held as
given, drawn turned into the fixed frame where its motion clock has the
sky, and draped again each second of that clock, the old ground line
kept until the new one is ready.
A clamped outline with animate is drawn with a colour material, its rings
sharing one colour, and pulses its alpha through it each frame as the
shape's fill does.
Sets other than icons take setColumns as the rows the columns make over
the items they hold, replacing every item as set does, as the stub does,
so renderer.shape holds on Cesium and joins its checks.
A layer given a timed source hides its own imagery and draws the frames
its clock shows (the scene's time, or setFrameTime on its own clock) as
Cesium layers just above it: the nearest frame, or in blend mode the later
over the earlier at its share of the way, with the next prefetch frames
loading unseen at alpha 0. Video segments are seen every 250 ms, each tile
its video seeked to the time's share of its length. frameReady names the
nearest frame once every globe tile drawn shows its own imagery. The
check globe.imagery.frames now runs on Cesium, and globe.imagery.video
draws a recorded video's frames.
Each frame drawn, a set's host turns the draw commands it gave to the set's
blend before the scene sorts them: opaque draws every command in the
opaque pass unblended with depth writes; translucent alpha-blends every
command without depth writes; additive adds colour times alpha without
depth writes, still depth-tested, after the opaque commands and before the
order-independent translucent pass. Ground commands only blend
differently. Lines, shapes, models, quads, meshes and GPU icons take every
blend, live through setOptions (models do not load again); GPU icons no
longer refuse opaque or additive. The contract documents the semantics and
the checks draw.sets.blend and draw.models.blend read the pixels. The
package boundaries own setBlend.js and screenCluster.js.
Clustered icon sets cluster with clusterScreenPoints over the shown icons
each frame drawn after the camera moves or the set changes. A cluster draws
one icon (icon(count), else a count badge) at its members' mean in place of
the members; a pick on it answers each member, seed first, at the cluster's
position. GPU icon sets refuse clustering. The stub clusters the same way,
the contract documents the semantics, and the check draw.icons.cluster
covers it.
Clamped outlines were refused; they are now draped lines, a ground polyline
a ring (a polygon's rings, an ellipse cut in 64, a rectangle's turned
corners) under the shape's pick id. Clamped extruded shapes, clamped walls,
and clamped image fills where the scene has no depth textures were refused;
they now stand on the surface unclamped, the surface height read when the
set is built (an extrusion from the lowest point under it, a wall's foot
under each position). The new conformance check draw.shapes.clamped draws
each kind; Cesium runs it.
Segment colours and shows were drawn on draped solid lines only. Any other
segmented line (3D, geodesic or draped; glow, dash, arrow, flow, pattern or
an outlined solid) now draws a primitive a segment, each with its style's
material in the segment's colour under a pick id that reads as the line's,
recoloured and shown in place; an arrow's head is on its last segment, and
a revealed line shows each segment by its share of the length. Draped
pieces swap in with the set's other ground primitives. Pattern lines drape
on a ground polyline of their own, and an inertial line with a depth-fail
style is a primitive turned with the sky each frame. The new conformance
check draw.lines.segmentStyles picks shown and hidden segments of five
mode and style pairs before and after an in-place change; Cesium runs it.
With EXT_disjoint_timer_query_webgl2 the Cesium renderer lists gpuTiming:
while frame signals have listeners, each drawn frame is timed from preRender
to postRender and a signal carries gpuMs of the newest timing back (a
disjoint one is dropped); queries are reused and let go on dispose. Without
the extension it answers 'none', as before. The new conformance check
quality.signals.gpuTiming pins both; the stub's timed frames carry 0 ms.
Cesium's models already take the atmosphere's scattering, in the stage that
draws distance fog; the capability now says so, and the contract doc says
it follows the sky's fog setting there.
An autodetect follow already rode Cesium's AUTODETECT tracking frame; the
capability now says so. The new check camera.follow.autodetect follows a
still target (range kept, its frame east-north-up on it) and one at orbital
speed (range kept frame by frame, its frame on the target with z up); the
stub and Cesium both run it.
Icons on billboards and on the GPU, line patterns, shape fills, quads and
raster shells take a URL, SVG, a blob (one object URL per blob), a keyed
canvas (packed into the GPU icon atlas as it is, by its key) and an atlas
slot as the image it holds. Blobs and canvases were refused on the GPU
path, blobs on billboards, and atlas slots everywhere but billboards. The
new conformance check draw.icons.images draws each kind on still and
receding icons; Cesium runs it.
The shared transparent tile kept a rejected encode, so every later empty
tile failed with it. A failed encode is now dropped and the next empty tile
tries again.
imageryLayer.lit (a layer shaded by the sun) joins the look with surface
shading. roleOf answers undefined for a member its port does not have, and
the port's own role without a member. The test now fails when two roles
claim the same entry.
ROLES sorts every member of PORTS into one of six roles: the Earth (streaming
and building the globe from map sources), scene contents, camera and input,
world queries, the look, and the host and frame loop. The ports follow the
API's shape; the roles say what the engine behind them does, and that the app
keeps the data while the renderer owns everything from a source spec or a
draw set down to the pixels. roleOf resolves a member to its role, the most
specific entry winning. No member changes; a test keeps every member in
exactly one role and every entry naming a real member.
The contract's TerrainSpec gains quantizedMesh terrain: Cesium's tile
format in the folder at its url, heights above the ellipsoid. Without an
ion key the globe-port map engine asks for Re:Earth's keyless terrain as
it, where it asked for the ellipsoid, so the renderer
draws the same ground; without the terrain capability keeps the
ellipsoid. Cesium's globe port draws it through CesiumTerrainProvider with
the keyless terrain's retry policy.
A weather frame source's regional tiles reach the renderer through the
imagery layer's fetchTile, drawn and handed over as PNG bytes, a null tile
one shared transparent tile; the camera-owner watch listens on the
renderer's canvas.
Its last turn was kept when it came back into view, so a vehicle that
left the view while the camera moved, and came back after the pass for
the camera's new pose, kept the turn from the old pose until the camera
moved again. Coming back into view now clears its last turn.
The rotation pass reprojected courses only when the camera moved, a poll
marked a course, or a vehicle was moving. A vehicle that entered the view
or was shown on a later visibility sweep (its ground height arriving
after its poll) kept the icon pointing up until one of those happened,
under a camera that held still. The visibility sweep now marks the
rotations for the next pass when it changes what is in view or shown.
The shipwrecks layer reads the click's top hit, as it read the scene's
exact pick before, not the touch contact search's wider hit: a tap that
misses everything near a wreck selects nothing, and a tap near another
layer's contact closes an open wreck card.
A badge's count image is sized by the renderer's own resolution scale
(its quality port's pixelRatio, 1 while that is browser recommended), as
the other icon sets are, not by the device pixel ratio.
Past its fix a coasting aircraft or military icon is never drawn lower
than COAST_FLOOR_LIFT_M over the ground the layer's floor cache knows,
as floorCoastedPosition keeps the tracked one. The renderer cannot read
that ground, so the planner reads it along the coast arc and plans the
coast in pieces where the ground rises under it: the arc as it is while
the ground stays clear for the lookahead, one-second pieces of the same
arc lifted and climbing where the ground lifts it, and a lifted hold
once the coast is over. Unknown ground is read again on the next plan;
a coast from above any terrain is never read.
When the control that had focus is gone or cannot take it, focus went to
the #cesiumContainer div, where Enter no longer finished a drawing. It now
goes to the globe's canvas, which the map's keys read as the map; the canvas
is focusable only until focus moves on or the globe is pressed. A control
disabled while the notice was up no longer leaves focus on the page, and
neither focus call scrolls.
- An error a frame of the inline panel's timer throws no longer reaches the
host page; it has been raised as a render error by then.
- An error Scene raised and threw on (rethrowRenderErrors) is raised once.
- After a lost context, later render errors are only logged, so the notice
keeps saying why.
- A render error without a value shows no detail.
- The globe's tile load progress and the scene's tileset load events are
finished too when a listener's error cuts them short.
- Focus goes back where it was when the globe draws again, or to the map.
- The appearance counter and the guard for a missing viewer are gone.
Tests cover every finished event, a thrown timer frame, a single report under
rethrowRenderErrors and the focus return; the inline tests share one setup.
The notice sat at z-index 1001, under the Québec camera viewer (2000), which
covered its text and, with video playing, its buttons on a phone. It now sits
at 2001. On touch screens its buttons are 44 px tall.
A source's contextGeneration tells the probe the same context was lost and
restored; it then makes its GPU objects again instead of drawing with dead
ones. A depth reader that throws turns the test off for a while instead of
throwing out of add(). Batches whose control point never answers count as
failed ones, so a query path that never answers stands down and is rebuilt
on the retry.
The GPU probe behind query.occlusionTest no longer depends on Cesium: a
renderer hands it the frame's depth through readSource (a DepthSource), and
createDepthOcclusionTest builds the query port's test from it. Besides depth
packed into RGBA8, as Cesium keeps it for picking, it reads a depth texture
(encoding 'depth', on the GPU only), and log depth with no near plane decodes
too. Cesium's sceneOcclusionProbe.js keeps only its scene
reader. Exported as gods-eye-view/render/occlusion.
A renderer plugin may supply applicationHooks(renderer) for what only its
renderer has (map engine, own credits, stale commands, QA handles). What every
renderer should do moves onto the contract: controls.keepEarthFramed (behind
the keepEarthFramed capability), query.occlusionTest (behind occlusionTest),
and panel drawing, which keepPanelRendering now does through resize and
frame.renderNow through the contract. renderNow throws when the frame fails to draw.
The Cesium port installs its zoom-out guard through keepEarthFramed (a setView
no longer cancels its turn) and answers occlusionTest with the scene's probe;
the stub answers it with a horizon test.
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.
- Every placement of Cesium's credit display (above the command dock, the
Minimal HUD's corner, clean view and recording, the phone tab bar and an
open sheet) has the same rule for the application's line; a test keeps
each stylesheet's pairs together.
- A credit's logo is drawn in place of its text, which names it (the
image's alt), as Cesium shows logo credits; the contract's Credit says
so. Links open with noopener and noreferrer; a list that empties while
focus is in it hands focus back to the line.
- A stack that stays after any failed switch (a tileset or imagery that
fails to load, or a photoreal base that fails to come back) still falls
back on its tile failures: the controller binds its listener again for
that switch where it handles the failure.
An undraped line in the polyline collection that moved was given a new
array of Cartesians, one new object a point. One that moves by as many
points, not geodesic, now has its new positions written into the points
its polyline draws, which the polyline then takes again: the range ring's
fronts, stepping out every interval, make no new points.
Cesium's camera measures each of heading, pitch and roll by moving the
camera into the eye's east-north-up frame and back, recomputing its
matrices twice each time. In 3D the pose now reads that frame once, takes
the eye's direction and up into it as Cesium's inverse transformation
does, and puts them through Cesium's own formulas: the same heading, pitch
and roll to the last bit or so, and the camera is left as it was. Other
modes still ask Cesium. The camera's matrices are copied straight into
their arrays.
The credits port compared every drawn frame's Cesium credits with the last
frame's by listing them: a sorted copy of the frame's credits, a set and a
string of ids, after every frame. It now first compares what that list is
made from, value for value (the logo, the static credits and the frame's
own, each with its count and placement, and which are the page's), and lists
them only when one of those changed. Most frames owe what the last owed.
- On a renderer whose plugin does not show its credits in a display of
its own (the ownCreditDisplay hook; Cesium's does), the application
shows what the credits port lists at the bottom left (#gev-credits):
inline credits on the line, the rest, the layers' data credits among
them, in the Data attribution list it opens. The button and list are
keyboard operable; Escape closes the list and returns focus. Text is set
as text; links and logos keep only safe schemes.
- The panel, Cockpit and overlay layouts keep clear of it as of Cesium's.
- The stub boot check fails when the credits line is not shown or its list
is empty; it keeps its report when the run stops early, counts only the
dev server's providers and other origins as feeds, and a failed default
renderer load is retried without dropping a newer one.
- When showing the photoreal base fails and the stack before it stays,
its tile-failure listener is bound again for the switch that kept it,
so Esri's OSM fallback still runs.
- The Cockpit test of a ride handed to another aircraft checks that the
follow's change adopted it (the Cockpit took the camera).
- The tests that faked a follow by setting the viewer's tracked entity,
or by raising its change event, follow through the camera port
(followEntity, or a port with follow and followChanged), and check
followedOf: camera handoffs, globe rotation, tilt, ground guard,
vessels, ALPR, CCTV, Contacts, radio, orientation, share links and
follow offsets, the tracked readout and the shell's camera listeners.
- The fake Cesium camera port delivers followChanged from the port itself.
- A ride handed to another aircraft is adopted by the follow's change, as
the application does, not by the test calling the adoption.
- The unbound-factory record lists the scene, the map defaults, share
restoration and the World Packet as entries whose caller loads the
factories; the map startup test stubs the default renderer load.
- The map source controller waits for a base that loads as it is shown
(the globe engine's tilesetReady) before it takes the stack before it
down: one that fails throws there, so that stack and its imagery stay
and the error is reported, as from any failed switch. The Cesium map
engine has no tilesetReady, so its switches are unchanged.
- A failed default renderer load is tried again by the next call, and
the standalone page's early load does not report a failure nobody
awaited yet.
- The adapter ratchet's on-demand import rule refuses a default or an
empty destructuring.
- The stub boot check fails a layer whose manager answers false rather
than throwing, or that is not on (or off) afterwards; a field drawn
counts as drawn; the dev server is closed when the browser cannot
start.
- dev/stub-app/main.js starts the standalone application on the stub
renderer with only the contract's required members (?capabilities=all
gives it every capability) and steps its frames.
- npm run qa:stub-boot serves the application's own page with that entry,
and fails when any Cesium module or asset is requested (the stylesheet
the build's Cesium plugin links into every page is reported), on a page
or console error, or when a data layer fails to turn on or off. A feed's
failed response and the dev server client's own errors are reported;
--strict also fails a layer that drew nothing.
- The browser CI job runs it.
- RENDERER-CONTRACT.md and CURRENT-STATE.md describe the application on
the stub and the boot check.
- The standalone page starts loading the default renderer as it starts
(loadDefaultRenderer), so Cesium arrives beside the page's own setup,
not after it; the scene takes a plugin or a promise of one.
- Where a follow target's layer has no display position yet, the followed
position is the target's own position at the frame port's scene time.
- The globe engine's photoreal base that fails to come back is off again
and the globe shown; a later switch tries again. The draped-imagery host
asks the map engine whether the globe is shown where the renderer cannot
say. The scene resizes the renderer with its container.
- Cockpit and voice tests follow through the camera port (followEntity),
not by setting the viewer's tracked entity; the fake frame port has a
scene time.
The application scene takes a renderer plugin and no longer refuses one
without a Cesium viewer. It loads the default (Cesium) plugin only when it
is given none, so a page on the stub never loads Cesium.
- Every layer and tool is handed the application's own scene object
(createSceneHost): the container and isDestroyed(), bound to the
renderer, the same on Cesium and the stub.
- What only Cesium needs at startup is done in its plugin's create: the
free-look height limit, and keyboard access to its credits' expand link
(creditKeyboard.js moves into the adapter).
- What a plugin may hand the application beside the contract goes through
provideApplicationHooks, each hook optional: Cesium's map engine, stale
command trimming, inline panel rendering, viewerDrawsEntity, the zoom-out
guard, and the viewer QA scripts read from window.__godsEyeView.
- The map stacks, and the photoreal base the scene loads, switch through
the renderer's own map engine (mapEngineFor), else its globe port
(globeEngine.js). The Cesium engine takes the scene object and changes
the viewer behind it.
- 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.
Every file that read the renderer's canvas as rendererOf(viewer)?.canvas
falling back to viewer.canvas, and the share restoration's gesture
listeners on viewer.canvas, now ask canvasOf(viewer). The 20 canvas
reach-throughs leave the viewer access record.
The band is copied out of its radius table as whole 32-bit pixels where
the image's bytes line up with words, a byte at a time where they do
not. Each front's positions come from the unit vector on the sphere
straight to the ellipsoid, without going through longitude and latitude
and back; they move by nanometres.
Each pulse step painted the band with a square root per pixel and built
each front's per-bearing constants anew. The band now keeps which entry
of its radius table each pixel reads while the subject stays put, so a
step only fills the table and copies it out; the fronts keep their
bearings' constants for the centre they were made for and come out the
same bits.
Cesium measures heading, pitch and roll by moving the camera into the
eye's east-north-up frame and back, twice each, and a frame reads the
pose many times over (the range ring's rim check reads it every frame).
The Cesium camera port keys the last pose on everything it is read
from: eye, axes, transform, frustum and mode, and answers from it while
they hold, with objects of the caller's own.
The reveal probe hides a contact's row, waits for frames that draw it
hidden, and shows it again. Those hidden frames are the probe's setup:
they now restart the reveal's clock and deadline and are reported as
hiddenMs. The row stays hidden for two drawn frames, past the frame that
follows the settle frame, so the reveal is timed on an ordinary frame
instead of on whether that frame was pipelined.
dropPendingTexture reads the private material._textures; it now does so
through internals.js like every other private field. The internals test
fails when the installed Cesium no longer declares _textures or no
longer takes a uniform's texture as Material updates.
Checks that read drawn pixels no longer skip when nothing is drawn: a
harness says pixels: false when its renderer draws only models into
pixels, as the stub, and a renderer that draws an icon, an
outlined line or a raster shell as nothing fails. The shell's patch is
read where the ground below projects, in the units readPixels crops in.
The contract notes what changed in version 0 besides additions, and
loses two stale lines.
A draped solid line with an outline went into a colour batch and lost its
edge; it now draws by its own outline material. A camera controller that
binds Ctrl+wheel before the controls are made relays trackpad pinches from
the start, not only after the binding is set again. A raster shell image
zero pixels wide is left to the material, as before.
A material takes a texture, and destroys it later, only when it next
updates. A canvas fill replaced by one of another size twice before a
frame, or disposed before one, left the texture in between to no one.
Such a texture is now destroyed when it is replaced or its shapes go.
The contract places a view given as direction and up exactly, but the
stub turned it into heading, pitch and roll first, so a thousand small
turns straight down drifted by a hundredth. The new check
camera.setView.exact holds the stub and Cesium to it; both pass.
A user's drag woke the pulses on every frame it drew, and each wake
stepped the fronts at once without noting the step, so a drag stepped
every frame and some frames twice. A wake now starts resting pulses at
once and leaves running ones to their Cyber sonar interval; a subject
move that steps notes it too.
draw.field.rasterShell now reads the middle of the frame, which the shell
covers, once 'drawn' has come. A renderer that draws a probe line into
pixels must draw the shell there too; one that draws neither, like the
stub, leaves the pixels unread.
Every conformance scene now has a reference. The quad and mesh views look
at their item's middle, where the mesh's base was cut off at the bottom of
the frame before.
The shell's material reads an image width of 1 as Cesium's 1x1 default
texture, nothing arrived yet, so a one pixel wide image never drew while
'drawn' was still told. Such an image is drawn as a copy two pixels wide,
which samples the same.
A solid line's outline.widthPx is the outline in all, half on each side and
inside the line's width, as Cesium draws it. The range ring's pulse fronts
pass their halo width whole again, so they keep main's look, and the
conformance check draw.lines.outline pins the width. The lines scene's
outlined line keeps its 2 px edge each side and its references are
re-recorded.
Meshes and quads are capabilities, so the CCTV layer asks for its viewshed
and plane sets only where the renderer has them and draws the rest of its
items without them.
The fronts and band are fixed in the world, so a camera move needs nothing
of them: they now step 80 ms apart however many frames are drawn, as a
parked view's do, and look the same moving or parked. Each frame checks
only whether the camera crossed the rim height, which shows or hides them
at once.
The pulse level is worked out once a step, so the camera pose is read
once rather than on every call. The band's alpha is tabulated along the
radius and each pixel looks it up (0.78 ms a paint down to 0.21 ms in
Node). A line sent again where it already runs keeps its positions, so the
polyline collection does not rewrite the ring's vertices on every step.
The band test now compares images byte by byte. A failing deepEqual on a
256x256 image builds a diff of every byte, and that ran a test process
out of memory.
The ring, its sonar fronts and the band behind them leave Cesium: the
ring and each front are one solid line with an outline, the band is one
flat unpickable ellipse at the rim filled with a canvas painted from the
pulse radii. rangeRingCesium.js goes, and the Cesium allow-list is empty.
Solid lines take an optional outline ({color, widthPx}, inside the
line's width on each side), drawn in the line's own pass so a
translucent halo never darkens where it meets the core; both colours
change in place, and outlined lines never settle into the static batch.
An unclamped image fill takes a new canvas in place: copied into its
texture when the size is the same.
A parked view steps the pulses from the 80 ms timer before it asks for
the frame that draws them, so it draws one frame a step; frames the
camera moves in, or held drawing, step them every frame, and the band is
painted at most every 80 ms. The lines reference scene gains an outlined
line.
An error Scene catches itself marks Cesium's render loop stopped while the
loop's next animation frame is still queued. A Retry, or a tab shown again,
before that frame ran started a second loop, and the globe drew every frame
twice. The render and resize wrapper now keeps the loop marked running after
a call made while it ran; the queued frame stops it if nothing restarted it.
This also covers the inline panel's timer frames, so its own guard goes.
Shapes take their radii in metres; the world annotation ring follows the
camera height itself (ringRadiusAt), resizing on preRender. The radial rim
preset and depthBias go: the launch pad zone draws a canvas image fill made
by the layer. Solid and dashed lines take one depthFail look (solid or
dash) in place of depthFailColor and depthFailDash. sonarCadenceHz goes from
the quality settings: nothing set it, and the sweep moves every 80 ms.
Camera move, look, rotateAround and zoom leave the camera port: the app's pans,
in-place turns, globe turns and zooms are setView views summed over the pose
(geo/eyeMoves), and the Cesium port places a view by direction and up
exactly rather than through heading, pitch and roll. The conformance driver
runs those script steps through setView; the lookAt script turns in place
where it turned about the frame-local axis, and its reference is recorded
again.
Quality no longer switches clouds or water (their ports are gone) and its
atmosphere and post-processing settings are low or high detail; whether the
sky or a pass shows stays with globe.sky and effects. The separate
input.ctrlWheelZoom switch is gone: 'ctrlWheel' in the camera's zoomInputs
also relays trackpad pinches, which the application turns on.
Drops from the contract, the stub, the Cesium renderer and the
conformance suite: agent paths, renderer-propagated orbits and celestial
draws (orbits stay drawn as icons and inertial lines), scalar raster
fields, lodGroup, volume classification, icon eye offsets, the dash gap
colour, box shapes, courseBlendMs (courseGlide covers easing), relief
surface shading, globe clouds and water, sky atmosphere tuning, heightmap
and quantized-mesh terrain, WMTS and ArcGIS imagery, the batched cached
height read, the quality benchmark and the animated-style and overlay
pixel-ratio knobs. Capabilities clouds, water, celestial, agents, orbits
and benchmark go with them.
The lodGroup check becomes a displayRange check across two sets, the
height-query check uses an extruded polygon in place of a box, the shape
scenes draw extruded blocks where they drew boxes, and the fields scene
draws a raster shell. The shape references are recorded again.
The city and street views were recorded before colour fills were built
with the vertex format their appearance reads, which drew lit faces
darker than the same entities. They have not matched since; these are
the views as the Cesium scene renderer draws them now.
The contact keeps taxiing while the regimes are driven, so a 3x3 patch
around where it started could be left behind before the zoomed-in read;
an unplanted cell's DEM floor, once it had landed under the raw height,
then decided the assertion. The planted floor now also reaches 600 m
along the fixture's heading. The assertion is unchanged.
Takes main's per-point mesh floor readings (#1642) onto the seam's
port-based sampler: a spot refused only while the cell's DEM prior was
cold is probed again, each spot is recorded once, a cell keeps at most
sixteen readings, and grounded flights read the floor at the contact
held inside its sticky cell.
Retry used to apply the queued listener changes of a Cesium event a
throwing listener left mid-raise, adds first and removes second. A layer
turned off and on while the notice was up landed in both queues and was
removed. The render and resize wrapper now finishes those events before
it raises the render error, so later adds and removes apply at once and
in order.
A narrow, nadir-looking camera moving over the ground asks the base
imagery for the tiles 5 to 20 s ahead, as the orbital view did from 16x
before it moved onto the renderer contract. The renderer works it out
from its own camera: field of view, look and motion over the ground.
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 the CCTV opening camera, the Iceland, Giroc HLS, Taiwan, Quebec,
Ottawa and world camera packs, the world clock and timeline, the zoom-out
limit and registered-only layer state, ported onto the renderer contract:
the sky follows the world time through the frame port's setTime in
preUpdate, the Quebec overlay reads the eye, projects and redraws through
the camera, query and frame ports, launches hide pending missions through
their draw records, and mission orbit rings turn on the scene clock.
Brings in the wildlife sightings layer (#1591, iNaturalist and Acartia
sightings). Its badges, density glow and privacy cells draw through the
draw port: the badges and the glow are icons sets (iconCollection.js
batches point writes into one upsert per task), and the privacy cells are
ground-clamped shapes and lines sets swapped whole. The eye, the view
rectangle, clicks, projection, ground readiness and frames come from the
camera, query, input, globe and frame ports, so the layer, its card and
its placement no longer import Cesium.
Differences from main: the density glow is drawn as pixel-sized splats
(56 px) instead of metre-sized ones with a near fade; the card's pan eases
with cubicOut, the contract's nearest ease-out; ground heights are
resampled when the globe's load progress settles or its surface changes,
rather than on tileset load events.
Also fixes two things the last merge left: a double-click that starts on
the followed track and ends off it reaches the renderer's own follow again
(a press that cannot end a double-click on the track gives its hold back
at its release), and the Active Fires heat drapes under the weather
imagery, so weather turned on after it stacks above. CURRENT-STATE notes
that the 2D and Columbus scene-mode checks are gone.
Brings in voice camera tilt (#1520) and free look with globe-in-view
recovery (#1532). The tilt and look maths in cameraVerbs.js and
globeInView.js run on camera poses and the geo helpers instead of Cesium.
The free-look height limit lives in the Cesium adapter
(render/cesium/freeLookLimit.js), installed through the application viewer
hooks; the globe-in-view recovery that main added to app/viewer.js runs on
the camera port in app/globeInViewRecovery.js. The scene-mode checks are
gone with the 2D and Columbus modes the seam does not draw.
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.
Brings in range ring visibility and sonar pulses (#1518, #1519), the
drone airspace layer (#1086), the Houston CCTV pack (#1125), typed chat
(#1507, #1545), in-view ground sampling for infrastructure (#1464) and
the CCTV model specs refresh (#1319).
What main added that reached Cesium or the viewer:
- Drone airspace draws its zones as clamped fills and draped boundary
lines in draw sets and takes clicks from the input dispatcher, as fire
perimeters does.
- Infrastructure ground sampling tests the view frustum and the horizon
from the camera port's pose (geo/frustum, geo/horizon) and reads loaded
terrain through the height queries.
- The awareness lifecycle reads the canvas, frames and whether the camera
controls take input through the ports. The sonar echo field measures
with the geo helpers.
- The range ring's pulses need a disc whose fill is computed per pixel
from values set each frame, and an outlined line whose opacity changes
without a rebuild. The draw port has neither, so that code keeps to one
module, src/layers/awareness/rangeRingCesium.js, which is on the Cesium
allow-list until the draw port can draw them. It draws only on a viewer
with a Cesium primitive collection, and takes its primitives out of the
collection it drew them in. On the stub the layer draws the
ring without pulses as a haloed line through the draw port.
Also from review of the previous merge: tests that the scene's viewer
hooks install the zoom-out guard, and that an ambiguous area name is
settled by the ground at mid-screen, else where the camera stands.
Brings in radio country coverage (#1206), the restored format scope
(#1527), the zoom-out guard (#1522), voice geometry and OSM places (#846)
and paired traffic flow density (#1495).
What main added that reached Cesium or the viewer now goes through the
renderer:
- The zoom-out guard reads the Cesium camera controller's own input, so
it moves into the adapter (src/render/cesium/zoomOutGuard.js). The
application installs it through the scene's viewer hooks, and a scene
whose renderer gives no guard starts without one.
- OSM places draws its points as a draw set, clamped to the ground.
- The voice area actions read the view box and the view centre from the
camera port.
- The voice workflow harness is test support, named as such where the
recent-imagery doubles are.
Import no longer loads KML, KMZ, GeoJSON and GPX through Cesium's data
source loaders. geoImportFeatures.js reads the sanitized file into plain
pins, lines, walls, polygons and ground overlays with the looks those
loaders gave them: icon, scale, colour, heading and hot spot, the shared
and inline style precedence, line and polygon colours and widths,
extruded and clamped geometry, rotated boxes and quads, and GeoJSON's
48 px pins, draped lines along rhumb lines and quarter-opacity fills.
geoImportPins.js draws them in three draw sets per file, places ground
pins through the height service (0 on the bare ellipsoid, whose coarse
tiles sag below it; the mesh nearby on photoreal maps), follows a
double-clicked pin, frames Fly-to, and shows, hides and removes them.
The Cesium adapter now draws two members the contract already had: an
icon's pixel offset and the wall shape. Image fills draw in the
translucent pass, so an overlay's own alpha blends as it did.
The Cesium allow-list is now empty; the ratchet test checks that its
scan still sees each way of reaching Cesium. The QA scripts read what a
file drew through the import's drawn(id), and the large-file check
compares it with Cesium's own reading of the same KML. A file the
renderer refuses to draw is refused by itself, without stopping its
batch. Two translations no longer used are dropped.
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 application scene is the composition root: it now takes everything it
needs from one adapter module (src/render/cesium/application.js), which
loads, shows and releases the photoreal tileset and hands out the viewer
hooks. The conformance page keeps importing the adapter's harness and scene
renderer, since running the suite on Cesium is its purpose. Both are named
in the ratchet as the only files outside the adapter that may import it,
each limited to those modules, by name only, and the modules may not hand
out the Cesium namespace. Only geoImportPins stays on the allow-list.
The embed views fly through rendererOf's camera port with geo maths, and
the panel render loop that keeps an inline panel drawing moves into the
Cesium adapter (src/render/cesium/panelRendering.js); the application
scene hands it to the embed views as `keepRendering`. The shell reaches
the camera, effects and globe through rendererOf and loads no Cesium
factories; whether Cockpit's aircraft is an entity of the viewer's own
comes from the scene's `viewerDrawsEntity`, wired in through the
controls. Callers handing the shell or the application tools a viewer
of their own load ./render/cesium/unbound once, as the ports' unbound
check now records.
src/sky/starrySky.js and src/app/viewer.js are Cesium through and
through, so they move into the adapter as src/render/cesium/starrySky.js
and applicationViewer.js; the ./application/viewer export points there.
The celestial ring's precise ICRF rotation reaches the shell through a
Cesium-free registry (src/sky/icrf.js) that the sky provides as it
loads; the application's renderer loads it, and so does
./render/cesium/unbound. Both files leave the Cesium allow-list.
The map stacks' imagery, terrain and Google 3D factories move into the
Cesium adapter (src/render/cesium/mapImagery.js, mapTerrain.js,
google3d.js); the ./maps/imagery, ./maps/terrain and ./maps/3d exports
point there. The catalog names its ion stacks by asset number, and the
map source controller and default sources are Cesium-free: they
build providers and switch imagery layers, terrain, tilesets and the
globe's visibility through a map engine (src/maps/engine.js) that the
Cesium adapter provides as it loads (mapEngine.js), through the
application's renderer or the ./render/cesium/unbound export. The
controller and createDefaultMapSources also take it as an `engine`
option.
src/maps/catalog.js, controller.js, imagery.js, terrain.js and google3d.js
leave the allow-list.
The world annotation renderer no longer draws entities, so the checks
read the mark's primitives in the scene instead: draped fills and
outlines, built, and unchanged while the camera is still. The last
outlines are checked by picking the mark at the middle of the view.
How long the primitives take to build is reported beside the first
drawn frame.
Areas, buildings, routes, arrows, pins and labels are draw-port shapes,
lines and points, one set per mark, faded by upserting their colours.
Pins pulse their ring and size it by camera height; arrows drape.
Ground heights come from the heights service. The module leaves the
Cesium allow-list.
Unclamped colour fills are built with position and normal only, as the
entities' colour batches build them; image fills keep texture coordinates.
With the default format Cesium packed texture coordinates with the normals
and the colour appearance decoded the packed value as the normal, so lit
colour fills (an extruded column, a box) shaded darker than the same
entity.
Shapes take an alpha pulse (from, to, periodMs, forever), run before each
frame, with frames asked for while anything drawn pulses. Any other pulse,
or one on a fill that is not a colour, is refused before anything changes.
An upsert that changes only colours, pulse, show or meta is written into
the drawn primitives: unclamped shapes through their instance colours and
ring materials, clamped colour fills through their ground primitive (or
once it is ready). Shapes not yet drawn, or drawn opaque and turning
translucent, rebuild as before.
Draped lines take the arrow style. Clamped ellipses with radii by camera
height are drawn at the camera's height each frame, drawn alone up to
MOVING_SHAPES (counting those a retiring host still draws alone) and
rebuilt past that. Extruded shapes that classify their volume draw as a
ClassificationPrimitive where the scene supports it, and extruded
polygons draw their outline cage. The stub picks clamped rectangles,
ellipses and classifying volumes, outside their holes. Conformance
checks radii by camera height and classifying volumes on both renderers.
The wind relief now asks the globe port for hillshade surface shading at
0.28 instead of building a globe material itself; the Cesium globe port
draws the same view-directed shading, over terrain normals or the globe's
curvature, and the unbound provider now lists surfaceShading. The wind
layer's canvas flow, bounds, imagery fade and render requests go through
the camera, frame and query ports, so src/layers/wind/rendering.js and
relief.js leave the Cesium allow list.
A refused shading request is taken back so it never shows after Wind is
off, and a camera height that is not a number falls back as before.
The application layers and standalone catalog entries no longer load the
unbound factories themselves: a viewer with no renderer bound
needs render/cesium/unbound loaded first. The contract and current-state
docs say what the Cesium adapter's fields and surface shading do now.
The Cesium draw port now implements draw.field for the windStreamlines
kind (src/render/cesium/drawStreamlines.js). It carries the flow shader,
the 30-degree cells, horizon and frustum culling and the path tracing over
from the wind layer. It moves the highlight on the page's own frames, at
most every 32 ms, and only while the field shows, is unpaused, has alpha
and some cell is in view on a visible page. A grid no path runs through,
or one short of the whole globe, is refused. A rebuild that fails draws
nothing and is never told drawn.
The wind layer's GPU flow (src/layers/wind/gpuRendering.js) now builds the
spec, fades it by camera height and pauses it through the draw, camera and
frame ports, and no longer reaches Cesium, so it leaves the Cesium allow
list. The layer runs no animation loop of its own while the renderer draws
the flow; the canvas fallback is unchanged and still takes over wherever
the field is refused. A new conformance check covers the field's 'drawn'
events.
The Cesium draw port now implements draw.field for the rasterShell kind
and advertises the 'fields' capability. The shell surface (a raised
rectangle with a detail window, drawn in primitive order without depth
writes) moves from the weather layer into src/render/cesium/drawFields.js.
A new rectangle or height is drawn invisibly first and swapped in whole,
and 'drawn' is told in the frame of the swap. A stage of older content
never replaces the drawn one while newer content decodes. A field hidden
mid-stage keeps building it.
The weather shell (src/layers/weather/shellRendering.js) now drives one
field through the draw, camera, frame and globe ports and no longer
imports Cesium, so it leaves the Cesium allow list. The wind shell on
photoreal hosts also draws through draw.field. The conformance page runs
each visual scene on its own, so a kind the Cesium renderer does not draw
yet (scalarRaster) fails only its own scene.
The cyber sonar scene now sets a screenModulation sector each tick that
draws and at the renderer's sonar cadence, and clears it outside the Cyber
map theme. A renderer without the capability, or one that stops listing
the pass, leaves markers native and reports the contact GPU unavailable,
while the HUD sweep keeps its clock. The old Cesium command wrapper is
removed; cyberSonarGpu.js and cyberSonarScene.js leave the allow-list.
The adapter's effects port now has screenModulation: a contract sector
shades points, billboards (labels among them) and icon sets in their own
vertex shaders, swapped into this scene's command list as the primitives
update, and tints models on the CPU after every owner has written its
colour. Geometry and picks are unchanged. It is the sweep the cyber HUD
already draws, carried into src/render/cesium/screenModulation.js and
driven by a sector instead of document settings; nothing is installed
until a sector is set, and disposal gives everything back.
The capability is advertised on the Cesium version the command swap is
tested against; diagnostics list the pass while it draws, and listeners
hear when it starts or stops (a native shader it cannot take stops it).
A set asks for a frame unless it changes nothing drawn: the same sector,
or only the angle of a sweep while no shaded marker was in view.
cyberSonarSector() gives the sector for the cyber sweep; the app switches
to the port in the next commit.
Conformance: the screenModulation check runs on Cesium; new checks read
the pixels (in the band an icon draws, outside it and at radius 0 it dims
to the floor, strength 1 draws it in the colour, clearing restores it) and
check the member is absent without the capability.
The traffic layer keys its cached road heights by the globe port's
surfaceVersion() and waits on isSettled('surface') instead of reading the
scene through render/cesium/surfaceState.js, which is gone. Heat-lines are
always asked for draped; the layer no longer checks whether the scene can
drape and drops them. The traffic layer and application/sources no longer
reach Cesium, and src/layers/traffic/rendering.js leaves the Cesium list.
Where the Cesium renderer cannot drape (no depth textures), its draw port
now draws every draped line over the surface, as the contract asks: along
the surface's curve between its positions, in its colour where the surface
hides it, hidden past the horizon (tested along its arc, shown in 2D). A
segmented line runs from its first shown segment to its last, in its style
colour. A line whose positions hold what they held takes a new colour in
place, so pulsing jam lines build nothing per frame; one that moves is
built anew alone.
src/services/groundSnap.js and src/services/meshFloorSampler.js no longer
reach Cesium. Whether the surface has streamed comes from the globe port
(the snap waits for the 'tiles' and 'surface' settle kinds; the sampler
runs only with the globe hidden and 'surface' settled), the camera height
gate from camera.pose(), heights from the query port, and the maths from
src/geo/ellipsoid.js. The raw exclusion path is gone: callers see through
their own draw sets by id. Cockpit's ground probe names the tracked
contact's icon and model sets, which the flights and military layers keep
on its entity record (groundSets), instead of the tracked holder object.
Probing is unchanged: at the caller's point, up to eight readings per cell
about 17 m apart, a read answering from the nearest one.
The application operations entry is now Cesium-free: a viewer with no
renderer bound needs ./render/cesium/unbound loaded first. Tests that used
to get the adapter's factories through ground snapping load it themselves.
The frame-pass source check ended at the old occluder and so scanned the rest
of the file; it now ends where the frame pass does. A draw-port pick carries
{set, id, meta}, so the sprite's pick is compared by its id.
The dispatcher now builds on renderer.input and the query port, with
positions as plain {x, y}. Its viewer access count is zero and it leaves
the Cesium allow-list. Layers that read the raw engine pick read the Hit,
drawHit or event.native instead, and pickRegistry's resolvePickId and
pickContact take a Hit, with the raw versions kept in the Cesium adapter.
rendererOf gains findInput, provideUnboundInput and provideNativeClick.
event.native carries the engine's pick, drill and pickWindow, and picks
through the follow helper happen inside it. An unbound input port
survives the viewer being bound until it is released.
The query port's pick memo is now per task rather than per frame,
because Cesium's own picks advance the frame number. A click on the sky
skips the depth pass when nothing is on the ray. Touch contact search
keeps its eight-deep drill in a 14x14 window.
Keeping a cell's lowest reading let a street probe pull a vehicle on a viaduct
or bridge in the same cell down to street level. Readings now stay at the point
they were taken (up to eight per cell, about 17 m apart), a read answers from
the reading nearest the vehicle, and two readings within about 5 m keep the
lower.
The rendered-mesh floor took one probe at each coarse cell's centre and kept it
for the session. A centre on a roof passed the +80 m DEM window and lifted every
vehicle in the cell to roof height (a Haymarket bus drew 23.5 m above the
street); a centre in the river put Red Line trains on the Longfellow Bridge
6-9 m under the deck. The sampler now probes at the caller's point, reads a
latched cell again at up to four points apart from each other, and the gate
keeps the lowest reading that passes.
Transit drew its vehicles into two Cesium billboard collections and culled,
turned and floored them through the Cesium scene. It now draws them as two
draw-port icon sets, still and moving, registered with the sprite order by
set id in the same places. Each marker is a plain record; a frame writes the
changed ones in one upsert per set, and markers taken out in one task go in
one removal. Clicks read the draw-port hit.
Visibility uses the query port's horizon test and the frustum planes of the
camera port's pose. Icons stay turned in screen space by an exact projection
through the query port, the same answer the Cesium helper gave. The flat
globe is told from terrain by asking the height service once per surface
change; floors are read again when the answer flips. The mesh floor sampler
sees through the layer's sets by id. The camera pose and surface version are
read once per task.
The Cesium draw port now moves and turns an icon without restyling it. The
GL upload probe moves to src/render/cesium/uploadProbe.js, which the QA
scripts hand to the frame probe; the QA scripts read the billboards drawn for
each set.
The box being dragged was two Cesium entities on a data source of its own.
It is now a clamped colour rectangle in a shapes set and a draped dashed
outline in a lines set, both unpickable, with the same colour, alpha,
width and dash length. The Cesium draw port now redraws a moved clamped
fill in the frame it moves, so the box shows on every frame of the drag.
The fill shows once the box has an area. The outline shows once the box
has any extent, so a drag along one axis still draws a line. The last box
is kept hidden between drags, and the next drag moves it.
markBaseTileset moves to a Cesium-free module, src/render/baseTilesets.js.
The globe port reads it and re-exports it, so a tileset a caller marks
as its base is still draped on. rendering.js no longer imports Cesium or
reaches the viewer and leaves the Cesium allow-list. The application's
tools loaded the globe factory only through it, so embed.js now loads it.
A clamped colour fill (a polygon, a fixed-radius ellipse or a rectangle)
whose upsert changed only its geometry rebuilt its set's ground primitive
batches asynchronously, and each upsert dropped the build in flight, so a
shape dragged every frame never drew. Once Cesium's terrain heights are
loaded, such a fill is now drawn alone where it now is, on a ground
primitive built in the same frame with the same pick id, and hidden in its
batch and in a host still retiring. That mirrors how a moved draped line is
drawn.
A set draws at most MOVING_SHAPES fills alone, counting those a retiring
host still draws; an upsert that would draw more rebuilds as before. A set
whose moved fills have been still for SETTLE_FRAMES drawn frames rebuilds
once, so they go back into its batches. If a second rebuild drops the host
drawing a fill alone before that host is ready, the fill shows again where
the retiring host draws it, unless it is hidden or gone.
An icon set drawn as Cesium billboards now changes an upsert in place
without walking the whole set when every touched item is already drawn
with the image it has, and writes only the position (and the course
axis that follows it), the pick record and the shown state when an
item's look is unchanged since it was last drawn. A layer that moves
hundreds of icons a frame through the draw port then costs a few times
a direct billboard write rather than thirty: 800 icons took 1.1 ms a
frame and now 0.18 ms in a Node benchmark, 3,000 took 4.4 ms and now
0.5 ms. What is drawn is unchanged; any add, removal, reorder, image
change or other restyle takes the existing path.
Five new camera conformance scripts move the camera by user input: a
left drag that coasts, thirty pixel-mode and thirty line-mode wheel
notches from 5 km, a middle-drag tilt, and Shift and Ctrl drags held too
long to coast. The runner turns input steps into pointer events for a
driver: a move starts where the pointer last pressed or moved and carries
the held button. The golden recorder now drives Cesium's own screen-space
camera controller on a stand-in canvas, with Date on the virtual clock so
inertia is deterministic. The existing goldens are unchanged.
A harness that answers pointer input sets cameraInput and a pointer hook.
Harnesses without it, such as the stub, skip the input scripts.
The input port reported a line-mode wheel at 33 1/3 pixels a line. It now
counts lines as the reference does, 40 pixels a line and 3 lines a page,
so a pixel or line wheel converts back to the same pixels.
The geo export now has geodesicAt and horizonFrom. The camera events module
is a public export (./render/camera/events) and holds move detection and the
command hooks as well as the per-listener changed measure; the stub camera
uses them. Each onCommand registration is now its own, so removing one twin
leaves the other. The stub's testing.drawnPosition says where it draws an
item, so a camera that is not the stub's can follow drawn items.
Transit lowered the one camera-change threshold every listener shared to
0.05, through a claim ledger. The camera port measures each listener
against its own threshold, so Transit now asks for 0.05 on its own port
listener, nobody else's trigger changes, and the ledger goes.
A new listener measures from the view at the next tick, so the layer looks
at the view once more after that tick, and a move made in between is not
missed. Disable always removes both subscriptions.
The billboards, the occluder and frustum checks and the frame probe still
drive Cesium, so the renderer stays on the Cesium list.
sensorPickPosition returns {x, y} rather than a Cesium Cartesian2 and is
handed the canvas it sizes by, so it no longer reaches Cesium or the
viewer and leaves the Cesium allow-list. The style records stay keyed by
the scene object.
The cloud layer takes latitude, longitude and height from pose() and its
angle conversion from geo/vector, so it no longer reaches Cesium and
leaves the Cesium allow-list.
ModulationSector gains radius and floor and says what it dims and what it
leaves alone; picks are unchanged and setting or clearing a sector asks
for one frame. The stub names its pass screenModulation, and a
conformance check covers the pass, the frame request and the pick.
windStreamlines takes alpha and paused; rasterShell replaces detailWindow
with a detail image and rectangle and says how shells stack, blend and
update; FieldHandle.on('drawn') says once per change that it is drawn,
never while hidden. The stub fires it on the render after a change, and a
conformance check covers it. The Cesium adapter has no fields yet.
The globe port takes the globe's material only when it is free, follows a
terrain change, lets go of a material someone replaced, and takes it again
once it comes free; idle ticks ask for no frame.
A new capability, surfaceIdentity, adds globe.surfaceVersion(): a number
that changes whenever what surface heights answer against changes (base,
terrain or photoreal swapped, the globe shown or hidden) and never on
camera moves or tile loads, so the app can key cached heights by it. The
settle kind 'surface' says whether that surface has loaded what is in
view: the terrain while the globe is shown, otherwise the drawn tiles,
false with neither; a renderer without the capability answers it as base.
The Cesium globe port reads both off the scene, so a base changed around
the port counts too; its versions come from one counter shared by every
port. The stub bumps on real base, terrain, photoreal and visibility
changes. A conformance check and a globe port test cover them.
ShapeItem.lit picks the renderer's fixed light or a flat colour; omitted,
extruded shapes and boxes are lit and the rest flat, as they were. The
Cesium draw port lights unclamped colour and image fills by it; clamped
shapes still drape unlit. A new reference scene, shapes-lit, draws a lit
and a flat box and square.
LineItem.mode now says a renderer that cannot drape at all draws draped
lines and clamped shapes as overlay, and clampState() says overlay. The
Cesium port says overlay when its context has no depth textures, which
only a WebGL 1 context can lack.
The satellite dots, the tracked satellite's dot and the orbit rings now go
through the draw port instead of a raw point collection, an entity and
primitives, so the layer's rendering no longer drives Cesium and leaves the
Cesium allow-list.
- Dots are one points set, patched in place and sent once per frame.
- The tracked dot is its own set, drawn at the sample the follow camera
framed (or after the frame's own sample when no camera read it).
- Rings are geodesic lines with a behind-the-globe colour, turned about the
pole by the sidereal angle in the layer each second, since the port has no
inertial frame. The orbit frame matrix is a plain 16-number array, and
the launches layer now receives plain ECEF orbit positions.
- Clicks match the draw hit against the layer's own sets.
- The focus pass projects every dot in one batched call.
- Depth-fail lines in the Cesium draw port honour pickable: false.
Among sets that skip the depth test, a higher drawOrder draws over a lower
one whatever order they were made in, and picks name them topmost first.
Cesium draws the earlier of two opaque near-plane icons on top and picks
it, so the draw port stacks the sets' hosts with a higher order earlier,
ties in the order the sets were made. Hosts trade places only among the
slots draw-set hosts already hold, so no other primitive moves; nothing
moves while every set is at 0. Translucent items blend
order-independently in Cesium and are not ordered by it.
The stub sorts its hits the same way. A conformance check draws two icon
sets at one spot and swaps their orders.
The query contract now says picks answer against the scene as drawn before
effects, and that a drillPick limit bounds the work as well as the answer:
the renderer stops at `limit` hits and looks through at most
max(limit, 16) things under the pointer. The Cesium query port passes that
depth to Cesium's drill (a pick looking under something unpickable stays
unbounded), a click's drill caches one pass per depth, and the stub counts
unpickable items toward the depth.
CameraPose says fovy and aspectRatio describe the nearest centred
perspective frustum, the exact projection being in matrices().
A changed listener's own threshold is now the capability
cameraChangeThreshold; without it every listener fires at 0.5. The Cesium
and stub cameras have it, measured per listener without touching Cesium's
shared percentageChanged.
Conformance: draw.drillPick checks limit 0, never the surface, nothing over
the bare globe, an unpickable cover, nearest first and a bounded prefix;
query.pickBeforeStyles picks an icon under a mirroring style; the threshold
trace is skipped without its capability.
The site dots, outlines and selected footprint fill are now draw-port sets
(points, draped lines, clamped shapes) instead of Cesium entities. The
selected site's dot is drawn by a set of its own, so selecting a site
redraws no other dot. Selection is registered through plain carrier
objects in the context store, as the local GeoJSON layer does, and the
tracked card reads the site's label and position from the carrier's entity
record.
A double-click on a site dot now follows it through camera.follow (gated on
the stock double-click follow), centred on the surface under the dot when
its height is loaded; one on an outline or fill zooms to it. Hiding the
layer stops a follow it started. The layer no longer lowers the shared
camera change sensitivity: its own camera-port listener carries its
threshold.
The follow offset fitting moves to src/geo/frames.js and is shared with
the local GeoJSON layer. rendering.js leaves the Cesium allow-list
(33 -> 32); the layer's entry joins DRAW_FROM_CALLER.
Each product edition now draws as three renderer sets (pins, lines and
fills) instead of a Cesium data source. Pins keep the depth test off and
the Street Level horizon cull, clicks resolve through the draw hit of the
current edition, and a new edition is drawn before the old one goes. A
viewer with no renderer bound draws nothing and releases the edition's
packed images. The layer leaves the Cesium list; a caller handing it a
viewer of their own loads ./render/cesium/unbound first. The QA script
reads pins from the scene instead of data sources.
The launches layer's sites, markers, reticles, mission lines, live orbit
rings and pad zone are now renderer draw sets. Picks go through the query
port, double-click follow through the camera port (shared with other layers
in src/data/stockFollow.js), and per-frame work through the frame port.
rendering.js, orbitRendering.js and launchPad.js leave the Cesium list.
The Cesium draw port gains what these need: pattern line styles, lines in
the inertial frame turned each frame by the set's motion clock, radial-rim
fills on clamped ellipses with a depth bias, and parking for hidden lines
that cannot settle into a static batch, so a hidden line no longer costs a
draw each frame. A roster writes each set once, and a followed live payload
shares one position sample with its marker each frame.
The stations, the cluster dots and the selected station's dot and bracket
are draw-port point and icon sets. Stations drawn too close together on
screen are grouped by geo/screenCluster.js as the default renderer's
entity clustering grouped them: the same boxes and screen coordinates, the
same reuse of the last pass's clusters when the eye comes lower, a pass
whenever the camera moves enough or a station is shown or hidden, and
stations a pass passes over hidden until the next. A cluster dot names its
seed station, so a click plays it as before. The Radio QA script reads the
drawn sets; the unused cluster-collection internals helper is gone.
The fire glows are one draw-port icon set with horizon cull, drawn on the
renderer's moving-icon path with a hold motion, as the layer's own icon
primitive drew them. Only glows that are new or changed are written, after
the set accepts them; fires a refresh drops are removed. Clicks read the
renderer's hit and match the layer's own set id. The sprite order registers
the set by its id.
The camera icons are now a draw-port icon set kept by an icon book; only
icons a view pass or restyle changes are written, in one write per pass.
Picks read the renderer's hit, the view pass and focus pass project
through the camera pose (geo/frustum.js poseProjector, matching the
renderer's projection and near clip) and the query port, and tile
readiness for ground sampling comes from the globe port.
The frustum wireframes, viewshed volumes and the active camera's monitor
plane are now line, mesh and quad items of the layer's own draw sets
(layers/cctv/drawSets.js), written from plain handles only as they change.
The plane takes its canvas double buffer or its video as a quad source.
Picks of lines and planes are matched by set, item id and the record that
draws them. The activation obstruction probe casts through the query
port's rayCast; its clamp lands a microtask later, rewrites the geometry
and asks again for the footprint ground, and a newer activation, a range
edit, a deactivation or a re-init drops an answer still to come.
The gizmo's rings and move arrows are draw-port lines that dim where
geometry hides them, and its handles and arrow tips are depth-test-free
draw-port points; their item ids keep the cctv-gizmo-<part> scheme the
layer's pick owner matches. Picks, rays and the cursor go through the query
port and the renderer's canvas, and the drag math runs on plain vectors.
The layer reports what the gizmo draws for the QA harness, which reads the
parts there instead of from the viewer's entities.
The Cesium draw port now makes quads sets (a posed, textured plane with its
outline, drawn as a plane entity with a transparent image material draws it)
and meshes sets (triangles in the east-north-up frame at an origin, flat and
two-sided or lit and closed). Quads change in place as they move, resize,
fade or take a new canvas; a video quad keeps frames coming while it plays
and gets a new material when its size or source kind changes. Mesh vertices
are placed in the Earth-fixed frame, so Cesium can project them for its 2D
views. The capabilities list both kinds.
The world overlay host now hands each paint lane the eye's height from
the camera port's pose (cameraHeight) beside its position. Detection reads
its view scale and label budget from it instead of the viewer's Cesium
camera, measures box distances with plain arithmetic, and no longer keeps
the viewer, so detection.js leaves the Cesium allow-list.
The satellites layer publishes its focus rectangle with
publishFocusTargetAt, projecting its cached position through the query
port and measuring from the camera port's pose, as flights and military
already do. The scene-taking publishFocusTargetFromCachedPosition and the
unused advanceProjectedSpriteFocus go, and focusDeemphasis.js leaves the
Cesium allow-list. The rectangle is the same; the target's frameNumber,
which nothing reads, is now -1 as the other layers publish it.
screenProjectedRotation, perspectiveProjectedRotation, horizonOccluder and
cameraPoseSignature read a Cesium scene or camera, so they move unchanged
to src/render/cesium/iconOrientation.js, where the CCTV, radio and transit
rendering (still Cesium-bound) load them. src/data/iconOrientation.js keeps
the label backdrop test and the rotation deadband, and leaves the Cesium
allow-list. Local ADS-B computes its rotation from the camera port's axes
with courseScreenRotation directly, the same answer without a stand-in
scene.
The ./aircraft package entry re-exports src/data/iconOrientation.js, so it
no longer carries the four moved helpers or the PERSPECTIVE_* constants.
iconSet.js and iconSegment.js no longer import Cesium and leave the
allow-list. A segment's base is split into high and low floats, and an
arc's east and north axes are computed, the way the default renderer
did it, so the GPU reads the same bits (tests compare every stored float
against Cesium, poles and the centre included). The set's epoch is a
geo/julian date; colours, distance curves and cull points come back as
plain objects. Renderer dates and colours passed in still work.
The primitive that draws icon sets in a Cesium scene now lives at
src/render/cesium/iconSetPrimitive.js beside the draw port's GPU icons,
and leaves the Cesium allow-list. Its importers (the draw port, CCTV,
FIRMS and the cyber sonar overlay) load it from there.
The bundled data centres now draw through the draw port, so there are no
Cesium entities to walk and nothing sets the viewer's selected entity: the
ownership check could not find a target at all. It now finds one from the
layer's context records, accepts a draw-port pick by the context id of the
item it carries, and counts gev:entity-selected announcements per click for
that same item, which both the old and the new build send. Because a
selecting click flies the camera away, the camera is put back and the same
item is found again, before and after draw mode opens, so the drawing click
lands on it rather than on plain ground. The drawing click must add a
vertex with no selection announced and no selected entity.
The hidden-Line check failed now and then with as much amber appearing as
going. Two shots of an unchanged scene differed by 30 to 194 amber pixels on
both builds: imagery was still refining after the fly-to, and the green
area's pulsing fill moves borderline roofs across the amber threshold. Each
shot now waits for the globe's tiles to load, and the other marks are set
aside while the Line is shot and checked back afterwards. The thresholds are
unchanged.
Traffic now hears the camera through the camera port, measured on the
frame at its own 5% threshold, so the raised camera.changed and moveEnd
events no longer reach it. Each move is now setView plus rendered frames,
the way a user move reaches the port, and the setup render records the
baseline pose the first measured move is compared with.
Keyless roads come from OpenFreeMap tiles, so the degraded leg holds those
requests as well as the Overpass proxy's. The interceptor counts road
requests per leg: the degraded leg must hold at least one and the cold city
must reach the network, since requestRoads can be answered from decoded
tiles. The notes say what Fetch->response and response.json measure for
each road source.
The tracking harness had drifted off the app before this migration began and
stopped at its share-link reload: it read Cesium's trackedEntity record, which
the camera port's follow now owns as a hidden helper. Read every invariant
through the mechanism that replaced the one it used:
- what the camera follows (share links, jitter, M3 release, stale cue, weld,
display floor) through data/followed.js, whose target's position is the
same function the tracked entity's position ran;
- fleet icons from the draw port's icon sets as the renderer holds them (the
GPU rows' colour, alpha, scale, shown flag, depth distance, position and
drawn course), the tracked icon's own set left out as before;
- models by their {set, id} pick ids; H1 now also requires the hit to be the
flights tracked-model set;
- display-floor/loading plants shown-but-not-ready on the layer's own model
record, which is what the layer decides ownership from;
- display-floor/hold reads the icon after the layer's microtask write to its
draw set.
Arrival rotation no longer has a CPU pass to tamper with or repair: the GPU
icon sets turn each icon along its drawn course every frame. The group now
measures the on-screen nose the drawn course projects to against the feed
course's, on the first frame after moveEnd and on the first frame drawn after
a frame that drew the row hidden (same 10 degree bound and budgets). That the
shader turns an icon to its course's screen angle is the renderer's contract,
drawn by the conformance reference scenes.
No tolerance changed and no invariant was removed. The pre-migration build
and this branch both pass 109 checks; a run with the grounded scale and the
fleet rotation mode broken fails the ground and arrival checks.
An undraped solid line (straight or geodesic, without a depth-fail colour,
not revealed, at least half a pixel wide) is drawn by the set's polyline
collection at once, as before. Once the set's lines have not changed for
30 drawn frames, every such line is built into static batches beside the
collection: a primitive of polyline geometries for opaque colours and one
for translucent ones, each line coloured and shown by its own instance
attributes under the pick id it had. A batch builds hidden, off the main
thread, and swaps in for the batch before it and the collection's
polylines once it is ready, each line showing as its item then asks. A
polyline collection works out every line's material every frame; a batch
costs nothing until it changes. The data centre stems (4,362 lines) cost
about 16 ms a frame in the collection and about 0.01 ms settled.
A batched line changes its show, colour and meta in place. One that moves,
or whose colour moves it between the opaque and translucent passes, leaves
its batch, hidden there, for the collection until the set settles again;
when a batch exists and fewer than 64 lines are left in the collection,
they settle after 300 frames, as rebuilding the batch for a few lines
costs more than drawing them. A line in the collection that moves or
changes colour drops a batch still building; a show change does not. A
colour-only change of such a line is now made in place in the collection
too, where it rebuilt the set. A batch whose build fails is reported once
and its lines stay in the collection. Glow, dash, arrow, flow, pattern,
revealed and depth-fail lines draw as they did.
The shared conformance suite checks solid lines left unchanged for many
frames still pick, hide, recolour and move in place.
A double-click on a point or polygon of a local GeoJSON layer follows it
again, as the default renderer followed the loader's entities: looking at
the centre of what the feature draws, north up, pitched down 45 degrees,
at the range that fits it in view. A line is zoomed to at once instead.
The layer acts only while the renderer's own double-click follow is on,
stops a follow it started when disabled, and stops listening when
destroyed.
The local GeoJSON layers drew every point on the plain pin once they drew
through the draw port. A marker-symbol is stamped on the pin again as the
default renderer's loader stamped it: a one-character string as bold
upper-case text, any other value as the Maki icon of that id from the
renderer's assets, and the plain pin when the icon cannot be loaded. The
pins are drawn on a canvas without the renderer, and the icons load before
the sets are built, as the loader waited for its pins.
A synchronous height sample saw through the draw sets item by item: each
item it hit cost another offscreen pass, and a hit line made its whole
line collection rebuild. The sets it sees through are now hidden whole
for the sample and shown again before anything draws, so it renders past
them in one pass with the same answer. A list read before the sets last
changed still sees through item by item, and a sample inside another
sees what the outer one hid unless it sees through it too.
The Cesium draw port drew an unclamped polygon's outline as one closed
polyline around its outer ring. Each ring now gets its own, with the same
width, colour and pick id, as the entity polygons the GeoJSON loader made
outlined their holes. The local GeoJSON layers and submarine cables draw
their raised polygons this way.
cssColor (src/render/color.js) now reads the colour names the default
renderer knows, in any case, upper-cased as it looks them up: its table,
with grey aliases, transparent and its lavendar_blush spelling, and no
rebeccapurple. The local GeoJSON layers read simplestyle fill, stroke and
marker colours through it, so a named colour no longer falls back to the
layer colour; submarine cables read their marker colours the same way.
The traffic lifecycle listens on the frame port's preRender and on the
camera port's changed (at its own 5% threshold) and moveEnd, instead of
the scene's preRender, the camera's events and the shared
percentageChanged ledger. It no longer reaches Cesium and leaves the
allow-list; rendering.js, still listed for the surface identity, tile
readiness and draped-line support, now loads the unbound camera and
globe factories for the layer.
The traffic layer's vehicle dots are now a points set on the draw port,
moved, added to and taken from in place each frame, instead of a Cesium
point collection. Road surface heights and readiness read the query,
camera, frame and globe ports and the heights service instead of the
scene; the surface identity and "any tileset drawn" checks, which the
contract cannot answer, move to rendering.js with the heat lines.
animation.js, style.js and surface.js leave the Cesium allow-list.
The Cesium draw port compares a moved point's look without allocating:
colours by index, and a frozen colour or curve of plain data by identity,
so a thousand dots moved every frame cost about what direct writes did.
The traffic QA scripts read the dots' draw items.
A set of unclamped points drawn by one point collection now takes new
points and removals where it is, instead of building the collection
anew; its pick ids and horizon cull follow, and the draw port's version
changes only when pick ids do. A point moved or restyled in place sets
only the members of its look whose values changed, and writes its
position without allocating, so a set moved every frame makes nothing
new. A draped line drawn by a material of its own takes a colour-only
change on its material, and unmoved lines sent again compare their
positions without flattening them. The shared conformance suite checks
points joining and leaving a set one by one.
A rectangle shape gains an optional rotation: radians counter-clockwise,
turning it about its centre in longitude and latitude, as a KML ground
overlay turns; an image fill turns with it. A renderer that predates it
draws the rectangle unturned. The Cesium draw port passes it as the
rectangle's rotation and texture rotation, and now drapes image fills on
clamped shapes, each on a ground primitive of its own that owns its
material, where it refused them before. Hidden image fills are not built
until they show. The stub picks draped rectangles, turned and across the
antimeridian, and a conformance check picks a quarter-turned overlay on
both renderers. The KML importer still draws its overlays itself.
A line item gains an optional depthFailDash ({ length, pattern16? }): the
parts behind the surface are dashed in depthFailColor, as a dash style
dashes a line. Without a depthFailColor, and on draped lines, it is
ignored; a renderer that predates it draws those parts solid. The Cesium
draw port gives the depth-fail appearance a PolylineDash material, and a
change of dash is a new look. The Draw tool's rubber band uses
{ length: 16 }, the dash its old entity asked for (that entity, a dynamic
polyline, never drew its depth-fail material, so the parts behind the
surface were hidden before the tool moved onto the draw port).
The camera port gains an optional followFrame() (capability followFrame):
the frame the eye is placed in now, as a column-major 4x4 matrix to ECEF.
Once a follow has framed the camera it is the follow's own frame
(east-north-up, or the orbit frame an autodetect follow chose), under
lookAt the target's east-north-up frame, otherwise the identity. setView
places a world pose and keeps that frame. The Cesium port reads it from
camera.transform, only when the capability is on; the stub from its own
eye frame. A conformance check covers the world, lookAt and enu-follow
frames, the offset in it, and setView keeping it.
src/ui/shareFollow.js now reads the pose, the frame and the follow offset
through the camera and frame ports: a shared offset is re-expressed in the
follow's own frame as before, satellites included, and the eye is placed
with setView at exact heading, pitch and roll, so a near-vertical view
keeps its roll. placeFollowEye returns false on a camera that cannot say
its frame. offsetFromHeadingPitchRange moves to src/geo/frames.js, shared
with the stub.
The data centre and dam layers (src/data/localGeojsonCore.js) no longer load
a Cesium GeoJSON data source. Each build is six draw sets: ground fills,
raised fills, draped lines, pins, stems and their tip dots. A walk changes
what moved or showed in place. Ground heights come from the heights query,
with the globe visibility getter deciding whether terrain is a floor. The
stems are sized from the camera pose, and clicks select and fly through the
input and camera ports. Point-and-ask reads a draw hit's meta as the
feature's context record (drawItemMeta in src/data/pickedContext.js).
The drawn parts keep the loader's ids and its reading of each feature:
simplestyle fill, stroke and marker colours, opacities, widths and marker
sizes; polygons with heights drawn at them and outlined; 3D points standing
their pin on the stem tip; ground edges along rhumb lines.
Differences: a marker-symbol draws the plain pin; named CSS colours fall
back to the layer colour; a raised polygon's outline is 1 px around its
outer ring only, and its fill is unlit; the layer no longer sets the
viewer's selectedEntity, so Cesium's stock double-click no longer follows
a feature; a caller's own Cesium viewer needs
gods-eye-view/render/cesium/unbound loaded first.
The Cesium draw port's version tells height queries when the pick ids
they see through may have changed. Icons changed in place keep their
billboards and pick id objects (meta and LOD group are written into
them), so only icons added or removed change what queries see through.
An in-place icon update, such as the tracked aircraft's icon every
frame, no longer bumps the version, so the see-through cache is no
longer rebuilt each frame. Re-registering an atlas whose images change
in place keeps it too, and still rebuilds a set it cannot patch.
The renderer contract gains an optional event on model draw sets,
`on('loadFailed', (id, message) => ...)`, beside `ready`: a model's url
failed to load, once per failed load. The item stays in the set drawing
what it drew before; removing it and adding it again tries at once. A
renderer that cannot tell a failure may never fire it.
The Cesium draw port fires it once Cesium is done with the frame it
raised the error in, and not for a load that was superseded or whose item
went. The stub fails urls under `stub-fail:`, telling each load once. A
conformance check (`draw.models.loadFailed`) runs on both, with a model
url the dev server does not serve for Cesium.
The flights and military layers use it in place of rewriting every
unloaded model every 5 s. A fleet model whose load failed is removed and
added again 5 s later. The tracked model gets back its per-selection
budget: a failed load is let go and tried again 1.5 s later, and after
three failures the contact stays 2D until another is selected, as
before the models moved onto the draw port. A good load retires the
budget, and a model that loads after all is kept.
A second ratchet beside the Cesium allow-list: files off that list (and
outside the Cesium adapter) may no longer reach Cesium through the viewer
either. src/render/viewerAccessAllowList.json records, per file, how many
such accesses it still makes (the viewer's entities, dataSources, scene,
camera, clock, imageryLayers, terrainProvider, trackedEntity and canvas;
the scene's primitives, pick, drillPick, pickPosition, globe, frame
events, canvas, requestRender and camera), read from the parsed source in
their plain, optional, bracketed, call-result and destructured forms.
viewer.container, comments and tests do not count.
The test fails when a file makes more accesses than recorded, when a
recorded count is higher than the file now needs or names a file gone or
back on the Cesium list, and when the record grows against origin/main.
scripts/viewer-access-baseline.mjs lowers the record to what the files
hold; it never adds or raises an entry. The record starts with 25 files
and 50 accesses.
An upsert that only shows or hides clamped colour fills, or changes their
meta, now writes each fill's show attribute instead of rebuilding every
ground primitive of the set. Hidden fills are built too, hidden, as
Cesium's entity ground batches keep them; a show written while the ground
primitives build waits for their swap. A hidden fill the port could not
draw shown stays out, as before, and a set whose fills are all hidden no
longer keeps the old ones drawn while it builds. Anything else about a
fill, including a value changed in place, still rebuilds.
The globe port could show or hide the globe surface but not say whether it
is shown. It now has an optional isGlobeVisible(), gated by a new
globeVisibility capability, in the Cesium adapter, the stub and a
conformance check. A Cesium scene without a globe does not offer it, so
callers keep their own default for an unknown surface.
The OSM overlays, the CCTV ground regime and the submarine cable drape now
read the getter instead of the scene's globe. cableClassificationTypeForScene
takes the viewer rather than its scene.
The flights and military layers now reach the renderer only through its
ports: motion, queries, state, tracking, enrichment, evidence and policy
read the camera pose, project through the query port, request and
suspend frames through the frame port, and key per-frame caches on the
frames drawn rather than the scene's frame number. Policy is plain data,
the enrichment view test is pose-based, and the tracked aircraft is an
icon in a draw-port set with a plain holder standing in for the entity
that Cockpit, the tracked card and share links read.
The mesh floor sampler can sample through the query port, excluding
named draw sets, and both layers use it that way. A pick of another
layer's tracked icon is never taken for one of a layer's own contacts.
Twelve layer files leave the Cesium allow-list.
src/geo/julian.js ports the parts of Cesium's JulianDate that dead
reckoning uses (arithmetic, comparison, the leap-second table and the
conversions to and from epoch milliseconds) onto plain
{dayNumber, secondsOfDay} objects, step for step, so the numbers match
and either module's functions take either date. celestial.js now shares
it instead of keeping its own copy.
motionModel.js and aircraftMotionRegime.js use it with the src/geo
ellipsoid, frame and vector helpers and leave the Cesium allow-list.
pickGroundPosition reads Cesium's depth and ellipsoid picks, so it moves
unchanged from scenePick into the listed input dispatcher, its only caller.
Weather rendering's default imagery host comes from the listed shell
rendering's globeImageryHost instead of reading the viewer's imagery layers.
Geo import asks the frame port for renders, the camera port for moveEnd and
the globe port's progress for the terrain queue running dry; its data sources
are added, removed and shown by the listed geoImportPins module. Voice capture
waits on the frame port's postRender. Visual settings toggle the infrared fog
through the globe sky port, and the anime style dims the Milky Way through a
sky getter it is given. The scope mask reads the camera height and listens on
the frame and camera ports. Recent imagery picks the view centre, reads the
view rectangle and the field of view through the query and camera ports.
Installations claim camera sensitivity from their rendering module. The
application shell loads the unbound globe factory.
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.
The two aircraft layers' fleet and tracked models are now draw-port
models sets made each layer lifetime, re-posed and restyled in place,
instead of Cesium models in a collection of their own. Model records are
plain data; picks name the set and the contact, readiness comes from the
set's ready event, the IR boost restyles in place (unlit, white tint,
full blend), and the drawn scale comes from the camera pose and pixel
floor. Fleet writes go out together at the end of each tick, before the
icons they replace, and a failed write hands the contacts back to their
icons. A model that has not loaded is rewritten every few seconds so the
renderer can retry it, which replaces the tracked model's load-failure
budget. Models load off the tile-contended job queue, as before.
aircraftModelLayer.js, modelRecord.js and the flights and military
lifecycle and testing files, plus flights rendering.js, come off the
Cesium allow-list.
Model visual anchors now turn glTF axes into the placed frame with plain
math, and a new modelDrawnScale reproduces the scale a model is drawn at
under its pixel floor from the camera pose and viewport, so callers no
longer need a Cesium model's computedScale. modelVisualAnchor.js comes
off the Cesium allow-list.
The preview of a shape being drawn is now two sets on the renderer's draw
port instead of a Cesium data source: one dashed rubber band along the
globe (the chosen colour at 0.9, 3 px, dash 16, primary at 0.35 behind
the surface) and a dot per vertex (8 px, black outline at 0.6, drawn over
depth). The band is written on each pointer move and vertex change
rather than re-read every frame. A pointer move now carries
`pickPosition`, its point in the pick buffer corrected for sensor styles
as a click's position is, which the rubber band follows; the tool reads
its canvas from the renderer and asks frames through the frame port.
The diagnostics count the preview sets live on the viewer
(`previewSets`, `previewItems`) in place of preview data sources.
One difference: where the band runs behind the surface it is drawn in a
solid colour, as the draw contract's depth-fail colour is a colour, not
a dashed material.
src/data/geoFileImport.js now only reads, bounds and sanitizes the
imported files (GeoJSON, GPX, KML and KMZ). Loading the parsed file as a
Cesium data source, scrubbing its entities, settling its ground pins,
the pin billboard collection and the footprint read for Fly-to move into
src/data/geoImportPins.js, which stays on the Cesium list as the
import's Cesium-bound part. The error, the entity limit, the one-minute
deadline and feature-name cleanup both parts use live in the new
src/data/geoImportShared.js; the reader re-exports them for its
existing importers.
Nothing changes for the person importing: the same files load with the
same refusals, styles, ground heights, pins and framing.
Cockpit now places its eye with the geo maths and moves the camera
through the camera port on the frame port's preUpdate, so cockpitCamera.js
and cockpitController.js no longer load Cesium and leave the allow-list.
Whether the aircraft still draws comes from a trackedEntityDrawn service,
which the application shell answers from the viewer's entities. The mesh
floor probe accepts the viewer as well as its scene.
The camera verbs size their keyhole fit by the renderer's canvas and listen
on it for the user's input, and the voice actions size their view samples
by it, rather than reaching through `viewer.scene`; a viewer with no
renderer bound answers with its own canvas, the same element. The test
fakes give their viewers a canvas, and a fake camera binding's renderer
reports the fake viewer's.
Local ADS-B's 3D aircraft are now one models set of the renderer's draw
port, re-posed in place each frame, instead of Cesium models of their own.
Ground placement samples heights through the query port and sees through
the layer's sets by id; clicks read the dispatcher's draw-set hit and the
query port's drill. A class change keeps the drawn model, at its own belly
offset, until the new asset is ready; a scale-only change applies at once.
The models file leaves the Cesium allow-list.
Cesium model sets retry a failed load when its item is next updated after
a short wait, and parse an item's tint only when it changes.
A models set kept one primitive per build and loaded every model again on
any change. Each item now keeps its own Cesium model: an update re-poses it
(position and orientation), and changes its scale, pixel floor, maximum
scale, shading, tint, colour blend, environment map, display range and show
where it is. Only a new url loads again, and the model it draws stays until
the new one is ready. `ready` fires once per load. Each frame before the
scene draws, the set caps models at their maxPixelSize, scales and fades
them by distance, and hides them past the horizon in a horizonCull set. A
load that fails is let go after its update, and stays a failure for
whenSettled until its item changes.
The stub fires `ready` only for a new item or a new url, and draws models
into readPixels as tinted squares. Its harness has a model asset now, so the
model checks run on it. New checks: a model moves, turns and restyles
without loading again, and only a new url loads it; its tint and colour
blend change live.
The voice actions now take the camera pose, view target picks and screen
projection from the camera and query ports, and do their ellipsoid and
bounding-sphere maths with the geo modules. The HUD hands its own camera
port to the basemap label lookup. The only scene object still read is the
canvas, for its size.
The verbs' motions run on the frame port's preUpdate, which Cesium raises
right after the clock tick they used to run on; a renderer bound after the
verbs started is picked up when the next motion starts. They read the camera
from its port's pose, wait for a flight through its `flying`, and frame an
orbit from the pose with the geo maths.
Globe rotation tests the keyhole fit from the pose and the port's projection
matrix (a centred perspective one) instead of Cesium's frustum, and checks
the Globe View preset by computing its pose rather than cloning a Cesium
camera. The contract's renderer is a 3D WGS84 globe, so the scene-mode and
non-WGS84 refusals go with their tests. At the start the captured pose is
written back through setView only when the camera handoff changed it (a
route's bank levelled), instead of copying the basis into Cesium's camera.
The verbs still read the viewer's canvas for its size and listen on it for
the user's input.
The route dolly's frame (arc points, horizontal chords, turn angles, the
heading's turn toward the gaze, the bank roll and the eye) and the corridor
cells now use src/geo instead of Cesium's Cartesian3, Cartographic,
Quaternion and Matrix3, with the same formulas in the same order, so every
frame comes out bit for bit as before. The mesh floor probe takes the viewer
and asks heights through heightsOf, so it sees through draw sets not drawn
for height queries, as every other height read does.
The transit trail's head is upserted where the vehicle crosses into the next
subdivision, so the Cesium draw port moves it there in the same frame
instead of building it anew; between crossings a frame changes only how far
it is revealed. A test runs the trail through the Cesium draw port across a
crossing and a second's fade, with nothing built anew.
A segmented line that was replaced by a plain one and moved while its set
rebuilds is hidden segment by segment where it was. A segmented line of no
length is patched as nothing to draw instead of rebuilt on every upsert,
and segmented lines are noted as rebuilt when they move.
The selected vehicle's trail is now two draw-port line sets instead of
Cesium primitives. The body is each run of joined history subdivisions as
draped lines in two lanes, a dark 5 px backing under the 3 px mode colour.
A subdivision shows once the vehicle has passed it and fades with its age;
both are written in place as segment shows and colours, once a second or
at a crossing, and a new mode colour is written the same way. The head is
the subdivision the vehicle is on, in the same two lanes, revealed up to
the vehicle with revealFraction: it is drawn anew only at a crossing.
Shows are written only when they change.
The transit tests bind a fake draw port, and the transit QA script finds
the trail's primitives by their draw set.
A draped solid line with segment colours or shows draws each segment as a
ground polyline instance of its own in the set's ground batch, under a
pick id that reads as the line's, so changing its colours or which
segments show writes their attributes without a rebuild; a change made
while the ground still builds is written as it swaps in. Undraped or
non-solid segmented lines are refused, and a segmented line of no length
builds no ground. The shared conformance suite changes a segmented
draped line every frame.
The shared trail renderer draws a trail's history and its live head as
lines in a draw-port set, geodesic for the history and straight for the
head, each dimmed behind the surface in its depth-fail colour, and
leaves the Cesium allow-list. The flights and military trail heads are
drawn through the trail each frame from the frame port instead of
entity callbacks, and the local ADS-B head uses the same head line. A
head given while its trail is hidden waits until the trail shows.
Geodesic lines are cut a step a degree of arc, with at least 64 steps
over the line, so a long trail of short legs costs its positions rather
than 64 vertices a leg.
The flood is two draw sets per layer: the corridor's dashed halo and
glowing core as draped lines (on tiles too under photoreal, on terrain
otherwise), moved in the frame the event moves them, and the surge front
as a clamped point. Only what changed is drawn again. Neither set is
pickable, and height queries see through both, so the shot paths no
longer list them to exclude.
The before/after images are globe-port layers on either side of the
split, over every layer drawn when they are added and draped on the
globe's surface only, as before. The divider moves the globe port's
split. An image that fails to load now takes the comparison (the pair,
the divider and its labels) down and leaves the event on, where a
failed provider used to fail the enable.
Evidence heights come through heightsOf, whose batch can now count an
answer from the bare ellipsoid as a miss, so points still fall back to
their authored elevations without terrain. The camera, canvas and the
event's vector maths go through the camera port, the renderer and
src/geo (lerp joins geo/vector).
The locator's country fill, revealed border and flood path lines, and
pulsing halos are now three draw sets per layer (fill under lines under
halos), none of them pickable. The border and flood path are draped lines
revealed with revealFraction: the old vertex-by-vertex head is turned into
a fraction of the line's length (geo/polyline lengthFraction, the inverse
of alongLength). The callout pulse brings what is drawn up to date each
frame, upserting only the lines and halos that changed. Camera moves and
flight cancels go through the camera port.
The border's own frame loop only asked for renders the pulse already asks
for, and is gone.
patchLines flattened a draped line's positions twice per upsert, once to
decide whether it could patch and once to apply it; it now flattens them
once and uses the result for both.
The Cesium draw port now drapes glow and dash lines as well as solid and
flow ones, each with its own ground primitive.
revealFraction is the fraction of the line's length, measured along the
line. Both renderers cut there: Cesium discards fragments past the cut in
the line's material, so the hidden part neither draws nor picks; the stub
cuts the line before drawing and picking.
A draped line whose positions change is rebuilt the same frame, on a ground
primitive of its own, once terrain heights are loaded; until then it is
rebuilt as before. A clamped dot whose look is unchanged is moved in place.
The stub now picks lines. A new shared conformance check, draw.lines.drape,
covers draped glow and dash lines, the reveal cut, a draped line growing
every frame, and a clamped point moving every frame.
The embedded media cards find their anchor on screen through the camera
port's pose (whether it is behind the eye) and the query port's
projection, read the renderer's canvas for its offset, and follow the
camera on the frame port's postRender. The card root still goes in the
viewer's container, which is DOM. A test binds the three ports and checks
the card follows its anchor, hides behind the eye, and unsubscribes on
destroy.
The full-globe ring reads the eye from the camera port's pose, projects the
Earth's centre through the query port, paints on the frame port's
postRender and asks it for the frame that ends a focus flight, and flies
out through the camera port with a geodetic destination. The sun and moon
come from the shared planetary model in geo/celestial, rotated into the
Earth-fixed frame: the precise ICRF frame once its tables have loaded,
which the application shell supplies from the starry sky
(icrfToFixedAxes), and the pseudo-fixed frame before, as Cesium's own
fallback did. It still reads the viewer's canvas and container, which are
DOM.
projectEarthDiscToViewport keeps its scratch arguments: the eye-to-centre
vector is still written before the facing test, which radio navigation
reads after the call.
The annotations entry loaded the Cesium port factories only through the
ring; its world renderer, which stays on the list, now loads them.
The local receiver layer draws its aircraft, the 978 MHz rings and the
selected aircraft's trail head through draw-port sets, updates them on
the frame port each frame, rotates icons from the camera port's screen
axes, and leaves the Cesium allow-list. The trail head now dims behind
terrain instead of vanishing, as the rest of the trail does.
An in-place update now applies the horizon cull at once, so a set moved
by a frame listener that runs after the draw port's own cull no longer
shows items through the globe until the next frame.
The directions layer draws its endpoint markers, its flowing route and
its maneuver dots through draw-port sets, takes clicks from the draw hit
and ground picks from the click's ground position, and leaves the Cesium
allow-list. The route keeps the annotation's flowing dashes, draped on
terrain and tiles; the maneuver dots keep their place in the sprite
order through the steps set.
Lines take the flow style, draped or not: the route annotation's flowing
dashes as a material whose clock the port runs each frame, asking for
frames while a shown set shows flow lines. Undraped lines with a
depth-fail colour draw it where the surface hides them, and one that moves
is built anew in place under the same pick id, so a line updated every
frame neither rebuilds its set nor blinks. A draped style the port cannot
drape is refused before the set changes. The shared conformance suite
draws both kinds and moves a depth-fail line frame by frame.
Unclamped points that move on an upsert now move on the point they have,
keeping their pick id and horizon cull, instead of rebuilding the set.
Points and clamped dots honour displayRange as icons do. The shared
conformance suite checks moved points and point display ranges, and the
lodGroup check now passes on the Cesium renderer too.
The private-field trim of Cesium's reused per-pass command arrays moves to
src/render/cesium/sceneCommandRelease.js. The installer waits for the
renderer frame port's postRender after each layer disable and calls a trim
the application scene hands over, so it no longer touches the Cesium scene.
Pack points, lines, polygons, image overlays and media markers are draw
sets now, one per pack resource and kind. Feature picks match the click's
draw hit by set and item id, and item ids are namespaced so code that reads
a bare pick id never takes a pack feature for a live contact. An image pack
draws its decoded pixels from a canvas: the Cesium draw port now fills
unclamped shapes with images, as the contract's fills allow, and frees
their materials with the set. The ./scenes export joins the entries whose
caller loads the unbound renderer factories.
The director converts degrees itself, finds its camera through the renderer
bridge rather than the Cesium adapter, and reads the canvas from its bound
renderer. A caller handing it a viewer of its own with no renderer bound
loads the package's ./render/cesium/unbound export first, as other
Cesium-free entries ask.
The local receiver motion model built its two chord points with Cesium's
fromDegrees only to measure the course between them. It now uses the app's
own ellipsoid conversion into plain scratch points, which gives the same
bits, and leaves the allow-list. A test pins the path-derived course for a
contact that reports no track.
The military snapshot renderer took the camera's ground point from the
Cesium camera, built fix positions and history entries with Cesium types,
re-floored stale grounded contacts with Cesium positions and handed the
scene to the mesh floor sampler itself. It now reads the ground point from
the camera port's pose, compares fix times in whole milliseconds as before,
and leaves positions, the stale re-floor and the mesh floor probe to the
military motion part. The file no longer touches Cesium and leaves the
allow-list.
The fix position, copy and history entry helpers the flights and military
motion parts both need now live once in the aircraft motion regime module.
The transit rendering part now owns everything that drives Cesium: the two
billboard collections (made, shown, cleared and removed in the same order
as before), the camera change listener and its sensitivity claim, the
preRender hookup, the camera height and subpoint reads, the globe-shown
and flat-terrain check, the mesh floor sampler call that sees through the
billboards, and the frame-measuring QA probe. The camera factory import
moves there too.
The height part asks the terrain under a vehicle through the queries
gateway (heightsOf over the query port) instead of the Cesium height
service; the Cesium query port answers it from the same loaded globe
tiles. The QA fixture paths are built with the shared ellipsoid helper,
which gives the same coordinates.
The transit tests bind a query port that reads the fake globe, and a new
test covers the hidden, terrain and flat globe answers. Height, lifecycle
and testing no longer import Cesium or drive the viewer, so they leave the
allow-list.
The radio lifecycle no longer makes, shows, hides or removes the stations'
Cesium data source or the selected station's entity itself: the rendering
part does, through installDataSource, setStationsShown,
removeSelectionEntity and removeDataSource, in the same order as before.
The camera factory import moves to the rendering part too, which stays on
the list. The lifecycle no longer imports Cesium or drives the viewer, so
it leaves the allow-list.
The flights snapshot renderer took the camera's ground point from the
Cesium camera, built fix positions and history entries with Cesium types,
and handed the scene to the mesh floor sampler itself. It now reads the
ground point from the camera port's pose, asks the flights motion part for
fix positions, copies and history entries, compares fix times in whole
milliseconds as before, and lets the rendering part sample the mesh floor.
The file no longer touches Cesium and leaves the allow-list.
The civil flights and military layers now draw their contacts as one GPU
icon set each from the renderer's draw port instead of a custom primitive.
Each contact is an icon item whose motion is the dead reckoning the layer
plans (interpolation between fixes, warm-up and coast arcs, or a hold),
with its nose gliding onto a new course at the fleet's slew cap. A
contact's item is replanned when its motion runs out, grounded contacts
are pinned with held motion, and focus de-emphasis is written per item.
The near/far image switch follows the renderer's pixel ratio, and writes
made during a fleet tick reach the set before that frame draws.
The aircraft icon layer and the flights icon part no longer touch Cesium
and leave the allow-list. Clicks resolve the draw port's pick ids as well
as the ones the tracked model and entities still carry, so selection,
follow and share-follow work as before.
Without depth textures the Cesium renderer still answers terrain heights now, from the loaded tiles, but a batch misses them as it does the surface. The gateway docs and the application guide say so.
The camera ground guard, place and landmark flights and imported-file
flights read terrain and surface heights through heightsOf, the one place
the app's height queries go, rather than asking the query port themselves.
With the annotation resolver off the allow-list, ground snapping, which
the application operations entry also reaches and which stays listed,
loads the Cesium camera factory for a viewer with no renderer bound.
The height docs say what the Cesium renderer answers without depth
textures: no surface or tiles height, and terrain from the loaded tiles.
The annotation engine no longer imports Cesium. The camera assist tests
whether a fresh mark is in view against the frustum planes of the camera
port's view-projection, with the same one-metre sphere Cesium's culling
volume used, and asks the query port whether it is behind the globe. The
view-projection is in world coordinates, so the test now also holds when
the camera has a reference frame of its own. Framing uses the camera port
and the geo helpers for spheres, angles and distances. It leaves the
Cesium allow-list.
The window.__CESIUM__ dev hook the QA scripts read moves to the
application viewer module, which every app boot loads before the viewer
is made. A new test covers the assist: marks in view, off the frustum,
behind the globe, and a camera that cannot answer.
The annotation resolver no longer imports Cesium. The view proximity
gate reads the camera port's pose and the geocode bias its view
rectangle. Screen-point picks go through the query port (depth pick,
then ellipsoid, then the globe along the pick ray) on the renderer's
canvas, and ground heights through the height gateway. It leaves the
Cesium allow-list.
Its tests bind a camera port over their camera doubles.
The screen annotation renderer no longer imports Cesium. Each projection
pass reads the eye from the camera port's pose and projects through the
query port: behind-camera and horizon rejection, then project. It
repaints on the frame port's postRender, and asks for ground heights
through the height gateway, which now sees through draw sets not drawn as
ground. It sizes the board from the renderer's canvas. It leaves the
Cesium allow-list.
The Cesium query port's project reuses a scratch point and window
position, as the renderer's own projection did.
Its tests bind fake camera, query and frame ports over their viewer
doubles. The hybrid renderer's shared fixture binds them too, so its
screen marks are projected and checked to be on screen.
The application guide now describes heightsOf(viewer): draw set ids to
see through, plain ECEF results, the surfaces each option reads, and that
the Cesium renderer answers no height without depth textures.
clampBatch answers null for a malformed position instead of throwing, and
copies the positions before the query runs so the answers stay in place.
The source scan also flags the query port's sampleHeightNow,
sampleHeightNowMany and clampToSurface outside the gateway; the four
sites that already asked the port directly are listed, and the list fails
once one of them no longer needs it.
The world overlay no longer imports Cesium. It reads the eye from the
camera port's pose, builds its view-projection from the camera port's
matrices, asks the query port whether a point is behind the globe, paints
on the frame port's postRender and asks it for renders, and invalidates
on the camera port's moveEnd. It still reads the viewer's container and
canvas, which are DOM. It leaves the Cesium allow-list.
The Cesium query port now keeps one horizon occluder per eye and a
scratch point, so the overlay's per-label horizon test allocates nothing,
as it did when the overlay held the occluder itself. The overlay tests
bind camera, frame and query ports over their viewer doubles, the
allocation probe using the Cesium port's own horizon test.
The Cesium scene's height service moves into the Cesium adapter
(src/render/cesium/heights.js), where the Cesium query port answers its
height members through it; the files still bound to the Cesium scene
import it from there.
src/queries/heights.js becomes the height gateway over the renderer's
query port: heightsOf(viewer) answers now, clampNow, batch, clampBatch and
supported as before, a miss is null, a failed or destroyed query rejects,
and exclusions are draw set ids. The source scan that keeps height queries
in one place still holds: outside the renderer, only the gateway asks for
streamed heights. The bikeshare layer samples its station heights through
it.
Heights leaves the allow-list.
Add fromDegreesInto to geo/ellipsoid: the same steps as fromDegrees in
the same order, so the same bits, written into a given object. The dense
catalog sweep and the tracked-frame sample use it instead of allocating
a fresh point for every move.
The off-Cesium guard now also catches member reads on the dot, ring and
tracked-entity handles through optional chaining or brackets, handles
taken into local names, destructured or spread, and checks its own
patterns against examples of what they must and must not catch.
The point collection and its dots, the baked orbit rings, the tracked
entity, the frame number, the focus publish and the pick decoding now
live in rendering.js, behind small helpers that take ECEF positions and
render-contract colours. The catalog, controls, ingestion, lifecycle,
orbits, policy, records, state, testing and tracking parts no longer
import Cesium or touch the viewer, scene or primitives, and leave the
allow-list. Point styles are [r, g, b, a] colours, converted once per
style; geodetic conversions use the geo helpers; the per-frame tick runs
through the frame port. What the layer draws and how it follows is
unchanged.
The box selection tool no longer builds Cesium entities itself: its fill
and dashed outline live in createImageryBoxPreview in the recent imagery
rendering module, and the tool takes the preview as a dependency. The
cockpit contact card reads the nearest contact's position with the geo
helpers. Both files leave the allow-list.
Tests now inject the preview with the Cesium double, check that a second
destroy returns the same promise, and pin the nose-relative bearing to a
known contact.
The shell's camera snapshot now comes from the camera port's pose and its
restore converts with the geo helpers. The shell stays on the allow-list:
it still loads the Cesium camera and effects factories for the entries
that reach it.
The map orientation controls pick the view's centre through the query
port (depth, then the globe along the pick ray, then the ellipsoid), read
the camera from the camera port's pose, and set the orbit frame through
the port's lookAt, release and setView. The eased orientation runs on the
frame port's preUpdate, the compass needle on its preRender, and the tilt
state refreshes on the camera port's moveEnd.
While the camera follows something, the orbit offset must stay in the
follow's own frame (a satellite's included), which only Cesium knows: that
step moves verbatim into placeFollowEye in shareFollow, which stays on the
Cesium allow-list. cameraOrientationControls leaves it.
The camera ground guard reads the eye from the camera port's pose, the
flight state from the port, and the surface under it from the query port's
heights, and lifts through the port. Place and landmark flights read the
terrain height from the query port and build their targets with geo.
Framing ranges read the field of view from the pose (the frustum's
wider-side angle, as it read before). An imported file's flight frames its
footprint, plain lon/lat/height points, with geo's bounding sphere and the
port's flyToBounds; walking the file's Cesium data source for those points
moves into the file importer, which stays on the Cesium allow-list.
The Cesium query port answers terrain heights without depth textures, as
the height service always has: only the drawn surface needs them.
cameraGroundGuard, locations, cameraFraming and flyToDataSource leave the
allow-list. The annotation resolver, still listed, loads the camera
factory for the application operations entry, which reached it through
locations before.
The navigation controller and the location navigation cancel flights and
read the camera's place through the camera port. Point-and-ask's camera
pose key and its "around here" radius read the camera port's pose; its
entity pick moves into the input dispatcher (pickAt), which picks as a
click does, so the follow's helper still reads as its target.
navigationController, locationNavigation and pointerPick leave the Cesium
allow-list. Their package entries (./ui/navigation and three voice
entries) no longer load the Cesium adapter: given a viewer of a
caller's own, they find its camera once the caller loads
./render/cesium/unbound. They are listed as such in the unbound camera
test, which fails if one starts loading the factory again.
The flights controller reads the camera's longitude and latitude from the
renderer's camera port instead of the Cesium camera, and asks for no area
when the pose has no ground point or the viewer is gone. It no longer
imports Cesium or reads the viewer's camera, so it leaves the allow-list.
The flights entry already loads the Cesium camera factory for viewers with
no renderer bound.
The camera pose key moves to render/camera/poseSignature.js, Cesium-free, and
iconOrientation's cameraPoseSignature builds the same key through it. The
vessels frame hook reads the pose only when a pass runs or a moved camera
could still need its trailing pass, and the unused focus scratch point goes.
The draw port takes the frame port's requestRender, so a GPU icon set's own
frames (its images packed into the atlas) are asked for under the reason
icons:<set id> in the frame diagnostics, where the vessels layer's own
ais-vessels-icons reason used to be. Other draw requests are unchanged.
A host with no registerSpriteSet still draws the ships and warns once. The
vessels draw test now checks the sprite order finds the set's host, and that
a torn-down layer draws a new set registered in the old one's place. The new
motion, icon book and pose key tests join the format check.
The GPU icon shader sizes its slot array to what the context can address:
the vertex uniform vectors it has, less 80 kept for the shader's other
uniforms, between 64 and 176. A WebGL 2 context addresses all 176; a context
with little room keeps the old 64, refuses sets that would need more, and
warns once if the atlas outgrows it. Slots past the array are never read.
The aircraft layers lift a contact for the horizon test only when its fix
is below 10 m; a horizon-culled set on the Cesium draw port lifts every row
drawn below 12 m, and the contract has no per-row lift to say otherwise.
The 10 m threshold is now named beside the cull height (iconSet's
ICON_CULL_LIFT_BELOW_M, which the aircraft icon layer reads), with what the
two rules share and where they part: they agree on every row the aircraft
rule lifts and every row drawn at 12 m or more, and the port judges the rest
higher (a contact between 10 and 12 m, or one drawn below its fix), so it
never hides what the aircraft rule shows. No renderer change: a 10 m
threshold in the port would change the ships and fires it already draws.
The draw contract measures an icon's imageLod switch in CSS pixels; the
aircraft layers' GPU icons switch to their near image past 76 device
(drawing-buffer) pixels. iconAtlas now names that switch, which the icon
shader reads, and nearImageSwitchPx(pixelRatio) gives it in CSS pixels for
a layer moving onto the draw port: 76 over the scene's pixel ratio, the one
the quality port's frame signals report. On the default renderer that is
its pixelRatio setting, or 1 while that is browser-recommended;
devicePixelRatio does not enter it, so the default is 1.
The Cesium draw port's GPU icon sets put each image into the shared icon
atlas at the item's drawn size. An SVG data URL (or SVG ref) that gives its
root a pixel width and height now takes the atlas at the larger of those,
at most 256 px, as a billboard rasterises it at its natural size; other
images still take the drawn size. A layer drawing a 64 px glyph at 20 CSS
px, with a 192 px near image, keeps both rasters through the draw port.
The atlas-room check counts the same slots the rows then take.
Ships (32 px SVGs drawn at 32) take the slots they took before.
render/motion/iconBook holds the icon items a layer drew to a draw set, as
the vessels' book did, and now also when each one's motion stops being what
the layer would plan: put(item, {expiresAt}) records it (Infinity: planned,
never due; null drops it; a restyle keeps it), and due(t) lists the ones to
plan afresh. It reads a moving icon's position and course at a time through
the shared evaluator, as the renderer draws it given its capabilities. An
item easing its course by courseBlendMs reads its target course.
This is what a layer with dead-reckoned contacts keeps on the CPU in place
of the GPU set's own row expiry. The vessels' icon book is now this one.
render/motion/iconMotion evaluates a draw item's motion segment and course
glide at a time on the set's motion clock, without a renderer: where the
item is drawn, the course it is drawn with, and when its motion ends. The app
can now read a moving icon back (to follow it, label it, judge a pick or
its horizon) the way the renderer draws it.
The stub renderer evaluates its segments with it, in place of its own copy,
and so now steps a lerp with no span 1 ms after t0, as the Cesium renderer
does. The Cesium GPU icon sets read the course shown before a write, a
blend's target and when rows stop moving through it, from copies of what
they wrote, and write each glide with the offset it computes, so an exact
half turn goes the way the app reads it.
norm360/norm180 and Position-to-ECEF move to geo for both to share.
Conformance gains a check that icons are drawn where the evaluator puts
them.
The weather layers listen for the camera's moveEnd through the camera port,
find the map centre through the query port's ellipsoid pick and the app's WGS84
helpers, and fly through the port's cameraOf. The shell rendering part, which
stays Cesium-bound, now defaults the Cesium namespace, provides the fallback
globe imagery host, and loads the adapter factories for a viewer with no
renderer bound.
The weather entry leaves the allow-list. It still reads the viewer's canvas
size for the centre pick.
The station discs are now one draw set of ground-clamped filled ellipses per
layer, with the same band colours, alpha and radius, and their readings as
item meta; they had no visible outline before either (Cesium turns outlines
off on clamped entity ellipses). The readout's in-view list reads the view
rectangle through the camera port. The layer no longer imports Cesium and
leaves the allow-list; a caller handing it a Cesium viewer of their own,
with no renderer bound, loads the ./render/cesium/unbound export once first.
Double-clicking a station no longer starts the viewer's entity follow, since
draw items are not entities.
The wind reading at the map centre now asks the renderer's query port where
the ellipsoid lies under the middle of the canvas and converts it with the app's
WGS84 helpers, instead of Cesium's camera pick and Cartographic. The
inspection marker projects its point with the query port, hides it beyond
the ellipsoid's horizon with isOccluded, and follows rendered frames through
the frame port's postRender phase instead of the scene's event. The layer
entry no longer carries a Cesium namespace: the rendering part, which stays
Cesium-bound, defaults it, owns the fallback globe imagery host, and loads
the adapter factories a viewer with no renderer bound gets its ports from.
The wind entry, its inspection reading and its marker leave the allow-list.
They still read the viewer's canvas size and container element.
The coverage lines are draped line sets on the draw port now, not
ground polyline primitives of the layer's own. A tile draws in sets of
120 line parts, as its primitives were batched; each part is an item of
its own (its id made unique in the tile) that picks its sequence
(`meta.pick`). A filter change redraws the sets in place, so the old
lines show until the new ones are ready. The selected sequence is one
set over the coverage, redrawn in place as tiles land; the tiles hide
their own lines of it, a show change made in place, so it shows
whichever set is drawn over which. The wait for the terrain-height
table goes: the renderer builds draped lines when it is ready. A colour
the layer cannot read is handed to the renderer as given.
Clicks no longer read the renderer's pick. The click dispatcher's event
gains `windowHit(width, height)`, the wider pick read as the canonical
id, the draw-set hit and whether it is the map itself. Street Level
routes its own sets' hits by their pick, anything else (a provider's own
drawing) by its id, as before; the ground under a click comes from the
event, and the ground click is told whether the map was hit. The screen
centre is aimed through the query port, a pick that fails counting as a
miss. Street Level no longer reads the scenePick service.
The Cesium draw port no longer lets a show queued while a draped line
built override one applied once it was ready, before the swap: the
highlight hand-over now depends on that.
lineCoverage leaves the Cesium allow-list; with it every Street Level
file named in this work is off the list.
Differences the contract does not let us avoid:
- The lines draw among the scene's primitives, not its ground
primitives: they now draw over other layers' clamped entities and
ground primitives, and win picks against them.
- The highlight builds asynchronously: a newly selected line is not
drawn for the frames that takes.
- Lines of other sequences in tiles that land after the highlight was
first drawn cross over it.
The photo marker and every provider's image cones are icon sets on the
draw port now, not billboard collections of their own. Each keeps its
pick id as the item id, so clicks route as before; each set is drawn
(empty) as soon as it is made, so the cones stay drawn over the marker
whichever is first given something to show. The horizon cull still runs
in the layer, against the ellipsoid lowered 1,000 m, and sends only the
items whose show changed; a quiet first cull of items about to be drawn
replaces the flags that held its callback back.
marker and sequenceCones leave the Cesium allow-list. The Panoramax line
click reads the camera height from the camera port.
A difference the contract does not let us avoid: the icons turn to their
bearing about local north (the contract's `course`), where the
billboards used the Earth's axis. Looking straight down nothing changes;
in a tilted view a cone now points along its true bearing on the ground
instead of leaning toward the pole.
The Street Level view maths no longer reads Cesium. The camera's place
comes from the camera port's pose; the visible box and the view focus
cast the query port's screen rays and meet them with the ground, the
WGS84 ellipsoid raised to the ground height, in geo; heights come from
the query port; the horizon cull for the marker and the cones tests
against an ellipsoid 1,000 m below WGS84 in geo and re-culls on the
frame port's pre-render. Ground clicks, the screen-centre aim, the
nearest-image point, photo framing, the coverage refresh and the ground
re-measure read the same ports and convert positions with geo.
geo's ellipsoid functions (toLonLatH, rayEllipsoid and those under them)
and horizonFrom take an optional ellipsoid, made with ellipsoidOf or
offsetEllipsoid; anything else, a map index included, means WGS84. Tests
check them against Cesium on raised and lowered ellipsoids.
view, index, cameraFraming, groundClick and selection leave the Cesium
allow-list. The Street Level entries are Cesium-free callers of the
unbound factories: given a viewer of a caller's own, with no renderer
bound, the caller loads ./render/cesium/unbound first. GhostMaps, which
uses the horizon cull and is still on the list, loads the camera factory
itself.
Differences the contract does not let us avoid:
- The ground under the camera no longer reads whether the globe is shown
(the globe port has no visibility getter). Where 3D tiles answer under
the camera they decide, as they did under Google 3D; elsewhere the
terrain answers, then the drawn surface below the camera. Over 3D tiles
shown on a map with the globe (and under other primitives at the
nadir) those now count as ground.
- Without depth-texture support the query port answers no heights, the
terrain included, so the ground then reads as the ellipsoid.
- selection and groundClick still read the click dispatcher's own pick
for now; they move to draw-set hits with the coverage lines.
The orbit controller and the frame-rate monitor had left the Cesium
allow-list but still hooked the scene's preRender and postRender events.
They now listen through the frame port; the monitor looks the port up
each time it is shown, so a renderer bound after it was created is the
one it counts.
The weather globe rendering had left the Cesium allow-list but still
listened to the scene's postRender event to admit, install and retire
frames, and asked the scene for renders directly. It now uses the frame
port, looked up the same injectable way as its globe, camera and credits
ports.
The cables lifecycle and ingestion parts had left the Cesium allow-list
but still hooked the scene's preRender event and asked the scene for
renders directly. They now use the frame port.
The awareness lifecycle and focus parts had left the Cesium allow-list
but still hooked the scene's preRender event and read the Cesium
camera's position and orientation. They now use the frame port and the
camera port's pose, with the same quantized motion signature.
The radio interaction, selection and navigation parts had left the
Cesium allow-list but still read pick objects, toggled entity
visibility, removed the selection entity, re-ran clustering and read the
Cesium camera. Navigation now reads the camera port's pose; the rest
moves into the rendering part.
The camera layer's lifecycle, cards, geometry, hover and selection parts
had left the Cesium allow-list but still drove the scene: Cesium camera
move events, scene picks and pick objects, entity removal, the
activation ray probe and the cards' canvas projection. The move events
now come from the camera port and card render requests go through the
frame port; the rest moves into the rendering part, which stays listed.
The move listeners are attached and released in one place, with a test.
The replay chase camera and the mission frame pass listen on the frame
port, the hover on the camera port's move events. Showing the missions,
clearing their entities and reading mission picks move into the launches
rendering part, which stays on the Cesium allow-list, so the layer's
other files no longer drive Cesium. A replay with no frame loop to move
its camera on does not start.
The ships are one icon set from the draw port, held on course with hold
motion segments and drawn over depth as before; the layer keeps what it last
drew in an icon book and reads focus and pick ownership back from there,
matching clicks on the draw hit's set and id. Its frame hook, camera pose,
horizon test and screen projection come from the frame, camera and query
ports, with the horizon lift in geo/horizon judging the same point the GPU
cull does. The icons' draw set is disposed when the layer is destroyed.
rendering.js no longer imports Cesium or touches the scene's primitives,
picks, render events or camera, and leaves the Cesium allow-list. It still
reads the canvas size for the label budget. Callers of the vessels entry
load the Cesium adapter's unbound fallbacks.
An icon set whose items move along motion segments, glide their course,
recede toward the limb, pick through a larger proxy or switch images by
drawn size, or that takes columns, now draws as one instanced
IconSetPrimitive in place of its billboards. The set switches the first time
an item needs it (or columns arrive) and stays switched; a course blend
alone switches it only when everything it holds can go. The Cesium ports
advertise columns, motionSegments and courseGlide.
GPU sets refuse loudly what billboards draw and they do not: clamped
heights, fadeByDistance, displayRange, offsets, anchors other than the
centre, axis and screen rotations, opaque and additive blends, images other
than URLs and SVG, and more images than the shared atlas has room for. A
refused write changes nothing.
The shared icon columns gain an image switch size, a pick proxy and a
per-row depth-test distance (defaulting to always over depth, as before),
arcs gain a climb rate, and the epoch rebases in both directions. Rows keep
asking for frames while they move, turn or blend; a write that moves a row
as it already moves (a restyle, a focus change) leaves its segment alone.
Billboard icons now fade with focus as GPU ones do.
Conformance gains columns and motion checks for the Cesium adapter.
Road surface refinement and the development timing marks now listen for
drawn frames on the renderer's frame port instead of the scene's own
postRender event. Refinement reads the drawn frame's surface readiness
directly, since frame-port listeners run before the rendered-frame
observer. The view-height estimate's globe and sample-height reads move
into the surface module, which stays on the Cesium allow-list.
Height easing projects waypoints through the query port and keeps them
beyond the camera's near plane from its pose, instead of the Cesium view
matrix and scene transforms. Point maths uses new allocation-free geo
helpers (distanceSquared, copyInto, lerpInto), which road selection now
shares. Retention leaves the Cesium allow-list.
Road selection reads the depth probe and each waypoint's window position
through the query port and the eye through the camera port, and keeps its
point maths in plain geo helpers. Flow leaves the Cesium allow-list.
The traffic layer's camera altitude, view bounds and fetch centre come from
the renderer's camera port (its pose and view rectangle), and the reticle
footprint samples the ground with the query port's ellipsoid picks and
rays instead of the camera's own. The footprint's nadir is the pose
position in geodetic radians, as the camera's own cartographic position
was. A pixel the renderer has no ray for (a canvas of no size) samples no
direction, as the unset scratch ray did. The lifecycle part loads the
default renderer's camera factory, so a viewer of a caller's own gets
both ports.
Footprint and viewport leave the allow-list.
Road waypoints are plain ECEF points from the geo helpers (the same
formulas as before, so every waypoint and segment length is unchanged), and
the palette is renderer colours. The style part, still on the point
primitives, turns those into the points' colours once per colour and owns
the dot painting the model used to do itself; the rendering part converts
them for the heat lines. The animation keeps its own lerp scratch, and the
ingestion's centre height asks with plain degrees.
Ingestion, model, policy, state and timing leave the allow-list.
The replay vehicle overlay asks the renderer's query port where the vehicle
and its path tangent land on screen, instead of Cesium's scene transforms,
and the anchor horizon test uses the geo vector helpers and the WGS84 radii.
A point behind the eye, or a scene with no query port, hides the overlay as
an unprojectable point did before.
Overlays leaves the allow-list.
The viewshed palette is renderer colours from a new hslColor in
render/color, which computes as the renderer's own fromHsl does (the CSS
HSL reading now goes through it). The volume primitive builder moves,
unchanged, into the camera layer's rendering part, which converts each
record's palette to Cesium colours once and draws the lines and volumes
with them as before. Tests check the palette against the renderer's
colours exactly.
cctvViewshed leaves the allow-list.
The frustum's view axis comes from geo/frames' east-north-up frame, and
the activation probe's mount point and hit distance from geo/ellipsoid and
geo/vector; a new test checks the axis and the monitor plane's orientation
against the renderer's own transforms, bit for bit. The mesh-floor
sampling reads the eye through the model's camera-port helper.
What the geometry part did with Cesium moves, unchanged, into the
rendering part, which owns the layer's Cesium drawing: the positions the
entities take, building the five coverage lines, building and removing
the viewshed volumes, the photoreal tileset readiness check, and the
probe's one ray pick, which now goes through a small rendering helper.
Geometry leaves the allow-list.
Cards, the geometry queue, the nearest-camera search, auto-hop's view
context and the view motion pass read where the eye is from the camera
port's pose, through one model helper that answers null when there is no
camera or the eye has no geographic position, as the code did for a
missing cartographic position. The motion pass measures with geo/vector,
and a camera's first position comes from geo/ellipsoid as a plain point;
everything that reads it takes x, y and z. Navigation flies through the
port it already used, now found through rendererOf; the rendering part
loads the camera factory so a viewer of a caller's own still has one.
Cards, geometryQueue, navigation and lifecycle leave the allow-list.
The layer's colours are renderer colours; the parts that still draw with
Cesium (icons, coverage lines, the monitor plane) turn them into Cesium
colours with the adapter's own conversion. The screen and matrix scratches
are plain objects, which is all the projections that fill them write.
The model part converts angles with geo/vector, reads where the eye is
from the camera port's pose, and builds the monitor plane's orientation
with geo/quaternion from the same axes; the projection part hands the
entity a Cesium quaternion of it. The photoreal tileset readiness check,
which looks through the scene's primitives, moves to the geometry part.
The ground pass moves a camera icon by writing geo/ellipsoid's position
into the record's own position object. The test plane's plain material
comes from the projection part, and the selection part only lost an
unused import.
All give the same numbers as the Cesium calls they replace. Policy,
state, selection, testing, model and ground leave the allow-list.
The ALPR badges were Cesium entities whose billboards the layer changed in
place: the canvas overlay swapped a badge to a faint pick target at its
anchor, selection swapped the image, and unresolved floors clamped to the
ground. They are now one icon set from the draw port, updated in place
through upsert, so selection and the overlay swap change the same
billboard without a rebuild or a blink. Badges keep their scale by
distance, ground clamping and depth-test settings.
Marker state lives in the app (markerState.js): a plain carrier per camera,
registered as the camera's context entity, and a marker set that batches
changes and sends only the icons that draw differently. Clicks on native
badges come from the dispatcher's draw hit. Projection, the on-screen
count, height samples (excluding the layer's own set), the screen-centre
ellipsoid pick and the camera reach the renderer through the query,
camera and frame ports. A resync of the overlay now hands back only the
cameras that leave it, so kept ones are not written twice.
index.js, overlay.js and presentation.js leave the Cesium allow-list; the
layer's entry is Cesium-free, and a caller's own viewer loads the
unbound factories.
Differences the contract does not let us avoid:
- Double-clicking a badge no longer starts the viewer's entity follow,
since draw items are not entities.
- The terrain fallback for anchors is no longer skipped while the globe
is hidden: the globe port has no visibility getter.
- Without depth support the query port answers no heights, terrain
included, so anchors wait for a cached floor there.
- On a viewer with no renderer bound, the surface counts as settled
when anchors are refined.
The named-site dots are a draw-port point set with horizon culling instead
of a raw point collection; their on-screen count tests the ellipsoid
horizon and projects through the query port, and they follow the camera
port's changed and moveEnd events and the frame port's preRender. Points
that only change look (a selection) are restyled in place. Clicks on a dot
read the draw hit; the item id is not the bare record id, so sibling
layers' pick-owner checks still treat a dot click as nobody's.
Code that only asks whether a click hit anything (the CCTV layer) now sees
a dot click as a hit, as it already did for the site markers: a draw item's
pick always resolves to its id.
The named markers leave the Cesium allow-list. The site markers in
rendering.js stay entities.
Trail vertices are geo/ellipsoid positions and the minimum move is measured
with geo/vector, both giving what the Cesium calls gave. Re-anchoring rows
when the geoid loads asks the rendering part for the anchor, now one
function prepareRecordVisual shares, so icon positions stay Cesium values.
The shared trail renderer takes plain ECEF positions as well, turning them
into Cartesian3s for its polyline; the Cartesian3s other layers hand it
pass through untouched. tracking leaves the Cesium allow-list.
The area the vessel feed asks for comes from the camera port's pose and
the query port's ellipsoid pick at the middle of the screen, converted
with geo/ellipsoid, rather than from the Cesium camera; the development
evidence snapshot projects through the query port. Both answer as the
Cesium calls did. The rendering module, still on the Cesium allow-list,
loads the camera factory so a viewer of a caller's own still has both
ports. cameraArea and evidence leave the Cesium allow-list.
The focus pass's screen scratch is a plain { x, y } (Cesium only writes x
and y into it), and getNearby measures distance with geo/vector, which
gives the same result for Cartesian3s. Both files leave the Cesium
allow-list.
The layer's entity data source is now created and removed by the
rendering part, which owns the entities and stays on Cesium: the replay
vehicle and the live payload move every frame, the selected site is the
viewer's selected entity, and the orbits draw with their own materials.
The hover keeps its pending pointer position as a plain point.
Lifecycle leaves the allow-list.
Replay and selection no longer import Cesium. Their maths uses the geo
helpers; the full-globe framing reads the camera's position and field of
view from the port's pose. Choosing the selected entity, showing only the
selected mission's entities and reading the projected orbit for framing
move into the rendering part, which owns the entities, so selection no
longer touches them. The full-globe framing now checks the canvas size
before it asks for the camera.
The replay camera still steps in the scene's preUpdate, as before; it moves
onto the frame port once unbound viewers have one.
Replay and selection leave the allow-list.
The launches layer's path building, replay camera maths, policy constants,
state, marker colours and mission panel no longer import Cesium. Paths and
camera poses are plain ECEF points computed by the geo helpers with the
default renderer's own formulas in the same order, so trajectories, orbits
and camera framing land where they did. Geodesic interpolation moves from
the stub renderer into geo/geodesic (geodesicLine, solved once per
geodesic), and geo/sphere gains the renderer's sphere union.
Marker colours are renderer colours, with the panel's CSS from the same
palette. The rendering part, still Cesium for its entities, converts the
plain points where the entities take them, culls with the shared horizon
test, loads the unbound camera factory, and hands the panel the live
payload position directly instead of through the entity.
Camera, model, panel, paths, policy, policyHelpers and state leave the
allow-list.
findFrame and frameOf find the bound renderer's frame port or, for a
caller's viewer with no renderer bound, one the Cesium adapter's factory
builds over it, as findQuery and findDraw do. Unlike the renderer's own,
it leaves the viewer's loop as its owner set it up: it listens to the
scene's phases, asks for frames, holds by asking again after each one
drawn, and maps suspend, the target rate and scene time onto the viewer.
Its preUpdate says whether the tick draws by the same test the renderer's
frame port makes, now shared by both.
The active fires layer's cards and LOD watcher take their query and frame
ports from findQuery and findFrame, in place of the layer's own copy of
projection, occlusion and preRender over the viewer's scene.
The Cesium query port moves out of createCesiumPorts into its own module,
unchanged, so it can also be built over a caller's viewer with no
renderer bound. findQuery and queryOf find the bound renderer's query port
or, for such a viewer, one the Cesium adapter's factory builds, as findDraw
and findCamera do. It picks the sets drawn through findDraw on that viewer
and its height samples see through them, so a layer can exclude its own
sets; it projects, casts rays and picks the ellipsoid as the renderer's
does. A renderer bound later answers new callers.
The camera factory and the caller's unbound export load it, and the
factory walk checks that every public entry reaching a findQuery or queryOf
caller loads it, or is a Cesium-free entry whose caller does.
Cesium icon sets now draw an item's scaleByDistance, fadeByDistance and
displayRange, as point sets already draw their curves, and drop them again
when a restyle in place leaves them out. An empty display range shows the
icon nowhere; a curve whose far end is not past its near one is left out
rather than refused mid-update. Cesium eases between a curve's ends rather
than interpolating linearly, as it always has for points.
The reference renderer now scales an item's pick size by its distance curve
and leaves out items faded or scaled to nothing, and the draw.icons.distance
conformance check covers all three fields.
An icon set's upsert, set, remove and an atlas registered again now restyle,
move, re-image, add and remove billboards in the collection the set already
has, so markers no longer blink as every image reloads on each change. A
changed image swaps on its own billboard; the old one keeps drawing until
the new one has loaded.
The set is still built anew where changing it in place would not draw the
same: when new icons would land ahead of drawn ones, when a set reorders
its items, when a key's generated image comes as a new canvas, when the
set is emptied, and when its collection would hold many more images than
it draws (a collection keeps every image it has loaded).
Adds the draw.icons.update conformance check.
A page's frames come at the display's rate: at 240 Hz the 20 frames the
check allowed pass inside the 100 ms flight, and it failed on 'the flight
ended'. It now waits up to a second by the harness clock, still capped at
600 frames, as the moveEnd check does.
The layer's view rectangle, wide-view pose, flights and camera events now
go through the camera port, and its distance and position maths through
the geo helpers: getNearby confirms candidates with the ported
ellipsoidal geodesic, as before, and returns plain ECEF positions. Class
colours are renderer colours; the entities convert them. The layer's
camera `changed` listener has its own 0.01 threshold on the port, the
sensitivity it already claimed while on; the claim stays for other raw
camera listeners.
Controls, lifecycle, model, state and viewport no longer import Cesium
and leave the allow-list. Rendering and the named markers stay on
Cesium: the site markers are entities because the camera follows them
on double-click and the tracked card reads its title and position from
them, and the entity data source moves from lifecycle into rendering.
Rendering loads the unbound camera factory for the parts that reach the
port.
The test camera bound over a Cesium-shaped fake now answers its view
rectangle from the fake's computeViewRectangle when it has one.
Cable lines, landing pins, polygon fills, reference stems and reference
points are now five draw sets per layer (submarine-cables:N:lines and so
on) instead of GeoJSON data sources and entities. Clicks resolve through
the draw hit; flights and the sweep's eye go through the camera port.
The layer keeps the styling the GeoJSON loader gave it: cable colours,
widths and alphas, simplestyle stroke, fill and marker properties, fills
that keep the source's alpha, raised polygons at their heights, the
default pin image, and features without a reference drawn but neither
picked nor culled. Lines are densified along rhumb lines at the
renderer's own granularity, so the draped geodesic arcs land on the same
vertices the rhumb-line polylines did.
Supporting pieces:
- geo/rhumb, geo/horizon and geo/geodesic port the default renderer's
rhumb line, ellipsoidal occluder and Vincenty inverse; the stub
renderer now uses the shared horizon test and Vincenty inverse
instead of its own copies. render/color gains cssColor, which reads
CSS colours as the renderer does (hex, rgb, hsl; not named colours).
- The Cesium draw port changes a line in place when only whether it
shows changes (draped, on its ground primitive, waiting for it to be
ready rather than restarting its build) or where an undraped line
runs; anything else still rebuilds. Icon sets honour their blend.
Ingestion, interaction, overlay, policy, rendering, state and surface no
longer import Cesium and leave the allow-list. Pins are culled at the
horizon each frame by the draw port instead of on the sweep, and
marker-symbol glyphs are not drawn inside pins.
Changing pickable, blend or clampTo through setOptions rebuilt a set of
every kind, so a models set loaded each glTF again and blinked. Now blend
rebuilds points only, pickable rebuilds only shapes and lines (whose ground
primitives build it in), and clampTo rebuilds everything but models, which
clamp nothing. The other kinds read those options at pick time.
Feed activation and the view bounds read the camera port's pose and view
rectangle instead of the Cesium camera; the look-at centre comes from
geo/rectangle, which crosses the antimeridian as Cesium's does. The layer's
lifecycle loads the Cesium camera factory, so a viewer of a caller's own
still has a camera to read. viewport leaves the Cesium allow-list.
The per-frame scratch position is a plain object, and trail vertices come
from geo/ellipsoid's fromDegrees, which matches Cesium's to the bit; the
billboards and trail geometry they feed copy them as before. The pick
diagnostic names the picked marker's collection from its vehicle rather
than from Cesium's private field. state, trails and selection leave the
Cesium allow-list.
The ALPR model's great-circle destination and the direction wedge's
corners now come from src/geo: the same numbers, the corners plain ECEF
rather than Cesium objects, which the overlay projects as before. Both
files leave the Cesium allow-list.
The Contacts layer's 250 km rim is now an outline-only ellipse in a draw
set of its own, taken from drawOf(viewer) when it is first drawn: the
same colour, height and radius, moved only after the subject travels 250
m, cleared with the subject and disposed with the layer. A rim drawn on
another viewer is redrawn on the current one. The Cesium draw port draws
the outlines of ellipses it does not clamp as the entities did, with an
outline geometry.
The layer's positions are plain ECEF from src/geo rather than Cesium
objects, the compass reads the camera through its port's pose, and its
flights go through cameraOf from the renderer bridge. Its four files
leave the Cesium allow-list; a caller handing the layer a viewer of its
own loads ./render/cesium/unbound first, as for earthquakes.
Heat cells are clamped rectangle fills in one draw set per layer
(firms:N:cells) instead of entities. The LOD watcher follows the camera
port's pose, view rectangle and moveEnd and the frame port's preRender;
cards project and horizon-test through the query port. Colours, the view
change thresholds and the padded bounds are unchanged. On a viewer with
no renderer bound, the layer answers projection, occlusion and preRender
from the viewer's scene, as it did before.
Policy, model, state, viewport, cards and lifecycle no longer import
Cesium and leave the allow-list. Rendering keeps Cesium for the detection
icons, which stay on the shared icon-set primitive, and loads the unbound
camera and draw factories. Heat cells are no longer entities, so
double-clicking one no longer makes the camera follow its centre.
Cells are clamped rectangle fills in one draw set per layer
(gnss-integrity:N), made with pickable: false so they never hide what is
under them from clicks, as before. The view anchor comes from the camera
port: where the line of sight meets the ellipsoid, else the middle of the
view rectangle, else the point under the eye. Re-anchoring follows the
camera port's moveEnd and changed events. The ray-ellipsoid intersection
moves from the stub renderer into geo/ellipsoid.js for both to use, and
geo/rectangle.js adds the antimeridian-aware width, height and centre of
a radian rectangle. The layer leaves the allow-list; the QA script finds
the cells among the scene's unpickable ground primitives.
Perimeter fills are clamped polygon fills with their holes, and fire
lines are draped lines along each outer ring, in two draw sets per layer
(fire-perimeters:N:fills and :lines). Clicks read the draw hit and match
the layer's own set and item ids. Colours, alphas, widths and clamping
are unchanged. The layer no longer imports Cesium, so it leaves the
allow-list and joins the entries whose callers load the unbound draw
factory. Hex palette colours become renderer colours through a small
shared helper.
Ground fills of such a set are built as ground primitives that skip the
pick pass, since a GroundPrimitive adds pick commands even with
allowPicking off; draped lines are built with allowPicking off. Turning a
set unpickable rebuilds it and lets its old ground go at once, so it stops
hiding the ground from picks straight away.
Radio's camera state, globe recenter plan and viewport anchor now read the
camera pose instead of the Cesium camera. The anchor intersects the view
ray with the ellipsoid through a shared rayEllipsoid helper, moved into
geo/ellipsoid from the stub renderer and checked against Cesium. Scratch
vectors are plain objects. navigation, queries and state leave the Cesium
allow-list; rendering and lifecycle stay, since they rely on entity
clustering, which the draw port does not offer yet.
Station dots and the selected-station highlight are now two point draw
sets, picked through the draw hit, and the layer follows the camera
through the camera port at its own threshold instead of the shared
percentageChanged ledger. Altitude and view centre come from the camera
pose and view rectangle. All five bikeshare files leave the Cesium
allow-list.
The Cesium draw port now keeps a rebuilt host in its place in the scene
instead of re-adding it on top, tags hosts with their set id so sprite
order can raise a draw set (registerSpriteSet), and restyles unclamped
points in place when they have not moved, so a status poll or selection
no longer rebuilds every station. Other draw-port layers (cyclone
markers, earthquake discs) now also keep their first-build slot rather
than jumping above the sprite layers on each rebuild.
At start-up the app now sets the globe's visibility through its bound
renderer's globe port rather than on the Cesium scene. The map
controller keeps writing the scene: it is a public entry, and on a
caller's own viewer the port would be one built just for it, whose
listeners outlive the controller.
The two recent imagery slots now add their GIBS layers through the
globe port and share their six-request budget through its admission
hook. The port moves the layers between the globe and the base tileset,
which the renderer now marks as a base when it is the host.
The renderer stays the layer's Cesium side: it still loads the camera
factory, and now the globe factory too. The weather and wind entries
load the globe factory as well, and the factory check counts callers
that take findGlobe as a default.
Radar, satellite clouds and lightning frames are imagery layers of the
globe port instead of Cesium providers in the viewer's collection. A frame
stages as a transparent layer on the globe's surface and counts its tiles
through the layer's admit hook; the global infrared mosaic draws each tile
of the geographic grid from the decoded canvas, the regional infrared
transfer runs as the layer's tile transform on the upright tile, and
throttled tiles are fetched again by the renderer. Readiness reads the
port's imagery settling, the camera port gives the view and its move end,
and the frame's credit, which a refreshed manifest can still change in
place, is owed through the credits port while the layer is shown.
Without a host the shown frame is hidden rather than detached.
Wind's colour field is a port layer too, so the draw order is a zOrder per
product (wind, infrared, radar, lightning), above the port's other
imagery, and the raise-to-top helper goes. The Cesium port keeps a tile
transform's bitmaps in straight alpha and closes the copies it spends,
and a provider that fails to build is told as an error of its root tile.
The weather rendering and raster tile modules no longer reach Cesium and
leave the allow-list; the 3D Tiles shell still does.
A tile a layer's admit hook defers is asked again on the frame its own
request in flight asks for as it settles, so a layer whose budget is full
no longer keeps a retry timer drawing frames; with none in flight the
delayed retry frame stays. Removing a layer cancels the Cesium requests it
still has in flight, which Cesium leaves running, freeing their per-server
slots. Statuses a spec names for retry are fetched up to three more times,
as the weather layer retried them before moving to the port.
The cyclone layer no longer imports Cesium. Its advisories are three draw
sets per rendering (points, lines, cones) taken from drawOf(viewer): the
centers and forecast points are clamped dots culled past the horizon, the
tracks and cone outlines are draped lines, and the cones are clamped
polygons that keep their holes. Flights go through cameraOf, and the focus
sphere comes from a port of BoundingSphere.fromPoints in src/geo/sphere.js.
Clicks read the new ClickEvent.drawHit: the dispatcher's pick as the
contract's Hit when it is a draw-set item. The Cesium port's query uses the
same conversion, now in render/cesium/drawHit.js. pickStorm takes that hit
and accepts only current items of the layer's own sets.
Every advisory commit redraws the points, so an empty advisory clears them;
an unchanged selection draws nothing. Far-side tracks and cones are left
to the globe's depth instead of a per-frame occluder. Both cyclone files
leave the Cesium allow-list.
The earthquake discs are now one draw set of ground-clamped filled
ellipses per layer, with the same colours, alphas and radii; they had no
visible outline before either (Cesium turns outlines off on clamped
entity ellipses). The layer and its model no longer import Cesium and
leave the allow-list.
depthColor now returns a renderer colour [r, g, b, a] rather than a
Cesium colour, and depthAccent its CSS. A caller handing the layer a
Cesium viewer of their own, with no renderer bound, first loads the new
./render/cesium/unbound export, which provides every unbound factory; the
camera factory now loads the draw factory too, so entries that already
load it draw as well. A fake draw port for layer tests comes with it.
Clamped items now follow the ground the way Cesium's own entities do: a
clamped point is a billboard of a drawn dot, a draped line a ground
polyline, and a clamped fill a ground primitive, packed so no two fills in
one overlap. A rebuilt set keeps its old ground primitives until the new
ones are ready and swaps them in one frame, and whenSettled waits for
them. Sets with horizonCull hide their points and icons past the horizon
before each frame, and a change to what a set clamps to rebuilds it.
The Cesium draw sets move out of the shared ports into their own module,
so they can be built over a viewer no renderer is bound to. findDraw and
drawOf find a viewer's draw port as findCamera finds its camera: the bound
renderer's, or one built over a caller's own viewer once the Cesium
adapter's draw module (exported as ./render/cesium/draw) has loaded. A
renderer bound later releases a built port: its sets keep drawing.
The sea-mark and ski-piste overlays add an XYZ imagery layer through the
globe port instead of building Cesium layers into a host collection. The
port drapes it on the globe on globe stacks and on the Google 3D tiles,
which the map stack now marks as its base tilesets. The row's hidden
reason reads the map stack's new getDrapeSurface, or the viewer's globe
when there is no map stack, and an overlay enabled before its viewer has
a globe port adds its layer once there is one. The overlays no longer
reach Cesium, so they leave the allow-list.
The globe port sets the base (photoreal tiles, terrain, imagery), shows
or hides the globe, and adds imagery layers: XYZ, WMTS, ArcGIS, world,
single-image and canvas sources, with admission, fetch and transform
hooks, a request budget and tile errors. Each layer drapes where its
drapeOn says: on the globe, or on the drawn base tileset, which is the
port's own photoreal tileset or one the map stack marks as its base,
followed every frame so a base switched outside the port moves the
layers. Port layers keep their order above other layers in each
collection. The sky reads the scene and writes through to it, and the
port reports settling and load progress.
The application renderer and the conformance renderer both have it, so
the application renderer now has every member of the contract. A viewer
with no renderer bound gets a globe port through findGlobe. The Cesium
conformance run checks imagery order, the split and the image-hook gate.
Data attribution no longer builds Cesium credits itself: each credit is
added through the renderer's credits port, in the attribution list as
before. The port's credit carries one link, so a credit whose markup
holds several links becomes one credit per link, shown together in
order, its wording kept. dataCredits.js leaves the Cesium allow-list.
The shared Cesium ports gain readPixels and releaseUnused, on both the
conformance renderer and the application's.
readPixels reads the drawn frame off the canvas at once, cropped in CSS
pixels and scaled from the canvas's CSS size, through one reused 2D canvas.
A canvas with no size reads blank.
releaseUnused trims every 3D tileset's cache, and after the next drawn frame
frees the globe tiles that frame did not draw. Cesium trims the globe's
cache only while tiles load, so a settled view would otherwise free nothing;
the trim goes through internals.js. The reader canvas is dropped too.
Two new checks, renderer.readPixels and renderer.releaseUnused, run on
Cesium and the stub.
whenSettled moves from the conformance renderer into the shared Cesium
ports, unchanged but for what it waits for, and the application's renderer
gains it. A hidden globe loads nothing, so it no longer holds settling up:
the application hides its globe under photoreal tiles. Shown 3D tilesets in
the scene must have loaded what is in view, named 'tiles' while they have
not. Disposing the ports ends the watches under way, which fail as
destroyed, as the conformance renderer's destroy did.
It waits for the globe, the scene's tiles and what the draw sets hold, not
for what layers still draw through the viewer themselves.
frame.setTime moves from the conformance renderer into the shared Cesium
ports, so the application's renderer has it. It moves the clock and asks for
a frame, which on-demand drawing needs. It no longer stops the clock: the
conformance renderer stops its own at creation, and the application's clock
keeps whatever state its owner gave it.
The shared Cesium ports gain draw.atlas, draw.clampState and
draw.on('clampState'), on both the conformance renderer and the
application's. An icon names an image by atlas slot; it draws once its atlas
holds the slot, and registering an atlas again rebuilds the icon sets that
read from it. A generated image with a key is one texture however many icons
draw it.
clampState is draped unless a shown 3D tileset is in the scene: the port
draws clamped items where it is given them and drapes nothing onto tiles yet,
so over tiles it says overlay. A change is told after the drawn frame that
shows it, never on subscribing.
A new draw.atlas check registers an atlas after its icons and picks them;
it and draw.clampState now run on Cesium.
camera.controls now maps the contract's CameraControls onto the scene's
ScreenSpaceCameraController: the enable flags, zoom distances, zoom
factor, coast as Cesium inertia (decay seconds, 0 for no coast), the
collision switch, the tilt limit as the upper end of pitchRange, and the
zoom bindings by name. suspend and enabled use the scene's shared input
holds, so they count with the input port's and the dispatcher's.
A follow's zoom hold now composes with the settings: minDistance and
coast.zoom read and set what the follow gives back, a higher floor takes
effect at once, and a follow never lengthens a shorter zoom coast.
The ctrl+wheel binding check reuses the controls' binding helpers, and
the controls checks run in the Cesium conformance set, the settings one
in Node as well.
The Cesium quality port supports pixel ratio, multisampling, shadows,
3D tile and terrain detail and the target frame rate, each applied when
first set and nothing changed before. Detail scales each tileset's and
the globe's own screen-space error and gives it back at full detail;
while tile detail is lowered, tilesets added later follow it. Frame
signals carry each drawn tick's CPU time, size, loop mode and holds.
The application and conformance renderers have the port, and the
conformance page runs the quality checks against Cesium.
The Cesium camera module now loads the credits factory, so the flight,
military and satellite packages own the credits modules too, and the
infrastructure build lists them.
The renderer bridge builds and keeps an effects port over a viewer no
renderer is bound to, with a factory the Cesium effects module provides,
so visual settings on a caller's own viewer draw their styles, bloom
and sharpen as before and give the scene's bloom back when destroyed.
The application shell loads the factory; a test checks every export
that reaches the effects lookup loads it.
VisualEffects defines each preset on the renderer and keeps its own
records of intensities and parameters, written through to the port, so
crossfades, the anime sky fade, bloom and sharpen behave as before. The
renderer animates the animated styles. Sensor picks read the style
records instead of the renderer's stages. The application renderer now
has the effects port and its capabilities.
The effects port puts each style the app defines on its own post-process
stage, takes the scene's bloom stage and adds a sharpen stage, with the
mappings the application uses today. An animated style holds frames and
advances its time uniform while it draws. A replaced style keeps drawing
until its intensity is 0, so the app can crossfade; the contract, the stub
and a new conformance check say so. The conformance renderer has the
port; the application renderer does not yet.
The street-level provider credits, the map source credit, the shared
inline OpenStreetMap and OpenMapTiles credits and the ALPR provider credit
go through the renderer's credits port instead of Cesium's credit display.
Their markup has one link each and is read as the port's plain data; the
ALPR credit is built as plain data, which the port escapes. src/maps/credits.js
and src/layers/streetLevel/credits.js no longer reach Cesium and leave the
allow-list.
findCredits finds the port as findCamera finds the camera: a Cesium viewer
of a caller's own, with no renderer bound, gets a credits port over its
own credit display, so the public entries keep their attribution. A port
built that way is released, not disposed, when a renderer binds later, and
a credit let go after its viewer is destroyed leaves the display alone.
The per-layer data credits and the transit and event credits stay on
Cesium's display: their markup carries several links each, which the
contract's credit cannot hold.
The shared Cesium ports gain credits, on both the conformance renderer and
the application's. list() reports what Cesium owes as plain data: its logo,
its static credits and the last drawn frame's imagery, terrain and tile
credits, read from the credit display through internals.js, with the
credits the app adds listed as given where the display shows them. addStatic
shows a credit through Cesium's display, as markup built from the plain
data with every value escaped and only web links kept, so attribution stays
on screen. change fires when the app adds or removes a credit, and after a
drawn frame whose Cesium credits differ from the last one's.
src/render/creditMarkup.js reads markup credits as plain data. The credits
listener check moves out of renderer.listenerRules into its own check, so a
renderer without every port can run it; it and the credits check now run on
Cesium.
setFov holds the vertical angle it is given across resizes (Cesium
keeps the wider one), waits for a frustum with a field of view, and
rejects angles outside (0, pi). matrices returns Cesium's view and
projection matrices, ECEF to eye in 3D, the only mode the app runs. The
conformance run checks both on Cesium.
Flights and military follow their tracked aircraft with an
entityFollowTarget: framed in ENU from viewFrom, never closer than
150 m, presentation read from the drawn entity's record. Satellites
follow in Cesium's autodetect frame. The layers' own framing
(applyTrackedCameraFrame) goes; the port's follow has the same
close-range rules, and trackedCamera.js no longer imports Cesium.
The port's helper entity draws nothing: its point's outline is
transparent too, and click and voice picks of it count as picks of
the target's drawn entity. The fake camera binder follows when the
fake has Cesium's entity tracking.
The tracked card, screen annotations, north-up, share links and Cockpit
ask data/followed.js what the camera follows, so they work the same when
a layer follows through the camera port. followed.js gains
entityFollowTarget (a FollowTarget whose presentation reads the drawn
entity's record), resumeFollowing and followedPosition.
src/data/followed.js answers what the camera follows: the camera port's
target, or the entity a layer still tracks itself, seen through the same
fields. Ownership checks, render holds, guards, voice actions, the CCTV
pacing and the navigation release paths read it instead of Cesium's
trackedEntity, so they keep working when layers follow through the port.
The release paths stop following, cancel the flight and release the
camera through the port. The rotate refusal names the followed target by
its name or label title.
The Cesium camera port follows a target with Cesium's own entity
tracking, on a hidden helper entity per target, and gains followed,
followFramed, followOffset and followChanged. A target with a minimum
range gets GEV's close-range rules, moved here from trackedCamera.js:
an exact first framing, no zoom coasting, a zoom floor, and an eye that
never crosses through the target. followChanged now fires only when
what is followed changes, on the stub too. No layer follows through the
port yet.
The Cesium camera port gains move, look, rotateAround and zoom, and the
browser conformance run now checks them, the lookAt-frame commands, the
changed thresholds and moveEnd (timed by the clock, not a frame count).
Orbit, the Bhote Koshi focus and cinematic, the launch zoom anchor and
replay chase, the camera verbs' motion tick and roll levelling, and
voice zoom write through the port.
The camera-port commits ran prettier over four test files that were
never prettier-formatted. Restore their earlier text and keep only the
camera-port edits.
The scene director's shot flights, start pose and stops, the annotation
framings and fly-to, the voice overhead framing and the local GeoJSON
click flight now drive the renderer's camera port. The director's stops
look the camera up with findCamera: teardown can run after the viewer is
gone, and then there is no flight to stop. The local GeoJSON flight,
part of the public infrastructure export, works on a plain Cesium viewer
through the unbound camera, and looks it up before taking its input
hold. Voice zoom stays for the move slice.
The embed view, the celestial-ring focus, the ground-guard lift, the
Bhote Koshi approach and orbit, launch selection and replay flights, and
the cockpit's view and takeover now drive the renderer's camera port.
The contract gains a sineInOut easing, pinned by a conformance trace.
A viewer with no renderer bound, such as one a caller of a public
export brings, now gets a camera port too, as it already got an input
port: cameraOf builds one over the viewer's own Cesium camera and keeps
it for the viewer's life, until a renderer is bound. The Cesium adapter
provides the factory as it loads; code that reaches Cesium takes cameraOf
from the adapter so the factory comes with it, and findCamera answers
null where a missing camera is not an error (HUD, share link, world
focus, Recent Imagery's ZOOM IN). A test walks every package export and
fails one that can reach the bridge without loading the factory.
A destroyed viewer gets no camera and lets go of a built one, and the
application renderer stays bound until its viewer is destroyed.
Cesium's Event.raiseEvent leaves an event mid-raise when a listener throws, so listeners added or removed afterwards stay queued. Retry now applies that queue for the frame and clock events: the notice's frame watchers see the next frame, and a listener removed since, such as a layer turned off, is not called again.
flyToBounds takes an easing, as flyTo does: in the contract, the Cesium
port and the reference recorder, pinned by a new conformance trace.
The flights of radio, awareness, CCTV, submarine cables, cyclones, the
launch preview, installations, ALPR, street-level framing, recent
imagery, weather and world focus now go through the renderer's camera
port. Street-level framing cancels its own flight handle rather than
whatever flight is current. worldFocus.js no longer reaches Cesium and
leaves the allow-list.
Layer pose reads stay for each layer's own slice. The local GeoJSON
flight stays on Cesium: gods-eye-view/infrastructure is used with plain
Cesium viewers that have no renderer bound.
The Cesium camera port moves into render/cesium/camera.js, with the
listener list and position conversion shared from common.js. It now
covers flights (flyTo, flyToBounds, cancelFlight, flying), lookAt and
release, command hooks, and a flightEnd event for the flights it starts.
A flight's end that Cesium raises inside one of the port's own calls is
delivered once Cesium's call returns, so its callback sees the flight
let go of. A flight Cesium declines to start, mid scene-mode morph,
ends as cancelled instead of never settling.
Flight traces run in Node on the recorder's headless camera with a
virtual clock; the browser harness keeps the instant traces.
The startup fly-in, landmark and viewport flights, share-link restore
and the shell's camera state now go through the port. camera.js and
sharelink.js leave the Cesium allow-list.
The first camera-family slice. The camera port's events move into a
shared module (render/camera/events.js) that the stub and the Cesium
port both use: listener lists, delivery with errors reported, and the
contract's per-listener `changed` measure.
The Cesium port gains:
- camera.on: `changed` measured per listener on every tick, where Cesium
measures its single threshold (the counts match Cesium's own at each
threshold); moveStart and moveEnd relayed from Cesium's camera;
- camera.viewRectangle, in degrees (now in CESIUM_CHECKS);
- lon and lat in pose, and NaN where Cesium has no cartographic position.
Code that still holds the viewer reaches the renderer through
rendererOf(viewer); the application renderer binds it on create and
unbinds on destroy.
The HUD reads its telemetry from the camera port and no longer imports
Cesium (off the allow-list). The share link writes the hash from the
pose. Its restore path stays on the viewer's camera for a later slice.
Behaviour changes:
- The share link listens to `changed` at its own 0.5 threshold, not at
whatever global threshold layers had set, and also to moveEnd, so the
hash always catches up with where the camera comes to rest.
- The HUD's and share link's camera callbacks run from the port's single
relay, ahead of other moveStart/moveEnd listeners, and a throw in one
is reported to the renderer's error listeners instead of escaping from
Cesium's render.
The Cesium renderer now creates the input port and exposes it as
renderer.input. The input dispatcher becomes an adapter over the port:
one port listener per event type, fanned out to its subscribers with the
ownership check read once per event, keeping the legacy event shapes.
- Ctrl+wheel zoom is switched on through renderer.input.ctrlWheelZoom.
- A dispatcher made for a viewer with no port creates its own port with
takeStock: false, which borrows the stock select and double-click
follow only while they are suppressed.
- The stock actions see the press as it began: a click whose press
started while select or follow was held off never runs them.
- A scene accepts one input port; cesiumInputOf(scene) returns it.
- Releasing one mouse button while another is held no longer gives the
held button a click. Cesium still ends that press.
src/render/cesium/input.js feeds the shared router from one
ScreenSpaceEventHandler: every button's press, release and click, double
clicks, moves and pinches, under any one modifier. The DOM event being
dispatched gives the full modifiers and pointer type; an action Cesium
raises on a timer takes its own modifier. Wheel comes from the canvas in
lines and is never cancelled. Clicks are picked once, lazily, through the
query port. Cesium ends every held button on any release; those presses
end there, but only the button released clicks.
The viewer's stock select and follow move off its handler and run first,
as they did, but only for a press no lease took and while not suppressed.
Camera holds go through the scene's shared holds, ctrlWheelZoom through
ctrlWheelZoom.js. The router gains a before-hook and dispose, which stops
delivery mid-event.
The conformance renderer exposes the port and the harness feeds it;
input.lease, input.lease.grab, input.lease.press, input.clickPick and
input.behaviours join the Cesium checks.
installTrackpadPinchZoom and its pinch scaling move unchanged from
src/app/viewer.js to src/render/cesium/ctrlWheelZoom.js, where the input
port's ctrlWheelZoom will turn it on and off. The application scene
imports it from there; the application/viewer export no longer carries
this undocumented helper.
The take-over of the camera controller's enableInputs moves, unchanged,
to src/render/cesium/cameraInput.js. acquireCameraInput(scene) gives every
user one set of counted holds per scene, so the renderer's input and
camera ports can hold camera input alongside the dispatcher; the
controller gets its own property back when the last user releases. The
dispatcher acquires its share once its handler is bound. The input guard
names the one module allowed to write the flag, and the new render files
join the format scope.
Frame-phase and draw-set ready listeners now run in subscription order,
skip one removed during delivery, defer one added during it, and hand a
throw to the renderer's error listeners (or reportError) instead of into
Cesium's render loop. The renderer gains on('error' | 'contextLost' |
'contextRestored'); Cesium cannot restore a lost context, so it never sends
contextRestored. Dispose clears every list. renderer.listeners joins the
Cesium checks.
The stub's lease and press routing moves to src/render/input/router.js,
unchanged, so a real renderer can feed it its own engine's events. The
router also keeps the behaviour holds (telling the renderer when one turns
off or on, unless it lacks it) and ctrlWheelZoom, and dispatch says who an
event went to.
The governor no longer writes the Cesium scene's render mode itself: each
owner holds the renderer's frame port once, requests go to it, and the
port is the one place the loop's mode is set. The port now also keeps
the loop from redrawing for scene time alone, which the governor did.
The application installs the governor as soon as its renderer exists and
holds the loop continuous ('boot') until its tools are up, where the
governor used to be installed, so boot draws as before. The hidden-tab
suspension goes through the port too, and the application's renderer now
has the whole frame port.
The frame port now does everything the contract asks of it on Cesium:
preUpdate says whether the tick draws (Cesium's own render test, read
live until the tick is over), holds are counted per reason, and suspend,
target fps, renderNow and diagnostics are real. Releasing the last hold
asks for one more frame.
whenSettled also waits until Cesium stops redrawing on its own. Each
request or worker task Cesium completes queues a redraw (a terrain
picker build after the camera moved, say), which no loading flag shows,
so it now waits for quiet frames and then a short stretch in which the
loop draws nothing by itself. It is bounded by its timeout, names a
stopped loop, and ends on destroy.
The app renderer still leaves out the members that steer the loop:
the render governor and the page's visibility handling own those
settings until they move onto the port.
The new frame.prediction check compares the preUpdate answer with what
each tick drew.
The Cesium renderer now has every QueryPort member: picks and drill
picks, depth and globe picks, rays, projection, occlusion, heights now
and streamed, clamping and ray casts. Capabilities come from what the
scene supports (depth textures for pickPosition, sampleHeight,
finestHeights and rayCast), in both the conformance and app renderers.
- Picks skip unpickable and hidden items, and report each item once. A
pick under an unpickable item stops at anything that hides the rest.
drillPick's limit counts after that filtering, so 0 gives none.
- Height queries and ray casts see through sets not drawn with
includeInHeightQueries, and through the sets a caller excludes, by
their items' pick ids. The list is built once per change to the sets.
- `tiles` samples and casts run with the globe hidden for the call;
`terrain` casts use the globe alone. A sample reports whether it came
from tiles, terrain, the ellipsoid or a set.
- A position clampToSurface cannot read is a miss, not a failed batch.
- Terrain on an ellipsoid is height 0. Before, sampling it threw, for
want of tile availability.
whenSettled also waits for icon images, and fails when one cannot load.
The conformance checks that pick or query settle first, because a
renderer answers from what it has loaded; the stub settles at once.
The Cesium renderer now passes 14 checks in the browser, and its
visual references are unchanged.
The conformance page can now run the logic checks against the Cesium
scene renderer as well as the stub. CESIUM_CHECKS lists the checks of
the ports Cesium already has; each phase 2 migration adds its own, so
the suite shows how far the renderer is through the contract. All eight
listed checks pass in the browser, and the stub still passes its 69.
A harness frame is one tick of the render loop, observed through
frame.on('preUpdate'). It asks for no frame itself, so a check's own
requestRender is what makes a tick draw, and a loop that stops fails
the check after five seconds instead of hanging the run. The harness
frees each WebGL context on destroy.
FrameTime.dt is now measured rather than fixed at 1/60, and renderOnce
honours timeoutMs. A scene renderer made without the models capability
has no draw.models.
The frame, draw, camera, query and capture ports move out of the
conformance scene renderer into src/render/cesium/ports.js, unchanged.
The app's transitional renderer, now src/render/cesium/appRenderer.js,
builds the same ports over the full viewer; it still leaves out globe,
whenSettled and setTime, which would misreport photoreal tiles and stop
the app clock.
Disposing the ports now settles a pending renderOnce and detaches the
draw sets, so a model that loads after destroy is destroyed rather than
added to a destroyed collection. A viewer whose ports fail to build is
destroyed with its credits.
Checked in a browser: the app boots with one credits element, and all
eleven conformance scenes match their references exactly.
Outside src/render/cesium/, only the 236 files on cesiumAllowList.json
may reach Cesium, and each must still do so, so porting a file removes
its entry. A file reaches Cesium by importing it or the Cesium adapter,
by name or by path, or by being handed the namespace as a parameter,
binding or property. Files added to the list since origin/main fail the
check, once the list is on main. The renderer contract, stub and
conformance suite must stay Cesium-free, and runtime code in a language
the check cannot read fails it.
createApplicationScene takes a renderer plugin, defaulting to Cesium,
which builds today's viewer and credits exactly as before. Its renderer
is transitional: it has only the members it really has, with read-only
capabilities, and a test pins the contract members still to come. Code
not yet ported reaches the viewer through cesiumViewerOf, never through
a renderer member. A plugin whose renderer has no viewer is refused and
destroyed, since the application still runs on the viewer. The result
now includes the renderer.
Not yet checked in a browser.
Voice actions read degrees from ECEF positions with toLonLatH and
measure distances with src/geo, at the sites that only did maths. A
position that converts to NaN now reads as unknown, never as NaN
coordinates. The analyst test gives its subject a real ECEF position
instead of patching Cesium. Sites that keep a Cesium Cartographic, or
use the camera or picks, wait for the renderer ports.
Share links convert degrees, radians and the flight destination with
src/geo. The hash and the destination are bit for bit the same as
before; the flight itself still goes through the Cesium camera.
fromRadians divides by gamma as Cesium does, so geodetic to ECEF is now
bit for bit Cesium's, and the test checks it exactly. Its tests also
cover three height bands, points inside the Earth and NaN input. toEcef
reads the renderer contract's Position, so it moves to the stub's maths.
The ellipsoid docs pair each conversion with Cesium's.
Ports Cesium's axis-angle, product, rotation-matrix and heading-pitch-roll
quaternions, with rotations given as frame axes. They match Cesium bit for
bit, including heading-pitch-roll frames on the polar axis. The model
convention is documented: at heading 0 the forward axis points east.
A port of Cesium's Simon 1994 sun and moon positions, its TEME to
pseudo-fixed rotation and the JulianDate time handling, with epoch
milliseconds as the only input. Results are identical to Cesium's,
tested with exact equality from year -500 to 3000 and across every
leap second. Times outside the model throw a RangeError, where
Cesium's debug build throws.
The world packet converts the eye position with toLonLatH instead of
Cesium's Cartographic, so the agent-world-packet group no longer needs
cesium. Degree conversions use precomputed factors, as Cesium.Math does,
so results stay bit for bit the same.
WGS84, ECEF and geodetic conversions, surface normals and east-north-up
frames, as plain {x, y, z} objects, exported as ./geo. A test checks
them against Cesium over random points and the poles. The stub's maths
re-exports them and keeps only the camera angle conventions.
- setFrames takes a timed source (URL frames, or video tiles in
segments) on the scene clock by default or its own; frameReady fires
once each time the shown frame is drawn.
- drapeOn is 'surface' | 'objects' | 'all' plus lit; imagery.host() and
onHostChange go, and the drape rule the app derives is written out.
- ImagerySpec.fetchTile answers bytes, missing or defer on every
renderer; tileTransform, admit and canvas imagery need imageHooks, and
add() throws for them without it.
- Generic names for the default renderer's world data: worldDataToken,
the photoreal fallback route, and world terrain and imagery.
- clouds and water capabilities, with globe.setClouds and setWater.
- claimPointer takes a grab filter, asked on each down: a lease takes
only the presses it grabs, and wheel, pinch and every other press stay
with the camera and everyone else. Each event of a press goes where its
down went, per button, so a claim never takes a press under way.
- The app owns the styles: effects.defineStyle passes a GLSL (and optionally
WGSL) full-screen pass, with the shader interface written out.
- Credits are plain data ({ text, href, logoUrl, inline }) that the app
renders; CreateOptions.creditContainer goes.
- controls.coast { drag, zoom } in seconds replaces the inertia trio; the
stub's defaults are the default renderer's, converted.
- The frame order is the default renderer's own: a move made by follow or
in preUpdate reaches changed on the next frame.
- lodGroup links items across sets as one thing at different detail;
picks name the member shown and report the group. displayRange is
half-open.
- An orbits capability: the renderer propagates two-line elements with
SGP4 on the set's motion clock. The stub propagates with satellite.js.
- Height queries see draw sets only with includeInHeightQueries (was
excludeFromHeightQueries); HeightSample.source gains 'set'.
- courseGlide is a capability; courseBlendMs eases the course on every
renderer.
- Arc segments climb at climbMps; a negative minDtS stays for the
aircraft warm-up.
- The star catalogue is optional, a hidden column row keeps its motion,
and draw.clampState() reports the drape fallback.
Checks cover the climb and warm-up, lodGroup ranges, orbits against SGP4
(with and without motionSegments), hidden rows resuming, and sets not
answering height queries by default.
An error thrown outside Scene's own error handling (a postRender listener,
the clock's onTick, a resize) stopped Cesium's loop without a renderError,
and with Cesium's panel turned off the globe froze silently. The notice now
raises such an error as a render error.
In an inline panel whose host stopped animation frames, Retry left the
panel's timer latched off, and once frames resumed a second render loop
drew every frame twice. The timer now follows Cesium's loop, and keeps the
loop marked running when its next frame is still queued.
Cesium stops its render loop after a render error and offers only a
panel that dismisses itself, and a lost WebGL context never draws again,
so the globe froze or went black while the controls kept responding.
The scene chrome now shows an alert dialog with the error. Retry restarts
the render loop and keeps the notice until a frame renders without an
error; after a lost context it reloads the page, whose address keeps the
view. Reset view opens the app root without the restored hash or share
path. An inline conversation panel never reloads its host page. The
application viewer turns off Cesium's own panel; other callers keep it.
The renderer contract is what the application asks of a 3D renderer. It is nine ports
(frame, globe, draw, camera, query, input, effects, credits, quality) plus
the renderer itself, one strict .d.ts per port in src/render/contract/.
PORTS lists every member at run time, and a TypeScript-compiler test fails
when the list and the types disagree on one member. An optional member
exists only with its capability; a required one answers null or empty
without it. Nothing in the application uses the contract yet.
The stub renderer (src/render/stub/) implements every port in memory and
draws nothing. Its camera is a port of the default camera's maths: views,
lookAt, flights with their height arc and easing, rectangle framing on the
geodesic midpoint, the view rectangle with its horizon and pole cases,
changed thresholds, follows, and flights that finish inside the call.
The conformance suite (src/render/conformance/) runs 59 checks against
a renderer through the contract alone, in Node or in a browser page. The
camera checks compare traces recorded from Cesium's own Camera, headless on
a virtual clock (scripts/record-camera-goldens.mjs), to 1 mm, 1e-9 and
1e-3 px. The other checks cover listener rules on every subscription, the
frame loop, draw sets, picks, motion clocks, heights, leases, imagery,
styles, credits and quality knobs. The stub passes all of them but the
model check, which needs a glTF asset.
Reference scenes draw one scene per primitive family, a city and a
calibration path from orbit to the street, from contract calls only and
with no network. /dev/conformance/ draws them on the Cesium scene renderer
(src/render/cesium/sceneRenderer.js), records references through a
dev-server-only, loopback-only endpoint, and compares captures with
pixelmatch's antialias detection plus a solid-pixel count. Measured on
Cesium: every MSAA setting passes, and a dropped 4 px point, a dropped 2 px
line and a 1 px shift of the view fail. visual.js states the limits.
The package exports ./render/contract, ./render/stub and
./render/conformance. Documented in docs/RENDERER-CONTRACT.md,
docs/CODE-BOUNDARIES.md and docs/CURRENT-STATE.md.
The Directions A and B letters and a data pack's media label were the two
Cesium text labels left, kept by an allow-list in noCesiumLabels.test.mjs.
Both now publish entries to the shared world-overlay host, and the
allow-list is gone, so any Cesium label in src is a test failure.
Directions publishes the letters to the directions-markers source; the
markers keep only their points. A clicked endpoint's letter hangs over the
surface that was clicked. One placed without a click stays hidden until its
ground-floor cell resolves, then requests a render, so a still camera shows
it; a cell that settles with no height falls back to the ellipsoid. Each
position is computed once.
A pack resource handle gains label(entry). The application passes its
shared overlay host to SceneDirector through dataPacks.overlayHost; without
one a media pack fails to load rather than drawing a native label. Each
labelled resource takes a source from a pool and returns it on dispose, as
the host never removes a source, so two presentations of one pack never
clear each other's labels and repeat loads add no sources. A label written
after dispose is ignored. The media label is protected, so it always draws
as before.
Live (Denver, keyless globe): a clicked A and a programmatic B both anchor
on their dots over 1.58 km ground. Documented in docs/CURRENT-STATE.md and
docs/DIRECTOR-DATA-PACKS.md.
The arrival ground guard replaced camera.flyTo, flyToBoundingSphere,
setView, lookAt and cancelFlight with wrappers so a direct caller would stop
it. It now remembers the pose it started on and, before each retry, yields
if a flight is under way or the camera has moved across the ground, down or
around. A straight rise is not a move: Cesium's terrain collision lifts a
buried eye that way as tiles load, which is the case the guard exists for.
This also catches owners the wrappers missed (a pose written directly,
lookAtTransform), and no camera method is replaced.
Recent imagery and weather overwrote provider.requestImage (weather also
provider.credit) to ration tiles. They now state that policy as a hook with
withTileRequestHook(provider, { requestImage, credit }) from
src/render/cesium/tileRequests.js, which hands Cesium a provider delegating
to the original and leaves the original untouched.
Every private Cesium field the app reaches goes through a named helper in
src/render/cesium/internals.js: the main and offscreen pick views and their
command extents, a billboard's collection, a cluster's point collection,
the widget's render-loop latch, the WebGL context and the current camera
flight. internals.test.mjs fails when the installed Cesium stops declaring
one of them, and a source scan fails on private access anywhere else. The
cyber sonar's primitives.update wrap stays until the effects work.
Live (Austin, keyless globe): a buried eye is lifted to 253 m over a 133 m
surface; a setView or flyTo by another caller makes the guard yield; radar
loads its tiles through the hook. Documented in docs/APPLICATION.md and
docs/CURRENT-STATE.md.
About 20 sites called scene.sampleHeight, globe.getHeight,
scene.clampToHeight or the MostDetailed variants directly, each with its own
idea of a miss (undefined, NaN, a throw). They now ask heightsFor(scene) in
src/queries/heights.js:
- now(point, { against, exclude }) answers from what is loaded, or null;
against is 'surface' (what is drawn) or 'terrain' (loaded terrain only).
- clampNow(position) moves a position onto the drawn surface, or null.
- batch() and clampBatch() wait for the most detailed tiles: null per
missed point, a rejection when the whole query fails.
- supported() reports { surface, clamp } without allocating.
Cesium still answers now() synchronously, so nothing changes on screen and
nothing is slower: in the live app 1,000 calls cost the same through the
service as direct (terrain 0.5-0.7 ms, surface 2-6 ms a call, run-to-run
noise larger than the difference). Every site already treated a miss as
"hold the last value or fall back"; a renderer that can only answer from a
cache or asynchronously can now plug in at one place.
- A Bhote Koshi evidence point whose terrain sample misses stays at its
fallback elevation instead of reading the miss as sea level.
- The mesh floor sampler skips a scene without depth-texture support
instead of spending its budget on probes that throw.
- The world annotation probe's trace reads hit/missed.
- A source scan forbids direct height calls outside the service.
The service is exported as ./queries/heights and documented in
docs/APPLICATION.md.
Every layer and tool bound its own ScreenSpaceEventHandler and picked the
same click again: with the usual layers on, one click ran about 26
scene.pick and 2 drillPick passes (120-215 ms in NYC with 18 layers). Pointer
input now comes in through src/input/dispatcher.js, one handler per scene.
A click is picked lazily and at most once per kind of query, and every
subscriber reads the same ClickEvent (pick, hit, id, ownerId, gesture,
drill, ground). The same click now costs 3 picks and 2 drills, 17-70 ms.
- Ambient onClick subscribers run only while no tool holds the pointer,
checked once per event; tools subscribe with their lease. Moves and
releases always reach ambient subscribers, so hover and drags end cleanly.
- Camera input and the viewer's stock select/track clicks are ref-counted
holds (suspendCamera, suppressStockClicks). The dispatcher owns the
controller's enableInputs, so a Cesium flight that ends no longer turns
input back on under a drag or the cockpit.
- The draw tool, imagery box, CCTV gizmo, cockpit, directions and every
selecting layer use it; bindTrackingClickGesture is gone (the gesture is
on the event). A source scan forbids new handlers, enableInputs writes and
stock-click removal outside the dispatcher.
- The sensor-style pick correction transit had now applies to every layer.
- Radio's 8-pick near-miss ring is one 17x17 windowed drill.
- A missed pick passed to pickContact is no longer picked again, and a
touch tap's contact search shares the click's drill.
- A gizmo drag whose release Cesium never reported ends on the next press
instead of leaving the camera held.
The dispatcher is exported as ./input with the pointer-lease functions, and
documented in docs/APPLICATION.md.
Aircraft draw from GPU icon sets, so the billboard mirror, the billboard
treatment and the aircraft visual-state module had no callers left. 3D models
are now records the layer holds under the contact's id (modelRecord.js):
show and placement are written through showModel/placeModel and read back
from the record; renderer-measured values stay on record.model.
The tracked-model click check only matches when a tracked model exists, so
an id-only pick is never mistaken for a click on the tracked plane.
The flights icon planning and presentation move into
`createAircraftIcons` (src/data/aircraftIconLayer.js), and the motion
regime both layers dead-reckon from into src/data/aircraftMotionRegime.js.
Flights keeps only its grounded-floor pass on top.
Military now draws every contact as a row of that icon set, like
flights: the billboards, the cull positions and the rotation-pass
signature go. Tracking hides the row and untracking re-plans it from
the tracked course. Queries read the drawn row position and judge the
horizon as the shader does. Snapshots that arrive before init or after
destroy are ignored, and per-contact lookups find no contact then
instead of throwing.
With about 120 live military contacts, preRender p95 drops from
0.7-0.8 ms to 0.2 ms on the same views. Render time and frame gaps are
unchanged or slightly lower.
Every flight is now a row in the layer's icon set. Its motion segment
follows the same regime `_deadReckon` picks (interpolate between fixes,
warm up backward from the oldest, coast forward from the newest), and
one shared `_motionRegime` makes that choice for both. The shader moves
every untracked contact between polls, so the 12 Hz fleet tick no
longer touches each billboard. It now only re-plans expired rows,
floors grounded contacts, advances focus while needed, and runs the 3D
model regime.
Grounded contacts the floor lifts are pinned to a hold at the floored
position. Their nose glides on the GPU. Contacts within 50 km re-floor
every tick, and farther ones take turns about once a second. Low
contacts are judged for the horizon at no lower than 12 m above the
ellipsoid, as before. Below hover speed a contact's nose holds. A row
whose fleet model is drawn keeps its focus updated, because the model
reads it. Untracking re-plans and re-floors the icon from the tracked
course.
On the same views with about 6,700 OpenSky flights, frame gaps at p95
drop from 28-40 ms to 17 ms, and the fleet tick from 16-37 ms to about
2 ms at most.
Icon rows live in typed-array columns: one packed motion segment (hold,
lerp or arc, with a course glide), style, colour and pick ids per row.
The primitive draws every row in one instanced call, dead-reckons in the
vertex shader, matches the billboard treatment the fleet layers use, and
picks and drill-picks like a billboard. Cyber sonar covers icon sets.
Installation selection fills and outlines record the installation they
belong to in the layer's installationMarkers store instead of an
installationId expando, and the click handler resolves them from there.
Named-marker points keep their { installationId } pick payload, which is
the app's own object, so sibling layers treat a point click as before; the
marker remembers its record id for visit() instead of reading the point.
The local GeoJSON package tracks the entities each layer loaded in a
per-instance set instead of a __localLayerId tag, and passes the stem
base to registerEntityContext as targetPosition instead of hanging it on
the entity; FIRMS does the same, and voice targeting reads the context
record. QA scripts find a layer's features by their context id.
Earthquake analyst records come from the events the layer drew, gated on
its own enabled flag, instead of reading each entity's position and
property bag back; the discs no longer carry the bag. CCTV coverage rays
and projection planes record their camera id in a layer pick store
instead of a cctvCameraId entity property, with the same ownership checks.
The tracked flight, military and local ADS-B billboards record their size
and distance scaling as the entity record's sprite, which the close-range
camera guard and the screen annotations' tracked footprint now read in
place of the billboard's property getters.
Flights, military and local ADS-B now write their models' show and world
matrix through setModel in src/data/modelMirror.js, and read them back
through modelState: the fleet and tracked handoffs, the tracked visual and
trail anchors, detection anchors and modelAnchorWorld. A matrix is copied
into the app's record and into the model's own matrix, so the shared scratch
can be passed directly and models still never share one matrix object.
What Cesium measures (ready, computedScale) is still read from the model,
and colour stays live as on billboards, because cyber sonar writes it too.
Test seams mirror the models they install, as they do billboards.
The three layers now add their billboards through addBillboard and write
the mirrored fields through setBillboard, so selection, cards, queries,
focus, view thinning and the FIRMS horizon cull read what was pushed from
the app instead of from Cesium. Vessels and FIRMS state their sprites' own
sizes (32 px ship artwork, the glow canvas at twice the core size), which
the mirror needs. A vessel helper, iconPosition, replaces the repeated
mirror-or-visual position lookups, and the vessel visibility pass writes
show only when it changes, as CCTV and FIRMS already did.
A billboard never given a position now has none in the mirror rather than
the origin.
Flights and military now add their billboards through addBillboard and
write show, position, scale, rotation, size and distance scaling through
setBillboard, which keeps the app's copy in src/data/billboardMirror.js.
Their reads go to billboardState instead of the Cesium billboard, so the
layers no longer read back what they pushed to the renderer.
A mirrored billboard needs an explicit width and height, because unset
Cesium reports the loaded image's size. Colour is not mirrored yet: the
cyber-sonar theme writes it too and tells the writers apart by the live
value, so it moves with the effects port.
Submarine cables wrote each pick's info both to a per-load WeakMap and to a
__gevTeleGeography expando, always together; one cablePicks store replaces
both and resolves the same objects. The voice view-target prewarm marks its
viewer in a WeakSet instead of a __gevViewTargetPrewarmInstalled property.
The aircraft layers' model spec key, IR boost and belly offset and the
billboards' large-icon flag move into aircraftVisuals, one store shared by
flights, military and local ADS-B. Installation markers' last drawn height
and selection move into installationMarkers. The CCTV viewshed QA tag is now
the viewshedCameraId record field, which qa-cctv-v2 reads through
entityRecords. Test fixtures drop a placement flag nothing reads.
registerEntityContext stamped __gevContextId on the entities, primitives and
carriers it registered, and selection and pick resolution read it back. It
is now the contextId field of the entity's own record.
The ALPR layer's private per-entity fields (record, clamp, canvas and display
anchors, wedge, native appearance, pick position, shown, surface check) move
from gevAlpr* expandos into alprMarkers, a store made by the new
createEntityStore(). The shared entity records are built on the same factory.
Flights, military, satellites, installations, local ADS-B and ALPR hung
gevTrackedId, gevDisplayPosition, gevVisualPosition, gevSelectionOrigin and
gevLabelModel on the Cesium entities they draw, and the tracked readout,
follow camera, cockpit, share links and awareness read them back. They now
live in src/data/entityRecords.js, an app-owned record per entity: layers
write entityRecord(entity), readers use readEntityRecord(entity). Nothing
changes on screen. This is the first slice of the renderer plan's state
mirror (P1).
The module is exported as ./data/entity-records so callers can read the
same records, and window.__godsEyeView.entityRecords gives the QA scripts
the same access from the page.
2026-11-03 08:09:00 -08:00
1512 changed files with 182529 additions and 49144 deletions
which reaches it) no longer reaches Cesium: the layer keys cached road
heights by the globe port's `surfaceVersion()` and waits on
`isSettled('surface')`. Heat-lines are always asked for draped; a renderer
that cannot drape draws them over the surface instead of the layer
dropping them. A viewer with no renderer bound needs
`gods-eye-view/render/cesium/unbound` loaded once first (samehkhamis).
- Where the Cesium renderer cannot drape (a WebGL context without depth
textures), every draped line now draws over the surface, as the renderer
contract asks: along the surface's curve between its positions, in its
colour where the surface hides it, hidden past the horizon. Segment colours
are dropped (it draws in its style colour) and it runs from its first shown
segment to its last (samehkhamis).
## [0.3.0] — 2026-10-27 — Street Level, On Your Phone, in Your Language
@@ -788,7 +899,7 @@
- Stop one retired bikeshare feed from reporting the whole layer as failed.
City feeds are fetched independently, but failure was recorded in a single
flag that only a successful *activation* cleared — and an already-loaded city
flag that only a successful _activation_ cleared — and an already-loaded city
never activates again. A dead feed re-entering camera range therefore latched
LOAD FAILED permanently over a map still drawing every other city's stations.
Failure is now tracked per city: a city that fails beside others still
@@ -1064,7 +1175,7 @@
photo a click opens, and the cones, by each photo's projection and upload
date. KartaView's SINCE is the upload date (all its server can filter by);
a note under the slider says so while KartaView is lit (`sinceBasis:
'upload'` in the provider contract).
'upload'` in the provider contract).
Mapillary's line coverage and sequence cones are now shared by both
(`lineCoverage.js`, `sequenceCones.js`).
@@ -1642,6 +1753,7 @@
Add feed provenance to analyst/view answers and HUD context while retaining existing response fields and runner ownership (Matt Van Horn, #347).
Analyst records for loaded satellites, datacenters and dams, with explicit bounded count/rank coverage (Matt Van Horn, #351).
- New Fire Perimeters layer (Events group): live NIFC WFIGS interagency
wildfire incident perimeters as ground-clamped polygons with a
containment-colored fire line, refreshed every 5 minutes from the public
@@ -1918,7 +2030,6 @@ of current runtime behavior, see [`docs/CURRENT-STATE.md`](docs/CURRENT-STATE.md
### Other changes
- Add ECMWF IFS model selection to Wind (#464, thanks @beneduzi), with model-scoped forecast-step caches, cancellation of replaced requests, and separate issue/valid timestamps.
- Add bounded Director feature actions with accessible controls, explicit camera/layer admission and cancellation; restore pack geometry on same-shot seek. Preserve existing scenes and content attribution.
@@ -2727,4 +2838,3 @@ represent previously published GitHub Releases.
@@ -139,6 +139,7 @@ The highest-leverage places to jump in:
- **Vue 3 + Pinia for the interface,** [CesiumJS](https://cesium.com/platform/cesiumjs/) for the globe and [Vite](https://vitejs.dev/) to build. See [Building UI](#building-ui).
- **Assembly lives in `src/app/`; standalone defaults live in `src/standalone/`.** UI controllers live in `src/ui/`, layer factories in `src/layers/`, portable sources in `src/sources/`, and application operations in `src/services/`. Existing `src/data/<layer>.js` entries retain compatibility; new code belongs with its focused owner.
- **Reach the renderer through its contract** ([docs/RENDERER-CONTRACT.md](docs/RENDERER-CONTRACT.md#moving-code-onto-the-contract)): `findDraw`, `findCamera` and the other ports in `src/render/rendererOf.js`, not Cesium or the viewer's `scene`, `camera` or `entities`. Two ratchet tests hold this: only files on `src/render/cesiumAllowList.json` may import Cesium, and `src/render/viewerAccessAllowList.json` caps the viewer accesses each other file still makes. Neither list may grow; when you port code off them, shrink them (`node scripts/viewer-access-baseline.mjs` lowers the second).
- Sources acquire records; renderers own Cesium resources. Import `gods-eye-view/layers/<family>/source` when only a source factory is needed. Common voice controls consume the session interface; protocol adapters own connection details.
- **Secrets stay server-side.** Anything needing a private key goes through a local proxy under `server/providers/`. The browser only ever sees the Google Maps key (which you restrict) and ephemeral tokens.
-`docs/CURRENT-STATE.md` is the authoritative runtime reference — read it first.
God's Eye View's **code** is [MIT](LICENSE)-licensed. **The MIT grant covers the source code only — it does NOT extend to third-party data or visual assets.** Every third-party source keeps its own license and terms. This file documents the live and bundled data sources; bundled 3D-model provenance is recorded in [`public/models/README.md`](public/models/README.md).
God's Eye View's **code** is [MIT](LICENSE)-licensed. **The MIT grant covers the source code only — it does NOT extend to third-party data or visual assets.** Every third-party source keeps its own license and terms. This file documents the live and bundled data sources. The bundled 3Dmodels are the project's own procedural fleet models, MIT-licensed with the code ([`public/models/README.md`](public/models/README.md)).
How to read this:
- **The non-permissive datasets are carved out, not omitted.** Some bundled data (e.g. TeleGeography, CC BY-NC-SA) isn't MIT-compatible. Rather than hide it, we **bundle it with a clear license carve-out** so the app works out of the box — but it stays under the provider's terms.
- **If your use doesn't fit a dataset's license, remove that dataset.** Most importantly: TeleGeography is **NonCommercial** — commercial users must delete it (or license it from TeleGeography). It's one self-contained folder.
- **Attribution is shown in-app** and listed here. Keep it intact. The required Google/Cesium credit renders on the on-globe credit line (bottom-left, `#cesium-credits`), and every per-layer credit below is registered into the expandable **"Data attribution"** lightbox on that line (`src/data/dataCredits.js` → `viewer.creditDisplay.addStaticCredit`). Both stay visible in clean-view and recording modes.
- **Bundled model attribution lives beside the model files.** [`public/models/README.md`](public/models/README.md) records each shipped model's creator, source, license, and modification status.
- **The bundled 3D models are the project's own.** Every model under `public/models/` is a procedural fleet model generated by the project maintainers and covered by the repository's MIT license; [`public/models/README.md`](public/models/README.md) describes the set.
---
@@ -223,19 +223,23 @@ The optional Local ADS-B layer and the broadcast-FM receiver use radio you recei
The numerical minima come from US 14 CFR 91.227(c), not a published jamming
describes the quality field origins and GPS-loss flag.
2.**GPSJAM aggregation:**score = `100 × max(0, bad − 1) / total`, with percent
bands < 2, 2–10, > 10. One bad aircraft is discounted. This is not the raw
share of bad aircraft. See the [GPSJAM FAQ](https://gpsjam.org/faq).
3.**GEV window:** 30 minutes over visited views, at least three aircraft per
0.5° cell. These bands were developed for daily totals; with fewer than ten
observations a cell can skip the middle band. Source timestamps date evidence
even through cache replays, and degraded evidence expires independently.
2.**GPSJAM aggregation:**aircraft are binned into H3 resolution-4 hexagons
(about 1,770 km² each), and score = `100 × max(0, bad − 1) / total`, with
percent bands < 2, 2–10, > 10. One bad aircraft is discounted. This is not
the raw share of bad aircraft. As on GPSJAM there is no minimum aircraft
count: every hexagon with an aircraft is shown, and the discount is the only
small-sample guard. See the [GPSJAM FAQ](https://gpsjam.org/faq).
3.**GEV window:** 30 minutes over visited views. These bands were developed
for daily totals; with fewer than ten observations a cell can skip the
middle band. Source timestamps date evidence even through cache replays,
and degraded evidence expires independently.
Medium/high cells report navigation-integrity anomalies. Interference is one
possible explanation, not a detected or located emitter. Avionics faults and
manoeuvring military trainers can also lower reported accuracy. Blank areas
can be outside coverage or lack enough observations. Attribution: adsb.lol
contributors, ODbL 1.0; GPSJAM for aggregation only.
are outside coverage or had no qualifying aircraft in the window.
Attribution: adsb.lol contributors, ODbL 1.0; GPSJAM for the grid and
aggregation only.
- **adsbdb enrichment.** `/api/adsbdb` resolves an ICAO hex to aircraft type, model name and registration, and the tracked flight's callsign to an airline and an origin/destination pair. Fan-out is deliberately small because adsbdb is a free community API that publishes no quota: at most 4 requests in flight, dispatches dripped to roughly 5/s, and each key asked for at most once per session (for the flights layer's enrichment, a lookup that failed temporarily, such as an outage, a timeout, a rate limit or an authorization refusal that may clear, may be asked again after a 60-second cool-down; an answer, found or not, and a permanent refusal such as a 404 are final; Local ADS-B lookups are asked once), with route lookups reserved for the tracked aircraft. The dev-server proxy caches each key for 24 hours in `.gev-cache/adsbdb.json`, negative answers included, so fresh entries survive server restarts. That gitignored cache remains local to the deployment and is not bundled with this repo. adsbdb publishes no general service license; its README says the route data may not be copied, published, or incorporated into other databases without the explicit permission of David J Taylor, Edinburgh. Deployers are responsible for obtaining any permission their use requires. Enrichment is best-effort and fail-silent — a flight that gets no answer keeps what the flight feed already gave it.
@@ -419,6 +423,7 @@ The [Bhote Koshi event pack](public/events/bhote-koshi-2026/README.md), under `p
| **Natural Earth countries, states and provinces** (260 admin-0/map units + 4,587 admin-1 polygons) | `natural_earth/` | **Public domain** | ✅ (no restrictions) | "Made with Natural Earth" (courtesy credit — not legally required) |
| **Natural Earth disputed areas** (11 of the source's 99 features, hand-picked; [list](src/data/local_data/natural_earth/README.md#disputed-areas-disputed_areasjson)) | `natural_earth/` | **Public domain** | ✅ (no restrictions) | "Made with Natural Earth" (courtesy credit — not legally required) |
| **Wikidata cities** (31,827 settlements of 15,000 people or more: name, position, population, country) | `wikidata_cities/` | **CC0 1.0** (public domain dedication) | ✅ (no restrictions) | "City, town and village names from Wikidata (CC0)" (courtesy credit — not legally required) |
| **US Census Bureau counties** (3,235 county polygons) | `us_census_counties/` | **Public domain** | ✅ (no restrictions) | "U.S. Census Bureau" (courtesy — not legally required) |
| **US Census Bureau places** (32,629 city, town and CDP polygons) | `us_census_places/` | **Public domain** | ✅ (no restrictions) | "U.S. Census Bureau" (courtesy — not legally required) |
| **Who's On First neighborhoods** (61,441 polygons) | `wof_neighborhoods/` | Per source: CC BY, ODC-By, Open Government licences, CC0, PDDL, public domain (folder `ATTRIBUTION.md`) | ✅ (attribution) | "Neighborhood boundaries: Who's On First and contributors"; per-source credits in the folder |
@@ -518,6 +523,20 @@ its width ("Sichuan, China · near Chengdu"), offline, with the states and provi
the division. Public domain; credited "Made with Natural Earth" with the other packs. Rebuild:
`node scripts/build-admin-packs.mjs --only places`; provenance in the folder README.
### Wikidata cities (`wikidata_cities/`)
Settlements of 15,000 people or more that Wikidata states a population and coordinates for,
read once from the Wikidata Query Service by `scripts/build-wikidata-cities.mjs`: one row per
place with its English label, latitude and longitude to 3 decimals, largest stated population,
ISO 3166-1 country code and Wikidata id (31,827 places, 1.6 MB). The pack is read the
first time a place name is looked up and gives the nearest city, the places in view and a city
found by name (`findPlace`: "Paris, France", or the nearest namesake in view). Groupings of
settlements (metropolitan areas, agglomerations) and places that no longer stand are left out
unless they are also a living city. Names match without accents ("Sao Paulo" finds São Paulo).
CC0; credited "City, town and village names from Wikidata (CC0)" as a courtesy once a name from
the pack is shown. Rebuild: `node scripts/build-wikidata-cities.mjs`; provenance in the folder
README. The app never calls Wikidata itself.
### Sky background (`sky/`)
Sources, licences, the changes CC BY asks to state, hashes and build commands
### A spy-satellite simulator in your browser — then you realize the sources are public and the data is real.
[](https://github.com/bilawalsidhu/gods-eye-view/actions/workflows/ci.yml) [](https://www.star-history.com/?type=date&repos=bilawalsidhu%2Fgods-eye-view) [](https://github.com/bilawalsidhu/gods-eye-view/stargazers) [](LICENSE)
Photorealistic 3D globe. Live aircraft, ships, satellites, earthquakes, traffic, and public cameras. Hands-free voice control powered by a realtime AI agent.
### A spy-satellite simulator in your browser. Except the data is real.
_No place left behind._
_The window through which we see our world._

[](https://godseyeview.ai)
<a href="https://www.youtube.com/@bilawalsidhu">
<img src="docs/media/youtube-popular-videos.png" alt="The God's Eye View video series on YouTube" width="100%">
</a>
Click any satellite, plane, ship or public camera and you can track it. Turn on FLIR mode and suddenly you're wondering, holy crap, is this real? And it's free, and open source.
▶️ **From the project behind the viral God's Eye View series**_(formerly WorldView)_ — [5M+ on YouTube](https://youtube.com/playlist?list=PL6qSg2I-7_koPbDnSMo0QeeHX_RknA2uv&si=nBGYMoHWQw41v93Q) · [25M+ across socials](https://www.google.com/search?q=god%27s+eye+view)
**[One-click install with Pinokio](https://pinokio.co/apps/github-com-bilawalsidhu-gods-eye-view)** · **[Run it from the terminal](#-quick-start)** · **[Hosted version waitlist](https://godseyeview.ai/online/)**
🏆 **Reached #1 on GitHub Trending, daily and weekly · August 2026**
🏆 **#1 on GitHub Trending**, daily and weekly · **[#8 Product of the Day](https://www.producthunt.com/products/god-s-eye-view?launch=god-s-eye-view)**, hunted by Chris Messina · _“pretty cool”_ — [Brendan Eich](https://x.com/BrendanEich/status/2094592096401490266), creator of JavaScript · Featured on **[Pinokio](https://pinokio.co/posts/01m1m4p9xxm3qw7dnnpj2wr93g)**
**[#8 Product of the Day](https://www.producthunt.com/products/god-s-eye-view?launch=god-s-eye-view)** · Hunted by Chris Messina, creator of the hashtag
▶️ **From the project behind the God's Eye View series**_(formerly WorldView)_ — [25M+ views on YouTube](https://youtube.com/playlist?list=PL6qSg2I-7_koPbDnSMo0QeeHX_RknA2uv&si=nBGYMoHWQw41v93Q)
_“pretty cool”_ — [Brendan Eich](https://x.com/BrendanEich/status/2094592096401490266), creator of JavaScript and co-founder of Mozilla and Brave · Featured on **[Pinokio](https://pinokio.co/posts/01m1m4p9xxm3qw7dnnpj2wr93g)**
⚡ **Start without API keys.** Install with [Pinokio](https://pinokio.co/apps/github-com-bilawalsidhu-gods-eye-view) or run locally from the terminal. Add optional keys inside the app. **[→ Quick Start](#-quick-start)**
**[Quick Start](#-quick-start) · [First Five Minutes](#-the-first-five-minutes) · [Talk to It](#-talk-to-it) · [What's Live](#-whats-on-the-globe) · [Under the Hood](#-under-the-hood) · [Keys & Costs](#-api-keys) · [Contributing](CONTRIBUTING.md)**
**[Quick Start](#-quick-start) · [What It Does](#️-what-this-thing-does) · [First Five Minutes](#-the-first-five-minutes) · [Talk to It](#️-talk-to-it) · [What's Live](#️-whats-on-the-globe) · [Keys & Costs](#-api-keys) · [Contributing](CONTRIBUTING.md)**
</div>
@@ -56,11 +52,41 @@ Start with the included data sources, then add your own. Each layer is a separat
## 🎛️ What This Thing Does
The world is already broadcasting. We fuse it together into a 3D globe for you and your agents.
We've got a plurality of sensor systems watching the planet right now. Satellite imagery, flights, ships, weather, public cameras. Each captures a sliver of what's happening. God's Eye View pulls that treasure trove of public data into a single picture.
<table>
<tr>
<td width="33%" valign="top"><img src="docs/media/site/voice.webp" alt="Ask the planet in God's Eye View" width="100%"><br><b>Ask the planet</b><br><sub>Use voice to ask the planet questions in natural language, and it annotates the 3D globe with the answer.</sub></td>
<td width="33%" valign="top"><img src="docs/media/site/flights.webp" alt="Flights and vessels in God's Eye View" width="100%"><br><b>Flights and vessels</b><br><sub>Click on a satellite, plane, ship or public camera and you can track it.</sub></td>
<td width="33%" valign="top"><img src="docs/media/site/satellites.webp" alt="Satellites in God's Eye View" width="100%"><br><b>Satellites</b><br><sub>Toggle on different kinds of satellites, everything from GPS to Starlink.</sub></td>
</tr>
<tr>
<td width="33%" valign="top"><img src="docs/media/site/cameras.webp" alt="Public cameras in God's Eye View" width="100%"><br><b>Public cameras</b><br><sub>Some layers, like traffic and camera poses, are estimates, and the app says so.</sub></td>
<td width="33%" valign="top"><img src="docs/media/site/cockpit.webp" alt="Cockpit in God's Eye View" width="100%"><br><b>Cockpit</b><br><sub>Visualize a flight from the third-person perspective and jump into a rendered cockpit view.</sub></td>
<td width="33%" valign="top"><img src="docs/media/site/weather.webp" alt="World class weather in God's Eye View" width="100%"><br><b>World class weather</b><br><sub>Clouds, rain radar, lightning density and cyclone tracks with forecast cones. And since we say 4D, you can scrub the cloud imagery backwards in time.</sub></td>
</tr>
<tr>
<td width="33%" valign="top"><img src="docs/media/site/imagery.webp" alt="Recent imagery in God's Eye View" width="100%"><br><b>Recent imagery</b><br><sub>Draw a bounding box around a fire and it'll retrieve the Sentinel-2 images, draped on the 3D terrain. All keyless, ladies and gentlemen.</sub></td>
<td width="33%" valign="top"><img src="docs/media/site/transit.webp" alt="Transit in God's Eye View" width="100%"><br><b>Transit</b><br><sub>Click a bus in Boston and it starts leaving a trail. This might be the most overkill way to track your bus.</sub></td>
<td width="33%" valign="top"><img src="docs/media/site/sdr.webp" alt="RF and SDR support in God's Eye View" width="100%"><br><b>RF and SDR support</b><br><sub>Now you can connect your own SDR and visualize everything you're detecting. The SDR nerds know all the other possibilities.</sub></td>
</tr>
<tr>
<td width="33%" valign="top"><img src="docs/media/site/radio.webp" alt="World radio in God's Eye View" width="100%"><br><b>World radio</b><br><sub>Ask for radio near anywhere and the globe starts broadcasting. Drag the tuner across up to 750 stations.</sub></td>
<td width="33%" valign="top"><img src="docs/media/site/mcp.webp" alt="MCP server in God's Eye View" width="100%"><br><b>MCP server</b><br><sub>We've built MCP access so your agents can query the same picture and add their findings to a shared canvas.</sub></td>
<td width="33%" valign="top"><img src="docs/media/site/director.webp" alt="Director Mode in God's Eye View" width="100%"><br><b>Director Mode</b><br><sub>Draw outlines, sketch paths, drop your annotations on the map.</sub></td>
</tr>
</table>
<details>
<summary><b>Everything else it does</b></summary>
- **🛩️ Cockpit view:** Ride inside a tracked flight — the camera holds the terrain under you all the way down.
- **📡 Contacts:** A 250 km roster of everything near your target — step through live aircraft and drop into any cockpit.
- **🎯 Click-to-track anything:** Camera locks on, draws a fading trail, surfaces full metadata — and a tracked fire or vessel hands you off to the nearest live camera in one click.
- **🖊️ Voice whiteboard:** Speak annotations onto the world — real boundary polygons, marks, and routes.
- **🛫 3D hangar:** Real per-class aircraft models — 787, ATR-72, Citation, Bell 206, MQ-9 — and a tracked contact swaps from glyph to 3D model as you close in.
- **🛫 3D fleet:** 122 procedural models drawn life size by type — airliners, business jets, helicopters, drones, ships, buses, trams and trains — and every contact swaps from glyph to 3D model as you close in.
- **🎨 Reskin reality:** GLSL sensor looks over the normal globe — CRT, NVG, FLIR/thermal, Noir.
- **🟩 Detection overlay:** Screen-space bounding boxes and IDs on everything in view.
- **🎖️ Military HUD:** Tactical heads-up display with intelligence-style telemetry.
@@ -77,6 +103,8 @@ Start with the included data sources, then add your own. Each layer is a separat
- **📦 Shareable scenes:** Import, preview and share Director scenes as files or bundles, with camera anchors, authored moves and data packs.
- **🌊 Nepal flood scene:** Replay the Bhote Koshi flood: flood path, witness sources and before-and-after imagery (bundled data is non-commercial; see [DATA_SOURCES.md](DATA_SOURCES.md)).
</details>
---
<div align="center">
@@ -156,7 +184,8 @@ See [docs/PERFORMANCE.md](docs/PERFORMANCE.md).
**macOS shortcut:** `./scripts/dev-fresh.sh` clears the Vite cache and pulls any
configured keys straight from the Keychain. It starts keyless too.
### Path 3 — Docker
<details>
<summary><b>Path 3 — Docker</b></summary>
No Node install needed; the container publishes the same dev server.
@@ -234,7 +263,10 @@ the container.
</details>
### Path 4 — GitHub Codespaces (cloud, no local install)
</details>
<details>
<summary><b>Path 4 — GitHub Codespaces (cloud, no local install)</b></summary>
Codespaces requires a GitHub account. Overpass queries, the News layer and OpenAI
voice token requests return HTTP 403 through its forwarded HTTPS URL, even with API keys
@@ -272,6 +304,8 @@ wider-publish case in [Sharing an instance](#-sharing-an-instance). Provider
Settings is unavailable on the forwarded URL. Never commit your workspace
`.env`. [SECURITY.md](SECURITY.md) has the threat model.
</details>
### Then power it up — in the app, not in a file
For a local setup, keys are upgrades, not prerequisites. When you want one,
@@ -314,54 +348,30 @@ and it carries the LAN-sharing rules alongside [Keys & Costs](#-api-keys).
## 🕐 The First Five Minutes
Choose a first-run mission, or try these in order. The GIFs show Google Photorealistic 3D; your starting basemap depends on the keys you've added.
Choose a first-run mission, or try these in order. Your starting basemap depends on the keys you've added.
1. **Light up the sky.** Take the **Live Contacts** mission (or turn on **Flights** yourself) — thousands of live aircraft, gliding on real telemetry, detection mesh already reading the scene. Click one: the camera locks on, a trail draws behind it, and its live telemetry card comes up.
2. **Take the controls.** Hit **COCKPIT** on your tracked plane and ride it down, switching sensors mid-flight: NVG into Ironbow FLIR.

3. **Drop into a busy airport.** Search one and descend to the taxiways with **3D** aircraft on — grounded contacts, taxi trails, the whole apron working in real time.

4. **Look through a public camera.** Turn on **Cameras** over Austin, London, California, Finland, or Delaware (live video). The feeds aren't webcam embeds — they project _into_ the 3D city. Cycle coverage to **VIEWSHED** and every camera draws its estimated coverage volume — where it reaches, and where it goes blind.

5. **Track something in orbit.** Turn on **Satellites** and click the ISS — you ride along at orbital distance, orbit ring and all.

6. **Switch the optics.** Tap `1`–`6` — CRT, NVG, FLIR — and the whole live planet re-renders through a different sensor.

7. **Talk to it**_(needs an OpenAI key)_: _"Take me to LAX and select the nearest airborne aircraft."_
8. **Come home.** Hit **Reset Globe** — or just say _"zoom out to a globe view."_
Real-time cockpit mode, built from live flight data: the camera rides your contact with real terrain holding underneath, all the way down — sensor styles come along for the ride, and **Contacts** keeps the 250 km roster one click away: jump plane to plane and fall straight into the next cockpit.

The cockpit even carries its own briefing strip: nearby live signals, regional headlines, and real local weather — with an opt-in **WX** mode that renders volumetric clouds from actual observations around your aircraft.

_Why cockpit mode exists: you're riding a real aircraft over real terrain — and you get to pick which sensor you see the world through._
---
## 🎙️ Talk to It
<details>
<summary><b>Providers, chat, ChatGPT OAuth and the voice check</b></summary>
The standalone app offers **OpenAI** and **Gemini** under **AI Provider** in Settings, one choice shared by voice and chat. OpenAI is the initial default; your choice is saved in this browser. To use Gemini, add `GEMINI_API_KEY` in Provider Settings or your local `.env` file, then select Gemini. `GEMINI_LIVE_MODEL` defaults to `gemini-3.8-live`. The permanent key stays on the local server, which issues a constrained, single-use session credential.
Changing provider ends the current conversation. If voice is on, the new provider starts with the same open-mic or push-to-talk mode; a held Space key is not carried over. Gemini uses the same map actions and captions, but has no OpenAI cost meter or MINI tier. When Gemini reports that its session has expired, start voice again for a new conversation. The AI Provider setting does not change the OpenAI-backed AI HUD summary.
@@ -376,6 +386,8 @@ GEV reads Codex's file credentials but does not write or refresh them. It checks
For a live voice check, run `node scripts/qa-voice-auth.mjs http://127.0.0.1:4189 oauth microphone.wav` against your local dev server. Use a WAV with three seconds of leading silence followed by a short spoken reply request. Replace `oauth` with `api-key` to check the API-key path. The check verifies audio input, a completed spoken reply, usage, resource cleanup, and reconnect. It saves screenshots and credential-free results under `.gev-logs/voice-auth/`.
</details>
Click **GEV MIC**, grant the microphone, and just talk. This is more than a voice-controlled remote:
- **🧠 It knows what it's looking at.** The agent pulls live scene context before answering — including coordinates, street names, active layers, and view scale. Ask _"what city is this?"_ mid-flight and it knows.
@@ -400,10 +412,6 @@ camera input stops rotation.
**✍️ Or draw it yourself** — UTILITIES ▸ **Draw**: pick Area, Line or Pin and a colour, click the vertices on the real world, double-click to finish, then name, recolour, hide or fly to each shape from its row. Same whiteboard, same persistence, no microphone needed.


**🔎 Interrogate it** — analyst queries against the live layers:
> 🗣️ _"How many flights are over Texas right now?"_ · _"Which ships are headed to Oakland?"_ · _"What is the biggest fire near Los Angeles?"_ · _"Is anything flying above forty thousand feet?"_ · _"When does the ISS pass over next?"_ · _"How many datacenters are in view?"_
@@ -416,10 +424,6 @@ camera input stops rotation.
> 🗣️ _"Show me global infrastructure."_ (stages the layers and pulls back to the globe) · _"Play Orbital Watch."_ (a full cinematic scene) · _"Set detection density to fifty percent."_ · _"Next contact — helicopters only."_ (mid-cockpit) · _"Show me space missions."_ · _"Switch to OSM."_ · _"Sharpen the image a touch."_ · _"Switch to the tactical layout."_ · _"What's turned on right now?"_

_Ask for radio near anywhere and the globe starts broadcasting — every station is a real place you can fly to._
---
**💬 Or ask from Claude and Codex.** God's Eye View is also an MCP server: ask Claude Desktop, Codex or ChatGPT desktop to show a place, and the live globe opens right in the conversation. Setup takes a minute — see [docs/MCP_SETUP.md](docs/MCP_SETUP.md).
@@ -428,6 +432,9 @@ _Ask for radio near anywhere and the globe starts broadcasting — every station
Twenty-three layers and map sources. **Twenty-one have a keyless path.** Some offer additional capabilities with a provider key. (🟢 no key · 🟡 free key · 🔴 metered.)
<details>
<summary><b>All twenty-three layers and map sources, with sources and keys</b></summary>
| 🗺️ **Map Stack** | Esri satellite imagery, Google Photorealistic 3D, OSM, plus additional ion-hosted stacks | Esri / Google / Ion / OSM | 🟢 Esri satellite + OSM · 🟡 ion-hosted Google 3D + world terrain · 🔴 direct Google + place search |
@@ -459,6 +466,8 @@ Twenty-three layers and map sources. **Twenty-one have a keyless path.** Some of
| 🌦️ **Observed Weather** | Rain radar (contiguous US), Satellite clouds (GOES regional or global infrared, Clouds only or Full image) and Lightning density (Americas and Pacific) on one history timeline | NOAA nowCOAST | 🟢 |
| 🌀 **Cyclones** | Advisory positions, forecast tracks and uncertainty cones for the Atlantic and eastern/central North Pacific | NOAA NHC / CPHC | 🟢 |
</details>
**Weather, keyless.** **Wind** animates 10 m forecast flow from NOAA GFS or ECMWF IFS, with an optional color field and a reading at map center. **Rain radar**, **Satellite clouds** and **Lightning density** are observations on one history timeline in the **WEATHER** panel (step back, **Play**, **Latest**); **Cyclone advisories** draw NHC and CPHC positions, forecast tracks and cones. On Google 3D Tiles the observed layers float above the city as translucent shells, sharpened around your view.
In the app, **Data Layers** groups them as Movement, Cameras, Infrastructure, Events, Weather and Audio; Directions and OSM Places sit in the separate **Utilities** panel with Draw and Import.
@@ -471,20 +480,17 @@ In the app, **Data Layers** groups them as Movement, Cameras, Infrastructure, Ev
| 🟡 A free Cesium ion token | **Google Photorealistic 3D cities** and world terrain — eligible personal, non-commercial use; current ion terms and quotas apply |
| 🔴 A Google Maps key | The same 3D direct from Google, plus Google place search — the billing-enabled, metered route |

_The Space Missions layer replaying a Falcon 9 ascent — labeled `RECONSTRUCTED ESTIMATE`, scrubbable 0.25×–4×._
**Also on the globe:** neighborhood overlays · an optional cockpit WX cloud effect. **Bundled static infrastructure:** Datacenters (4,352), Dams (704), and Submarine Cables (712).

**Missing a layer you want?** Open an issue — or add it and send the PR.
---
## 📷 Street Level
<details>
<summary><b>Street Level setup and use</b></summary>
> Street-level photos from any provider in one panel. This build ships **Mapillary** (a free client token), **Google Street View** (your Google Maps key), **KartaView** and **Panoramax** (no key).
**Setup.** At [mapillary.com/dashboard/developers](https://www.mapillary.com/dashboard/developers), register an application with **Read** access and copy its **Client Token** (`MLY|…`). Paste it into **POWER UP → Mapillary**, or set `MAPILLARY_CLIENT_TOKEN` in `.env` and restart. Without it Street Level starts on **KartaView** instead, and the Mapillary chip says which key to add. **Google Street View** uses `GOOGLE_MAPS_API_KEY` with the **Maps JavaScript API** enabled for it in Google Cloud; its chip starts off, since every panorama is billed to the key. **KartaView** and **Panoramax** need nothing: their public APIs are keyless.
@@ -493,37 +499,26 @@ _The Space Missions layer replaying a Falcon 9 ascent — labeled `RECONSTRUCTED
Share links carry the provider switches and filters (`0.m.0` Mapillary off, `0.m.0_0.r.google-1` Street View on, `0.m.0_0.r.google-0*kartaview-1*panoramax-0` KartaView on and `0.m.0_0.r.google-0*kartaview-0*panoramax-1` Panoramax on, as the app writes them (`0.m.0_0.r.kartaview-1` and `0.m.0_0.r.panoramax-1` work too; a link that leaves out `m` keeps Mapillary, the default, lit), `0.p.p` panoramas only, `0.s.365` the last year). To add a provider, implement the contract in `src/layers/streetLevel/registry.js` and register it in `src/app/layers/streetLevel.js`.
| **🚁 Ask the planet** | _"Why are all these military helicopters flying in circles?"_ Select a military track — it silently backfills ~24 h of real trace history — and see what it's been doing, resolved as stacked 3D loops. |
| **✈️ Final approach** | Click-track an airliner lining up for a runway, hop into the **cockpit**, and ride it down. |
| **🌃 Night watch** | Fly to your own city, switch to **NVG**, and let the detection mesh and HUD read the scene. |
| **🚢 Port call** | Vessels on over the Port of Long Beach. Click a tanker for its tactical card and wake trail — then hit **NEAREST** in the CCTV panel and look at the same water through a public camera. |
| **📻 Tokyo FM** | Orbit Shibuya with the **Radio** layer on — then drag the analog tuner needle: every position snaps to a real station and the globe flies to whoever's broadcasting. |
| **🔥 Fire line** | FIRMS over California. Click a detection — the camera dives to it — read the intensity, then hit **NEAREST** in the CCTV panel for a ground view. |
| **🚶 Ask for a walking route** _🎙️_ | Tell the world where you want to go and watch a real street-following route trace itself through the 3D city — then _"fly it"_: banked turns, eased ends, a camera that leads the path like a drone shot. |
| **📏 Measure LAX to DFW** _🎙️_ | _"How far is LAX from DFW?"_ — an arrow spans the country, the distance lands in the caption, and the endpoints stay pinned to the real world as you orbit. |
| **🚀 Launch replay** | Open **Space Missions**, pick a launch from the last 30 days, and ride the T-minus countdown through ascent to orbit — scrub it at 0.25×–4×. Labeled `RECONSTRUCTED ESTIMATE`, because it is one. |
| **🪦 Walk the boneyard** | Fly from regional context down into dense, fully resolved rows of retired aircraft. |
| **🏗️ Orbit Three Gorges** | Sweep the dam and its terrain at a glance — then flip on the **Dams** layer and find 703 more. |
This started as a mad science experiment that suddenly blew up. Next thing you know, Iran happened. Bilawal reconstructed it in 4D. The questions we kept getting: when can I use this thing, and can I bring my own data to the party?
_🎙️ = voice missions — they need an OpenAI key._
<table>
<tr>
<td width="33%" valign="top"><a href="https://www.youtube.com/watch?v=o_FJ1NIH9yw"><img src="https://img.youtube.com/vi/o_FJ1NIH9yw/mqdefault.jpg" alt="God's Eye View Blew Up. Here's What You Can Do With It." width="100%"></a><br><a href="https://www.youtube.com/watch?v=o_FJ1NIH9yw"><b>God's Eye View Blew Up. Here's What You Can Do With It.</b></a><br><sub>3.1M views on YouTube</sub></td>
<td width="33%" valign="top"><a href="https://www.youtube.com/watch?v=0p8o7AeHDzg"><img src="https://img.youtube.com/vi/0p8o7AeHDzg/mqdefault.jpg" alt="I Built God's Eye View to Monitor Iran in 4D" width="100%"></a><br><a href="https://www.youtube.com/watch?v=0p8o7AeHDzg"><b>I Built God's Eye View to Monitor Iran in 4D</b></a><br><sub>1.9M views on YouTube</sub></td>
<td width="33%" valign="top"><a href="https://www.youtube.com/watch?v=GRJaKcXZS94"><img src="https://img.youtube.com/vi/GRJaKcXZS94/mqdefault.jpg" alt="We Got Open Source God's Eye Before GTA 6" width="100%"></a><br><a href="https://www.youtube.com/watch?v=GRJaKcXZS94"><b>We Got Open Source God's Eye Before GTA 6</b></a><br><sub>1.2M views on YouTube</sub></td>
</tr>
<tr>
<td width="33%" valign="top"><a href="https://www.youtube.com/watch?v=pMZR4HmziyA"><img src="https://img.youtube.com/vi/pMZR4HmziyA/mqdefault.jpg" alt="Florida Learjet Crash - Final 78 Seconds Reconstructed in God's Eye View" width="100%"></a><br><a href="https://www.youtube.com/watch?v=pMZR4HmziyA"><b>Florida Learjet Crash - Final 78 Seconds Reconstructed in God's Eye View</b></a><br><sub>3.5M views on YouTube</sub></td>
<td width="33%" valign="top"><a href="https://www.youtube.com/watch?v=ccZzOGnT4Cg"><img src="https://img.youtube.com/vi/ccZzOGnT4Cg/mqdefault.jpg" alt="God's Eye View Reveals Iran's Chokehold on the Global Economy" width="100%"></a><br><a href="https://www.youtube.com/watch?v=ccZzOGnT4Cg"><b>God's Eye View Reveals Iran's Chokehold on the Global Economy</b></a><br><sub>700K views on YouTube</sub></td>
<td width="33%" valign="top"><a href="https://www.youtube.com/watch?v=g3toZwkrQQE"><img src="https://img.youtube.com/vi/g3toZwkrQQE/mqdefault.jpg" alt="God's Eye View Just Got a Massive Upgrade (Thanks To You!)" width="100%"></a><br><a href="https://www.youtube.com/watch?v=g3toZwkrQQE"><b>God's Eye View Just Got a Massive Upgrade (Thanks To You!)</b></a><br><sub>502K views on YouTube</sub></td>
</tr>
</table>

_Ask the planet: a military contact's last ~24 hours of real trace history, resolved as stacked 3D loops._

_"Draw the walking route… now fly it" — banked turns, eased ends, the camera leading the path like a drone shot._

_Walk the boneyard: rows of retired airframes, fully resolved in 3D._
More reconstructions, interviews and press: [godseyeview.ai/press](https://godseyeview.ai/press/) · [the full series on YouTube](https://youtube.com/playlist?list=PL6qSg2I-7_koPbDnSMo0QeeHX_RknA2uv&si=nBGYMoHWQw41v93Q)
---
@@ -532,7 +527,7 @@ _Walk the boneyard: rows of retired airframes, fully resolved in 3D._
How the globe handles live data:
- **World-stable icons.** Aircraft and ships point along their _true real-world heading_ at every camera angle — tracked or not, looking straight down or across the horizon — via per-frame screen-space course projection. No spinning, no viewport-locking.
- **Smooth motion from choppy data.** Live feeds arrive every 15–30s; the globe renders one interval behind real time and interpolates between known fixes. Dead reckoning fills the gaps.
- **Smooth motion from choppy data.** Live feeds arrive every 15–30s, often minutes late; the globe renders as far behind real time as the feed is late (at least one interval) and draws each aircraft along a smooth curve between its known fixes. Dead reckoning fills the gaps.
- **Honest satellites.** SGP4 propagation with orbit rings that stay locked to their satellites via GMST realignment — no drift, no per-second flicker.
- **Sits on the real ground.** Entity heights are aligned to work with Google 3D tiles, so aircraft park on aprons and cameras stand on street corners instead of floating.
- **Caching and request budgets.** An OpenSky credit governor, a TomTom daily tile budget, and disk-cached TLEs reduce repeated requests. These controls do not replace provider quotas or billing controls.
@@ -590,10 +585,6 @@ metered and Liveuamap is a paid subscription:
| 🟡 | **World News API** | 📰 News layer, Local: the news of the country in view. The free plan allows 50 points a day; `WORLDNEWSAPI_DAILY_READS` (default 30) keeps Core inside it. Core keeps each country's news for up to 1 hour, and World News API's [terms](https://worldnewsapi.com/terms/) allow caching only with its prior written permission, which is yours to get. The Data attribution popover credits it with a link | [worldnewsapi.com/console](https://worldnewsapi.com/console/) — free plan |

_What the TomTom key buys you: rush-hour density painted on the city — then dive from the jam straight into the camera watching it._
### Cherry on top
| | Key | Why | Get it |
@@ -704,7 +695,7 @@ God's Eye View runs on **public data, clear sources, and local-first execution.*
**Maintainers:** [Bilawal Sidhu](https://github.com/bilawalsidhu) and [Sameh Khamis](https://github.com/samehkhamis) at [Halfpixel](https://halfpixel.ai).
<sub>Media note: the capture GIFs on this page show Google Photorealistic 3D Tiles and live data layers, used promotionally with in-frame attribution; they aren't licensed for standalone reuse. See [media provenance and permissions](docs/media/README.md); full source terms in [DATA_SOURCES.md](DATA_SOURCES.md).</sub>
<sub>Media note: the clips on this page are the ones shown on godseyeview.ai. Some show Google Photorealistic 3D Tiles and live data layers, used promotionally with in-frame attribution; they aren't licensed for standalone reuse. See [media provenance and permissions](docs/media/README.md); full source terms in [DATA_SOURCES.md](DATA_SOURCES.md).</sub>
> [!IMPORTANT]
> God's Eye View is an exploratory visualization of public and third-party data.
@@ -725,13 +716,13 @@ So here it is. Step inside the spy-thriller cockpit — except the data is real
One heads-up from the inside: build in this space for a week and you learn that **the present is the cheap part**. The moment you try to go back in time — tiling, serving, and scrubbing _what happened_ and _what changed_ at any real resolution — the data gets expensive and the compute gets brutal. That's the long game.
**Update — a hosted version is coming.** We originally planned to keep this repository as the open-source client and build a separate professional product. Then the launch happened, and the loudest request wasn't another feature — it was _"just give me a link."_ So we're building an official hosted God's Eye View at [Halfpixel](https://halfpixel.ai): no installation, just open it in your browser. The hosted version is the easiest way into this open-source project. More soon.
**Update — a hosted version is coming.** We originally planned to keep this repository as the open-source client and build a separate professional product. Then the launch happened, and the loudest request wasn't another feature — it was _"just give me a link."_ So we're building an official hosted God's Eye View at [Halfpixel](https://halfpixel.ai): no installation, just open it in your browser. The hosted version is the easiest way into this open-source project. Sign up for the [waitlist](https://godseyeview.ai/online/) and get notified.
---
<div align="center">
▶️ [Watch the God's Eye View series](https://youtube.com/playlist?list=PL6qSg2I-7_koPbDnSMo0QeeHX_RknA2uv&si=nBGYMoHWQw41v93Q) · 📬 [Map the World](https://maptheworld.ai/) — the newsletter behind the project
🌐 [godseyeview.ai](https://godseyeview.ai), the official site · ▶️ [Watch the God's Eye View series](https://youtube.com/playlist?list=PL6qSg2I-7_koPbDnSMo0QeeHX_RknA2uv&si=nBGYMoHWQw41v93Q) · 📬 [Map the World](https://maptheworld.ai/) — the newsletter behind the project
- While anything moves (layers in motion, the camera, a followed contact), the globe now draws at the display's own refresh rate instead of a fixed 60 frames a second. A parked scene still ticks at most 60 times a second. Waits that counted frames (a followed contact's first position, a shared follow view, a trail's temporary copy) now count drawn time, so they last the same at any refresh rate. Screen marks over a followed contact fade out over the same time at any refresh rate.
- A civil or military aircraft whose feed sends neither a ground track nor a true heading now faces the way its newer positions went, instead of north, so a taxiing aircraft no longer appears to move sideways or backwards. An older position from another feed, or position noise on a parked aircraft, never turns it.
- Playing the world clock away from live now draws at the display's own refresh rate instead of at most 60 FPS.
- Vessels following a playing clock are moved again once the fastest would have moved half a pixel on screen, at least once a second, and at once when the camera moves or zooms. Before, every drawn vessel moved every frame by a fraction of a pixel, which took most of each frame with thousands of vessels in view.
- A grounded aircraft turns from its icon into its 3D model as soon as the 3D tiles under it have loaded. Tiles still streaming no longer count as a failed ground sample, so after a pan the models no longer appear late and in batches, up to half a minute after the view settled.
| `server/standalone/` | Environment, local settings writes and server composition |
See [application construction](APPLICATION.md) and the
[infrastructure contract](INFRASTRUCTURE-LAYERS.md) for construction interfaces.
[infrastructure contract](INFRASTRUCTURE-LAYERS.md) for construction interfaces, and the [renderer contract](RENDERER-CONTRACT.md) for what a renderer provides.
## Import direction gates
@@ -293,9 +294,9 @@ the user's later collapse choice, including body remounts. Mark the body
`max-height` and puts the scroll offset back afterwards. Panel bodies only
scroll on an open-card change, with one write, never on a refresh.
Compose `createRailCards({ container, document, onParams, onOpen })` and
@@ -83,6 +83,21 @@ menu.onChoose = (code) => switchLocale(code); // switched in place and stored (i
`switchLocale` does what a choice in the globe picker does, and returns `'unchanged'` for the active language. `onLocaleChange` tells the application's own menu to mark the new language.
The same entry exports the translator Core's text goes through (`t`, `tn`, `msg`, `translateKnown`, `formatNumber`, `formatDate`, `formatRelativeTime`), so the application's own text follows the same language. To show its own wording for one of Core's messages, it overrides it by the catalog key, in English and in any locale it words:
```js
import { setMessageOverrides } from '<core package>/i18n';
setMessageOverrides({
en: { 'Download scene JSON': 'Download scene file' },
de: { 'Download scene JSON': 'Szenendatei herunterladen' },
});
```
Keys are the catalogs' (`context|text` for a context, the English plural for `tn`). A `t` entry is text; a `tn` entry is `{one, other, …}` forms, chosen by the plural rules of the locale they are worded in; an entry of the other kind is ignored. An overridden message shows the application's text in the active locale, else its English: an English-only override replaces Core's translations of that message too, so word every locale that should keep its own. Each call replaces the earlier overrides and `{}` removes them.
Call it before views render. `onLocaleChange` listeners word their text again at once, but a view already drawn keeps its text until it next renders. Import it from the `./i18n` entry only: a second copy of the module (a path alias into Core's sources) keeps its own overrides and language.
## Rules
- **Pass literals.**`t('Close')`, not `t(label)` (unless `label` holds a `msg()` value) and never a template literal with `${…}`.
| `overlayHost.clearSource` | `(sourceId)`; remove that source's overlay entries |
| `registerEntityContext` | `(entity, metadata)`; register selectable feature metadata, including the owning layer and data source |
| `selectEntityContext` | `(entity)`; select that registered feature |
| `clearSelectedEntityContextForLayer` | `(layerId)`; clear selection only if owned by this layer |
| `removeEntityContextsForLayer` | `(layerId)`; remove records owned by the layer on destruction or failed setup |
| `clearSelectedEntityContextForLayer` | `(layerId, { evicted })`; clear selection only if owned by this layer; `evicted` when its feature left the data |
| `removeEntityContextsForLayer` | `(layerId, { retainIds })`; remove records owned by the layer on destruction or failed setup, or those a new feature set no longer has |
| `getSelectedEntityContext` | optional; `()` the selected record, so `replaceFeatures` keeps a selection the new set still has |
| `governorRequestRender` | `(reason)`; request a frame through the existing render scheduler |
Each returned layer supports `init(viewer)`, `enable(viewer)`, `disable(viewer)`,
@@ -45,18 +46,43 @@ Callbacks must be ready before enable and remain usable through destruction.
Disable retains the loaded dataset for reuse and clears selection and listeners.
Concurrent enables share one load. Destroy is permanent, aborts pending fetches,
discards late results, and clears the owned data source, context records, overlays,
discards late results, and clears the owned draw sets, context records, overlays,
input handler and listeners. The layer never creates an application context store,
overlay host, viewer, or render scheduler. The consumer must resolve one compatible
Cesium installation shared with its viewer; it must not bundle separate copies.
The layers draw, size their stems and fly the camera through the renderer's
ports. A viewer the application has bound a renderer to needs nothing more; a
Cesium viewer with no renderer bound loads
`gods-eye-view/render/cesium/unbound` once first; until then the layer reports
an error naming it, as it does for a dataset it cannot load.
A selected feature is the context record its draw item carries as `meta`; the
layer no longer sets the viewer's `selectedEntity`.
Features keep their own simplestyle `fill`, `fill-opacity`, `stroke`,
`stroke-opacity`, `stroke-width`, `marker-color` and `marker-size`, given as
hex, `rgb()` or `hsl()` colours or by the CSS colour names the default renderer
knows (it has no `rebeccapurple`, and spells `lavenderblush``lavendar_blush`);
a `marker-symbol` is stamped on the pin as the default renderer stamped it: a
one-character string as bold upper-case text, any other value as the Maki icon
of that id from the renderer's assets, the plain pin when the icon cannot be
loaded. The assets are found as the renderer finds them from a page script: the
`CESIUM_BASE_URL` global, else the folder `Cesium.js` is loaded from; a
page bundling Cesium as modules sets `CESIUM_BASE_URL` for icon pins. Polygons with heights are drawn at them, outlined; points with
heights stand their pin on the stem's tip. Edges follow rhumb lines.
`gods-eye-view/infrastructure/geojson` exports the lower-level
`createLocalGeoJsonLayer(options, services)` and existing infrastructure overlay
helpers. `gods-eye-view/infrastructure/lod` exports the existing LOD policy helpers.
helpers. Its options also take `loadFeatures({ signal })`, a loader resolving to
GeoJSON features in place of `url`, and `featureColor(properties)`, a CSS colour
per feature for its fill, stem, dot, pin and label accent. The layer it returns
also has `dropCachedFeatures()`, so the next `enable` loads again, and
`replaceFeatures(viewer, features)`, which draws a new feature set in place of
the current one: the current one stays drawn until the new one is built, and
stays if that fails (the call then rejects). `gods-eye-view/infrastructure/lod` exports the existing LOD policy helpers.
Consumers use the package exports, which do not import standalone application
globals.
Dataset files and source/license notices remain under `src/data/local_data/`.
Their input counts are 4,352 datacenter features and 704 dam features. Cesium may
expand multipart geometries into multiple entities; entity and stem counts are
different measurements. This change does not refresh or relicense the datasets.
Their input counts are 4,352 datacenter features and 704 dam features. A multipart
geometry draws as several parts, each with its own stem; part and stem counts are
different measurements from feature counts. This change does not refresh or relicense the datasets.
Bilawal Sidhu created and owns the following 17 GIFs and has authorized their inclusion and redistribution as part of this public repository and its project documentation. Any appearance by Bilawal Sidhu in these captures is included with his permission.
The following animated images in `site/` are the clips shown on [godseyeview.ai](https://godseyeview.ai), converted to animated WebP for the README. Bilawal Sidhu and Halfpixel, Inc. created them and have authorized their inclusion and redistribution as part of this public repository and its project documentation.
The GIFs are promotional captures of God's Eye View. They include Google Photorealistic 3D Tiles and public or third-party data layers with in-frame attribution. Bilawal Sidhu's ownership and permission cover the captures and his likeness; they do not replace the terms of Google Maps Platform or any displayed data provider. Keep the visible attribution intact.
The clips are promotional captures and renders of God's Eye View. Some include Google Photorealistic 3D Tiles and public or third-party data layers with in-frame attribution. The permission above covers the clips; it does not replace the terms of Google Maps Platform or any displayed data provider. Keep the visible attribution intact.
The launch-era capture GIFs that this page listed before were removed from the README and from the repository in November 2026. They remain in the Git history under the terms stated for them at the time.
## Public README PNGs
Bilawal Sidhu published the following PNGs in the existing public `bilawalsidhu/gods-eye-view` repository and authorized their continued inclusion and redistribution with this repository and its project documentation:
Bilawal Sidhu published the following PNG in the existing public `bilawalsidhu/gods-eye-view` repository and authorized their continued inclusion and redistribution with this repository and its project documentation:
- `youtube-popular-videos.png`
- `open-source-survey.png`
Source: [`assets/youtube-popular-videos.png`](https://github.com/bilawalsidhu/gods-eye-view/blob/7afb3beefb2dd39110ed117c8f06825e9ca2ada4/assets/youtube-popular-videos.png) and [`assets/open-source-survey.png`](https://github.com/bilawalsidhu/gods-eye-view/blob/7afb3beefb2dd39110ed117c8f06825e9ca2ada4/assets/open-source-survey.png) in public repository commit [`7afb3beefb2dd39110ed117c8f06825e9ca2ada4`](https://github.com/bilawalsidhu/gods-eye-view/commit/7afb3beefb2dd39110ed117c8f06825e9ca2ada4). The localized files preserve the source bytes unchanged.
Source: [`assets/open-source-survey.png`](https://github.com/bilawalsidhu/gods-eye-view/blob/7afb3beefb2dd39110ed117c8f06825e9ca2ada4/assets/open-source-survey.png) in public repository commit [`7afb3beefb2dd39110ed117c8f06825e9ca2ada4`](https://github.com/bilawalsidhu/gods-eye-view/commit/7afb3beefb2dd39110ed117c8f06825e9ca2ada4). The localized files preserve the source bytes unchanged.
These files are not covered by the project's MIT License. No permission is granted for standalone reuse or modification. Commercial reuse outside this repository requires separate permission. No share-alike license applies.
@@ -4,7 +4,7 @@ Catalog: `src/i18n/locales/zh-Hant.json`. General rules: [TRANSLATORS.md](../TRA
`zh-Hant` is the Simplified Chinese catalog (`zh-CN`, credited to abiyeenzo, #914, and EDIT-Aeterna, #979) written in Traditional characters with OpenCC character conversion. Wording and terminology are the same as in `zh-CN`: change a term in [zh-CN.md](./zh-CN.md) and the `zh-CN` catalog first, then convert. Only the script differs.
"description":"A real-time intelligence console for planet Earth \u2014 photorealistic 3D globe, live aircraft/ships/satellites/earthquakes/CCTV, and hands-free voice control. Runs in a browser.",
"description":"A real-time intelligence console for planet Earth — photorealistic 3D globe, live aircraft/ships/satellites/earthquakes/CCTV, and hands-free voice control. Runs in a browser.",
The model files in this directory are third-party visual assets. They are not
covered by the repository's MIT source-code license; each remains available
under the license listed below.
Every 3D model shipped in this directory is one of the project's procedural
fleet models under [`fleet/`](fleet/): aircraft, helicopters, ships, buoys,
transit and rail vehicles, and a few other airborne and ground objects. They
are generated from code by the project maintainers, contain no third-party
artwork, and are covered by the repository's [MIT license](../../LICENSE)
like the source code.
| File | Original work and creator | Source | License | Project modifications |
|---|---|---|---|---|
| `airplane.glb` | “boeing 747” by [zairiq-123](https://sketchfab.com/zairiq-123) | [Sketchfab model](https://sketchfab.com/3d-models/boeing-747-9b16672038ba48f98e6d80a159044ed9) | [CC BY 4.0](https://creativecommons.org/licenses/by/4.0/) | Substantially modified and optimized for God's Eye View, including geometry/material simplification and coordinate/orientation preparation. The former 24× runtime calibration is baked into the mesh; location, rotation, and scale are applied; the bounding-box centre is at the origin; and the model uses glTF +Y-up with its nose toward local −X. Geometry remains uncompressed so the aircraft asset does not compete with photogrammetry for Draco worker capacity. |
| `jet.glb` | “Private Jet” by [Nick the Name](https://sketchfab.com/Nick_The_Name) | [Sketchfab model](https://sketchfab.com/3d-models/private-jet-cbdd1de6ced9461e950eafaa302cc82b) | [CC BY 4.0](https://creativecommons.org/licenses/by/4.0/) | Repackaged as a glTF binary for the project's military-flight visualization. Imported hierarchy transforms are baked into the meshes; location, rotation, and scale are applied; the bounding-box centre is at the origin; and the model uses meter scale, glTF +Y-up, and the shared nose −X convention. Existing materials are preserved. |
| `bell206.glb` | “Bell 206 JetRanger” by [terran4627](https://sketchfab.com/terran4627) | [Sketchfab model](https://sketchfab.com/3d-models/bell-206-jetranger-d2f7ba1d671549d4b26aaf834139a1dd) | [CC BY 4.0](https://creativecommons.org/licenses/by/4.0/) | Optimized for God's Eye View: geometry/material simplification, textures resized to 256 px WebP, orientation/scale vertex-baked to real-world meters (Y-up, nose −X), origin centered. |
| `c172.glb` | “Cessna 172” by [e737](https://sketchfab.com/e0057537) | [Sketchfab model](https://sketchfab.com/3d-models/cessna-172-64cddaee5aff470682659a8c08525046) | [CC BY 4.0](https://creativecommons.org/licenses/by/4.0/) | Optimized for God's Eye View: geometry/material simplification, textures resized to 256 px WebP, orientation/scale vertex-baked to real-world meters (Y-up, nose −X), origin centered. |
| `citation2.glb` | “1990 Cessna Citation, Texture Detailed, Exterior” by [BlenderCommunityHead](https://sketchfab.com/aboodgoudagad) | [Sketchfab model](https://sketchfab.com/3d-models/1990-cessna-citation-texture-detailed-exterior-a78839624fe64900a8352cb23462350a) | [CC BY 4.0](https://creativecommons.org/licenses/by/4.0/) | Optimized for God's Eye View: geometry/material simplification, textures resized to 256 px WebP, orientation/scale vertex-baked to real-world meters (Y-up, nose −X), origin centered. |
| `mq9.glb` | “MQ-9” by [IProZenoN](https://sketchfab.com/IProZenoN) | [Sketchfab model](https://sketchfab.com/3d-models/mq-9-fabe963feb354c5584b51f9c470c3f7e) | [CC BY 4.0](https://creativecommons.org/licenses/by/4.0/) | Optimized for God's Eye View: geometry/material simplification, textures resized to 256 px WebP, orientation/scale vertex-baked to real-world meters (Y-up, nose −X), origin centered. |
| `b789.glb` | “Boeing 787-9” by [Nobilis 2](https://sketchfab.com/nobilishornet2) | [Sketchfab model](https://sketchfab.com/3d-models/boeing-787-9-b6711e2e698e4e469675c1154a50b7a3) | [CC BY 4.0](https://creativecommons.org/licenses/by/4.0/) | Optimized for God's Eye View: geometry/material simplification, textures resized to 256 px WebP, orientation/scale vertex-baked to real-world meters (Y-up, nose −X), origin centered. |
| `atr72.glb` | “ATR 72 - 600” by [Oyan3D](https://sketchfab.com/oyan3D) | [Sketchfab model](https://sketchfab.com/3d-models/atr-72-600-1e1a7186f7444d288675262fcee44744) | [CC BY 4.0](https://creativecommons.org/licenses/by/4.0/) | Optimized for God's Eye View: geometry/material simplification, textures removed with dominant material colors baked into PBR factors (flat “abstracted” style), orientation/scale vertex-baked to real-world meters (Y-up, nose −X), origin centered. |
| Path | What it holds |
|---|---|
| `fleet/catalog.json` | Every model by name: its file, category, built length, beam and bounds (metres, in Cesium's Z-up model frame: x along the length with the nose toward −X, y across the beam, z up), the clearance below its origin, and its 2D icon class. |
| `fleet/types.json` | Which model draws which vehicle, and at what length: ICAO aircraft and helicopter type codes, ADS-B emitter categories, AIS ship-type and length ranges, GTFS route types, transit modes and rail categories, with the defaults. |
| `fleet/aircraft/`, `fleet/helicopters/`, `fleet/ships/`, `fleet/buoys/`, `fleet/transit/`, `fleet/other/` | The models, one GLB each (EXT_meshopt_compression and KHR_mesh_quantization, vertex colours, no textures). |
CC BY 4.0 permits sharing and adaptation, including commercial use, provided
appropriate credit is retained, the license is linked, and modifications are
identified. These credits do not imply endorsement by the original creators.
How the layers use them:
- Each layer draws a vehicle with the model its type selects, scaled to the
type's published length (a vessel to its reported AIS length and beam), so
every model is drawn life size. Ground objects, balloons and obstacles in
the `other` category are drawn at the size they are built.
- An aid to navigation (a vessel record whose type names a buoy, beacon, IALA
mark, RACON or light, or whose MMSI is an aid station's `99MIDxxxx`) is
drawn as the `buoys` model of its mark (cardinal north, east, south or west,
port or starboard hand, safe water, isolated danger, special mark), a red
can when its type names no mark, at its built size and with no heading
(`vesselModelSpec`, `aidToNavigationModel`).
- An aircraft model's origin is its axis; it stands that model's scaled
clearance above the ground. A ship's origin is its waterline, and a transit
or rail vehicle's the road or rail top (a monorail or gondola is raised by
its `transit.elevation` entry, for a source that names those modes).
- Transit and rail models carry a `_TINT` vertex attribute that marks where
the route or category colour is painted.
- The whole set loads once, up front, when a layer that draws it starts; no
model is fetched while a session runs.
`src/data/fleetModels.js` reads the set and chooses each vehicle's model;
`src/data/fleetModels.test.mjs` checks that every model `types.json` names is
in the catalog and on disk, and that no GLB exceeds 3 MB.
Loaded 100 of 1512 files, more files were not shown because too many files have changed in this diff.
Show more
Reference in new issue
Block a user
Blocking a user prevents them from interacting with repositories, such as opening or commenting on pull requests or issues. Learn more about blocking a user.