Commit Graph
558 Commits
Author SHA1 Message Date
Sameh Khamis 4fd1a850f1 Keep the satellites layer's Cesium objects in its rendering part
The point collection and its dots, the baked orbit rings, the tracked
entity, the frame number, the focus publish and the pick decoding now
live in rendering.js, behind small helpers that take ECEF positions and
render-contract colours. The catalog, controls, ingestion, lifecycle,
orbits, policy, records, state, testing and tracking parts no longer
import Cesium or touch the viewer, scene or primitives, and leave the
allow-list. Point styles are [r, g, b, a] colours, converted once per
style; geodetic conversions use the geo helpers; the per-frame tick runs
through the frame port. What the layer draws and how it follows is
unchanged.
2026-11-07 03:53:05 -08:00
Sameh Khamis a2c4d27b5a Read the navigation and point-and-ask camera through the renderer's ports
The navigation controller and the location navigation cancel flights and
read the camera's place through the camera port. Point-and-ask's camera
pose key and its "around here" radius read the camera port's pose; its
entity pick moves into the input dispatcher (pickAt), which picks as a
click does, so the follow's helper still reads as its target.

navigationController, locationNavigation and pointerPick leave the Cesium
allow-list. Their package entries (./ui/navigation and three voice
entries) no longer load the Cesium adapter: given a viewer of a
caller's own, they find its camera once the caller loads
./render/cesium/unbound. They are listed as such in the unbound camera
test, which fails if one starts loading the factory again.
2026-11-07 03:11:51 -08:00
Sameh Khamis ad56ede30d Own the shared icon motion evaluator in the ghost maps package
Ghost maps reaches the draw port's GPU icon code, which now evaluates
motion through the shared Cesium-free evaluator; list it as the
package's own.
2026-11-07 02:45:10 -08:00
Sameh Khamis 1c8cf240c4 Tidy the vessels layer on the draw port: shared pose key, lazy pose, frame reasons, sprite order
The camera pose key moves to render/camera/poseSignature.js, Cesium-free, and
iconOrientation's cameraPoseSignature builds the same key through it. The
vessels frame hook reads the pose only when a pass runs or a moved camera
could still need its trailing pass, and the unused focus scratch point goes.

The draw port takes the frame port's requestRender, so a GPU icon set's own
frames (its images packed into the atlas) are asked for under the reason
icons:<set id> in the frame diagnostics, where the vessels layer's own
ais-vessels-icons reason used to be. Other draw requests are unchanged.

A host with no registerSpriteSet still draws the ships and warns once. The
vessels draw test now checks the sprite order finds the set's host, and that
a torn-down layer draws a new set registered in the old one's place. The new
motion, icon book and pose key tests join the format check.
2026-11-07 02:36:39 -08:00
Sameh Khamis e72382b1aa Keep each drawn icon's expiry in a shared icon book, for replanning
render/motion/iconBook holds the icon items a layer drew to a draw set, as
the vessels' book did, and now also when each one's motion stops being what
the layer would plan: put(item, {expiresAt}) records it (Infinity: planned,
never due; null drops it; a restyle keeps it), and due(t) lists the ones to
plan afresh. It reads a moving icon's position and course at a time through
the shared evaluator, as the renderer draws it given its capabilities. An
item easing its course by courseBlendMs reads its target course.

This is what a layer with dead-reckoned contacts keeps on the CPU in place
of the GPU set's own row expiry. The vessels' icon book is now this one.
2026-11-07 02:36:39 -08:00
Sameh Khamis 0349941b71 Read a moving icon's position and course through one shared evaluator
render/motion/iconMotion evaluates a draw item's motion segment and course
glide at a time on the set's motion clock, without a renderer: where the
item is drawn, the course it is drawn with, and when its motion ends. The app
can now read a moving icon back (to follow it, label it, judge a pick or
its horizon) the way the renderer draws it.

The stub renderer evaluates its segments with it, in place of its own copy,
and so now steps a lerp with no span 1 ms after t0, as the Cesium renderer
does. The Cesium GPU icon sets read the course shown before a write, a
blend's target and when rows stop moving through it, from copies of what
they wrote, and write each glide with the offset it computes, so an exact
half turn goes the way the app reads it.

norm360/norm180 and Position-to-ECEF move to geo for both to share.
Conformance gains a check that icons are drawn where the evaluator puts
them.
2026-11-07 02:36:39 -08:00
Sameh Khamis 2061f5647c Draw the air quality stations through the renderer's draw port
The station discs are now one draw set of ground-clamped filled ellipses per
layer, with the same band colours, alpha and radius, and their readings as
item meta; they had no visible outline before either (Cesium turns outlines
off on clamped entity ellipses). The readout's in-view list reads the view
rectangle through the camera port. The layer no longer imports Cesium and
leaves the allow-list; a caller handing it a Cesium viewer of their own,
with no renderer bound, loads the ./render/cesium/unbound export once first.

Double-clicking a station no longer starts the viewer's entity follow, since
draw items are not entities.
2026-11-07 01:50:52 -08:00
Sameh Khamis 03ff8f291f Read the wind layer's map-centre reading and its marker through the query and frame ports
The wind reading at the map centre now asks the renderer's query port where
the ellipsoid lies under the middle of the canvas and converts it with the app's
WGS84 helpers, instead of Cesium's camera pick and Cartographic. The
inspection marker projects its point with the query port, hides it beyond
the ellipsoid's horizon with isOccluded, and follows rendered frames through
the frame port's postRender phase instead of the scene's event. The layer
entry no longer carries a Cesium namespace: the rendering part, which stays
Cesium-bound, defaults it, owns the fallback globe imagery host, and loads
the adapter factories a viewer with no renderer bound gets its ports from.

The wind entry, its inspection reading and its marker leave the allow-list.
They still read the viewer's canvas size and container element.
2026-11-07 01:50:42 -08:00
Sameh Khamis f0e5540561 Own the GPU icon modules in the ghost maps package
Ghost maps now loads the camera factory, which reaches the draw port and
its GPU icon set modules; list them as the package's own.
2026-11-07 01:50:42 -08:00
Sameh Khamis 7e07927660 Draw Street Level's coverage lines through the renderer's draw port
The coverage lines are draped line sets on the draw port now, not
ground polyline primitives of the layer's own. A tile draws in sets of
120 line parts, as its primitives were batched; each part is an item of
its own (its id made unique in the tile) that picks its sequence
(`meta.pick`). A filter change redraws the sets in place, so the old
lines show until the new ones are ready. The selected sequence is one
set over the coverage, redrawn in place as tiles land; the tiles hide
their own lines of it, a show change made in place, so it shows
whichever set is drawn over which. The wait for the terrain-height
table goes: the renderer builds draped lines when it is ready. A colour
the layer cannot read is handed to the renderer as given.

Clicks no longer read the renderer's pick. The click dispatcher's event
gains `windowHit(width, height)`, the wider pick read as the canonical
id, the draw-set hit and whether it is the map itself. Street Level
routes its own sets' hits by their pick, anything else (a provider's own
drawing) by its id, as before; the ground under a click comes from the
event, and the ground click is told whether the map was hit. The screen
centre is aimed through the query port, a pick that fails counting as a
miss. Street Level no longer reads the scenePick service.

The Cesium draw port no longer lets a show queued while a draped line
built override one applied once it was ready, before the swap: the
highlight hand-over now depends on that.

lineCoverage leaves the Cesium allow-list; with it every Street Level
file named in this work is off the list.

Differences the contract does not let us avoid:
- The lines draw among the scene's primitives, not its ground
  primitives: they now draw over other layers' clamped entities and
  ground primitives, and win picks against them.
- The highlight builds asynchronously: a newly selected line is not
  drawn for the frames that takes.
- Lines of other sequences in tiles that land after the highlight was
  first drawn cross over it.
2026-11-07 01:40:32 -08:00
Sameh Khamis a10f3a16e1 Read Street Level's camera and ground through the renderer's ports
The Street Level view maths no longer reads Cesium. The camera's place
comes from the camera port's pose; the visible box and the view focus
cast the query port's screen rays and meet them with the ground, the
WGS84 ellipsoid raised to the ground height, in geo; heights come from
the query port; the horizon cull for the marker and the cones tests
against an ellipsoid 1,000 m below WGS84 in geo and re-culls on the
frame port's pre-render. Ground clicks, the screen-centre aim, the
nearest-image point, photo framing, the coverage refresh and the ground
re-measure read the same ports and convert positions with geo.

geo's ellipsoid functions (toLonLatH, rayEllipsoid and those under them)
and horizonFrom take an optional ellipsoid, made with ellipsoidOf or
offsetEllipsoid; anything else, a map index included, means WGS84. Tests
check them against Cesium on raised and lowered ellipsoids.

view, index, cameraFraming, groundClick and selection leave the Cesium
allow-list. The Street Level entries are Cesium-free callers of the
unbound factories: given a viewer of a caller's own, with no renderer
bound, the caller loads ./render/cesium/unbound first. GhostMaps, which
uses the horizon cull and is still on the list, loads the camera factory
itself.

Differences the contract does not let us avoid:
- The ground under the camera no longer reads whether the globe is shown
  (the globe port has no visibility getter). Where 3D tiles answer under
  the camera they decide, as they did under Google 3D; elsewhere the
  terrain answers, then the drawn surface below the camera. Over 3D tiles
  shown on a map with the globe (and under other primitives at the
  nadir) those now count as ground.
- Without depth-texture support the query port answers no heights, the
  terrain included, so the ground then reads as the ellipsoid.
- selection and groundClick still read the click dispatcher's own pick
  for now; they move to draw-set hits with the coverage lines.
2026-11-07 01:40:32 -08:00
Sameh Khamis 9857ff1024 Own the GPU icon modules in the traffic package
The traffic package reaches the Cesium draw port, which now loads the
GPU icon set modules; list them as the package's own.
2026-11-07 00:45:08 -08:00
Sameh Khamis f6422d2247 Draw the vessels layer's ships through the renderer's ports
The ships are one icon set from the draw port, held on course with hold
motion segments and drawn over depth as before; the layer keeps what it last
drew in an icon book and reads focus and pick ownership back from there,
matching clicks on the draw hit's set and id. Its frame hook, camera pose,
horizon test and screen projection come from the frame, camera and query
ports, with the horizon lift in geo/horizon judging the same point the GPU
cull does. The icons' draw set is disposed when the layer is destroyed.

rendering.js no longer imports Cesium or touches the scene's primitives,
picks, render events or camera, and leaves the Cesium allow-list. It still
reads the canvas size for the label budget. Callers of the vessels entry
load the Cesium adapter's unbound fallbacks.
2026-11-07 00:38:20 -08:00
Sameh Khamis bb85e0fa74 Draw moving icon sets on the GPU through the Cesium draw port
An icon set whose items move along motion segments, glide their course,
recede toward the limb, pick through a larger proxy or switch images by
drawn size, or that takes columns, now draws as one instanced
IconSetPrimitive in place of its billboards. The set switches the first time
an item needs it (or columns arrive) and stays switched; a course blend
alone switches it only when everything it holds can go. The Cesium ports
advertise columns, motionSegments and courseGlide.

GPU sets refuse loudly what billboards draw and they do not: clamped
heights, fadeByDistance, displayRange, offsets, anchors other than the
centre, axis and screen rotations, opaque and additive blends, images other
than URLs and SVG, and more images than the shared atlas has room for. A
refused write changes nothing.

The shared icon columns gain an image switch size, a pick proxy and a
per-row depth-test distance (defaulting to always over depth, as before),
arcs gain a climb rate, and the epoch rebases in both directions. Rows keep
asking for frames while they move, turn or blend; a write that moves a row
as it already moves (a restyle, a focus change) leaves its segment alone.
Billboard icons now fade with focus as GPU ones do.

Conformance gains columns and motion checks for the Cesium adapter.
2026-11-07 00:38:20 -08:00
Sameh Khamis a8cf63999b Read the street traffic viewport through the camera and query ports
The traffic layer's camera altitude, view bounds and fetch centre come from
the renderer's camera port (its pose and view rectangle), and the reticle
footprint samples the ground with the query port's ellipsoid picks and
rays instead of the camera's own. The footprint's nadir is the pose
position in geodetic radians, as the camera's own cartographic position
was. A pixel the renderer has no ray for (a canvas of no size) samples no
direction, as the unset scratch ray did. The lifecycle part loads the
default renderer's camera factory, so a viewer of a caller's own gets
both ports.

Footprint and viewport leave the allow-list.
2026-11-07 00:09:10 -08:00
Sameh Khamis 10db177251 Compute street traffic roads, colours and state without Cesium
Road waypoints are plain ECEF points from the geo helpers (the same
formulas as before, so every waypoint and segment length is unchanged), and
the palette is renderer colours. The style part, still on the point
primitives, turns those into the points' colours once per colour and owns
the dot painting the model used to do itself; the rendering part converts
them for the heat lines. The animation keeps its own lerp scratch, and the
ingestion's centre height asks with plain degrees.

Ingestion, model, policy, state and timing leave the allow-list.
2026-11-07 00:09:10 -08:00
Sameh Khamis 7d760d32fc Take the camera layer's policy, state, model and ground off Cesium
The layer's colours are renderer colours; the parts that still draw with
Cesium (icons, coverage lines, the monitor plane) turn them into Cesium
colours with the adapter's own conversion. The screen and matrix scratches
are plain objects, which is all the projections that fill them write.

The model part converts angles with geo/vector, reads where the eye is
from the camera port's pose, and builds the monitor plane's orientation
with geo/quaternion from the same axes; the projection part hands the
entity a Cesium quaternion of it. The photoreal tileset readiness check,
which looks through the scene's primitives, moves to the geometry part.
The ground pass moves a camera icon by writing geo/ellipsoid's position
into the record's own position object. The test plane's plain material
comes from the projection part, and the selection part only lost an
unused import.

All give the same numbers as the Cesium calls they replace. Policy,
state, selection, testing, model and ground leave the allow-list.
2026-11-06 23:47:08 -08:00
Sameh Khamis 2592289612 Draw the ALPR layer's markers through the renderer's ports
The ALPR badges were Cesium entities whose billboards the layer changed in
place: the canvas overlay swapped a badge to a faint pick target at its
anchor, selection swapped the image, and unresolved floors clamped to the
ground. They are now one icon set from the draw port, updated in place
through upsert, so selection and the overlay swap change the same
billboard without a rebuild or a blink. Badges keep their scale by
distance, ground clamping and depth-test settings.

Marker state lives in the app (markerState.js): a plain carrier per camera,
registered as the camera's context entity, and a marker set that batches
changes and sends only the icons that draw differently. Clicks on native
badges come from the dispatcher's draw hit. Projection, the on-screen
count, height samples (excluding the layer's own set), the screen-centre
ellipsoid pick and the camera reach the renderer through the query,
camera and frame ports. A resync of the overlay now hands back only the
cameras that leave it, so kept ones are not written twice.

index.js, overlay.js and presentation.js leave the Cesium allow-list; the
layer's entry is Cesium-free, and a caller's own viewer loads the
unbound factories.

Differences the contract does not let us avoid:
- Double-clicking a badge no longer starts the viewer's entity follow,
  since draw items are not entities.
- The terrain fallback for anchors is no longer skipped while the globe
  is hidden: the globe port has no visibility getter.
- Without depth support the query port answers no heights, terrain
  included, so anchors wait for a cached floor there.
- On a viewer with no renderer bound, the surface counts as settled
  when anchors are refined.
2026-11-06 23:28:43 -08:00
Sameh Khamis faded8a418 Draw the installations layer's named markers through the renderer's ports
The named-site dots are a draw-port point set with horizon culling instead
of a raw point collection; their on-screen count tests the ellipsoid
horizon and projects through the query port, and they follow the camera
port's changed and moveEnd events and the frame port's preRender. Points
that only change look (a selection) are restyled in place. Clicks on a dot
read the draw hit; the item id is not the bare record id, so sibling
layers' pick-owner checks still treat a dot click as nobody's.

Code that only asks whether a click hit anything (the CCTV layer) now sees
a dot click as a hit, as it already did for the site markers: a draw item's
pick always resolves to its id.

The named markers leave the Cesium allow-list. The site markers in
rendering.js stay entities.
2026-11-06 23:28:43 -08:00
Sameh Khamis 1c840cb66f Read the vessel view area and evidence through the camera and query ports
The area the vessel feed asks for comes from the camera port's pose and
the query port's ellipsoid pick at the middle of the screen, converted
with geo/ellipsoid, rather than from the Cesium camera; the development
evidence snapshot projects through the query port. Both answer as the
Cesium calls did. The rendering module, still on the Cesium allow-list,
loads the camera factory so a viewer of a caller's own still has both
ports. cameraArea and evidence leave the Cesium allow-list.
2026-11-06 23:02:09 -08:00
Sameh Khamis 0a81c2e197 Take the vessel layer's state and queries off Cesium
The focus pass's screen scratch is a plain { x, y } (Cesium only writes x
and y into it), and getNearby measures distance with geo/vector, which
gives the same result for Cartesian3s. Both files leave the Cesium
allow-list.
2026-11-06 23:02:09 -08:00
Sameh Khamis a2503476de Compute launch paths, cameras and colours without Cesium
The launches layer's path building, replay camera maths, policy constants,
state, marker colours and mission panel no longer import Cesium. Paths and
camera poses are plain ECEF points computed by the geo helpers with the
default renderer's own formulas in the same order, so trajectories, orbits
and camera framing land where they did. Geodesic interpolation moves from
the stub renderer into geo/geodesic (geodesicLine, solved once per
geodesic), and geo/sphere gains the renderer's sphere union.

Marker colours are renderer colours, with the panel's CSS from the same
palette. The rendering part, still Cesium for its entities, converts the
plain points where the entities take them, culls with the shared horizon
test, loads the unbound camera factory, and hands the panel the live
payload position directly instead of through the entity.

Camera, model, panel, paths, policy, policyHelpers and state leave the
allow-list.
2026-11-06 22:57:55 -08:00
Sameh Khamis 0782b073e2 Own the query and frame modules in the transit package
Transit's viewport loads the Cesium camera factory, which now loads the
unbound query and frame factories too.
2026-11-06 22:30:27 -08:00
Sameh Khamis 4ed51930c2 Give a viewer of its own a frame port, and use it for the active fires layer
findFrame and frameOf find the bound renderer's frame port or, for a
caller's viewer with no renderer bound, one the Cesium adapter's factory
builds over it, as findQuery and findDraw do. Unlike the renderer's own,
it leaves the viewer's loop as its owner set it up: it listens to the
scene's phases, asks for frames, holds by asking again after each one
drawn, and maps suspend, the target rate and scene time onto the viewer.
Its preUpdate says whether the tick draws by the same test the renderer's
frame port makes, now shared by both.

The active fires layer's cards and LOD watcher take their query and frame
ports from findQuery and findFrame, in place of the layer's own copy of
projection, occlusion and preRender over the viewer's scene.
2026-11-06 22:25:07 -08:00
Sameh Khamis 784561a6ae Give a viewer of its own a query port, as it has draw and camera ports
The Cesium query port moves out of createCesiumPorts into its own module,
unchanged, so it can also be built over a caller's viewer with no
renderer bound. findQuery and queryOf find the bound renderer's query port
or, for such a viewer, one the Cesium adapter's factory builds, as findDraw
and findCamera do. It picks the sets drawn through findDraw on that viewer
and its height samples see through them, so a layer can exclude its own
sets; it projects, casts rays and picks the ellipsoid as the renderer's
does. A renderer bound later answers new callers.

The camera factory and the caller's unbound export load it, and the
factory walk checks that every public entry reaching a findQuery or queryOf
caller loads it, or is a Cesium-free entry whose caller does.
2026-11-06 22:25:07 -08:00
Sameh Khamis 1d2b853576 Move the installations layer's camera, geometry and colours onto renderer ports
The layer's view rectangle, wide-view pose, flights and camera events now
go through the camera port, and its distance and position maths through
the geo helpers: getNearby confirms candidates with the ported
ellipsoidal geodesic, as before, and returns plain ECEF positions. Class
colours are renderer colours; the entities convert them. The layer's
camera `changed` listener has its own 0.01 threshold on the port, the
sensitivity it already claimed while on; the claim stays for other raw
camera listeners.

Controls, lifecycle, model, state and viewport no longer import Cesium
and leave the allow-list. Rendering and the named markers stay on
Cesium: the site markers are entities because the camera follows them
on double-click and the tracked card reads its title and position from
them, and the entity data source moves from lifecycle into rendering.
Rendering loads the unbound camera factory for the parts that reach the
port.

The test camera bound over a Cesium-shaped fake now answers its view
rectangle from the fake's computeViewRectangle when it has one.
2026-11-06 22:10:53 -08:00
Sameh Khamis e74c7c1f44 Draw submarine cables through the renderer's draw and camera ports
Cable lines, landing pins, polygon fills, reference stems and reference
points are now five draw sets per layer (submarine-cables:N:lines and so
on) instead of GeoJSON data sources and entities. Clicks resolve through
the draw hit; flights and the sweep's eye go through the camera port.
The layer keeps the styling the GeoJSON loader gave it: cable colours,
widths and alphas, simplestyle stroke, fill and marker properties, fills
that keep the source's alpha, raised polygons at their heights, the
default pin image, and features without a reference drawn but neither
picked nor culled. Lines are densified along rhumb lines at the
renderer's own granularity, so the draped geodesic arcs land on the same
vertices the rhumb-line polylines did.

Supporting pieces:
- geo/rhumb, geo/horizon and geo/geodesic port the default renderer's
  rhumb line, ellipsoidal occluder and Vincenty inverse; the stub
  renderer now uses the shared horizon test and Vincenty inverse
  instead of its own copies. render/color gains cssColor, which reads
  CSS colours as the renderer does (hex, rgb, hsl; not named colours).
- The Cesium draw port changes a line in place when only whether it
  shows changes (draped, on its ground primitive, waiting for it to be
  ready rather than restarting its build) or where an undraped line
  runs; anything else still rebuilds. Icon sets honour their blend.

Ingestion, interaction, overlay, policy, rendering, state and surface no
longer import Cesium and leave the allow-list. Pins are culled at the
horizon each frame by the draw port instead of on the sweep, and
marker-symbol glyphs are not drawn inside pins.
2026-11-06 22:10:53 -08:00
Sameh Khamis af449184ca Read transit's viewport from the camera port
Feed activation and the view bounds read the camera port's pose and view
rectangle instead of the Cesium camera; the look-at centre comes from
geo/rectangle, which crosses the antimeridian as Cesium's does. The layer's
lifecycle loads the Cesium camera factory, so a viewer of a caller's own
still has a camera to read. viewport leaves the Cesium allow-list.
2026-11-06 21:23:57 -08:00
Sameh Khamis 56d56a4d6d Take transit's state, trails and selection off Cesium
The per-frame scratch position is a plain object, and trail vertices come
from geo/ellipsoid's fromDegrees, which matches Cesium's to the bit; the
billboards and trail geometry they feed copy them as before. The pick
diagnostic names the picked marker's collection from its vehicle rather
than from Cesium's private field. state, trails and selection leave the
Cesium allow-list.
2026-11-06 21:23:57 -08:00
Sameh Khamis 6e23d2aac9 Move the active fires layer's cells, camera, cards and LOD onto renderer ports
Heat cells are clamped rectangle fills in one draw set per layer
(firms:N:cells) instead of entities. The LOD watcher follows the camera
port's pose, view rectangle and moveEnd and the frame port's preRender;
cards project and horizon-test through the query port. Colours, the view
change thresholds and the padded bounds are unchanged. On a viewer with
no renderer bound, the layer answers projection, occlusion and preRender
from the viewer's scene, as it did before.

Policy, model, state, viewport, cards and lifecycle no longer import
Cesium and leave the allow-list. Rendering keeps Cesium for the detection
icons, which stay on the shared icon-set primitive, and loads the unbound
camera and draw factories. Heat cells are no longer entities, so
double-clicking one no longer makes the camera follow its centre.
2026-11-06 20:30:33 -08:00
Sameh Khamis 6f82f9cc9c Draw GNSS integrity cells through the renderer's draw port
Cells are clamped rectangle fills in one draw set per layer
(gnss-integrity:N), made with pickable: false so they never hide what is
under them from clicks, as before. The view anchor comes from the camera
port: where the line of sight meets the ellipsoid, else the middle of the
view rectangle, else the point under the eye. Re-anchoring follows the
camera port's moveEnd and changed events. The ray-ellipsoid intersection
moves from the stub renderer into geo/ellipsoid.js for both to use, and
geo/rectangle.js adds the antimeridian-aware width, height and centre of
a radian rectangle. The layer leaves the allow-list; the QA script finds
the cells among the scene's unpickable ground primitives.
2026-11-06 20:30:33 -08:00
Sameh Khamis 3f9089eccb Draw wildfire perimeters through the renderer's draw port
Perimeter fills are clamped polygon fills with their holes, and fire
lines are draped lines along each outer ring, in two draw sets per layer
(fire-perimeters:N:fills and :lines). Clicks read the draw hit and match
the layer's own set and item ids. Colours, alphas, widths and clamping
are unchanged. The layer no longer imports Cesium, so it leaves the
allow-list and joins the entries whose callers load the unbound draw
factory. Hex palette colours become renderer colours through a small
shared helper.
2026-11-06 20:30:20 -08:00
Sameh Khamis 8c6fa6258b Move the bikeshare layer onto the renderer's draw and camera ports
Station dots and the selected-station highlight are now two point draw
sets, picked through the draw hit, and the layer follows the camera
through the camera port at its own threshold instead of the shared
percentageChanged ledger. Altitude and view centre come from the camera
pose and view rectangle. All five bikeshare files leave the Cesium
allow-list.

The Cesium draw port now keeps a rebuilt host in its place in the scene
instead of re-adding it on top, tags hosts with their set id so sprite
order can raise a draw set (registerSpriteSet), and restyles unclamped
points in place when they have not moved, so a status poll or selection
no longer rebuilds every station. Other draw-port layers (cyclone
markers, earthquake discs) now also keep their first-build slot rather
than jumping above the sprite layers on each rebuild.
2026-11-06 20:26:35 -08:00
Sameh Khamis b1733fa41a Drape recent imagery through the renderer's globe port
The two recent imagery slots now add their GIBS layers through the
globe port and share their six-request budget through its admission
hook. The port moves the layers between the globe and the base tileset,
which the renderer now marks as a base when it is the host.

The renderer stays the layer's Cesium side: it still loads the camera
factory, and now the globe factory too. The weather and wind entries
load the globe factory as well, and the factory check counts callers
that take findGlobe as a default.
2026-11-06 20:06:40 -08:00
Sameh Khamis bd5a688144 Draw tropical cyclones through the renderer's draw port
The cyclone layer no longer imports Cesium. Its advisories are three draw
sets per rendering (points, lines, cones) taken from drawOf(viewer): the
centers and forecast points are clamped dots culled past the horizon, the
tracks and cone outlines are draped lines, and the cones are clamped
polygons that keep their holes. Flights go through cameraOf, and the focus
sphere comes from a port of BoundingSphere.fromPoints in src/geo/sphere.js.

Clicks read the new ClickEvent.drawHit: the dispatcher's pick as the
contract's Hit when it is a draw-set item. The Cesium port's query uses the
same conversion, now in render/cesium/drawHit.js. pickStorm takes that hit
and accepts only current items of the layer's own sets.

Every advisory commit redraws the points, so an empty advisory clears them;
an unchanged selection draws nothing. Far-side tracks and cones are left
to the globe's depth instead of a per-frame occluder. Both cyclone files
leave the Cesium allow-list.
2026-11-06 19:15:09 -08:00
Sameh Khamis bb3106991e Draw earthquakes through the renderer's draw port
The earthquake discs are now one draw set of ground-clamped filled
ellipses per layer, with the same colours, alphas and radii; they had no
visible outline before either (Cesium turns outlines off on clamped
entity ellipses). The layer and its model no longer import Cesium and
leave the allow-list.

depthColor now returns a renderer colour [r, g, b, a] rather than a
Cesium colour, and depthAccent its CSS. A caller handing the layer a
Cesium viewer of their own, with no renderer bound, first loads the new
./render/cesium/unbound export, which provides every unbound factory; the
camera factory now loads the draw factory too, so entries that already
load it draw as well. A fake draw port for layer tests comes with it.
2026-11-06 19:15:08 -08:00
Sameh Khamis 99ad51048f Give layers a draw port through the viewer they hold
The Cesium draw sets move out of the shared ports into their own module,
so they can be built over a viewer no renderer is bound to. findDraw and
drawOf find a viewer's draw port as findCamera finds its camera: the bound
renderer's, or one built over a caller's own viewer once the Cesium
adapter's draw module (exported as ./render/cesium/draw) has loaded. A
renderer bound later releases a built port: its sets keep drawing.
2026-11-06 19:15:01 -08:00
Sameh Khamis b3dfcddcde Drape the open-data map overlays through the renderer's globe port
The sea-mark and ski-piste overlays add an XYZ imagery layer through the
globe port instead of building Cesium layers into a host collection. The
port drapes it on the globe on globe stacks and on the Google 3D tiles,
which the map stack now marks as its base tilesets. The row's hidden
reason reads the map stack's new getDrapeSurface, or the viewer's globe
when there is no map stack, and an overlay enabled before its viewer has
a globe port adds its layer once there is one. The overlays no longer
reach Cesium, so they leave the allow-list.
2026-11-06 18:29:40 -08:00
Sameh Khamis c67cda5f84 Give the Cesium renderer the contract's globe port
The globe port sets the base (photoreal tiles, terrain, imagery), shows
or hides the globe, and adds imagery layers: XYZ, WMTS, ArcGIS, world,
single-image and canvas sources, with admission, fetch and transform
hooks, a request budget and tile errors. Each layer drapes where its
drapeOn says: on the globe, or on the drawn base tileset, which is the
port's own photoreal tileset or one the map stack marks as its base,
followed every frame so a base switched outside the port moves the
layers. Port layers keep their order above other layers in each
collection. The sky reads the scene and writes through to it, and the
port reports settling and load progress.

The application renderer and the conformance renderer both have it, so
the application renderer now has every member of the contract. A viewer
with no renderer bound gets a globe port through findGlobe. The Cesium
conformance run checks imagery order, the split and the image-hook gate.
2026-11-06 18:29:40 -08:00
Sameh Khamis 09a84ea8a5 Give the Cesium camera port its user camera controls
camera.controls now maps the contract's CameraControls onto the scene's
ScreenSpaceCameraController: the enable flags, zoom distances, zoom
factor, coast as Cesium inertia (decay seconds, 0 for no coast), the
collision switch, the tilt limit as the upper end of pitchRange, and the
zoom bindings by name. suspend and enabled use the scene's shared input
holds, so they count with the input port's and the dispatcher's.

A follow's zoom hold now composes with the settings: minDistance and
coast.zoom read and set what the follow gives back, a higher floor takes
effect at once, and a follow never lengthens a shorter zoom coast.

The ctrl+wheel binding check reuses the controls' binding helpers, and
the controls checks run in the Cesium conformance set, the settings one
in Node as well.
2026-11-06 17:26:03 -08:00
Sameh Khamis f0c5eaa868 Give the Cesium renderer a quality port
The Cesium quality port supports pixel ratio, multisampling, shadows,
3D tile and terrain detail and the target frame rate, each applied when
first set and nothing changed before. Detail scales each tileset's and
the globe's own screen-space error and gives it back at full detail;
while tile detail is lowered, tilesets added later follow it. Frame
signals carry each drawn tick's CPU time, size, loop mode and holds.
The application and conformance renderers have the port, and the
conformance page runs the quality checks against Cesium.
2026-11-06 17:17:44 -08:00
Sameh Khamis 9f07da38a5 Own the credits modules where the camera factory loads them
The Cesium camera module now loads the credits factory, so the flight,
military and satellite packages own the credits modules too, and the
infrastructure build lists them.
2026-11-06 16:44:24 -08:00
Sameh Khamis 94b8b0bd30 Give a viewer with no renderer an effects port, as cameras get
The renderer bridge builds and keeps an effects port over a viewer no
renderer is bound to, with a factory the Cesium effects module provides,
so visual settings on a caller's own viewer draw their styles, bloom
and sharpen as before and give the scene's bloom back when destroyed.
The application shell loads the factory; a test checks every export
that reaches the effects lookup loads it.
2026-11-06 16:33:40 -08:00
Sameh Khamis 6a7905fc49 Drive the visual styles, bloom and sharpen through the effects port
VisualEffects defines each preset on the renderer and keeps its own
records of intensities and parameters, written through to the port, so
crossfades, the anime sky fade, bloom and sharpen behave as before. The
renderer animates the animated styles. Sensor picks read the style
records instead of the renderer's stages. The application renderer now
has the effects port and its capabilities.
2026-11-06 16:32:49 -08:00
Sameh Khamis bbda6dd0a1 Run styles, bloom and sharpen through a Cesium effects port
The effects port puts each style the app defines on its own post-process
stage, takes the scene's bloom stage and adds a sharpen stage, with the
mappings the application uses today. An animated style holds frames and
advances its time uniform while it draws. A replaced style keeps drawing
until its intensity is 0, so the app can crossfade; the contract, the stub
and a new conformance check say so. The conformance renderer has the
port; the application renderer does not yet.
2026-11-06 16:32:39 -08:00
Sameh Khamis 765a0db094 Add layer and map credits through the renderer's credits port
The street-level provider credits, the map source credit, the shared
inline OpenStreetMap and OpenMapTiles credits and the ALPR provider credit
go through the renderer's credits port instead of Cesium's credit display.
Their markup has one link each and is read as the port's plain data; the
ALPR credit is built as plain data, which the port escapes. src/maps/credits.js
and src/layers/streetLevel/credits.js no longer reach Cesium and leave the
allow-list.

findCredits finds the port as findCamera finds the camera: a Cesium viewer
of a caller's own, with no renderer bound, gets a credits port over its
own credit display, so the public entries keep their attribution. A port
built that way is released, not disposed, when a renderer binds later, and
a credit let go after its viewer is destroyed leaves the display alone.

The per-layer data credits and the transit and event credits stay on
Cesium's display: their markup carries several links each, which the
contract's credit cannot hold.
2026-11-06 16:32:23 -08:00
Sameh Khamis 979e2213b9 Give the Cesium renderer the contract's credits port
The shared Cesium ports gain credits, on both the conformance renderer and
the application's. list() reports what Cesium owes as plain data: its logo,
its static credits and the last drawn frame's imagery, terrain and tile
credits, read from the credit display through internals.js, with the
credits the app adds listed as given where the display shows them. addStatic
shows a credit through Cesium's display, as markup built from the plain
data with every value escaped and only web links kept, so attribution stays
on screen. change fires when the app adds or removes a credit, and after a
drawn frame whose Cesium credits differ from the last one's.

src/render/creditMarkup.js reads markup credits as plain data. The credits
listener check moves out of renderer.listenerRules into its own check, so a
renderer without every port can run it; it and the credits check now run on
Cesium.
2026-11-06 16:32:17 -08:00
Sameh Khamis e3a850bc9c Follow aircraft and satellites through the camera port
Flights and military follow their tracked aircraft with an
entityFollowTarget: framed in ENU from viewFrom, never closer than
150 m, presentation read from the drawn entity's record. Satellites
follow in Cesium's autodetect frame. The layers' own framing
(applyTrackedCameraFrame) goes; the port's follow has the same
close-range rules, and trackedCamera.js no longer imports Cesium.

The port's helper entity draws nothing: its point's outline is
transparent too, and click and voice picks of it count as picks of
the target's drawn entity. The fake camera binder follows when the
fake has Cesium's entity tracking.
2026-11-06 16:10:48 -08:00
Sameh Khamis 99f9a701d9 Read the followed target, not trackedEntity, in the follow readers
The tracked card, screen annotations, north-up, share links and Cockpit
ask data/followed.js what the camera follows, so they work the same when
a layer follows through the camera port. followed.js gains
entityFollowTarget (a FollowTarget whose presentation reads the drawn
entity's record), resumeFollowing and followedPosition.
2026-11-06 15:31:36 -08:00
Sameh Khamis 7eec2f828c Read what the camera follows through one module
src/data/followed.js answers what the camera follows: the camera port's
target, or the entity a layer still tracks itself, seen through the same
fields. Ownership checks, render holds, guards, voice actions, the CCTV
pacing and the navigation release paths read it instead of Cesium's
trackedEntity, so they keep working when layers follow through the port.
The release paths stop following, cancel the flight and release the
camera through the port. The rotate refusal names the followed target by
its name or label title.
2026-11-06 12:27:23 -08:00