Commit Graph
3738 Commits
Author SHA1 Message Date
Sameh Khamis 1bff078097 Draw the installations layer through the renderer ports
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.
2026-11-08 12:13:29 -08:00
Sameh Khamis 481df0b093 Merge branch 'sameh/renderer-leftovers' into sameh/renderer-seam
# Conflicts:
#	src/render/cesium/draw.test.mjs
#	src/render/cesiumAllowList.json
2026-11-08 12:00:30 -08:00
Sameh Khamis dabdab47d6 Draw S2 GhostMaps through the renderer draw port, off Cesium
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.
2026-11-08 11:54:43 -08:00
Sameh Khamis 4a9b1389ba Draw rocket launches through the renderer ports, off Cesium
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.
2026-11-08 11:26:21 -08:00
Sameh Khamis a59f9b10b2 Draw Radio stations and their clusters through the draw port and take the Radio renderer off the Cesium list
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.
2026-11-08 11:11:50 -08:00
Sameh Khamis b2502d6f37 Draw FIRMS fire glows through the draw port and take the FIRMS renderer off the Cesium list
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.
2026-11-08 10:29:40 -08:00
Sameh Khamis 3fa1ad0283 Merge branch 'sameh/renderer-cctv' into sameh/renderer-seam 2026-11-08 09:45:47 -08:00
Sameh Khamis 5c05f9befe Wait for both ends of the unturned draped fill in the rotation check
A draped fill can reach the pick pass tile by tile, so the far end of the
wide rectangle was sometimes not pickable yet in the frame the centre was.
2026-11-08 09:45:47 -08:00
Sameh Khamis 1d08043bf9 Draw CCTV camera icons through the renderer ports and take rendering.js off the Cesium list
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.
2026-11-08 09:38:24 -08:00
Sameh Khamis 2a607ec4d8 Draw CCTV coverage, viewsheds and the monitor plane through the renderer ports and take projection.js off the Cesium list
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.
2026-11-08 08:35:12 -08:00
Sameh Khamis bbad02b73e Draw the CCTV calibration gizmo through the renderer ports and take it off the Cesium list
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.
2026-11-08 07:55:30 -08:00
Sameh Khamis 393f1686f2 Draw quads and meshes through the Cesium draw port
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.
2026-11-08 07:23:54 -08:00
Sameh Khamis fa762f808e Paint detection from the overlay host's camera, off Cesium
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.
2026-11-08 06:06:06 -08:00
Sameh Khamis d0ca460313 Publish the tracked satellite's focus through the renderer ports
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.
2026-11-08 05:56:09 -08:00
Sameh Khamis b6e94b8d93 Move the scene-reading icon orientation helpers into the Cesium adapter
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.
2026-11-08 05:49:05 -08:00
Sameh Khamis d8d6db4389 Keep icon sets and their motion segments off the renderer
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.
2026-11-08 05:33:20 -08:00
Sameh Khamis 09f2b88bf9 Move the instanced icon set primitive into the Cesium adapter
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.
2026-11-08 05:19:53 -08:00
Sameh Khamis f65df05b62 Merge branch 'sameh/renderer-track' into sameh/renderer-seam 2026-11-08 05:02:53 -08:00
Sameh Khamis 2875063c38 Prove draw-tool click ownership through the context store and steady the hidden-Line pixel check
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.
2026-11-08 04:40:30 -08:00
Sameh Khamis f33767c054 Drive the traffic baseline capture through rendered camera moves and count road requests
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.
2026-11-08 01:55:08 -08:00
Sameh Khamis fe79eb840e Read tracking invariants through the follow service, draw-port sets and layer records
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.
2026-11-08 00:51:37 -08:00
Sameh Khamis 17364d1eee Settle unchanging solid lines into static batches in the Cesium draw port
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.
2026-11-08 00:40:29 -08:00
Sameh Khamis abef2800fb Follow a local GeoJSON feature on double-click through the camera port
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.
2026-11-07 23:47:04 -08:00
Sameh Khamis c5fffae09e Stamp a GeoJSON point's marker-symbol on its pin again
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.
2026-11-07 23:47:04 -08:00
Sameh Khamis 0d9b96badf Hide the sets a height sample sees through for that sample
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.
2026-11-07 23:47:04 -08:00
Sameh Khamis 0584707436 Outline a raised polygon's holes as well as its outer ring
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.
2026-11-07 23:47:04 -08:00
Sameh Khamis 85d4f4840c Read CSS colour names as the default renderer reads them
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.
2026-11-07 23:47:04 -08:00
Sameh Khamis 38e0750715 Animate traffic on the frame port and follow the camera through the camera port
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.
2026-11-07 23:16:11 -08:00
Sameh Khamis 5715bf9df3 Draw the traffic heat-lines through the draw port, batching alike draped glow lines in the Cesium draw port 2026-11-07 23:16:11 -08:00
Sameh Khamis bbd6049e21 Draw the traffic dots through the draw port and read the road surface through renderer ports
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.
2026-11-07 23:16:11 -08:00
Sameh Khamis d9db5199ed Add and remove points in place, set only what changed, and recolour material lines in place in the Cesium draw port
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.
2026-11-07 23:16:11 -08:00
Itallo BrandãoandClaude Opus 5.5 e631839a4e fix(transit): quote Halifax's Open Government Licence
The licence page refuses automated requests; its text was read in a browser.
Credit now uses the licence's own attribution statement.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-11-08 03:08:40 -03:00
Itallo Brandão 543c607b23 Merge remote-tracking branch 'origin/main' into feat/transit-more-cities 2026-11-08 02:57:49 -03:00
Itallo BrandãoandClaude Opus 5.5 923287eb92 chore(changelog): name the transit fragment after PR #1628
Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-11-08 02:56:19 -03:00
Itallo BrandãoandClaude Opus 5.5 71b694ab62 feat(transit): add 32 more keyless cities across Europe, Asia, Oceania and North America
Prague, Warsaw, Kraków (buses and trams), Poznań, Gdańsk, Rzeszów, Vilnius,
Bucharest, Cluj-Napoca, Iași, Rome, Turin, Venice (buses and waterbuses),
Bordeaux, Montpellier, Rouen, Toulon, Le Havre, Tours, Málaga, Lisbon's city
Carris, Sendai, Johor Bahru, Kota Bharu, Adelaide, Atlanta, Denver, Edmonton,
Halifax and Victoria.

Each entry records its licence, or that none is stated and the Metro
Transit/OVapi basis it ships on. Montpellier and Toulon publish km/h and are
converted. Route ids are read as the rider-facing line; Prague, Bordeaux and
Le Havre trams and Venice waterbuses take their own mode. Adelaide needs
`Accept: */*` to get binary protobuf. Every feed was fetched through the dev
proxy on 2026-11-08.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-11-08 02:50:32 -03:00
Sameh Khamis 6286bcfb07 Turn draped rectangles by an optional rotation, and drape image fills in the Cesium port
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.
2026-11-07 21:49:34 -08:00
Sameh Khamis 7ad65b2e87 Dash a line's parts behind the surface, and the Draw tool's rubber band there
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).
2026-11-07 21:49:25 -08:00
Sameh Khamis 90e73f2ef2 Read the eye's follow frame through the camera port and take share-follow off the Cesium list
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.
2026-11-07 21:49:25 -08:00
Sameh Khamis b0ed9d7e90 Draw the local GeoJSON layers through the draw port and take them off the Cesium list
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.
2026-11-07 21:49:15 -08:00
Sameh Khamis 333c9b39fe Keep the draw port's version when icons only change in place
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.
2026-11-07 20:25:15 -08:00
Sameh Khamis 6861632b96 Lower the viewer-access record for the files the globe visibility getter cleared 2026-11-07 19:48:54 -08:00
Sameh Khamis 5370feb825 Report model load failures to model sets, and bound the tracked model's retries again
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.
2026-11-07 19:44:15 -08:00
Sameh Khamis 396e7f0deb Ratchet Cesium-shaped viewer access in files off the Cesium list
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.
2026-11-07 19:44:15 -08:00
Sameh Khamis 0f9bd23829 Change a clamped fill's show in place in the Cesium draw port
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.
2026-11-07 19:44:15 -08:00
Sameh Khamis 2e91579f8f Add a globe visibility getter to the renderer contract
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.
2026-11-07 19:44:15 -08:00
Sameh Khamis 23d56f8393 Move the flights and military layers onto the renderer ports
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.
2026-11-07 18:49:23 -08:00
Sameh Khamis 00a0a0dbc7 Move aircraft motion's Julian-date math off Cesium
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.
2026-11-07 18:49:23 -08:00
Sameh Khamis 1f1d08f34e Move the click's ground pick into the input dispatcher and weather's default host into its shell rendering
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.
2026-11-07 18:10:39 -08:00
Sameh Khamis 81d8e3a4a7 Move geo import, voice capture, visual settings, scope mask and recent imagery onto the renderer ports
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.
2026-11-07 18:10:39 -08:00
Sameh Khamis b19fa56565 Read the canvas from the renderer in the layers, voice and tools
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.
2026-11-07 18:10:39 -08:00