From 1b226e14f22e52df157a2bbb73a6f917b3cc99a4 Mon Sep 17 00:00:00 2001 From: Sameh Khamis Date: Fri, 13 Nov 2026 16:08:41 -0800 Subject: [PATCH] Renderer contract: the renderer's look is its own; clouds are observed cover placed by scene time globe.sky switches parts of the sky on and off; how the sky, atmosphere, haze, lighting, tone mapping and exposure look is the renderer's own, and no check compares colours. globe.weather's clouds is the fraction of the sky covered; clouds are placed by scene time and the wind and shade the ground under them where the sun lights it. New conformance check globe.weather.sceneTime. --- CHANGELOG.md | 14 +++++-- docs/RENDERER-CONTRACT.md | 14 ++++++- src/render/conformance/checks/ports.js | 52 ++++++++++++++++++++++++++ src/render/contract/globe.d.ts | 19 +++++++++- src/render/stub/stub.test.mjs | 3 +- 5 files changed, 93 insertions(+), 9 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index ed7bfe9d1..3b06f41f3 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,6 +2,13 @@ ## [Unreleased] +- The renderer contract no longer ties a renderer's look to the default + renderer's: `globe.sky` switches parts of the sky on and off, while how + the sky, atmosphere, haze, lighting, tone mapping and exposure look is + the renderer's own. `globe.weather`'s `clouds` is the fraction of the sky + covered, as observed; clouds are placed by scene time and the wind and + shade the ground under them where the sun lights it. New conformance + check `globe.weather.sceneTime` (samehkhamis). - Selecting an aircraft, a vessel, a train or a transit vehicle no longer makes it bigger: it keeps the size and form it had and changes colour (a transit vehicle only widens its dark ring). A click on an aircraft, a @@ -869,7 +876,7 @@ - Stop one retired bikeshare feed from reporting the whole layer as failed. City feeds are fetched independently, but failure was recorded in a single - flag that only a successful *activation* cleared — and an already-loaded city + flag that only a successful _activation_ cleared — and an already-loaded city never activates again. A dead feed re-entering camera range therefore latched LOAD FAILED permanently over a map still drawing every other city's stations. Failure is now tracked per city: a city that fails beside others still @@ -1145,7 +1152,7 @@ photo a click opens, and the cones, by each photo's projection and upload date. KartaView's SINCE is the upload date (all its server can filter by); a note under the slider says so while KartaView is lit (`sinceBasis: - 'upload'` in the provider contract). +'upload'` in the provider contract). Mapillary's line coverage and sequence cones are now shared by both (`lineCoverage.js`, `sequenceCones.js`). @@ -1723,6 +1730,7 @@ Add feed provenance to analyst/view answers and HUD context while retaining existing response fields and runner ownership (Matt Van Horn, #347). Analyst records for loaded satellites, datacenters and dams, with explicit bounded count/rank coverage (Matt Van Horn, #351). + - New Fire Perimeters layer (Events group): live NIFC WFIGS interagency wildfire incident perimeters as ground-clamped polygons with a containment-colored fire line, refreshed every 5 minutes from the public @@ -1999,7 +2007,6 @@ of current runtime behavior, see [`docs/CURRENT-STATE.md`](docs/CURRENT-STATE.md ### Other changes - - Add ECMWF IFS model selection to Wind (#464, thanks @beneduzi), with model-scoped forecast-step caches, cancellation of replaced requests, and separate issue/valid timestamps. - Add bounded Director feature actions with accessible controls, explicit camera/layer admission and cancellation; restore pack geometry on same-shot seek. Preserve existing scenes and content attribution. @@ -2808,4 +2815,3 @@ represent previously published GitHub Releases. ## [0.1.0] — 2026-02-09 - Initial project version. - diff --git a/docs/RENDERER-CONTRACT.md b/docs/RENDERER-CONTRACT.md index 2d1b31803..972ccea56 100644 --- a/docs/RENDERER-CONTRACT.md +++ b/docs/RENDERER-CONTRACT.md @@ -146,8 +146,18 @@ under the camera (the weather service, through `deriveWeatherEffectProfile`), asking again after five minutes or 25 km, and none from orbit; the Display panel's Weather group turns live off and sets clouds, fog, rain and snow by hand, and shows only on a renderer that -lists `weather`. The Cesium port does not list it. The checks -`globe.weather` and `globe.weather.drawn` (a pixel check) pin it. +lists `weather`. The Cesium port does not list it. The strengths say what +is observed (`clouds` is the fraction of the sky covered), not how it is +drawn: the renderer draws clouds, fog and haze its own way, with clouds +placed by scene time and the wind, and shading the ground under them where +the sun lights it. The checks `globe.weather`, `globe.weather.drawn` and +`globe.weather.sceneTime` (pixel checks) pin it. + +How the sky, atmosphere, haze, lighting and the frame's tone mapping and +exposure look is the renderer's own: `globe.sky` switches parts on and +off, and no check compares colours. The +reference images under `src/render/conformance/goldens/visual/` are the +default renderer's own, for checking it against itself. The Cesium port lists `followAutodetect`: an `autodetect` follow is Cesium's own AUTODETECT tracking frame, east-north-up on a still or slow diff --git a/src/render/conformance/checks/ports.js b/src/render/conformance/checks/ports.js index 42a142012..7e5935981 100644 --- a/src/render/conformance/checks/ports.js +++ b/src/render/conformance/checks/ports.js @@ -4781,6 +4781,58 @@ export function portChecks() { }, { capability: 'weather' }, ), + check( + 'globe.weather.sceneTime', + 'clouds are where scene time puts them: moving it moves them, going back brings them back', + async (h, r) => { + if (h.pixels === false) return { skip: 'reads pixels' }; + r.camera.setView({ + destination: { ...AUSTIN, height: 600 }, + orientation: { heading: 0, pitch: 0.05, roll: 0 }, + }); + const frame = async () => { + await drawn(h, r, 4); + await settled(r); + r.frame.renderNow(); + return r.readPixels({ scale: 0.1 }).data; + }; + const apart = (a, b) => { + let sum = 0; + for (let i = 0; i < a.length; i += 4) + for (let c = 0; c < 3; c++) sum += Math.abs(a[i + c] - b[i + c]); + return sum / ((a.length / 4) * 3); + }; + const t0 = r.frame.time(); + const later = t0 + 30 * 60_000; + // What moving scene time changes without clouds (the sun), so the + // clouds' own movement is measured on top of it. + const clearAt0 = await frame(); + r.frame.setTime(later); + const clearLater = await frame(); + r.frame.setTime(t0); + r.globe.weather.set({ + clouds: 0.5, + wind: { speedMps: 20, fromDeg: 270 }, + }); + const cloudsAt0 = await frame(); + r.frame.setTime(later); + const cloudsLater = await frame(); + r.frame.setTime(t0); + const cloudsAgain = await frame(); + r.globe.weather.set({ clouds: 0, wind: { speedMps: 0, fromDeg: 0 } }); + const sun = apart(clearAt0, clearLater); + const moved = apart(cloudsAt0, cloudsLater); + ok( + moved > sun + 2, + `30 minutes of wind move the clouds (${moved.toFixed(1)} against ${sun.toFixed(1)} clear)`, + ); + ok( + apart(cloudsAt0, cloudsAgain) < 3, + `the same scene time draws the same clouds (${apart(cloudsAt0, cloudsAgain).toFixed(1)})`, + ); + }, + { capability: 'weather' }, + ), // --- Effects, credits, quality --------------------------------------- check( diff --git a/src/render/contract/globe.d.ts b/src/render/contract/globe.d.ts index 1b292d2cc..adacf2ea6 100644 --- a/src/render/contract/globe.d.ts +++ b/src/render/contract/globe.d.ts @@ -199,7 +199,11 @@ export interface BaseStatus { } /** - * The sky. A renderer whose sun, moon or fog are not separate from its + * The sky. These switch parts of it on and off; they do not say how it + * looks. How the sky, the atmosphere over the ground, distance haze, the + * lighting and the tone mapping and exposure of the frame look is each + * renderer's own, and no check compares colours with + * each other. Where the renderer's sun, moon or fog are not separate from its * atmosphere follows `atmosphere` for them and reports them as it draws them. */ export interface SkySettings { @@ -224,9 +228,20 @@ export interface SkySettings { * fades what makes no sense at the camera's height (rain from orbit) by * itself. None of it is picked or answers height queries. The application sets the * conditions observed at the view, which the user can override. + * + * The renderer draws these in its own way, as well as it can; the + * strengths say what is observed, not how it is drawn. Clouds and + * precipitation are where scene time (`frame.time()`) puts them, drifting + * with `wind`: the same scene time draws the same sky, and moving scene time + * moves them. Where the sun lights the globe (`SkySettings.lighting`), + * clouds shade the ground and models under them. */ export interface WeatherSettings { - /** Cloud cover. */ + /** + * The fraction of the sky the clouds cover, as observed: 0 clear, about + * 0.5 scattered to broken, 1 overcast. Under scattered cloud the ground + * shows between the clouds, from below and from above. + */ clouds: number; /** Fog: 1 is about 500 m visibility or less. */ fog: number; diff --git a/src/render/stub/stub.test.mjs b/src/render/stub/stub.test.mjs index 2d1313253..55bd05b55 100644 --- a/src/render/stub/stub.test.mjs +++ b/src/render/stub/stub.test.mjs @@ -20,7 +20,7 @@ test('the stub passes the conformance suite', async () => { .filter((r) => r.status === 'skip') .map((r) => r.id); // It draws only models into pixels, so the sweep's, a lit shape's, a line outline's and - // the blends' (over a drawn shape), video tiles' and the weather's pixels go unread; its camera takes no user gestures: the drag and wheel scripts are for a + // the blends' (over a drawn shape), video tiles' and the weather's pixels (drawn, and by scene time) go unread; its camera takes no user gestures: the drag and wheel scripts are for a // camera that does (a controller over it, say). assert.deepEqual(skipped, [ 'effects.screenModulation.pixels', @@ -30,6 +30,7 @@ test('the stub passes the conformance suite', async () => { 'draw.models.blend', 'globe.imagery.video', 'globe.weather.drawn', + 'globe.weather.sceneTime', ...CAMERA_SCRIPTS.filter(usesInput).map((s) => `camera.trace.${s.name}`), ]); });