Commit Graph
258 Commits
Author SHA1 Message Date
Sameh Khamis 619c19ea67 Application extras come from the renderer plugin; framing, occlusion and panel drawing are contract ports
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.
2026-11-10 21:17:56 -08:00
Sameh Khamis a755f63638 Merge origin/main: shipwrecks, news, transit fronts, signal-lost trails and uncredited photos on the renderer's ports
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.
2026-11-10 20:03:28 -08:00
Sameh Khamis 6a6967d1ad Place the credits line where Cesium's is, and draw a logo in place of its text
- 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.
2026-11-10 18:48:26 -08:00
Sameh Khamis 241c8dde64 Write a line that moves by as many points into the points it draws
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.
2026-11-10 18:29:56 -08:00
Sameh Khamis 9743993f8e Measure a pose's heading, pitch and roll in one east-north-up frame
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.
2026-11-10 18:29:56 -08:00
Sameh Khamis a896d886a2 Tell a frame that owes the credits the last one owed without listing them
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.
2026-11-10 18:29:56 -08:00
Sameh Khamis 16c7034c28 Show the renderer's credits in the application's own line
- 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.
2026-11-10 18:29:47 -08:00
Sameh Khamis 1fbe546531 Follow through the camera port in the remaining tests
- 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.
2026-11-10 18:10:14 -08:00
Sameh Khamis 9a13aeab48 A photoreal base that fails to come back keeps the stack before it
- 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.
2026-11-10 18:10:07 -08:00
Sameh Khamis ae4fbb5053 Load the default renderer as the page starts, and follow through the camera port in tests
- 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.
2026-11-10 17:44:29 -08:00
Sameh Khamis 6daf63d90c Start the application through the contract, not on the Cesium viewer
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.
2026-11-10 17:18:48 -08:00
Sameh Khamis a72d4c3b1f Follow, drape and read the camera through the ports, not the viewer
- 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.
2026-11-10 17:18:10 -08:00
Sameh Khamis ebbe006924 Reach the canvas through canvasOf, not the viewer
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.
2026-11-10 17:18:10 -08:00
Sameh Khamis 0a0645e28e Answer an unmoved camera's pose from the last read
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.
2026-11-10 14:50:57 -08:00
Sameh Khamis 4972aac345 Read a material's held texture through internals.js, pinned to Cesium's Material
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.
2026-11-10 09:50:22 -08:00
Sameh Khamis f1817756ed Read conformance pixels where they are drawn, and skip them only by the harness
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.
2026-11-10 09:46:12 -08:00
Sameh Khamis d5e3968caa Draw outlined draped lines with their outline; relay pinches for an early Ctrl+wheel
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.
2026-11-10 09:46:11 -08:00
Sameh Khamis 8ca657e63f Run camera.setView.exact on the Cesium renderer in the conformance page 2026-11-10 09:46:11 -08:00
Sameh Khamis c56ff090e6 Destroy an image fill's texture its material never took
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.
2026-11-10 09:46:03 -08:00
Sameh Khamis f834903950 Place the stub's camera exactly from a direction and up
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.
2026-11-10 09:45:49 -08:00
Sameh Khamis 3f194d0eec Check that a raster shell draws its image, not only that it says so
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.
2026-11-10 09:23:43 -08:00
Sameh Khamis 72a322f7ce Record Cesium references for the quad, mesh and field scenes
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.
2026-11-10 09:07:51 -08:00
Sameh Khamis 46d44eed89 Draw a one pixel wide raster shell image
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.
2026-11-10 09:07:51 -08:00
Sameh Khamis 149f8aad4d Settle a line outline's width as the whole outline, half on each side
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.
2026-11-10 08:59:36 -08:00
Sameh Khamis e4af6c8ed7 Cut the range ring's frame cost while the camera moves
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.
2026-11-10 07:59:23 -08:00
Sameh Khamis 74d6d97b29 Draw the Global Context range ring and its pulses through the draw port
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.
2026-11-10 07:48:07 -08:00
Sameh Khamis c8346c9fda Keep shape radii, rim gradients, depth-fail looks, sweep cadence and step camera moves out of the renderer contract
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.
2026-11-10 04:08:41 -08:00
Sameh Khamis 7a376ebefc Make quality settings detail only and fold ctrl-wheel zoom into the camera's zoom inputs
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.
2026-11-10 03:35:35 -08:00
Sameh Khamis 46cdeba7fa Remove renderer contract members nothing in the application uses
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.
2026-11-10 03:27:10 -08:00
Sameh Khamis 71f2f12f75 Re-record the city scene's references with colour fills shaded as entities shade them
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.
2026-11-10 03:23:24 -08:00
Sameh Khamis 40a0dce951 Pre-load orbital imagery ahead from the Cesium renderer
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.
2026-11-10 01:46:41 -08:00
Sameh Khamis 2b60531c3c Merge main through #1634 into the renderer seam
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.
2026-11-10 00:31:23 -08:00
Sameh Khamis 020a433b51 Merge main through #1591 into the renderer seam
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.
2026-11-09 23:06:26 -08:00
Sameh Khamis 96764f85ca Merge main through #1532 into the renderer seam
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.
2026-11-09 21:34:03 -08:00
Sameh Khamis 823b5dc301 Merge main through #1556 into the renderer seam
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.
2026-11-09 20:52:52 -08:00
Sameh Khamis b9f8ac1ff0 Merge main through #1319 into the renderer seam
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.
2026-11-09 19:59:26 -08:00
Sameh Khamis fd42fc0afd Merge main through #1495 into the renderer seam
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.
2026-11-09 18:51:30 -08:00
Sameh Khamis 6c1f91014c Draw imported files through the draw port, off Cesium
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.
2026-11-09 15:50:53 -08:00
Sameh Khamis c073064507 Stack sprite layers by draw order, flights on top
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.
2026-11-09 14:32:50 -08:00
Sameh Khamis 4c587a6d0f Application scene and conformance page leave the Cesium allow-list
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.
2026-11-09 12:58:45 -08:00
Sameh Khamis 26665e8390 Embed views and the application shell leave the Cesium 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.
2026-11-09 12:43:36 -08:00
Sameh Khamis e6d9ec0636 Starry sky and the application viewer move into the Cesium adapter
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.
2026-11-09 12:31:46 -08:00
Sameh Khamis a8a9cc73a4 Map stacks off the Cesium allow-list: providers move into the Cesium adapter
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.
2026-11-09 12:11:42 -08:00
Sameh Khamis aea5c3acc6 Merge branch 'sameh/renderer-annotations' into sameh/renderer-seam 2026-11-09 11:35:31 -08:00
Sameh Khamis d9e72dfc8b World annotation renderer draws through the renderer's ports
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.
2026-11-09 10:34:53 -08:00
Sameh Khamis 6b4b04d082 Cesium draw port builds colour fills with the vertex format their appearance reads
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.
2026-11-09 10:27:20 -08:00
Sameh Khamis 2c68fc0248 Conformance: the atlas check makes its canvas slot only where a 2D context exists, not wherever there is a document 2026-11-09 10:21:48 -08:00
Sameh Khamis c148e2888f Cesium draw port pulses shape alpha and recolours shapes in place
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.
2026-11-09 09:50:30 -08:00
Sameh Khamis 1d813a8055 Cesium draw port drapes arrows, draws ellipse radii by camera height and classifies volumes
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.
2026-11-09 09:23:04 -08:00
Sameh Khamis 2a26d13fff render: wind relief is the globe port's hillshade; the wind layer no longer reaches Cesium
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.
2026-11-09 08:13:04 -08:00