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).
AIS Vessels are keyed by the id their live source gives, with the MMSI as an
attribute: an MMSI can be shared, spoofed or reused, so two vessels with one
MMSI are now two vessels. Looking a vessel up or selecting it by MMSI still
finds it.
A share link made while a vessel is selected opens that vessel. A UUID vessel
id travels as 16 bytes in a new thing field (13). A shared thing that is not
reporting now says so in a sentence per kind, with its id (ICAO, NORAD, MMSI
or vessel UUID) on a second line.
A live source may now declare a timeline: it can answer a snapshot at a
given time (source.timeline = { coverage(), stepMs, subscribe? }, read by
readSnapshotTimeline). While such a layer is on it follows the world clock
and registers the coverage. At the live edge it polls exactly as before;
away from it the layer asks for getSnapshot({ ...query, atMs }) at the step
at or before the clock time and shows that snapshot instead of polling.
src/time/snapshotTimeline.js owns the following: a seek, time going
backwards or leaving live replaces every contact with the snapshot at the
new time (play waits on it, for at most 8 s); playing on keeps one
snapshot ahead and gates play on it, applying those snapshots as polls so
contacts move smoothly; outside coverage the layer is empty; back at live
it is cleared and polls at once. One load at a time, and a load the
source drops for a newer one is not a failure.
While following, aircraft are drawn at the clock time with no render
delay, records and absences are judged at the clock, track requests carry
atMs, and vessels move between fixes along the great circle. The world
clock counts jumps (seeks and returns to live) in getState().
A source with no timeline never follows the clock, and every layer stays
live, unchanged.
The radio and push-to-talk helpers shared by both voice providers now pass
English catalog text, and the OpenAI controller words its detail when shown,
like the Gemini session. A token failure without a server message carries
its status as sourceParams, so it is worded again with the number. The docs
say sourceDetail is the message as given, catalog text when it is the app's
own.
- 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.
The Gemini session translated each status and error message once, when it
happened, so after a language change the voice control kept showing it in
the old language. The state event now also carries the English catalog text
as sourceDetail, and the control words it when shown. The local server's
known token errors stay catalog text until then instead of being translated
on arrival.
- 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 Gemini token route now answers a missing key with code API_KEY_MISSING,
the session carries it to the error state as missingKey, and the voice
control hides "Check microphone permission" for that error, as it already
does for OpenAI. The OpenAI controller sends the same flag, so the shared
control and the controller agree whichever updates last.
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.
The voice error was matched against the translated key message to decide
whether to show the microphone hint, so switching language brought the hint
back and left the message in the old language. The error now carries a
missing-key flag into the status, which words the message at render time.
A controller test covers the language switch, and CURRENT-STATE.md documents
the keyless voice response.
The decision no longer reports not-entity-context or channel-closed, which
its only caller rules out first, nor pointer-scale-not-useful, which the
crop path already checks and logs. A closed channel returns before any
record, as on main. The crop decision is pointer-crop-eligible, since the
crop checks after it decide whether the pointer is on ground, and a sender
called on a closed channel logs channel-lost.
In a dense downtown view from about 400 m up, the occlusion margin of
max(3 m, 2% of the range) came to 14 to 20 m, so a wall, awning, tree or
lower facade standing 10 to 20 m in front of a street was read as the
road itself: the vehicle's dot was hidden by the scene, but its bracket and
callout were still drawn. Checked against scene.pickPosition in one such
view, 18 of 470 vehicles in frame fell in that band.
The margin now depends on how steeply the camera looks down on the
contact. A point on the line of sight s metres in front of a vehicle
stands s * sin(elevation) above it, so a surface there hides the vehicle
once that rise passes 2 m. The margin stays at least 3 m and at most 2%
of the range, so grazing and street-level views are unchanged. In the
same views no vehicle with the drawn surface within 3 m in front of it
(its own road) is newly hidden.
From the review of the first change:
- A contact back in view after longer than a retest interval is held back
and retested like a new one, instead of being drawn from an answer
given before it left the view. It gets a fresh record, so a test still
in flight from before cannot end the hold-back either.
- The hold-back for a contact's first answer stretches with the retest
pace when a crowded view slows it.
- A batch whose control point failed no longer counts as a first answer.
- An unknown log-depth flag reads as "no depth" rather than as standard
depth, which would have put every surface in front of every contact.
- A shader that fails to build leaves no shader behind and is not built
again on the same context.
The detection overlay only hid a contact behind the Earth's curve, so a
street vehicle behind or under a building, a 3D tile or a hill still had
its bracket and "VEH-nnnn" callout painted over that geometry, while its
own dot was depth-tested and correctly hidden.
A contact a layer marks `depthTested: true` (only Street Traffic does) is
now tested against the depth the scene drew and left out of the overlay
while a drawn surface stands in front of it by more than max(3 m, 2% of
its range). Other layers are untouched: their markers are drawn over the
scene on purpose.
The test runs on the GPU and never waits for it. Each tested contact is
one point drawn inside an occlusion query; the vertex shader looks up the
frame's packed pick depth at the contact's pixel, decodes it and drops the
point when the surface is nearer than the contact's threshold. Query
results are collected on later frames. Reading depth back was measured
and rejected: `scene.pickPosition` per contact costs 0.2 to 1.4 ms each,
and Chromium answers `getBufferSubData` with a round trip to its GPU
process even behind a signalled sync object (1.5 ms on a quiet machine,
15 to 25 ms on a busy one).
- Contacts are retested every 100 to 200 ms, spread across frames, at
most 256 a frame; with more in view the pace stretches so none starves.
- Hiding is immediate. A hidden contact returns 600 ms after its last
"hidden" answer, so one on a silhouette edge does not blink, and a
contact new to the view is held back until its first answer (400 ms at
most), so orbiting does not flash brackets behind buildings.
- A callout whose contact goes behind something is dropped at once, not
carried to the next solve and not faded out on the facade.
- These times run on painted frames, so a hidden tab does not expire them.
- A control point in every batch must draw; if it does not, the batch is
ignored and after three the probe stands down for ten seconds. With no
pick depth (2D, Columbus view, depth picking off) nothing is hidden.
A WebGL 1 context reads depth back synchronously about 8 times a second.
The renderer internals this depends on are read in one function,
`readSceneDepthSource`, with the engine version they were checked against.
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.
- layerStateTokenLedger.test: the retired-token reuse case now offers the
retired token (02) to the newcomer, not News's 00.
- he.json: the catalog's singular imperative, {count} first in the plural,
Wikidata read as one source, and smoother legend and info text.
- layerManifest: News after Shipwrecks, so the prompt-budget comment stays
next to the entries it explains.
- CURRENT-STATE: Prettier-formatted (table column, blank line before a heading).
Main added the News layer at the same places: both layers are kept in the
layer names, panel order (News stays last of Events), standalone sources,
voice manifest, credits, DATA_SOURCES and the CURRENT-STATE table. News took
share-link token 00 first, so Shipwrecks moves to 01 (ledger, registry,
CURRENT-STATE and the token tests). The catalog now has 40 layers and the
share-link registry 38. Shipwreck strings are added to the new Hebrew
catalog; the other catalogs keep both sides' strings.
Removing one source's wrecks on the page split merged records: a wreck both
sources list is one Wikidata record carrying EMODnet facts, so expiring
Wikidata dropped wrecks EMODnet still had, and expiring EMODnet kept its
facts. The page now keeps every shown wreck, marked stale, until the newest
source passes the limit, then clears them all. Adds a source test for the
reported ages and limit.
The page compared the proxy's fetchedAt with its own clock, so a skewed
browser clock cleared or kept wrecks wrongly; a snapshot without a timestamp
never expired; and one old source cleared the other's fresh wrecks. The proxy
now reports each source's age on its own clock and its seven-day limit; the
page turns them into per-source deadlines when the snapshot arrives (seven
days from arrival when no age is given) and, on a failed refresh, removes only
the sources past theirs. A refused short refresh is logged.
CURRENT-STATE said each source is asked at most once a day; a failed source
is retried after 15 minutes. It now also covers refused short refreshes and
the page clearing expired wrecks, and its two shipwreck paragraphs are
rewrapped. The card's comment no longer says the records carry no names.
- A source without a version (undefined, not null) compared as unchanged, so
an injected source's new snapshots were never drawn.
- When the page could not refresh (the proxy answers 502 once both sources
are past seven days), it kept showing the old wrecks as fresh. They are now
marked stale, and removed once older than the proxy's own seven-day limit.
A 200 answer that was valid but cut short (30 Wikidata wrecks instead of
about 1,450) replaced the last good set for a day. It now counts as a failed
refresh: the old records are served as stale and the source is retried after
15 minutes; once the old set is past seven days, the new one is taken.
- The legend counted each era twice, scanning every record eight times per
row refresh; it now counts once.
- Each year picker listed every year from the oldest dated wreck (well over
a thousand entries); it lists the years that have a wreck, plus the chosen
ends.
- Labels fell back to Portuguese and links to Portuguese Wikipedia while the
app ships 11 locales: labels now fall back through the app's languages
after English, and a wreck with no English article links its Wikidata
item, which lists the article in every language.
DATA_SOURCES and CURRENT-STATE said text naming people is dropped. The filter
drops text with a title or role word (Mr, captain, owner, crew, reported by);
a bare name with none of them still passes. The docs and the code comment
now say so.
Air accidents (#1584) is not merged, so comments, the changelog fragment and
CURRENT-STATE no longer explain the shipwrecks markers, card and picker by
it; the row-range test fixture is the shipwrecks row. CURRENT-STATE now says
the markers are one billboard collection and the period is stored swapped.
They were listed as owned by the ghostmaps and ghostmaps-source packages,
which they are not part of; ghostmaps-source is meant to stay free of
rendering code, and shipwrecks/index.js imports Cesium. The app groups that
own every layer keep them.
A period set as 1950 to 1900 (a link or the voice tool) showed as 1900–1950
but stayed reversed, so changing "From" to 1920 gave 1920 to 1900, shown as
1900–1920: the end the reader did not touch moved.
- The ~8,000 markers were one Cesium entity each; they are now one
BillboardCollection (as FIRMS, vessels and wildlife sightings do), ordered
at the bottom of the shared sprite stack so moving traffic draws over it.
- eyeOffset.z was the death toll in metres, so a 1,500-death wreck's marker
sat 1.5 km toward the camera and clipped or drifted when close. It is gone;
markers are added by rising toll, so a bigger toll still draws on top.
- The page asks every 6 h but the proxy changes data at most daily: the proxy
now sends a version that changes with either source's data, and the layer
rebuilds only when it does.
- Adds a controller test: enable/disable, teardown, draw order, unchanged
snapshots, a late response after turning off, and the period closing an
open card.
A refresh with one source down (or Wikidata answering 200 with no results)
was cached as the day's snapshot, replacing the full set; and once the
snapshot was a day old, every request after a failure fetched both sources
again. Each source now keeps its own last good records, served as stale for
up to seven days, and a source that failed is not asked again for 15 minutes,
even when there is no data yet. A Wikidata answer without results, or with no
wreck in it, counts as a failure.
The query read P576 through wdt:, which carries no precision, and a missing
precision counted as a day. It now reads the best-rank statement's value with
wikibase:timePrecision, and a value without a precision is trusted to the
year only. Against the live query service the new query takes 23 s and dates
16 more wrecks while every date the old one gave is unchanged.
parseYear took the minus sign of -0299 as a separator, so a wreck from 300 BC
showed as year 300, sat at AD 300 in the period picker and stretched its
range. Years before AD 100 now keep their year as text ("300 BC", "AD 50")
and count as ancient, like EMODnet's period-dated wrecks; the query service's
XSD 1.1 years (0000 is 1 BC) are converted. Merging records now carries that
text with the date, and coarser-than-year precisions give no date.
The exclusion tested the provenance after it was cut to 80 characters, so a
long source list ending in wrecksite.eu kept the row, and a row whose only
trace was a wrecksite.eu page link was kept too. Both raw values are now
checked before anything is cut.
When the whole feed backs off, no poll counts a miss, so the tracked
aircraft read STALE at full brightness while no newer position came in.
It now takes the same stale fade as a missed update, in the flights and
military layers.
The route check allowed 200 km off the great circle between the airports, so a
coast-to-coast flight routed a few hundred kilometres around weather lost its
origin and destination (JFK–SFO over Kansas, 384 km south). The tolerance is
now 200 km or 15% of the route's length, whichever is larger: 623 km for
JFK–SFO, and still 200 km for a short hop, so a wrong leg stays hidden.
The trail no longer joins a day of history into one line. It lifts the pen
across a gap of more than 48 minutes, an implied speed over 1,500 kt, or a
report without altitude (a parked aircraft within 0.1 nm for under 3 h stays
joined), and every history point is kept as its own segment. History never
gets an invented altitude. The live end is the path the aircraft was drawn
along, thinned to its shape, so it no longer cuts corners through turns; a
late report trims what was drawn after it. Old segments are frozen in chunks,
so a 2,000-point trail costs about 0.1 ms a frame.
A tracked aircraft that misses an update shows STALE and is dimmed. It keeps
flying on its last speed and heading for five minutes (at most 1,500 kt),
then stops, dimmed, labelled SIGNAL LOST with the time since its last report,
and is kept for ten minutes after that report so the camera keeps its target.
Aircraft on or near known ground hold at their last report instead of
coasting. Military flights follow the same rules.
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 catalog source 'NASA FIRMS · LIVE' still led the row; getStats() now
names the source 'NASA FIRMS' for such a snapshot. get_active_fires says
"in the 24 hours to" its end and reports window_end. The end is checked
to be a printable time, cleared under KEY REQUIRED, the test moves next
to the layer, and the changelog and CURRENT-STATE describe it.
A FIRMS source may answer the 24 hours to a set time, naming its end as
`at` (epoch ms). The layer row then reads "24 h to MM-DD HH:MM UTC"
instead of "LIVE · updated ...", and getStats() reports `at`. A
snapshot without `at` (the trailing 24 hours to now, as the dev proxy
serves) keeps the LIVE label. Translated in every catalog.
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.
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.
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.