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.
Applying the rest of a posted view after the camera was taken during its
terrain wait still let it change the camera: stop_tracking dropped a follow
the user had just started, and annotate_map framed the view's marks. A
camera taken during the wait now ends the view again, as before. The 2 s
terrain timeout and the per-view catch on the queue stay.
- The look-at longitude wraps fully, so a tilted camera at a pole gives a
point on the globe. The strict off-globe check on street_level is undone:
points are clamped again, as before.
- A posted view that fails is answered, and the views behind it still apply.
- A posted view waits at most 2 s for the terrain under its camera, then
keeps its own estimate.
- A camera taken during that wait stays where it is: the rest of the view
applies, and only its photos stand down.
- show_street_level keeps a search or a press on the globe made during its
own flight: it adopts only its own navigation stamps on landing, and a
gesture is never forgiven.
Main added a Swedish catalog in #1630, so the catalog test failed on the
strings this PR adds. They use the catalog's terms (Gatunivå, nyckel,
bilder på gatunivå, vyns mitt).
- Releasing a held viewer frees the old source's adapter without resetting
the panel, so a replacement's error, outcome and armed OPEN survive; a
cross-source replacement drops the old photo's details and marker.
- The action holds the open photo only for its own switch-off: a source
switched by hand during the load stops it and reports cancelled.
- A posted view waiting on terrain watches the camera and stands down after a
navigation or a globe press; a flat or straight-down camera asks no terrain.
- An arming link opens the panel without persisting the layout, and a posted
view's street-level step runs as programmatic.
- An off-globe street_level point throws TypeError.
- zh-Hant uses the file's wording for the new strings; README and
CURRENT-STATE count 35 tools.
Translate the 148 strings main added since (mostly the News layer) and
prune the 5 it no longer uses; keep both Hebrew and Swedish in the
language lists.
- SECURITY.md: OPEN also takes the link's point when the screen centre
cannot be picked at all.
- TOOLS.md: the panel's own link opens Street View only for a result issued
in the last five minutes; an older one only arms.
- Changelog: the hiding modes stop a request, collapsing the panel does not;
failure cards are in the interface language.
- CURRENT-STATE: a posted view without a point grounds its look-at too.
show_in_gods_eye_view measured a view's altitude from the terrain before
taking the point the camera looks at; a view posted straight into the
embedded app used the ellipsoid altitude, so a camera over high ground
opened photos kilometres ahead. groundedLookAt moves to the view module,
and the embedded app uses it with the app's terrain heights for a posted
street_level that names no point.
A provider that threw while geocoding (offline, an upstream down) escaped
the action as a bare error. show_street_level now reports it as its
location stage ("Could not arrive at …", the cause in detail), and nothing
is switched or looked up; fly_to_location itself is unchanged.
The voice card showed English for show_street_level failures the catalog
did not know: a missing key, a map or source that could not be switched on,
the layer, invalid coordinates, an imagery fallback and the filter clause.
They now translate like the other action errors (exact messages and
patterns in speech.js), in all twelve languages; the spoken line stays
English, and the filter clause names the filters as their chips do.
- The cloud brightness key is a filter, not a brightness scale.
- Counted lines without a plural form read "label: count", so 1 agrees.
- Fire confidence is «tillförlitlighet», not «säkerhet».
- Agreement with «flöde» and «luftfartyg»; course on the tracking line is
«FÄRDRIKTNING», which fits both aircraft and ships.
- Wildlife is «Artobservationer», since the layer also shows plants and fungi.
- Bridge readouts are nouns (BLICK, ÖGONHÖJD), cockpit key hints share one
verb form, tool names in pointer messages are quoted, and «jfr» replaces
«jmf.»; the guide's example follows.
- Smaller wording and consistency fixes across the catalog.
GDELT exports are read in parallel, so two reports with the same time
arrived in whichever order their exports finished, and the feed test that
pages through them failed now and then. Same-time reports now order by
most mentions, then by id.
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.
A weather feed may also be a frame source. With an optional
getFrameImage({ product, time, size, bbox, signal }) the layers take
whole-extent images, detail windows and the global mosaic from it; with an
optional getFrameTile({ product, time, z, x, y, size, signal }) regional
tiles and their prefetch come from it, null being a transparent tile. Pixels
may be an ImageBitmap, ImageData, canvas or VideoFrame of exactly the
requested size; the layer draws them once and closes them. Cancellation
reaches the source, and a feed without these methods reads the image and
tile routes as before.
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.