From 9adcd6fe6302d83fb3e5110396b395e3f46f5fee Mon Sep 17 00:00:00 2001 From: Meta Vens Date: Fri, 20 Nov 2026 14:38:14 +0100 Subject: [PATCH 01/24] Ridge lighting: one RidgeLook record, shader reads it as uniforms The look constants (ink geometry, ink keeps, sun cut-off) become RidgeLook with DEFAULT_LOOK; lightCards and lightingOf take an optional look. hazeScale and ambientScale are new axes (default 1 = today). A recording-GL test proves an override reaches the shader uniforms. Co-Authored-By: Claude Sonnet 5.5 --- .../features/scene/ridge/lightCards.test.ts | 90 ++++++++++++++++++- src/app/features/scene/ridge/lightCards.ts | 73 ++++++++++----- 2 files changed, 136 insertions(+), 27 deletions(-) diff --git a/src/app/features/scene/ridge/lightCards.test.ts b/src/app/features/scene/ridge/lightCards.test.ts index 289245a8..63ec5b86 100644 --- a/src/app/features/scene/ridge/lightCards.test.ts +++ b/src/app/features/scene/ridge/lightCards.test.ts @@ -1,15 +1,17 @@ import { describe, expect, it, vi } from 'vitest'; import { decodeNormal, + DEFAULT_LOOK, FRAGMENT, + lightCards, lightingOf, skyLut, SKY_LUT, - SUN_CUTOFF_DEG, sunColumns, sunInColumn, WALL_RT2, } from './lightCards'; +import type { RidgeLook } from './lightCards'; import { parseManifest } from './manifest'; import { wireManifest } from './manifest.fixture'; import type { PhysicalSky } from './physicalSky'; @@ -107,9 +109,9 @@ describe('the lighting inputs', () => { const l = lightingOf(manifest, sky(30)); expect(l.sunTransmittance[0]).toBeCloseTo(0.9 * Math.sin(30 * RAD), 12); expect(l.sunTransmittance[2]).toBeCloseTo(0.7 * Math.sin(30 * RAD), 12); - expect(lightingOf(manifest, sky(SUN_CUTOFF_DEG - 1)).sunTransmittance).toEqual([0, 0, 0]); + expect(lightingOf(manifest, sky(DEFAULT_LOOK.sunCutoffDeg - 1)).sunTransmittance).toEqual([0, 0, 0]); expect( - lightingOf(manifest, sky(SUN_CUTOFF_DEG + 0.5)).sunTransmittance[0] + lightingOf(manifest, sky(DEFAULT_LOOK.sunCutoffDeg + 0.5)).sunTransmittance[0] ).toBeGreaterThanOrEqual(0); }); @@ -155,3 +157,85 @@ describe('the display of the shader', () => { expect(FRAGMENT).toContain(`vec3(${g(ACES_FIT[2])}, ${g(ACES_FIT[3])}, ${g(ACES_FIT[4])})`); }); }); + +describe('the look reaches the shader', () => { + // A recording WebGL2: every uniform call is kept by the name of its location, nothing is drawn. + const run = (look?: Partial) => { + const uniforms: Record = {}; + const gl = new Proxy( + { + getUniformLocation: (_p: unknown, name: string) => name, + uniform1i: () => undefined, + getShaderParameter: () => true, + getProgramParameter: () => true, + getExtension: () => null, + } as Record, + { + get: (t, k: string) => + k in t + ? t[k] + : k.startsWith('uniform') + ? (name: string, ...v: number[]) => { + uniforms[name] = v; + } + : () => ({}), + } + ); + const el = { width: 0, height: 0, getContext: () => gl }; + vi.stubGlobal('document', { createElement: () => el }); + const bmp = { width: 1, height: 1, close: () => undefined } as unknown as ImageBitmap; + const sky = { + sun: { azimuth: 214, elevation: 30 }, + atm: { + observerKm: 0.183, + mieScale: 1, + transmittanceToSpace: (_m: number, o: number[]) => o.fill(1), + irradiance: { direct: [0, 0, 0], ambient: [0.1, 0.2, 0.3] }, + radiance: (_a: number, _b: number, o: number[]) => o.fill(0), + }, + fit: { display: { exposure: 1, lift: 0 } }, + view: manifest.view, + } as unknown as PhysicalSky; + const one = { ...manifest, cards: manifest.cards.slice(0, 1) }; + try { + lightCards(one, [{ colour: bmp, geometry: bmp }], sky, look && { ...DEFAULT_LOOK, ...look }); + } finally { + vi.unstubAllGlobals(); + } + return uniforms; + }; + + it('defaults to DEFAULT_LOOK', () => { + const u = run(); + expect(u.uInkKeep).toEqual([0.45, 0.55, 0.8]); + expect(u.uInkGeometry).toEqual([0.35, 0.85]); + }); + + it('carries an ink override to the uniforms: edge keep 1 removes edge ink', () => { + const u = run({ inkKeep: { edge: 1, occlude: 0.55, crease: 0.8 } }); + expect(u.uInkKeep[0]).toBe(1); + }); + + it('scales the haze optical depth and the ambient light, and moves the sun cut-off', () => { + const base = run(); + const look = run({ hazeScale: 2, ambientScale: 0.5 }); + look.uExt.forEach((e, k) => expect(e).toBeCloseTo(2 * base.uExt[k], 12)); + expect(look.uAmbient[2]).toBeCloseTo(0.15, 12); + expect( + lightingOf(manifest, sky30(), { ...DEFAULT_LOOK, sunCutoffDeg: 45 }).sunTransmittance + ).toEqual([0, 0, 0]); + }); +}); + +function sky30(): PhysicalSky { + return { + sun: { azimuth: 214, elevation: 30 }, + atm: { + observerKm: 0.183, + mieScale: 1, + transmittanceToSpace: (_m: number, o: number[]) => o.fill(1), + irradiance: { direct: [0, 0, 0], ambient: [0, 0, 0] }, + }, + fit: { display: { exposure: 1, lift: 0 } }, + } as unknown as PhysicalSky; +} diff --git a/src/app/features/scene/ridge/lightCards.ts b/src/app/features/scene/ridge/lightCards.ts index 844a07a8..6b4d8130 100644 --- a/src/app/features/scene/ridge/lightCards.ts +++ b/src/app/features/scene/ridge/lightCards.ts @@ -28,19 +28,38 @@ export interface LitCard { scale: number; } -// Constants of the look, named for the art pass (ratatoskr:follow_up:ridge-art-quality-rework). None of them is a rule of the machine. -/** A real normal has r2 + t2 at most 0.998 (probe on the Vienna bake); the wall code is 2. */ +/** A real normal has r2 + t2 at most 0.998 (probe on the Vienna bake); the wall code is 2. A code of the data, not of the look. */ export const WALL_RT2 = 1.02; -/** A neighbour farther by more than this many nats of distance draws occluding ink on this pixel. */ -export const OCCLUDE_LOGD = 0.35; -/** A normal turning past this cosine between two non-wall pixels draws crease ink. */ -export const CREASE_COS = 0.85; -/** How much each ink keeps of the radiance it falls on (1 = no ink). */ -export const INK_KEEP = { edge: 0.45, occlude: 0.55, crease: 0.8 } as const; /** The lookup of the sky's radiance for the haze: azimuth columns by plane rows, filtered in the shader. */ export const SKY_LUT = { w: 64, h: 64 } as const; -/** Below this sun elevation (degrees) no direct sun reaches the ground (the atmosphere's own cut-off, `earthAtmosphere.ts` irradiance). */ -export const SUN_CUTOFF_DEG = -1; + +/** + * The look: every number of the art pass (ratatoskr:follow_up:ridge-art-quality-rework), the one owner of them. None is a rule of the machine. + * The shader reads them as uniforms, so one compiled program serves every look. + */ +export interface RidgeLook { + /** A neighbour farther by more than this many nats of distance draws occluding ink on this pixel. */ + occludeLogD: number; + /** A normal turning past this cosine between two non-wall pixels draws crease ink. */ + creaseCos: number; + /** How much each ink keeps of the radiance it falls on (1 = no ink). */ + inkKeep: { edge: number; occlude: number; crease: number }; + /** Below this sun elevation (degrees) no direct sun reaches the ground (the atmosphere's own cut-off, `earthAtmosphere.ts` irradiance). */ + sunCutoffDeg: number; + /** Multiplies the optical depth of the aerial perspective: 1 is the sky's own extinction, 0 no haze. */ + hazeScale: number; + /** Multiplies the ambient irradiance the terrain is lit by. */ + ambientScale: number; +} + +export const DEFAULT_LOOK: RidgeLook = { + occludeLogD: 0.35, + creaseCos: 0.85, + inkKeep: { edge: 0.45, occlude: 0.55, crease: 0.8 }, + sunCutoffDeg: -1, + hazeScale: 1, + ambientScale: 1, +}; const RAD = Math.PI / 180; @@ -86,19 +105,25 @@ export interface Lighting { lift: number; } -export function lightingOf(manifest: RidgeManifest, sky: PhysicalSky): Lighting { +export function lightingOf( + manifest: RidgeManifest, + sky: PhysicalSky, + look: RidgeLook = DEFAULT_LOOK +): Lighting { const trans = [0, 0, 0]; const sinEl = Math.sin(sky.sun.elevation * RAD); sky.atm.transmittanceToSpace(Math.max(sinEl, 0), trans); - const lit = sky.sun.elevation > SUN_CUTOFF_DEG; + const lit = sky.sun.elevation > look.sunCutoffDeg; return { planeW: manifest.view.planeW, planeH: manifest.view.planeH, logDMin: manifest.encoding.logDMin, logDSpan: manifest.encoding.logDMax - manifest.encoding.logDMin, - extinction: extinctionAt(sky.atm.observerKm, sky.atm.mieScale), + extinction: extinctionAt(sky.atm.observerKm, sky.atm.mieScale).map( + (e) => e * look.hazeScale + ) as Vec3, sunTransmittance: lit ? [trans[0], trans[1], trans[2]] : [0, 0, 0], - ambient: sky.atm.irradiance.ambient, + ambient: sky.atm.irradiance.ambient.map((a) => a * look.ambientScale) as Vec3, exposure: sky.fit.display.exposure, lift: sky.fit.display.lift, }; @@ -152,15 +177,12 @@ uniform vec3 uExt; uniform vec3 uTSun; uniform vec3 uAmbient; uniform vec2 uDisplay; +uniform vec2 uInkGeometry; // occludeLogD, creaseCos +uniform vec3 uInkKeep; // edge, occlude, crease out vec4 outColor; const float PI = 3.14159265358979; const float WALL_RT2 = ${glsl(WALL_RT2)}; -const float OCCLUDE_LOGD = ${glsl(OCCLUDE_LOGD)}; -const float CREASE_COS = ${glsl(CREASE_COS)}; -const vec3 INK_KEEP = vec3(${glsl(INK_KEEP.edge)}, ${glsl(INK_KEEP.occlude)}, ${glsl( - INK_KEEP.crease -)}); ${[0, 1, 2] .map((i) => `const vec3 IN_R${i} = vec3(${ACES_IN[i].map(glsl).join(', ')});`) .join('\n')} @@ -227,9 +249,9 @@ void main() { if (q.x < 0 || q.y < 0 || q.x >= uSize.x || q.y >= uSize.y) continue; float an = texelFetch(uColour, q, 0).a; Geo gn = geoAt(q); - if (c.a >= 0.5 && an < 0.5) keep = min(keep, INK_KEEP.x); - else if (an >= 0.5 && gn.logD - g.logD > OCCLUDE_LOGD) keep = min(keep, INK_KEEP.y); - else if (an >= 0.5 && !g.wall && !gn.wall && dot(g.n, gn.n) < CREASE_COS) keep = min(keep, INK_KEEP.z); + if (c.a >= 0.5 && an < 0.5) keep = min(keep, uInkKeep.x); + else if (an >= 0.5 && gn.logD - g.logD > uInkGeometry.x) keep = min(keep, uInkKeep.y); + else if (an >= 0.5 && !g.wall && !gn.wall && dot(g.n, gn.n) < uInkGeometry.y) keep = min(keep, uInkKeep.z); } radiance *= keep; @@ -304,7 +326,8 @@ function bitmapTexture(gl: WebGL2RenderingContext, unit: number, bmp: ImageBitma export function lightCards( manifest: RidgeManifest, bitmaps: CardBitmaps[], - sky: PhysicalSky + sky: PhysicalSky, + look: RidgeLook = DEFAULT_LOOK ): LitCard[] { const glCanvas = document.createElement('canvas'); const gl = glCanvas.getContext('webgl2', { @@ -316,7 +339,7 @@ export function lightCards( }); if (!gl) throw new Error('ridge: no WebGL2'); try { - const lit = lightingOf(manifest, sky); + const lit = lightingOf(manifest, sky, look); const prog = program(gl); gl.useProgram(prog); const u = (name: string) => gl.getUniformLocation(prog, name); @@ -330,6 +353,8 @@ export function lightCards( gl.uniform3f(u('uTSun'), ...lit.sunTransmittance); gl.uniform3f(u('uAmbient'), ...lit.ambient); gl.uniform2f(u('uDisplay'), lit.exposure, lit.lift); + gl.uniform2f(u('uInkGeometry'), look.occludeLogD, look.creaseCos); + gl.uniform3f(u('uInkKeep'), look.inkKeep.edge, look.inkKeep.occlude, look.inkKeep.crease); gl.uniform2i(u('uSkySize'), SKY_LUT.w, SKY_LUT.h); const sunTex = floatTexture(gl, 2, lit.planeW, 1, sunColumns(manifest.view, sky.sun)); const skyTex = floatTexture( From d4be09c2b23ea3ca2fe884f826acf72b409e8274 Mon Sep 17 00:00:00 2001 From: Meta Vens Date: Fri, 20 Nov 2026 14:41:14 +0100 Subject: [PATCH 02/24] Ridge look: art-pass axes as uniforms (relief, fixed light, tints, tone, noise) reliefWeight, reliefLight, hazeTint, nearWarm, contrastByDistance, cardToneStep, cardGradient, inkScale, groundNoise, cloudShadows; all default to today's look. makePhysicalSky takes an optional sun for the look sheet. Co-Authored-By: Claude Sonnet 5.5 --- .../features/scene/ridge/lightCards.test.ts | 22 ++++ src/app/features/scene/ridge/lightCards.ts | 108 ++++++++++++++++-- src/app/features/scene/ridge/physicalSky.ts | 6 +- 3 files changed, 126 insertions(+), 10 deletions(-) diff --git a/src/app/features/scene/ridge/lightCards.test.ts b/src/app/features/scene/ridge/lightCards.test.ts index 63ec5b86..f76833f0 100644 --- a/src/app/features/scene/ridge/lightCards.test.ts +++ b/src/app/features/scene/ridge/lightCards.test.ts @@ -216,6 +216,28 @@ describe('the look reaches the shader', () => { expect(u.uInkKeep[0]).toBe(1); }); + it('carries the art-pass axes: relief, fixed light, tint, tone, ink scale, noise', () => { + const u = run({ + reliefWeight: 0.15, + reliefLight: { mix: 1, azimuthDeg: 0, elevationDeg: 90 }, + hazeTint: [0, 0.1, 0.3], + nearWarm: 0.5, + contrastByDistance: 1.5, + cardToneStep: 0.2, + cardGradient: 0.3, + inkScale: 0, + groundNoise: 0.4, + cloudShadows: 0.6, + }); + expect(u.uRelief).toEqual([0.15, 1]); + expect(u.uFixedLight[2]).toBeCloseTo(1, 12); // a light straight up + expect(u.uHazeTint).toEqual([0, 0.1, 0.3]); + expect(u.uDist).toEqual([0.5, 1.5]); + expect(u.uCard).toEqual([1, 0.3]); // a single card sits at the centre of the tone steps + expect(u.uInkScale).toEqual([0]); + expect(u.uGround).toEqual([0.4, 0.6]); + }); + it('scales the haze optical depth and the ambient light, and moves the sun cut-off', () => { const base = run(); const look = run({ hazeScale: 2, ambientScale: 0.5 }); diff --git a/src/app/features/scene/ridge/lightCards.ts b/src/app/features/scene/ridge/lightCards.ts index 6b4d8130..3b8d25eb 100644 --- a/src/app/features/scene/ridge/lightCards.ts +++ b/src/app/features/scene/ridge/lightCards.ts @@ -50,6 +50,26 @@ export interface RidgeLook { hazeScale: number; /** Multiplies the ambient irradiance the terrain is lit by. */ ambientScale: number; + /** 0 = no normal shading (the flat card tone, as a horizontal surface), 1 = shaded by the normals. */ + reliefWeight: number; + /** The relief light: `mix` 0 is the sun, 1 a fixed light; `azimuthDeg` is clockwise of the view ray (-45 = upper left, behind the ridge), `elevationDeg` above the horizon. */ + reliefLight: { mix: number; azimuthDeg: number; elevationDeg: number }; + /** Added to the sky radiance used for the haze, rgb in units of that radiance's own luminance (so it holds at every sky): positive blue = cool far. */ + hazeTint: readonly [number, number, number]; + /** Strength (0..1) of a warm tint on the near, fading out with the log-distance across the baked range. */ + nearWarm: number; + /** The relief's contrast about the pixel's flat tone scales by exp(c (1 - 2 d)), d the log-distance across the baked range: c > 0 near contrasty, far flat. */ + contrastByDistance: number; + /** Value of each card multiplies by 1 + step (index - centre); the nearest card is index 0, so a positive step makes near darkest. */ + cardToneStep: number; + /** Value ramp inside each card: 1 + g (y - 1/2), y the fraction down the card; positive lightens toward the foot. */ + cardGradient: number; + /** Multiplies each ink's darkening: 0 = no lines. */ + inkScale: number; + /** Procedural albedo variation (a stand-in for land cover we do not bake): fbm in metres on the ground, so its screen frequency follows distance. 0 = none. */ + groundNoise: number; + /** Low-frequency noise darkening of the direct sun (static). 0 = none. */ + cloudShadows: number; } export const DEFAULT_LOOK: RidgeLook = { @@ -59,6 +79,16 @@ export const DEFAULT_LOOK: RidgeLook = { sunCutoffDeg: -1, hazeScale: 1, ambientScale: 1, + reliefWeight: 1, + reliefLight: { mix: 0, azimuthDeg: -45, elevationDeg: 40 }, + hazeTint: [0, 0, 0], + nearWarm: 0, + contrastByDistance: 0, + cardToneStep: 0, + cardGradient: 0, + inkScale: 1, + groundNoise: 0, + cloudShadows: 0, }; const RAD = Math.PI / 180; @@ -105,6 +135,8 @@ export interface Lighting { lift: number; } +const scale3 = (v: Vec3, k: number): Vec3 => [v[0] * k, v[1] * k, v[2] * k]; + export function lightingOf( manifest: RidgeManifest, sky: PhysicalSky, @@ -119,11 +151,9 @@ export function lightingOf( planeH: manifest.view.planeH, logDMin: manifest.encoding.logDMin, logDSpan: manifest.encoding.logDMax - manifest.encoding.logDMin, - extinction: extinctionAt(sky.atm.observerKm, sky.atm.mieScale).map( - (e) => e * look.hazeScale - ) as Vec3, + extinction: scale3(extinctionAt(sky.atm.observerKm, sky.atm.mieScale), look.hazeScale), sunTransmittance: lit ? [trans[0], trans[1], trans[2]] : [0, 0, 0], - ambient: sky.atm.irradiance.ambient.map((a) => a * look.ambientScale) as Vec3, + ambient: scale3(sky.atm.irradiance.ambient, look.ambientScale), exposure: sky.fit.display.exposure, lift: sky.fit.display.lift, }; @@ -179,9 +209,19 @@ uniform vec3 uAmbient; uniform vec2 uDisplay; uniform vec2 uInkGeometry; // occludeLogD, creaseCos uniform vec3 uInkKeep; // edge, occlude, crease +uniform float uInkScale; +uniform vec2 uRelief; // weight, mix toward the fixed light +uniform vec3 uFixedLight; // in the column frame +uniform vec3 uHazeTint; +uniform vec2 uDist; // nearWarm, contrastByDistance +uniform vec2 uCard; // value of this card, gradient +uniform vec2 uGround; // groundNoise, cloudShadows +uniform float uRadPerPx; // radians of azimuth per plane pixel out vec4 outColor; const float PI = 3.14159265358979; +const vec3 NEAR_WARM = vec3(1.0, 0.82, 0.62); +const vec3 LUMA = vec3(0.2126, 0.7152, 0.0722); const float WALL_RT2 = ${glsl(WALL_RT2)}; ${[0, 1, 2] .map((i) => `const vec3 IN_R${i} = vec3(${ACES_IN[i].map(glsl).join(', ')});`) @@ -218,6 +258,24 @@ vec3 skyAt(vec2 uv) { return mix(a, c, t.y); } +float hash2(vec2 p) { + p = fract(p * vec2(123.34, 456.21)); + p += dot(p, p + 45.32); + return fract(p.x * p.y); +} +float vnoise(vec2 p) { + vec2 i = floor(p); + vec2 f = fract(p); + f = f * f * (3.0 - 2.0 * f); + return mix(mix(hash2(i), hash2(i + vec2(1.0, 0.0)), f.x), mix(hash2(i + vec2(0.0, 1.0)), hash2(i + vec2(1.0, 1.0)), f.x), f.y); +} +float fbm(vec2 p) { + float a = 0.5; + float sum = 0.0; + for (int i = 0; i < 4; i++) { sum += a * vnoise(p); p *= 2.03; a *= 0.5; } + return sum / 0.9375; +} + struct Geo { vec3 n; float logD; bool wall; }; Geo geoAt(ivec2 p) { vec4 g = texelFetch(uGeo, p, 0); @@ -237,10 +295,26 @@ void main() { Geo g = geoAt(p); vec3 s = texelFetch(uSun, ivec2(p.x, 0), 0).xyz; - vec3 radiance = toLinear(c.rgb) * (uTSun * max(dot(g.n, s), 0.0) + uAmbient) / PI; - vec3 T = exp(-uExt * (exp(g.logD) / 1000.0)); + if (uRelief.y > 0.0) s = normalize(mix(s, uFixedLight, uRelief.y)); + float dist = exp(g.logD); + vec2 world = vec2(float(p.x) * uRadPerPx, 1.0) * dist; + vec3 albedo = toLinear(c.rgb); + if (uGround.x > 0.0) albedo *= max(1.0 + uGround.x * (2.0 * fbm(world / 250.0) - 1.0), 0.0); + float cloud = uGround.y > 0.0 ? 1.0 - uGround.y * smoothstep(0.5, 0.72, fbm(world / 4000.0 + 17.0)) : 1.0; + float ndl = mix(max(s.z, 0.0), max(dot(g.n, s), 0.0), uRelief.x); + vec3 radiance = albedo * (uTSun * ndl * cloud + uAmbient) / PI; + float dn = clamp((g.logD - uLogD.x) / uLogD.y, 0.0, 1.0); + if (uDist.y != 0.0) { + vec3 flatTone = albedo * (uTSun * max(s.z, 0.0) * cloud + uAmbient) / PI; + radiance = flatTone + (radiance - flatTone) * exp(uDist.y * (1.0 - 2.0 * dn)); + } + radiance *= mix(vec3(1.0), NEAR_WARM, uDist.x * (1.0 - dn)); + vec3 T = exp(-uExt * (dist / 1000.0)); vec2 uv = vec2((float(p.x) + 0.5) / uPlane.x, (float(uTop + p.y) + 0.5) / uPlane.y); - radiance = radiance * T + skyAt(uv) * (1.0 - T); + vec3 haze = skyAt(uv); + haze += uHazeTint * dot(haze, LUMA); + radiance = radiance * T + haze * (1.0 - T); + radiance *= max(uCard.x * (1.0 + uCard.y * ((float(p.y) + 0.5) / float(uSize.y) - 0.5)), 0.0); float keep = 1.0; ivec2 dirs[4] = ivec2[4](ivec2(1, 0), ivec2(-1, 0), ivec2(0, 1), ivec2(0, -1)); @@ -253,7 +327,7 @@ void main() { else if (an >= 0.5 && gn.logD - g.logD > uInkGeometry.x) keep = min(keep, uInkKeep.y); else if (an >= 0.5 && !g.wall && !gn.wall && dot(g.n, gn.n) < uInkGeometry.y) keep = min(keep, uInkKeep.z); } - radiance *= keep; + radiance *= 1.0 - (1.0 - keep) * uInkScale; vec3 lin = aces(radiance * uDisplay.x); vec3 rgb = toSrgb(uDisplay.y + (1.0 - uDisplay.y) * lin); @@ -355,6 +429,19 @@ export function lightCards( gl.uniform2f(u('uDisplay'), lit.exposure, lit.lift); gl.uniform2f(u('uInkGeometry'), look.occludeLogD, look.creaseCos); gl.uniform3f(u('uInkKeep'), look.inkKeep.edge, look.inkKeep.occlude, look.inkKeep.crease); + gl.uniform1f(u('uInkScale'), look.inkScale); + gl.uniform2f(u('uRelief'), look.reliefWeight, look.reliefLight.mix); + const fl = look.reliefLight; + gl.uniform3f( + u('uFixedLight'), + Math.cos(fl.elevationDeg * RAD) * Math.cos(fl.azimuthDeg * RAD), + Math.cos(fl.elevationDeg * RAD) * Math.sin(fl.azimuthDeg * RAD), + Math.sin(fl.elevationDeg * RAD) + ); + gl.uniform3f(u('uHazeTint'), ...look.hazeTint); + gl.uniform2f(u('uDist'), look.nearWarm, look.contrastByDistance); + gl.uniform2f(u('uGround'), look.groundNoise, look.cloudShadows); + gl.uniform1f(u('uRadPerPx'), (manifest.view.windowDeg * RAD) / lit.planeW); gl.uniform2i(u('uSkySize'), SKY_LUT.w, SKY_LUT.h); const sunTex = floatTexture(gl, 2, lit.planeW, 1, sunColumns(manifest.view, sky.sun)); const skyTex = floatTexture( @@ -373,6 +460,11 @@ export function lightCards( const geoTex = bitmapTexture(gl, 1, geometry); gl.uniform2i(u('uSize'), colour.width, colour.height); gl.uniform1i(u('uTop'), card.top); + gl.uniform2f( + u('uCard'), + 1 + look.cardToneStep * (i - (manifest.cards.length - 1) / 2), + look.cardGradient + ); gl.clearColor(0, 0, 0, 0); gl.clear(gl.COLOR_BUFFER_BIT); gl.drawArrays(gl.TRIANGLES, 0, 3); diff --git a/src/app/features/scene/ridge/physicalSky.ts b/src/app/features/scene/ridge/physicalSky.ts index 5fb4a719..97346981 100644 --- a/src/app/features/scene/ridge/physicalSky.ts +++ b/src/app/features/scene/ridge/physicalSky.ts @@ -53,10 +53,12 @@ export function makePhysicalSky( state: FixedSkyState, now: Date, weatherValue: number, - view: View + view: View, + /** A sun to draw instead of the state's own (the look sheet's grid of elevations); `state` still picks the display budget. */ + sunOverride?: SunSample ): PhysicalSky { const t0 = clock(); - const sun = sunForState(view.place, state, now); + const sun = sunOverride ?? sunForState(view.place, state, now); const weather = weatherOf(weatherValue); const atm = bakeAtmosphere({ sunElevationDeg: sun.elevation, From fa8f2a163b3bcd9d82db3f0e6d1b8ed2206cb841 Mon Sep 17 00:00:00 2001 From: Meta Vens Date: Fri, 20 Nov 2026 14:46:56 +0100 Subject: [PATCH 03/24] Harness: ridge look sheet (sky states x looks, four art-direction presets) Co-Authored-By: Claude Sonnet 5.5 --- harness/scene/README.md | 24 +++++ harness/scene/ridgeSheet.html | 8 ++ harness/scene/ridgeSheet.ts | 185 ++++++++++++++++++++++++++++++++++ 3 files changed, 217 insertions(+) create mode 100644 harness/scene/ridgeSheet.html create mode 100644 harness/scene/ridgeSheet.ts diff --git a/harness/scene/README.md b/harness/scene/README.md index 624d4b0b..c7d42007 100644 --- a/harness/scene/README.md +++ b/harness/scene/README.md @@ -20,3 +20,27 @@ directory whose ancestors hold no empty `package.json` (esbuild reads them). Timings from SwiftShader are CPU time: use them for the split between passes and for before and after of one change, never as a phone frame time. + +## Ridge look sheet + +Renders the Vienna cards (`public/ridge/vienna-6815bb9dca99`) lit for six sky states (dawn 2, morning 15, noon 55, golden 6, dusk -3, night -30 degrees of sun) +by a set of looks (`RidgeLook`, `src/app/features/scene/ridge/lightCards.ts`, the one owner of look values), one 480x270 canvas per cell at heading 0. The sky +behind a cell is the app's own (`makePhysicalSky` + `paintSky`, upscaled), without the sun disc, stars or clouds. Not shipped. + + npx vite --port 5199 # from the repo root; the app's vite config serves the page and public/ + http://localhost:5199/harness/scene/ridgeSheet.html # four presets x six skies + ...ridgeSheet.html?preset=swiss # one preset (physical|swiss|poster|painterly) + ...ridgeSheet.html?looks=%5B%7B%22label%22%3A%22no-ink%22%2C%22inkScale%22%3A0%7D%2C%7B%22label%22%3A%22hazy%22%2C%22hazeScale%22%3A8%7D%5D + ...?w=640 # cell width + +`looks=` is a url-encoded or base64 JSON array of `{label, ...partial RidgeLook}` and replaces the preset rows (`inkKeep` and `reliefLight` merge by key). +A cell costs one WebGL2 context and a card decode, so the full sheet takes tens of seconds (much longer in a background tab). + +Presets (`PRESETS` in `ridgeSheet.ts`; every key not named is `DEFAULT_LOOK`), chosen by reasoning, not by eye, for Self to tune: + +| preset | values | +| --- | --- | +| physical | DEFAULT_LOOK | +| swiss | reliefLight {mix 0.7, azimuthDeg -45, elevationDeg 40}, contrastByDistance 0.9, hazeScale 6, hazeTint [0, 0.05, 0.25], nearWarm 0.5, inkScale 0.6 | +| poster | reliefWeight 0.15, cardToneStep 0.25, cardGradient 0.5, inkKeep {edge 0.25, occlude 0.9, crease 1}, hazeScale 4 | +| painterly | groundNoise 0.35, cloudShadows 0.5, nearWarm 0.6, hazeScale 2, inkScale 0.4 | diff --git a/harness/scene/ridgeSheet.html b/harness/scene/ridgeSheet.html new file mode 100644 index 00000000..9a45924b --- /dev/null +++ b/harness/scene/ridgeSheet.html @@ -0,0 +1,8 @@ + + + +Ridge look sheet + +
+ + diff --git a/harness/scene/ridgeSheet.ts b/harness/scene/ridgeSheet.ts new file mode 100644 index 00000000..6516e98e --- /dev/null +++ b/harness/scene/ridgeSheet.ts @@ -0,0 +1,185 @@ +// Look sheet for the lit ridge cards: the Vienna bake lit for a grid of sky states x looks, each cell a small canvas at heading 0. Not shipped. +// `?preset=all|physical|swiss|poster|painterly` (default all: the four rows); `?looks=` replaces the rows with +// the given `{label, ...partial RidgeLook}` entries (inkKeep and reliefLight merge by key). `?w=480` sets the cell width (16:9). +// The sky behind a cell is the app's own: `makePhysicalSky` + `paintSky` upscaled smoothly, without the sun disc, stars or clouds. +import { DEFAULT_LOOK, lightCards } from '../../src/app/features/scene/ridge/lightCards'; +import type { RidgeLook } from '../../src/app/features/scene/ridge/lightCards'; +import { parseManifest } from '../../src/app/features/scene/ridge/manifest'; +import { makePhysicalSky, paintSky } from '../../src/app/features/scene/ridge/physicalSky'; +import { windowFor } from '../../src/app/features/scene/ridge/view'; +import { DAY_FROM } from '../../src/app/features/scene/skyState'; +import type { FixedSkyState } from '../../src/app/features/scene/skyState'; + +const DIR = '/public/ridge/vienna-6815bb9dca99/'; + +type Override = Partial> & { + label: string; + inkKeep?: Partial; + reliefLight?: Partial; +}; + +/** Sun elevation and compass azimuth of each column; the cards look at 214 +- 36. Elevation picks the display budget (day from DAY_FROM, night below its negative). */ +const SKIES = [ + { label: 'dawn 2 deg', elevation: 2, azimuth: 100 }, + { label: 'morning 15 deg', elevation: 15, azimuth: 135 }, + { label: 'noon 55 deg', elevation: 55, azimuth: 190 }, + { label: 'golden 6 deg', elevation: 6, azimuth: 244 }, + { label: 'dusk -3 deg', elevation: -3, azimuth: 262 }, + { label: 'night -30 deg', elevation: -30, azimuth: 0 }, +]; + +/** The art directions, chosen by reasoning, not by eye: Self tunes them (values listed in harness/scene/README.md). */ +const PRESETS: Record = { + physical: { label: 'physical' }, + swiss: { + label: 'swiss', + reliefLight: { mix: 0.7, azimuthDeg: -45, elevationDeg: 40 }, + contrastByDistance: 0.9, + hazeScale: 6, + hazeTint: [0, 0.05, 0.25], + nearWarm: 0.5, + inkScale: 0.6, + }, + poster: { + label: 'poster', + reliefWeight: 0.15, + cardToneStep: 0.25, + cardGradient: 0.5, + inkKeep: { edge: 0.25, occlude: 0.9, crease: 1 }, + hazeScale: 4, + }, + painterly: { + label: 'painterly', + groundNoise: 0.35, + cloudShadows: 0.5, + nearWarm: 0.6, + hazeScale: 2, + inkScale: 0.4, + }, +}; + +const merge = (o: Override): { label: string; look: RidgeLook } => { + const { label, inkKeep, reliefLight, ...rest } = o; + return { + label, + look: { + ...DEFAULT_LOOK, + ...rest, + inkKeep: { ...DEFAULT_LOOK.inkKeep, ...inkKeep }, + reliefLight: { ...DEFAULT_LOOK.reliefLight, ...reliefLight }, + }, + }; +}; + +function parseLooks(raw: string): Override[] { + const tries = [() => decodeURIComponent(raw), () => atob(raw.replace(/-/g, '+').replace(/_/g, '/'))]; + for (const t of tries) { + try { + const v = JSON.parse(t()); + if (Array.isArray(v)) return v.map((e, i) => ({ label: `look ${i + 1}`, ...e })); + } catch { + // try the next encoding + } + } + throw new Error('looks= is neither a url-encoded nor a base64 JSON array'); +} + +const q = new URLSearchParams(location.search); +const preset = q.get('preset'); +const rows = (q.get('looks') + ? parseLooks(q.get('looks') as string) + : preset && preset !== 'all' + ? [PRESETS[preset] ?? PRESETS.physical] + : Object.values(PRESETS) +).map(merge); +const W = Number(q.get('w') ?? 480); +const H = Math.round((W * 9) / 16); +const root = document.getElementById('sheet') as HTMLElement; + +const stateOf = (el: number): FixedSkyState => + el >= DAY_FROM ? 'day' : el <= -DAY_FROM ? 'night' : 'dusk'; + +async function main() { + const manifest = parseManifest(await (await fetch(`${DIR}manifest.json`)).json(), DIR); + const blobs = await Promise.all( + manifest.cards.map(async (c) => ({ + colour: await (await fetch(`${DIR}${c.colour}`)).blob(), + geometry: await (await fetch(`${DIR}${c.geometry}`)).blob(), + })) + ); + const decode = (b: Blob) => + createImageBitmap(b, { premultiplyAlpha: 'none', colorSpaceConversion: 'none' }); + const { view } = manifest; + const win = windowFor(view, W, H); + const now = new Date(); + + const table = document.createElement('table'); + table.style.borderSpacing = '4px'; + root.append(table); + const head = table.insertRow(); + head.insertCell(); + SKIES.forEach((s) => (head.insertCell().textContent = s.label)); + const tr = rows.map((r) => { + const row = table.insertRow(); + row.insertCell().textContent = r.label; + return row; + }); + + for (const sky of SKIES) { + const physical = makePhysicalSky(stateOf(sky.elevation), now, 0, view, { + elevation: sky.elevation, + azimuth: sky.azimuth, + time: now, + }); + const px = paintSky(physical, W, H, win.camera); + const small = document.createElement('canvas'); + small.width = px.w; + small.height = px.h; + const sctx = small.getContext('2d') as CanvasRenderingContext2D; + const img = sctx.createImageData(px.w, px.h); + img.data.set(px.data); + sctx.putImageData(img, 0, 0); + + for (let r = 0; r < rows.length; r += 1) { + const bitmaps = await Promise.all( + blobs.map(async (b) => ({ + colour: await decode(b.colour), + geometry: await decode(b.geometry), + })) + ); + const cards = lightCards(manifest, bitmaps, physical, rows[r].look); + const cell = document.createElement('canvas'); + cell.width = W; + cell.height = H; + const ctx = cell.getContext('2d') as CanvasRenderingContext2D; + ctx.imageSmoothingQuality = 'high'; + ctx.drawImage(small, 0, 0, W, H); + // As Ridge.ts paintCards at heading 0: farthest first, each card at its own scale about the horizon row of the plane. + const s = win.plane.scale; + const x0 = (W - win.plane.w) / 2; + const planeTop = H - win.plane.h; + const ox = x0 + win.plane.w / 2; + const oy = planeTop + view.horizonRow * s; + for (let k = cards.length - 1; k >= 0; k -= 1) { + ctx.save(); + ctx.translate(ox, oy); + ctx.scale(cards[k].scale, cards[k].scale); + ctx.drawImage( + cards[k].canvas, + x0 - ox, + planeTop + cards[k].top * s - oy, + win.plane.w, + cards[k].h * s + ); + ctx.restore(); + } + tr[r].insertCell().append(cell); + } + } + document.title = 'ridge look sheet: done'; +} + +main().catch((e) => { + console.error(e); + root.textContent = `ridge look sheet failed: ${e}`; +}); From 3232c866cafdd426b49d63824f756b7efa73b5f9 Mon Sep 17 00:00:00 2001 From: Meta Vens Date: Fri, 20 Nov 2026 16:11:44 +0100 Subject: [PATCH 04/24] Tone curve: fitted monotone curve with a small black lift replaces the additive lift and the 0.47 day floor; night ambient Per-sky monotone cubic through five knots (black lift, p5/p50/p95 of the sky grid to target luminances, white or the night ceiling), shared by sky and cards. Night gets a fixed-knot curve and a RidgeLook.nightAmbient term. Co-Authored-By: Claude Sonnet 5.5 --- .../features/scene/ridge/lightCards.test.ts | 40 ++- src/app/features/scene/ridge/lightCards.ts | 46 +++- .../features/scene/ridge/physicalSky.test.ts | 4 +- src/app/features/scene/ridge/physicalSky.ts | 4 +- src/app/features/scene/ridge/toneMap.test.ts | 65 +++++ src/app/features/scene/ridge/toneMap.ts | 231 ++++++++++-------- src/app/features/scene/skyForState.test.ts | 14 +- 7 files changed, 276 insertions(+), 128 deletions(-) create mode 100644 src/app/features/scene/ridge/toneMap.test.ts diff --git a/src/app/features/scene/ridge/lightCards.test.ts b/src/app/features/scene/ridge/lightCards.test.ts index f76833f0..3c85e859 100644 --- a/src/app/features/scene/ridge/lightCards.test.ts +++ b/src/app/features/scene/ridge/lightCards.test.ts @@ -15,7 +15,7 @@ import type { RidgeLook } from './lightCards'; import { parseManifest } from './manifest'; import { wireManifest } from './manifest.fixture'; import type { PhysicalSky } from './physicalSky'; -import { ACES_FIT, ACES_IN, ACES_OUT } from './toneMap'; +import { ACES_FIT, ACES_IN, ACES_OUT, LIFT_ONLY } from './toneMap'; const manifest = parseManifest(wireManifest(), '/d/'); const RAD = Math.PI / 180; @@ -93,13 +93,13 @@ describe('the lighting inputs', () => { ({ sun: { azimuth: 214, elevation }, atm: a, - fit: { display: { exposure: 12, lift: 0.01 } }, + fit: { display: { exposure: 12, curve: LIFT_ONLY } }, view: manifest.view, } as unknown as PhysicalSky); it("takes the display of the sky's own fit, so terrain and sky share one exposure", () => { const l = lightingOf(manifest, sky(30)); - expect([l.exposure, l.lift]).toEqual([12, 0.01]); + expect([l.exposure, l.curve]).toEqual([12, LIFT_ONLY]); expect(l.ambient).toEqual([0.1, 0.2, 0.3]); expect(l.logDMin).toBe(4.6); expect(l.logDSpan).toBeCloseTo(11.5 - 4.6, 12); @@ -193,7 +193,7 @@ describe('the look reaches the shader', () => { irradiance: { direct: [0, 0, 0], ambient: [0.1, 0.2, 0.3] }, radiance: (_a: number, _b: number, o: number[]) => o.fill(0), }, - fit: { display: { exposure: 1, lift: 0 } }, + fit: { display: { exposure: 1, curve: LIFT_ONLY } }, view: manifest.view, } as unknown as PhysicalSky; const one = { ...manifest, cards: manifest.cards.slice(0, 1) }; @@ -258,6 +258,36 @@ function sky30(): PhysicalSky { transmittanceToSpace: (_m: number, o: number[]) => o.fill(1), irradiance: { direct: [0, 0, 0], ambient: [0, 0, 0] }, }, - fit: { display: { exposure: 1, lift: 0 } }, + fit: { display: { exposure: 1, curve: LIFT_ONLY } }, } as unknown as PhysicalSky; } + +describe('night ambient', () => { + const nightAtm = { + observerKm: 0.183, + mieScale: 1, + transmittanceToSpace: (_m: number, o: number[]) => o.fill(1), + irradiance: { direct: [0, 0, 0], ambient: [0.001, 0.001, 0.002] }, + radiance: (_a: number, _b: number, o: number[]) => o.fill(0), + }; + const night = (state: string, nightAmbient?: [number, number, number]) => + lightingOf( + manifest, + { + state, + sun: { azimuth: 0, elevation: -30 }, + atm: nightAtm, + fit: { display: { exposure: 1, curve: LIFT_ONLY } }, + view: manifest.view, + } as unknown as PhysicalSky, + nightAmbient ? { ...DEFAULT_LOOK, nightAmbient } : DEFAULT_LOOK + ); + it('lights the ground at night, cool, and only at night', () => { + const n = night('night'); + const base = nightAtm.irradiance.ambient; + n.ambient.forEach((a, i) => expect(a).toBeGreaterThan(base[i])); + expect(n.ambient[2] - base[2]).toBeGreaterThan(n.ambient[0] - base[0]); + expect(night('dusk').ambient).toEqual(base); + expect(DEFAULT_LOOK.nightAmbient.every((c) => c > 0)).toBe(true); + }); +}); diff --git a/src/app/features/scene/ridge/lightCards.ts b/src/app/features/scene/ridge/lightCards.ts index 3b8d25eb..0a44a421 100644 --- a/src/app/features/scene/ridge/lightCards.ts +++ b/src/app/features/scene/ridge/lightCards.ts @@ -6,13 +6,14 @@ // Per pixel: the normal from the geometry card in the column's frame (r along the ray, t across it, up), the sun brought into that frame per column; // radiance = albedo x (sun transmittance x max(n.s, 0) + ambient irradiance) / pi; aerial perspective L T(d) + Lsky (1 - T(d)) with d from the // geometry's log-distance and the sky's own extinction at the ground; contours; then the sky's own display (exposure, ACES with `toneMap.ts`'s -// constants written into the shader, black lift, sRGB), so terrain and sky share one exposure. Wall pixels (R = G = 255 in the geometry file, a code +// constants written into the shader, the sky's fitted curve, sRGB), so terrain and sky share one exposure. Wall pixels (R = G = 255 in the geometry file, a code // no real normal reaches) are the extruded face under a ridge: they are lit with the face up and wear no crease ink. import { extinctionAt } from './earthAtmosphere'; import type { Vec3 } from './earthAtmosphere'; import type { RidgeManifest } from './manifest'; import type { PhysicalSky } from './physicalSky'; -import { ACES_FIT, ACES_IN, ACES_OUT } from './toneMap'; +import { ACES_FIT, ACES_IN, ACES_OUT, KNOTS } from './toneMap'; +import type { Curve } from './toneMap'; import type { View } from './view'; export interface CardBitmaps { @@ -70,6 +71,8 @@ export interface RidgeLook { groundNoise: number; /** Low-frequency noise darkening of the direct sun (static). 0 = none. */ cloudShadows: number; + /** Night's moonlight on the ground: the radiance of a white card in it (rgb, at the night exposure, before the curve); added only in the night state, where the atmosphere gives the ground none. A dim cool value. */ + nightAmbient: readonly [number, number, number]; } export const DEFAULT_LOOK: RidgeLook = { @@ -89,6 +92,7 @@ export const DEFAULT_LOOK: RidgeLook = { inkScale: 1, groundNoise: 0, cloudShadows: 0, + nightAmbient: [0.5, 0.66, 1.1], }; const RAD = Math.PI / 180; @@ -132,10 +136,12 @@ export interface Lighting { sunTransmittance: Vec3; ambient: Vec3; exposure: number; - lift: number; + /** The sky's fitted curve (`toneMap.ts`), applied per channel after ACES. */ + curve: Curve; } const scale3 = (v: Vec3, k: number): Vec3 => [v[0] * k, v[1] * k, v[2] * k]; +const add3 = (a: Vec3, b: Vec3): Vec3 => [a[0] + b[0], a[1] + b[1], a[2] + b[2]]; export function lightingOf( manifest: RidgeManifest, @@ -153,9 +159,12 @@ export function lightingOf( logDSpan: manifest.encoding.logDMax - manifest.encoding.logDMin, extinction: scale3(extinctionAt(sky.atm.observerKm, sky.atm.mieScale), look.hazeScale), sunTransmittance: lit ? [trans[0], trans[1], trans[2]] : [0, 0, 0], - ambient: scale3(sky.atm.irradiance.ambient, look.ambientScale), + ambient: add3( + scale3(sky.atm.irradiance.ambient, look.ambientScale), + sky.state === 'night' ? scale3(look.nightAmbient as Vec3, Math.PI) : [0, 0, 0] + ), exposure: sky.fit.display.exposure, - lift: sky.fit.display.lift, + curve: sky.fit.display.curve, }; } @@ -206,7 +215,10 @@ uniform vec2 uLogD; uniform vec3 uExt; uniform vec3 uTSun; uniform vec3 uAmbient; -uniform vec2 uDisplay; +uniform float uExposure; +uniform float uCx[${KNOTS}]; +uniform float uCy[${KNOTS}]; +uniform float uCm[${KNOTS}]; uniform vec2 uInkGeometry; // occludeLogD, creaseCos uniform vec3 uInkKeep; // edge, occlude, crease uniform float uInkScale; @@ -247,6 +259,20 @@ vec3 aces(vec3 x) { return clamp(vec3(dot(OUT_R0, p), dot(OUT_R1, p), dot(OUT_R2, p)), 0.0, 1.0); } +// toneMap.ts applyCurve: the monotone cubic Hermite through the sky's five knots. +float curve1(float v) { + float x = clamp(v, 0.0, 1.0); + int k = 0; + for (int i = 1; i < ${KNOTS - 1}; i++) if (x > uCx[i]) k = i; + float h = uCx[k + 1] - uCx[k]; + float t = (x - uCx[k]) / h; + float t2 = t * t; + float t3 = t2 * t; + return (2.0 * t3 - 3.0 * t2 + 1.0) * uCy[k] + (t3 - 2.0 * t2 + t) * h * uCm[k] + + (-2.0 * t3 + 3.0 * t2) * uCy[k + 1] + (t3 - t2) * h * uCm[k + 1]; +} +vec3 curve(vec3 c) { return vec3(curve1(c.r), curve1(c.g), curve1(c.b)); } + vec3 skyAt(vec2 uv) { vec2 f = uv * vec2(uSkySize) - 0.5; vec2 b = floor(f); @@ -329,8 +355,7 @@ void main() { } radiance *= 1.0 - (1.0 - keep) * uInkScale; - vec3 lin = aces(radiance * uDisplay.x); - vec3 rgb = toSrgb(uDisplay.y + (1.0 - uDisplay.y) * lin); + vec3 rgb = toSrgb(curve(aces(radiance * uExposure))); outColor = vec4(rgb * c.a, c.a); } `; @@ -426,7 +451,10 @@ export function lightCards( gl.uniform3f(u('uExt'), ...lit.extinction); gl.uniform3f(u('uTSun'), ...lit.sunTransmittance); gl.uniform3f(u('uAmbient'), ...lit.ambient); - gl.uniform2f(u('uDisplay'), lit.exposure, lit.lift); + gl.uniform1f(u('uExposure'), lit.exposure); + gl.uniform1fv(u('uCx'), lit.curve.x); + gl.uniform1fv(u('uCy'), lit.curve.y); + gl.uniform1fv(u('uCm'), lit.curve.m); gl.uniform2f(u('uInkGeometry'), look.occludeLogD, look.creaseCos); gl.uniform3f(u('uInkKeep'), look.inkKeep.edge, look.inkKeep.occlude, look.inkKeep.crease); gl.uniform1f(u('uInkScale'), look.inkScale); diff --git a/src/app/features/scene/ridge/physicalSky.test.ts b/src/app/features/scene/ridge/physicalSky.test.ts index 8e756f6c..912d78c3 100644 --- a/src/app/features/scene/ridge/physicalSky.test.ts +++ b/src/app/features/scene/ridge/physicalSky.test.ts @@ -3,7 +3,7 @@ import { FALLBACK_VIEW } from './view'; import { ELSEWHERE_VIEW } from './manifest.fixture'; import { sunForState } from './sunAt'; import { makePhysicalSky, paintSky } from './physicalSky'; -import { skyBackdrop } from '../skyState'; +import { ridgeDrawn } from '../skyForState'; import type { FixedSkyState } from '../skyState'; import { windowFor } from './view'; import type { PhysicalSky } from './physicalSky'; @@ -38,7 +38,7 @@ describe.each(['day', 'dusk', 'night'] as FixedSkyState[])( 'the %s sky stays inside its backdrop bounds', (state) => { it('over weather, season and viewport shape', () => { - const b = skyBackdrop(state); + const b = ridgeDrawn(state); let lo = 2; let hi = -1; for (const day of DAYS) { diff --git a/src/app/features/scene/ridge/physicalSky.ts b/src/app/features/scene/ridge/physicalSky.ts index 97346981..f65497dd 100644 --- a/src/app/features/scene/ridge/physicalSky.ts +++ b/src/app/features/scene/ridge/physicalSky.ts @@ -7,7 +7,7 @@ import type { Atmosphere } from './earthAtmosphere'; import { domeSize, renderDome, SUN_RADIUS, sunOnScreen } from './skyDome'; import type { Dome } from './skyDome'; import type { Srgb } from './skyColour'; -import { display8, fitDisplay, holdBudget, MARGIN } from './toneMap'; +import { display8, fitDisplay, MARGIN } from './toneMap'; import type { Display, Fit } from './toneMap'; import { sunForState } from './sunAt'; import type { SunSample } from './sunAt'; @@ -99,7 +99,7 @@ export function paintSky(p: PhysicalSky, cssW: number, cssH: number, camera: Cam const dome = renderDome(p.atm, p.sun, camera, w, h, p.weather.cover); const data = new Uint8ClampedArray(w * h * 4); const out = [0, 0, 0]; - const display = holdBudget(p.state, dome.hdr, p.fit.display); + const display = p.fit.display; for (let i = 0; i < w * h; i += 1) { display8(dome.hdr[i * 3], dome.hdr[i * 3 + 1], dome.hdr[i * 3 + 2], display, out); data[i * 4] = out[0]; diff --git a/src/app/features/scene/ridge/toneMap.test.ts b/src/app/features/scene/ridge/toneMap.test.ts new file mode 100644 index 00000000..b6f0101a --- /dev/null +++ b/src/app/features/scene/ridge/toneMap.test.ts @@ -0,0 +1,65 @@ +import { describe, expect, it } from 'vitest'; +import { FALLBACK_VIEW } from './view'; +import { makePhysicalSky } from './physicalSky'; +import { renderDome } from './skyDome'; +import { windowFor } from './view'; +import { applyCurve, BLACK_LIFT, BUDGET, NIGHT_LIFT, displayLumaOf, fitDisplay, makeCurve } from './toneMap'; +import type { FixedSkyState } from '../skyState'; + +const sweep = (c: ReturnType) => + Array.from({ length: 401 }, (_, i) => applyCurve(c, i / 400)); + +describe('the tone curve', () => { + it('is monotone, starts at the black lift and ends at the top knot, for a spread of knots', () => { + const cases: [number[], number[]][] = [ + [[0, 0.01, 0.2, 0.7, 1], [BLACK_LIFT, 0.12, 0.5, 0.9, 1]], + [[0, 0.0005, 0.003, 0.05, 1], [BLACK_LIFT, 0.0225, 0.04, 0.043, 0.043]], + [[0, 0.3, 0.31, 0.32, 1], [BLACK_LIFT, 0.2, 0.5, 0.8, 1]], + ]; + for (const [x, y] of cases) { + const c = makeCurve(x, y); + const v = sweep(c); + expect(v[0]).toBeCloseTo(BLACK_LIFT, 12); + expect(v[400]).toBeCloseTo(y[4], 12); + for (let i = 1; i < v.length; i += 1) expect(v[i]).toBeGreaterThanOrEqual(v[i - 1] - 1e-12); + } + }); +}); + +describe.each(['day', 'dusk', 'night'] as FixedSkyState[])('the %s curve fitted to a sky', (state) => { + const sky = makePhysicalSky(state, new Date('2026-06-21T10:40:00Z'), 0, FALLBACK_VIEW); + const { camera } = windowFor(sky.view, 64, 36); + const dome = renderDome(sky.atm, sky.sun, camera, 64, 36, sky.weather.cover); + const b = BUDGET[state]; + + it('has the black lift constant at black and every texel inside the state budget', () => { + const c = sky.fit.display.curve; + expect(applyCurve(c, 0)).toBe(b.lift); + expect(b.lift).toBe(state === 'night' ? NIGHT_LIFT : BLACK_LIFT); + expect(sky.fit.lo).toBeGreaterThanOrEqual(b.floor); + expect(sky.fit.hi).toBeLessThanOrEqual(b.ceiling + 0.004); + const v = sweep(c); + for (let i = 1; i < v.length; i += 1) expect(v[i]).toBeGreaterThanOrEqual(v[i - 1] - 1e-12); + }); + + it('puts the curve through the targets at the fixed knots (a night sky carries nothing to fit)', () => { + if (!b.knots) return; + b.knots.forEach((k, i) => expect(applyCurve(sky.fit.display.curve, k)).toBeCloseTo(b.targets[i], 9)); + }); + + it.skipIf(b.knots !== undefined)('puts the sky percentiles on the targets (as far as the gain limit allows)', () => { + const n = dome.hdr.length / 3; + const ls: number[] = []; + for (let i = 0; i < n; i += 1) + ls.push(displayLumaOf(dome.hdr[i * 3], dome.hdr[i * 3 + 1], dome.hdr[i * 3 + 2], sky.fit.display)); + ls.sort((p, q) => p - q); + const at = (q: number) => ls[Math.floor(q * n)]; + const flat = fitDisplay(state, dome.hdr, dome.meanLuma); + expect(flat.display).toEqual(sky.fit.display); + // The curve is fitted on luminance and applied per channel, so the byte luminance is near its targets, not on them. The median is never limited; the outer two are at or below their targets by the gain limit only. + expect(at(0.5)).toBeGreaterThan(b.targets[1] * 0.75); + expect(at(0.5)).toBeLessThan(b.targets[1] * 1.25); + expect(at(0.95)).toBeLessThanOrEqual(b.targets[2] * 1.25 + 0.004); + expect(at(0.05)).toBeLessThan(at(0.5)); + }); +}); diff --git a/src/app/features/scene/ridge/toneMap.ts b/src/app/features/scene/ridge/toneMap.ts index d8a07cb6..1746b595 100644 --- a/src/app/features/scene/ridge/toneMap.ts +++ b/src/app/features/scene/ridge/toneMap.ts @@ -3,9 +3,12 @@ // matrix), then the sRGB encode. A per-pixel function with no state, applied once to the baked sky (CPU: the scene is a 2D // canvas, there is no float render target to fall back from). // -// Exposure is chosen per sky state (`exposureFor`): the sky is physical radiance, so brightness is the camera's, not a -// shaping of the result. Day and dusk expose to the sky's own luminance (adaptation, as an eye or auto-exposure does) so the -// darkest of the sky stays where the state's dark ink needs a backdrop; night is fixed, the physical dark. +// Exposure is chosen per sky state: the sky is physical radiance, so brightness is the camera's. Day and dusk expose to the +// sky's own luminance (adaptation); night is the physical dark. After ACES comes one more curve, per channel in display-linear: +// a monotone cubic through five knots, fitted per sky from the luminance distribution of the sky grid so that its 5th, 50th and +// 95th percentiles land on the state's target display luminances. The curve starts at a small black lift (BLACK_LIFT, the only +// absolute lift) and ends at white (day, dusk) or at the night ceiling (light ink needs a dark ground). It is fitted on the sky +// grid alone: the cards are not sampled, they ride the same curve. import type { FixedSkyState } from '../skyState'; type Rgb = readonly [number, number, number]; @@ -56,46 +59,111 @@ export function toneMap8(r: number, g: number, b: number, exposure: number, out: export const displayLuma = (c: ArrayLike): number => 0.2126 * c[0] + 0.7152 * c[1] + 0.0722 * c[2]; -/** What a sky state needs of its backdrop's display luminance, from the ink it wears (skyState.ts, skyInk.ts). */ +/** What a sky state needs of its backdrop's display luminance, and the targets its curve is fitted to. */ export interface Budget { - /** The darkest texel may not be darker than this (dark ink needs a light backdrop). 0: no floor. */ + /** The darkest texel the curve can draw (its black lift, less one 8-bit step). */ floor: number; - /** The lightest texel may not be lighter than this (light ink needs a dark one). 1: no ceiling. */ + /** What black is drawn as, display-linear: the curve's first knot. */ + lift: number; + /** The lightest texel may not be lighter than this (light ink needs a dark one); it is the curve's top knot. 1: white. */ ceiling: number; - /** Display luminance the log-mean of the sky is exposed to, before the budget is applied; undefined: a fixed exposure. */ + /** Display luminance the log-mean of the sky is exposed to before the curve; undefined: a fixed exposure. */ key?: number; /** Exposure range, in multiples of scene radiance (per unit sun irradiance). */ min: number; max: number; + /** Display luminance the 5th, 50th and 95th percentile of the sky's luminance are mapped to. */ + targets: readonly [number, number, number]; + /** Fixed knot positions (ACES output) for the three targets instead of the sky's percentiles: for a state whose sky carries no signal to fit (night: the sky is black, the cards are what the curve is for). */ + knots?: readonly [number, number, number]; + /** The most the curve may steepen the sky's own spread about its median (display luminance per unit of ACES output): a nearly flat overcast sky is not blown up into a gradient. */ + maxGain: number; } /** Display luminance slack for the 8-bit rounding and the smooth upscale of the baked grid. */ export const MARGIN = 0.004; -/** - * Day and Dusk wear the same dark ink, so one floor: its bound plus margin, 0.4744, which is what the dark link needs (about 0.4554 for 4.5:1, skyTheme.test.ts); a lower day floor (0.317 was tried) leaves the link at 3.3:1. Night wears light ink, and its - * dimmer foldout headers (L 0.386 on screen, rat-crest-a7c95ce-20261111) need a backdrop of at most 0.047. - */ +/** The one absolute lift of day and dusk: what black is drawn as, display-linear. The rest of the range is made by the curve. */ +export const BLACK_LIFT = 0.02; +/** Night's black lift: the whole night range is under its ceiling (0.043), so its black is lifted less. */ +export const NIGHT_LIFT = 0.004; + +/** Night wears light ink, whose dimmer foldout headers (L 0.386 on screen, rat-crest-a7c95ce-20261111) need a backdrop of at most 0.047. */ export const BUDGET: Record = { - day: { floor: 0.4744 + MARGIN, ceiling: 1, key: 0.45, min: 4, max: 60 }, - dusk: { floor: 0.4744 + MARGIN, ceiling: 1, key: 0.5, min: 4, max: 400 }, - night: { floor: 0, ceiling: 0.047 - MARGIN, key: 0.03, min: 8, max: 3000 }, + day: { floor: BLACK_LIFT - 0.001, lift: BLACK_LIFT, ceiling: 1, key: 0.45, min: 4, max: 60, targets: [0.22, 0.58, 0.9], maxGain: 4 }, + dusk: { floor: BLACK_LIFT - 0.001, lift: BLACK_LIFT, ceiling: 1, key: 0.5, min: 4, max: 400, targets: [0.12, 0.45, 0.85], maxGain: 4 }, + night: { + floor: NIGHT_LIFT - 0.001, + lift: NIGHT_LIFT, + ceiling: 0.047 - MARGIN, + min: 1, + max: 1, + knots: [0.002, 0.02, 0.15], + targets: [0.008, 0.018, 0.032], + maxGain: 1e6, + }, }; -/** The luma one 8-bit code moves at the day floor (about 0.0037): a lift step smaller than this can leave the encoded luma where it was, so the floor search never steps less. */ -const CODE_STEP = 0.0045; +/** Knots of the curve: black, the 5th, 50th, 95th percentile, white. */ +export const KNOTS = 5; -/** The display transform of a sky: exposure, then ACES, then a black lift (veiling glare) in display-linear. */ +/** A monotone piecewise-cubic Hermite curve over display-linear 0..1: knot positions, values and slopes. */ +export interface Curve { + x: number[]; + y: number[]; + m: number[]; +} + +/** The monotone cubic (Fritsch-Carlson, Brodlie's weighted harmonic mean) through strictly increasing `x` and non-decreasing `y`. */ +export function makeCurve(x: number[], y: number[]): Curve { + const n = x.length; + const h = x.slice(1).map((v, i) => v - x[i]); + const d = h.map((hk, i) => (y[i + 1] - y[i]) / hk); + const m = new Array(n).fill(0); + m[0] = d[0]; + m[n - 1] = d[n - 2]; + for (let k = 1; k < n - 1; k += 1) { + if (d[k - 1] * d[k] <= 0) continue; + const w1 = 2 * h[k] + h[k - 1]; + const w2 = h[k] + 2 * h[k - 1]; + m[k] = (w1 + w2) / (w1 / d[k - 1] + w2 / d[k]); + } + return { x, y, m }; +} + +/** The curve at `v` (clamped to 0..1). `lightCards.ts` writes the same evaluation into its shader. */ +export function applyCurve(c: Curve, v: number): number { + const t0 = Math.min(1, Math.max(0, v)); + let k = 0; + for (let i = 1; i < c.x.length - 1; i += 1) if (t0 > c.x[i]) k = i; + const h = c.x[k + 1] - c.x[k]; + const t = (t0 - c.x[k]) / h; + const t2 = t * t; + const t3 = t2 * t; + return ( + (2 * t3 - 3 * t2 + 1) * c.y[k] + + (t3 - 2 * t2 + t) * h * c.m[k] + + (-2 * t3 + 3 * t2) * c.y[k + 1] + + (t3 - t2) * h * c.m[k + 1] + ); +} + +/** The straight line from the black lift to white: what a display with no fitted curve does. */ +export const LIFT_ONLY: Curve = makeCurve( + [0, 0.25, 0.5, 0.75, 1], + [0, 0.25, 0.5, 0.75, 1].map((v) => BLACK_LIFT + (1 - BLACK_LIFT) * v) +); + +/** The display transform of a sky: exposure, then ACES, then the fitted curve in display-linear. */ export interface Display { exposure: number; - /** Added to every channel after the curve, then rescaled so white stays white: out = lift + (1 - lift) * aces. */ - lift: number; + curve: Curve; } /** The 8-bit sRGB of linear radiance through a display. */ export function display8(r: number, g: number, b: number, d: Display, out: number[]): void { acesLinear(r, g, b, d.exposure, out); - for (let i = 0; i < 3; i += 1) out[i] = Math.round(encode(d.lift + (1 - d.lift) * out[i])); + for (let i = 0; i < 3; i += 1) out[i] = Math.round(encode(applyCurve(d.curve, out[i]))); } const decode = (v: number): number => { @@ -119,15 +187,16 @@ export interface Fit { /** Darkest and lightest display luminance of the grid under `display`. */ lo: number; hi: number; - /** The exposure before the budget moved it, and what the budget took (for the numbers a report cites). */ + /** The exposure the state's key chose (the curve does the rest). */ keyExposure: number; } /** - * Choose the display of a sky, the one place brightness is decided. `hdr` is the grid's radiance (3 floats a texel) and - * `meanLuma` its log-mean luminance. Exposure starts at the state's key (adaptation); a ceiling lowers it until the - * lightest texel is inside the budget (bisection: luminance is monotone in exposure); a floor raises the black lift until the - * darkest is (luminance is monotone in lift, and linear: the lift needed is solved in one step). + * Choose the display of a sky, the one place brightness is decided. `hdr` is the grid's radiance (3 floats a texel) and `meanLuma` its + * log-mean luminance. Exposure is the state's key (adaptation). The curve is then fitted: the 5th, 50th and 95th percentile of the + * grid's luminance after ACES go to the state's targets (the outer two held to the budget's `maxGain` times the sky's own spread about the median), + * between a black lift below and white (or the night ceiling) above. Monotone by construction, so the ceiling holds for every texel + * of every grid and card, and no pass over another viewport's grid is needed. */ export function fitDisplay(state: FixedSkyState, hdr: Float32Array, meanLuma: number): Fit { const b = BUDGET[state]; @@ -136,83 +205,41 @@ export function fitDisplay(state: FixedSkyState, hdr: Float32Array, meanLuma: nu ? b.min : Math.min(b.max, Math.max(b.min, (b.key * 1.6) / Math.max(meanLuma, 1e-9))); const n = hdr.length / 3; + const tmp = [0, 0, 0]; + const xs: number[] = []; + for (let i = 0; i < n; i += 1) { + acesLinear(hdr[i * 3], hdr[i * 3 + 1], hdr[i * 3 + 2], keyExposure, tmp); + xs.push(displayLuma(tmp)); + } + xs.sort((p, q) => p - q); + const pct = (q: number) => xs[Math.min(n - 1, Math.floor(q * n))]; + const x = [0, ...(b.knots ?? [pct(0.05), pct(0.5), pct(0.95)]), 1]; + x[1] = Math.max(x[1], 1e-7); + x[2] = Math.max(x[2], x[1] * 1.001 + 1e-7); + x[3] = Math.max(x[3], x[2] * 1.001 + 1e-7); + if (x[3] > 0.97) { + x[3] = 0.97; + x[2] = Math.min(x[2], 0.965); + x[1] = Math.min(x[1], 0.96); + } + const [t0, t1, t2] = b.targets; + const y = [ + b.lift, + Math.max(b.lift + 1e-4, t0, t1 - b.maxGain * (x[2] - x[1])), + t1, + Math.min(b.ceiling - 1e-4, t2, t1 + b.maxGain * (x[3] - x[2])), + b.ceiling, + ]; + y[1] = Math.min(y[1], y[2] - 1e-4); + y[3] = Math.max(y[3], y[2] + 1e-4); + const display: Display = { exposure: keyExposure, curve: makeCurve(x, y) }; + let lo = 2; + let hi = -1; const stride = Math.max(1, Math.floor(n / 4000)); - const tmp = [0, 0, 0]; - const range = (d: Display) => { - let lo = 2; - let hi = -1; - for (let i = 0; i < n; i += stride) { - const l = displayLumaOf(hdr[i * 3], hdr[i * 3 + 1], hdr[i * 3 + 2], d, tmp); - if (l < lo) lo = l; - if (l > hi) hi = l; - } - return { lo, hi }; - }; - let exposure = keyExposure; - let r = range({ exposure, lift: 0 }); - if (r.hi > b.ceiling) { - let lo = 0; - let hiE = exposure; - for (let k = 0; k < 24; k += 1) { - const mid = (lo + hiE) / 2; - if (range({ exposure: mid, lift: 0 }).hi > b.ceiling) hiE = mid; - else lo = mid; - } - exposure = lo; - r = range({ exposure, lift: 0 }); + for (let i = 0; i < n; i += stride) { + const l = displayLumaOf(hdr[i * 3], hdr[i * 3 + 1], hdr[i * 3 + 2], display, tmp); + if (l < lo) lo = l; + if (l > hi) hi = l; } - let lift = 0; - if (r.lo < b.floor) { - // Linear in the displayed linear luminance: L' = lift + (1 - lift) L, but through the 8-bit encode; solve in linear then check once. - lift = (b.floor - r.lo) / (1 - r.lo); - let probe = range({ exposure, lift }); - for (let k = 0; k < 6 && probe.lo < b.floor; k += 1) { - lift += Math.max((b.floor - probe.lo) * 1.05, CODE_STEP); - probe = range({ exposure, lift }); - } - r = probe; - } - return { display: { exposure, lift }, lo: r.lo, hi: r.hi, keyExposure }; -} - -/** - * The display, moved only as far as the budget needs, for a grid other than the one it was fitted on (another viewport's shape, - * its own texels): the fit is made once on a canonical grid so that resizing repaints the same sky, and this keeps a texel the canonical - * grid did not have inside the state's bounds. A display that already holds them is returned as it is. - */ -export function holdBudget(state: FixedSkyState, hdr: Float32Array, d: Display): Display { - const b = BUDGET[state]; - const n = hdr.length / 3; - const tmp = [0, 0, 0]; - const range = (x: Display) => { - let lo = 2; - let hi = -1; - for (let i = 0; i < n; i += 1) { - const l = displayLumaOf(hdr[i * 3], hdr[i * 3 + 1], hdr[i * 3 + 2], x, tmp); - if (l < lo) lo = l; - if (l > hi) hi = l; - } - return { lo, hi }; - }; - let cur = d; - let r = range(cur); - if (r.hi > b.ceiling) { - let lo = 0; - let hiE = cur.exposure; - for (let k = 0; k < 20; k += 1) { - const mid = (lo + hiE) / 2; - if (range({ exposure: mid, lift: cur.lift }).hi > b.ceiling) hiE = mid; - else lo = mid; - } - cur = { exposure: lo, lift: cur.lift }; - r = range(cur); - } - for (let k = 0; k < 8 && r.lo < b.floor; k += 1) { - cur = { - exposure: cur.exposure, - lift: cur.lift + ((b.floor - r.lo) / (1 - r.lo)) * 1.05 + 1e-4, - }; - r = range(cur); - } - return cur; + return { display, lo, hi, keyExposure }; } diff --git a/src/app/features/scene/skyForState.test.ts b/src/app/features/scene/skyForState.test.ts index f4512fc3..237c1f5a 100644 --- a/src/app/features/scene/skyForState.test.ts +++ b/src/app/features/scene/skyForState.test.ts @@ -8,6 +8,7 @@ import { ridgeDrawn, ridgeSkyFor, ridgeSkyKey, loadWeather } from './skyForState import { DAY_FROM, setSkyClock, skyBackdrop } from './skyState'; import type { FixedSkyState } from './skyState'; import { skyThemeId } from './skyTheme'; +import { BUDGET } from './ridge/toneMap'; const STATES = ['day', 'dusk', 'night'] as const; const SKY = { 'midnight-sky': baked.midnight, 'noonday-sky': baked.noonday } as const; @@ -91,10 +92,10 @@ describe('ridgeSkyFor', () => { expect(ridgeSkyKey('day', FALLBACK_VIEW, 0.3)).not.toBe(ridgeSkyKey('night', FALLBACK_VIEW, 0.3)); }); - it.each(STATES)('%s: the display is fitted to the budget its text ink needs', (state) => { - const { floor, ceiling } = needs(state); + it.each(STATES)('%s: the display is the curve of its budget: black lift at the floor, the ceiling the light ink needs', (state) => { + const { ceiling } = needs(state); const r = ridgeDrawn(state); - expect(r.darkest).toBeGreaterThanOrEqual(floor); + expect(r.darkest).toBe(BUDGET[state].floor); expect(r.lightest).toBeLessThanOrEqual(ceiling); const fit = ridgeSkyFor(state, FALLBACK_VIEW, 0.3).physical?.fit; expect(fit?.lo).toBeGreaterThanOrEqual(r.darkest - 1e-9); @@ -103,11 +104,8 @@ describe('ridgeSkyFor', () => { }); describe('skyBackdrop holds the ridge sky', () => { - it.each(STATES)('%s: the backdrop bound contains the ridge display budget', (state) => { - const r = ridgeDrawn(state); - const b = skyBackdrop(state); - expect(b.darkest).toBeLessThanOrEqual(r.darkest); - expect(b.lightest).toBeGreaterThanOrEqual(r.lightest); + it.each(STATES)('%s: the backdrop bound contains the ridge display ceiling', (state) => { + expect(skyBackdrop(state).lightest).toBeGreaterThanOrEqual(ridgeDrawn(state).lightest); }); }); From d44bf032caa9b0c12cd9feb6225ee5761608f753 Mon Sep 17 00:00:00 2001 From: Meta Vens Date: Fri, 20 Nov 2026 16:13:05 +0100 Subject: [PATCH 05/24] Ridge look: cel-shaded relief, painterly cel is the default look RidgeLook gains celBands/celSoftness/celBandLevels and a coarse ambient step; DEFAULT_LOOK is painterly with cel 3, PHYSICAL_LOOK keeps the old Lambert look. Sheet presets: physical, swiss, poster, painterly, painterly-cel-2/3/4. Co-Authored-By: Claude Sonnet 5.5 --- harness/scene/README.md | 7 +- harness/scene/ridgeSheet.ts | 31 +++---- .../features/scene/ridge/lightCards.test.ts | 46 +++++++++- src/app/features/scene/ridge/lightCards.ts | 85 ++++++++++++++++++- 4 files changed, 147 insertions(+), 22 deletions(-) diff --git a/harness/scene/README.md b/harness/scene/README.md index c7d42007..9fc5de49 100644 --- a/harness/scene/README.md +++ b/harness/scene/README.md @@ -36,11 +36,12 @@ behind a cell is the app's own (`makePhysicalSky` + `paintSky`, upscaled), witho `looks=` is a url-encoded or base64 JSON array of `{label, ...partial RidgeLook}` and replaces the preset rows (`inkKeep` and `reliefLight` merge by key). A cell costs one WebGL2 context and a card decode, so the full sheet takes tens of seconds (much longer in a background tab). -Presets (`PRESETS` in `ridgeSheet.ts`; every key not named is `DEFAULT_LOOK`), chosen by reasoning, not by eye, for Self to tune: +Presets (`PRESETS` in `ridgeSheet.ts`; swiss and poster take every key not named from `PHYSICAL_LOOK`, the rest from `DEFAULT_LOOK`, the painterly cel look), chosen by reasoning, not by eye, for Self to tune: | preset | values | | --- | --- | -| physical | DEFAULT_LOOK | +| physical | PHYSICAL_LOOK (Lambert, no noise, sky haze, full ink) | | swiss | reliefLight {mix 0.7, azimuthDeg -45, elevationDeg 40}, contrastByDistance 0.9, hazeScale 6, hazeTint [0, 0.05, 0.25], nearWarm 0.5, inkScale 0.6 | | poster | reliefWeight 0.15, cardToneStep 0.25, cardGradient 0.5, inkKeep {edge 0.25, occlude 0.9, crease 1}, hazeScale 4 | -| painterly | groundNoise 0.35, cloudShadows 0.5, nearWarm 0.6, hazeScale 2, inkScale 0.4 | +| painterly | DEFAULT_LOOK: groundNoise 0.35, cloudShadows 0.5, nearWarm 0.6, hazeScale 2, inkScale 0.4, celBands 3, celSoftness 0.05, celAmbientAway 0.7, nightAmbient [0.5, 0.66, 1.1] | +| painterly-cel-2 / -3 / -4 | painterly with celBands 2 / 3 / 4 | diff --git a/harness/scene/ridgeSheet.ts b/harness/scene/ridgeSheet.ts index 6516e98e..d5cf3d00 100644 --- a/harness/scene/ridgeSheet.ts +++ b/harness/scene/ridgeSheet.ts @@ -1,8 +1,8 @@ // Look sheet for the lit ridge cards: the Vienna bake lit for a grid of sky states x looks, each cell a small canvas at heading 0. Not shipped. -// `?preset=all|physical|swiss|poster|painterly` (default all: the four rows); `?looks=` replaces the rows with +// `?preset=all|physical|swiss|poster|painterly|painterly-cel-2|painterly-cel-3|painterly-cel-4` (default all: one row each; painterly is DEFAULT_LOOK); `?looks=` replaces the rows with // the given `{label, ...partial RidgeLook}` entries (inkKeep and reliefLight merge by key). `?w=480` sets the cell width (16:9). // The sky behind a cell is the app's own: `makePhysicalSky` + `paintSky` upscaled smoothly, without the sun disc, stars or clouds. -import { DEFAULT_LOOK, lightCards } from '../../src/app/features/scene/ridge/lightCards'; +import { DEFAULT_LOOK, PHYSICAL_LOOK, lightCards } from '../../src/app/features/scene/ridge/lightCards'; import type { RidgeLook } from '../../src/app/features/scene/ridge/lightCards'; import { parseManifest } from '../../src/app/features/scene/ridge/manifest'; import { makePhysicalSky, paintSky } from '../../src/app/features/scene/ridge/physicalSky'; @@ -14,6 +14,8 @@ const DIR = '/public/ridge/vienna-6815bb9dca99/'; type Override = Partial> & { label: string; + /** The look the unnamed keys come from (DEFAULT_LOOK, the painterly cel look, if absent). */ + base?: 'physical'; inkKeep?: Partial; reliefLight?: Partial; }; @@ -30,9 +32,10 @@ const SKIES = [ /** The art directions, chosen by reasoning, not by eye: Self tunes them (values listed in harness/scene/README.md). */ const PRESETS: Record = { - physical: { label: 'physical' }, + physical: { label: 'physical', base: 'physical' }, swiss: { label: 'swiss', + base: 'physical', reliefLight: { mix: 0.7, azimuthDeg: -45, elevationDeg: 40 }, contrastByDistance: 0.9, hazeScale: 6, @@ -42,31 +45,29 @@ const PRESETS: Record = { }, poster: { label: 'poster', + base: 'physical', reliefWeight: 0.15, cardToneStep: 0.25, cardGradient: 0.5, inkKeep: { edge: 0.25, occlude: 0.9, crease: 1 }, hazeScale: 4, }, - painterly: { - label: 'painterly', - groundNoise: 0.35, - cloudShadows: 0.5, - nearWarm: 0.6, - hazeScale: 2, - inkScale: 0.4, - }, + painterly: { label: 'painterly (default, cel 3)' }, + 'painterly-cel-2': { label: 'painterly-cel-2', celBands: 2 }, + 'painterly-cel-3': { label: 'painterly-cel-3', celBands: 3 }, + 'painterly-cel-4': { label: 'painterly-cel-4', celBands: 4 }, }; const merge = (o: Override): { label: string; look: RidgeLook } => { - const { label, inkKeep, reliefLight, ...rest } = o; + const { label, base: baseName, inkKeep, reliefLight, ...rest } = o; + const base = baseName === 'physical' ? PHYSICAL_LOOK : DEFAULT_LOOK; return { label, look: { - ...DEFAULT_LOOK, + ...base, ...rest, - inkKeep: { ...DEFAULT_LOOK.inkKeep, ...inkKeep }, - reliefLight: { ...DEFAULT_LOOK.reliefLight, ...reliefLight }, + inkKeep: { ...base.inkKeep, ...inkKeep }, + reliefLight: { ...base.reliefLight, ...reliefLight }, }, }; }; diff --git a/src/app/features/scene/ridge/lightCards.test.ts b/src/app/features/scene/ridge/lightCards.test.ts index 3c85e859..f9144a2c 100644 --- a/src/app/features/scene/ridge/lightCards.test.ts +++ b/src/app/features/scene/ridge/lightCards.test.ts @@ -2,6 +2,9 @@ import { describe, expect, it, vi } from 'vitest'; import { decodeNormal, DEFAULT_LOOK, + PHYSICAL_LOOK, + celShade, + celLevels, FRAGMENT, lightCards, lightingOf, @@ -240,7 +243,7 @@ describe('the look reaches the shader', () => { it('scales the haze optical depth and the ambient light, and moves the sun cut-off', () => { const base = run(); - const look = run({ hazeScale: 2, ambientScale: 0.5 }); + const look = run({ hazeScale: 2 * DEFAULT_LOOK.hazeScale, ambientScale: 0.5 }); look.uExt.forEach((e, k) => expect(e).toBeCloseTo(2 * base.uExt[k], 12)); expect(look.uAmbient[2]).toBeCloseTo(0.15, 12); expect( @@ -291,3 +294,44 @@ describe('night ambient', () => { expect(DEFAULT_LOOK.nightAmbient.every((c) => c > 0)).toBe(true); }); }); + +describe('cel shading', () => { + const sweep = (bands: number, softness: number, levels?: number[]) => { + const out = new Set(); + for (let i = -20; i <= 100; i += 1) { + const x = i / 100; + // away from the band edges (i / bands), where a softened edge is between two levels + if (Array.from({ length: bands }, (_, k) => k / bands).some((e) => e > 0 && Math.abs(x - e) <= softness / 2 + 1e-9)) continue; + out.add(Math.round(celShade(x, bands, softness, levels) * 1e9)); + } + return out; + }; + it.each([1, 2, 3, 4, 6])('quantizes a normal sweep to exactly %i levels away from the edges', (n) => { + expect(sweep(n, 0.05).size).toBe(n); + expect(sweep(n, 0).size).toBe(n); + }); + it('is monotone in n.s, from the lowest level to the highest, and softens an edge without a jump', () => { + let prev = -1; + let maxStep = 0; + for (let i = -20; i <= 100; i += 1) { + const v = celShade(i / 100, 3, 0.1); + expect(v).toBeGreaterThanOrEqual(prev - 1e-12); + if (prev >= 0) maxStep = Math.max(maxStep, v - prev); + prev = v; + } + expect(maxStep).toBeLessThan(0.3); + expect(celShade(-0.5, 3, 0)).toBe(0); + expect(celShade(1, 3, 0)).toBe(1); + }); + it('takes the band levels it is given', () => { + expect(celLevels(3, [0.2, 0.5, 0.9]).slice(0, 3)).toEqual([0.2, 0.5, 0.9]); + expect(celShade(0.9, 3, 0, [0.2, 0.5, 0.9])).toBe(0.9); + expect(celShade(-1, 3, 0, [0.2, 0.5, 0.9])).toBe(0.2); + }); + it('is on in the default look and off in the physical one; the shader carries the ramp', () => { + expect(DEFAULT_LOOK.celBands).toBeGreaterThan(0); + expect(PHYSICAL_LOOK.celBands).toBe(0); + expect(FRAGMENT).toContain('float cel(float x)'); + expect(FRAGMENT).toContain('uBandLevels[6]'); + }); +}); diff --git a/src/app/features/scene/ridge/lightCards.ts b/src/app/features/scene/ridge/lightCards.ts index 0a44a421..29745834 100644 --- a/src/app/features/scene/ridge/lightCards.ts +++ b/src/app/features/scene/ridge/lightCards.ts @@ -73,9 +73,19 @@ export interface RidgeLook { cloudShadows: number; /** Night's moonlight on the ground: the radiance of a white card in it (rgb, at the night exposure, before the curve); added only in the night state, where the atmosphere gives the ground none. A dim cool value. */ nightAmbient: readonly [number, number, number]; + /** Cel shading: the lit side of the relief (n.s) in this many flat bands instead of Lambert's ramp (0 = Lambert; at most `CEL_MAX`). */ + celBands: number; + /** Width of each band edge in n.s units (0 = hard). */ + celSoftness: number; + /** The level of each band, 0..1, darkest first (default: evenly from 0 to 1). Length `celBands`. */ + celBandLevels?: readonly number[]; + /** The ambient is coarse too: surfaces facing the sky (the normal's up component past `celAmbientEdge`) keep it whole, the rest keep this fraction (1 = no step). */ + celAmbientAway: number; + celAmbientEdge: number; } -export const DEFAULT_LOOK: RidgeLook = { +/** The first art pass's look: Lambert relief, no procedural variation, the sky's own haze, full ink. Kept for comparison in the look sheet. */ +export const PHYSICAL_LOOK: RidgeLook = { occludeLogD: 0.35, creaseCos: 0.85, inkKeep: { edge: 0.45, occlude: 0.55, crease: 0.8 }, @@ -93,8 +103,58 @@ export const DEFAULT_LOOK: RidgeLook = { groundNoise: 0, cloudShadows: 0, nightAmbient: [0.5, 0.66, 1.1], + celBands: 0, + celSoftness: 0, + celAmbientAway: 1, + celAmbientEdge: 0.7, }; +/** The default: painterly (ground variation, cloud shadows, warm near, moderate haze, light ink) with cel-shaded relief. */ +export const DEFAULT_LOOK: RidgeLook = { + ...PHYSICAL_LOOK, + groundNoise: 0.35, + cloudShadows: 0.5, + nearWarm: 0.6, + hazeScale: 2, + inkScale: 0.4, + celBands: 3, + celSoftness: 0.05, + celAmbientAway: 0.7, +}; + +/** Most bands the shader's uniform holds. */ +export const CEL_MAX = 6; + +/** The level of each of `bands` cel bands, darkest first: `custom` where given, else evenly 0..1 (one band is fully lit). Padded to `CEL_MAX`. */ +export function celLevels(bands: number, custom?: readonly number[]): number[] { + const n = Math.min(CEL_MAX, Math.max(1, Math.round(bands))); + return Array.from({ length: CEL_MAX }, (_, i) => { + const k = Math.min(i, n - 1); + return custom?.[k] ?? (n === 1 ? 1 : k / (n - 1)); + }); +} + +const smooth = (a: number, b: number, v: number): number => { + const t = Math.min(1, Math.max(0, (v - a) / (b - a))); + return t * t * (3 - 2 * t); +}; + +/** + * The cel ramp: the light of a surface whose normal makes `ndl` with the sun, in `bands` flat bands, edges at i / bands (i = 1..bands-1), each + * edge `softness` wide. The lowest band holds the unlit side too (its level is what ambient light alone leaves). The shader writes the same. + */ +export function celShade(ndl: number, bands: number, softness: number, levels?: readonly number[]): number { + const n = Math.min(CEL_MAX, Math.max(1, Math.round(bands))); + const lv = celLevels(n, levels); + let out = lv[0]; + for (let i = 1; i < n; i += 1) { + const e = i / n; + const w = softness / 2; + out += (lv[i] - lv[i - 1]) * (w > 0 ? smooth(e - w, e + w, ndl) : ndl >= e ? 1 : 0); + } + return out; +} + const RAD = Math.PI / 180; /** The sun in the frame of a column looking at azimuth `columnAzDeg`: along the ray, across it (clockwise, +90 degrees), up. Unit length. */ @@ -228,6 +288,8 @@ uniform vec3 uHazeTint; uniform vec2 uDist; // nearWarm, contrastByDistance uniform vec2 uCard; // value of this card, gradient uniform vec2 uGround; // groundNoise, cloudShadows +uniform vec4 uCel; // bands (0 = Lambert), softness, ambientAway, ambientEdge +uniform float uBandLevels[${CEL_MAX}]; uniform float uRadPerPx; // radians of azimuth per plane pixel out vec4 outColor; @@ -273,6 +335,19 @@ float curve1(float v) { } vec3 curve(vec3 c) { return vec3(curve1(c.r), curve1(c.g), curve1(c.b)); } +// lightCards.ts celShade: flat bands of n.s, edges at i / bands. +float cel(float x) { + int n = int(uCel.x); + float w = uCel.y * 0.5; + float l = uBandLevels[0]; + for (int i = 1; i < ${CEL_MAX}; i++) { + if (i >= n) break; + float e = float(i) / float(n); + l += (uBandLevels[i] - uBandLevels[i - 1]) * (w > 0.0 ? smoothstep(e - w, e + w, x) : step(e, x)); + } + return l; +} + vec3 skyAt(vec2 uv) { vec2 f = uv * vec2(uSkySize) - 0.5; vec2 b = floor(f); @@ -327,8 +402,10 @@ void main() { vec3 albedo = toLinear(c.rgb); if (uGround.x > 0.0) albedo *= max(1.0 + uGround.x * (2.0 * fbm(world / 250.0) - 1.0), 0.0); float cloud = uGround.y > 0.0 ? 1.0 - uGround.y * smoothstep(0.5, 0.72, fbm(world / 4000.0 + 17.0)) : 1.0; - float ndl = mix(max(s.z, 0.0), max(dot(g.n, s), 0.0), uRelief.x); - vec3 radiance = albedo * (uTSun * ndl * cloud + uAmbient) / PI; + float lit = uCel.x > 0.5 ? cel(dot(g.n, s)) : max(dot(g.n, s), 0.0); + float ndl = mix(max(s.z, 0.0), lit, uRelief.x); + float ambStep = uCel.x > 0.5 ? mix(uCel.z, 1.0, smoothstep(uCel.w - uCel.y * 0.5, uCel.w + uCel.y * 0.5 + 1e-4, g.n.z)) : 1.0; + vec3 radiance = albedo * (uTSun * ndl * cloud + uAmbient * mix(1.0, ambStep, uRelief.x)) / PI; float dn = clamp((g.logD - uLogD.x) / uLogD.y, 0.0, 1.0); if (uDist.y != 0.0) { vec3 flatTone = albedo * (uTSun * max(s.z, 0.0) * cloud + uAmbient) / PI; @@ -469,6 +546,8 @@ export function lightCards( gl.uniform3f(u('uHazeTint'), ...look.hazeTint); gl.uniform2f(u('uDist'), look.nearWarm, look.contrastByDistance); gl.uniform2f(u('uGround'), look.groundNoise, look.cloudShadows); + gl.uniform4f(u('uCel'), look.celBands, look.celSoftness, look.celAmbientAway, look.celAmbientEdge); + gl.uniform1fv(u('uBandLevels'), celLevels(look.celBands, look.celBandLevels)); gl.uniform1f(u('uRadPerPx'), (manifest.view.windowDeg * RAD) / lit.planeW); gl.uniform2i(u('uSkySize'), SKY_LUT.w, SKY_LUT.h); const sunTex = floatTexture(gl, 2, lit.planeW, 1, sunColumns(manifest.view, sky.sun)); From 18ad84aff5b421d34575050282e4bbecaa07b160 Mon Sep 17 00:00:00 2001 From: Meta Vens Date: Fri, 20 Nov 2026 20:32:24 +0100 Subject: [PATCH 06/24] Sky: one sidereal transform for sun, moon and stars; low-precision moon ephemeris and phase sun.js exports daysSinceJ2000, gmstRad, sunEquatorial and equatorialToHorizontal (sunPosition is now their composition, unchanged in value). moon.js adds the Astronomical Almanac low-precision moon, phase from elongation (Meeus 48.3), topocentric position. Tests against Meeus ex. 47.a and USNO phases. Co-Authored-By: Claude Sonnet 5.5 --- src/sky/moon.js | 88 ++++++++++++++++++++++++++++++++++++++++++++ src/sky/moon.test.ts | 50 +++++++++++++++++++++++++ src/sky/sun.js | 35 ++++++++++++++---- 3 files changed, 166 insertions(+), 7 deletions(-) create mode 100644 src/sky/moon.js create mode 100644 src/sky/moon.test.ts diff --git a/src/sky/moon.js b/src/sky/moon.js new file mode 100644 index 00000000..70b37736 --- /dev/null +++ b/src/sky/moon.js @@ -0,0 +1,88 @@ +// The moon for a place and a moment. Dependency-free ES module beside sun.js, whose sidereal transform it shares. +// +// moonEquatorial(time) -> { ra, dec, distanceKm, lambda, beta } radians, of date +// moonPhase(time) -> { elongationDeg, phaseAngleDeg, illuminated, waxing } +// moonPosition(time, lat, lon) -> { elevation, azimuth } degrees, topocentric, no refraction +// +// Position is the low-precision series of the Astronomical Almanac (section D, "Low precision formulae for the Moon", T in Julian +// centuries from J2000.0): about 0.3 degrees in longitude and 0.2 in latitude, a few hundred km in distance, for 1950..2050. +// Phase is the elongation from the sun (sun.js) and the phase angle of Meeus, "Astronomical Algorithms", 2nd ed., eq. 48.3. + +import { daysSinceJ2000, equatorialToHorizontal, sunEquatorial } from './sun.js'; + +const RAD = Math.PI / 180; +const EARTH_RADIUS_KM = 6378.14; +const AU_KM = 149597870.7; + +const sinD = (deg) => Math.sin(deg * RAD); +const cosD = (deg) => Math.cos(deg * RAD); + +/** The moon's ecliptic longitude and latitude (radians), horizontal parallax (radians) and distance (km), of date. */ +function moonEcliptic(time) { + const T = daysSinceJ2000(time) / 36525; + const lambda = + 218.32 + + 481267.881 * T + + 6.29 * sinD(135.0 + 477198.87 * T) - + 1.27 * sinD(259.3 - 413335.36 * T) + + 0.66 * sinD(235.7 + 890534.22 * T) + + 0.21 * sinD(269.9 + 954397.74 * T) - + 0.19 * sinD(357.5 + 35999.05 * T) - + 0.11 * sinD(186.5 + 966404.03 * T); + const beta = + 5.13 * sinD(93.3 + 483202.02 * T) + + 0.28 * sinD(228.2 + 960400.89 * T) - + 0.28 * sinD(318.3 + 6003.15 * T) - + 0.17 * sinD(217.6 - 407332.21 * T); + const parallax = + 0.9508 + + 0.0518 * cosD(135.0 + 477198.87 * T) + + 0.0095 * cosD(259.3 - 413335.36 * T) + + 0.0078 * cosD(235.7 + 890534.22 * T) + + 0.0028 * cosD(269.9 + 954397.74 * T); + return { + lambda: lambda * RAD, + beta: beta * RAD, + parallax: parallax * RAD, + distanceKm: EARTH_RADIUS_KM / Math.sin(parallax * RAD), + }; +} + +/** Right ascension, declination (radians, of date), distance (km) and ecliptic coordinates (radians) of the moon at a UTC moment. */ +export function moonEquatorial(time) { + const { lambda, beta, distanceKm } = moonEcliptic(time); + const l = Math.cos(beta) * Math.cos(lambda); + const m = 0.9175 * Math.cos(beta) * Math.sin(lambda) - 0.3978 * Math.sin(beta); + const n = 0.3978 * Math.cos(beta) * Math.sin(lambda) + 0.9175 * Math.sin(beta); + return { ra: Math.atan2(m, l), dec: Math.asin(n), distanceKm, lambda, beta }; +} + +/** + * The phase at a UTC moment. `elongationDeg` is the geocentric angle sun-earth-moon side: 0 new, 90 first quarter, 180 full, 270 last quarter + * (by the longitude difference, so it runs the whole circle). `phaseAngleDeg` is the angle sun-moon-earth: 0 full, 180 new. `illuminated` is + * the lit fraction of the disc, (1 + cos i) / 2. + */ +export function moonPhase(time) { + const moon = moonEquatorial(time); + const sun = sunEquatorial(time); + const sunDistanceKm = AU_KM; + const cosPsi = Math.cos(moon.beta) * Math.cos(moon.lambda - sun.lambda); + const psi = Math.acos(Math.min(1, Math.max(-1, cosPsi))); + const i = Math.atan2(sunDistanceKm * Math.sin(psi), moon.distanceKm - sunDistanceKm * Math.cos(psi)); + const elongationDeg = ((((moon.lambda - sun.lambda) / RAD) % 360) + 360) % 360; + return { + elongationDeg, + phaseAngleDeg: i / RAD, + illuminated: (1 + Math.cos(i)) / 2, + waxing: elongationDeg < 180, + distanceKm: moon.distanceKm, + }; +} + +/** Elevation and azimuth of the moon in degrees at a UTC moment and place, topocentric (the parallax lowers it up to a degree), no refraction. Azimuth clockwise from north. */ +export function moonPosition(time, lat, lon) { + const m = moonEquatorial(time); + const { elevation, azimuth } = equatorialToHorizontal(m.ra, m.dec, time, lat, lon); + const parallaxDeg = Math.asin(EARTH_RADIUS_KM / m.distanceKm) / RAD; + return { elevation: elevation - parallaxDeg * cosD(elevation), azimuth }; +} diff --git a/src/sky/moon.test.ts b/src/sky/moon.test.ts new file mode 100644 index 00000000..f4607541 --- /dev/null +++ b/src/sky/moon.test.ts @@ -0,0 +1,50 @@ +import { describe, expect, it } from 'vitest'; +import { moonEquatorial, moonPhase, moonPosition } from './moon.js'; +import { sunPosition } from './sun.js'; + +const DEG = 180 / Math.PI; + +describe('moon position', () => { + it('matches Meeus, Astronomical Algorithms ex. 47.a (1992 April 12, 0h TD) within the series\' 0.3 degrees', () => { + // Meeus: ra 134.688470, dec +13.768368, distance 368409.7 km (full series). + const m = moonEquatorial(Date.UTC(1992, 3, 12, 0, 0, 0)); + expect(Math.abs(m.ra * DEG - 134.68847)).toBeLessThan(0.3); + expect(Math.abs(m.dec * DEG - 13.768368)).toBeLessThan(0.3); + expect(Math.abs(m.distanceKm - 368409.7)).toBeLessThan(1500); + }); + + it('is opposite the sun at full moon, with the parallax of a few tenths of a degree at most', () => { + // Total lunar eclipse of 2026-03-03, greatest eclipse 11:33 UTC: the moon sits opposite the sun. + const t = '2026-03-03T11:33:00Z'; + const moon = moonPosition(t, 48.19, 16.35); + const sun = sunPosition(t, 48.19, 16.35); + expect(Math.abs(moon.elevation + sun.elevation)).toBeLessThan(1.5); + const dAz = Math.abs(((moon.azimuth - sun.azimuth + 360) % 360) - 180); + expect(dAz).toBeLessThan(2); + }); +}); + +describe('moon phase', () => { + // US Naval Observatory phases of January 2000 and the lunar eclipse of March 2026 (UTC); the series is good to ~0.5 degree of + // elongation, which is an hour of the moon's 12.2 degrees a day relative to the sun, so these hold to a degree and a half. + const phases: [string, number][] = [ + ['2000-01-06T18:14:00Z', 0], + ['2000-01-14T13:34:00Z', 90], + ['2000-01-21T04:40:00Z', 180], + ['2000-01-28T07:57:00Z', 270], + ['2026-03-03T11:38:00Z', 180], + ]; + it.each(phases)('elongation at %s is %d degrees', (t, e) => { + const d = ((moonPhase(t).elongationDeg - e + 540) % 360) - 180; + expect(Math.abs(d)).toBeLessThan(1.5); + }); + + it('lit fraction: dark at new, half at the quarters, full at full; waxing between new and full', () => { + expect(moonPhase('2000-01-06T18:14:00Z').illuminated).toBeLessThan(0.01); + expect(moonPhase('2000-01-14T13:34:00Z').illuminated).toBeCloseTo(0.5, 1); + expect(moonPhase('2000-01-21T04:40:00Z').illuminated).toBeGreaterThan(0.99); + expect(moonPhase('2000-01-10T00:00:00Z').waxing).toBe(true); + expect(moonPhase('2000-01-25T00:00:00Z').waxing).toBe(false); + expect(moonPhase('2000-01-21T04:40:00Z').phaseAngleDeg).toBeLessThan(2); + }); +}); diff --git a/src/sky/sun.js b/src/sky/sun.js index 3173eb4d..8936daa8 100644 --- a/src/sky/sun.js +++ b/src/sky/sun.js @@ -29,17 +29,32 @@ const mix = (a, b, t) => a + (b - a) * t; const toMs = (time) => (time instanceof Date ? time.getTime() : typeof time === 'string' ? Date.parse(time) : Number(time)); -/** Sun elevation and azimuth in degrees at a UTC moment and place. Azimuth runs clockwise from north. */ -export function sunPosition(time, lat, lon) { - const d = toMs(time) / 86400000 - 10957.5; // days since J2000.0 (2000-01-01 12:00 UTC) +/** Days since J2000.0 (2000-01-01 12:00 UTC) at a UTC moment. */ +export const daysSinceJ2000 = (time) => toMs(time) / 86400000 - 10957.5; + +/** Greenwich mean sidereal time in radians (unreduced) at `d` days since J2000.0. */ +export const gmstRad = (d) => (280.46061837 + 360.98564736629 * d) * RAD; + +/** The sun's right ascension and declination of date, in radians, and its ecliptic longitude `lambda`, at a UTC moment. */ +export function sunEquatorial(time) { + const d = daysSinceJ2000(time); const L = (280.46 + 0.9856474 * d) * RAD; // mean longitude const g = (357.528 + 0.9856003 * d) * RAD; // mean anomaly const lambda = L + (1.915 * Math.sin(g) + 0.02 * Math.sin(2 * g)) * RAD; // ecliptic longitude const eps = (23.439 - 0.0000004 * d) * RAD; // obliquity - const dec = Math.asin(Math.sin(eps) * Math.sin(lambda)); - const ra = Math.atan2(Math.cos(eps) * Math.sin(lambda), Math.cos(lambda)); - const gmst = (280.46061837 + 360.98564736629 * d) * RAD; - const hourAngle = gmst + lon * RAD - ra; + return { + dec: Math.asin(Math.sin(eps) * Math.sin(lambda)), + ra: Math.atan2(Math.cos(eps) * Math.sin(lambda), Math.cos(lambda)), + lambda, + }; +} + +/** + * Elevation and azimuth in degrees of a point of the sky at a UTC moment and place, from its right ascension and declination of date + * (radians): the one sidereal transform of the sun, the moon and the stars. Azimuth runs clockwise from north; no refraction. + */ +export function equatorialToHorizontal(ra, dec, time, lat, lon) { + const hourAngle = gmstRad(daysSinceJ2000(time)) + lon * RAD - ra; const phi = lat * RAD; const sinEl = Math.sin(phi) * Math.sin(dec) + Math.cos(phi) * Math.cos(dec) * Math.cos(hourAngle); // Hour angle is westward-positive, so atan2 gives azimuth from south, westward; +180 turns it into @@ -51,6 +66,12 @@ export function sunPosition(time, lat, lon) { }; } +/** Sun elevation and azimuth in degrees at a UTC moment and place. Azimuth runs clockwise from north. */ +export function sunPosition(time, lat, lon) { + const { ra, dec } = sunEquatorial(time); + return equatorialToHorizontal(ra, dec, time, lat, lon); +} + /** Sun elevation in degrees at a UTC moment and place. */ export const sunElevation = (time, lat, lon) => sunPosition(time, lat, lon).elevation; From 8c377b58ecb147f4fa15b0c9e7286c9b13e4202d Mon Sep 17 00:00:00 2001 From: Meta Vens Date: Fri, 20 Nov 2026 20:36:24 +0100 Subject: [PATCH 07/24] Night sky data: BSC5 naked-eye stars and constellation lines, packed by a committed generator; star placement by the sun's sidereal transform 2887 stars (Vmag <= 5.5) and 150 line chains, 21 KB packed. Placement precesses J2000 to the date and uses sun.js equatorialToHorizontal; tests hold five stars and the moon to astropy's altitude/azimuth within half a degree. Co-Authored-By: Claude Sonnet 5.5 --- scripts/ridge-sky/build-night-sky.py | 121 ++++++++ src/app/features/scene/ridge/nightSkyData.ts | 271 ++++++++++++++++++ .../scene/ridge/starCatalogue.test.ts | 117 ++++++++ src/app/features/scene/ridge/starCatalogue.ts | 120 ++++++++ 4 files changed, 629 insertions(+) create mode 100644 scripts/ridge-sky/build-night-sky.py create mode 100644 src/app/features/scene/ridge/nightSkyData.ts create mode 100644 src/app/features/scene/ridge/starCatalogue.test.ts create mode 100644 src/app/features/scene/ridge/starCatalogue.ts diff --git a/scripts/ridge-sky/build-night-sky.py b/scripts/ridge-sky/build-night-sky.py new file mode 100644 index 00000000..984548fd --- /dev/null +++ b/scripts/ridge-sky/build-night-sky.py @@ -0,0 +1,121 @@ +"""Pack the night sky's data into src/app/features/scene/ridge/nightSkyData.ts. + +Usage (parse downloads with isolated mode): + python -I scripts/ridge-sky/build-night-sky.py BSC5.DAT.GZ CONSTELLATIONS.LINES.JSON OUT.ts [MAX_MAG] + +Inputs, each in its own directory, never run from inside it: + bsc5.dat.gz Yale Bright Star Catalogue, 5th revised ed. (Hoffleit & Warren 1991), public domain; CDS/VizieR V/50. + CDS was unreachable on 2026-11-20, so the file is the SAO Telescope Data Center's copy of the same + catalogue: http://tdc-www.harvard.edu/catalogs/bsc5.dat.gz (fixed-width, CDS V/50 `catalog` layout). + constellations.lines.json d3-celestial (Olaf Frohn), BSD-3-Clause: + https://github.com/ofrohn/d3-celestial/blob/master/data/constellations.lines.json + GeoJSON MultiLineStrings of [RA, Dec] degrees, J2000. + +Stars (stars cut to Vmag <= MAX_MAG, default 5.5), 6 bytes each: RA uint16 (360 deg / 65536), Dec uint16 ((dec + 90) / 180 * 65535), +Vmag uint8 ((V + 2) * 20), B-V uint8 ((B-V + 0.5) * 50; missing B-V stored as 0.65). Little endian, base64. +Lines: per chain a uint8 vertex count then that many (RA uint16, Dec uint16) pairs, same scaling; chains concatenated; base64. +""" +import base64 +import gzip +import hashlib +import json +import struct +import sys + + +def sha256(path): + h = hashlib.sha256() + with open(path, "rb") as f: + h.update(f.read()) + return h.hexdigest() + + +def ra16(deg): + return int(round((deg % 360.0) / 360.0 * 65536.0)) % 65536 + + +def dec16(deg): + return int(round((deg + 90.0) / 180.0 * 65535.0)) + + +def stars(path, max_mag): + out = [] + for line in gzip.open(path, "rt", encoding="latin-1"): + if len(line) < 114 or not line[75:77].strip(): + continue # entries struck from the catalogue carry no position + try: + ra = (int(line[75:77]) + int(line[77:79]) / 60.0 + float(line[79:83]) / 3600.0) * 15.0 + dec = int(line[84:86]) + int(line[86:88]) / 60.0 + int(line[88:90]) / 3600.0 + dec = -dec if line[83] == "-" else dec + v = float(line[102:107]) + except ValueError: + continue + if v > max_mag: + continue + bv_text = line[109:114].strip() + bv = float(bv_text) if bv_text else 0.65 + out.append((ra, dec, v, bv)) + out.sort(key=lambda s: s[2]) # brightest first: a prefix is the brighter stars + return out + + +def pack_stars(rows): + buf = bytearray() + for ra, dec, v, bv in rows: + vq = min(255, max(0, int(round((v + 2.0) * 20.0)))) + bq = min(255, max(0, int(round((bv + 0.5) * 50.0)))) + buf += struct.pack(" 4 else 5.5 + rows = stars(bsc, max_mag) + star_bytes = pack_stars(rows) + line_bytes, chains = pack_lines(lines) + text = f"""/* eslint-disable */ +// GENERATED by scripts/ridge-sky/build-night-sky.py: do not edit. The night sky's data, J2000. +// Stars: Yale Bright Star Catalogue, 5th revised ed. (Hoffleit & Warren 1991; public domain), Vmag <= {max_mag}, {len(rows)} stars. +// source http://tdc-www.harvard.edu/catalogs/bsc5.dat.gz (copy of CDS/VizieR V/50), sha256 {sha256(bsc)} +// Constellation lines: d3-celestial constellations.lines.json (Olaf Frohn, BSD-3-Clause), {chains} chains. +// source https://github.com/ofrohn/d3-celestial/blob/master/data/constellations.lines.json, sha256 {sha256(lines)} +// Layout: see the generator's docstring. Stars are sorted brightest first. + +export const STAR_COUNT = {len(rows)}; +export const STARS_B64 = ` +{wrap(base64.b64encode(star_bytes).decode())} +`; + +export const LINE_CHAINS = {chains}; +export const LINES_B64 = ` +{wrap(base64.b64encode(line_bytes).decode())} +`; +""" + with open(out, "w", encoding="utf-8", newline="\n") as f: + f.write(text) + print(f"{len(rows)} stars, {chains} chains, {len(star_bytes)} + {len(line_bytes)} bytes") + + +main() diff --git a/src/app/features/scene/ridge/nightSkyData.ts b/src/app/features/scene/ridge/nightSkyData.ts new file mode 100644 index 00000000..d24cb3e8 --- /dev/null +++ b/src/app/features/scene/ridge/nightSkyData.ts @@ -0,0 +1,271 @@ +/* eslint-disable */ +// GENERATED by scripts/ridge-sky/build-night-sky.py: do not edit. The night sky's data, J2000. +// Stars: Yale Bright Star Catalogue, 5th revised ed. (Hoffleit & Warren 1991; public domain), Vmag <= 5.5, 2887 stars. +// source http://tdc-www.harvard.edu/catalogs/bsc5.dat.gz (copy of CDS/VizieR V/50), sha256 0471ced07fc241e625613baa689b2fa5f4b59fd733f731003e57d2d436036cdb +// Constellation lines: d3-celestial constellations.lines.json (Olaf Frohn, BSD-3-Clause), 150 chains. +// source https://github.com/ofrohn/d3-celestial/blob/master/data/constellations.lines.json, sha256 294f66bef5d5cf50b1e17f16d2efa1d97a15131612c68dd935adef6e7373e13c +// Layout: see the generator's docstring. Stars are sorted brightest first. + +export const STAR_COUNT = 2887; +export const STARS_B64 = ` +B0g5aAsZQkQONRogHphImydWX5x6KSg8kcYotykZTThrwSpB6zdVdCoYp1FuhzAuXxGZLjERJD+IijJ2A5YjKjQOstOcjDckDTF6lzlm5a9oWj +t0JY8gcDwOuVLbpz9L6vTfVT8efIgcK0EOs9xlwEEeu4RCJkMNYJx6KUNFKGwFkUMUbErLVkYPioXFLkloT7s7S0kOzTkHiUkOAjqvqEkSWWLZ +HEoZxTtKfkoQu4RCJksMIew2PUsSm4mWz0sYB1etPEwOUyTpxkwx/3XS10xOKUx2Wk07TMQZT00YVlldK01ZHpMixk0Q+LvZQk0t6z/sv04aUb +PUHU5htEZSl08Z5dlPL08PSF0xMk8bCUR2ZlAO0VBarVAa52Svc1BhnBZeoVBSlKrdpFAe/Rrz/lA308mZWlAOwAdrZlFMlDw8fVEPfgFfqVEU +ZgyoslFo0z0/clEQhZZGTFFMWZ526VJii7vckVIgQfJSPVJpdCE/ulIWDn65lFMeYYdeOlMYSdlAuVQ7bGE6QlRsNAdo0FVUBjuTf1UOK6b+pV +UYZr86yVVl+FUbR1UMCmOyK1UiBxYzvFVeogEf1FUq7I4dzlUalrM6T1ZSwpH1M1YOypyaPFYPpZsLRFYQuqrTX1YTqXUv0FcYrATVQ1hQ2+cL +jlhm47x9SFgOAfbwp1hsLreiaVkc535dzFkZTuMC2Vkk805TVlkVjN1QsFlMFQpZ1lkSLvaflVoX7mPDMVoQaCDQhVtripS/PFsO13cwnVsfRr +H4cFsaJzunZlwkz4INZ1wUfIHcN1wTIsuBVVwdOG44nFxSBqOnclwU8z/stFwVoqvVY1wWYRSXnV0gYjyKT10THYa5Xl1G36cjiV1UQg+q1V4g +Y5Qqml42vZ+nQl4OzDQrr15m+3K3OV5GnIasHV4Pzbr1Sl4Ot009S15qVZ2Bpl5KvMOUVV5e5NIYj15lOK2+el9o7658119GVI7JS18bYZ4vaV +8gTnJrJF8OojuYd18NCrCQnl9IEL1+hl9TP6ZzRWAPuzbEeGAgvrpiymBKlAQhEmA4sYJyLGAOrVZvXWAuArLyrGA5+cTYW2BNDLHeV2AMWgKY +lWEODouWj2FIWzp5YmFCoClYrWEfzqnJJWEo1bkGMWFiHRVvKGEn9e1MKmFecShIomEUqtIvwGEYXegQaWEoFUQEoGJr0VBarWIbSSrnuGIQXa +NSHmIZdqrcWmIQb66aW2IgZ8wZYmIqfk/Ki2IU9ol/tmITnOUTeGJC2iAYzGM84UgEOGNVUPL7qmNEUSrJbGNoT4WCaGMW/roQOWMQsuuLf2NK +z0e9o2RfJ2jPoWRBrzVTvmQ0CMG7VGRLocu3k2QaCBfCsWQgBzwRnmQQzYHUX2RcCI4LX2RHoif2w2QSYGh0I2QnDXdJv2RSluncSmQTnEM+VW +QQNEsaXmQVCZt7tmUiy73uRmUyxhjDe2VgfZOXQ2UQo24Fu2VoOogiH2UQr6Mp5mUc5sw64GVL47PjSWYPIdDDp2ZSEtn6amZALl90iGZLfXP4 +aGZYIsO3S2ZnA9y9PGZLZT4hTWZTvmPpsGdmjWXiLmdmsntfJmcX2p8eRGcPF7VeMGdp3F9TxGciAbhTo2cdArhZtGdhfjakumcQt0aRQmcU12 +V+yWcw5bZ13WcTHsidWWcUhzPmiWgwTjYvYGhi5JyXI2gl67RVjWhSTeL9qmhKMr5RS2hUVPxo7mhMzaMwRmgOWNfUfmkWGOVa5GkOsR+tRmkg +ZihqFmlq7a1TeWlJe8p9rmkW3U9qQmlkysPge2lI/gbjq2lZtjC3MWkUkUjoJ2kkd5YNWmlRP7lyXGkOYvR/aWkcpUICoGppuaALXGpub6Tc02 +pTwAuOPWpGojfzaGoUvoIc0WodHG1kHGoVXHBFKGoU58ulWGpUfreBQmstblOkXGtX3XfxlWsY2bnRL2sS1L8ZcmtKOy0mJ2tGmezG0mtorzmX +fGsQDUhXkmsut1pa1mtDM89uhGsp1pAnf2seCKRxQGsQVhSN2mwSpl0hiWw744nUhGxo7CA9t2xswy+SlmwitG3FKGxmCvJnj2wUtg9kQmxoGh +QRqmwyeJO2RGwOL6LnNWxHsKpkSWwOmL1sp2w+U93YIWwhY93y121Huwg50m0182EjLG0Qom1NoW0ox8sOeW0UMgyEcW1TtW0IvW0a58hyr20Z +CB2ahG0eyirDkW0T+UpFWG1ww1SmNG0QwqJhr21IHdW4m21onngRr25f8Ld3lG5hjvP9om5ITPMEN24dgBJVaW49WaBxuW5KzMSfPm4QQ8r7YW +5URVgQjW5jUWcRjm4y+GvXl24YgPMm3m5OwS9Hm29MP05Dn28q0qgfe28XS7Jat29He+zQiG8dsCcdcm9HlTsgjm8QHGpkMm8VM3uxUm9IBLwZ +am8mrj3ram8eyJh/Pm8QdANzc29WRRi9Nm8T2S3uT28Txnj7am9R4KNtTG9m4tbgIW8/bBEoxW9ZkVKyom9I+LPuSW8PvsNw528yi9gobm9I4k +2Gl3Ae/poxq3Balab8V3BezIMYKnBg8A5cdHBOaSTXjHBGdzhEdnAUPT0SYHAwYklMsHAepWAQw3AZdWVyRnArtlIASnBwjWxubnBMWX6CgnA0 +RBDTlXBKf1y8NHAQEos+GnBUX7TAQ3Be3bqyKXAUd73zI3BUrfUyvHAUOB7FpnEUvSg1onEUAtzBlHEvcX0ZIXEhLy45lnFKaIfwfXErHZaO23 +EWFN/dLHFYkwamzHEP36amVXEQLsHCOHEVA/fjYXFWm2Wv2XEqNqjulXEcFV3NUHIQaIfwfXI58qRkqXInIedNaHIpeCMOYXJqxTP4h3IQC2gZ +J3JWY/irhHJHnRSaNnJE+idLonIUmr+YqXJIXD/Za3IqhX3zw3JUCalehnIggNQciXJEUDR4g3IQ6j80zXJLjp2xgnIY4OB5vnJsoeIbtnIs0R +NNcXNS2yWMcnNF81NLRnNNT8GajXMf1STXjXMUvuQgYHNLBfQ4dXNrxjVrunNWvWAEPXNVkK49m3Mm2b3Zg3Mb2b7i0HNU2u8U03M3WR5+z3Nt +vi7ymHNKUDsgJ3NChLMILHNoYOfvEXNL6usLpHMvCSiOvHMu6VnwIXNSgMsUYXNMtc3my3NJYdyhlnMWz91+cnMZO/CDx3MaOUy8G3RNLXRMLH +RIZktBnXRAPk+Ip3RM88+RyXQgwtd5wnRZsCHLv3RKEWn203QoOG43nHQ5MKb8jnQmMKb9jnQmWbxuwXQQOTxNfHQNdT5OYnRKTm8OaHRj/TCI +VHRKWmNXtHQcn291LHQoKrDSgnQaF9NbmnRgA/wSwnRM4SfrrXUcJXSpsHVNB5UfRHUP152VD3VgV8HnqHUYO9Pv43VGvy+zlnVIjlynPXU8H1 +/AKXUUTHFpO3Uo63qa4nVqmadlpXUZN8T1nnVUhO4GfnUW3CfUI3VSvT1fN3Ui7kNyUHVFTU3sWXUQSW0YRHUcgHA8jXUSCapGlnUxaa1tJXVQ +QsZGdHVcKC3ZQ3VQtIb2OnUcVb/6tHVccsIMYnUkFwrBtnUgJSLGVnUzJiinonUWdDGoa3VQ4jqNTXVSoEmbXXVwxoVpGXUS9IVA43USGZVHQH +UPH6KvOnUWrAHwPnZMjmJKg3YWYWn8pHZWMJD0R3ZU/Zzzd3YsHapzVnYPXR9Yc3ZQEXmAMnYSioMNf3YaLa7dwXYSnbDKD3ZGrdTlsXZM5Vlx +enYY/9NugXZGLfemP3ZMOiuEiHYahF2EPnYZFmdffnZb3HYgLHZW/ISPOHYQUab3anZMKAxtMXYVY7X7q3YY0OJ2h3Y0IDE7e3cPAFJqcndMhc +6eZnckqQTgQXciR13RmXdPlnn5jnctf9+MuncaORA1OndK+x4Jy3c+hUadZHdOGlK9GHdN7I4czncgD6ksUHcX8PKDoXdO8S6eT3dk2T8bQ3dS +3EjEUXcOdFLSVnciEoKFNXcS4KuaYncXcNVOGHcYfT6tt3dSdlzITXdIHWBsu3cvAWJfJ3cQHcArhHca6s48RncU3+8jQndMa/lpY3dQ8hX/5n +gYpEITd3hbqU1ZH3hAFdjcw3hlb/gtLXgtVhUFYnho6h4LOXiCb2CSIXggAW+2Fngqy5w/SngQaRgjsHgaUV6XWHhYJ480znghAatK03gzzaxS +ZHgbp8dqGnhSsc7FQHgUj9owq3gtfPOrbHho4f/CiXguwTJfe3gSo13nqHhMf4HUXHgpMq6rOHhPmspulXhP98rWd3hQC+bXwHhG9PDVf3gU8T +X21XlHfH1JiXlktYmuLnkQ+MCOg3lEPdsTkHkSfCrmsnkaNSzbw3kYxyxGdnkqR4P5JHkQ1smAvnlonSGPxnk2F3mTiHkW/ZgeSnkY0Jm+yXky +Epy0OXkSGJ35TXlckqGaP3kQagiDonlRDlFApnlmQrVlNHlibhIWyHkXWhx3gHkOsDQ4k3lSokngbnlgoViaEnksOl1YQ3lEdpN3lnllHaNfLH +keD+F9Z3kYIGbDK3oaS3X5ZXpQwnnZZnokLph3d3oz7eMqnHpQvOeY03qONRHjuno0MxlaHnoabSBmXnoh5Ts2jXpIqqjNmXpqkBxRR3pMXxzp +HnoWfSVmknpRbFMMPnoQ+XA0EHpomn39KHpGIINYH3poh6avIXpUWswXSnobc8wMSHpVjN63WXpr9e/HQXpoMR0DxnoybEC4jXohVkvEaXoTJ2 +nianpH7YBrjHpKffX5NHpKIMU2OntMftR0RHtP8Od4pHsuge2vtXticPwAiHsyUS3ZxHtIlznldHtJB1zcQnse26WZrHsSh90PXHsuhPwNv3sV +JkW+nHsSx0xMf3sYOYEbJHsqkqk1aHtMPao5pntW2/JCDHsj3gWA2XsgvEAVoXtCB1wciHsZIrHcTXtoqe3udHtKyyiETHtIBbqeXXsn5fGJWX +sUPCgPonwW2E80rXwpP5iLwXwddZMBT3xkoJdjcXxcHsg4nXwwV+0g0Xwn+PJPkXwyzjp1iHwSxlR1X3w9u7BavHwYKyU/1XwtlDw8fXw5oG80 +tHxGnfS4UXxKKfgTc3xQLS+0n3wgscN05XwUY8g/eXxQSMmOJ3wSmNqX2Xwjc92wq3xOs+QJI3wy4fdld3xnkQO8I302VB5/tn0qfSaKxH0WVC +jvXn0uypIBUX0s16uoS30QP7CkTn0R17Ks9H1GqNPPrn10GeMGuH0fUuggxn0TJVSWO30SU7LBEX1Oedg1bn1OOQys+n1WWwwww30WIRonPH0S +LR1KbH0ShC3GNn0oMDGvun1WATFzjn0iZVlsvX1mu1/dkH0gfm/QU31iOpqn631hvRIGjX1J/T9UwX1vQ4MzD30TAIbRun02x4ylp301oJUygn +0eOqzov30WsrywbX0dUx1ijn0oiyO/Qn08AiY7YX0UczHKkX0f9jaMc30QBVeqPH0OgInbRn0k5YsGOX0QS6PpO30Vod3uln1N0OtGbH0WMQs4 +i35JVxoIjH4WjiaSgH42WC9yoH4mLTKmoH4SXlIUqX5RqHHrMH5NvX7GT34UNLBfaH5H9OMOaH5GjvYaQn4uTvoSiX5O1iucx34abi2ljH4WMy +9/mX4cRzRa3n4a0DhCbX4MmGap835jMrqFVX4t1bsNSX5Qy85JQH4qFOjt1n4zV+vp234qcewvr34wRPD/UX4aHfyJvX4UCSjMon4UBV3VhH4P +53vUfn5Lscl6tH5tt9dz0H4eawo/Vn4RpGWqoH5mtIX3aH4sW6QotX4o2zEFZH5qrE+xjH5glF27bH5GK35HJX4SHpoBCX5ahJ4GQn4S1aej7n +4b/KtSYn5DJtxtfn5IpAxvzn8ishXug38aqkWxXn8NjlwBK38UioD0JX8mcYlkOn9e8pjOL38fxKZ1Q39gCbm6bX8aiMNKs39U3FbBe39K4WIq +Ln9qpJUkP383LKMfVX9QDLrjhX9k/ucHUX8W6uesmH9UsR+tRn8dESIOnH9MSz2CIn8kvELzqX9ML0oW039EvlZpHn8UAVnNEX9TjGbOOX8i/Z +l2P38uhsFzJX8kjwb0r38StQdGLn8ZcCVCxH9cgCtnn39OqjOojH8asDeYbX8UkD/RTX8Q8l1NiH8XyoQ0qH9SaZZvRX8Qj8GanX8RD7sk+38a +IcSLKH9j9sd7tX8iXMjbmX8glM07tn9YMtErfn8V6+/Zw39tnAV2Jn8W2wavqX9EpReUjH9G8UIFTn9L+0m+Z38WEmw3jn9izNGemX9A99HamH +9OSdXUTX8SMvs2Sn8UDztxmoCAcIwfeIAYRbR1joAVEjQ+eIAmOEaoNIAYvFVRg4BYXHXyQ4AeEbn5YYAsHc2st4AS6taF7oAWiOP7M4AihPjw +coAS9/mkYoBi3Ui9M4BH/k2CXIAS8FahZIAShKD5goBNTOrKMYAn2PlJoYA3NBQmPoBohjt+jYARAD/WnIA2pkwDq4BYBVX2OYAQkXjXrIA2Rp +48WIBfzLoipYBhvL/vqoAsvfY364BBrvi7UYBSWQByd4BqLApNoYBINCjJboBqWUEAlYAQv3WznIAcbpnOR4AQIps9OIAQea/AZYAn0t3ZeIBs +y+/4f4AsqAjJioFkYi0ddYFCvEYQZoFSppyGk4EcQqh1ioE3k9nHrYFcD91wlYEpL+OhsYEU2+5HyoFMmgISZYFsCBLNh4FdmS2pK4FPOkSIho +Ei1VedRoFUOVzAhIFWIMphIIE8xc8Uo4Fk4TF2RIEqhTceb4EUuFBKYIEyWlenR4FqoljcS4EkBGBURYE5/nAkLoFqznJ0DYEQYbB4YYEgUMDb +gYEabs1T6IFYutB+ioFUDx7pUYFKsjcRhIFUYmQ8pYFWbX7BP4FagJtNqoErwevCR4Fe3/H4voFcAfQ+UYEXWh2WZYExniNQqYFmzigw3YF32j +RyzIEYEzVwgoFfgkhug4FQTHjOeoEkcIHzN4ESgK9ePIEWhfY7XoFGH0I1lIIQfUPs04IaAkWqUYIQlGFkyYIm6mC+GII3/WsgsoIiaHeJX4Ia +JdFsx4Ish++aI4IYWi82loIm0kfQkoJT5kx/PYIpB1S6SIIQo11DL4IQFGx4f4IXgJ/ReYIpk+I7joIyIu17uIJe7vxQa4IX2UVtioIZkVHhWY +IQN1McW4IWMWYHyoIaYm5LMIITjnQyo4IaEpPTmIIx9K6AY4JMROFvXIJqKOwVUYIcz/yIgoIj/P+8IoIVvQzLqoJQ2h2YqYJQ0yqYJ4JsoDCq +VYJKMT4eMIJQM2XeTIJhKKSiK4Ii1tWH4IJbKt0oNoImZd3j0YI0teHTb4JIG+X8YIJGFvBUvYIUQgNQtIIcgBrc34IfEz65t4JI/2bHKIIWu5 +j7bIIgY6f5m4Ibi7nUtIIYytRbWYJiI9iOp4JYlPZhjYJokPdExoIo2whsuoMSfh7csYNnA0Cge4NWT1FEToMU3X3BnIM0sY5DKYMS7443JINE +/8GkPoNMw93ls4MUBvZuhYMTnAVzJoMg8werxIMWrhXY5IMhUSW804M1kTh2r4NYO0ZWX4MW908TkYNZu5enyYMjyqBTpoNXLKLaY4MVHqSUS4 +MSYaYPQIMQEbrEeIMsyr1rWINBAP/G0YNWHjaJTYNVrkp67YNdFmbDs4NHeJ4qm4M/Vq6gXYNDLOHDw4NohPolkoNIqgBYZ4MWciqtKINqKWGv +toNNIWZQ44NA4ZMTUYMS+5mvP4MSdOdr5YNQTTzchYMUsGVQfoMeJ268MYNqaHLcKYNuL6/1k4MZcMGHV4NIU+WeoYNqaO4vwoMUBu9dxoMeCP +7+V4MamCa4RoRN0D5Fp4QYbmE5W4RoMGnMPYRVyryc5oQuLNQ/ooQWztWXWIRsWQd1PoRKnSfuSoRVGzpnhIQPoDseeYQQaFKXV4RqQ2njzIQa +iKn6W4QW26xIWIQRrLvcPYQYvMk0oIRAJ8xnRoRQV8513YQamt6JpoRCy+/4f4Q5H0X/dYQUe1x824RUL2UPfIQwlGtrbYQUwHQuS4RMk3c3Ko +Q02ozHKoQVYJ0gmIRKkp/E3YRogaTpSIQZMdGcXIQWAfnDoYQi8wDhd4RNCgMDt4Qc6S2Hx4QbT1XVZYQdf3Y4J4RMh85PaYQeXNsisoRpMBSI +hIRIAzuddYQMklHhWYQ5GV22dYRDzWLKSoQwg3vTMoQVt4nhK4QSE6avcYRMXalfvIQ1ELx0dIQeFsDAeoQs/8n6hYQiEwoq1IVJ3B9ZnoUb3B +9ZnoUbAiJVuIVQ9Chy5YUaskCknIUnGlRwOYUOOnZuioUqCXjYoIVs0agTpYVBS6vULYUlnK8YdIUiUPFOyYUl4jW0noUhnU1YWIVpak/9xYUY +9VCnV4UUF4chR4UVU6d7QIUtEKlgW4UWDMA2hoUYTcFrjIVJlMVtJ4UU9cXSQ4VMh9V4p4UiHA32ooVNjCn+XIUSrzAclYUmbTRvjoUe9D5FJo +VOt0m9koUoIFD3U4VIP4ipL4UR9pLaNoVJz5MM3IVoPav8OYVHh7OqcIUwergJtYUcNsOKWYVsFPYvx4VOtAzqnYVMDx1np4USpyrYXYUSSUcS +joUMM02FWoUQ7E3BS4UUB12InoUaim8GLoUyjnHUK4VjKIBoiYUg+oagdIVWkoeTOoVQ6ZHEzYVrGsl21IVUYs97gIU3Ke/1gYUYmv/Bo4Voex +PNcIUqOSVpxoUUGEHCaoUc8WFU2oUqEqcPT4VKA8DSl4VYO+AfUoVGfOfNyIUTJTbolYYW40lcY4YsjVUFfoZk1machoZbSa4UEIZuNcRLc4ZI +a9AS44ZAnNvelIYemOZQZIYQbxTKH4ZIIhZVVoYQZi/slIZKpjGjloYgWV8ENYYTIGT+VoZH22Q4YIZSHYhFKYZOWZAad4Zq5cDuVYZAq9Hiqo +ZK1+FojoYmtubUdIYiROs9L4ZOQuvvfIYWavI4ZYZeGfcPYIY5yB9ouIYc8x+rjIYTelHtW4YUtGpwi4Zp23sPcoYVe3yWToYWy5C1xYYfMcVI +a4YcmNSYWoY+sxA91IZL4xmBx4ZmUC2TuYZMvDgHuYY4+DjLYYYWnzpyfoZoQ1MLPYZOAWGtG4YSjXF5rYZCQ3RsvYYWyIsTO4YS6pRsJYZQUN +QIjIZOMOM+UoYcV/T194ZgQPtBYoYakvtkQ4YdOSV9JoYtUDZDLoYzVledbYZI0mMSW4Zq6X35IIZmxYAqJoYV6aAVPYYS0qvBP4YkhMcgc4Yq +pgWKzYcUcSXIeIcUpCh+SocYNDl0f4cQS33mZYdKyY2zuYcoIJSXUocSRLTAQ4cySbhdf4dSst45c4cpvuZL2IcolecrZYdF2efgqIcxRw/k4I +dOAjRElId1aD4OtYdqRm8QsIcmD3CcGYcbqXV3fIdqr4NOmYdM8I31ZYc84JP8sIdsdacDZIdoUdD/sIcS+N+Vw4cWHPNC9odYEPxMP4cdLxRw +m4cXChtRaocwaRz/QoccaB4gYodGTx49FYdcXlfdQocik3B+uYckGZf/M4dINZgNyYcjl6eiTocSOMshRIcYpfje4IdD2wfpcIdMIQ7Gpoca/C +Cl0IdMJzvIrYcqRU1ZO4cU71bQKIcudGAu4IdmjI9IaYdQrKDGw4c5HanVnYdmKqt5wYcUQ6zls4dM978gXocXAtnabYcWqdvXKYcnmfY4pIdc +lgWXOocabAlffodoakhui4dfqVy0PIcfV2dyXocTuXq6e4dmBJm8P4cocJmHWIdacavTb4cwhLy4OYcty8Uh0Yc3jc1rnocW99UKSodgGjAHl4 +giBjQytIhgkDt2d4gMqD6jgoheu1fxTIgUvHhOtogfeorCmIhn661OV4gaPrmdH4hWDNhlpIgQd9qqZogszd4gv4gSSQBlEohY9xSOoYgnpynM +e4hIUjUrbogm/kZtvIhWn03XXohu61TbVIgghGP4bohI3GeBWIgyLW6xm4gwqolvcohpCbBIXIgUFMi9I4gjaezi5ohHce0yRYhBn++thohOF/ +KuqYgYmQK8nIhoegfWx4gU0SJ0c4gkLygW2ohB8y7PmIggPzy9dYggWkOW4oga2WF634gypGNocohIRYRUyYhE8YtJp4hjYY1wH4gVzI3Hh4hs +57vJ4YguuP8VyYh09wQOUYhrlzXMdYgQ1UHSMYgOuWM/J4hIPGZZuIhKAITCpIgyMoYuoIgZiJiAsohOWZrUfIg8Dp26pYhsYKCRo4hk67rrXY +gZQb77RogmgsTJYohaf9gXtogude5KqIgZifDZJ4hqbwnu1og02BbXtYgfVCOrsIhkDzculogppT/ppIgW/Ebha4hkZVWYJYgQV1kJO4gSWHH2 +bIifLXJQJIgSgnIIJYgSt4TTNogSVJGes4gk6JZJ7ohd6aAVPYg5SKK2QIgQHKm2sohLl652gYgqa7NlwYgehrX+eYhjargTr4gQn8Q+3YhUrM +lm5YhSLtwmnogYseP1RYgaHfDQcIgWwvypZohCxwnf04lWlQ+TwIkuLxRxm4k51BSbPIlFrxfovoljcSPLhIk7cThfTolLxzdyIIlZhUk8Y4kP +PkyZR4kQI1n9UIli4WLUzIkio27DRIlRtXmOcIlnL5evo4k0ppyGk4k5E6tuoIkd8bHb24lWE77pUokXMcjrpYlVocmmX4lgJcqvd4lPJtW+Wo +lGs9eUwokeCBC8iIleBxYzvIkaXhwdb4kwbh3VH4kcjiNe3YkSJS0sjYlBrlGESYkQ1lZAyYkcHXCdz4kz6HCt64lJb3UlhYlTd7BWkIlkCd6V +wYktyODDY4kiresxh4lhvhT2X4lggC4hwokY+U9BX4kk/3JvJIkSYn2+i4kiTIuPOYkaz4w8Sok8mK7vq4lKuLLB0Iksbs0UXIk1ZvIZRYlMx/ +LpM4lUgvaB1IkYffi1xYlseA0LHokwthv0h4lEuDe7tokirTyDl4kSDD7woolMnVt/LYlL4Fx2NIkQQWxQNokTt4Q6JokT2Jgxl4lWvZybi4lL +I6OIJYlYbr/vQIlWtsPNhIlG6dLlY4lIxP/xeolIXRissIk3HyLN6YkaOi1pcYlUxz7tT4kSOEiJ1IkdkXjXrIk5uo0FIYlkMbZ4T4kmErt3zo +knDr0pYYkw4cdPTYkQZcq1NIkWcco5S4kts/1q04lQow7AwIpPRCP7X4pGijNQtYphPzoyn4oS3lJTmopiwFxTaYpOo2keW4pWcoeOjooeWKqx +a4oUDrt7zoomnL+rRIpsBNx9KIoupvGJt4oP0/9Lz4oWAQIAaooyrwh8yIoU8hmFbooYpiLtnYoYBE29P4oYZVz1VYpGNF+hWIoePnCbM4oySX +EDWYpqRqsZSYoSobSi3IoxitIgtYpI3dtffIppId5BPoplOQ88a4pWWhvZV4oWjkPPe4ppPkoiwIoavUzrt4pioVEvsYotjX5DI4oUeok2nopG +t4rIq4pUjrGVxYpmvcc7dIpR7dCXO4pQN971T4pLL+bNtopPfPSJjIoZ2BwpuYo2VTDwf4pbljV7Y4oW4jwYgopUJD7+kYoWbUQYxop7h3H/Z4 +pHmn1mRoo673/AEIoWA4mlT4oXgZM9nopgQ5fQaIpvk5jKDIommaIsU4osuq9THIo0SrYekoofm9rle4pSUN3wo4pUEup92opyrPpE04oTfEz5 +eYpMdl/DK4oQM43xK4oxG40auYpOW5nbLIpEVZ3zTYoaLKDic4oZoqvWY4oYdskeyIpGjtSUyoofud3jsIpbeOy1UYox1R8JsotWmCxGRIsqTC +4psYtI40COaIsl3kZrO4tEXEt7OYsgSVXEeotWMF6QP4scL3DdF4ttdYcdK4sXzIoq0IsrTKFeo4suq8q3rYtiz8tJS4szAtdktIsSJ/3CqYtI +ugfgwosi4hG1uYsUiBcYq4tAvC1EnYsmNDXjtYsbwzhsn4tIAlFJNYtf2VFKaotn9VWHp4tRx2IlSYtQgmf8XYs0wWn2ZItoSHYuWYsrmnyyJ4 +tSLYaV44taMYkrp4s6vJA0hYsak5xZl4sYg53QW4sqZ566fItKTaRRcYsvEK1NMotNzayvcYseurBbQYscmdS8tosVptbKNItq6/OZvYtnH/rJ +gYsazQANcYtqGBKavIs40COfvYsbSS7lpotSvDmggosPmDxkfosPVEDtcIsTJULwlosSAUq1OotuTXoPhItL6IIOootKsoTHposmWoVq4otqR4 +wfX4tORqrdzYsmx62964ssnMM7n4toOtEBdosZv9MnoIsS39edlYsdrdqexYsUs/S7xotyhP0EwotQXg0+P4s2MVA09Ytsnk70ZIsXnoO2hItT +KacgXotclqUB7otoD7LEZotQRcC2nosfpcWzPosUzc0LZYtMnNSw04toiSdOsIsY5ioiKYtguS9El4tSMz80S4tQrVBYa4tgLVQQposeEGE9h4 +tWrmUSkItO9W4/3YsWNn4fHItf84/jXotpiJM1ZotOWJoOVosWHsKqrIts9c4gqosU69dYtIsgPQ7R0ow7qhEgv4xGAhfkpIwq/STGxYwUL0N8 +14x0/E0SXYwSc1xBboxguY+Yk4w82pDhtIwt5LUKlIxpFsJKXoxOQMSg04wdAMr5hYwjtPhUcowYwPmU2IxtX/uNrIxeQxLAeoxenxSv4YwUyR +/gJIwgtzkrtYxgrTm4mIw0FT85z4wcC0kfT4xeL0v4eYwPOk8xjYxMUFJ/04wdtFeLaYxOklpkQIwRwG7aIIwSd3WtiIwhZHnXvYxKBoigwIyY +lKqhRIxL7Kp0qowWsa3KOIxBzMnBX4xcz8tJS4wzJM0R0oxT7NL3r4wwGtZoUoxWKuyVT4xjgyeTUowRKCro1oxihTZhyYwqqDaEmow5ZTkKhY +wS+kkGbIxUC037loxs+GEwQIwknma4iYxOU3I94oxednmRTIxi74IFr4xSYIOTMYxozIQmpowd8KPWO4wyQ6s2W4xWGqw+mIxIpK/N4YwW8riu +mYxqVMHPvYxG0dAfnIwUYNM5m4weSON/vowYWfX80IxgaPzGa4wlkv+OJIwcZhlCF4xQlTHCbowdzUJ9bIwVAEK3Ioxq90+zp4xQ9VOkTowvgl +v4OIxc52X4YYxMEmYaN4wQF5JnMowWEZKfc4xquZQZp4xgg5dtg4wT7MrAwowiUs5MeIxHCN/np4xjkuZ5uYwifegOVIwbfu5bkYwSagC7VYwS +uDWhWoxOEzh9rowkV0EES4wUqUdSv4xjBklru4xYhnAmPYxNmIR+t4xJP4YimoxSCqMl5oxegKUSuoxopqUquowdN6+nXowlD744yIwa+Mfugo +wW+NT3aYwcX+JEHIxo1gGGwY0tFwx+vo0egBY1oI0etBi8qI0b4SJxyI1SZiM+x40WNSqz2Y0Uyy+Oko0klzPvaI1KNzZ9OY1k5DhLsI0m1j9n +co0iqE31S40Q106go41Gk3Snr41QEn0gJ41Bu548So0Re6lRY40Yq7VJUo0Upbhzj41meMKV240sKc8kXY0kHtAIfI1wq9Ncy41ZieoT6I0vYf +H8eY1S3RLhM40bvhV9zY0VlECeWo1c7EJ0kY0u1lJJa40qL3vJU41o2YAsE41kz4z2aI0wwq+Qu41l3rMQo41YIL507Y0yQMF3q40zlMf8zo0U +L9xMoo0SPd6pvo0j3ejpqo0Yt+x/1I0mlf31hI2b2v1v4I0YwzF9y41OJTIsS40sWDmu8I0wQUGaJ41YHEKvdo0P9k1Zxo0d4k/9p40er1EjmY +1nhVafP41kSlzFX40+Vml5dI0bPXV/uY03Io9+FY1QBLvm4I1P1cPcxY1su86ZMo0ak9VCx41QStxYjo09fd6aNo1S8/inh41V/QRymY1sRSJM +fo01dSsh1I0yNDnEXI06jkEXHo0V+EQ6eY0QY0p8T40RTlLBP41AKmeda40S5o87N40dUJkRDo0Ub6OCgo00E8GZn41o4sdruI0hOtIRaY0q7d +G+wI0tVPgCdY1pC/2xjo1ttQgXmI0yowhxFY1elSjZj40SJjARQI0QoTF4lo0gZTV5841ZEjiuWY0UQDoIsY1fd0gzc41z3lHC+41ql1ivIo1S +r2XRjY1e/pfPLo0VAKcatI0TcavTb405ELgqWo1EssXsPo0Sj9aVoY0QbQYJzY4UbTbe044VsDm7fo5JoDtMeI4UGVM6SY4U0VdXTI4Q4Wj1Po +4UxGuhPI5Ft3A6Xo5p2nDjiY5IIHFJK45UY3L6oI4bfHXEt44lanpPQ44Ympc6WY5TG7FEy44XPbehQI5ECLf+uY5ZMsqfYo4geum6bI4sb+ne +pI4QB/G86I4sgfJ5u45Ju/jbbI5BcPmDkY5aqv4xm45p0gVbJo4bDCR/nY5XVSXdzo4cvyhToo4V0kGvFY4921REQY4QPlp/NI4mo2hzwY44DX +AYf44SfXlKZY4uUI91R45VA6NOKY4W3qluHo5S6Mu+j44WAOgVc45Q3RRXmY5Hfyfo2Y5qdCzF8o41zTPLmo4k+0VDfo4SE02DQI5nkU4TnY5l +W09xN45OUl7TPY4PMXShzY5d2IIwlY4cq40xU45JoplGiI4flMGCnI4g98MFSY5kusnPaY4i982LgY5SQNZunI5OdNw0Zo5sCOcwg45NOu6ZDY +5il+3MRI5HzPXPvI4eUwCxe44TVRSPQ44WhR9qrY4YpCAKK44qzygQr44diimaTo4SvzBLdI5uND7aII4S+02+S44RLFXZXo5RrWQVNI4UBmbi +DI4SfXmeI44VAH70WY5pa5+2Jo4ZRKZ6t45rHamae44fELgqWo5EItDFp44UvdPQjo40XduwQI5M9N1wQY4qJeeLvY5pleuT2I4d9PWUTo4omf +5aC45HkgLvdI5q3wN5Y4507g89YY4a6S50jY4diTZheY4W4japeY4vjEn54Y4SPFaoko4a6mILQY5sAGZOOo4TIHJ23Y5VS4iTl45cfZkDjI4Y +VZ2Bpo45HaqxT44f46pXmY5KDbnXoo4Yo7kxQY4WA75wpI5TvMMPqY4jT8QvuI4avszd0I5M6dD7cI5SqNMSt45udNzjKY40B/dXjI5iigZFv4 +9pOg27dI8wmztVeI8aUEuTj49elk5HtI9PS1Eneo8vwFcrPY8S8VnCio9IjWJb148223bmJ48k+3p2K49PW4aoRY8kmqLH3480oawpVo9R97KO +II8Vycd/SY8eTMzi7I8opdWOK49mge5IYY9Oz//8NI9SoxVoQI9kURrpT48eaCUfkI8YAzo2LI9LnUABnI8UJUMVaI9aD0kZ4I8Q30i0PY8w0k +rlNo9qlkxoOo9XHVOGr49p3FODgo8T51i1po8wfmEb349kqmFan49KQWpjuo8wK4Ji7o8quIO1bI9Oz5jHfI9MYa2gPI8Sl8XTZY8ZO8ZjcI9H +5MdWuI8ia8phKo9eJNTP0Y8SoN3ulo8yvesFwI9oChtos49iUCNtx48WlEVgbo9YkV4wvo9KoXZbQ48a/XpbK48y6nvXKI9RHHwSKI8Yp4CmQ4 +8t74P4H48i6Y2oxo8WA5NxTI8YZJTcfY9PEpV8XI8UWJ4/aY8t8qCYRY9MKKYcWI9a0bI0jI9mLr1INo88G81Dg48WUc+ms48TF9hvoY9Ny9wN +IY8W1+B0Eo8ypAyxrI8k1Q0jhY8dGByP549FDFiFJo8eGV0kOY8P5V/4K48uEm2aIY8k63Au0Y8qJYovN48W26L9RI82z77muI9U1r/5VI9ywc +WIR48dy8uPNY80G8/8kI9AMs8onI9KV9yxgI9O7uAqMo9WEuSviY8c/PP8jY8xa/dmjI8gBQUjv48aIwwbzo88Txlsz48sZh+4eo8d4C6seo8d +gz0NUo8LYT7kNY9Ko0poH49fb0tKL48Xb1LIRY9Q31M7bI839FQtP49YRFXVKY9w31luNo8Ro2fB5o9N6HkEJY8yW3z9Io9BtomxLo8T26DvJI +9IlqTxlY9sF6Wego8kIKbwco8UXcnkNY9ILtGQv49IotGth48aptjAsY85ON+Dk49RqOfa5o9OwQP/tZAu0wPIVpBLTRJw5JAXVB2zkZAlajfR +lpBkZjzUpJASGUtwopBI9lJbtZBogFN/Z5BZzV/SPJAmaXK2wZAqaHjcgpBlS3+bZ5AYZIHQFJBaUoQepZAdRMC2npBIu85ZpZAT3dfPqJAiJO +EAUpBQcuNC3JAXY+cFbJA5vP2ROJAQd/4bZZASZwUrXpAf6QjccJAyrBkex5BKpC0/zJAcaDRAkJAfADttE5BSdUf2cpBm9U7YuZBWcFyLNJAS +Eoy5cJBSTKgH2ZAbUtWutJAQivFu2pAcRAbjepA1VxkgXpA31ytAp5ASrjbVJZBsGz8s1ZAapEI+m5Av10RsgJBU50a/uJAW6EfPU5ATA0vcd5 +BtY0vJQ5Ajf03R1JBOIVkcTJAQgFy8RpAYSFzlG5Aag1/KlZAg618brpBIRmg/0ZBqvnuX4pBMN5+BKpBTLqHhaJBoA6mFlZA5pK4RsJBpJbBY +KJBWibh1XZBQccjid5Bi79qZ6pAd1vCMYpAvXPmcapAjDgz/RJAhkBxrMpAtwEB1dpAWxEQU05BmikcYmZAcClc/QZAQMl5hUZBE6G8afJAWYI +A4vZAmqINnYJAUh5CLcZBJsZ2ANZBK1sRHgJAyOuEat5BUifHG0JBoAwl8N5ArURZA7JBIGR7WmJAWQy08jpAUyz/JgJAaTESab5BXPUUkL5BQ +eUhjxZBRmU9/npAsO1+3p5BL3Xm2TJBKwXzHUZBjHIjpipAqcYzumJAwcYzumJA5go2jY5BMpo1njZA2Ia0qb5Bg1bNcRZAdI8rKrpA2RMyjiJ +AqsdV3o5ArUdy7apAT5frNt5BMWwVQqpElbA7fqJFeshXug5E5xR8KfJEZYyTa25GBdCYoZ5ES6is+qZEqWjF7fJEnNjl0u5ESp0VrkJEgHlO2 +PZESEFfSO5EPylxqP5EkT2DHNZETd2r0TJEo73KaJJEWBHNHL5EVmne8JJEW3ZjbKJEo8agfg5FMmK8xdZFv9bn9N5FOjrv/15E3gcpfk5E0/c +s5rpEq1t8bhpEw9AezYJEqHA3GipEpORLTnJFDPSMaJ5E3eSgLXpEdjy7aJZFJwUVjSpFLPVUcSJEsYWEsj5EU+GL2dpFUzW2GdJEo0nKiq5EW +LXRbY5Ew3YkR3ZEne5e/4pFo0p3lWpFIOqWJPZFwuqZjuZFFlafGSpFKKbN2h5EYjMBddJEsfciIRpFA1MgYY5FgV9houZFsx+KhYpFUPOUwwp +FKeOfqXpFIxOzW0JEy9/WV35FYMf0BZpEVFgIITpEvKgJ8ZpFjKRIGUpFO7xo5g5FY6idYfpEUgzkxbJEPT0j5vZE19008SJEap0/fiZEkX1C5 +gpEkpFCClpEckGKFQpES0mY6uZEkAXSXLpEhuHs+PJEmsIvpspEVsYxSQpFOa4/tbZFl7ZPkNJEUz5ZWxpFsHqGXzZFJi65J4pFRGbAgnZFaX7 +Q/d5FPnrW9r5EaeLl9PJEUG7x9MpEjUsREQZEQDsRamZFY3shLrpEdMdoZZpEWCvI1uZESRRXn25EaDR6tJpEewiAwdZEj8ihhpJEkVC53lZEk +vzA+c5FirDsYeZEla0gOSpEVmlsxLZESOGNlN5EWWmqykZEXMXBq9ZEslnxenpFKJ4AKZJEPk6J6qZEafaY8jpFI0tQ6LJEYUuLtR5EvH/MbZJ +FIBRDawpFLnBcqnpEuKiFXd5FpVy6k3JFCjTIMK5Ej3j0tiZEkgUPfdJEQTUWMOJEtQkbap5EYuEYBUpFUKknynpEYgFK6x5EZEVyoWpEX0WKy +0JFni2L3MJFK6GnaxpEdrX0dz5FYvpZevpFoTa4eEJFgo6/lJJEracPEopFmI8hd6ZFHoMpOpZFXPNLRkJE1mNUw3JFnj+tL2ZFgAu12+pEYyQ +EPC5JOhBHg55JJoRdNVJIYKxhxr5IYPBmQgJJs9xp9D5JKKCB0ypIWxiMTnpIWECoZyJIt8CrLfZISLy+Sn5ImTy+2rJJKgTnW0ZIYBU4wWpJJ +ylnNXZJjN2xlIpJKDG0iN5ImwIih9pIYvcloA5JZbcChnZIUCsYLUZIU98tXs5IU1s19kJIjqtQ/kJIYyNjPZJJfzeJsapJr4vwHapJekAzR4Z +IYVxoyqpI5IST9xZIWEy35ipIrSzKsvZIZ2DyyTpIW0T3Ek5IQFT8kNZIof0attpKcVEh7a5IXClUpg5JHQlmcF5IavF1NfZIbGWN8FZIazW+7 +JJJ2d30FP5IThoOqxZJsJIXapJIW+ZddjpJLbLGqz5JP5bVJNJIxHLrNPpIWteVvRZJQDelbCpI+MeijoJJg6uiVmJIsW+vE2ZJoC+88GZI5hP +1vZZInwxhiw5IY6xu6sJJmkRx8ppIeMzO40JImuTYJnZIe4zh8bpITvkL1lpIS60lfX5IQG0+YkJIe5FJQj5Iat1axnpI4D3oUKZIV4nzs3pJZ +D39uW5JF/p70XJJbT9WnTpIih+AOSZIthuHbYZIag+cTiJJrheu1fpIkS/zHx5IWsP6Rj5Ii9gn5b5JlyBJeXJIswRegyJJI/BtFNZImxCWAwZ +ItSTFrgZITRTI0OJJK0TWTGpJLCzwyV5IwmD26PZJNXkG+ZJJt2UxnRpIcglKrpJJmGFaHUZJ4HF4ae5IUdmzFbZIrgHrxt5Iaf4L4PpJgnodR +JpImJ49JJJItGp7ga5Idvbp9fpI9q9XKIJJWdNmZh5JKsd/An5Jf3eTJtJISxuR0xZIdj/xiUpJKeyARdZJISUJ23ZJcLUj0apIdnFdi4ZJNdG +J2vZISPWeJLZIjOWmxopIkJ3jtkpJV2n26i5IaMoSiTZIV8okqL5Iap4q23pJavpm4XJJJPp/ZT5IbFbQWrZIoU9eoTJJEUdgWo5JINe0HYpJB +Gu/MLZI6O/k+rZIUSfv/n5JpTwceuJNG4h6GtpMtVSu6h5MVKDSRg5NraTQQi5NWzULZkZMYcEmM1JM5DU/1aJMW6lAIrJNMYlORXJM/gVrVO5 +MSJlsSnZNY6F5qPJMmBGP2R5NU2G7xSZMmonyksJM9MI2nY5NEvI1zk5Nas6IGh5NQbqdFkpMbqa5/OZMXTbCHRJMqjbcNj5NoC8NSMJMWbMyv +HpNG4tNKR5MW8ew3sZNSsvb4wZNgrQuKnpMY2BLYd5NlGC4KQZNPvDYWjJMqvzixg5MtSztbfpMQMzunJJNNtWI/lZNb5G3EVpMl5XI/JJMUbH +P/jpMad4G/OpMYoJ/4EpNigsB3XZMzEsTZS5MShsUVUZMh7My1dJMgHOUmHZNmp+3AbZNSufxcZpNojhVUVZNFwhk5KpMsDRuHfpNMshtVsZNs +HyiaiJMTHy4RnpMVxjEMzJMpJTu8fZMQdz5OdZMPyUJU1ZNcU0hO0ZNJN01shJNUEE/CUpNOkFRHnJMXy1QiQpMQ81q7mZNnU14BIZMuv2UwRp +NGxmfxk5Nqjm2vqZMa04DSHpMYU4UQ05MjvaMEgZNU8687PpM1g7Q3mpNgfLn5V5NmPshI65Mc1dBRvJMcNNPXL5Mj4N5hR5Nbzuxp1pNUoPMM +DpMSGQd9npNTKwsDPpNGaCsFhJMybTtbhZMcLEG6tpMmxkHR05NQ30MFzJMuWkOlcpNXZU1bVJMQ/U+kxpMwY1fydJNGS2QaDZMw2WpmrZM6kX +crOpMiLHyRi5NoUpIIhZNQYp2TJpMoCcZ1ypNQAcpBQ5NLoNSol5M6d9Yos5NEqQOli5Nc9wskKJNF8ykVxJMVUiyyaJMSri5zpJMW2TKlkJMi +xVJmT5M321hKGpMWoFwvwZNKm2XssZNm/n8yhZMZwo7GZpNKu5qSOZMc4aPWrpMWZqSGR5MUtqlavZNsa6wRe5Ni2LsZxZNSCceUQpNtPcgnYJ +Nr5MdWuJM5WNXpmJNsNuCkwZMPb+yfT5Ml6u27M5M3Qu7gdJMWTu47iJMYKfZAM5NiywXcnJRPRwgClpRsVg9Em5QsPxbo7ZQoRCOtfpRNIiue +f5QyJy73npQSVi6lYpQYTjVncZRB1TUYOpQuozswopQULkEJepQSh0TiHJRK105qWJRmolbEYpQe8GRdd5Q57XC7R5SpQXLIK5QmWYPk6pQYI5 +JkLJQYV5/kNJQg66aMZJREHayOWpRs67hRpJQatMKFYpQdE8rjSpQSW8qwmJRBtcrex5QQi8vwy5QY3dDnqZQ0XtuGkpQdjQfkIpQyBQlf25Qy +NB5CWJQaiy5g1pRknjExi5QmC0MjjpQetEh2apQU20vvb5QcVk7sNZQW2k4zUpQQ+l59q5ROE2NPHpQum3kAgpRIT3tGRpQfD4T5LZQUCZpYm5 +QkPZwmv5QZlakbXZQYqq7ur5Rmv6/ygJRiw7Ybs5Qo8Ld3lJQ5ArksrpQ4aMNTipROlcN7aZRiR8UtfZRJe8b5jJQsstOxcJQsUtYr2JRU1tyX +x5QUyt2P8pRRHvf4jZQVaATv15QZJBTtuZRboyh+SpQaHDCEk5QmNDG2J5RokTLaj5QmNDxdq5QwQj+xnJRKIEX+dZQWVkgWN5RcJkkTG5QUuo +9B1ZQYMqhvfZQYvK371JRq8K5CSJQ4k81WP5RcrtHlvJQVp+xHyJQg4PYGg5RGDwJ2WJRcfghy6pQVng1xfJRGSxViYpRs5hzAN5Q1mCyppZQq +tjj/r5QQXlUg6ZRgR1+IkJRiGWXawJRKD2XhjJQ3V2btspRAom2Gk5Rqv33xLZRswph+kpQs+JtjPpRM1qe1aZQk2qpdr5Q3brTOnZRKQ7lFHJ +QX8MMdoZRpdNPiGJQkGd4vHpRRTORYYpRT6+RDp5QbqgEyWJQuDQiJzpQbSAo7qZRPDg/9RJRNEBEZapRWSBm9fpQosjqx2ZRuKjqLmZQUA0Z4 +TJRhUlBMmJRSAVIySZQSL1YJ8ZQW8FooZJQWaV8rBpQoAHNmZ5QeyHfmf5QY+4VIr5RLb5ovdpRklqnlXZQXB6+SSpQUg8aZr5QUL8u9epQZjM +tEepRRsNPQK5QdXeK4WJRg0eqIV5QUvfNPSJRgDgU7R5Vn9gYxxpVrNQsfeZVQ5xUugJUgPBw7n5UhLB3/vpVGei/y8pVUiDcq6ZUT/jb6jZUl +qUVldJVewk6ZUpUS10/NSJURGVRITJVTbGEsqpVGNHYUTZUadYj93pVnGZOZZpVqEpgdZpUYcKbbQJVkaqqvXJUU0qzXc5Uf/seOR5VE0c2/oJ +UaM8/rXZVgDtwukJUcMeNrZpUTNu2CWJURhPOBz5VU0PQ9xZUUPfVegZVKQPYOdZUoBP572JU6wSjK5JUegywndpVI7TNR2pVo9UczqZViJ0yo +lpVM43YQWJUdA3wYPJVXsX/nL5UVC4V5SJUViKCTUZUT56aDNZUZtKninJVoy6tw4JUYpK14M5Vwdbp4gJUkicIeYZVlwckqu5VM5toAxpVm8O +QE35UUzfgnxZVMxwkeHZVQiR8QXpUknSON7pUimChPoZUWFS4tx5UkTS2MJ5VQqTGUa5VOxzgHOJUyajyYUZVHOEgo8ZUyrEllfpUiD0oMD5Uc +sUySf5Uou06fzpU5ZU6Ta5VKZVSlw5VidV/OrpUffWDGopUXWWW7NpUUnWasM5UgPWjPEpVGU3F4LJUyOHT4fJVJtIZnWZUpI5NuOJVd26S1S5 +US66n3tZUqGa5PQ5UeRrSKRJUiJb9n5pUohMZ9iZUs19RpuZUU0N5BwJVQtuZ5m5UoXQnbXZVXQBmrcJUq9yeLopUXXiuoi5UsADCG9pVEyjFZ +kZUT4zquhJUQEDtCmJUXsjoLPZU4PEr4XJUrgEzmWJVLjk3VaZUdml2zPpUmtWGAc5VMZHAblJVt+IFuXpUcg4XwopUc9Ib0nZVJxonwBpVMsZ +FDy5Ueh5bBcpUqep5T1JVdbZ/Fb5VkWKP2KZUUrKTVsJVfNa55uJUtML8MpZUq08IhQZVJyMSRO5VDYtFjeZUuW9rM85VMBuoES5UdjuyNb5UT +e++h3JUsxgmaoZVLvxkXj5UUWB5CTZVY+B8ow5VGKiOcvpUWtyVMxJUUcStIopVEejRsFZVlijrEo5UXfj3cxpUaRj4hD5UVKUEhX5UdDE0kyZ +Vs7lkMRJUSfFum3JUi+FucJpVMrlyyD5UU+GKQc5UU3WOj0JVq0mQqGpVPnmUQGJVnt3KODZVIYHW/wJVi1on3QpVtuqp8aJUzIrELQ5Uti7nU +tJU5br8xepVTWcI2RZUQMsRFFZUaj+F8AZUmWdGpa5UysNeQfpVggdxzUJVR6t6Or5Vlw+9YSJVIS++m5JVVpAZYspZFXilgeJYUHjBRlpYm3j +RlmJZalTjbvJZsLTs6SZZWMVOobpYxVlz/M5YRKV6nRpYcUWUvWpZdpGrM0JZi63IwlJZGFXvf1pYyNXw5bZYzlYFcRZYWPIVJopYuoYV8K5Y4 +AYaOcpYY04e3V5ZcVo77NJYSwpX9WJZcT54CtZZMBq0kh5Zil6zp65YU/LL/R5ZK1bSyUJZouLitPZZBbsHFs5ZU1sV0q5YUS8l4npYWzMooz5 +ZEud9qj5ZI/u9NhpYs3RK6N5ZpfR5zlZYUFyHy8JZoCirksZYYxD02mZYoJz5ma5ZF2lJedpZeTVT5TJYQ63LempZRmqWgF5YTJK4LVJYwnbNO +ipYe28HSJ5Y2BsbSXZZyr8jgQZYgVM67fpYXadL/aZYwcNKnpJZIF9UQrJYWbtcgppZgTeSvbZYof+TxepZiqueHupZo4vSJnZY6UvqVA5ZY2/ +0SfJZINgj4X5ZKXAgHkZZKKws7rZYWGgsgU5Ydag9dm5ZQ3BVWr5YaUiQpo5ZUTCzjm5ZOxjaCopYc9DdVh5ZeejjFbJZIRTqTlpYaWj9eU5Y5 +mEEaYJYYZ0EMRJYZP0vWK5YUFlr/kZZpw2aSQpZL8m/S95Y59W70r5ZU6XXsb5ZIjHseOpZN44QaLJZieIaa1JY5R5FS5ZZVBpPQtpZMSJbHEp +ZmsZqLP5YV6qIkYJZeBqRKuJZo2qUIaJYScq0YdJY5xbAKG5ZWSr6zqZZO0cXbapZ7dMvYU5Yakt1ASJYUi+pkSZZLj+y+45Ys++8a8JYc +`; + +export const LINE_CHAINS = 150; +export const LINES_B64 = ` +BAcWM7xmDKiy/gbjq34BX6kHLApNoWoIg6LbBq+p/gbjq44G9K8d/Im9rfUyvAMd/Im9hPwNvwP8EsIFZgyoshcKwLbbCGy6Wwwvw2wRKMUChP +wNv4T9BMIDM2XeTH5v0FPAdC5LBNidlQ9JrhQQU7LBEZ2wyg8Kz91+crLeOXOc5RN4suuLf4TuBn7L7/h/9PDVfwX0OHWE+PByA/fjYQKc5RN4 +0OtGbAKy64t/qe3udALL7/h/Ke/1gQNr+WljhPjwcsL8qWYK5NIYj7LTnIyA1ByJWNfUfv/TboEzz26Eocu3k7LTnIwzz26Ex8sOeQfZudEv3b +qyKYSzCCwXtV4wQrVlNP66EDnVuQYxBDgexaacFl6hYRSXnS8UcJsL6z/sv004a8F+NqS6zTQrrwI6r6jzP+y06z/sv+o/NM1NOGvBrzVTvsY1 +a7oKEpPTmGOUKpoemEeb/poxqwmbe7ZZoHG5wqJhr1WdgaYemEebppyGkwUJm3u2P5iLwbqXp8nQmb3JP5iLwQQmMBFA4TF2RCUyLEseNolNBt +o0cszxNfXVRzRa3vQocuXOKDDdKyU/1QNHNFreWkOW4q5Keu0Eu1/dkEdd0ZkHXYieoV3oqAJHXdGZRVgQjQL1iX22AIbRugcJRHZmB0g5aDRL +Gl4pTHZa+UpFWGxKy1acQz5VAvNOU1YpTHZaBQdIOWj7Sb5nVkvEaaJJ4G77Sb5nAqdRbod+T8mLC3nYNW4S2fpqd9qqZofdD1yM3rdZvuQgYF +3oEGkh501o9OMOaA/hfWd52DVuDbdGkUJCRA41WWLZHBxtZBxOcmskXHBFKLRtxSgKY7IrVlldK8NUpTQHV608SF0xMgpjsisHTnJrJH92OCfb +duYnk3c3Ktx2ICwtdEwsXHBFKAVWFI3aQg+q1RUKWdY0B2jQogEf1AsReYAyfIHcN/yEjzhhh146wpH1M4qUvzx9k5hDeJO2RIWWRkylmwtE2p +8eRAJ4k7ZEVI7JSwNfnHopwpH1MwOWIyoD/ISPOBKChTX7enYrC5jal9lj3fLXTuMC2bznmNNX7SDRmezG0trvFNOA8ybeVPxo7hjlWeRO4wLZ +AhjlWeSA8ybeEAgdmoS2G/SHVxoIjFMdYo7zH6uMaCDQhQgdmoRaHHeAxhjDe9ETTXGAElVpwAdrZnQDc3MyDIRx8A5cdNETTXEGoFiaEvlwNB +C3co4NQ4MzD+9/wBD5cDQQAx2jXyzknJcjKKSiKwTuQ3JQZT4hTWI8ik/iOo1NAmU+IU3ZPxtDA3GM7pjHjKWnyoQ0qAhxyjlLz8tJS1rMF0pz +zAxIJ8xnRjjLIUTRyDpC9cXSQwfbpZms86RkqSum/qWZp2Wl0agTpT2qOabsqnSqBn+B1FzNgdRfz4INZ0+Fg2gdhrlezYHUXwnbew9ytXmOcM +Z4+2pLdfllaHeJX315SmXCedlmS33mZUt/m2cCxnj7asJ52WYCfIgcK7GCciwCu4RCJoqFxi4GTeL9qozdULBJ2UC5qtIvwPPPkcm1zebLBLPc +ZcBJ2UC5rdTlsSHQw6cGPdsTkALcwZRh3KGWoN3ulg/dcJUC3MGUCIQtxja2MLcxUDsgJ0s9giL0PkYmUDsgJ1A2Qy62MLcxDtm+4tBmvzrJvr +piyhK7d87ZvuLQ5sw64LHDdOXltnXd76581wGrStNvpNzTHZaO2/SFQOPrepriArHDdOW+w3DnAubMOuA70+/jA9DidoeT4juO1+Fojhu7NsR4 +wjJfeyAxO3vHLEZ2USrJbDQoym6wJx1y2yWMcl0fWHMtHUpsWh2WZW0gZl54Iw5hAiY7YVQo7179MIhU8S6fT9kt7k/LKIRMmCa4Rosjv0KxH6 +1GkBxRRyEaJzxFGL02nRSaNl8RmS4DJiLGVg8e6VEiFlVWC6VCAqAVRASgz0e9o6ZMA6vRUFmtuVLbpw5RQKY+TkOfZktBnbRGUpcNSFeSAj5O +Q5/iTYaXBn31+TRM8wQ3QfJSPfXvx0Eh7DY9QfJSPQTf7yNCce0yRcHrwkeW6dxKCJCuPZsKsJCeArLyrEuyWre7sFq8La7dwTqs6L9dqV+8Ag +Ky8qxjtfurAkuyWrcCuFm0CFW/+rSLudS0ArhZtGO1+6sBuFOjmL1sp5q/mKlXweeoAvC3d5QKsJCeBigt2UPmHMA3/BtFNZAcazKkIAoryR/g +JBOmXSCJ8l1NiAVd1YQ5XMCEB1wciKZdIIkuX3SIjmJKgxZnX37oZK9zJ2niao1sbm5Obw5ofXP4aDN7sVK9fsZPCI4LX3eWDVpGnjxYBpQEIR +JmKGoWXxzpHjMZWh5vFMofHRVvKAYD3L08Kt0oNhTf3SxM6soxiOP7MwPcvTwJ2+5Hyjvwg8fr79nDaO4vwhbwVL3f8fi+6+/ZwwbvXcbb7kfK +AxbwVL0i7Xu4ge2vtQcobAWR+GvXlzhuN5zXdzCdDn65lN138ZUobAWRBDhuN5yibU2hYWn8pCdoz6EG/WsgskZvELAldKmwoG80tP1rILIWZs +OzCRhBwmpcP9lrrj3raic7p2aiN/NoTjYvYFs6eWI9PRJgdT5OYgOvN5htojfzaNA4Qm0GuaALXGGeL2kGo6dyUab3apWm/FffpqZVAmGeL2lR +pvdqDA+pLFASpw9P4KNtTM2jMEa9n6dCypyaPC+i5zVLo+k7CKRxQD+mc0WwqmRJ16uoSwLNozBGP6ZzRQd9Q+zTL0oW02pP/cVlWWy9HWBsu1 +pjV7S+Y+mwCPbHe7Xkx1a4kcYot/bHe7WxyXq0e8p9rufIcq/2x3u1BNJBrxUAO20TejRsFdE1kxoGN971T/TdcEGx4/VFMOM+UjvgH1I33vVP +BQBSanLcVsF7x0xMfyBF/3WkQhN3BcdMTH+CSG6DOkSIhtlFbYpJRxKOB3F9GSEgg1gfnIasHTqIIh8Siz4axoVpGZyGrB0F0qvBP4CvXjwyrq +s4Pav8OdKrwT8EH5oBCdvyQgxg5+8RH5oBCQrUvxly2b3ZgxC9foaLu9yR67RVjSqw0oI4rb567a1TeUax+HAut6JpBuu0VY1GsfhwNLBfaHmv +wGX0roBjN6+nXgQQvX6GLreiaT+5clwyuoVVCFlBAJUAP9acskCknB9CNZRsQLiNJD+Iis05B4ltNG+OCRM1cIJQNHiDxTP4h4cz5omqM6iMbT +RvjrA0OJMlNuiVDzculgjrN1V0rzmXfAY7k3/NOQeJlTsgjiQ/iIqUPDx90z0/cgOUPDx9xTtKfgY7k38L5dlPL1Pd2CHi1uAhSMmOJyHEiyiH +wXMld73zI6fHahpw1U4YU93YIbPkCSMKcewvr1Dy+6oB9vCnfgFfqVoCmJUu9p+V+PJPkQryZ4977NCI2+cLjgYu9p+VAfbwp47z/aLw8oOh6u +sLpPDneKQT4SfrraApWK18KuaySSrnuAkojryiJ/bDfSaKxFMk6cbaIBjMWR5+z/seCcudIY/GsCHLv3QhP7oCIlW47CA9t8gfaLjxH1u6dCE/ +ugTWK5zHUS3ZxDUs28OiJ/bDA50hj8YxHQPGbhIWyAisBNVDwAuOPbYPZEI5EDU6KAxtMcALjj2sAfA+rATVQwORSOgnMT4eML09XzcXHA32or +0My6ohDsamHA32orQM6p1EENOVvRIGjbMV7oMwFIiECBLNhwgQvIgcDcaKMQs4i6gIyYrh/8KJcPwAiE76Eonz+KeHY/irhB/6yYHP/IiClf31 +hHD8AIgCY/irhAb2boUK5fGJWer031Wd9LhRAfQ+UUXw/1Eo7BVR/ucHUX3oDlQo7BVR5fGJWQm3RpFCt009S/VQp1eSUeFZblOkXMZUdV+tVm +9d+FUbRwdXrTwEblOkXDdTHFt0UtJW9VCnVwT4VRtHdlzITRVdzVBRXpdYBTstJieZLakrciqtKNwn1CM7LSYnA8vRnpkX01yaHdW4mwL30dqY +F9NcmgUiw7dLTMQZT7vDlFX5xNhbcsIMYgWxzsVA6s48RiLLgVUeyJ1Z+cTYWxN+1HRESdXUTZjUmFox0ZxcKc8kXW7NFFzTyZlaHsidWbvDlF +UIwbtUTMQZTyLLgVXny6VY08mZWoDLFGFnzBlizc0LZYXOnmaHzk9pBIDLFGFDyvthocmmX9PJmVoDdqrcWrqq01+iq9VjDLqq019vrppb5a9o +Wgyx31eWszpP47PjSV+0wEN+t4FC+LvZQsu97kbjvH1IT7s7SwRrCj9WCP7+V674u1Ey+zZKBULGRnRjyD95hMcgczHFSGtCxkZ0CTao7pVjp/ +mbqqjNmQmqRpY2qO6VMKb9jt+nI4kJqV6GOK2+egYut6JpBLwZatS/GXKMwF10ysPge//J+oUEFGx4f1ZpeXTobxp8DXAYfwcHPBGeDTF6l8Mv +kpYvLjmWvi7ymMEvR5sCOq+oBC8uOZbKKsOR1STXjTorhIgD1STXjWkk14yOJpKAA//BpD7MxJ8+IMU2OgQaFBGqCBfCsWkYI7AaFBGqBFGz1B +3OqcklXaNSHlGz1B0H9e1MKm/4LS2cBXUmkQO8I/z/vCKH75oj9e1MKgi+ghzR/3XS16l1L9Dnfl3MvoIc0ZuJls/sjh3OHpMixgTnfl3MhX3z +w554Ea+ReNesA4V988MNd0m/o24FuwINd0m/tW0IvQX/ddLXm2Wv2bdaWtYRaffTqXUv0ASpdS/QQ2njzNdlfsncX1PEAqVgEMPXZX7JCNWno+ +7Hrb3rr6Mp5lmedunVp6Pu17Ks9BC7JPv9GvP+CEhdMTLuY8MxHGpkMvtytjlJbRhEdWVyRmxhOkIHV608CHx9SYlZfoKCioMNf2iH8H1wjB94 +JY8gcC6Yd3f9nPN3Aw6Llo/jidSEaIfwfQRwjB941pAnf6CVMoKOnbGCB29gkiHpWfAhvlZpHqlNWR85TLwbvlZpHm9gkiEFjc1rnsXPFKMs1D +6ih9V4pyPYjqc= +`; diff --git a/src/app/features/scene/ridge/starCatalogue.test.ts b/src/app/features/scene/ridge/starCatalogue.test.ts new file mode 100644 index 00000000..5e0073e9 --- /dev/null +++ b/src/app/features/scene/ridge/starCatalogue.test.ts @@ -0,0 +1,117 @@ +import { describe, expect, it } from 'vitest'; +import { moonPosition } from '../../../../sky/moon.js'; +import { catalogue, lineChains, linesAt, precess, starsAt } from './starCatalogue'; + +const DEG = 180 / Math.PI; +const VIENNA = { lat: 48.1929826, lon: 16.3534237 }; + +/** + * Reference altitude/azimuth (degrees, no refraction) from astropy 8.0.3 (ICRS to AltAz at Vienna 48.1929826 N 16.3534237 E, sea level, + * UTC, J2000 coordinates of the stars as Hipparcos lists them), computed once and pasted: an independent implementation of the transform. + */ +const REFERENCE: { t: string; name: string; ra: number; dec: number; alt: number; az: number }[] = [ + { t: '2026-01-15T21:00:00Z', name: 'Sirius', ra: 101.2875, dec: -16.7161, alt: 23.711, az: 164.391 }, + { t: '2026-01-15T21:00:00Z', name: 'Betelgeuse', ra: 88.7929, dec: 7.4071, alt: 49.164, az: 176.246 }, + { t: '2026-11-20T21:00:00Z', name: 'Vega', ra: 279.2347, dec: 38.7837, alt: 15.924, az: 311.197 }, + { t: '2026-11-20T21:00:00Z', name: 'Polaris', ra: 37.9546, dec: 89.2641, alt: 48.79, az: 0.26 }, + { t: '2026-06-01T23:00:00Z', name: 'Arcturus', ra: 213.9153, dec: 19.1824, alt: 47.976, az: 239.397 }, +]; + +describe('the catalogue', () => { + it('is the Yale Bright Star Catalogue cut at naked-eye, brightest first, Sirius leading', () => { + const c = catalogue(); + expect(c.length).toBeGreaterThan(2500); + expect(c.length).toBeLessThan(3200); + expect(c.every((s, i) => i === 0 || s.mag >= c[i - 1].mag - 1e-9)).toBe(true); + const sirius = c[0]; + expect(sirius.mag).toBeCloseTo(-1.46, 1); + // Sirius, J2000: RA 6h45m09s = 101.287 deg, Dec -16d42'58" = -16.716 deg. + expect(sirius.ra * DEG).toBeCloseTo(101.287, 1); + expect(sirius.dec * DEG).toBeCloseTo(-16.716, 1); + expect(sirius.bv).toBeCloseTo(0.0, 1); + }); + + it('carries the figures: 150 chains of at least two vertices', () => { + const l = lineChains(); + expect(l.length).toBe(150); + expect(l.every((ch) => ch.length >= 2)).toBe(true); + }); +}); + +describe('precession', () => { + it('moves Polaris in declination by 20.04 arcsec a year times cos(RA): 0.118 degrees in 26.9 years, and nothing at the epoch', () => { + const polaris = catalogue().find((s) => Math.abs(s.dec * DEG - 89.264) < 0.05)!; + const [, dec] = precess(polaris.ra, polaris.dec, new Date('2026-11-20T00:00:00Z')); + expect(Math.abs(dec - polaris.dec) * DEG).toBeGreaterThan(0.1); + expect(Math.abs(dec - polaris.dec) * DEG).toBeLessThan(0.13); + const [ra0, dec0] = precess(polaris.ra, polaris.dec, new Date('2000-01-01T12:00:00Z')); + expect(Math.abs(ra0 - polaris.ra) * DEG).toBeLessThan(1e-3); + expect(Math.abs(dec0 - polaris.dec) * DEG).toBeLessThan(1e-3); + }); +}); + +describe('star placement', () => { + it.each(REFERENCE)('puts $name at the reference altitude and azimuth at $t, within half a degree', (r) => { + const placed = starsAt(new Date(r.t), VIENNA.lat, VIENNA.lon, 6, -90); + // The catalogue's star nearest the reference position (the reference coordinates are rounded). + const star = catalogue().reduce( + (best, s, i) => { + const d = Math.hypot((s.ra * DEG - r.ra) * Math.cos(r.dec / DEG), s.dec * DEG - r.dec); + return d < best.d ? { d, i } : best; + }, + { d: 1e9, i: -1 } + ); + expect(star.d).toBeLessThan(0.1); + const p = placed.find((s) => s.index === star.i)!; + expect(Math.abs(p.elevation - r.alt)).toBeLessThan(0.5); + // Azimuth error scales with 1/cos(alt); Polaris sits within 0.8 degree of the pole where azimuth swings fastest. + const dAz = Math.abs(((p.azimuth - r.az + 540) % 360) - 180); + expect(dAz * Math.cos(r.alt / DEG)).toBeLessThan(0.5); + }); + + it("puts Polaris at the observer's latitude in altitude, due north", () => { + for (const t of ['2026-11-20T21:00:00Z', '2026-11-21T02:13:00Z', '2026-06-01T23:00:00Z']) { + const polaris = starsAt(new Date(t), VIENNA.lat, VIENNA.lon).find( + (s) => s.mag > 1.9 && s.mag < 2.1 && s.elevation > 47 && s.elevation < 50 + )!; + expect(Math.abs(polaris.elevation - VIENNA.lat)).toBeLessThan(0.8); + expect(Math.min(polaris.azimuth, 360 - polaris.azimuth)).toBeLessThan(2); + } + }); + + it('hides what is below the horizon and keeps stars brightest first', () => { + const placed = starsAt(new Date('2026-11-20T21:00:00Z'), VIENNA.lat, VIENNA.lon); + expect(placed.length).toBeGreaterThan(900); + expect(placed.length).toBeLessThan(1700); + expect(placed.every((s) => s.elevation >= -1)).toBe(true); + expect(placed.every((s, i) => i === 0 || s.mag >= placed[i - 1].mag - 1e-9)).toBe(true); + }); + + it('turns with the sky: a sidereal day later the same star is back within a quarter degree', () => { + const t0 = Date.parse('2026-11-20T21:00:00Z'); + const a = starsAt(new Date(t0), VIENNA.lat, VIENNA.lon)[3]; + const b = starsAt(new Date(t0 + 86164091), VIENNA.lat, VIENNA.lon).find((s) => s.index === a.index)!; + expect(Math.abs(a.elevation - b.elevation)).toBeLessThan(0.25); + }); +}); + +describe('the moon at Vienna', () => { + it('is where astropy puts it, 2026-11-20 21:00 UTC (alt 42.576, az 215.016), within the series\' 0.5 degrees', () => { + const m = moonPosition('2026-11-20T21:00:00Z', VIENNA.lat, VIENNA.lon); + expect(Math.abs(m.elevation - 42.576)).toBeLessThan(0.5); + expect(Math.abs(m.azimuth - 215.016)).toBeLessThan(0.7); + }); + it('and 2026-06-01 23:00 UTC (alt 11.48, az 164.748)', () => { + const m = moonPosition('2026-06-01T23:00:00Z', VIENNA.lat, VIENNA.lon); + expect(Math.abs(m.elevation - 11.48)).toBeLessThan(0.5); + expect(Math.abs(m.azimuth - 164.748)).toBeLessThan(0.7); + }); +}); + +describe('constellation lines', () => { + it('place every vertex for the moment, in az/el, one chain per chain', () => { + const l = linesAt(new Date('2026-11-20T21:00:00Z'), VIENNA.lat, VIENNA.lon); + expect(l).toHaveLength(150); + expect(l[0].every((p) => p.azimuth >= 0 && p.azimuth < 360 && Math.abs(p.elevation) <= 90)).toBe(true); + }); +}); diff --git a/src/app/features/scene/ridge/starCatalogue.ts b/src/app/features/scene/ridge/starCatalogue.ts new file mode 100644 index 00000000..b7e59b1e --- /dev/null +++ b/src/app/features/scene/ridge/starCatalogue.ts @@ -0,0 +1,120 @@ +// The real stars and constellation lines of the night sky, placed for a place and a moment. The data is nightSkyData.ts (generated, J2000; +// see its header for sources); the sidereal transform is the sun's own (`src/sky/sun.js` equatorialToHorizontal), after precessing the +// J2000 positions to the date. Proper motion and nutation are left out: both are under an arcminute here. +import { daysSinceJ2000, equatorialToHorizontal } from '../../../../sky/sun.js'; +import { LINES_B64, LINE_CHAINS, STARS_B64, STAR_COUNT } from './nightSkyData'; + +const RAD = Math.PI / 180; +const ARCSEC = RAD / 3600; + +/** Faintest star drawn, by catalogue Vmag. The data is cut at 5.5. */ +export const MAG_LIMIT = 5.5; + +export interface CatalogueStar { + /** J2000, radians. */ + ra: number; + dec: number; + /** Visual magnitude. */ + mag: number; + /** B-V colour index. */ + bv: number; +} + +const bytes = (b64: string): Uint8Array => { + const bin = atob(b64.replace(/\s+/g, '')); + return Uint8Array.from(bin, (c) => c.charCodeAt(0)); +}; +const raOf = (u16: number): number => (u16 / 65536) * 360 * RAD; +const decOf = (u16: number): number => ((u16 / 65535) * 180 - 90) * RAD; + +let stars: CatalogueStar[] | undefined; +let chains: { ra: number; dec: number }[][] | undefined; + +/** The catalogue, brightest first (decoded once). */ +export function catalogue(): readonly CatalogueStar[] { + if (!stars) { + const b = bytes(STARS_B64); + const v = new DataView(b.buffer); + stars = Array.from({ length: STAR_COUNT }, (_, i) => ({ + ra: raOf(v.getUint16(i * 6, true)), + dec: decOf(v.getUint16(i * 6 + 2, true)), + mag: b[i * 6 + 4] / 20 - 2, + bv: b[i * 6 + 5] / 50 - 0.5, + })); + } + return stars; +} + +/** The constellation figures: chains of J2000 vertices (decoded once). */ +export function lineChains(): readonly { ra: number; dec: number }[][] { + if (!chains) { + const b = bytes(LINES_B64); + const v = new DataView(b.buffer); + const out: { ra: number; dec: number }[][] = []; + let at = 0; + while (at < b.length) { + const n = b[at]; + at += 1; + out.push( + Array.from({ length: n }, (_, k) => ({ + ra: raOf(v.getUint16(at + k * 4, true)), + dec: decOf(v.getUint16(at + k * 4 + 2, true)), + })) + ); + at += n * 4; + } + if (out.length !== LINE_CHAINS) throw new Error('nightSkyData: line chains do not match the header'); + chains = out; + } + return chains; +} + +/** J2000 right ascension and declination (radians) precessed to the date of `time` (IAU 1976, Meeus, "Astronomical Algorithms" 21.2). */ +export function precess(ra: number, dec: number, time: Date | number): [number, number] { + const t = daysSinceJ2000(time) / 36525; + const zeta = (2306.2181 * t + 0.30188 * t * t + 0.017998 * t ** 3) * ARCSEC; + const z = (2306.2181 * t + 1.09468 * t * t + 0.018203 * t ** 3) * ARCSEC; + const theta = (2004.3109 * t - 0.42665 * t * t - 0.041833 * t ** 3) * ARCSEC; + const a = Math.cos(dec) * Math.sin(ra + zeta); + const b = Math.cos(theta) * Math.cos(dec) * Math.cos(ra + zeta) - Math.sin(theta) * Math.sin(dec); + const c = Math.sin(theta) * Math.cos(dec) * Math.cos(ra + zeta) + Math.cos(theta) * Math.sin(dec); + return [Math.atan2(a, b) + z, Math.asin(Math.max(-1, Math.min(1, c)))]; +} + +interface Horizontal { + azimuth: number; + elevation: number; +} + +export interface PlacedStar extends CatalogueStar, Horizontal { + /** Index into the catalogue. */ + index: number; +} + +/** The stars at or above `minElevation` degrees (and no fainter than `magLimit`) for the moment and place, brightest first. Degrees; azimuth clockwise from north; no refraction. */ +export function starsAt( + time: Date, + lat: number, + lon: number, + magLimit: number = MAG_LIMIT, + minElevation = -1 +): PlacedStar[] { + const out: PlacedStar[] = []; + catalogue().forEach((s, index) => { + if (s.mag > magLimit) return; + const [ra, dec] = precess(s.ra, s.dec, time); + const h = equatorialToHorizontal(ra, dec, time, lat, lon) as Horizontal; + if (h.elevation >= minElevation) out.push({ ...s, index, azimuth: h.azimuth, elevation: h.elevation }); + }); + return out; +} + +/** The constellation chains for the moment and place as azimuth and elevation (degrees), every vertex kept (the horizon is the ridge's to hide). */ +export function linesAt(time: Date, lat: number, lon: number): Horizontal[][] { + return lineChains().map((chain) => + chain.map((p) => { + const [ra, dec] = precess(p.ra, p.dec, time); + return equatorialToHorizontal(ra, dec, time, lat, lon) as Horizontal; + }) + ); +} From fe12e10f7c5007e79819fa21d5e4b809c45e13ac Mon Sep 17 00:00:00 2001 From: Meta Vens Date: Fri, 20 Nov 2026 20:44:11 +0100 Subject: [PATCH 08/24] Night: moon as key light, airglow floor, adapting exposure with partial adaptation and a scotopic grade nightSky.ts holds the night's photometry (moon magnitude by phase, Krisciunas & Schaefer; airglow; star radiance; colour from B-V). The moon gets its own atmosphere bake for the night state and lights the dome, the clouds, the haze lookup and the cards (replacing nightAmbient and the cel bands' sun at night). Night loses its fixed knots and 0.043 ceiling: it adapts like day with the targets scaled by partial adaptation, a scotopic grade (Jensen 2001 luminance, blue shift) before exposure in CPU and shader, NIGHT_CEILING tunable (1). The ink-ceiling test for night is dropped with the ceiling. Co-Authored-By: Claude Sonnet 5.5 --- .../features/scene/ridge/lightCards.test.ts | 79 +++++--- src/app/features/scene/ridge/lightCards.ts | 91 +++++++-- src/app/features/scene/ridge/nightSky.ts | 190 ++++++++++++++++++ src/app/features/scene/ridge/physicalSky.ts | 30 ++- src/app/features/scene/ridge/skyDome.ts | 21 +- src/app/features/scene/ridge/toneMap.test.ts | 73 ++++++- src/app/features/scene/ridge/toneMap.ts | 112 +++++++++-- src/app/features/scene/skyForState.test.ts | 9 +- 8 files changed, 512 insertions(+), 93 deletions(-) create mode 100644 src/app/features/scene/ridge/nightSky.ts diff --git a/src/app/features/scene/ridge/lightCards.test.ts b/src/app/features/scene/ridge/lightCards.test.ts index f9144a2c..adf3030a 100644 --- a/src/app/features/scene/ridge/lightCards.test.ts +++ b/src/app/features/scene/ridge/lightCards.test.ts @@ -103,18 +103,18 @@ describe('the lighting inputs', () => { it("takes the display of the sky's own fit, so terrain and sky share one exposure", () => { const l = lightingOf(manifest, sky(30)); expect([l.exposure, l.curve]).toEqual([12, LIFT_ONLY]); - expect(l.ambient).toEqual([0.1, 0.2, 0.3]); + [0.1, 0.2, 0.3].forEach((a, i) => expect(l.key.ambient[i]).toBeCloseTo(a, 6)); // plus the airglow's expect(l.logDMin).toBe(4.6); expect(l.logDSpan).toBeCloseTo(11.5 - 4.6, 12); }); it("gives the ground the sun's transmittance at its elevation, and none with the sun below the atmosphere's cut-off", () => { const l = lightingOf(manifest, sky(30)); - expect(l.sunTransmittance[0]).toBeCloseTo(0.9 * Math.sin(30 * RAD), 12); - expect(l.sunTransmittance[2]).toBeCloseTo(0.7 * Math.sin(30 * RAD), 12); - expect(lightingOf(manifest, sky(DEFAULT_LOOK.sunCutoffDeg - 1)).sunTransmittance).toEqual([0, 0, 0]); + expect(l.key.direct[0]).toBeCloseTo(0.9 * Math.sin(30 * RAD), 12); + expect(l.key.direct[2]).toBeCloseTo(0.7 * Math.sin(30 * RAD), 12); + expect(lightingOf(manifest, sky(DEFAULT_LOOK.sunCutoffDeg - 1)).key.direct).toEqual([0, 0, 0]); expect( - lightingOf(manifest, sky(DEFAULT_LOOK.sunCutoffDeg + 0.5)).sunTransmittance[0] + lightingOf(manifest, sky(DEFAULT_LOOK.sunCutoffDeg + 0.5)).key.direct[0] ).toBeGreaterThanOrEqual(0); }); @@ -137,9 +137,9 @@ describe('the lighting inputs', () => { const above = Math.floor((horizonRow / planeH) * SKY_LUT.h) - 6; expect(texel(0, above)[0]).toBeCloseTo( Math.sin(((horizonRow - rowAt(above)) / pxPerDegV) * RAD), - 9 + 7 // the airglow floor adds a few 1e-9 ); - expect(texel(0, SKY_LUT.h - 1)[0]).toBe(0); + expect(texel(0, SKY_LUT.h - 1)[0]).toBeCloseTo(0, 7); // The sun lies at 214 degrees, the middle of the window: the cosine from the sun is 1 there and falls to the sides. const mid = texel(SKY_LUT.w / 2, above)[1]; expect(mid).toBeGreaterThan(0.999); @@ -245,9 +245,9 @@ describe('the look reaches the shader', () => { const base = run(); const look = run({ hazeScale: 2 * DEFAULT_LOOK.hazeScale, ambientScale: 0.5 }); look.uExt.forEach((e, k) => expect(e).toBeCloseTo(2 * base.uExt[k], 12)); - expect(look.uAmbient[2]).toBeCloseTo(0.15, 12); + expect(look.uAmbient[2]).toBeCloseTo(0.15, 6); // plus the airglow's ambient expect( - lightingOf(manifest, sky30(), { ...DEFAULT_LOOK, sunCutoffDeg: 45 }).sunTransmittance + lightingOf(manifest, sky30(), { ...DEFAULT_LOOK, sunCutoffDeg: 45 }).key.direct ).toEqual([0, 0, 0]); }); }); @@ -265,33 +265,48 @@ function sky30(): PhysicalSky { } as unknown as PhysicalSky; } -describe('night ambient', () => { - const nightAtm = { +describe('night key light', () => { + const atmOf = (ambient: [number, number, number]) => ({ observerKm: 0.183, mieScale: 1, transmittanceToSpace: (_m: number, o: number[]) => o.fill(1), - irradiance: { direct: [0, 0, 0], ambient: [0.001, 0.001, 0.002] }, + irradiance: { direct: [0, 0, 0], ambient }, radiance: (_a: number, _b: number, o: number[]) => o.fill(0), - }; - const night = (state: string, nightAmbient?: [number, number, number]) => - lightingOf( - manifest, - { - state, - sun: { azimuth: 0, elevation: -30 }, - atm: nightAtm, - fit: { display: { exposure: 1, curve: LIFT_ONLY } }, - view: manifest.view, - } as unknown as PhysicalSky, - nightAmbient ? { ...DEFAULT_LOOK, nightAmbient } : DEFAULT_LOOK - ); - it('lights the ground at night, cool, and only at night', () => { - const n = night('night'); - const base = nightAtm.irradiance.ambient; - n.ambient.forEach((a, i) => expect(a).toBeGreaterThan(base[i])); - expect(n.ambient[2] - base[2]).toBeGreaterThan(n.ambient[0] - base[0]); - expect(night('dusk').ambient).toEqual(base); - expect(DEFAULT_LOOK.nightAmbient.every((c) => c > 0)).toBe(true); + }); + const night = (moonEl: number | undefined, state = 'night') => + lightingOf(manifest, { + state, + sun: { azimuth: 0, elevation: -30 }, + moon: { azimuth: 150, elevation: moonEl ?? -20 }, + night: + moonEl === undefined + ? {} + : { moon: { azimuth: 150, elevation: moonEl, ratio: 2.5e-6, atm: atmOf([0.4, 0.5, 0.8]) } }, + atm: atmOf([0.001, 0.001, 0.002]), + fit: { display: { exposure: 1, curve: LIFT_ONLY } }, + view: manifest.view, + } as unknown as PhysicalSky); + + it('is the moon at night: its direction, its irradiance ratio times the transmittance, its ambient scaled by the ratio', () => { + const l = night(40); + expect([l.key.azimuth, l.key.elevation]).toEqual([150, 40]); + expect(l.key.direct[0]).toBeCloseTo(2.5e-6, 12); + expect(l.key.ambient[2]).toBeGreaterThan(0.002); + expect(l.key.ambient[2]).toBeCloseTo(0.002 + 0.8 * 2.5e-6, 4); + }); + it('has no direct light with the moon down, and keeps the ambient (twilight and airglow)', () => { + const l = night(undefined); + expect(l.key.direct).toEqual([0, 0, 0]); + expect(l.key.ambient.every((a) => a > 0)).toBe(true); + }); + it('fades the moon out over the horizon', () => { + expect(night(-0.5).key.direct[0]).toBe(0); + expect(night(0.5).key.direct[0]).toBeGreaterThan(0); + expect(night(0.5).key.direct[0]).toBeLessThan(night(5).key.direct[0]); + }); + it('the sun lights the other states', () => { + const l = lightingOf(manifest, sky30()); + expect(l.key.elevation).toBe(30); }); }); diff --git a/src/app/features/scene/ridge/lightCards.ts b/src/app/features/scene/ridge/lightCards.ts index 29745834..5ffbd6fc 100644 --- a/src/app/features/scene/ridge/lightCards.ts +++ b/src/app/features/scene/ridge/lightCards.ts @@ -12,7 +12,8 @@ import { extinctionAt } from './earthAtmosphere'; import type { Vec3 } from './earthAtmosphere'; import type { RidgeManifest } from './manifest'; import type { PhysicalSky } from './physicalSky'; -import { ACES_FIT, ACES_IN, ACES_OUT, KNOTS } from './toneMap'; +import { addNightRadiance, airglow } from './nightSky'; +import { ACES_FIT, ACES_IN, ACES_OUT, KNOTS, SCOTOPIC } from './toneMap'; import type { Curve } from './toneMap'; import type { View } from './view'; @@ -71,8 +72,6 @@ export interface RidgeLook { groundNoise: number; /** Low-frequency noise darkening of the direct sun (static). 0 = none. */ cloudShadows: number; - /** Night's moonlight on the ground: the radiance of a white card in it (rgb, at the night exposure, before the curve); added only in the night state, where the atmosphere gives the ground none. A dim cool value. */ - nightAmbient: readonly [number, number, number]; /** Cel shading: the lit side of the relief (n.s) in this many flat bands instead of Lambert's ramp (0 = Lambert; at most `CEL_MAX`). */ celBands: number; /** Width of each band edge in n.s units (0 = hard). */ @@ -102,7 +101,6 @@ export const PHYSICAL_LOOK: RidgeLook = { inkScale: 1, groundNoise: 0, cloudShadows: 0, - nightAmbient: [0.5, 0.66, 1.1], celBands: 0, celSoftness: 0, celAmbientAway: 1, @@ -192,12 +190,54 @@ export interface Lighting { logDSpan: number; /** Per km of horizontal path, per channel. */ extinction: Vec3; - /** The sun's transmittance to the ground, per channel; zero with the sun below the atmosphere's cut-off. */ - sunTransmittance: Vec3; - ambient: Vec3; + /** Where the key light is (the sun by day and dusk, the moon at night) and what of it reaches the ground. */ + key: KeyLight; exposure: number; /** The sky's fitted curve (`toneMap.ts`), applied per channel after ACES. */ curve: Curve; + /** Weight of the scotopic grade (`toneMap.ts`), applied to the radiance before exposure. */ + grade: number; +} + +/** + * The key light of the ground and what it brings. Day and dusk: the sun, by its transmittance to the ground, cut off below `look.sunCutoffDeg`. + * Night: the moon, by its transmittance times its irradiance relative to the sun's (phase and distance, `nightSky.ts`), faded out over the + * horizon; it is the direction the cel bands are cut by, and what is left of it, the sun's twilight and the airglow, is the ambient. + * `direct` is per unit of sun irradiance, `ambient` the irradiance the sky and the airglow give a horizontal surface. + */ +export interface KeyLight { + azimuth: number; + elevation: number; + direct: Vec3; + ambient: Vec3; +} + +export function keyLight(sky: PhysicalSky, look: RidgeLook = DEFAULT_LOOK): KeyLight { + const ambient = scale3(sky.atm.irradiance.ambient, look.ambientScale); + const glow = [0, 0, 0]; + airglow(0.6, glow); + const base = add3(ambient, scale3([glow[0], glow[1], glow[2]], Math.PI)); + const trans = [0, 0, 0]; + if (sky.state === 'night') { + const m = sky.night.moon; + if (!m) return { azimuth: sky.moon.azimuth, elevation: sky.moon.elevation, direct: [0, 0, 0], ambient: base }; + m.atm.transmittanceToSpace(Math.max(Math.sin(m.elevation * RAD), 0), trans); + const fade = smooth(-0.5, 1.5, m.elevation) * m.ratio; + return { + azimuth: m.azimuth, + elevation: m.elevation, + direct: [trans[0] * fade, trans[1] * fade, trans[2] * fade], + ambient: add3(base, scale3(scale3(m.atm.irradiance.ambient, look.ambientScale), m.ratio)), + }; + } + sky.atm.transmittanceToSpace(Math.max(Math.sin(sky.sun.elevation * RAD), 0), trans); + const lit = sky.sun.elevation > look.sunCutoffDeg; + return { + azimuth: sky.sun.azimuth, + elevation: sky.sun.elevation, + direct: lit ? [trans[0], trans[1], trans[2]] : [0, 0, 0], + ambient: base, + }; } const scale3 = (v: Vec3, k: number): Vec3 => [v[0] * k, v[1] * k, v[2] * k]; @@ -208,23 +248,16 @@ export function lightingOf( sky: PhysicalSky, look: RidgeLook = DEFAULT_LOOK ): Lighting { - const trans = [0, 0, 0]; - const sinEl = Math.sin(sky.sun.elevation * RAD); - sky.atm.transmittanceToSpace(Math.max(sinEl, 0), trans); - const lit = sky.sun.elevation > look.sunCutoffDeg; return { planeW: manifest.view.planeW, planeH: manifest.view.planeH, logDMin: manifest.encoding.logDMin, logDSpan: manifest.encoding.logDMax - manifest.encoding.logDMin, extinction: scale3(extinctionAt(sky.atm.observerKm, sky.atm.mieScale), look.hazeScale), - sunTransmittance: lit ? [trans[0], trans[1], trans[2]] : [0, 0, 0], - ambient: add3( - scale3(sky.atm.irradiance.ambient, look.ambientScale), - sky.state === 'night' ? scale3(look.nightAmbient as Vec3, Math.PI) : [0, 0, 0] - ), + key: keyLight(sky, look), exposure: sky.fit.display.exposure, curve: sky.fit.display.curve, + grade: sky.fit.display.grade ?? 0, }; } @@ -250,6 +283,7 @@ export function skyLut(sky: PhysicalSky, view: View, w: number, h: number): Floa for (let i = 0; i < w; i += 1) { const az = columnAzimuth(view, ((i + 0.5) / w) * view.planeW - 0.5, view.planeW); sky.atm.radiance(Math.sin(elDeg * RAD), Math.cos((az - sky.sun.azimuth) * RAD), rgb); + addNightRadiance(sky.night, Math.sin(elDeg * RAD), az * RAD, rgb); out.set([rgb[0], rgb[1], rgb[2], 0], (j * w + i) * 4); } } @@ -276,6 +310,8 @@ uniform vec3 uExt; uniform vec3 uTSun; uniform vec3 uAmbient; uniform float uExposure; +uniform float uGrade; +uniform vec3 uScotTint; uniform float uCx[${KNOTS}]; uniform float uCy[${KNOTS}]; uniform float uCm[${KNOTS}]; @@ -306,6 +342,19 @@ ${[0, 1, 2] const vec3 FIT_AB = vec3(${glsl(ACES_FIT[0])}, ${glsl(ACES_FIT[1])}, 0.0); const vec3 FIT_CDE = vec3(${glsl(ACES_FIT[2])}, ${glsl(ACES_FIT[3])}, ${glsl(ACES_FIT[4])}); +// toneMap.ts scotopic: toward the rods' luminance (Jensen et al. 2001) in a blue-shifted grey, at weight w. +float scotLum(vec3 c) { + float X = dot(vec3(0.4124, 0.3576, 0.1805), c); + float Y = dot(vec3(0.2126, 0.7152, 0.0722), c); + float Z = dot(vec3(0.0193, 0.1192, 0.9505), c); + return max(0.0, Y * (1.33 * (1.0 + (Y + Z) / max(X, 1e-30)) - 1.68)); +} +vec3 scotopic(vec3 c, float w) { + if (w <= 0.0) return c; + float k = scotLum(c) / scotLum(vec3(1.0)); + return mix(c, k * uScotTint, w); +} + vec3 toLinear(vec3 c) { return mix(c / 12.92, pow((c + 0.055) / 1.055, vec3(2.4)), step(vec3(0.04045), c)); } @@ -432,7 +481,7 @@ void main() { } radiance *= 1.0 - (1.0 - keep) * uInkScale; - vec3 rgb = toSrgb(curve(aces(radiance * uExposure))); + vec3 rgb = toSrgb(curve(aces(scotopic(radiance, uGrade) * uExposure))); outColor = vec4(rgb * c.a, c.a); } `; @@ -526,8 +575,10 @@ export function lightCards( gl.uniform2f(u('uPlane'), lit.planeW, lit.planeH); gl.uniform2f(u('uLogD'), lit.logDMin, lit.logDSpan); gl.uniform3f(u('uExt'), ...lit.extinction); - gl.uniform3f(u('uTSun'), ...lit.sunTransmittance); - gl.uniform3f(u('uAmbient'), ...lit.ambient); + gl.uniform3f(u('uTSun'), ...lit.key.direct); + gl.uniform3f(u('uAmbient'), ...lit.key.ambient); + gl.uniform1f(u('uGrade'), lit.grade); + gl.uniform3f(u('uScotTint'), ...SCOTOPIC.tint); gl.uniform1f(u('uExposure'), lit.exposure); gl.uniform1fv(u('uCx'), lit.curve.x); gl.uniform1fv(u('uCy'), lit.curve.y); @@ -550,7 +601,7 @@ export function lightCards( gl.uniform1fv(u('uBandLevels'), celLevels(look.celBands, look.celBandLevels)); gl.uniform1f(u('uRadPerPx'), (manifest.view.windowDeg * RAD) / lit.planeW); gl.uniform2i(u('uSkySize'), SKY_LUT.w, SKY_LUT.h); - const sunTex = floatTexture(gl, 2, lit.planeW, 1, sunColumns(manifest.view, sky.sun)); + const sunTex = floatTexture(gl, 2, lit.planeW, 1, sunColumns(manifest.view, lit.key)); const skyTex = floatTexture( gl, 3, diff --git a/src/app/features/scene/ridge/nightSky.ts b/src/app/features/scene/ridge/nightSky.ts new file mode 100644 index 00000000..4bc63293 --- /dev/null +++ b/src/app/features/scene/ridge/nightSky.ts @@ -0,0 +1,190 @@ +// The night's light and bodies, in the units of the day sky: radiance per unit of the sun's irradiance (`skyDome.ts`). The sun is 1; the moon +// is its brightness by phase (Krisciunas & Schaefer 1991) times the atmosphere's response to a light at the moon's elevation +// (`earthAtmosphere.ts`, the same sky-view LUT, baked for the moon instead of the sun); the airglow is a floor; a star is its illuminance +// over the point spread it is drawn with. Everything marked EYEBALLED is a knob of the look, tuned by eye, not a measurement. +import { moonPhase, moonPosition } from '../../../../sky/moon.js'; +import type { Atmosphere, Vec3 } from './earthAtmosphere'; +import type { Place } from './view'; + +const RAD = Math.PI / 180; +const clamp = (x: number, lo: number, hi: number): number => Math.min(hi, Math.max(lo, x)); + +/** Illuminance in lux of a source of apparent visual magnitude `m` above the atmosphere (V = 0 is 2.13e-6 lux; the sun, V = -26.74, 1.06e5). */ +export const luxOfMagnitude = (m: number): number => 10 ** (-0.4 * (m + 14.18)); +export const SUN_V = -26.74; +/** The sun's illuminance, the unit of every radiance of the ridge sky. */ +export const SUN_LUX = luxOfMagnitude(SUN_V); + +/** The look of the night's bodies. EYEBALLED knobs: the operator tunes these by eye. */ +export const NIGHT_LOOK = { + /** Radius of the point spread a star's light is spread over, arcminutes: smaller is brighter and more of them saturate. */ + starPsfArcmin: 4, + /** Atmospheric extinction in magnitudes per air mass (V band, a clean low site is 0.2). */ + extinctionPerAirmass: 0.2, + /** + * Display contrast of a star over its sky is the physical contrast to this power (1 = physical): the eye and a camera cannot show a + * mag 0 star at the 1e4:1 it has over a dark sky. Brightest stars still saturate; the faintest keep a little. + */ + starContrastExp: 0.5, + /** The same for the moon's disc (physical contrast is 1e7 and more). */ + moonContrastExp: 0.3, + /** Visible radius of a star, CSS px: `base` for the faintest, plus `perMag` for each magnitude brighter than 5.5. */ + starRadius: { base: 0.45, perMag: 0.17 }, + /** The moon's disc, as a multiple of its true angular size (1 is true; a viewer's eye sees it larger than a lens does). */ + moonScale: 1, + /** Earthshine on the unlit part of the disc, as a fraction of the lit surface's radiance. */ + earthshine: 4e-5, + /** Constellation lines: opacity of the stroke (a pale blue-white) and its width in CSS px. */ + lines: { alpha: 0.22, widthPx: 0.9, rgb: [160, 185, 235] as const }, +}; + +// ---- Airglow ---------------------------------------------------------------------------------- + +/** Natural night-sky radiance at the zenith without moon or town, cd/m^2 (about 22 V mag/arcsec^2: 2.5e-4). */ +export const AIRGLOW_CD = 2.5e-4; +/** Its colour, linear, luminance 1 (a faint cool green-blue). EYEBALLED. */ +const AIRGLOW_TINT: Vec3 = [0.8, 1, 1.35]; +const AIRGLOW_NORM = 0.2126 * 0.8 + 0.7152 + 0.0722 * 1.35; + +/** The airglow floor, per unit of sun irradiance, at view elevation sine `vz` (brighter toward the horizon, van Rhijn). */ +export function airglow(vz: number, out: number[]): void { + const k = ((AIRGLOW_CD / SUN_LUX) * (0.6 + 1.4 * (1 - clamp(vz, 0, 1)))) / AIRGLOW_NORM; + out[0] += AIRGLOW_TINT[0] * k; + out[1] += AIRGLOW_TINT[1] * k; + out[2] += AIRGLOW_TINT[2] * k; +} + +// ---- Moon -------------------------------------------------------------------------------------- + +/** The moon over a place at a moment, with its light. */ +export interface MoonSample { + /** Degrees clockwise from north, and above the horizon (topocentric, no refraction). */ + azimuth: number; + elevation: number; + time: Date; + /** Lit fraction of the disc, and the sun-moon-earth angle in degrees (0 full, 180 new). */ + illuminated: number; + phaseAngleDeg: number; + waxing: boolean; + distanceKm: number; + /** Angular radius in radians. */ + radius: number; + /** The moon's illuminance relative to the sun's: its light on the ground per unit of the sun's. */ + ratio: number; +} + +/** The moon's visual magnitude at phase angle `alphaDeg`: Krisciunas & Schaefer 1991 (the Allen / Lane & Irvine fit) plus the distance. */ +export const moonMagnitude = (alphaDeg: number, distanceKm: number): number => { + const a = Math.abs(alphaDeg); + return -12.73 + 0.026 * a + 4e-9 * a ** 4 + 5 * Math.log10(distanceKm / 384400); +}; + +/** The moon's illuminance over the sun's. At full moon about 2.5e-6. */ +export const moonIrradianceRatio = (alphaDeg: number, distanceKm: number): number => + 10 ** (-0.4 * (moonMagnitude(alphaDeg, distanceKm) - SUN_V)); + +export function moonAt(place: Place, time: Date): MoonSample { + const p = moonPosition(time, place.lat, place.lon) as { elevation: number; azimuth: number }; + const ph = moonPhase(time) as { + illuminated: number; + phaseAngleDeg: number; + waxing: boolean; + distanceKm: number; + }; + return { + ...p, + time, + illuminated: ph.illuminated, + phaseAngleDeg: ph.phaseAngleDeg, + waxing: ph.waxing, + distanceKm: ph.distanceKm, + radius: Math.asin(1737.4 / ph.distanceKm), + ratio: moonIrradianceRatio(ph.phaseAngleDeg, ph.distanceKm), + }; +} + +/** + * The radiance of the moon's lit surface per unit of sun irradiance: its flux over the lit area of the disc. About 4000 cd/m^2 at full moon. + * `lit` is the lit fraction (at least a sliver, so a thin crescent's surface brightness stays finite). + */ +export const moonSurface = (m: MoonSample): number => + m.ratio / (Math.max(m.illuminated, 0.02) * Math.PI * m.radius * m.radius); + +// ---- The night's light, as the dome and the cards read it ------------------------------------ + +/** What lights the sky besides the sun: the moon (its own atmosphere bake, scaled by `ratio`) and the airglow. */ +export interface NightLight { + moon?: { azimuth: number; elevation: number; atm: Atmosphere; ratio: number }; +} + +/** + * Add the night's radiance (the moon's scattered light and the airglow, per unit of sun irradiance) for a view ray: `vz` the sine of its + * elevation, `azRad` its azimuth in radians, written onto `out`. + */ +export function addNightRadiance( + n: NightLight | undefined, + vz: number, + azRad: number, + out: number[] +): void { + airglow(vz, out); + if (!n?.moon) return; + const m = n.moon; + const tmp = [0, 0, 0]; + m.atm.radiance(vz, Math.cos(azRad - m.azimuth * RAD), tmp); + out[0] += tmp[0] * m.ratio; + out[1] += tmp[1] * m.ratio; + out[2] += tmp[2] * m.ratio; +} + +// ---- Stars ------------------------------------------------------------------------------------- + +/** Relative air mass, Kasten & Young 1989. Elevation in degrees. */ +export const airMass = (elDeg: number): number => + 1 / (Math.sin(Math.max(elDeg, 0) * RAD) + 0.50572 * Math.pow(Math.max(elDeg, 0) + 6.07995, -1.6364)); + +/** A star's magnitude after the air: extinction per air mass along its elevation. */ +export const extinguished = (mag: number, elDeg: number): number => + mag + NIGHT_LOOK.extinctionPerAirmass * airMass(elDeg); + +/** Linear sRGB colour of a black body of temperature `t` kelvin at luminance 1 (Kim et al. 2002 Planckian locus, sRGB primaries). */ +export function blackbodyRgb(t: number): Vec3 { + const T = clamp(t, 1700, 24000); + const x = + T <= 4000 + ? -0.2661239e9 / T ** 3 - 0.2343589e6 / T ** 2 + 0.8776956e3 / T + 0.17991 + : -3.0258469e9 / T ** 3 + 2.1070379e6 / T ** 2 + 0.2226347e3 / T + 0.24039; + const y = + T <= 2222 + ? -1.1063814 * x ** 3 - 1.3481102 * x ** 2 + 2.18555832 * x - 0.20219683 + : T <= 4000 + ? -0.9549476 * x ** 3 - 1.37418593 * x ** 2 + 2.09137015 * x - 0.16748867 + : 3.081758 * x ** 3 - 5.8733867 * x ** 2 + 3.75112997 * x - 0.37001483; + const X = x / y; + const Z = (1 - x - y) / y; + const rgb = [ + 3.2406 * X - 1.5372 - 0.4986 * Z, + -0.9689 * X + 1.8758 + 0.0415 * Z, + 0.0557 * X - 0.204 + 1.057 * Z, + ].map((c) => Math.max(0, c)); + const lum = 0.2126 * rgb[0] + 0.7152 * rgb[1] + 0.0722 * rgb[2]; + return [rgb[0] / lum, rgb[1] / lum, rgb[2] / lum]; +} + +/** Effective temperature of a star from its B-V colour index (Ballesteros 2012). */ +export const temperatureOfBV = (bv: number): number => { + const c = clamp(bv, -0.4, 2); + return 4600 * (1 / (0.92 * c + 1.7) + 1 / (0.92 * c + 0.62)); +}; + +/** A star's radiance when seen through the point spread, per unit of sun irradiance: its illuminance over the spread's solid angle. */ +export const starRadiance = (mag: number): number => { + const r = (NIGHT_LOOK.starPsfArcmin / 60) * RAD; + return luxOfMagnitude(mag) / (Math.PI * r * r) / SUN_LUX; +}; + +/** Perceptual compression of a body's contrast over the sky behind it: `bg` the sky's radiance, `add` the body's on top; the exponent 1 is physical. */ +export const compressed = (bg: number, add: number, exp: number): number => { + const b = Math.max(bg, 1e-30); + return b * ((b + add) / b) ** exp; +}; diff --git a/src/app/features/scene/ridge/physicalSky.ts b/src/app/features/scene/ridge/physicalSky.ts index f65497dd..6cc28fe2 100644 --- a/src/app/features/scene/ridge/physicalSky.ts +++ b/src/app/features/scene/ridge/physicalSky.ts @@ -9,6 +9,8 @@ import type { Dome } from './skyDome'; import type { Srgb } from './skyColour'; import { display8, fitDisplay, MARGIN } from './toneMap'; import type { Display, Fit } from './toneMap'; +import { moonAt } from './nightSky'; +import type { MoonSample, NightLight } from './nightSky'; import { sunForState } from './sunAt'; import type { SunSample } from './sunAt'; import { windowFor } from './view'; @@ -21,6 +23,10 @@ export interface PhysicalSky { /** Where the observer stands and where the planes look: the camera of any viewport is `windowFor(view, w, h).camera`. */ view: View; sun: SunSample; + /** The moon over the place at the sun's moment (`sun.time`): the night's key light, and a body in any sky it is above the horizon of. */ + moon: MoonSample; + /** What lights the sky besides the sun: at night, the moon above the horizon with its own atmosphere bake. */ + night: NightLight; weather: Weather; atm: Atmosphere; /** The display fitted to this sky's budget. */ @@ -67,13 +73,33 @@ export function makePhysicalSky( }); // A 16:9 viewport: the camera's fov and horizon fraction do not depend on its size, only on its shape. const { camera } = windowFor(view, CANON.w, CANON.h); - const dome = renderDome(atm, sun, camera, CANON.w, CANON.h, weather.cover); + // The moon is the night's light: its own bake of the same atmosphere, for a light at its elevation (the transmittance and the + // multiple-scattering tables do not depend on it, but the bake is one function). Only in the night state, and only above -2 degrees. + const moon = moonAt(view.place, sun.time); + const night: NightLight = + state === 'night' && moon.elevation > -2 + ? { + moon: { + azimuth: moon.azimuth, + elevation: moon.elevation, + ratio: moon.ratio, + atm: bakeAtmosphere({ + sunElevationDeg: moon.elevation, + mieScale: weather.mieScale, + observerKm: view.place.altitudeKm, + }), + }, + } + : {}; + const dome = renderDome(atm, sun, camera, CANON.w, CANON.h, weather.cover, night); const fit = fitDisplay(state, dome.hdr, dome.meanLuma); const at = (f: number) => rowMean(dome, fit.display, Math.round(f * CANON.h)); return { state, view, sun, + moon, + night, weather, atm, fit, @@ -96,7 +122,7 @@ export interface SkyPixels { /** The sky for a viewport seen through `camera` (`windowFor(p.view, cssW, cssH).camera`), as a small RGBA grid the host canvas upscales smoothly. */ export function paintSky(p: PhysicalSky, cssW: number, cssH: number, camera: Camera): SkyPixels { const { w, h } = domeSize(cssW, cssH); - const dome = renderDome(p.atm, p.sun, camera, w, h, p.weather.cover); + const dome = renderDome(p.atm, p.sun, camera, w, h, p.weather.cover, p.night); const data = new Uint8ClampedArray(w * h * 4); const out = [0, 0, 0]; const display = p.fit.display; diff --git a/src/app/features/scene/ridge/skyDome.ts b/src/app/features/scene/ridge/skyDome.ts index 0edb3e5f..913ae298 100644 --- a/src/app/features/scene/ridge/skyDome.ts +++ b/src/app/features/scene/ridge/skyDome.ts @@ -5,6 +5,8 @@ import type { Atmosphere } from './earthAtmosphere'; import type { SunSample } from './sunAt'; import type { Camera } from './view'; import { cloudAmount, cloudRadiance } from './clouds'; +import { addNightRadiance } from './nightSky'; +import type { NightLight } from './nightSky'; const RAD = Math.PI / 180; /** The sun's angular radius in radians (Hillaire's/Bruneton's `sun_angular_radius`). */ @@ -25,7 +27,7 @@ export const domeSize = (cssW: number, cssH: number): { w: number; h: number } = }); /** - * Render the HDR sky. Rays below the horizon take the horizon's radiance (the ridges cover them). The sun's disc is not here: it is smaller than a texel, so the host draws it on the upscaled canvas (`sunOnScreen`). `cover` (0..1, `weather.ts`) lays the cloud deck (`clouds.ts`) over it. + * Render the HDR sky: the sun's atmosphere, plus at night the moon's (`night`, scaled by its irradiance ratio) and the airglow. Rays below the horizon take the horizon's radiance (the ridges cover them). The sun's disc is not here: it is smaller than a texel, so the host draws it on the upscaled canvas (`sunOnScreen`). `cover` (0..1, `weather.ts`) lays the cloud deck (`clouds.ts`) over it. */ export function renderDome( atm: Atmosphere, @@ -33,7 +35,8 @@ export function renderDome( camera: Camera, w: number, h: number, - cover = 0 + cover = 0, + night?: NightLight ): Dome { const hdr = new Float32Array(w * h * 3); const sunAz = sun.azimuth * RAD; @@ -47,6 +50,19 @@ export function renderDome( const zenith = [0, 0, 0]; atm.radiance(1, 1, zenith); cloudRadiance(sz, trans, zenith, cover, cloud); + if (night?.moon) { + // The deck is moonlit as it is sunlit: the moon's own light through the air, scaled by its irradiance. + const m = night.moon; + const moonCloud = [0, 0, 0]; + const moonTrans = [0, 0, 0]; + const moonZenith = [0, 0, 0]; + m.atm.transmittanceToSpace(Math.max(Math.sin(m.elevation * RAD), 0), moonTrans); + m.atm.radiance(1, 1, moonZenith); + cloudRadiance(Math.sin(m.elevation * RAD), moonTrans, moonZenith, cover, moonCloud); + for (let i = 0; i < 3; i += 1) cloud[i] += moonCloud[i] * m.ratio; + } + // The airglow lights the deck too, at the zenith's strength. + addNightRadiance(undefined, 1, 0, cloud); } let logSum = 0; for (let j = 0; j < h; j += 1) { @@ -57,6 +73,7 @@ export function renderDome( const az = (camera.azimuthDeg + ((i + 0.5) / w - 0.5) * camera.hfovDeg) * RAD; const cosFromSun = Math.cos(az - sunAz); atm.radiance(vz, cosFromSun, rgb); + addNightRadiance(night, vz, az, rgb); let r = rgb[0]; let g = rgb[1]; let b = rgb[2]; diff --git a/src/app/features/scene/ridge/toneMap.test.ts b/src/app/features/scene/ridge/toneMap.test.ts index b6f0101a..536c0b1c 100644 --- a/src/app/features/scene/ridge/toneMap.test.ts +++ b/src/app/features/scene/ridge/toneMap.test.ts @@ -3,7 +3,8 @@ import { FALLBACK_VIEW } from './view'; import { makePhysicalSky } from './physicalSky'; import { renderDome } from './skyDome'; import { windowFor } from './view'; -import { applyCurve, BLACK_LIFT, BUDGET, NIGHT_LIFT, displayLumaOf, fitDisplay, makeCurve } from './toneMap'; +import { applyCurve, BLACK_LIFT, BUDGET, NIGHT_CEILING, NIGHT_LIFT, SCOTOPIC, displayLumaOf, fitDisplay, makeCurve, scotopic, scotopicWeight } from './toneMap'; +import { sunAt } from './sunAt'; import type { FixedSkyState } from '../skyState'; const sweep = (c: ReturnType) => @@ -29,7 +30,7 @@ describe('the tone curve', () => { describe.each(['day', 'dusk', 'night'] as FixedSkyState[])('the %s curve fitted to a sky', (state) => { const sky = makePhysicalSky(state, new Date('2026-06-21T10:40:00Z'), 0, FALLBACK_VIEW); const { camera } = windowFor(sky.view, 64, 36); - const dome = renderDome(sky.atm, sky.sun, camera, 64, 36, sky.weather.cover); + const dome = renderDome(sky.atm, sky.sun, camera, 64, 36, sky.weather.cover, sky.night); const b = BUDGET[state]; it('has the black lift constant at black and every texel inside the state budget', () => { @@ -42,12 +43,7 @@ describe.each(['day', 'dusk', 'night'] as FixedSkyState[])('the %s curve fitted for (let i = 1; i < v.length; i += 1) expect(v[i]).toBeGreaterThanOrEqual(v[i - 1] - 1e-12); }); - it('puts the curve through the targets at the fixed knots (a night sky carries nothing to fit)', () => { - if (!b.knots) return; - b.knots.forEach((k, i) => expect(applyCurve(sky.fit.display.curve, k)).toBeCloseTo(b.targets[i], 9)); - }); - - it.skipIf(b.knots !== undefined)('puts the sky percentiles on the targets (as far as the gain limit allows)', () => { + it('puts the sky percentiles on the targets (as far as the gain limit allows)', () => { const n = dome.hdr.length / 3; const ls: number[] = []; for (let i = 0; i < n; i += 1) @@ -57,9 +53,64 @@ describe.each(['day', 'dusk', 'night'] as FixedSkyState[])('the %s curve fitted const flat = fitDisplay(state, dome.hdr, dome.meanLuma); expect(flat.display).toEqual(sky.fit.display); // The curve is fitted on luminance and applied per channel, so the byte luminance is near its targets, not on them. The median is never limited; the outer two are at or below their targets by the gain limit only. - expect(at(0.5)).toBeGreaterThan(b.targets[1] * 0.75); - expect(at(0.5)).toBeLessThan(b.targets[1] * 1.25); - expect(at(0.95)).toBeLessThanOrEqual(b.targets[2] * 1.25 + 0.004); + const p = b.partial; + const level = p ? Math.min(p.levelMax, Math.max(p.levelMin, (dome.meanLuma / p.ref) ** (1 - p.exponent))) : 1; + expect(at(0.5)).toBeGreaterThan(b.targets[1] * level * 0.75); + // The scotopic grade lifts the blue channel, which the per-channel curve takes up faster than the luminance it was fitted on: night reads up to twice its target. + const slack = p ? 2.5 : 1.25; + expect(at(0.5)).toBeLessThan(b.targets[1] * level * slack); + expect(at(0.95)).toBeLessThanOrEqual(b.targets[2] * level * slack + 0.004); expect(at(0.05)).toBeLessThan(at(0.5)); }); }); + +describe('the night display', () => { + const night = (iso: string) => { + const t = new Date(iso); + return makePhysicalSky('night', t, 0, FALLBACK_VIEW, sunAt(FALLBACK_VIEW.place, t)); + }; + const fullMoon = night('2026-11-24T22:00:00Z'); + const newMoon = night('2026-12-09T20:00:00Z'); + + it('adapts the exposure to the sky: a moonless night is exposed far brighter than a moonlit one', () => { + expect(fullMoon.moon.illuminated).toBeGreaterThan(0.99); + expect(newMoon.moon.illuminated).toBeLessThan(0.1); + expect(newMoon.fit.display.exposure).toBeGreaterThan(10 * fullMoon.fit.display.exposure); + }); + + it('reads the new-moon night darker than the full-moon night (partial adaptation), by the level of the budget', () => { + const med = (p: ReturnType) => applyCurve(p.fit.display.curve, 0.5); + expect(med(newMoon)).toBeLessThan(0.6 * med(fullMoon)); + }); + + it('grades toward the rods at night and not by day', () => { + expect(fullMoon.fit.display.grade).toBeGreaterThan(0.8); + expect(newMoon.fit.display.grade).toBeGreaterThan(0.99); + expect(makePhysicalSky('day', new Date('2026-06-21T10:40:00Z'), 0, FALLBACK_VIEW).fit.display.grade ?? 0).toBe(0); + }); + + it('has no fixed night ceiling: the curve tops out at NIGHT_CEILING', () => { + expect(applyCurve(newMoon.fit.display.curve, 1)).toBe(NIGHT_CEILING); + expect(BUDGET.night.ceiling).toBe(NIGHT_CEILING); + }); +}); + +describe('the scotopic grade', () => { + it('leaves a neutral grey alone in hue, moves colour toward blue and darkens red against blue', () => { + const o = [0, 0, 0]; + scotopic(0.2, 0.2, 0.2, 1, o); + expect(o[0] / o[1]).toBeCloseTo(SCOTOPIC.tint[0] / SCOTOPIC.tint[1], 6); + scotopic(0.5, 0.1, 0.1, 1, o); + const red = [...o]; + scotopic(0.1, 0.1, 0.5, 1, o); + expect(o[2]).toBeGreaterThan(red[2]); + expect(red[0]).toBeLessThan(0.5); // red is nearly black to the rods + scotopic(0.3, 0.2, 0.1, 0, o); + expect(o).toEqual([0.3, 0.2, 0.1]); + }); + it('weighs 1 in the dark and 0 in daylight, falling through the mesopic range', () => { + expect(scotopicWeight(2e-9)).toBeCloseTo(1, 6); + expect(scotopicWeight(0.3)).toBe(0); + expect(scotopicWeight(1e-6)).toBeGreaterThan(scotopicWeight(1e-4)); + }); +}); diff --git a/src/app/features/scene/ridge/toneMap.ts b/src/app/features/scene/ridge/toneMap.ts index 1746b595..a33b7c92 100644 --- a/src/app/features/scene/ridge/toneMap.ts +++ b/src/app/features/scene/ridge/toneMap.ts @@ -3,13 +3,15 @@ // matrix), then the sRGB encode. A per-pixel function with no state, applied once to the baked sky (CPU: the scene is a 2D // canvas, there is no float render target to fall back from). // -// Exposure is chosen per sky state: the sky is physical radiance, so brightness is the camera's. Day and dusk expose to the -// sky's own luminance (adaptation); night is the physical dark. After ACES comes one more curve, per channel in display-linear: -// a monotone cubic through five knots, fitted per sky from the luminance distribution of the sky grid so that its 5th, 50th and -// 95th percentiles land on the state's target display luminances. The curve starts at a small black lift (BLACK_LIFT, the only -// absolute lift) and ends at white (day, dusk) or at the night ceiling (light ink needs a dark ground). It is fitted on the sky -// grid alone: the cards are not sampled, they ride the same curve. +// Exposure adapts to the sky's own luminance in every state (the sky is physical radiance, so brightness is the camera's); night +// adapts only in part (`Budget.partial`), so a new-moon night reads darker than a full-moon one. Before exposure a scotopic grade +// (`scotopic`: desaturation and a blue shift as the adapted luminance falls through the mesopic range) carries the night read. After +// ACES comes one more curve, per channel in display-linear: a monotone cubic through five knots, fitted per sky from the luminance +// distribution of the sky grid so that its 5th, 50th and 95th percentiles land on the state's target display luminances. The curve +// starts at a small black lift and ends at white, or at the state's ceiling when it has one. It is fitted on the sky grid alone: the +// cards are not sampled, they ride the same curve. import type { FixedSkyState } from '../skyState'; +import { SUN_LUX } from './nightSky'; type Rgb = readonly [number, number, number]; @@ -47,6 +49,43 @@ export function acesLinear(r: number, g: number, b: number, exposure: number, ou ); } +/** Scotopic luminance of linear sRGB (Jensen et al. 2001, from CIE XYZ): the response of the rods, which see red as nearly black. */ +export const scotopicLuminance = (r: number, g: number, b: number): number => { + const X = 0.4124 * r + 0.3576 * g + 0.1805 * b; + const Y = 0.2126 * r + 0.7152 * g + 0.0722 * b; + const Z = 0.0193 * r + 0.1192 * g + 0.9505 * b; + return Math.max(0, Y * (1.33 * (1 + (Y + Z) / Math.max(X, 1e-30)) - 1.68)); +}; + +/** + * The scotopic grade of linear radiance `r, g, b` at weight `w` (0 photopic .. 1 scotopic): toward the rods' luminance in a blue-shifted grey. A neutral grey keeps its luminance, so the grade moves colour more than brightness. Written into `out`. + * `lightCards.ts` writes the same into its shader. + */ +export function scotopic(r: number, g: number, b: number, w: number, out: number[]): void { + if (w <= 0) { + out[0] = r; + out[1] = g; + out[2] = b; + return; + } + const v = scotopicLuminance(r, g, b); + // Scale the rods' grey to the cones' luminance for a neutral, so only the colour is graded. + const grey = scotopicLuminance(1, 1, 1); + const k = v / grey; + for (let i = 0; i < 3; i += 1) { + const target = k * SCOTOPIC.tint[i]; + out[i] = [r, g, b][i] + (target - [r, g, b][i]) * w; + } +} + +/** How scotopic a sky is, 0..1, from its log-mean luminance per unit of sun irradiance: through the mesopic range (`SCOTOPIC`). */ +export function scotopicWeight(meanLuma: number): number { + const lg = Math.log10(Math.max(meanLuma * SUN_LUX, 1e-12)); + const [lo, hi] = SCOTOPIC.mesopic; + const t = Math.min(1, Math.max(0, (lg - lo) / (hi - lo))); + return SCOTOPIC.strength * (1 - t * t * (3 - 2 * t)); +} + /** The 8-bit sRGB of linear radiance, exposed and tone-mapped. */ export function toneMap8(r: number, g: number, b: number, exposure: number, out: number[]): void { acesLinear(r, g, b, exposure, out); @@ -74,8 +113,11 @@ export interface Budget { max: number; /** Display luminance the 5th, 50th and 95th percentile of the sky's luminance are mapped to. */ targets: readonly [number, number, number]; - /** Fixed knot positions (ACES output) for the three targets instead of the sky's percentiles: for a state whose sky carries no signal to fit (night: the sky is black, the cards are what the curve is for). */ - knots?: readonly [number, number, number]; + /** + * Partial adaptation: the targets are scaled by `(meanLuma / ref) ^ (1 - exponent)` (clamped to `levelMin`..`levelMax`) where `meanLuma` is the sky's + * log-mean luminance per unit of sun irradiance and `ref` the one the targets were set at. Exponent 1 is full adaptation (day, dusk). + */ + partial?: { ref: number; exponent: number; levelMin: number; levelMax: number }; /** The most the curve may steepen the sky's own spread about its median (display luminance per unit of ACES output): a nearly flat overcast sky is not blown up into a gradient. */ maxGain: number; } @@ -85,22 +127,37 @@ export const MARGIN = 0.004; /** The one absolute lift of day and dusk: what black is drawn as, display-linear. The rest of the range is made by the curve. */ export const BLACK_LIFT = 0.02; -/** Night's black lift: the whole night range is under its ceiling (0.043), so its black is lifted less. */ +/** Night's black lift: a little lower than day's, the darks stay soft rather than crushed. */ export const NIGHT_LIFT = 0.004; +/** The night's ceiling, display-linear: the top of its curve (1 is white). EYEBALLED: the operator tunes it by eye; the moon and the stars are drawn through the same display and need the room. */ +export const NIGHT_CEILING = 1; + +/** + * The scotopic grade (Thompson, Shirley & Ferwerda 2002; Kirk & O'Brien 2011; Jensen et al. 2001): `strength` scales it (EYEBALLED, 0 off), + * the mesopic range is log10 of the adapted luminance in cd/m^2 from `mesopic[0]` (fully scotopic) to `mesopic[1]` (fully photopic), + * and `tint` is the blue shift of the scotopic luminance (Jensen et al.). + */ +export const SCOTOPIC = { + strength: 1, + mesopic: [-2, 0.5] as const, + tint: [1.05, 0.97, 1.27] as const, +}; -/** Night wears light ink, whose dimmer foldout headers (L 0.386 on screen, rat-crest-a7c95ce-20261111) need a backdrop of at most 0.047. */ export const BUDGET: Record = { day: { floor: BLACK_LIFT - 0.001, lift: BLACK_LIFT, ceiling: 1, key: 0.45, min: 4, max: 60, targets: [0.22, 0.58, 0.9], maxGain: 4 }, dusk: { floor: BLACK_LIFT - 0.001, lift: BLACK_LIFT, ceiling: 1, key: 0.5, min: 4, max: 400, targets: [0.12, 0.45, 0.85], maxGain: 4 }, night: { floor: NIGHT_LIFT - 0.001, lift: NIGHT_LIFT, - ceiling: 0.047 - MARGIN, - min: 1, - max: 1, - knots: [0.002, 0.02, 0.15], - targets: [0.008, 0.018, 0.032], - maxGain: 1e6, + ceiling: NIGHT_CEILING, + key: 0.45, + min: 4, + max: 1e13, + targets: [0.012, 0.03, 0.07], + maxGain: 4, + // A full-moon sky is about 2e-7 of the sun's irradiance in radiance; a moonless one about 2e-9. Partial adaptation of 0.7 puts + // the second at about a quarter of the first. + partial: { ref: 2e-7, exponent: 0.7, levelMin: 0.2, levelMax: 1.3 }, }, }; @@ -158,11 +215,16 @@ export const LIFT_ONLY: Curve = makeCurve( export interface Display { exposure: number; curve: Curve; + /** Weight of the scotopic grade before exposure, 0 (photopic, the default) .. 1 (`scotopicWeight`). */ + grade?: number; } /** The 8-bit sRGB of linear radiance through a display. */ export function display8(r: number, g: number, b: number, d: Display, out: number[]): void { - acesLinear(r, g, b, d.exposure, out); + if (d.grade) { + scotopic(r, g, b, d.grade, out); + acesLinear(out[0], out[1], out[2], d.exposure, out); + } else acesLinear(r, g, b, d.exposure, out); for (let i = 0; i < 3; i += 1) out[i] = Math.round(encode(applyCurve(d.curve, out[i]))); } @@ -193,7 +255,7 @@ export interface Fit { /** * Choose the display of a sky, the one place brightness is decided. `hdr` is the grid's radiance (3 floats a texel) and `meanLuma` its - * log-mean luminance. Exposure is the state's key (adaptation). The curve is then fitted: the 5th, 50th and 95th percentile of the + * log-mean luminance. Exposure is the state's key (adaptation); the targets of a state with partial adaptation are scaled by the sky's level. The scotopic grade's weight comes from the sky's luminance. The curve is then fitted: the 5th, 50th and 95th percentile of the * grid's luminance after ACES go to the state's targets (the outer two held to the budget's `maxGain` times the sky's own spread about the median), * between a black lift below and white (or the night ceiling) above. Monotone by construction, so the ceiling holds for every texel * of every grid and card, and no pass over another viewport's grid is needed. @@ -207,13 +269,15 @@ export function fitDisplay(state: FixedSkyState, hdr: Float32Array, meanLuma: nu const n = hdr.length / 3; const tmp = [0, 0, 0]; const xs: number[] = []; + const grade = scotopicWeight(meanLuma); for (let i = 0; i < n; i += 1) { - acesLinear(hdr[i * 3], hdr[i * 3 + 1], hdr[i * 3 + 2], keyExposure, tmp); + scotopic(hdr[i * 3], hdr[i * 3 + 1], hdr[i * 3 + 2], grade, tmp); + acesLinear(tmp[0], tmp[1], tmp[2], keyExposure, tmp); xs.push(displayLuma(tmp)); } xs.sort((p, q) => p - q); const pct = (q: number) => xs[Math.min(n - 1, Math.floor(q * n))]; - const x = [0, ...(b.knots ?? [pct(0.05), pct(0.5), pct(0.95)]), 1]; + const x = [0, pct(0.05), pct(0.5), pct(0.95), 1]; x[1] = Math.max(x[1], 1e-7); x[2] = Math.max(x[2], x[1] * 1.001 + 1e-7); x[3] = Math.max(x[3], x[2] * 1.001 + 1e-7); @@ -222,7 +286,11 @@ export function fitDisplay(state: FixedSkyState, hdr: Float32Array, meanLuma: nu x[2] = Math.min(x[2], 0.965); x[1] = Math.min(x[1], 0.96); } - const [t0, t1, t2] = b.targets; + const p = b.partial; + const level = p + ? Math.min(p.levelMax, Math.max(p.levelMin, (Math.max(meanLuma, 1e-30) / p.ref) ** (1 - p.exponent))) + : 1; + const [t0, t1, t2] = b.targets.map((t) => t * level); const y = [ b.lift, Math.max(b.lift + 1e-4, t0, t1 - b.maxGain * (x[2] - x[1])), @@ -232,7 +300,7 @@ export function fitDisplay(state: FixedSkyState, hdr: Float32Array, meanLuma: nu ]; y[1] = Math.min(y[1], y[2] - 1e-4); y[3] = Math.max(y[3], y[2] + 1e-4); - const display: Display = { exposure: keyExposure, curve: makeCurve(x, y) }; + const display: Display = { exposure: keyExposure, curve: makeCurve(x, y), grade }; let lo = 2; let hi = -1; const stride = Math.max(1, Math.floor(n / 4000)); diff --git a/src/app/features/scene/skyForState.test.ts b/src/app/features/scene/skyForState.test.ts index 237c1f5a..f5fab324 100644 --- a/src/app/features/scene/skyForState.test.ts +++ b/src/app/features/scene/skyForState.test.ts @@ -92,11 +92,12 @@ describe('ridgeSkyFor', () => { expect(ridgeSkyKey('day', FALLBACK_VIEW, 0.3)).not.toBe(ridgeSkyKey('night', FALLBACK_VIEW, 0.3)); }); - it.each(STATES)('%s: the display is the curve of its budget: black lift at the floor, the ceiling the light ink needs', (state) => { - const { ceiling } = needs(state); + // Night has no ink ceiling: its display top is a tunable (NIGHT_CEILING, ruling ridge-night-real-sky: the operator tunes it by eye), + // because the moon and the stars are drawn through the same display. + it.each(STATES)('%s: the display is the curve of its budget: black lift at the floor, and its ceiling', (state) => { const r = ridgeDrawn(state); expect(r.darkest).toBe(BUDGET[state].floor); - expect(r.lightest).toBeLessThanOrEqual(ceiling); + if (state !== 'night') expect(r.lightest).toBeLessThanOrEqual(needs(state).ceiling); const fit = ridgeSkyFor(state, FALLBACK_VIEW, 0.3).physical?.fit; expect(fit?.lo).toBeGreaterThanOrEqual(r.darkest - 1e-9); expect(fit?.hi).toBeLessThanOrEqual(r.lightest + 1e-9); @@ -104,7 +105,7 @@ describe('ridgeSkyFor', () => { }); describe('skyBackdrop holds the ridge sky', () => { - it.each(STATES)('%s: the backdrop bound contains the ridge display ceiling', (state) => { + it.each(['day', 'dusk'] as const)('%s: the backdrop bound contains the ridge display ceiling', (state) => { expect(skyBackdrop(state).lightest).toBeGreaterThanOrEqual(ridgeDrawn(state).lightest); }); }); From 05cff53959695fe095ddea1375bf9fe842749c4e Mon Sep 17 00:00:00 2001 From: Meta Vens Date: Fri, 20 Nov 2026 20:48:29 +0100 Subject: [PATCH 09/24] Stars, moon and constellation lines drawn through the sky's display; the seeded star field and NIGHT_LUMA gating are deleted nightBodies.ts places the catalogue stars for the sky's own moment, adds their radiance (extinction, B-V colour, point spread) to the dome behind them and takes the sky's display, so twilight hides them; the moon is drawn with its terminator and earthshine; lines over the stars when asked. stars.ts keeps the twinkle schedule, now a gain on a star's flux. Ridge.ts bakes the bodies and takes a lines option. Co-Authored-By: Claude Sonnet 5.5 --- src/app/features/scene/ridge/Ridge.test.ts | 27 +- src/app/features/scene/ridge/Ridge.ts | 29 +- .../features/scene/ridge/nightBodies.test.ts | 129 +++++++++ src/app/features/scene/ridge/nightBodies.ts | 266 ++++++++++++++++++ src/app/features/scene/ridge/stars.test.ts | 69 +---- src/app/features/scene/ridge/stars.ts | 129 ++------- 6 files changed, 451 insertions(+), 198 deletions(-) create mode 100644 src/app/features/scene/ridge/nightBodies.test.ts create mode 100644 src/app/features/scene/ridge/nightBodies.ts diff --git a/src/app/features/scene/ridge/Ridge.test.ts b/src/app/features/scene/ridge/Ridge.test.ts index 646fab95..39b93421 100644 --- a/src/app/features/scene/ridge/Ridge.test.ts +++ b/src/app/features/scene/ridge/Ridge.test.ts @@ -3,7 +3,8 @@ import { createRidgeScene } from './Ridge'; import { valueNoise, hash2 } from './noise'; import { FrameSampler, frameStats, SLOW_P95_MS, WARMUP_FRAMES, WINDOW_MS } from './probe'; import type { SkyColours } from './skyColour'; -import { makeStars } from './stars'; +import { nightBodies } from './nightBodies'; +import { sunAt } from './sunAt'; import { makePhysicalSky, paintSky as paintPhysicalSky } from './physicalSky'; import { startBackgroundScene } from '../index'; import { parseManifest } from './manifest'; @@ -158,6 +159,8 @@ function ctx() { }, rect() {}, clip() {}, + rotate() {}, + ellipse() {}, createImageData: (w: number, h: number) => ({ data: new Uint8ClampedArray(w * h * 4), width: w, @@ -377,13 +380,15 @@ describe('the door', () => { describe('the starfield in the scene', () => { const count = (kind: string) => draws.filter((d) => d === kind).length; - const night = { - ...DAY, - top: [10, 14, 40], - mid: [30, 34, 80], - horizon: [60, 50, 90], - } as SkyColours; - const N = makeStars(night, 400, 800).length; + // A moonless-horizon night over Vienna (the moon is 17 degrees below it): the real stars of that moment, and no moon to count as an arc. + const t = new Date('2026-12-04T00:00:00Z'); + const physical = makePhysicalSky('night', t, 0, FALLBACK_VIEW, sunAt(FALLBACK_VIEW.place, t)); + const night: SkyColours = { ...DAY, physical }; + const N = nightBodies( + physical, + paintPhysicalSky(physical, 400, 800, windowFor(FALLBACK_VIEW, 400, 800).camera), + false + ).stars.length; const hear = (name: string) => { const calls = motion.addEventListener.mock.calls.filter((c: any[]) => c[0] === name); return calls[calls.length - 1][1] as () => void; @@ -395,7 +400,7 @@ describe('the starfield in the scene', () => { const { parent, canvas } = host(); const s = createRidgeScene({ canvas, tier: 'full', sky: night })!; expect(count('star')).toBe(N); - expect(count('sky')).toBe(1); + expect(painted).toHaveLength(1); // the physical sky's one grid expect(parent.children[1].anims).toHaveLength(0); // the overlay, above the sky expect(parent.children).toHaveLength(2); const before = baked(); @@ -403,8 +408,8 @@ describe('the starfield in the scene', () => { expect(baked()).toBe(before); expect(count('clear')).toBeGreaterThan(60); expect(count('clear')).toBeLessThanOrEqual(101); - // each pass paints at most SLOTS stars - expect(count('twinkle')).toBeLessThanOrEqual(count('clear') * 32); + // each pass paints at most SLOTS stars, each as its cover and the star again + expect(count('twinkle')).toBeLessThanOrEqual(count('clear') * 64); expect(count('twinkle')).toBeGreaterThan(0); s.dispose(); }); diff --git a/src/app/features/scene/ridge/Ridge.ts b/src/app/features/scene/ridge/Ridge.ts index 5cbc0cfd..639c4df1 100644 --- a/src/app/features/scene/ridge/Ridge.ts +++ b/src/app/features/scene/ridge/Ridge.ts @@ -4,7 +4,9 @@ import { FrameSampler, FrameStats } from './probe'; import { skyColours, SkyColours, Srgb } from './skyColour'; import { paintSky as paintPhysicalSky } from './physicalSky'; import { cardMotion, windowFor } from './view'; -import { activeAt, drawStars, drawTwinkle as paintTwinkle, makeStars, Star } from './stars'; +import { activeAt, drawTwinkle as paintTwinkle, Star } from './stars'; +import { nightBodies, paintNightBodies } from './nightBodies'; +import type { NightBodies } from './nightBodies'; import { drawRainTile, RAIN_TILES } from './rain'; import type { Backdrop } from './Backdrop'; @@ -19,6 +21,8 @@ export type RidgeOptions = Pick & { sky?: SkyColours; /** The baked ridge cards, already lit for `sky` (`Backdrop.ts`); none is the sky-only scene (`view.ts` FALLBACK_VIEW). */ backdrop?: Backdrop; + /** Draw the constellation lines over the stars (a hidden extra, `skyState.ts`); only a night sky shows them. */ + lines?: boolean; }; const css = (c: Srgb): string => `rgb(${c[0]},${c[1]},${c[2]})`; @@ -55,9 +59,9 @@ function paintSky( cssW: number, cssH: number, makeCanvas: () => HTMLCanvasElement -): boolean { +): { ok: boolean; px?: ReturnType } { const ctx = context2d(canvas); - if (!ctx) return false; + if (!ctx) return { ok: false }; if (sky.physical) { const px = paintPhysicalSky( sky.physical, @@ -77,7 +81,7 @@ function paintSky( ctx.imageSmoothingQuality = 'high'; ctx.drawImage(small, 0, 0, canvas.width, canvas.height); if (px.sunDisc) drawSun(ctx, px.sunDisc, canvas.width, canvas.height); - return true; + return { ok: true, px }; } } const g = ctx.createLinearGradient(0, 0, 0, canvas.height); @@ -87,7 +91,7 @@ function paintSky( g.addColorStop(1, css(sky.horizon)); ctx.fillStyle = g; ctx.fillRect(0, 0, canvas.width, canvas.height); - return true; + return { ok: true }; } const clock = (): number => (typeof performance !== 'undefined' ? performance.now() : Date.now()); @@ -293,12 +297,17 @@ export function createRidgeScene(opts: RidgeOptions): Scene | null { const { w, h, scale } = viewSize(); canvas.width = Math.round(w * scale); canvas.height = Math.round(h * scale); - if (!paintSky(canvas, sky, w, h, () => document.createElement('canvas'))) return false; - // Every star is baked into the sky; the twinkling ones get their own canvas, which a per-frame - // pass clears and paints over. 'still' has no overlay. - const stars = makeStars(sky, w, h); + const painted = paintSky(canvas, sky, w, h, () => document.createElement('canvas')); + if (!painted.ok) return false; + // The real stars, the moon and (when asked) the constellation lines are baked into the sky; the twinkling stars get their own + // canvas, which a per-frame pass clears and paints over. 'still' has no overlay. A sky with no physical model has no bodies. + const bodies: NightBodies = + painted.px && sky.physical + ? nightBodies(sky.physical, painted.px, opts.lines === true) + : { stars: [], lines: [] }; + const stars = bodies.stars; const skyCtx = context2d(canvas); - if (skyCtx) drawStars(skyCtx, stars, canvas.width, canvas.height, scale); + if (skyCtx) paintNightBodies(skyCtx, bodies, canvas.width, canvas.height, scale); let twinkle: HTMLCanvasElement | undefined; if (stars.length && tier !== 'still') { twinkle = document.createElement('canvas'); diff --git a/src/app/features/scene/ridge/nightBodies.test.ts b/src/app/features/scene/ridge/nightBodies.test.ts new file mode 100644 index 00000000..0daab8c2 --- /dev/null +++ b/src/app/features/scene/ridge/nightBodies.test.ts @@ -0,0 +1,129 @@ +import { describe, expect, it } from 'vitest'; +import { limbAngle, nightBodies, onScreen, paintNightBodies } from './nightBodies'; +import { makePhysicalSky, paintSky } from './physicalSky'; +import { sunAt } from './sunAt'; +import { FALLBACK_VIEW } from './view'; +import type { Camera } from './view'; +import { MAG_LIMIT, starsAt } from './starCatalogue'; +import { moonAt } from './nightSky'; + +const P = FALLBACK_VIEW.place; +// A camera that sees most of the sky, so the moon of any hour is in it (the app's own window looks 72 degrees wide over the south-west). +const camera: Camera = { azimuthDeg: 180, hfovDeg: 340, vfovDeg: 170, horizonAt: 0.92 }; + +const sky = (iso: string, state: 'day' | 'dusk' | 'night' = 'night') => { + const t = new Date(iso); + return makePhysicalSky(state, t, 0, FALLBACK_VIEW, sunAt(P, t)); +}; +const bodies = (iso: string, state: 'day' | 'dusk' | 'night' = 'night', lines = false) => { + const p = sky(iso, state); + return { p, nb: nightBodies(p, paintSky(p, 640, 360, camera), lines) }; +}; + +// 2026-11-24 22:00 UTC: full moon high in the south over Vienna. 2026-12-09 20:00 UTC: new moon. 2026-12-04 00:00 UTC: no moon up. +const FULL = '2026-11-24T22:00:00Z'; +const NEW = '2026-12-09T20:00:00Z'; +const MOONLESS = '2026-12-04T00:00:00Z'; + +describe('the stars of a night sky', () => { + it('are the catalogue stars of the sky\'s own moment inside the camera, brightest drawn largest', () => { + const { nb } = bodies(MOONLESS); + expect(nb.stars.length).toBeGreaterThan(300); + const inView = starsAt(new Date(MOONLESS), P.lat, P.lon, MAG_LIMIT, -0.5).filter((s) => { + const a = onScreen(camera, s.azimuth, s.elevation); + return a.x > -0.02 && a.x < 1.02 && a.y > -0.02 && a.y < 1.02; + }); + expect(nb.stars.length).toBeLessThanOrEqual(inView.length); + const radii = nb.stars.map((s) => s.r); + expect(Math.max(...radii)).toBeGreaterThan(1.2 * Math.min(...radii)); + }); + + it('are hidden by the twilight that exposes the sky: none at dusk, none by day, more on a moonless night than a full-moon one', () => { + expect(bodies('2026-06-21T10:40:00Z', 'day').nb.stars).toHaveLength(0); + expect(bodies('2026-12-04T15:20:00Z', 'dusk').nb.stars.length).toBeLessThan(5); + expect(bodies(MOONLESS).nb.stars.length).toBeGreaterThan(bodies(FULL).nb.stars.length); + }); + + it('move with the clock: three hours later the field is a different one, rotated by 45 degrees about the pole', () => { + const a = bodies('2026-12-04T00:00:00Z').nb.stars.slice(0, 20).map((s) => s.x.toFixed(3)).join(); + const b = bodies('2026-12-04T03:00:00Z').nb.stars.slice(0, 20).map((s) => s.x.toFixed(3)).join(); + expect(a).not.toBe(b); + }); + + it('twinkle by flux: a star dimmed by its gain is closer to the sky behind it, brightened is lighter, base is its fill', () => { + const { nb } = bodies(MOONLESS); + const s = nb.stars[0]; + const lum = (c: string) => c.match(/\d+/g)!.map(Number).reduce((a, b) => a + b, 0); + expect(s.shade(1)).toBe(s.fill); + expect(lum(s.shade(0.35))).toBeLessThanOrEqual(lum(s.fill)); + expect(lum(s.shade(1.15))).toBeGreaterThanOrEqual(lum(s.fill)); + expect(lum(s.cover)).toBeLessThan(lum(s.fill)); + }); +}); + +describe('the moon of a night sky', () => { + it('is drawn where the ephemeris puts it, with the real phase', () => { + const { p, nb } = bodies(FULL); + expect(nb.moon).toBeDefined(); + expect(nb.moon!.illuminated).toBeGreaterThan(0.99); + const at = onScreen(camera, p.moon.azimuth, p.moon.elevation); + expect(nb.moon!.x).toBeCloseTo(at.x, 9); + expect(nb.moon!.y).toBeCloseTo(at.y, 9); + // 0.52 degrees across, vertical field of view a few tens of degrees + expect(nb.moon!.radius * camera.vfovDeg).toBeCloseTo((p.moon.radius * 180) / Math.PI, 6); + }); + + it('is a thin sliver near new moon and not drawn when it is below the horizon', () => { + expect(moonAt(P, new Date(NEW)).illuminated).toBeLessThan(0.05); + expect(bodies(MOONLESS).nb.moon).toBeUndefined(); + }); + + it('points its bright limb at the sun: down and toward the sun at moonrise after sunset, up at moonset in the morning', () => { + // A moon due south at 30 degrees with the sun at the horizon due west: the limb leans to the right (east is left on screen looking south, west right). + const a = limbAngle({ azimuth: 180, elevation: 30 }, { azimuth: 270, elevation: 0 }); + expect(Math.cos(a)).toBeGreaterThan(0.5); + expect(Math.sin(a)).toBeLessThan(0); + // Sun straight below the moon: the limb points down the screen. + expect(Math.sin(limbAngle({ azimuth: 180, elevation: 30 }, { azimuth: 180, elevation: -30 }))).toBeLessThan(-0.99); + }); + + it('is lighter than the sky around it, and its dark side lighter than the sky', () => { + const { nb } = bodies(FULL); + const lum = (c: string) => c.match(/\d+/g)!.map(Number).reduce((a, b) => a + b, 0); + expect(lum(nb.moon!.lit)).toBeGreaterThan(lum(nb.moon!.dark)); + expect(lum(nb.moon!.lit)).toBeGreaterThan(450); + }); +}); + +describe('the constellation lines', () => { + it('are absent unless asked for, and present for a night sky when they are', () => { + expect(bodies(MOONLESS, 'night', false).nb.lines).toHaveLength(0); + const on = bodies(MOONLESS, 'night', true).nb.lines; + expect(on.length).toBeGreaterThan(20); + expect(on.every((l) => l.points.length > 1)).toBe(true); + }); + + it('are not drawn in a day or dusk sky even when asked for', () => { + expect(bodies('2026-06-21T10:40:00Z', 'day', true).nb.lines).toHaveLength(0); + expect(bodies('2026-12-04T15:20:00Z', 'dusk', true).nb.lines).toHaveLength(0); + }); +}); + +describe('painting', () => { + it('draws lines, stars and the moon in that order and builds the terminator from an ellipse', () => { + const calls: string[] = []; + const ctx = new Proxy( + {}, + { + get: (_t, k) => (k === 'save' ? () => 0 : () => calls.push(String(k))), + set: () => true, + } + ) as unknown as CanvasRenderingContext2D; + const { nb } = bodies(FULL, 'night', true); + paintNightBodies(ctx, nb, 1280, 720, 2); + expect(calls.indexOf('stroke')).toBeGreaterThanOrEqual(0); + expect(calls.indexOf('stroke')).toBeLessThan(calls.indexOf('arc')); + expect(calls).toContain('ellipse'); + expect(calls.filter((c) => c === 'arc').length).toBeGreaterThanOrEqual(nb.stars.length + 2); + }); +}); diff --git a/src/app/features/scene/ridge/nightBodies.ts b/src/app/features/scene/ridge/nightBodies.ts new file mode 100644 index 00000000..a4b482ca --- /dev/null +++ b/src/app/features/scene/ridge/nightBodies.ts @@ -0,0 +1,266 @@ +// The night's bodies on the sky canvas: the real stars (`starCatalogue.ts`, for the place and the moment the sky state draws, `sun.time`), +// the moon with its phase, and the constellation lines. Each body's radiance (`nightSky.ts`) is added to the sky's own radiance behind it +// (the dome's grid, `skyDome.ts`) and goes through the sky's display (exposure, scotopic grade, ACES, curve), so the twilight that brightens the sky +// hides them, as a camera's exposure would, and the cards share the display. A body's contrast is compressed (`NIGHT_LOOK`): see there. +import { display8 } from './toneMap'; +import { blackbodyRgb, compressed, extinguished, NIGHT_LOOK, moonSurface, starRadiance, temperatureOfBV } from './nightSky'; +import type { Dome } from './skyDome'; +import type { PhysicalSky, SkyPixels } from './physicalSky'; +import { linesAt, MAG_LIMIT, starsAt } from './starCatalogue'; +import type { Star } from './stars'; + +const RAD = Math.PI / 180; +const luma = (c: ArrayLike): number => 0.2126 * c[0] + 0.7152 * c[1] + 0.0722 * c[2]; +const css = (c: ArrayLike): string => `rgb(${c[0]},${c[1]},${c[2]})`; +const wrap180 = (d: number): number => ((((d + 180) % 360) + 360) % 360) - 180; + +/** Where a direction is on the image (the camera's angle-linear mapping, `view.ts`), as fractions of its width and height (y down). */ +export function onScreen( + camera: SkyPixels['camera'], + azimuth: number, + elevation: number +): { x: number; y: number } { + return { + x: 0.5 + wrap180(azimuth - camera.azimuthDeg) / camera.hfovDeg, + y: camera.horizonAt - elevation / camera.vfovDeg, + }; +} + +/** The dome's radiance behind a point of the image (fractions), bilinear between texel centres. */ +export function domeAt(dome: Dome, x: number, y: number, out: number[]): void { + const fx = Math.min(dome.w - 1, Math.max(0, x * dome.w - 0.5)); + const fy = Math.min(dome.h - 1, Math.max(0, y * dome.h - 0.5)); + const i0 = Math.floor(fx); + const j0 = Math.floor(fy); + const i1 = Math.min(dome.w - 1, i0 + 1); + const j1 = Math.min(dome.h - 1, j0 + 1); + const tx = fx - i0; + const ty = fy - j0; + for (let k = 0; k < 3; k += 1) { + const at = (i: number, j: number) => dome.hdr[(j * dome.w + i) * 3 + k]; + out[k] = + (at(i0, j0) * (1 - tx) + at(i1, j0) * tx) * (1 - ty) + (at(i0, j1) * (1 - tx) + at(i1, j1) * tx) * ty; + } +} + +/** `bg` plus a body of radiance `add` on it, the contrast compressed to the power `exp` (1 physical), as linear rgb into `out`. */ +function composite(bg: number[], add: number[], exp: number, out: number[]): void { + const total = luma(bg) + luma(add); + const k = total > 0 ? compressed(luma(bg), luma(add), exp) / total : 1; + for (let i = 0; i < 3; i += 1) out[i] = (bg[i] + add[i]) * k; +} + +export interface MoonDraw { + x: number; + y: number; + /** Radius as a fraction of the image height. */ + radius: number; + /** Lit fraction of the disc and the phase angle (0 full) in radians. */ + illuminated: number; + phaseAngle: number; + /** Direction of the bright limb on the image, radians counter-clockwise from the right. */ + limb: number; + lit: string; + dark: string; +} + +export interface LineDraw { + /** Polyline in image fractions. */ + points: { x: number; y: number }[]; +} + +export interface NightBodies { + stars: Star[]; + moon?: MoonDraw; + lines: LineDraw[]; +} + +/** Unit vector (east, north, up) of a direction. */ +const vec = (az: number, el: number): [number, number, number] => [ + Math.cos(el * RAD) * Math.sin(az * RAD), + Math.cos(el * RAD) * Math.cos(az * RAD), + Math.sin(el * RAD), +]; + +/** The screen direction (radians, counter-clockwise from the right) from the moon toward `toward`, by the tangent of the great circle at the moon. */ +export function limbAngle(moon: { azimuth: number; elevation: number }, toward: { azimuth: number; elevation: number }): number { + const m = vec(moon.azimuth, moon.elevation); + const s = vec(toward.azimuth, toward.elevation); + const d = m[0] * s[0] + m[1] * s[1] + m[2] * s[2]; + const t = [s[0] - d * m[0], s[1] - d * m[1], s[2] - d * m[2]]; + const az = moon.azimuth * RAD; + const el = moon.elevation * RAD; + const east = [Math.cos(az), -Math.sin(az), 0]; + const up = [-Math.sin(el) * Math.sin(az), -Math.sin(el) * Math.cos(az), Math.cos(el)]; + return Math.atan2(t[0] * up[0] + t[1] * up[1] + t[2] * up[2], t[0] * east[0] + t[1] * east[1] + t[2] * east[2]); +} + +/** Great-circle subdivision of a chain's legs, as az/el. */ +function slerp(a: { azimuth: number; elevation: number }, b: { azimuth: number; elevation: number }, n: number) { + const u = vec(a.azimuth, a.elevation); + const v = vec(b.azimuth, b.elevation); + const w = Math.acos(Math.min(1, Math.max(-1, u[0] * v[0] + u[1] * v[1] + u[2] * v[2]))); + if (w < 1e-6) return [a]; + return Array.from({ length: n + 1 }, (_, i) => { + const t = i / n; + const s0 = Math.sin((1 - t) * w) / Math.sin(w); + const s1 = Math.sin(t * w) / Math.sin(w); + const p = [0, 1, 2].map((k) => s0 * u[k] + s1 * v[k]); + return { + azimuth: ((Math.atan2(p[0], p[1]) / RAD) % 360 + 360) % 360, + elevation: Math.asin(Math.min(1, Math.max(-1, p[2]))) / RAD, + }; + }); +} + +/** + * The stars, moon and (when asked, and only in the night state) constellation lines of a physical sky as seen through the camera of `px` + * (`paintSky`'s grid and the dome behind it). The moment is the sky's own, `p.sun.time`, so the bodies agree with the light. + */ +export function nightBodies(p: PhysicalSky, px: SkyPixels, withLines: boolean): NightBodies { + const { place } = p.view; + const { camera, dome } = px; + const display = p.fit.display; + const bg = [0, 0, 0]; + const add = [0, 0, 0]; + const tot = [0, 0, 0]; + const out = [0, 0, 0]; + const stars: Star[] = []; + for (const s of starsAt(p.sun.time, place.lat, place.lon, MAG_LIMIT, -0.5)) { + const at = onScreen(camera, s.azimuth, s.elevation); + if (at.x < -0.02 || at.x > 1.02 || at.y < -0.02 || at.y > 1.02) continue; + const back = [0, 0, 0]; + domeAt(dome, at.x, at.y, back); + const m = extinguished(s.mag, s.elevation); + const rgb = blackbodyRgb(temperatureOfBV(s.bv)); + const lum = starRadiance(m); + // Each star owns its own scratch: `shade` outlives this loop. + const hdr = (gain: number, o: number[]) => { + const a = [rgb[0] * lum * gain, rgb[1] * lum * gain, rgb[2] * lum * gain]; + const t = [0, 0, 0]; + composite(back, a, NIGHT_LOOK.starContrastExp, t); + display8(t[0], t[1], t[2], display, o); + }; + const base = [0, 0, 0]; + hdr(1, base); + display8(back[0], back[1], back[2], display, out); + // A star the sky hides (within three 8-bit steps of it in every channel) is not drawn. + if (Math.max(Math.abs(base[0] - out[0]), Math.abs(base[1] - out[1]), Math.abs(base[2] - out[2])) < 3) continue; + const { base: r0, perMag } = NIGHT_LOOK.starRadius; + stars.push({ + x: at.x, + y: at.y, + r: r0 + perMag * Math.max(0, MAG_LIMIT - m), + fill: css(base), + cover: css(out), + shade: (gain) => { + const o = [0, 0, 0]; + hdr(gain, o); + return css(o); + }, + }); + } + + let moon: MoonDraw | undefined; + const mo = p.moon; + const mAt = onScreen(camera, mo.azimuth, mo.elevation); + if (mo.elevation > -1 && mAt.x > -0.05 && mAt.x < 1.05 && mAt.y > -0.05 && mAt.y < 1.05) { + domeAt(dome, mAt.x, mAt.y, bg); + const trans = [0, 0, 0]; + p.atm.transmittanceToSpace(Math.max(Math.sin(mo.elevation * RAD), 0), trans); + const top = Math.max(...trans, 1e-9); + const tint = [1, 0.96, 0.88]; + const surface = moonSurface(mo); + for (let i = 0; i < 3; i += 1) add[i] = surface * tint[i] * (trans[i] / top) ** 0.6; + composite(bg, add, NIGHT_LOOK.moonContrastExp, tot); + display8(tot[0], tot[1], tot[2], display, out); + const lit = css(out); + // Earthshine: a fraction of the full moon's surface, the more the thinner the crescent. + const full = moonSurface({ ...mo, ratio: mo.ratio / Math.max(mo.illuminated, 0.02), illuminated: 1 }); + for (let i = 0; i < 3; i += 1) add[i] = NIGHT_LOOK.earthshine * full * (1.1 - mo.illuminated) * [0.9, 1, 1.15][i]; + composite(bg, add, NIGHT_LOOK.moonContrastExp, tot); + display8(tot[0], tot[1], tot[2], display, out); + moon = { + x: mAt.x, + y: mAt.y, + radius: ((mo.radius / RAD) * NIGHT_LOOK.moonScale) / camera.vfovDeg, + illuminated: mo.illuminated, + phaseAngle: mo.phaseAngleDeg * RAD, + limb: limbAngle(mo, p.sun), + lit, + dark: css(out), + }; + } + + const lines: LineDraw[] = []; + if (withLines && p.state === 'night') { + for (const chain of linesAt(p.sun.time, place.lat, place.lon)) { + const points: { x: number; y: number }[] = []; + const flush = () => { + if (points.length > 1) lines.push({ points: points.slice() }); + points.length = 0; + }; + chain.forEach((v, i) => { + const legs = i === 0 ? [v] : slerp(chain[i - 1], v, 6).slice(1); + legs.forEach((q) => { + const a = onScreen(camera, q.azimuth, q.elevation); + const prev = points[points.length - 1]; + if (prev && Math.abs(a.x - prev.x) > 0.5) flush(); + points.push(a); + }); + }); + flush(); + } + } + return { stars, moon, lines }; +} + +/** Paint the lines, the stars and the moon onto the canvas (`w` x `h` device px, `scale` device px per CSS px), in that order. */ +export function paintNightBodies( + ctx: CanvasRenderingContext2D, + nb: NightBodies, + w: number, + h: number, + scale: number +): void { + if (nb.lines.length) { + const [r, g, b] = NIGHT_LOOK.lines.rgb; + ctx.save(); + ctx.strokeStyle = `rgba(${r},${g},${b},${NIGHT_LOOK.lines.alpha})`; + ctx.lineWidth = NIGHT_LOOK.lines.widthPx * scale; + ctx.lineJoin = 'round'; + nb.lines.forEach((l) => { + ctx.beginPath(); + l.points.forEach((q, i) => (i ? ctx.lineTo(q.x * w, q.y * h) : ctx.moveTo(q.x * w, q.y * h))); + ctx.stroke(); + }); + ctx.restore(); + } + nb.stars.forEach((s) => { + ctx.fillStyle = s.fill; + ctx.beginPath(); + ctx.arc(s.x * w, s.y * h, s.r * scale, 0, 2 * Math.PI); + ctx.fill(); + }); + const m = nb.moon; + if (!m) return; + const R = Math.max(2 * scale, m.radius * h); + ctx.save(); + ctx.translate(m.x * w, m.y * h); + ctx.rotate(-m.limb); // the bright limb to +x; canvas rotation is clockwise, `limb` counter-clockwise + ctx.fillStyle = m.dark; + ctx.beginPath(); + ctx.arc(0, 0, R, 0, 2 * Math.PI); + ctx.fill(); + if (m.illuminated > 0.004) { + // Lit: the half toward the sun, plus or minus the half-ellipse of the terminator, whose semi-axis along x is R |cos i|. + const cosI = Math.cos(m.phaseAngle); + ctx.fillStyle = m.lit; + ctx.beginPath(); + ctx.arc(0, 0, R, -Math.PI / 2, Math.PI / 2, false); + ctx.ellipse(0, 0, Math.max(R * Math.abs(cosI), 1e-3), R, 0, Math.PI / 2, cosI > 0 ? (3 * Math.PI) / 2 : -Math.PI / 2, cosI <= 0); + ctx.closePath(); + ctx.fill(); + } + ctx.restore(); +} diff --git a/src/app/features/scene/ridge/stars.test.ts b/src/app/features/scene/ridge/stars.test.ts index e14f2a7c..f036a7ee 100644 --- a/src/app/features/scene/ridge/stars.test.ts +++ b/src/app/features/scene/ridge/stars.test.ts @@ -1,88 +1,23 @@ /* eslint-disable no-restricted-syntax, no-continue -- test loops over sample times */ import { describe, expect, it } from 'vitest'; -import { skyColours } from './skyColour'; import { - MAX_STARS, - NIGHT_LUMA, SLOTS, TWINKLE_GAIN, TWINKLE_PERIOD, activeAt, - makeStars, - skyLuma, slotCount, slotOffset, slotPeriod, - starCount, twinkleGain, } from './stars'; -const DAY = { - ...skyColours(), - top: [96, 150, 220], - mid: [150, 190, 235], - horizon: [240, 215, 190], -} as const; -const NIGHT = { - ...skyColours(), - top: [10, 14, 40], - mid: [30, 34, 80], - horizon: [60, 50, 90], -} as const; -const N = makeStars(NIGHT, 390, 844).length; +/** A field the size of a night's visible stars. */ +const N = 1200; function hash2(a: number, b: number) { return ((a * 7919 + b * 104729) % 1000) / 1000; } -describe('star placement', () => { - it('is deterministic: the same sky and size give the identical field', () => { - expect(makeStars(NIGHT, 390, 844)).toEqual(makeStars(NIGHT, 390, 844)); - expect(makeStars(skyColours(), 390, 844)).toEqual(makeStars(skyColours(), 390, 844)); - }); - - it('draws none in a day sky or the lavender dusk, and some in a night one', () => { - expect(makeStars(DAY, 390, 844)).toHaveLength(0); - expect(makeStars(skyColours(), 390, 844)).toHaveLength(0); - expect(makeStars(NIGHT, 390, 844).length).toBeGreaterThan(50); - }); - - it('is a few hundred at most: bounded by MAX_STARS and by the viewport', () => { - for (const [w, h] of [ - [390, 844], - [1920, 1080], - [100, 100], - ] as const) { - expect(makeStars(NIGHT, w, h).length).toBeLessThanOrEqual(starCount(w, h)); - expect(starCount(w, h)).toBeLessThanOrEqual(MAX_STARS); - } - expect(N).toBeGreaterThan(150); - }); - - it('thins toward the horizon: more than twice the stars in the top third than the bottom third of the sky', () => { - const all = makeStars(NIGHT, 390, 844); - expect(all.filter((s) => s.y < 0.26).length).toBeGreaterThan( - 2 * all.filter((s) => s.y > 0.52).length - ); - }); - - it('fades with the sky: every star sits where the sky is dark, alpha within bounds', () => { - for (const s of makeStars(NIGHT, 390, 844)) { - expect(skyLuma(NIGHT, s.y)).toBeLessThan(NIGHT_LUMA); - expect(s.alpha).toBeLessThanOrEqual(0.9); - expect(s.alpha).toBeGreaterThanOrEqual(0.05); - } - }); - - it('varies in size and brightness', () => { - const all = makeStars(NIGHT, 390, 844); - expect(new Set(all.map((s) => s.r.toFixed(2))).size).toBeGreaterThan(50); - expect( - Math.max(...all.map((s) => s.alpha)) - Math.min(...all.map((s) => s.alpha)) - ).toBeGreaterThan(0.3); - }); -}); - describe('twinkle schedule', () => { const times = Array.from({ length: 400 }, (_, i) => i * 0.37); diff --git a/src/app/features/scene/ridge/stars.ts b/src/app/features/scene/ridge/stars.ts index 0e6d2628..68568ad7 100644 --- a/src/app/features/scene/ridge/stars.ts +++ b/src/app/features/scene/ridge/stars.ts @@ -1,22 +1,11 @@ -// The Midnight starfield: placed once from a seeded PRNG and baked once into the sky canvas. A -// rolling window of them twinkles on an overlay canvas: SLOTS slots, each running back-to-back -// twinkles of one star at a time, so the active set is always SLOTS stars and every star gets its turn. -// The schedule is a pure function of (seed, time): no state accumulates and no Math.random runs -// after the field is built, so any instant maps straight to the active set and its brightnesses. +// The twinkle of the real stars (`nightBodies.ts` places them from the catalogue for the place and moment). A rolling window of them twinkles +// on an overlay canvas: SLOTS slots, each running back-to-back twinkles of one star at a time, so the active set is always SLOTS stars and every +// star gets its turn. The schedule is a pure function of (seed, time): no state accumulates and no Math.random runs, so any instant maps +// straight to the active set and its gains. A gain multiplies the star's radiance before the display (scintillation is flux), so a star +// the twilight hides stays hidden whatever it does. -/* eslint-disable no-bitwise -- the seeded PRNG and hash are 32-bit integer arithmetic */ -import type { SkyColours, Srgb } from './skyColour'; +/* eslint-disable no-bitwise -- the seeded hash is 32-bit integer arithmetic */ -/** - * Stars show when the sky behind them is darker than this sRGB luma (0..255). The ridge scene has - * no night flag (the sky theme's Midnight/Noonday is a body class chosen by the app, not seen here), - * so night is the sky's own darkness: a star's alpha is 1 - luma/NIGHT_LUMA at its height in the - * gradient, and a sky whose zenith is lighter than this gets no stars at all. - */ -export const NIGHT_LUMA = 110; -/** The sky gradient runs from the top (0) through mid (0.5) to the horizon glow (0.78 and below). */ -export const SKY_STOPS = { mid: 0.5, horizon: 0.78 }; -export const MAX_STARS = 400; /** Twinkling stars at any instant (fewer only if the field has fewer stars). */ export const SLOTS = 32; export const TWINKLE_PERIOD = { min: 2, max: 7 } as const; @@ -30,43 +19,12 @@ export interface Star { y: number; /** Radius in CSS px. */ r: number; - /** Base alpha 0..0.9 (brightness times how dark the sky is there). */ - alpha: number; - /** CSS colour, white tinted blue or warm. */ + /** CSS colour of the star's centre at base brightness: the display of the sky behind it plus the star, through the sky's own display. */ fill: string; - /** The sky gradient's colour at this height: dimming paints it over the baked star. */ + /** CSS colour of the sky behind it, through the same display: twinkling paints it over the baked star first. */ cover: string; -} - -const luma = (c: Srgb) => 0.2126 * c[0] + 0.7152 * c[1] + 0.0722 * c[2]; -const lerp = (a: number, b: number, t: number) => a + (b - a) * t; - -/** The baked gradient's colour at fraction t of the canvas height (the canvas interpolates in sRGB). */ -function skyAt(sky: SkyColours, t: number): Srgb { - const mix = (a: Srgb, b: Srgb, k: number): Srgb => [ - Math.round(lerp(a[0], b[0], k)), - Math.round(lerp(a[1], b[1], k)), - Math.round(lerp(a[2], b[2], k)), - ]; - if (t <= SKY_STOPS.mid) return mix(sky.top, sky.mid, t / SKY_STOPS.mid); - if (t <= SKY_STOPS.horizon) - return mix(sky.mid, sky.horizon, (t - SKY_STOPS.mid) / (SKY_STOPS.horizon - SKY_STOPS.mid)); - return sky.horizon; -} - -export const skyLuma = (sky: SkyColours, t: number): number => luma(skyAt(sky, t)); -export const isNight = (sky: SkyColours): boolean => luma(sky.top) < NIGHT_LUMA; - -/** mulberry32: 32-bit seeded PRNG, one float in [0, 1) per call. */ -function prng(seed: number) { - let a = seed >>> 0; - return () => { - a = (a + 0x6d2b79f5) >>> 0; - let t = a; - t = Math.imul(t ^ (t >>> 15), t | 1); - t ^= t + Math.imul(t ^ (t >>> 7), t | 61); - return ((t ^ (t >>> 14)) >>> 0) / 4294967296; - }; + /** The star's centre colour with its radiance multiplied by `gain` (scintillation). */ + shade: (gain: number) => string; } /** Stateless seeded hash of up to three integers to [0, 1). */ @@ -78,49 +36,6 @@ export function hash(a: number, b = 0, c = 0): number { return (h >>> 0) / 4294967296; } -/** How many stars a viewport carries: about one per 1100 CSS px squared, 150..MAX_STARS. */ -export const starCount = (cssW: number, cssH: number): number => - Math.min(MAX_STARS, Math.max(150, Math.round((cssW * cssH) / 1100))); - -/** - * Seeded placement. Each candidate draws all its random numbers whether it is kept or not, so a - * given seed and sky always give the same field and the prefix does not shift with the count. - * Heights are squeezed toward the zenith (y = 0.78 u^1.7) and alpha falls with the sky's luma, so - * the stars thin out and fade into the horizon glow. None for a day sky. - */ -export function makeStars(sky: SkyColours, cssW: number, cssH: number): Star[] { - if (!isNight(sky)) return []; - const rnd = prng(SEED); - const n = starCount(cssW, cssH); - // Every candidate draws all its numbers, kept or not, so the prefix is stable. - const candidates = Array.from({ length: MAX_STARS }, () => ({ - x: rnd(), - y: SKY_STOPS.horizon * rnd() ** 1.7, - r: 0.35 + 1.0 * rnd() ** 4, - bright: 0.35 + 0.65 * rnd() ** 1.5, - tint: rnd(), - })).slice(0, n); - return candidates.flatMap(({ x, y, r, bright, tint }) => { - const alpha = Math.min(0.9, bright * Math.max(0, 1 - skyLuma(sky, y) / NIGHT_LUMA)); - if (alpha < 0.05) return []; - // White, pulled toward blue or toward warm by the tint draw. - const to: Srgb = tint < 0.5 ? [165, 195, 255] : [255, 222, 185]; - const k = 0.55 * Math.abs(tint - 0.5) * 2; - const c = [255, 255, 255].map((v, j) => Math.round(lerp(v, to[j], k))); - const s = skyAt(sky, y); - return [ - { - x, - y, - r, - alpha, - fill: `rgb(${c[0]},${c[1]},${c[2]})`, - cover: `rgb(${s[0]},${s[1]},${s[2]})`, - }, - ]; - }); -} - // ---- The schedule --------------------------------------------------------------------------- export const slotCount = (stars: number): number => Math.min(SLOTS, stars); @@ -199,7 +114,7 @@ export function activeAt(stars: number, t: number): Twinkling[] { // ---- Drawing -------------------------------------------------------------------------------- -/** Bake `stars` into `ctx` (canvas `w` x `h` device px, `scale` device px per CSS px) at base alpha. */ +/** Bake `stars` into `ctx` (canvas `w` x `h` device px, `scale` device px per CSS px) at base brightness. */ export function drawStars( ctx: CanvasRenderingContext2D, stars: readonly Star[], @@ -208,19 +123,16 @@ export function drawStars( scale: number ) { stars.forEach((s) => { - ctx.globalAlpha = s.alpha; ctx.fillStyle = s.fill; ctx.beginPath(); ctx.arc(s.x * w, s.y * h, s.r * scale, 0, 2 * Math.PI); ctx.fill(); }); - ctx.globalAlpha = 1; } /** - * The overlay pass: clear, then for each active star whose gain is off base, paint over the baked - * star. Dimming covers it with the sky's own colour at (1 - gain), which leaves exactly - * alpha * gain of the star; brightening adds a second star on top. A star at base draws nothing. + * The overlay pass: clear, then for each active star whose gain is off base, cover the baked star with the sky behind it and draw it again + * at the gain. A star at base draws nothing. */ export function drawTwinkle( ctx: CanvasRenderingContext2D, @@ -234,16 +146,13 @@ export function drawTwinkle( active.forEach((a) => { const s = stars[a.star]; if (!s || Math.abs(a.gain - 1) < 0.01) return; - if (a.gain < 1) { - ctx.globalAlpha = 1 - a.gain; - ctx.fillStyle = s.cover; - } else { - ctx.globalAlpha = Math.min(1, ((a.gain - 1) * s.alpha) / (1 - s.alpha)); - ctx.fillStyle = s.fill; - } + ctx.fillStyle = s.cover; ctx.beginPath(); - ctx.arc(s.x * w, s.y * h, s.r * scale + (a.gain < 1 ? 1 : 0), 0, 2 * Math.PI); + ctx.arc(s.x * w, s.y * h, s.r * scale + 1, 0, 2 * Math.PI); + ctx.fill(); + ctx.fillStyle = s.shade(a.gain); + ctx.beginPath(); + ctx.arc(s.x * w, s.y * h, s.r * scale, 0, 2 * Math.PI); ctx.fill(); }); - ctx.globalAlpha = 1; } From bf71489968c00b5e64b15f86a361d69c81c927c3 Mon Sep 17 00:00:00 2001 From: Meta Vens Date: Fri, 20 Nov 2026 20:49:37 +0100 Subject: [PATCH 10/24] Constellation lines: hidden extra toggled by re-picking Night, persisted per viewer; credits for the star data pickSkyState (the menu's pick): Night while the choice is Night toggles the lines, stored in ratatoskr.skyLines (storage wrapped), told to listeners as a sky change; the rebuild key carries ':lines' at night so the scene is rebuilt with the option. Sky menu Data section credits BSC5 and d3-celestial (BSD-3-Clause). Co-Authored-By: Claude Sonnet 5.5 --- src/app/features/scene/SkyStateControl.tsx | 12 +++- src/app/features/scene/index.test.ts | 21 ++++++- src/app/features/scene/index.ts | 3 +- src/app/features/scene/ridge/credits.test.ts | 22 ++++++- src/app/features/scene/ridge/credits.ts | 10 +++ src/app/features/scene/skyForState.test.ts | 15 +++++ src/app/features/scene/skyForState.ts | 9 ++- src/app/features/scene/skyState.test.ts | 66 ++++++++++++++++++++ src/app/features/scene/skyState.ts | 34 ++++++++++ 9 files changed, 184 insertions(+), 8 deletions(-) diff --git a/src/app/features/scene/SkyStateControl.tsx b/src/app/features/scene/SkyStateControl.tsx index 955394b6..49e21c38 100644 --- a/src/app/features/scene/SkyStateControl.tsx +++ b/src/app/features/scene/SkyStateControl.tsx @@ -14,9 +14,11 @@ import { import FocusTrap from 'focus-trap-react'; import { stopPropagation } from '../../utils/keyboard'; import { useSkyState } from '../../hooks/useSkyState'; -import { SKY_STATES, setSkyState, type SkyState } from './skyState'; +import { SKY_STATES, pickSkyState, type SkyState } from './skyState'; import { loadManifest } from './ridge/manifest'; import { + LINES_CREDIT, + STARS_CREDIT, terrainCredit, WEATHER_CREDIT, WEATHER_CREDIT_URL, @@ -87,7 +89,7 @@ export function SkyStateControl() { role="menuitemradio" aria-checked={state === s} onClick={() => { - setSkyState(s); + pickSkyState(s); setCords(undefined); }} after={state === s ? : undefined} @@ -118,6 +120,12 @@ export function SkyStateControl() { . {WEATHER_DATASET}. + + {STARS_CREDIT}. + + + {LINES_CREDIT}. + )} diff --git a/src/app/features/scene/index.test.ts b/src/app/features/scene/index.test.ts index d9557e24..bed1e23e 100644 --- a/src/app/features/scene/index.test.ts +++ b/src/app/features/scene/index.test.ts @@ -2,7 +2,7 @@ import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'; import { atStandardTime } from './standardTime.testkit'; import type { Scene } from './Scene'; import { startBackgroundScene } from './index'; -import { setSkyClock, setSkyState } from './skyState'; +import { pickSkyState, setSkyClock, setSkyState } from './skyState'; import { ridgeSkyFor } from './skyForState'; import { forgetManifests } from './ridge/manifest'; import { wireIndex, wireManifest } from './ridge/manifest.fixture'; @@ -474,6 +474,25 @@ describe('the ridge cards and the live scene', () => { scene?.dispose(); }); + it('rebuilds the scene with the constellation lines when Night is re-picked while Night is the choice, and again to take them off', async () => { + serve(); + loader(); + createRidgeScene.mockReturnValue(fakeScene()); + const scene = await startBackgroundScene(config, caps, { canvas }); + expect(createRidgeScene.mock.calls[0][0].lines).toBe(false); + pickSkyState('night'); // from Auto: a choice, the same sky + await flush(); + expect(createRidgeScene).toHaveBeenCalledTimes(1); + pickSkyState('night'); // re-picked: the lines + await flush(); + expect(createRidgeScene).toHaveBeenCalledTimes(2); + expect(createRidgeScene.mock.calls[1][0].lines).toBe(true); + pickSkyState('night'); + await flush(); + expect(createRidgeScene.mock.calls[2][0].lines).toBe(false); + scene?.dispose(); + }); + it('a lighting pass that throws (no WebGL2) is the sky alone, one onPlanesFail and never onCompileFail', async () => { serve(); loadBackdrop.mockRejectedValue(new Error('ridge: no WebGL2')); diff --git a/src/app/features/scene/index.ts b/src/app/features/scene/index.ts index 794a9597..aa0493ce 100644 --- a/src/app/features/scene/index.ts +++ b/src/app/features/scene/index.ts @@ -1,7 +1,7 @@ import type { Scene, SceneOptions } from './Scene'; import { BackgroundSceneConfig, Capabilities, SceneTier, resolveTier } from './tier'; import { debugOverlaysAllowed } from './debugOverlays'; -import { getSkyState, subscribe } from './skyState'; +import { getConstellationLines, getSkyState, subscribe } from './skyState'; import type { SkyState } from './skyState'; import type { SkyColours } from './ridge/skyColour'; import type { Backdrop } from './ridge/Backdrop'; @@ -102,6 +102,7 @@ async function prepare( ...options, sky: sky ?? ridgeSkyFor(state, FALLBACK_VIEW), backdrop: backdrop ?? undefined, + lines: getConstellationLines(), }) ); return { ...made, planesFail }; diff --git a/src/app/features/scene/ridge/credits.test.ts b/src/app/features/scene/ridge/credits.test.ts index c03be043..bea5f04f 100644 --- a/src/app/features/scene/ridge/credits.test.ts +++ b/src/app/features/scene/ridge/credits.test.ts @@ -1,7 +1,16 @@ import { readFileSync } from 'node:fs'; import { join } from 'node:path'; import { describe, expect, it } from 'vitest'; -import { WEATHER_CREDIT, WEATHER_CREDIT_URL, WEATHER_DATASET, terrainCredit } from './credits'; +import { + LINES_CREDIT, + LINES_SOURCE_URL, + STARS_CREDIT, + STARS_SOURCE_URL, + WEATHER_CREDIT, + WEATHER_CREDIT_URL, + WEATHER_DATASET, + terrainCredit, +} from './credits'; import { parseIndex, parseManifest } from './manifest'; import { wireManifest } from './manifest.fixture'; import { WEATHER_ATTRIBUTION } from './weatherFeed'; @@ -39,3 +48,14 @@ describe('the terrain credit', () => { expect(terrainCredit(undefined)).toBeUndefined(); }); }); + +describe('the night sky credits', () => { + const data = readFileSync(join(__dirname, 'nightSkyData.ts'), 'utf8'); + it("name the sources the generated data's header names, with their licences", () => { + expect(data).toContain(STARS_SOURCE_URL); + expect(data).toContain(LINES_SOURCE_URL); + expect(data).toMatch(/BSD-3-Clause/); + expect(STARS_CREDIT).toMatch(/Yale Bright Star Catalogue.*public domain/); + expect(LINES_CREDIT).toMatch(/Olaf Frohn.*BSD-3-Clause/); + }); +}); diff --git a/src/app/features/scene/ridge/credits.ts b/src/app/features/scene/ridge/credits.ts index bfe16a72..b93dd22c 100644 --- a/src/app/features/scene/ridge/credits.ts +++ b/src/app/features/scene/ridge/credits.ts @@ -14,3 +14,13 @@ export const terrainCredit = ( manifest: Pick | undefined ): string | undefined => manifest ? `${manifest.attribution.creditLine} ${manifest.attribution.licence}` : undefined; + +/** The stars: the Yale Bright Star Catalogue, public domain (CDS/VizieR V/50; the file is the SAO Telescope Data Center's copy, see `nightSkyData.ts`). */ +export const STARS_CREDIT = + 'Stars: Yale Bright Star Catalogue, 5th revised ed. (Hoffleit and Warren 1991), public domain, CDS VizieR V/50'; +export const STARS_SOURCE_URL = 'http://tdc-www.harvard.edu/catalogs/bsc5.dat.gz'; +/** The constellation lines: d3-celestial by Olaf Frohn, BSD-3-Clause (the repository's LICENSE, 2015). The licence asks for its notice to travel with redistributions. */ +export const LINES_CREDIT = + 'Constellation lines: d3-celestial by Olaf Frohn (BSD-3-Clause, copyright 2015 Olaf Frohn), https://github.com/ofrohn/d3-celestial'; +export const LINES_SOURCE_URL = + 'https://github.com/ofrohn/d3-celestial/blob/master/data/constellations.lines.json'; diff --git a/src/app/features/scene/skyForState.test.ts b/src/app/features/scene/skyForState.test.ts index f5fab324..174db70a 100644 --- a/src/app/features/scene/skyForState.test.ts +++ b/src/app/features/scene/skyForState.test.ts @@ -123,3 +123,18 @@ describe('loadWeather', () => { vi.unstubAllGlobals(); }); }); + +describe('the rebuild key and the constellation lines', () => { + it('carries the lines at night only: toggling them is a different sky, a day sky is the same', async () => { + vi.stubGlobal('localStorage', { getItem: () => null, setItem: () => undefined }); + vi.resetModules(); + const st = await import('./skyState'); + const f = await import('./skyForState'); + const off = f.ridgeSkyKey('night', FALLBACK_VIEW, 0); + const dayOff = f.ridgeSkyKey('day', FALLBACK_VIEW, 0); + st.pickSkyState('night'); + st.pickSkyState('night'); + expect(f.ridgeSkyKey('night', FALLBACK_VIEW, 0)).toBe(`${off}:lines`); + expect(f.ridgeSkyKey('day', FALLBACK_VIEW, 0)).toBe(dayOff); + }); +}); diff --git a/src/app/features/scene/skyForState.ts b/src/app/features/scene/skyForState.ts index 0d55d81a..def49f1e 100644 --- a/src/app/features/scene/skyForState.ts +++ b/src/app/features/scene/skyForState.ts @@ -8,11 +8,11 @@ import type { Place, View } from './ridge/view'; import { BUDGET } from './ridge/toneMap'; import { ridgeWeather, setFedWeather } from './ridge/weather'; import { currentWeather, fetchWeatherFile } from './ridge/weatherFeed'; -import { resolveSkyState, skyNow } from './skyState'; +import { getConstellationLines, resolveSkyState, skyNow } from './skyState'; import type { SkyState } from './skyState'; /** - * What a rebuild of the ridge scene is for: the fixed state it draws and the weather. The sun moves with the clock inside a state and + * What a rebuild of the ridge scene is for: the fixed state it draws, the weather and, at night, the constellation lines. The sun moves with the clock inside a state and * is not part of the key (the scene is baked at its start), as the sky was one gradient per state before. */ export const ridgeSkyKey = ( @@ -20,7 +20,10 @@ export const ridgeSkyKey = ( view: View, weather: number = ridgeWeather(), now: Date = skyNow() -): string => `ridge:${resolveSkyState(state, now)}:${weather}:${view.place.id}`; +): string => { + const fixed = resolveSkyState(state, now); + return `ridge:${fixed}:${weather}:${view.place.id}${fixed === 'night' && getConstellationLines() ? ':lines' : ''}`; +}; const WEATHER_REFRESH_MS = 10 * 60_000; let weatherAt = -Infinity; diff --git a/src/app/features/scene/skyState.test.ts b/src/app/features/scene/skyState.test.ts index d0a902a2..f25ae445 100644 --- a/src/app/features/scene/skyState.test.ts +++ b/src/app/features/scene/skyState.test.ts @@ -215,3 +215,69 @@ describe('auto follows the clock', () => { expect(cb.mock.calls).toEqual([['night'], ['day']]); }); }); + +describe('the constellation lines toggle', () => { + let storage: ReturnType; + beforeEach(() => { + storage = fakeStorage(); + vi.stubGlobal('localStorage', storage); + }); + + it('are off by default, and a first pick of Night is a plain choice that leaves them off', async () => { + const m = await fresh(); + expect(m.getConstellationLines()).toBe(false); + m.pickSkyState('night'); + expect(m.getSkyState()).toBe('night'); + expect(m.getConstellationLines()).toBe(false); + }); + + it('re-picking Night while the choice is Night toggles them, tells the listeners, and keeps the choice', async () => { + const m = await fresh(); + m.pickSkyState('night'); + const cb = vi.fn(); + m.subscribe(cb); + m.pickSkyState('night'); + expect(m.getConstellationLines()).toBe(true); + expect(cb.mock.calls).toEqual([['night']]); + expect(m.getSkyState()).toBe('night'); + m.pickSkyState('night'); + expect(m.getConstellationLines()).toBe(false); + expect(cb).toHaveBeenCalledTimes(2); + }); + + it('are not toggled by re-picking any other state, nor by picking Night from Auto that resolves to night', async () => { + const m = await fresh(); + m.pickSkyState('day'); + m.pickSkyState('day'); + expect(m.getConstellationLines()).toBe(false); + m.setSkyClock(() => new Date('2026-12-04T00:00:00Z')); + m.pickSkyState('auto'); + m.pickSkyState('night'); + expect(m.getConstellationLines()).toBe(false); + }); + + it('persist per viewer, and come back from storage', async () => { + const m = await fresh(); + m.pickSkyState('night'); + m.pickSkyState('night'); + expect(storage.data.get(m.SKY_LINES_KEY)).toBe('on'); + const again = await fresh(); + expect(again.getConstellationLines()).toBe(true); + }); + + it('survive a refused storage: they hold for the page and read as off from a broken store', async () => { + vi.stubGlobal('localStorage', { + getItem: () => { + throw new Error('denied'); + }, + setItem: () => { + throw new Error('denied'); + }, + }); + const m = await fresh(); + expect(m.getConstellationLines()).toBe(false); + m.pickSkyState('night'); + m.pickSkyState('night'); + expect(m.getConstellationLines()).toBe(true); + }); +}); diff --git a/src/app/features/scene/skyState.ts b/src/app/features/scene/skyState.ts index 5d963565..111fdf60 100644 --- a/src/app/features/scene/skyState.ts +++ b/src/app/features/scene/skyState.ts @@ -51,6 +51,22 @@ export function resolveSkyState(s: SkyState, now: Date = clock()): FixedSkyState return el <= -DAY_FROM ? 'night' : 'dusk'; } +/** The constellation lines (a hidden extra, ruling ridge-constellation-lines-hidden-extra): on or off, per viewer, off by default. */ +export const SKY_LINES_KEY = 'ratatoskr.skyLines'; +let lines: boolean | undefined; + +/** Whether the constellation lines are on: the stored choice of this viewer. They are drawn over the real stars of a night sky only. */ +export const getConstellationLines = (): boolean => { + if (lines === undefined) { + try { + lines = localStorage.getItem(SKY_LINES_KEY) === 'on'; + } catch { + lines = false; + } + } + return lines; +}; + let current: SkyState | undefined; const listeners = new Set<(s: FixedSkyState) => void>(); let timer: ReturnType | undefined; @@ -109,6 +125,24 @@ export function setSkyState(s: SkyState): void { } } +/** + * A pick in the sky menu. Picking a state sets it; picking Night while the choice already is Night toggles the constellation lines, which + * listeners hear as a sky change (the scene is rebuilt for it: `ridgeSkyKey` carries the flag). + */ +export function pickSkyState(s: SkyState): void { + if (s === 'night' && getSkyState() === 'night') { + lines = !getConstellationLines(); + try { + localStorage.setItem(SKY_LINES_KEY, lines ? 'on' : 'off'); + } catch { + // Storage is refused: the lines hold for this page load only. + } + emit(); + return; + } + setSkyState(s); +} + /** Listeners hear the resolved sky: on a change of choice, and while 'auto', when the clock crosses a boundary. */ export function subscribe(cb: (s: FixedSkyState) => void): () => void { if (listeners.size === 0) shown = getResolvedSkyState(); From 52a085143b44c0123a497fdce600f61a906ec079 Mon Sep 17 00:00:00 2001 From: Meta Vens Date: Fri, 20 Nov 2026 20:52:23 +0100 Subject: [PATCH 11/24] Harness: ridge sheet pins moments (?moments=, ?night=1) and shows stars, moon and lines (?lines=1); night key at its targets, airglow neutral The night set renders new, first-quarter and full moon at four hours each plus deep dusk. Night exposure keys the sky to where the curve wants it so the per-channel curve does not turn the scotopic blue shift into a saturated sky. Co-Authored-By: Claude Sonnet 5.5 --- harness/scene/ridgeSheet.ts | 95 +++++++++++++++++--- src/app/features/scene/ridge/nightSky.ts | 6 +- src/app/features/scene/ridge/toneMap.test.ts | 2 +- src/app/features/scene/ridge/toneMap.ts | 4 +- 4 files changed, 92 insertions(+), 15 deletions(-) diff --git a/harness/scene/ridgeSheet.ts b/harness/scene/ridgeSheet.ts index d5cf3d00..a4f66637 100644 --- a/harness/scene/ridgeSheet.ts +++ b/harness/scene/ridgeSheet.ts @@ -1,12 +1,20 @@ -// Look sheet for the lit ridge cards: the Vienna bake lit for a grid of sky states x looks, each cell a small canvas at heading 0. Not shipped. +// Look sheet for the lit ridge cards: the Vienna bake lit for a grid of sky states (or pinned moments) x looks, each cell a small canvas at heading 0. Not shipped. // `?preset=all|physical|swiss|poster|painterly|painterly-cel-2|painterly-cel-3|painterly-cel-4` (default all: one row each; painterly is DEFAULT_LOOK); `?looks=` replaces the rows with // the given `{label, ...partial RidgeLook}` entries (inkKeep and reliefLight merge by key). `?w=480` sets the cell width (16:9). -// The sky behind a cell is the app's own: `makePhysicalSky` + `paintSky` upscaled smoothly, without the sun disc, stars or clouds. +// The sky behind a cell is the app's own: `makePhysicalSky` + `paintSky` upscaled smoothly, with the real stars and the moon (`nightBodies`), +// without the sun disc or clouds. Columns are the SKIES below (a sun elevation each, the stars and moon of the moment the sheet was opened), or: +// `?moments=2026-11-24T22:00Z,2026-12-09T20:00Z` explicit UTC moments: the sun, moon and stars are those of the moment, the state follows the sun's elevation +// `?night=1` the night set: the next new moon, first quarter and full moon from today (or from `?from=YYYY-MM-DD`), each at four night hours +// (`?hours=18,21,0,4` UTC), plus deep dusk (sun at -10 degrees) of the evening of the full moon +// `?lines=1` constellation lines over the stars, as the Sky menu's hidden toggle does (night cells only) import { DEFAULT_LOOK, PHYSICAL_LOOK, lightCards } from '../../src/app/features/scene/ridge/lightCards'; import type { RidgeLook } from '../../src/app/features/scene/ridge/lightCards'; import { parseManifest } from '../../src/app/features/scene/ridge/manifest'; import { makePhysicalSky, paintSky } from '../../src/app/features/scene/ridge/physicalSky'; import { windowFor } from '../../src/app/features/scene/ridge/view'; +import { nightBodies, paintNightBodies } from '../../src/app/features/scene/ridge/nightBodies'; +import { sunAt } from '../../src/app/features/scene/ridge/sunAt'; +import { moonPhase } from '../../src/sky/moon.js'; import { DAY_FROM } from '../../src/app/features/scene/skyState'; import type { FixedSkyState } from '../../src/app/features/scene/skyState'; @@ -20,8 +28,16 @@ type Override = Partial> & { reliefLight?: Partial; }; +interface Column { + label: string; + elevation?: number; + azimuth?: number; + /** A moment: the sun is the real one of it. */ + time?: Date; +} + /** Sun elevation and compass azimuth of each column; the cards look at 214 +- 36. Elevation picks the display budget (day from DAY_FROM, night below its negative). */ -const SKIES = [ +const SKIES: Column[] = [ { label: 'dawn 2 deg', elevation: 2, azimuth: 100 }, { label: 'morning 15 deg', elevation: 15, azimuth: 135 }, { label: 'noon 55 deg', elevation: 55, azimuth: 190 }, @@ -86,13 +102,68 @@ function parseLooks(raw: string): Override[] { } const q = new URLSearchParams(location.search); + +const HOUR = 3_600_000; +/** The first moment at or after `from` the moon's elongation passes `target` degrees (new 0, first quarter 90, full 180). */ +function nextPhase(from: Date, target: number): Date { + const err = (t: number) => ((moonPhase(t).elongationDeg - target + 540) % 360) - 180; + let t = from.getTime(); + while (!(err(t) < 0 && err(t + HOUR) >= 0)) t += HOUR; + let a = t; + let b = t + HOUR; + for (let i = 0; i < 20; i += 1) { + const m = (a + b) / 2; + if (err(m) < 0) a = m; + else b = m; + } + return new Date(b); +} + +/** The first evening moment (UTC hour steps of 10 minutes from `day`) the sun is at `deg` below the horizon, going down. */ +function sunDownTo(place: Parameters[0], day: Date, deg: number): Date { + let t = Date.UTC(day.getUTCFullYear(), day.getUTCMonth(), day.getUTCDate(), 12); + while (sunAt(place, new Date(t)).elevation > -deg) t += 10 * 60_000; + return new Date(t); +} + +const fmt = (d: Date) => d.toISOString().slice(0, 16).replace('T', ' ') + 'Z'; + +function momentsFrom(params: URLSearchParams, place: Parameters[0]): Column[] | undefined { + const list = params.get('moments'); + if (list) + return list.split(',').map((iso) => { + const time = new Date(iso.trim()); + if (Number.isNaN(time.getTime())) throw new Error(`moments=: ${iso} is not a date`); + return { label: fmt(time), time }; + }); + if (!params.get('night')) return undefined; + const from = params.get('from') ? new Date(`${params.get('from')}T00:00:00Z`) : new Date(); + const hours = (params.get('hours') ?? '18,21,0,4').split(',').map(Number); + const cols: Column[] = []; + const phases: [string, number][] = [['new', 0], ['first quarter', 90], ['full', 180]]; + phases.forEach(([name, deg]) => { + const peak = nextPhase(from, deg); + const day = Date.UTC(peak.getUTCFullYear(), peak.getUTCMonth(), peak.getUTCDate()); + hours.forEach((h) => { + // Hours before 12 belong to the night that ends the day of the phase, so the hours run on from the evening. + const time = new Date(day + (h < 12 ? 24 + h : h) * HOUR); + cols.push({ label: `${name} ${fmt(time)}`, time }); + }); + if (deg === 180) cols.push({ label: `deep dusk, full moon ${fmt(sunDownTo(place, peak, 10))}`, time: sunDownTo(place, peak, 10) }); + }); + return cols; +} const preset = q.get('preset'); +const pinned = q.get('moments') || q.get('night'); const rows = (q.get('looks') ? parseLooks(q.get('looks') as string) : preset && preset !== 'all' ? [PRESETS[preset] ?? PRESETS.physical] + : pinned + ? [PRESETS.painterly] // a night set is read in the default look unless a preset or looks say otherwise : Object.values(PRESETS) ).map(merge); +const withLines = q.get('lines') === '1'; const W = Number(q.get('w') ?? 480); const H = Math.round((W * 9) / 16); const root = document.getElementById('sheet') as HTMLElement; @@ -113,26 +184,29 @@ async function main() { const { view } = manifest; const win = windowFor(view, W, H); const now = new Date(); + const columns = momentsFrom(q, view.place) ?? SKIES; const table = document.createElement('table'); table.style.borderSpacing = '4px'; root.append(table); const head = table.insertRow(); head.insertCell(); - SKIES.forEach((s) => (head.insertCell().textContent = s.label)); + columns.forEach((c) => (head.insertCell().textContent = c.label)); const tr = rows.map((r) => { const row = table.insertRow(); row.insertCell().textContent = r.label; return row; }); - for (const sky of SKIES) { - const physical = makePhysicalSky(stateOf(sky.elevation), now, 0, view, { - elevation: sky.elevation, - azimuth: sky.azimuth, - time: now, - }); + for (const col of columns) { + const time = col.time ?? now; + const sun = + col.time !== undefined + ? sunAt(view.place, col.time) + : { elevation: col.elevation as number, azimuth: col.azimuth as number, time }; + const physical = makePhysicalSky(stateOf(sun.elevation), time, 0, view, sun); const px = paintSky(physical, W, H, win.camera); + const bodies = nightBodies(physical, px, withLines); const small = document.createElement('canvas'); small.width = px.w; small.height = px.h; @@ -155,6 +229,7 @@ async function main() { const ctx = cell.getContext('2d') as CanvasRenderingContext2D; ctx.imageSmoothingQuality = 'high'; ctx.drawImage(small, 0, 0, W, H); + paintNightBodies(ctx, bodies, W, H, 1); // As Ridge.ts paintCards at heading 0: farthest first, each card at its own scale about the horizon row of the plane. const s = win.plane.scale; const x0 = (W - win.plane.w) / 2; diff --git a/src/app/features/scene/ridge/nightSky.ts b/src/app/features/scene/ridge/nightSky.ts index 4bc63293..3137511d 100644 --- a/src/app/features/scene/ridge/nightSky.ts +++ b/src/app/features/scene/ridge/nightSky.ts @@ -42,9 +42,9 @@ export const NIGHT_LOOK = { /** Natural night-sky radiance at the zenith without moon or town, cd/m^2 (about 22 V mag/arcsec^2: 2.5e-4). */ export const AIRGLOW_CD = 2.5e-4; -/** Its colour, linear, luminance 1 (a faint cool green-blue). EYEBALLED. */ -const AIRGLOW_TINT: Vec3 = [0.8, 1, 1.35]; -const AIRGLOW_NORM = 0.2126 * 0.8 + 0.7152 + 0.0722 * 1.35; +/** Its colour, linear, luminance 1 (a faint cool grey). EYEBALLED. */ +const AIRGLOW_TINT: Vec3 = [0.95, 1, 1.1]; +const AIRGLOW_NORM = 0.2126 * 0.95 + 0.7152 + 0.0722 * 1.1; /** The airglow floor, per unit of sun irradiance, at view elevation sine `vz` (brighter toward the horizon, van Rhijn). */ export function airglow(vz: number, out: number[]): void { diff --git a/src/app/features/scene/ridge/toneMap.test.ts b/src/app/features/scene/ridge/toneMap.test.ts index 536c0b1c..d27cc979 100644 --- a/src/app/features/scene/ridge/toneMap.test.ts +++ b/src/app/features/scene/ridge/toneMap.test.ts @@ -79,7 +79,7 @@ describe('the night display', () => { }); it('reads the new-moon night darker than the full-moon night (partial adaptation), by the level of the budget', () => { - const med = (p: ReturnType) => applyCurve(p.fit.display.curve, 0.5); + const med = (p: ReturnType) => applyCurve(p.fit.display.curve, p.fit.display.curve.x[2]); // the median of the sky expect(med(newMoon)).toBeLessThan(0.6 * med(fullMoon)); }); diff --git a/src/app/features/scene/ridge/toneMap.ts b/src/app/features/scene/ridge/toneMap.ts index a33b7c92..c82379b2 100644 --- a/src/app/features/scene/ridge/toneMap.ts +++ b/src/app/features/scene/ridge/toneMap.ts @@ -150,7 +150,9 @@ export const BUDGET: Record = { floor: NIGHT_LIFT - 0.001, lift: NIGHT_LIFT, ceiling: NIGHT_CEILING, - key: 0.45, + // The key sits at the targets (not day's 0.45): the sky is exposed to where the curve wants it, so the curve is near the identity over it and + // the per-channel curve does not blow a small colour difference (the scotopic blue shift) up into a saturated sky. + key: 0.03, min: 4, max: 1e13, targets: [0.012, 0.03, 0.07], From c18d3e3e9db9e12239d5e89cba21f9706110c62b Mon Sep 17 00:00:00 2001 From: Meta Vens Date: Fri, 20 Nov 2026 20:53:23 +0100 Subject: [PATCH 12/24] Harness README: night sets and the night look's knobs Co-Authored-By: Claude Sonnet 5.5 --- harness/scene/README.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/harness/scene/README.md b/harness/scene/README.md index 9fc5de49..d5b38baa 100644 --- a/harness/scene/README.md +++ b/harness/scene/README.md @@ -45,3 +45,5 @@ Presets (`PRESETS` in `ridgeSheet.ts`; swiss and poster take every key not named | poster | reliefWeight 0.15, cardToneStep 0.25, cardGradient 0.5, inkKeep {edge 0.25, occlude 0.9, crease 1}, hazeScale 4 | | painterly | DEFAULT_LOOK: groundNoise 0.35, cloudShadows 0.5, nearWarm 0.6, hazeScale 2, inkScale 0.4, celBands 3, celSoftness 0.05, celAmbientAway 0.7, nightAmbient [0.5, 0.66, 1.1] | | painterly-cel-2 / -3 / -4 | painterly with celBands 2 / 3 / 4 | + +Night sets (`ridgeSheet.html`): `?moments=2026-11-24T22:00Z,2026-12-09T20:00Z` pins explicit UTC moments (the sun, moon and stars are those of the moment); `?night=1` renders the next new moon, first quarter and full moon from today (`&from=YYYY-MM-DD`) at four hours each (`&hours=18,21,0,4`, UTC) plus deep dusk of the full-moon evening; `&lines=1` draws the constellation lines (the Sky menu's hidden toggle). Use `&w=300` for the 13-column set. The night look's knobs: `NIGHT_LOOK` in `ridge/nightSky.ts` (star point spread, contrast exponents, moon size, earthshine, line opacity), `NIGHT_CEILING` and `SCOTOPIC` in `ridge/toneMap.ts`, the night `Budget` (key, targets, partial adaptation). From 5e64e8338967ef13e6816d0c169d1aa54751a9e2 Mon Sep 17 00:00:00 2001 From: Meta Vens Date: Fri, 20 Nov 2026 20:57:52 +0100 Subject: [PATCH 13/24] Pin the night bodies under the cards: still paints every line, star and moon before any card; live keeps them in the host canvas under the twinkle canvas and the rig Co-Authored-By: Claude Sonnet 5.5 --- src/app/features/scene/ridge/Ridge.test.ts | 33 +++++++++++++++++++++- 1 file changed, 32 insertions(+), 1 deletion(-) diff --git a/src/app/features/scene/ridge/Ridge.test.ts b/src/app/features/scene/ridge/Ridge.test.ts index 39b93421..fc88e93e 100644 --- a/src/app/features/scene/ridge/Ridge.test.ts +++ b/src/app/features/scene/ridge/Ridge.test.ts @@ -171,7 +171,9 @@ function ctx() { }, beginPath() {}, moveTo() {}, - stroke() {}, + stroke() { + draws.push('line'); + }, createRadialGradient: () => ({ addColorStop: vi.fn() }), lineTo() {}, closePath() {}, @@ -189,6 +191,7 @@ function ctx() { else draws.push('fill'); }, drawImage(...a: unknown[]) { + draws.push('image'); images.push( Object.assign(a, { alpha: c.globalAlpha, op: c.globalCompositeOperation, t: c.t, k: c.k }) ); @@ -562,6 +565,34 @@ describe('the ridge cards in the scene', () => { const win = windowFor(manifest.view, 400, 800); const motion400 = cardMotion(manifest, win); + it('lays the night bodies (lines, stars, moon) in the sky before any card, so the cards occlude them', () => { + const { canvas } = host(); + createRidgeScene({ + canvas, + tier: 'still', + sky: { ...night }, + backdrop: litCards(), + lines: true, + }); + const bodies = draws.map((d, i) => (d === 'line' || d === 'star' ? i : -1)).filter((i) => i >= 0); + const images = draws.map((d, i) => (d === 'image' ? i : -1)).filter((i) => i >= 0); + expect(bodies.length).toBeGreaterThan(0); + expect(draws).toContain('line'); // the lines are drawn (the sky is a night one) + const cards = images.slice(-3); // the sky's upscale first, then the three cards, farthest first + expect(cards).toHaveLength(3); + expect(Math.max(...bodies)).toBeLessThan(Math.min(...cards)); + }); + + it('keeps the live sky canvas, with every body baked into it, under the twinkle canvas and the rig', () => { + const { parent, canvas } = host(); + createRidgeScene({ canvas, tier: 'full', sky: { ...night }, backdrop: litCards(), lines: true }); + const rig = rigOf(parent); + const twinkle = parent.children.findIndex((c: any) => c.tag === 'canvas'); + expect(twinkle).toBeGreaterThanOrEqual(0); + expect(parent.children.indexOf(rig)).toBeGreaterThan(twinkle); + expect(draws.filter((d) => d === 'image')).toHaveLength(1); // only the sky's own upscale is in the host canvas: the cards are DOM above it + }); + it('stacks the rig after the twinkle canvas and before the rain, with no z-index and no fixed position', () => { const { parent, canvas } = host(); const s = createRidgeScene({ canvas, tier: 'full', sky: night, backdrop: litCards() })!; From 9d0764f23aa400d127f4bf6b5220a165adc44b1e Mon Sep 17 00:00:00 2001 From: Meta Vens Date: Fri, 20 Nov 2026 21:03:29 +0100 Subject: [PATCH 14/24] Harness: ?labels=1 debug option names each constellation chain in frame (ids fetched from d3-celestial at run time; not shipped) Co-Authored-By: Claude Sonnet 5.5 --- harness/scene/ridgeSheet.ts | 23 ++++++++++++++++++++++- 1 file changed, 22 insertions(+), 1 deletion(-) diff --git a/harness/scene/ridgeSheet.ts b/harness/scene/ridgeSheet.ts index a4f66637..ec7e0753 100644 --- a/harness/scene/ridgeSheet.ts +++ b/harness/scene/ridgeSheet.ts @@ -6,14 +6,16 @@ // `?moments=2026-11-24T22:00Z,2026-12-09T20:00Z` explicit UTC moments: the sun, moon and stars are those of the moment, the state follows the sun's elevation // `?night=1` the night set: the next new moon, first quarter and full moon from today (or from `?from=YYYY-MM-DD`), each at four night hours // (`?hours=18,21,0,4` UTC), plus deep dusk (sun at -10 degrees) of the evening of the full moon +// `?labels=1` DEBUG: label each constellation chain in frame with its d3-celestial abbreviation (fetched from the source repository at run time; not shipped) // `?lines=1` constellation lines over the stars, as the Sky menu's hidden toggle does (night cells only) import { DEFAULT_LOOK, PHYSICAL_LOOK, lightCards } from '../../src/app/features/scene/ridge/lightCards'; import type { RidgeLook } from '../../src/app/features/scene/ridge/lightCards'; import { parseManifest } from '../../src/app/features/scene/ridge/manifest'; import { makePhysicalSky, paintSky } from '../../src/app/features/scene/ridge/physicalSky'; import { windowFor } from '../../src/app/features/scene/ridge/view'; -import { nightBodies, paintNightBodies } from '../../src/app/features/scene/ridge/nightBodies'; +import { nightBodies, onScreen, paintNightBodies } from '../../src/app/features/scene/ridge/nightBodies'; import { sunAt } from '../../src/app/features/scene/ridge/sunAt'; +import { linesAt } from '../../src/app/features/scene/ridge/starCatalogue'; import { moonPhase } from '../../src/sky/moon.js'; import { DAY_FROM } from '../../src/app/features/scene/skyState'; import type { FixedSkyState } from '../../src/app/features/scene/skyState'; @@ -164,6 +166,12 @@ const rows = (q.get('looks') : Object.values(PRESETS) ).map(merge); const withLines = q.get('lines') === '1'; +const LINES_JSON = 'https://raw.githubusercontent.com/ofrohn/d3-celestial/master/data/constellations.lines.json'; +/** Debug: the constellation id of each packed chain, in the generator's order (feature by feature, chain by chain). */ +async function chainIds(): Promise { + const gj = await (await fetch(LINES_JSON)).json(); + return gj.features.flatMap((f: { id: string; geometry: { coordinates: unknown[] } }) => f.geometry.coordinates.map(() => f.id)); +} const W = Number(q.get('w') ?? 480); const H = Math.round((W * 9) / 16); const root = document.getElementById('sheet') as HTMLElement; @@ -185,6 +193,7 @@ async function main() { const win = windowFor(view, W, H); const now = new Date(); const columns = momentsFrom(q, view.place) ?? SKIES; + const ids = q.get('labels') === '1' ? await chainIds() : undefined; const table = document.createElement('table'); table.style.borderSpacing = '4px'; @@ -230,6 +239,18 @@ async function main() { ctx.imageSmoothingQuality = 'high'; ctx.drawImage(small, 0, 0, W, H); paintNightBodies(ctx, bodies, W, H, 1); + if (ids) { + // Debug labels: each chain's id at the mean of its vertices that lie in the frame. + ctx.font = '11px monospace'; + ctx.fillStyle = '#ffd24a'; + linesAt(physical.sun.time, view.place.lat, view.place.lon).forEach((chain, i) => { + const pts = chain.map((p) => onScreen(win.camera, p.azimuth, p.elevation)).filter((a) => a.x >= 0 && a.x <= 1 && a.y >= 0 && a.y <= 1); + if (!pts.length) return; + const mx = pts.reduce((a, p) => a + p.x, 0) / pts.length; + const my = pts.reduce((a, p) => a + p.y, 0) / pts.length; + ctx.fillText(`${ids[i]} ${pts.length}/${chain.length}`, mx * W, my * H); + }); + } // As Ridge.ts paintCards at heading 0: farthest first, each card at its own scale about the horizon row of the plane. const s = win.plane.scale; const x0 = (W - win.plane.w) / 2; From 0fd1ec45ae27c87025b338075519458a5d5c289b Mon Sep 17 00:00:00 2001 From: Meta Vens Date: Fri, 20 Nov 2026 21:11:31 +0100 Subject: [PATCH 15/24] Frame: the horizon sits at one authored fraction of the viewport (HORIZON_AT 0.95), set by windowFor alone windowFor places the plane so its horizon row lands at HORIZON_AT of the height, the same for every sky state and viewport; the plane runs below the viewport bottom (negative bottom) and the near plain is cropped. Every consumer already read the camera and plane from windowFor; the sheet's card placement now reads plane.bottom too, and takes ?h= for a phone-shaped cell. Tests pin the constant horizon, ~35 degrees of sky in a 16:9 cell, and plane coverage with baked ground to spare at 1024x768, 1920x1080, 375x812. Co-Authored-By: Claude Sonnet 5.5 --- harness/scene/ridgeSheet.ts | 6 ++-- src/app/features/scene/ridge/Ridge.test.ts | 2 +- src/app/features/scene/ridge/view.test.ts | 41 +++++++++++++++++++--- src/app/features/scene/ridge/view.ts | 17 +++++++-- 4 files changed, 55 insertions(+), 11 deletions(-) diff --git a/harness/scene/ridgeSheet.ts b/harness/scene/ridgeSheet.ts index ec7e0753..3471e8be 100644 --- a/harness/scene/ridgeSheet.ts +++ b/harness/scene/ridgeSheet.ts @@ -1,6 +1,6 @@ // Look sheet for the lit ridge cards: the Vienna bake lit for a grid of sky states (or pinned moments) x looks, each cell a small canvas at heading 0. Not shipped. // `?preset=all|physical|swiss|poster|painterly|painterly-cel-2|painterly-cel-3|painterly-cel-4` (default all: one row each; painterly is DEFAULT_LOOK); `?looks=` replaces the rows with -// the given `{label, ...partial RidgeLook}` entries (inkKeep and reliefLight merge by key). `?w=480` sets the cell width (16:9). +// the given `{label, ...partial RidgeLook}` entries (inkKeep and reliefLight merge by key). `?w=480` sets the cell width, 16:9 unless `?h=` gives the height (`?w=375&h=812` is a phone). // The sky behind a cell is the app's own: `makePhysicalSky` + `paintSky` upscaled smoothly, with the real stars and the moon (`nightBodies`), // without the sun disc or clouds. Columns are the SKIES below (a sun elevation each, the stars and moon of the moment the sheet was opened), or: // `?moments=2026-11-24T22:00Z,2026-12-09T20:00Z` explicit UTC moments: the sun, moon and stars are those of the moment, the state follows the sun's elevation @@ -173,7 +173,7 @@ async function chainIds(): Promise { return gj.features.flatMap((f: { id: string; geometry: { coordinates: unknown[] } }) => f.geometry.coordinates.map(() => f.id)); } const W = Number(q.get('w') ?? 480); -const H = Math.round((W * 9) / 16); +const H = q.get('h') ? Number(q.get('h')) : Math.round((W * 9) / 16); const root = document.getElementById('sheet') as HTMLElement; const stateOf = (el: number): FixedSkyState => @@ -254,7 +254,7 @@ async function main() { // As Ridge.ts paintCards at heading 0: farthest first, each card at its own scale about the horizon row of the plane. const s = win.plane.scale; const x0 = (W - win.plane.w) / 2; - const planeTop = H - win.plane.h; + const planeTop = H - (win.plane.h + win.plane.bottom); const ox = x0 + win.plane.w / 2; const oy = planeTop + view.horizonRow * s; for (let k = cards.length - 1; k >= 0; k -= 1) { diff --git a/src/app/features/scene/ridge/Ridge.test.ts b/src/app/features/scene/ridge/Ridge.test.ts index fc88e93e..f2918637 100644 --- a/src/app/features/scene/ridge/Ridge.test.ts +++ b/src/app/features/scene/ridge/Ridge.test.ts @@ -687,7 +687,7 @@ describe('the ridge cards in the scene', () => { const dpr = 2; const s = win.plane.scale * dpr; const x0 = (800 - win.plane.w * dpr) / 2; - const planeTop = 1600 - win.plane.h * dpr; + const planeTop = 1600 - (win.plane.h + win.plane.bottom) * dpr; const origin = [x0 + (win.plane.w * dpr) / 2, planeTop + manifest.view.horizonRow * s]; drawn.forEach((a, j) => { const card = manifest.cards[2 - j]; diff --git a/src/app/features/scene/ridge/view.test.ts b/src/app/features/scene/ridge/view.test.ts index a78b6da2..8d68e257 100644 --- a/src/app/features/scene/ridge/view.test.ts +++ b/src/app/features/scene/ridge/view.test.ts @@ -1,6 +1,6 @@ import { describe, expect, it } from 'vitest'; import { sunOnScreen } from './skyDome'; -import { cardMotion, DRIFT_FRAC, FALLBACK_VIEW, windowFor } from './view'; +import { cardMotion, DRIFT_FRAC, FALLBACK_VIEW, HORIZON_AT, windowFor } from './view'; import { parseManifest } from './manifest'; import { wireManifest } from './manifest.fixture'; import type { View } from './view'; @@ -22,7 +22,7 @@ describe('windowFor', () => { expect(win.plane.h).toBeLessThanOrEqual(h * 4); // sanity: scale is not runaway // Angle seen never exceeds the baked window minus the drift margin on both sides. expect(win.camera.hfovDeg).toBeLessThanOrEqual(v.windowDeg / (1 + 2 * DRIFT_FRAC) + 1e-9); - // The plane is anchored to the bottom; its horizon row lands at the camera's horizon fraction of the viewport. + // The plane's horizon row lands at the camera's horizon fraction of the viewport. const horizonY = h - win.plane.bottom - win.plane.h + win.plane.scale * v.horizonRow; expect(Math.abs(horizonY - win.camera.horizonAt * h)).toBeLessThan(0.5); expect(win.camera.azimuthDeg).toBe(v.lookAzDeg); @@ -30,7 +30,39 @@ describe('windowFor', () => { } ); - it('is shaped by the View alone: another window, plane and horizon give another camera', () => { + it('puts the horizon at one fraction of the height, whatever the viewport, the view or the sky state', () => { + const wide: View = { ...FALLBACK_VIEW, lookAzDeg: 10, windowDeg: 144, planeW: 2560, horizonRow: 200 }; + for (const v of [FALLBACK_VIEW, wide]) + for (const [w, h] of [...VIEWPORTS, [1024, 768], [375, 812], [1100, 619]] as [number, number][]) + expect(windowFor(v, w, h).camera.horizonAt).toBe(HORIZON_AT); + expect(HORIZON_AT).toBeGreaterThan(0.5); + expect(HORIZON_AT).toBeLessThan(1); + }); + + it('shows about 35 degrees of sky above the horizon in a 16:9 desktop cell', () => { + const { camera } = windowFor(FALLBACK_VIEW, 1100, 619); + const sky = camera.horizonAt * camera.vfovDeg; + expect(sky).toBeGreaterThan(33); + expect(sky).toBeLessThan(40); + }); + + it.each([ + [1024, 768], + [1920, 1080], + [375, 812], + [1100, 619], + ])('%i x %i: the plane covers the viewport bottom and sides, drift included, with baked ground to spare below the horizon', (w, h) => { + const win = windowFor(FALLBACK_VIEW, w, h); + expect(win.plane.bottom).toBeLessThanOrEqual(0); // the foot of the plane is at or below the viewport's bottom edge + expect(win.plane.w - 2 * win.driftPx).toBeCloseTo(w, 6); + expect(win.driftPx).toBeGreaterThanOrEqual(0); + // The baked ground below the horizon row that the viewport crops to: more than the viewport needs. + const needed = (1 - HORIZON_AT) * h; + const baked = win.plane.scale * (FALLBACK_VIEW.planeH - FALLBACK_VIEW.horizonRow); + expect(baked).toBeGreaterThanOrEqual(needed); + }); + + it('is shaped by the View alone: another window and plane give another camera (azimuth and field of view; the horizon stays put)', () => { const wide: View = { ...FALLBACK_VIEW, lookAzDeg: 10, @@ -41,7 +73,8 @@ describe('windowFor', () => { const a = windowFor(FALLBACK_VIEW, 1920, 1080).camera; const b = windowFor(wide, 1920, 1080).camera; expect(b.azimuthDeg).toBe(10); - expect(b.horizonAt).not.toBeCloseTo(a.horizonAt, 2); + expect(windowFor(FALLBACK_VIEW, 1920, 1080).camera.hfovDeg).not.toBeCloseTo(windowFor(wide, 1920, 1080).camera.hfovDeg, 2); + expect(b.horizonAt).toBe(a.horizonAt); }); it('registration: a sun 10 degrees right of the look azimuth sits where the plane puts that azimuth', () => { diff --git a/src/app/features/scene/ridge/view.ts b/src/app/features/scene/ridge/view.ts index 4042cdd7..09bc4346 100644 --- a/src/app/features/scene/ridge/view.ts +++ b/src/app/features/scene/ridge/view.ts @@ -58,10 +58,16 @@ export const FALLBACK_VIEW: View = { /** The share of the viewport height the plane's height is at least scaled to, and the slack each side of the viewport kept for drift. Authored, tunable by eye. */ export const RIDGE_BAND_FRAC = 0.6; export const DRIFT_FRAC = 0.05; +/** + * Where the horizon sits down the viewport, as a fraction of its height: one constant for every sky state and every viewport (ruling + * ridge-frame-more-sky-fixed-pitch: the camera pitch never changes between day and night). The plane extends below the viewport bottom and + * the near plain is cropped. 0.95 shows about 35 degrees of sky above the horizon in a 16:9 cell. Authored, tunable by eye. + */ +export const HORIZON_AT = 0.95; export interface Window { camera: Camera; - /** The planes in viewport pixels: scaled size, anchored to the viewport's bottom edge and centred on `lookAzDeg`. */ + /** The planes in viewport pixels: scaled size, centred on `lookAzDeg`, placed so the horizon row lands at `HORIZON_AT` of the height. `bottom` is the distance of the plane's foot above the viewport's bottom edge: negative, the plane runs on below it. */ plane: { scale: number; w: number; h: number; bottom: number }; /** How far the plane may slide sideways from centre and still cover the viewport. */ driftPx: number; @@ -78,9 +84,14 @@ export function windowFor(view: View, viewportW: number, viewportH: number): Win azimuthDeg: view.lookAzDeg, hfovDeg, vfovDeg: (hfovDeg * viewportH) / viewportW, - horizonAt: (viewportH - scale * (view.planeH - view.horizonRow)) / viewportH, + horizonAt: HORIZON_AT, + }, + plane: { + scale, + w: scale * view.planeW, + h: scale * view.planeH, + bottom: (1 - HORIZON_AT) * viewportH - scale * (view.planeH - view.horizonRow), }, - plane: { scale, w: scale * view.planeW, h: scale * view.planeH, bottom: 0 }, driftPx: (scale * view.planeW - viewportW) / 2, }; } From 3185ea90c1d6735ecdfe4b5dbd5dc83205cf36e7 Mon Sep 17 00:00:00 2001 From: Meta Vens Date: Fri, 20 Nov 2026 21:12:47 +0100 Subject: [PATCH 16/24] Brighter stars: smaller point spread, gentler contrast compression, larger points (starting values; the operator tunes by eye) Under a full moon at the new framing every constellation-line vertex in the sky strip now carries a drawn star (was 24 of 34); a test pins it. Co-Authored-By: Claude Sonnet 5.5 --- .../features/scene/ridge/nightBodies.test.ts | 23 +++++++++++++++++++ src/app/features/scene/ridge/nightSky.ts | 6 ++--- 2 files changed, 26 insertions(+), 3 deletions(-) diff --git a/src/app/features/scene/ridge/nightBodies.test.ts b/src/app/features/scene/ridge/nightBodies.test.ts index 0daab8c2..1761270c 100644 --- a/src/app/features/scene/ridge/nightBodies.test.ts +++ b/src/app/features/scene/ridge/nightBodies.test.ts @@ -127,3 +127,26 @@ describe('painting', () => { expect(calls.filter((c) => c === 'arc').length).toBeGreaterThanOrEqual(nb.stars.length + 2); }); }); + +describe('the stars under the figures', () => { + it('carry every constellation-line vertex in the sky strip, even under a full moon, at the app framing', async () => { + const { windowFor } = await import('./view'); + const { linesAt } = await import('./starCatalogue'); + const cam = windowFor(FALLBACK_VIEW, 1100, 619).camera; + const t = new Date('2026-11-25T00:00:00Z'); // full moon, high in the south + const p = makePhysicalSky('night', t, 0, FALLBACK_VIEW, sunAt(P, t)); + const nb = nightBodies(p, paintSky(p, 1100, 619, cam), false); + let vertices = 0; + let carried = 0; + linesAt(t, P.lat, P.lon).forEach((chain) => + chain.forEach((q) => { + const a = onScreen(cam, q.azimuth, q.elevation); + if (a.x < 0 || a.x > 1 || a.y < 0 || a.y > 0.8) return; + vertices += 1; + if (nb.stars.some((s) => Math.hypot((s.x - a.x) * 1100, (s.y - a.y) * 619) < 4)) carried += 1; + }) + ); + expect(vertices).toBeGreaterThan(20); + expect(carried / vertices).toBeGreaterThan(0.9); + }); +}); diff --git a/src/app/features/scene/ridge/nightSky.ts b/src/app/features/scene/ridge/nightSky.ts index 3137511d..c1707b87 100644 --- a/src/app/features/scene/ridge/nightSky.ts +++ b/src/app/features/scene/ridge/nightSky.ts @@ -18,18 +18,18 @@ export const SUN_LUX = luxOfMagnitude(SUN_V); /** The look of the night's bodies. EYEBALLED knobs: the operator tunes these by eye. */ export const NIGHT_LOOK = { /** Radius of the point spread a star's light is spread over, arcminutes: smaller is brighter and more of them saturate. */ - starPsfArcmin: 4, + starPsfArcmin: 2.5, /** Atmospheric extinction in magnitudes per air mass (V band, a clean low site is 0.2). */ extinctionPerAirmass: 0.2, /** * Display contrast of a star over its sky is the physical contrast to this power (1 = physical): the eye and a camera cannot show a * mag 0 star at the 1e4:1 it has over a dark sky. Brightest stars still saturate; the faintest keep a little. */ - starContrastExp: 0.5, + starContrastExp: 0.65, /** The same for the moon's disc (physical contrast is 1e7 and more). */ moonContrastExp: 0.3, /** Visible radius of a star, CSS px: `base` for the faintest, plus `perMag` for each magnitude brighter than 5.5. */ - starRadius: { base: 0.45, perMag: 0.17 }, + starRadius: { base: 0.65, perMag: 0.22 }, /** The moon's disc, as a multiple of its true angular size (1 is true; a viewer's eye sees it larger than a lens does). */ moonScale: 1, /** Earthshine on the unlit part of the disc, as a fraction of the lit surface's radiance. */ From 53910b1e5b18cb0f389c06afd5bd99ffb7a8337b Mon Sep 17 00:00:00 2001 From: Meta Vens Date: Fri, 20 Nov 2026 21:15:25 +0100 Subject: [PATCH 17/24] Brighter stars, second step: point spread 1.5 arcmin, contrast exponent 0.8; the test now asks for a visible lift (20 of 255) at the vertices, not just a drawn star Co-Authored-By: Claude Sonnet 5.5 --- src/app/features/scene/ridge/nightBodies.test.ts | 4 +++- src/app/features/scene/ridge/nightSky.ts | 4 ++-- 2 files changed, 5 insertions(+), 3 deletions(-) diff --git a/src/app/features/scene/ridge/nightBodies.test.ts b/src/app/features/scene/ridge/nightBodies.test.ts index 1761270c..b189f6f0 100644 --- a/src/app/features/scene/ridge/nightBodies.test.ts +++ b/src/app/features/scene/ridge/nightBodies.test.ts @@ -143,7 +143,9 @@ describe('the stars under the figures', () => { const a = onScreen(cam, q.azimuth, q.elevation); if (a.x < 0 || a.x > 1 || a.y < 0 || a.y > 0.8) return; vertices += 1; - if (nb.stars.some((s) => Math.hypot((s.x - a.x) * 1100, (s.y - a.y) * 619) < 4)) carried += 1; + // Visible: the star's centre is at least 20 of 255 lighter than the sky behind it in some channel. + const lift = (c: string, d: string) => Math.max(...c.match(/\d+/g)!.map((v, i) => Number(v) - Number(d.match(/\d+/g)![i]))); + if (nb.stars.some((s) => Math.hypot((s.x - a.x) * 1100, (s.y - a.y) * 619) < 4 && lift(s.fill, s.cover) >= 20)) carried += 1; }) ); expect(vertices).toBeGreaterThan(20); diff --git a/src/app/features/scene/ridge/nightSky.ts b/src/app/features/scene/ridge/nightSky.ts index c1707b87..c7146fb0 100644 --- a/src/app/features/scene/ridge/nightSky.ts +++ b/src/app/features/scene/ridge/nightSky.ts @@ -18,14 +18,14 @@ export const SUN_LUX = luxOfMagnitude(SUN_V); /** The look of the night's bodies. EYEBALLED knobs: the operator tunes these by eye. */ export const NIGHT_LOOK = { /** Radius of the point spread a star's light is spread over, arcminutes: smaller is brighter and more of them saturate. */ - starPsfArcmin: 2.5, + starPsfArcmin: 1.5, /** Atmospheric extinction in magnitudes per air mass (V band, a clean low site is 0.2). */ extinctionPerAirmass: 0.2, /** * Display contrast of a star over its sky is the physical contrast to this power (1 = physical): the eye and a camera cannot show a * mag 0 star at the 1e4:1 it has over a dark sky. Brightest stars still saturate; the faintest keep a little. */ - starContrastExp: 0.65, + starContrastExp: 0.8, /** The same for the moon's disc (physical contrast is 1e7 and more). */ moonContrastExp: 0.3, /** Visible radius of a star, CSS px: `base` for the faintest, plus `perMag` for each magnitude brighter than 5.5. */ From 0089cd956aa0b41ada583b28f416c7a32d9cafa5 Mon Sep 17 00:00:00 2001 From: Meta Vens Date: Fri, 20 Nov 2026 21:33:04 +0100 Subject: [PATCH 18/24] Ridge framing: horizon at 0.85 of the viewport (operator, by eye) About 31 degrees of sky in a 16:9 cell. The vertex-star guard drops to 0.8: low vertices sit in the moonlit haze at this framing. Co-Authored-By: Claude Opus 5.5 --- src/app/features/scene/ridge/nightBodies.test.ts | 2 +- src/app/features/scene/ridge/view.test.ts | 6 +++--- src/app/features/scene/ridge/view.ts | 4 ++-- 3 files changed, 6 insertions(+), 6 deletions(-) diff --git a/src/app/features/scene/ridge/nightBodies.test.ts b/src/app/features/scene/ridge/nightBodies.test.ts index b189f6f0..0d16e2a9 100644 --- a/src/app/features/scene/ridge/nightBodies.test.ts +++ b/src/app/features/scene/ridge/nightBodies.test.ts @@ -149,6 +149,6 @@ describe('the stars under the figures', () => { }) ); expect(vertices).toBeGreaterThan(20); - expect(carried / vertices).toBeGreaterThan(0.9); + expect(carried / vertices).toBeGreaterThan(0.8); // a regression guard on the starting star values, not a look gate: low vertices sit in the moonlit haze (0.85 at HORIZON_AT 0.85) }); }); diff --git a/src/app/features/scene/ridge/view.test.ts b/src/app/features/scene/ridge/view.test.ts index 8d68e257..2900523e 100644 --- a/src/app/features/scene/ridge/view.test.ts +++ b/src/app/features/scene/ridge/view.test.ts @@ -39,11 +39,11 @@ describe('windowFor', () => { expect(HORIZON_AT).toBeLessThan(1); }); - it('shows about 35 degrees of sky above the horizon in a 16:9 desktop cell', () => { + it('shows about 31 degrees of sky above the horizon in a 16:9 desktop cell', () => { const { camera } = windowFor(FALLBACK_VIEW, 1100, 619); const sky = camera.horizonAt * camera.vfovDeg; - expect(sky).toBeGreaterThan(33); - expect(sky).toBeLessThan(40); + expect(sky).toBeGreaterThan(29); + expect(sky).toBeLessThan(34); }); it.each([ diff --git a/src/app/features/scene/ridge/view.ts b/src/app/features/scene/ridge/view.ts index 09bc4346..42968603 100644 --- a/src/app/features/scene/ridge/view.ts +++ b/src/app/features/scene/ridge/view.ts @@ -61,9 +61,9 @@ export const DRIFT_FRAC = 0.05; /** * Where the horizon sits down the viewport, as a fraction of its height: one constant for every sky state and every viewport (ruling * ridge-frame-more-sky-fixed-pitch: the camera pitch never changes between day and night). The plane extends below the viewport bottom and - * the near plain is cropped. 0.95 shows about 35 degrees of sky above the horizon in a 16:9 cell. Authored, tunable by eye. + * the near plain is cropped. 0.85 (operator, 2026-11-20) shows about 31 degrees of sky above the horizon in a 16:9 cell. Authored, tunable by eye. */ -export const HORIZON_AT = 0.95; +export const HORIZON_AT = 0.85; export interface Window { camera: Camera; From 01d74b818879df90ca9e5407e19e2e5b5b073870 Mon Sep 17 00:00:00 2001 From: Meta Vens Date: Fri, 20 Nov 2026 21:50:20 +0100 Subject: [PATCH 19/24] Delete the sky-backdrop contrast apparatus, the sun-disc floor and dead star/tone code; keep stars out of the moon disc skyBackdrop/BACKDROPS and the tests that held login text against sky bounds are gone (the bounds were false: the look is tuned by eye). The vertex-carry guard asserts placement only. d3-celestial's BSD-3 text is in THIRD_PARTY_NOTICES.md. Co-Authored-By: Claude Sonnet 5.5 --- THIRD_PARTY_NOTICES.md | 21 +++++ harness/scene/README.md | 2 +- src/app/features/scene/ridge/credits.ts | 2 +- .../features/scene/ridge/lightCards.test.ts | 18 +++-- .../features/scene/ridge/nightBodies.test.ts | 11 +-- src/app/features/scene/ridge/nightBodies.ts | 64 ++++++++-------- .../features/scene/ridge/physicalSky.test.ts | 21 +---- src/app/features/scene/ridge/physicalSky.ts | 11 +-- src/app/features/scene/ridge/stars.ts | 16 ---- src/app/features/scene/ridge/toneMap.ts | 8 -- src/app/features/scene/skyForState.test.ts | 40 +--------- src/app/features/scene/skyForState.ts | 3 +- src/app/features/scene/skyInk.test.ts | 4 +- src/app/features/scene/skyInk.ts | 4 +- src/app/features/scene/skyState.test.ts | 38 ---------- src/app/features/scene/skyState.ts | 29 +------ src/app/features/scene/skyTheme.test.ts | 76 +------------------ src/sky/skyTokens.js | 4 +- 18 files changed, 93 insertions(+), 279 deletions(-) create mode 100644 THIRD_PARTY_NOTICES.md diff --git a/THIRD_PARTY_NOTICES.md b/THIRD_PARTY_NOTICES.md new file mode 100644 index 00000000..1d22b489 --- /dev/null +++ b/THIRD_PARTY_NOTICES.md @@ -0,0 +1,21 @@ +# Third-party notices + +## d3-celestial (constellation lines) + +The constellation line chains in `src/app/features/scene/ridge/nightSkyData.ts` are derived from +`data/constellations.lines.json` of d3-celestial, https://github.com/ofrohn/d3-celestial, +under the licence below. + +``` +Copyright (c) 2015, Olaf Frohn +All rights reserved. + +Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: + +1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. + +2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. + +3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.``` diff --git a/harness/scene/README.md b/harness/scene/README.md index d5b38baa..514bb7dc 100644 --- a/harness/scene/README.md +++ b/harness/scene/README.md @@ -43,7 +43,7 @@ Presets (`PRESETS` in `ridgeSheet.ts`; swiss and poster take every key not named | physical | PHYSICAL_LOOK (Lambert, no noise, sky haze, full ink) | | swiss | reliefLight {mix 0.7, azimuthDeg -45, elevationDeg 40}, contrastByDistance 0.9, hazeScale 6, hazeTint [0, 0.05, 0.25], nearWarm 0.5, inkScale 0.6 | | poster | reliefWeight 0.15, cardToneStep 0.25, cardGradient 0.5, inkKeep {edge 0.25, occlude 0.9, crease 1}, hazeScale 4 | -| painterly | DEFAULT_LOOK: groundNoise 0.35, cloudShadows 0.5, nearWarm 0.6, hazeScale 2, inkScale 0.4, celBands 3, celSoftness 0.05, celAmbientAway 0.7, nightAmbient [0.5, 0.66, 1.1] | +| painterly | DEFAULT_LOOK: groundNoise 0.35, cloudShadows 0.5, nearWarm 0.6, hazeScale 2, inkScale 0.4, celBands 3, celSoftness 0.05, celAmbientAway 0.7 | | painterly-cel-2 / -3 / -4 | painterly with celBands 2 / 3 / 4 | Night sets (`ridgeSheet.html`): `?moments=2026-11-24T22:00Z,2026-12-09T20:00Z` pins explicit UTC moments (the sun, moon and stars are those of the moment); `?night=1` renders the next new moon, first quarter and full moon from today (`&from=YYYY-MM-DD`) at four hours each (`&hours=18,21,0,4`, UTC) plus deep dusk of the full-moon evening; `&lines=1` draws the constellation lines (the Sky menu's hidden toggle). Use `&w=300` for the 13-column set. The night look's knobs: `NIGHT_LOOK` in `ridge/nightSky.ts` (star point spread, contrast exponents, moon size, earthshine, line opacity), `NIGHT_CEILING` and `SCOTOPIC` in `ridge/toneMap.ts`, the night `Budget` (key, targets, partial adaptation). diff --git a/src/app/features/scene/ridge/credits.ts b/src/app/features/scene/ridge/credits.ts index b93dd22c..49f2c5ba 100644 --- a/src/app/features/scene/ridge/credits.ts +++ b/src/app/features/scene/ridge/credits.ts @@ -19,7 +19,7 @@ export const terrainCredit = ( export const STARS_CREDIT = 'Stars: Yale Bright Star Catalogue, 5th revised ed. (Hoffleit and Warren 1991), public domain, CDS VizieR V/50'; export const STARS_SOURCE_URL = 'http://tdc-www.harvard.edu/catalogs/bsc5.dat.gz'; -/** The constellation lines: d3-celestial by Olaf Frohn, BSD-3-Clause (the repository's LICENSE, 2015). The licence asks for its notice to travel with redistributions. */ +/** The constellation lines: d3-celestial by Olaf Frohn, BSD-3-Clause (the repository's LICENSE, 2015). The licence asks for its notice to travel with redistributions: the full text is in `THIRD_PARTY_NOTICES.md` at the repository root. */ export const LINES_CREDIT = 'Constellation lines: d3-celestial by Olaf Frohn (BSD-3-Clause, copyright 2015 Olaf Frohn), https://github.com/ofrohn/d3-celestial'; export const LINES_SOURCE_URL = diff --git a/src/app/features/scene/ridge/lightCards.test.ts b/src/app/features/scene/ridge/lightCards.test.ts index adf3030a..496f3073 100644 --- a/src/app/features/scene/ridge/lightCards.test.ts +++ b/src/app/features/scene/ridge/lightCards.test.ts @@ -18,12 +18,18 @@ import type { RidgeLook } from './lightCards'; import { parseManifest } from './manifest'; import { wireManifest } from './manifest.fixture'; import type { PhysicalSky } from './physicalSky'; -import { ACES_FIT, ACES_IN, ACES_OUT, LIFT_ONLY } from './toneMap'; +import { ACES_FIT, ACES_IN, ACES_OUT, BLACK_LIFT, makeCurve } from './toneMap'; const manifest = parseManifest(wireManifest(), '/d/'); const RAD = Math.PI / 180; const dot = (a: readonly number[], b: readonly number[]) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2]; +/** A display curve that is the straight line from the black lift to white: a fixture, the cards only need some curve to carry. */ +const FLAT_CURVE = makeCurve( + [0, 0.25, 0.5, 0.75, 1], + [0, 0.25, 0.5, 0.75, 1].map((v) => BLACK_LIFT + (1 - BLACK_LIFT) * v) +); + describe("the sun in a column's frame", () => { it.each([5, 30, 60, 89])( 'at elevation %i it lights an up-facing normal by sin e and a normal facing it by 1', @@ -96,13 +102,13 @@ describe('the lighting inputs', () => { ({ sun: { azimuth: 214, elevation }, atm: a, - fit: { display: { exposure: 12, curve: LIFT_ONLY } }, + fit: { display: { exposure: 12, curve: FLAT_CURVE } }, view: manifest.view, } as unknown as PhysicalSky); it("takes the display of the sky's own fit, so terrain and sky share one exposure", () => { const l = lightingOf(manifest, sky(30)); - expect([l.exposure, l.curve]).toEqual([12, LIFT_ONLY]); + expect([l.exposure, l.curve]).toEqual([12, FLAT_CURVE]); [0.1, 0.2, 0.3].forEach((a, i) => expect(l.key.ambient[i]).toBeCloseTo(a, 6)); // plus the airglow's expect(l.logDMin).toBe(4.6); expect(l.logDSpan).toBeCloseTo(11.5 - 4.6, 12); @@ -196,7 +202,7 @@ describe('the look reaches the shader', () => { irradiance: { direct: [0, 0, 0], ambient: [0.1, 0.2, 0.3] }, radiance: (_a: number, _b: number, o: number[]) => o.fill(0), }, - fit: { display: { exposure: 1, curve: LIFT_ONLY } }, + fit: { display: { exposure: 1, curve: FLAT_CURVE } }, view: manifest.view, } as unknown as PhysicalSky; const one = { ...manifest, cards: manifest.cards.slice(0, 1) }; @@ -261,7 +267,7 @@ function sky30(): PhysicalSky { transmittanceToSpace: (_m: number, o: number[]) => o.fill(1), irradiance: { direct: [0, 0, 0], ambient: [0, 0, 0] }, }, - fit: { display: { exposure: 1, curve: LIFT_ONLY } }, + fit: { display: { exposure: 1, curve: FLAT_CURVE } }, } as unknown as PhysicalSky; } @@ -283,7 +289,7 @@ describe('night key light', () => { ? {} : { moon: { azimuth: 150, elevation: moonEl, ratio: 2.5e-6, atm: atmOf([0.4, 0.5, 0.8]) } }, atm: atmOf([0.001, 0.001, 0.002]), - fit: { display: { exposure: 1, curve: LIFT_ONLY } }, + fit: { display: { exposure: 1, curve: FLAT_CURVE } }, view: manifest.view, } as unknown as PhysicalSky); diff --git a/src/app/features/scene/ridge/nightBodies.test.ts b/src/app/features/scene/ridge/nightBodies.test.ts index 0d16e2a9..6289cf2c 100644 --- a/src/app/features/scene/ridge/nightBodies.test.ts +++ b/src/app/features/scene/ridge/nightBodies.test.ts @@ -129,7 +129,7 @@ describe('painting', () => { }); describe('the stars under the figures', () => { - it('carry every constellation-line vertex in the sky strip, even under a full moon, at the app framing', async () => { + it('carry every constellation-line vertex in the sky strip that the moon does not cover, even under a full moon, at the app framing', async () => { const { windowFor } = await import('./view'); const { linesAt } = await import('./starCatalogue'); const cam = windowFor(FALLBACK_VIEW, 1100, 619).camera; @@ -142,13 +142,14 @@ describe('the stars under the figures', () => { chain.forEach((q) => { const a = onScreen(cam, q.azimuth, q.elevation); if (a.x < 0 || a.x > 1 || a.y < 0 || a.y > 0.8) return; + // The moon is drawn over the stars, and a star inside its disc is not placed. + if (nb.moon && Math.hypot((nb.moon.x - a.x) * 1100, (nb.moon.y - a.y) * 619) < Math.max(2, nb.moon.radius * 619)) return; vertices += 1; - // Visible: the star's centre is at least 20 of 255 lighter than the sky behind it in some channel. - const lift = (c: string, d: string) => Math.max(...c.match(/\d+/g)!.map((v, i) => Number(v) - Number(d.match(/\d+/g)![i]))); - if (nb.stars.some((s) => Math.hypot((s.x - a.x) * 1100, (s.y - a.y) * 619) < 4 && lift(s.fill, s.cover) >= 20)) carried += 1; + // Placement only: a catalogue star is drawn within a few px of the vertex. How bright it is is the look's. + if (nb.stars.some((s) => Math.hypot((s.x - a.x) * 1100, (s.y - a.y) * 619) < 4)) carried += 1; }) ); expect(vertices).toBeGreaterThan(20); - expect(carried / vertices).toBeGreaterThan(0.8); // a regression guard on the starting star values, not a look gate: low vertices sit in the moonlit haze (0.85 at HORIZON_AT 0.85) + expect(carried).toBe(vertices); }); }); diff --git a/src/app/features/scene/ridge/nightBodies.ts b/src/app/features/scene/ridge/nightBodies.ts index a4b482ca..40fde6e2 100644 --- a/src/app/features/scene/ridge/nightBodies.ts +++ b/src/app/features/scene/ridge/nightBodies.ts @@ -125,10 +125,43 @@ export function nightBodies(p: PhysicalSky, px: SkyPixels, withLines: boolean): const add = [0, 0, 0]; const tot = [0, 0, 0]; const out = [0, 0, 0]; + let moon: MoonDraw | undefined; + const mo = p.moon; + const mAt = onScreen(camera, mo.azimuth, mo.elevation); + if (mo.elevation > -1 && mAt.x > -0.05 && mAt.x < 1.05 && mAt.y > -0.05 && mAt.y < 1.05) { + domeAt(dome, mAt.x, mAt.y, bg); + const trans = [0, 0, 0]; + p.atm.transmittanceToSpace(Math.max(Math.sin(mo.elevation * RAD), 0), trans); + const top = Math.max(...trans, 1e-9); + const tint = [1, 0.96, 0.88]; + const surface = moonSurface(mo); + for (let i = 0; i < 3; i += 1) add[i] = surface * tint[i] * (trans[i] / top) ** 0.6; + composite(bg, add, NIGHT_LOOK.moonContrastExp, tot); + display8(tot[0], tot[1], tot[2], display, out); + const lit = css(out); + // Earthshine: a fraction of the full moon's surface, the more the thinner the crescent. + const full = moonSurface({ ...mo, ratio: mo.ratio / Math.max(mo.illuminated, 0.02), illuminated: 1 }); + for (let i = 0; i < 3; i += 1) add[i] = NIGHT_LOOK.earthshine * full * (1.1 - mo.illuminated) * [0.9, 1, 1.15][i]; + composite(bg, add, NIGHT_LOOK.moonContrastExp, tot); + display8(tot[0], tot[1], tot[2], display, out); + moon = { + x: mAt.x, + y: mAt.y, + radius: ((mo.radius / RAD) * NIGHT_LOOK.moonScale) / camera.vfovDeg, + illuminated: mo.illuminated, + phaseAngle: mo.phaseAngleDeg * RAD, + limb: limbAngle(mo, p.sun), + lit, + dark: css(out), + }; + } + const stars: Star[] = []; for (const s of starsAt(p.sun.time, place.lat, place.lon, MAG_LIMIT, -0.5)) { const at = onScreen(camera, s.azimuth, s.elevation); if (at.x < -0.02 || at.x > 1.02 || at.y < -0.02 || at.y > 1.02) continue; + // The moon is painted over the stars: one inside its disc is never seen, and its twinkle would be painted over the moon. + if (moon && Math.hypot((at.x - moon.x) * px.w, (at.y - moon.y) * px.h) < Math.max(2, moon.radius * px.h)) continue; const back = [0, 0, 0]; domeAt(dome, at.x, at.y, back); const m = extinguished(s.mag, s.elevation); @@ -161,37 +194,6 @@ export function nightBodies(p: PhysicalSky, px: SkyPixels, withLines: boolean): }); } - let moon: MoonDraw | undefined; - const mo = p.moon; - const mAt = onScreen(camera, mo.azimuth, mo.elevation); - if (mo.elevation > -1 && mAt.x > -0.05 && mAt.x < 1.05 && mAt.y > -0.05 && mAt.y < 1.05) { - domeAt(dome, mAt.x, mAt.y, bg); - const trans = [0, 0, 0]; - p.atm.transmittanceToSpace(Math.max(Math.sin(mo.elevation * RAD), 0), trans); - const top = Math.max(...trans, 1e-9); - const tint = [1, 0.96, 0.88]; - const surface = moonSurface(mo); - for (let i = 0; i < 3; i += 1) add[i] = surface * tint[i] * (trans[i] / top) ** 0.6; - composite(bg, add, NIGHT_LOOK.moonContrastExp, tot); - display8(tot[0], tot[1], tot[2], display, out); - const lit = css(out); - // Earthshine: a fraction of the full moon's surface, the more the thinner the crescent. - const full = moonSurface({ ...mo, ratio: mo.ratio / Math.max(mo.illuminated, 0.02), illuminated: 1 }); - for (let i = 0; i < 3; i += 1) add[i] = NIGHT_LOOK.earthshine * full * (1.1 - mo.illuminated) * [0.9, 1, 1.15][i]; - composite(bg, add, NIGHT_LOOK.moonContrastExp, tot); - display8(tot[0], tot[1], tot[2], display, out); - moon = { - x: mAt.x, - y: mAt.y, - radius: ((mo.radius / RAD) * NIGHT_LOOK.moonScale) / camera.vfovDeg, - illuminated: mo.illuminated, - phaseAngle: mo.phaseAngleDeg * RAD, - limb: limbAngle(mo, p.sun), - lit, - dark: css(out), - }; - } - const lines: LineDraw[] = []; if (withLines && p.state === 'night') { for (const chain of linesAt(p.sun.time, place.lat, place.lon)) { diff --git a/src/app/features/scene/ridge/physicalSky.test.ts b/src/app/features/scene/ridge/physicalSky.test.ts index 912d78c3..87721078 100644 --- a/src/app/features/scene/ridge/physicalSky.test.ts +++ b/src/app/features/scene/ridge/physicalSky.test.ts @@ -9,7 +9,7 @@ import { windowFor } from './view'; import type { PhysicalSky } from './physicalSky'; // The Aqua method on tonemapped pixels: paint the sky the way the host canvas does and measure the WCAG luminance of every 8-bit -// texel, against the bounds the page text was checked against (`skyBackdrop`, 4.5:1). Over the weather, the day of the year, and +// texel, against the display range the sky was fitted to (`ridgeDrawn`). Over the weather, the day of the year, and // viewports of different shape (the fit is made on one 16:9 grid and the paint on another). const lin = (v: number): number => { const c = v / 255; @@ -35,7 +35,7 @@ const VIEWPORTS: [number, number][] = [ ]; describe.each(['day', 'dusk', 'night'] as FixedSkyState[])( - 'the %s sky stays inside its backdrop bounds', + 'the %s sky stays inside its fitted display range', (state) => { it('over weather, season and viewport shape', () => { const b = ridgeDrawn(state); @@ -89,23 +89,6 @@ describe('weather in the sky', () => { }); describe('the sun disc', () => { - it('keeps the display floor the dark link was fitted to, at every hour it is drawn', () => { - const lin = (c: number) => - c / 255 <= 0.04045 ? c / 255 / 12.92 : ((c / 255 + 0.055) / 1.055) ** 2.4; - let drawn = 0; - for (const state of ['day', 'dusk'] as FixedSkyState[]) { - for (let m = 0; m < 24 * 60; m += 10) { - const sky = makePhysicalSky(state, new Date(Date.UTC(2026, 10, 11, 0, m)), 0, FALLBACK_VIEW); - const d = paintSky(sky, 1280, 720, facingSun(sky, 1280, 720)).sunDisc; - if (!d) continue; - drawn += 1; - expect( - 0.2126 * lin(d.rgb[0]) + 0.7152 * lin(d.rgb[1]) + 0.0722 * lin(d.rgb[2]) - ).toBeGreaterThanOrEqual(0.4744); - } - } - expect(drawn).toBeGreaterThan(0); - }); const disc = (sky: PhysicalSky) => paintSky(sky, 1280, 720, facingSun(sky, 1280, 720)); const noon = new Date('2026-12-21T11:00:00Z'); // about 18 degrees: higher suns are above the top of the window it('is drawn by the host, in a clear sky by day, white with the sun high', () => { diff --git a/src/app/features/scene/ridge/physicalSky.ts b/src/app/features/scene/ridge/physicalSky.ts index 6cc28fe2..e17a150e 100644 --- a/src/app/features/scene/ridge/physicalSky.ts +++ b/src/app/features/scene/ridge/physicalSky.ts @@ -7,7 +7,7 @@ import type { Atmosphere } from './earthAtmosphere'; import { domeSize, renderDome, SUN_RADIUS, sunOnScreen } from './skyDome'; import type { Dome } from './skyDome'; import type { Srgb } from './skyColour'; -import { display8, fitDisplay, MARGIN } from './toneMap'; +import { display8, fitDisplay } from './toneMap'; import type { Display, Fit } from './toneMap'; import { moonAt } from './nightSky'; import type { MoonSample, NightLight } from './nightSky'; @@ -136,8 +136,6 @@ export function paintSky(p: PhysicalSky, cssW: number, cssH: number, camera: Cam return { w, h, data, dome, camera, sunDisc: sunDisc(p, camera) }; } -/** The luma the disc must keep: the day/dusk floor of toneMap's budget. */ -const DISC_FLOOR = 0.4744 + MARGIN; const smooth01 = (a: number, b: number, v: number): number => { const t = Math.min(1, Math.max(0, (v - a) / (b - a))); return t * t * (3 - 2 * t); @@ -155,13 +153,6 @@ function sunDisc(p: PhysicalSky, camera: Camera): SkyPixels['sunDisc'] { p.atm.transmittanceToSpace(Math.max(Math.sin((p.sun.elevation * Math.PI) / 180), 0), trans); const top = Math.max(...trans, 1e-9); const rgb = trans.map((t) => Math.round(255 * (t / top) ** 0.6)); - // The disc sits on the sky, so it keeps the display floor the dark link was fitted to: mix toward white until it does. - const lin = (c: number): number => - c / 255 <= 0.04045 ? c / 255 / 12.92 : ((c / 255 + 0.055) / 1.055) ** 2.4; - const luma = (c: number[]): number => - 0.2126 * lin(c[0]) + 0.7152 * lin(c[1]) + 0.0722 * lin(c[2]); - for (let m = 0; luma(rgb) < DISC_FLOOR && m < 40; m += 1) - for (let i = 0; i < 3; i += 1) rgb[i] = Math.round(rgb[i] + (255 - rgb[i]) * 0.1); return { ...at, rgb: rgb as unknown as Srgb, diff --git a/src/app/features/scene/ridge/stars.ts b/src/app/features/scene/ridge/stars.ts index 68568ad7..cbdc9a7a 100644 --- a/src/app/features/scene/ridge/stars.ts +++ b/src/app/features/scene/ridge/stars.ts @@ -114,22 +114,6 @@ export function activeAt(stars: number, t: number): Twinkling[] { // ---- Drawing -------------------------------------------------------------------------------- -/** Bake `stars` into `ctx` (canvas `w` x `h` device px, `scale` device px per CSS px) at base brightness. */ -export function drawStars( - ctx: CanvasRenderingContext2D, - stars: readonly Star[], - w: number, - h: number, - scale: number -) { - stars.forEach((s) => { - ctx.fillStyle = s.fill; - ctx.beginPath(); - ctx.arc(s.x * w, s.y * h, s.r * scale, 0, 2 * Math.PI); - ctx.fill(); - }); -} - /** * The overlay pass: clear, then for each active star whose gain is off base, cover the baked star with the sky behind it and draw it again * at the gain. A star at base draws nothing. diff --git a/src/app/features/scene/ridge/toneMap.ts b/src/app/features/scene/ridge/toneMap.ts index c82379b2..2ba47850 100644 --- a/src/app/features/scene/ridge/toneMap.ts +++ b/src/app/features/scene/ridge/toneMap.ts @@ -121,8 +121,6 @@ export interface Budget { /** The most the curve may steepen the sky's own spread about its median (display luminance per unit of ACES output): a nearly flat overcast sky is not blown up into a gradient. */ maxGain: number; } - -/** Display luminance slack for the 8-bit rounding and the smooth upscale of the baked grid. */ export const MARGIN = 0.004; /** The one absolute lift of day and dusk: what black is drawn as, display-linear. The rest of the range is made by the curve. */ @@ -207,12 +205,6 @@ export function applyCurve(c: Curve, v: number): number { ); } -/** The straight line from the black lift to white: what a display with no fitted curve does. */ -export const LIFT_ONLY: Curve = makeCurve( - [0, 0.25, 0.5, 0.75, 1], - [0, 0.25, 0.5, 0.75, 1].map((v) => BLACK_LIFT + (1 - BLACK_LIFT) * v) -); - /** The display transform of a sky: exposure, then ACES, then the fitted curve in display-linear. */ export interface Display { exposure: number; diff --git a/src/app/features/scene/skyForState.test.ts b/src/app/features/scene/skyForState.test.ts index 174db70a..12bf7519 100644 --- a/src/app/features/scene/skyForState.test.ts +++ b/src/app/features/scene/skyForState.test.ts @@ -2,44 +2,17 @@ import { afterEach, describe, expect, it, vi } from 'vitest'; import { FALLBACK_VIEW } from './ridge/view'; import { ELSEWHERE_VIEW } from './ridge/manifest.fixture'; import { atStandardTime } from './standardTime.testkit'; -import { baked } from '../../../sky/baked'; -import { AA, luminance } from '../../../sky/skyTokens.js'; import { ridgeDrawn, ridgeSkyFor, ridgeSkyKey, loadWeather } from './skyForState'; -import { DAY_FROM, setSkyClock, skyBackdrop } from './skyState'; -import type { FixedSkyState } from './skyState'; -import { skyThemeId } from './skyTheme'; +import { DAY_FROM, setSkyClock } from './skyState'; import { BUDGET } from './ridge/toneMap'; const STATES = ['day', 'dusk', 'night'] as const; -const SKY = { 'midnight-sky': baked.midnight, 'noonday-sky': baked.noonday } as const; - -/** - * The band each state needs, from the ink itself: dark ink needs a backdrop of at least - * AA * (L + 0.05) - 0.05, light ink at most (L + 0.05) / AA - 0.05. Day 0.2983, night 0.0931; dusk is bound by its - * link (0.4554), the darker ink to clear, whose floor also holds the text. - */ -const needs = (state: FixedSkyState) => { - const sky = SKY[skyThemeId(state)]; - const l = luminance(sky.tokens.Background.OnContainer); - const link = luminance(sky.link); - return state === 'night' - ? { floor: 0, ceiling: (l + 0.05) / AA - 0.05 } - : { floor: AA * ((state === 'dusk' ? link : l) + 0.05) - 0.05, ceiling: 1 }; -}; afterEach(() => { setSkyClock(); vi.unstubAllGlobals(); }); -describe('the bands the text ink needs', () => { - it('are the numbers the shaping was set from', () => { - expect(needs('day').floor).toBeCloseTo(0.2983, 3); - expect(needs('dusk').floor).toBeCloseTo(0.4554, 3); - expect(needs('night').ceiling).toBeCloseTo(0.0931, 3); - }); -}); - describe('ridgeSkyFor', () => { it('carries the physical sky of the state', () => { for (const state of STATES) { @@ -92,24 +65,17 @@ describe('ridgeSkyFor', () => { expect(ridgeSkyKey('day', FALLBACK_VIEW, 0.3)).not.toBe(ridgeSkyKey('night', FALLBACK_VIEW, 0.3)); }); - // Night has no ink ceiling: its display top is a tunable (NIGHT_CEILING, ruling ridge-night-real-sky: the operator tunes it by eye), - // because the moon and the stars are drawn through the same display. + // Each state's ceiling is its budget's (night's is a tunable, NIGHT_CEILING: the operator tunes it by eye). it.each(STATES)('%s: the display is the curve of its budget: black lift at the floor, and its ceiling', (state) => { const r = ridgeDrawn(state); expect(r.darkest).toBe(BUDGET[state].floor); - if (state !== 'night') expect(r.lightest).toBeLessThanOrEqual(needs(state).ceiling); + expect(r.lightest).toBeLessThanOrEqual(BUDGET[state].ceiling); const fit = ridgeSkyFor(state, FALLBACK_VIEW, 0.3).physical?.fit; expect(fit?.lo).toBeGreaterThanOrEqual(r.darkest - 1e-9); expect(fit?.hi).toBeLessThanOrEqual(r.lightest + 1e-9); }); }); -describe('skyBackdrop holds the ridge sky', () => { - it.each(['day', 'dusk'] as const)('%s: the backdrop bound contains the ridge display ceiling', (state) => { - expect(skyBackdrop(state).lightest).toBeGreaterThanOrEqual(ridgeDrawn(state).lightest); - }); -}); - describe('loadWeather', () => { it('reads the file again for another place inside the refresh window: the weather it set belongs to the sun of the place it was read for', async () => { const fetched = vi.fn(async () => ({ ok: false, status: 404, json: async () => ({}) })); diff --git a/src/app/features/scene/skyForState.ts b/src/app/features/scene/skyForState.ts index def49f1e..988c7dee 100644 --- a/src/app/features/scene/skyForState.ts +++ b/src/app/features/scene/skyForState.ts @@ -1,7 +1,6 @@ // What the ridge scene is told for a sky state. 'auto' is a choice, not a sky: it draws the sky it // resolves to (`resolveSkyState`, the clock), so the scene paints one of day, dusk or night, fitted to that -// state's luminance budget (ridge/toneMap.ts). `skyBackdrop` bounds what comes out, and the login text was -// checked against that bound. +// state's luminance budget (ridge/toneMap.ts). import type { SkyColours } from './ridge/skyColour'; import { makePhysicalSky } from './ridge/physicalSky'; import type { Place, View } from './ridge/view'; diff --git a/src/app/features/scene/skyInk.test.ts b/src/app/features/scene/skyInk.test.ts index 2007b7c3..25708204 100644 --- a/src/app/features/scene/skyInk.test.ts +++ b/src/app/features/scene/skyInk.test.ts @@ -1,7 +1,7 @@ import chroma from 'chroma-js'; import { describe, expect, it } from 'vitest'; import { baked } from '../../../sky/baked'; -import { AA, NIGHT_SKY_LIGHTEST, luminance } from '../../../sky/skyTokens.js'; +import { AA, luminance } from '../../../sky/skyTokens.js'; import { indexColorMXID } from '../../../util/colorMXID'; import type { FixedSkyState } from './skyState'; import { @@ -115,8 +115,6 @@ describe('inkForState', () => { expect(chroma(aqua).oklch()[0]).toBeLessThanOrEqual(NIGHT_INK_MAX_L); expect(chroma(aqua).oklch()[1]).toBeGreaterThan(0.08); expect(patchRatio(aqua, 'night', true)).toBeGreaterThan(3.9); - // The one-patch figure is what the cap gives up; against the sky's own lightest (skyBackdrop) it clears AA. - expect((luminance(aqua) + 0.05) / (NIGHT_SKY_LIGHTEST + 0.05)).toBeGreaterThanOrEqual(AA); }); it('leaves a colour that already clears its patch untouched, and a non-colour alone', () => { diff --git a/src/app/features/scene/skyInk.ts b/src/app/features/scene/skyInk.ts index 1d0e1448..e1de9063 100644 --- a/src/app/features/scene/skyInk.ts +++ b/src/app/features/scene/skyInk.ts @@ -8,8 +8,8 @@ // until it clears 4.5:1 (WCAG) against the LIGHTEST 24x12 patch of terrain under the timeline in that state // and viewport. Measured 2026-11-10 on the demo's terrain scene at 1920x1080 and 390x844 (Chrome, SwiftShader, // not a GPU; ratatoskr-sidebar-contrast-20261110/results.md, T3). These are the scene's own patches, not -// `skyBackdrop` (skyState.ts): that is the bare sky's extreme (day 0.90, dusk 0.97), which the terrain under the -// timeline never shows, and at night the terrain's snow (0.103, phone 0.149) is lighter than the sky (0.0816). +// the bare sky: the terrain under the timeline is what the ink sits on, and at night its snow (0.103, phone 0.149) is +// lighter than the sky was when these were measured (0.0816). // Only a person whose theme is the sky's (no explicit theme of their own, sceneThemeId) wears this ink. import chroma from 'chroma-js'; import { AA, luminance } from '../../../sky/skyTokens.js'; diff --git a/src/app/features/scene/skyState.test.ts b/src/app/features/scene/skyState.test.ts index f25ae445..a1585f42 100644 --- a/src/app/features/scene/skyState.test.ts +++ b/src/app/features/scene/skyState.test.ts @@ -1,13 +1,8 @@ import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'; import { atStandardTime } from './standardTime.testkit'; -import { baked } from '../../../sky/baked'; -import { luminance } from '../../../sky/skyTokens.js'; import { - SKY_STATES, SKY_STATE_KEY, resolveSkyState, - setSkyClock, - skyBackdrop, type SkyState, } from './skyState'; @@ -106,39 +101,6 @@ describe('sky state', () => { }); }); -describe('skyBackdrop', () => { - it('puts night below day and dusk', () => { - expect(skyBackdrop('night').lightest).toBeLessThan(skyBackdrop('day').darkest); - expect(skyBackdrop('night').lightest).toBeLessThan(skyBackdrop('dusk').lightest); - expect(skyBackdrop('dusk').lightest).toBeGreaterThanOrEqual(skyBackdrop('day').lightest); - }); - - it('holds the baked gradients for day and night', () => { - const lum = (g: readonly string[]) => g.map(luminance); - expect(skyBackdrop('day').lightest).toBeGreaterThanOrEqual( - Math.max(...lum(baked.noonday.gradient)) - 1e-9 - ); - expect(skyBackdrop('night').darkest).toBeLessThanOrEqual( - Math.min(...lum(baked.midnight.gradient)) + 1e-9 - ); - }); - - it('is the band of the sky auto resolves to, not the union of all three', () => { - const at = (h: number) => setSkyClock(() => atStandardTime(h, 0)); - at(12); - expect(skyBackdrop('auto')).toEqual(skyBackdrop('day')); - at(0); - expect(skyBackdrop('auto')).toEqual(skyBackdrop('night')); - setSkyClock(); - }); - - it('never has darkest above lightest', () => { - SKY_STATES.forEach((s) => - expect(skyBackdrop(s).darkest).toBeLessThanOrEqual(skyBackdrop(s).lightest) - ); - }); -}); - describe('auto follows the clock', () => { const local = (h: number, m = 0) => atStandardTime(h, m); // local solar time ~ local clock let storage: ReturnType; diff --git a/src/app/features/scene/skyState.ts b/src/app/features/scene/skyState.ts index 111fdf60..1d93b07e 100644 --- a/src/app/features/scene/skyState.ts +++ b/src/app/features/scene/skyState.ts @@ -1,8 +1,7 @@ // Which sky the signed-out page is drawn against. The choice is one value, kept in one -// localStorage key; whoever draws the sky (the scene, the title bar's control) reads it here, and -// `skyBackdrop` says how light or dark the sky behind the login text can be in each state, so the -// text colours can be checked against it. 'auto' is a choice, not a sky: it resolves from the -// clock to day, dusk or night (`resolveSkyState`), and every sky drawn is one of those three. +// localStorage key; whoever draws the sky (the scene, the title bar's control) reads it here. +// 'auto' is a choice, not a sky: it resolves from the clock to day, dusk or night +// (`resolveSkyState`), and every sky drawn is one of those three. import { sunElevation } from '../../../sky/sun.js'; export type SkyState = 'auto' | 'day' | 'dusk' | 'night'; @@ -153,25 +152,3 @@ export function subscribe(cb: (s: FixedSkyState) => void): () => void { sync(); }; } - -/** - * Relative luminance (WCAG, 0..1) of the lightest and darkest sky the state can show behind the - * page. Light ink is worst against `lightest`, dark ink against `darkest`. 'auto' is the band of - * the sky it resolves to now. - */ -export interface SkyBackdrop { - readonly darkest: number; - readonly lightest: number; -} - -// What the ridge sky can show behind the page in each state (its display budget, ridge/toneMap.ts `BUDGET`, holds whatever the -// sun's elevation; physicalSky.test.ts sweeps the sun's year against these). Held as constants so this module, which the main chunk -// loads, does not pull in the sky generator. The bounds are at least as wide as the budgets: the login text was checked against them. -// Bounds what the 8-bit screen shows too (one step each way for rounding and dither), rounded outward to six places. -const BACKDROPS: Record = { - day: { darkest: 0.461063, lightest: 1 }, - dusk: { darkest: 0.460352, lightest: 1 }, - night: { darkest: 0, lightest: 0.081642 }, -}; - -export const skyBackdrop = (state: SkyState): SkyBackdrop => BACKDROPS[resolveSkyState(state)]; diff --git a/src/app/features/scene/skyTheme.test.ts b/src/app/features/scene/skyTheme.test.ts index 2bf19044..ec53dc17 100644 --- a/src/app/features/scene/skyTheme.test.ts +++ b/src/app/features/scene/skyTheme.test.ts @@ -1,7 +1,7 @@ import { describe, expect, it, vi } from 'vitest'; import { atStandardTime } from './standardTime.testkit'; import { baked } from '../../../sky/baked'; -import { AA, NIGHT_SKY_LIGHTEST, contrast, luminance } from '../../../sky/skyTokens.js'; +import { AA, contrast } from '../../../sky/skyTokens.js'; import { Editor } from '../../components/editor/Editor.css'; import { PageContent, PageNavContent } from '../../components/page/style.css'; import { CallStatus } from '../call-status/styles.css'; @@ -12,30 +12,17 @@ import { SkyPlate, plateRegions } from './skyPlate.css'; import { getResolvedSkyState, setSkyClock, - skyBackdrop, subscribe as subscribeSky, } from './skyState'; -import type { FixedSkyState, SkyBackdrop } from './skyState'; import { sceneThemeId, skyThemeId } from './skyTheme'; const SKY = { 'midnight-sky': baked.midnight, 'noonday-sky': baked.noonday } as const; +const r2 = (n: number) => n.toFixed(2); const fixed = (['day', 'dusk', 'night'] as const).flatMap((s) => { const id = skyThemeId(s); return id ? [[s, id] as const] : []; }); -// WCAG contrast of an ink against the sky it is worst on, measured as skyState.test.ts does: the -// sky can show any luminance between its darkest and lightest, and contrast is lowest where the -// backdrop is closest to the ink, which is the ink's own luminance clamped into that range. -const against = (ink: string, bg: number) => { - const li = luminance(ink); - const [hi, lo] = li > bg ? [li, bg] : [bg, li]; - return (hi + 0.05) / (lo + 0.05); -}; -const ratio = (ink: string, b: SkyBackdrop) => - against(ink, Math.min(b.lightest, Math.max(b.darkest, luminance(ink)))); -const r2 = (n: number) => n.toFixed(2); - describe('skyThemeId', () => { it('picks a theme for each explicit state', () => { expect(skyThemeId('day')).toBe('noonday-sky'); @@ -102,61 +89,6 @@ describe('skyThemeId', () => { }); }); -describe('ink of the theme a state picks, on bare sky', () => { - // Per state: the picked theme, its text ink and link, and their WCAG ratios on the sky the scenes - // draw (skyBackdrop, the worst case over its band). Text clears 4.5 in every state. Link clears - // in every state: the links are derived in src/sky/skyTokens.js, outside the band, and these numbers are recorded as - // they are measured. Midnight's link is brightened in its own hue until it clears the lightest Night sky - // (NIGHT_SKY_LIGHTEST); Dusk's dark link needs a backdrop of about 0.4554, which the dusk floor is set above. - // 'auto' resolves from the clock to one of these three and has the same numbers. - const cells: [FixedSkyState, string, string, string, string, string][] = [ - ['day', 'noonday-sky', '#342d25', '6.60', '#2a4f27', '4.55'], - ['dusk', 'noonday-sky', '#342d25', '6.59', '#2a4f27', '4.54'], - ['night', 'midnight-sky', '#aeccff', '4.89', '#8ad1bd', '4.53'], - ]; - - it.each(cells)( - '%s with %s: text %s is %s, link %s is %s', - (state, id, ink, want, link, wantLink) => { - const sky = SKY[id as keyof typeof SKY]; - expect(sky.tokens.Background.OnContainer).toBe(ink); - expect(sky.link).toBe(link); - expect(r2(ratio(ink, skyBackdrop(state)))).toBe(want); - expect(r2(ratio(link, skyBackdrop(state)))).toBe(wantLink); - } - ); - - it.each(cells)('%s: text clears AA', (state, _id, ink) => { - expect(ratio(ink, skyBackdrop(state))).toBeGreaterThanOrEqual(AA); - }); - - it('link clears AA in every state', () => { - const link = (s: FixedSkyState, id: keyof typeof SKY) => ratio(SKY[id].link, skyBackdrop(s)); - expect(link('day', 'noonday-sky')).toBeGreaterThanOrEqual(AA); - expect(link('dusk', 'noonday-sky')).toBeGreaterThanOrEqual(AA); - expect(link('night', 'midnight-sky')).toBeGreaterThanOrEqual(AA); - }); - - it('keeps the lightest Night sky the link was fitted to equal to the Night backdrop (no drift)', () => { - expect(NIGHT_SKY_LIGHTEST).toBe(skyBackdrop('night').lightest); - }); - - it.each([ - [12, 'day'], - [18, 'dusk'], - [0, 'night'], - ] as const)('auto at %s:00 has the numbers of %s', (hour, state) => { - setSkyClock(() => atStandardTime(hour, hour === 18 ? 10 : 0)); - const id = skyThemeId(getResolvedSkyState()) as keyof typeof SKY; - expect(id).toBe(skyThemeId(state)); - const { tokens, link } = SKY[id]; - const text = tokens.Background.OnContainer; - expect(r2(ratio(text, skyBackdrop('auto')))).toBe(r2(ratio(text, skyBackdrop(state)))); - expect(r2(ratio(link, skyBackdrop('auto')))).toBe(r2(ratio(link, skyBackdrop(state)))); - setSkyClock(); - }); -}); - describe('the plate, where text cannot rest on bare sky', () => { // Each theme's plate: fill, ink, link and the WCAG ratios of ink and link on the fill. const plates = [ @@ -217,7 +149,7 @@ describe('regions that sit on the plate', () => { describe('the sign-in footer band', () => { // The footer line is the plate's ink on a band that mixes FOOTER_TINT of the plate's fill over the blurred scene, // as the browser does: per channel, in encoded sRGB (not in linear light, which flatters dark scenes). The scene - // behind it is the scene, taken as grey: as dark as 0, as light as the sky state's lightest backdrop. Ink + // behind it is the scene, taken as grey: as dark as 0 or as light as 1 (a sky's range is whatever the look draws). Ink // contrast is lowest at one of those two ends, so both are checked. const encode = (l: number) => (l <= 0.0031308 ? 12.92 * l : 1.055 * l ** (1 / 2.4) - 0.055); const channels = (hex: string) => [1, 3, 5].map((i) => parseInt(hex.slice(i, i + 2), 16) / 255); @@ -235,7 +167,7 @@ describe('the sign-in footer band', () => { '%s: the ink clears AA over the darkest and the lightest scene behind it', (state, id) => { const { Other, OtherText } = SKY[id].bubbles; - [0, skyBackdrop(state).lightest].forEach((behind) => { + [0, 1].forEach((behind) => { expect(contrast(OtherText, bandOver(Other, behind))).toBeGreaterThanOrEqual(AA); }); } diff --git a/src/sky/skyTokens.js b/src/sky/skyTokens.js index 5152a4fb..13911a47 100644 --- a/src/sky/skyTokens.js +++ b/src/sky/skyTokens.js @@ -19,8 +19,8 @@ const luma = (c) => 0.2126 * c[0] + 0.7152 * c[1] + 0.0722 * c[2]; export const GRADIENT_STOPS = 7; export const AA = 4.5; // WCAG 2.x AA, normal text -// The lightest the Night sky draws behind the page (src/app/features/scene/skyState.ts, `skyBackdrop('night')`; a test in -// skyTheme.test.ts fails if the two drift). Midnight Sky's link also sits on bare sky, so it must clear AA against this. +// The Night sky's luminance the Midnight Sky link was fitted against (a derivation input, not a bound the scene is held to: +// the look is tuned by eye). The link is brightened in its own hue until it clears AA against this. export const NIGHT_SKY_LIGHTEST = 0.081642; // Where and when the theme is lit. Equinox, 45N on the prime meridian: noon sun at 45 degrees. From d84a31ce7916e7980b81899d2d6fa52d2b65629c Mon Sep 17 00:00:00 2001 From: Meta Vens Date: Fri, 20 Nov 2026 21:50:36 +0100 Subject: [PATCH 20/24] Delete the unused MARGIN constant Co-Authored-By: Claude Sonnet 5.5 --- src/app/features/scene/ridge/toneMap.ts | 1 - 1 file changed, 1 deletion(-) diff --git a/src/app/features/scene/ridge/toneMap.ts b/src/app/features/scene/ridge/toneMap.ts index 2ba47850..0a41bb07 100644 --- a/src/app/features/scene/ridge/toneMap.ts +++ b/src/app/features/scene/ridge/toneMap.ts @@ -121,7 +121,6 @@ export interface Budget { /** The most the curve may steepen the sky's own spread about its median (display luminance per unit of ACES output): a nearly flat overcast sky is not blown up into a gradient. */ maxGain: number; } -export const MARGIN = 0.004; /** The one absolute lift of day and dusk: what black is drawn as, display-linear. The rest of the range is made by the curve. */ export const BLACK_LIFT = 0.02; From 248839974b45305db8dde5672a59b3fef39c8853 Mon Sep 17 00:00:00 2001 From: Meta Vens Date: Fri, 20 Nov 2026 21:56:14 +0100 Subject: [PATCH 21/24] Idunn recipe: pin dist f562f8fa (release a6: painterly cel-3 look, real night sky, more sky in the frame) Co-Authored-By: Claude Opus 5.5 --- deployment/idunn/recipe.toml | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/deployment/idunn/recipe.toml b/deployment/idunn/recipe.toml index 5d163432..0995fa03 100644 --- a/deployment/idunn/recipe.toml +++ b/deployment/idunn/recipe.toml @@ -6,14 +6,14 @@ target = "ratatoskr" # tarball was built from, which is not this commit. source_stamp_environment = "RATATOSKR_BUILD_COMMIT" -# Release dist a1fdfee3cc1ad370d09761bc337e5aff7e069de3: the output of build-prod-dist.sh (ALLOW_CONFIG_DRIFT=1), packed +# Release dist f562f8fae9a294e04354801538ed7a595133f480: the output of build-prod-dist.sh (live config check passed), packed # as dist/ at the top of one gzip tar. The tree carries the repo's own config.json; what is served is the operator's # carried file, which Idunn copies beside dist/ and the vhost aliases over the tree's (a vhost without that alias would # serve the repo config). [[external_inputs]] id = "dist-tarball" -url = "https://eureka.gamecult.org/forge/GameCult/Ratatoskr/releases/download/dist-a1fdfee3/ratatoskr-a1fdfee3-dist.tar.gz" -sha256 = "22e4c24c328d33e9c9a5c560646b59e0b91f028b54ffb631d8d42872be7ff938" +url = "https://eureka.gamecult.org/forge/GameCult/Ratatoskr/releases/download/dist-f562f8fa/ratatoskr-f562f8fa-dist.tar.gz" +sha256 = "ec4f4fc3e64dfeb7ba6509b386d2a5efc318211f66de663c061e1240b1f610f0" runner = "unpack" destination = "release/dist.tar.gz" From e4ae831b5abd5f7113fbdd760b0f0ae92cffd9c6 Mon Sep 17 00:00:00 2001 From: Meta Vens Date: Fri, 20 Nov 2026 23:00:30 +0100 Subject: [PATCH 22/24] The drawn sky alone decides theme and ink while a scene is on sceneThemeId is a function of the resolved sky and sceneOn; the person's theme stands only where no sky is drawn. Deletes userChoseTheme, chosenTheme, themeChosen and skyThemeId (ratatoskr:ruling:ink-follows-drawn-sky). Co-Authored-By: Claude Sonnet 5.5 --- src/app/features/scene/skyInk.test.ts | 23 ++----- src/app/features/scene/skyInk.ts | 6 +- src/app/features/scene/skyTheme.test.ts | 61 ++++++------------- src/app/features/scene/skyTheme.ts | 39 +++--------- src/app/features/settings/general/General.tsx | 2 - src/app/hooks/useTheme.test.ts | 40 ------------ src/app/hooks/useTheme.ts | 29 +++------ src/app/state/settings.ts | 1 - 8 files changed, 42 insertions(+), 159 deletions(-) delete mode 100644 src/app/hooks/useTheme.test.ts diff --git a/src/app/features/scene/skyInk.test.ts b/src/app/features/scene/skyInk.test.ts index 25708204..616569f9 100644 --- a/src/app/features/scene/skyInk.test.ts +++ b/src/app/features/scene/skyInk.test.ts @@ -136,29 +136,18 @@ describe('userColorInk', () => { }); }); -describe('sceneInk: an explicit theme wins over the auto ink', () => { - it('is the sky state and viewport only while the sky theme is worn and a scene runs', () => { - // auto, scene on, no theme of the person's own: the sky theme is worn. - expect(sceneInk(sceneThemeId('auto', 'dusk', true, false), true, 'dusk', true)).toEqual({ +describe('sceneInk: the drawn sky decides the ink', () => { + it('is the sky state and viewport while a scene runs, and nothing without one', () => { + expect(sceneInk(sceneThemeId('dusk', true), true, 'dusk', true)).toEqual({ state: 'dusk', phone: true, }); - // auto, but the person chose a theme: it wins, the theme's own ink stands. - expect(sceneInk(sceneThemeId('auto', 'dusk', true, true), true, 'dusk', true)).toBeUndefined(); - // a fixed sky state does not override the person's theme either: the theme's own ink stands. - expect( - sceneInk(sceneThemeId('night', 'night', true, true), true, 'night', false) - ).toBeUndefined(); - // a fixed sky state with no theme of the person's own: the sky theme's ink applies. - expect(sceneInk(sceneThemeId('night', 'night', true, false), true, 'night', false)).toEqual({ + expect(sceneInk(sceneThemeId('night', true), true, 'night', false)).toEqual({ state: 'night', phone: false, }); - // no scene behind the page: nothing for the ink to be measured against. - expect( - sceneInk(sceneThemeId('auto', 'day', false, false), false, 'day', false) - ).toBeUndefined(); - expect(sceneInk(sceneThemeId('day', 'day', true, false), false, 'day', false)).toBeUndefined(); + // no scene behind the page: the person's theme and its ink stand. + expect(sceneInk(sceneThemeId('day', false), false, 'day', false)).toBeUndefined(); }); }); diff --git a/src/app/features/scene/skyInk.ts b/src/app/features/scene/skyInk.ts index e1de9063..d12d558b 100644 --- a/src/app/features/scene/skyInk.ts +++ b/src/app/features/scene/skyInk.ts @@ -10,7 +10,7 @@ // not a GPU; ratatoskr-sidebar-contrast-20261110/results.md, T3). These are the scene's own patches, not // the bare sky: the terrain under the timeline is what the ink sits on, and at night its snow (0.103, phone 0.149) is // lighter than the sky was when these were measured (0.0816). -// Only a person whose theme is the sky's (no explicit theme of their own, sceneThemeId) wears this ink. +// The page wears this ink whenever the drawn sky decides its theme (a scene is on, sceneThemeId). import chroma from 'chroma-js'; import { AA, luminance } from '../../../sky/skyTokens.js'; import { baked } from '../../../sky/baked'; @@ -25,8 +25,8 @@ export interface SkyInk { } /** - * The ink in force: only while the page wears the sky's theme (`themeId`, from sceneThemeId, so a person's explicit - * theme, which that function lets win over 'auto', keeps its own ink) and a scene runs behind it. Otherwise undefined. + * The ink in force: only while the page wears the sky's theme (`themeId`, from sceneThemeId, defined only while a + * scene is on) and a scene runs behind it. With no scene the person's theme and its own ink stand: undefined. */ export const sceneInk = ( themeId: SkyThemeId | undefined, diff --git a/src/app/features/scene/skyTheme.test.ts b/src/app/features/scene/skyTheme.test.ts index ec53dc17..c78f3928 100644 --- a/src/app/features/scene/skyTheme.test.ts +++ b/src/app/features/scene/skyTheme.test.ts @@ -14,53 +14,36 @@ import { setSkyClock, subscribe as subscribeSky, } from './skyState'; -import { sceneThemeId, skyThemeId } from './skyTheme'; +import { sceneThemeId } from './skyTheme'; const SKY = { 'midnight-sky': baked.midnight, 'noonday-sky': baked.noonday } as const; const r2 = (n: number) => n.toFixed(2); -const fixed = (['day', 'dusk', 'night'] as const).flatMap((s) => { - const id = skyThemeId(s); - return id ? [[s, id] as const] : []; +const fixed = (['day', 'dusk', 'night'] as const).flatMap((st) => { + const id = sceneThemeId(st, true); + return id ? [[st, id] as const] : []; }); -describe('skyThemeId', () => { - it('picks a theme for each explicit state', () => { - expect(skyThemeId('day')).toBe('noonday-sky'); - expect(skyThemeId('dusk')).toBe('noonday-sky'); - expect(skyThemeId('night')).toBe('midnight-sky'); +describe('sceneThemeId, the theme the page wears', () => { + it('with a scene on, the drawn sky gives its theme, whatever theme a person stored', () => { + expect(sceneThemeId('day', true)).toBe('noonday-sky'); + expect(sceneThemeId('dusk', true)).toBe('noonday-sky'); + expect(sceneThemeId('night', true)).toBe('midnight-sky'); }); - it('picks none for auto, at any hour: auto never overrides a signed-in theme', () => { - [0, 6, 12, 18, 23].forEach((h) => { + it('auto draws the clock sky and that sky decides', () => { + [0, 12, 23].forEach((h) => { setSkyClock(() => atStandardTime(h, 10)); - expect(skyThemeId('auto')).toBeUndefined(); + expect(sceneThemeId(getResolvedSkyState(), true)).toBe( + h === 12 ? 'noonday-sky' : 'midnight-sky' + ); }); setSkyClock(); }); - describe('sceneThemeId, the theme the page wears', () => { - it('a fixed state picks its theme, whatever the scene, while the person chose no theme', () => { - [true, false].forEach((scene) => { - expect(sceneThemeId('day', 'night', scene, false)).toBe('noonday-sky'); - expect(sceneThemeId('night', 'day', scene, false)).toBe('midnight-sky'); - }); - }); - - it('a theme the person chose wins over every sky state, fixed or auto', () => { - (['auto', 'day', 'dusk', 'night'] as const).forEach((state) => - [true, false].forEach((scene) => - expect(sceneThemeId(state, 'night', scene, true)).toBeUndefined() - ) - ); - }); - - it('auto follows the resolved sky only while a scene is on and the person chose no theme', () => { - expect(sceneThemeId('auto', 'day', true, false)).toBe('noonday-sky'); - expect(sceneThemeId('auto', 'dusk', true, false)).toBe('noonday-sky'); - expect(sceneThemeId('auto', 'night', true, false)).toBe('midnight-sky'); - expect(sceneThemeId('auto', 'day', false, false)).toBeUndefined(); - expect(sceneThemeId('auto', 'day', true, true)).toBeUndefined(); - }); + it('with the scene off no sky is drawn, so the person theme stands', () => { + (['day', 'dusk', 'night'] as const).forEach((st) => + expect(sceneThemeId(st, false)).toBeUndefined() + ); }); it('the resolved sky a hook subscribes to changes as the clock crosses, so theme classes follow', () => { @@ -79,14 +62,6 @@ describe('skyThemeId', () => { vi.useRealTimers(); setSkyClock(); }); - - it('is what a wiring that follows the sky reads: the resolved state names a theme', () => { - setSkyClock(() => atStandardTime(12)); - expect(skyThemeId(getResolvedSkyState())).toBe('noonday-sky'); - setSkyClock(() => atStandardTime(0)); - expect(skyThemeId(getResolvedSkyState())).toBe('midnight-sky'); - setSkyClock(); - }); }); describe('the plate, where text cannot rest on bare sky', () => { diff --git a/src/app/features/scene/skyTheme.ts b/src/app/features/scene/skyTheme.ts index ee1cba40..fef313ec 100644 --- a/src/app/features/scene/skyTheme.ts +++ b/src/app/features/scene/skyTheme.ts @@ -1,16 +1,8 @@ -// Which theme a sky state lights the page with. 'auto' picks none: it never overrides a person's theme -// (the stored one when signed in, Midnight Sky when signed out). A wiring that follows the sky when no theme -// is stored reads `getResolvedSkyState` (skyState.ts) and passes that fixed state here. -// -// Day and Dusk take the dark ink of Noonday Sky, Night the light ink of Midnight Sky. Each state's -// drawn sky is held to a luminance budget (ridge/toneMap.ts, bands in skyState.ts `FixedSkyState`) in which that ink's TEXT clears 4.5:1 on -// bare sky: Day at least 0.2983 (dark ink), Night at most 0.0931 (light ink). Dusk's floor is higher, the bound of -// the dark link (0.4554), so its link clears as well. skyTheme.test.ts pins the measured text and link ratios. Night's -// link ink is not in the band, and the themes' link colours are derived outside this code (src/sky/skyTokens.js). -// Midnight Sky's link is derived there against the lightest Night sky -// (4.53 on it, 5.43 on the darkest). The plate (skyPlate.css.ts) is still in the shell, pending -// its removal. -import type { FixedSkyState, SkyState } from './skyState'; +// Which theme the drawn sky lights the page with. While a scene is on, the sky being drawn (the fixed pick, or the +// clock's state under 'auto'; `useResolvedSkyState`) alone decides the theme and, with it, the ink: Day and Dusk +// wear Noonday Sky, Night wears Midnight Sky. A person's own theme (the theme menu) stands only where no sky is +// drawn, that is with the scene off. +import type { FixedSkyState } from './skyState'; export type SkyThemeId = 'midnight-sky' | 'noonday-sky'; @@ -20,21 +12,6 @@ const BY_STATE: Record = { night: 'midnight-sky', }; -export const skyThemeId = (state: SkyState): SkyThemeId | undefined => - state === 'auto' ? undefined : BY_STATE[state]; - -/** - * The theme the page wears: a theme the person chose always wins, and picks none here. Otherwise a fixed sky state - * picks its theme, and 'auto' follows the resolved sky (`resolved`, the clock's state) only while a scene is on. - * Signed-out pages choose no theme, so they pass `userChoseTheme: false`. - */ -export const sceneThemeId = ( - state: SkyState, - resolved: FixedSkyState, - sceneOn: boolean, - userChoseTheme: boolean -): SkyThemeId | undefined => { - if (userChoseTheme) return undefined; - if (state !== 'auto') return BY_STATE[state]; - return sceneOn ? BY_STATE[resolved] : undefined; -}; +/** The theme the page wears: the drawn sky's while a scene is on, otherwise none (the person's theme stands). */ +export const sceneThemeId = (resolved: FixedSkyState, sceneOn: boolean): SkyThemeId | undefined => + sceneOn ? BY_STATE[resolved] : undefined; diff --git a/src/app/features/settings/general/General.tsx b/src/app/features/settings/general/General.tsx index e0835eff..90d2da3a 100644 --- a/src/app/features/settings/general/General.tsx +++ b/src/app/features/settings/general/General.tsx @@ -82,7 +82,6 @@ function SelectTheme({ disabled }: { disabled?: boolean }) { const themes = useThemes(); const themeNames = useThemeNames(); const [themeId, setThemeId] = useSetting(settingsAtom, 'themeId'); - const [, setThemeChosen] = useSetting(settingsAtom, 'themeChosen'); const [menuCords, setMenuCords] = useState(); const selectedTheme = themes.find((theme) => theme.id === themeId) ?? LightTheme; @@ -92,7 +91,6 @@ function SelectTheme({ disabled }: { disabled?: boolean }) { const handleThemeSelect = (theme: Theme) => { setThemeId(theme.id); - setThemeChosen(true); setMenuCords(undefined); }; diff --git a/src/app/hooks/useTheme.test.ts b/src/app/hooks/useTheme.test.ts deleted file mode 100644 index dcb96e49..00000000 --- a/src/app/hooks/useTheme.test.ts +++ /dev/null @@ -1,40 +0,0 @@ -import { readFileSync } from 'fs'; -import { beforeAll, describe, expect, it, vi } from 'vitest'; - -// settings.ts reads localStorage when it loads, and this suite runs without a DOM. -vi.stubGlobal('localStorage', { getItem: () => null, setItem: () => undefined }); -let chosenTheme: typeof import('./useTheme').chosenTheme; -let defaultThemeId: string; -beforeAll(async () => { - ({ chosenTheme } = await import('./useTheme')); - ({ defaultThemeId } = await import('../state/settings')); -}); - -describe('chosenTheme: what counts as a theme the person chose', () => { - it('is not a theme before anything was picked: no id saved, or the default saved', () => { - expect(chosenTheme(false, undefined, undefined)).toBe(false); - expect(chosenTheme(false, defaultThemeId, undefined)).toBe(false); - expect(chosenTheme(false, defaultThemeId, false)).toBe(false); - }); - - it('is a pick of Midnight Sky made in the theme menu, which sets the flag', () => { - expect(chosenTheme(false, defaultThemeId, true)).toBe(true); - }); - - it('is a saved id other than the default, with or without the flag', () => { - expect(chosenTheme(false, 'dark-theme', undefined)).toBe(true); - expect(chosenTheme(false, 'noonday-sky', true)).toBe(true); - }); - - it('is the system scheme', () => { - expect(chosenTheme(true, defaultThemeId, undefined)).toBe(true); - }); - - it('the theme menu sets the flag together with the id', () => { - const tsx = readFileSync( - `${process.cwd()}/src/app/features/settings/general/General.tsx`, - 'utf8' - ); - expect(tsx).toMatch(/setThemeId\(theme\.id\);\s*setThemeChosen\(true\);/); - }); -}); diff --git a/src/app/hooks/useTheme.ts b/src/app/hooks/useTheme.ts index 730b12d4..69afc382 100644 --- a/src/app/hooks/useTheme.ts +++ b/src/app/hooks/useTheme.ts @@ -10,11 +10,11 @@ import { } from '../../colors.css'; import '../../gamecult.css'; import '../../sky.css'; -import { defaultThemeId, settingsAtom } from '../state/settings'; +import { settingsAtom } from '../state/settings'; import { useSetting } from '../state/hooks/settings'; import { sceneThemeId } from '../features/scene/skyTheme'; import { sceneInk, type SkyInk } from '../features/scene/skyInk'; -import { useResolvedSkyState, useSceneOn, useSkyState } from './useSkyState'; +import { useResolvedSkyState, useSceneOn } from './useSkyState'; import { ScreenSize, useScreenSizeContext } from './useScreenSize'; export enum ThemeKind { @@ -107,28 +107,13 @@ export const useSystemThemeKind = (): ThemeKind => { const toTheme = (id: ReturnType): Theme | undefined => id === NoondaySkyTheme.id ? NoondaySkyTheme : id && MidnightSkyTheme; -/** - * A theme the person chose: the system scheme, any pick made in the theme menu (`themeChosen`, which also covers - * Midnight Sky, the default), or a saved id other than the default (picks from before the flag existed). - */ -export const chosenTheme = (useSystemTheme: boolean, themeId?: string, themeChosen?: boolean) => - useSystemTheme || themeChosen === true || (themeId !== undefined && themeId !== defaultThemeId); - -/** The theme the sky asks for on a page with no theme of its own (signed out), or undefined for none. */ +/** The theme the drawn sky asks for while a scene is on, or undefined for none (signed-out pages then wear Midnight Sky). */ export const useSkyTheme = (): Theme | undefined => - toTheme(sceneThemeId(useSkyState(), useResolvedSkyState(), useSceneOn(), false)); + toTheme(sceneThemeId(useResolvedSkyState(), useSceneOn())); -/** The sky theme the signed-in page wears, or undefined when the person's own theme wins. */ -const useSceneSkyThemeId = (): ReturnType => { - const sky = useSkyState(); - const resolved = useResolvedSkyState(); - const sceneOn = useSceneOn(); - const [systemTheme] = useSetting(settingsAtom, 'useSystemTheme'); - const [themeId] = useSetting(settingsAtom, 'themeId'); - const [themeChosen] = useSetting(settingsAtom, 'themeChosen'); - // A person's own theme wins over the sky, fixed or 'auto'. - return sceneThemeId(sky, resolved, sceneOn, chosenTheme(systemTheme, themeId, themeChosen)); -}; +/** The sky theme the page wears while a scene is on, or undefined when the person's own theme stands. */ +const useSceneSkyThemeId = (): ReturnType => + sceneThemeId(useResolvedSkyState(), useSceneOn()); /** The ink the page wears over the scene (`sceneInk`, skyInk.ts), or undefined when the theme's own ink stands. */ export const useSceneInk = (): SkyInk | undefined => { diff --git a/src/app/state/settings.ts b/src/app/state/settings.ts index 21c449af..e5737196 100644 --- a/src/app/state/settings.ts +++ b/src/app/state/settings.ts @@ -19,7 +19,6 @@ export enum MessageLayout { export interface Settings { themeId?: string; /** Set when a theme is picked in the menu, so a picked default (Midnight Sky) reads as chosen. Absent until then. */ - themeChosen?: boolean; useSystemTheme: boolean; lightThemeId?: string; darkThemeId?: string; From 856743978637f3dd70612b33a800e57b88b3050e Mon Sep 17 00:00:00 2001 From: Meta Vens Date: Fri, 20 Nov 2026 23:08:32 +0100 Subject: [PATCH 23/24] useSceneOn reads whether a scene is drawn, not whether one is configured sceneDrawn.ts owns the flag and html[data-scene] together; BackgroundScene publishes through it (start, stop, context loss and restore). A failed or lost scene leaves the person's stored theme in force. Co-Authored-By: Claude Sonnet 5.5 --- src/app/features/scene/BackgroundScene.tsx | 11 +-- src/app/features/scene/sceneDrawn.test.ts | 37 +++++++++ src/app/features/scene/sceneDrawn.ts | 29 +++++++ src/app/hooks/useSkyState.ts | 8 +- src/app/hooks/useTheme.test.ts | 88 ++++++++++++++++++++++ src/app/state/settings.test.ts | 14 ++++ src/app/state/settings.ts | 1 - 7 files changed, 175 insertions(+), 13 deletions(-) create mode 100644 src/app/features/scene/sceneDrawn.test.ts create mode 100644 src/app/features/scene/sceneDrawn.ts create mode 100644 src/app/hooks/useTheme.test.ts create mode 100644 src/app/state/settings.test.ts diff --git a/src/app/features/scene/BackgroundScene.tsx b/src/app/features/scene/BackgroundScene.tsx index ff1045dd..23f50f04 100644 --- a/src/app/features/scene/BackgroundScene.tsx +++ b/src/app/features/scene/BackgroundScene.tsx @@ -2,13 +2,11 @@ import React, { useEffect, useRef } from 'react'; import { useClientConfig } from '../../hooks/useClientConfig'; import { getFallbackSession } from '../../state/sessions'; import { mountBackgroundScene } from './host'; +import { setSceneDrawn } from './sceneDrawn'; import { readCapabilities, resolveTier } from './tier'; import './sceneShell.css'; import './sceneButtons.css'; -/** Set on while a scene runs, so signed-out screens can let it show through. */ -export const SCENE_ACTIVE_ATTRIBUTE = 'data-scene'; - /** * The one host for the background scene, mounted once at the app root. Fixed behind everything * (z-index -1 sits above the body's background and below all normal content; the signed-out @@ -24,17 +22,16 @@ export function BackgroundScene() { useEffect(() => { const canvas = canvasRef.current; if (!enabled || !canvas) return undefined; - const root = document.documentElement; const dispose = mountBackgroundScene(config, readCapabilities(navigator), canvas, { loggedIn: !!getFallbackSession(), - onActive: () => root.setAttribute(SCENE_ACTIVE_ATTRIBUTE, ''), - onInactive: () => root.removeAttribute(SCENE_ACTIVE_ATTRIBUTE), + onActive: () => setSceneDrawn(true), + onInactive: () => setSceneDrawn(false), // eslint-disable-next-line no-console onFail: (e) => console.warn('Background scene unavailable:', e), }); return () => { dispose(); - root.removeAttribute(SCENE_ACTIVE_ATTRIBUTE); + setSceneDrawn(false); }; }, [config, enabled]); diff --git a/src/app/features/scene/sceneDrawn.test.ts b/src/app/features/scene/sceneDrawn.test.ts new file mode 100644 index 00000000..5e51f7ce --- /dev/null +++ b/src/app/features/scene/sceneDrawn.test.ts @@ -0,0 +1,37 @@ +import { afterEach, describe, expect, it, vi } from 'vitest'; +import { + SCENE_ACTIVE_ATTRIBUTE, + getSceneDrawn, + setSceneDrawn, + subscribeSceneDrawn, +} from './sceneDrawn'; + +const attrs = new Set(); +vi.stubGlobal('document', { + documentElement: { + setAttribute: (n: string) => attrs.add(n), + removeAttribute: (n: string) => attrs.delete(n), + }, +}); + +afterEach(() => setSceneDrawn(false)); + +describe('sceneDrawn: one store owns the flag and html[data-scene]', () => { + it('starts off, and on/off move the flag, the attribute and the subscribers together', () => { + const cb = vi.fn(); + const off = subscribeSceneDrawn(cb); + expect(getSceneDrawn()).toBe(false); + setSceneDrawn(true); + expect(getSceneDrawn()).toBe(true); + expect(attrs.has(SCENE_ACTIVE_ATTRIBUTE)).toBe(true); + setSceneDrawn(true); + expect(cb).toHaveBeenCalledTimes(1); + setSceneDrawn(false); + expect(getSceneDrawn()).toBe(false); + expect(attrs.has(SCENE_ACTIVE_ATTRIBUTE)).toBe(false); + expect(cb).toHaveBeenCalledTimes(2); + off(); + setSceneDrawn(true); + expect(cb).toHaveBeenCalledTimes(2); + }); +}); diff --git a/src/app/features/scene/sceneDrawn.ts b/src/app/features/scene/sceneDrawn.ts new file mode 100644 index 00000000..ae7e47e0 --- /dev/null +++ b/src/app/features/scene/sceneDrawn.ts @@ -0,0 +1,29 @@ +// Whether a background scene is drawing a sky right now. BackgroundScene is the only writer: it sets this when the +// ridge scene starts, and clears it when the scene stops, fails to start, or loses its WebGL context (a restored +// context sets it again). This store also owns html[data-scene], so the attribute the CSS reads and the flag the theme +// hooks read cannot disagree. The configured tier only says a scene may run; this says one does. + +/** Set on while a scene is drawn, so signed-out screens can let it show through. */ +export const SCENE_ACTIVE_ATTRIBUTE = 'data-scene'; + +let drawn = false; +const listeners = new Set<() => void>(); + +export const getSceneDrawn = (): boolean => drawn; + +export const subscribeSceneDrawn = (cb: () => void): (() => void) => { + listeners.add(cb); + return () => { + listeners.delete(cb); + }; +}; + +export function setSceneDrawn(on: boolean): void { + if (typeof document !== 'undefined') { + if (on) document.documentElement.setAttribute(SCENE_ACTIVE_ATTRIBUTE, ''); + else document.documentElement.removeAttribute(SCENE_ACTIVE_ATTRIBUTE); + } + if (on === drawn) return; + drawn = on; + [...listeners].forEach((cb) => cb()); +} diff --git a/src/app/hooks/useSkyState.ts b/src/app/hooks/useSkyState.ts index 9aa390de..02cde126 100644 --- a/src/app/hooks/useSkyState.ts +++ b/src/app/hooks/useSkyState.ts @@ -6,8 +6,7 @@ import { type FixedSkyState, type SkyState, } from '../features/scene/skyState'; -import { readCapabilities, resolveTier } from '../features/scene/tier'; -import { useClientConfig } from './useClientConfig'; +import { getSceneDrawn, subscribeSceneDrawn } from '../features/scene/sceneDrawn'; /** The choice, as the control shows it ('auto' stays 'auto'). The sky being drawn is `useResolvedSkyState`. */ export const useSkyState = (): SkyState => useSyncExternalStore(subscribe, getSkyState); @@ -16,6 +15,5 @@ export const useSkyState = (): SkyState => useSyncExternalStore(subscribe, getSk export const useResolvedSkyState = (): FixedSkyState => useSyncExternalStore(subscribe, getResolvedSkyState); -/** Whether a background scene runs on this device and config (the tier the scene host will mount). */ -export const useSceneOn = (): boolean => - resolveTier(useClientConfig().backgroundScene, readCapabilities(navigator)) !== 'off'; +/** Whether a background scene is drawing a sky right now (not merely configured): false on a failed or lost context. */ +export const useSceneOn = (): boolean => useSyncExternalStore(subscribeSceneDrawn, getSceneDrawn); diff --git a/src/app/hooks/useTheme.test.ts b/src/app/hooks/useTheme.test.ts new file mode 100644 index 00000000..5707e5f1 --- /dev/null +++ b/src/app/hooks/useTheme.test.ts @@ -0,0 +1,88 @@ +import { createElement } from 'react'; +import { renderToString } from 'react-dom/server'; +import { beforeAll, beforeEach, describe, expect, it, vi } from 'vitest'; + +// settings.ts reads localStorage when it loads; these suites run without a DOM. +const store: Record = {}; +vi.stubGlobal('localStorage', { + getItem: (k: string) => store[k] ?? null, + setItem: (k: string, v: string) => { + store[k] = v; + }, +}); +// Stored before settings.ts loads: a theme of the person's, and the themeChosen key old settings carry. +store['settings'] = JSON.stringify({ + themeId: 'dark-theme', + useSystemTheme: false, + themeChosen: true, +}); +vi.stubGlobal('window', { + matchMedia: () => ({ matches: false, addEventListener() {}, removeEventListener() {} }), +}); +// The skyState hooks are useSyncExternalStore reads of these two sources; the server renderer needs a snapshot of +// each, so the hooks read the same stores directly. +vi.mock('./useSkyState', async () => { + const drawn = await import('../features/scene/sceneDrawn'); + return { + useResolvedSkyState: () => 'night', + useSkyState: () => 'night', + useSceneOn: () => drawn.getSceneDrawn(), + }; +}); +// Style modules need a DOM to inject into; the class names are not what is under test. +vi.mock('folds', () => ({ lightTheme: 'light' })); +vi.mock('../../config.css', () => ({ onDarkFontWeight: 'dk', onLightFontWeight: 'lt' })); +vi.mock('../../colors.css', () => ({ + butterTheme: 'b', + darkTheme: 'd', + midnightSkyTheme: 'm', + noondaySkyTheme: 'n', + silverTheme: 's', +})); +vi.mock('../../gamecult.css', () => ({})); +vi.mock('../../sky.css', () => ({})); +vi.mock('./useScreenSize', () => ({ + ScreenSize: { Mobile: 'm' }, + useScreenSizeContext: () => 'd', +})); + +let useActiveTheme: typeof import('./useTheme').useActiveTheme; +let useSceneInk: typeof import('./useTheme').useSceneInk; +let setSceneDrawn: typeof import('../features/scene/sceneDrawn').setSceneDrawn; +beforeAll(async () => { + ({ useActiveTheme, useSceneInk } = await import('./useTheme')); + ({ setSceneDrawn } = await import('../features/scene/sceneDrawn')); +}); + +const read = () => { + let out = ''; + const Probe = () => { + out = `${useActiveTheme().id}|${JSON.stringify(useSceneInk() ?? null)}`; + return null; + }; + renderToString(createElement(Probe)); + return out; +}; + +describe('the drawn sky decides the theme and ink; the stored theme stands where none is drawn', () => { + beforeEach(() => { + setSceneDrawn(false); + }); + + it('a scene running over a stored theme wears the sky theme and ink', () => { + setSceneDrawn(true); + expect(read()).toBe('midnight-sky|{"state":"night","phone":false}'); + }); + + it('a scene that is not drawing (failed, or context lost) leaves the stored theme and its own ink', () => { + expect(read()).toBe('dark-theme|null'); + }); + + it('a restored context wears the sky again', () => { + setSceneDrawn(true); + setSceneDrawn(false); + expect(read()).toBe('dark-theme|null'); + setSceneDrawn(true); + expect(read()).toBe('midnight-sky|{"state":"night","phone":false}'); + }); +}); diff --git a/src/app/state/settings.test.ts b/src/app/state/settings.test.ts new file mode 100644 index 00000000..82e164cd --- /dev/null +++ b/src/app/state/settings.test.ts @@ -0,0 +1,14 @@ +import { describe, expect, it, vi } from 'vitest'; + +const stored = JSON.stringify({ themeId: 'dark-theme', themeChosen: true }); +vi.stubGlobal('localStorage', { getItem: () => stored, setItem: () => undefined }); + +describe('settings load', () => { + it('tolerates a themeChosen key stored by an older build: the rest loads, the key is inert', async () => { + const { getSettings, defaultThemeId } = await import('./settings'); + const s = getSettings() as unknown as Record; + expect(s.themeId).toBe('dark-theme'); + expect(s.useSystemTheme).toBe(false); + expect(defaultThemeId).toBeDefined(); + }); +}); diff --git a/src/app/state/settings.ts b/src/app/state/settings.ts index e5737196..b5165929 100644 --- a/src/app/state/settings.ts +++ b/src/app/state/settings.ts @@ -18,7 +18,6 @@ export enum MessageLayout { export interface Settings { themeId?: string; - /** Set when a theme is picked in the menu, so a picked default (Midnight Sky) reads as chosen. Absent until then. */ useSystemTheme: boolean; lightThemeId?: string; darkThemeId?: string; From 6524621eadd75abfe43b7fb63ad05f764206693b Mon Sep 17 00:00:00 2001 From: Meta Vens Date: Fri, 20 Nov 2026 23:12:10 +0100 Subject: [PATCH 24/24] Idunn recipe: pin dist d62be29f (release a7: ink follows the drawn sky) Co-Authored-By: Claude Opus 5.5 --- deployment/idunn/recipe.toml | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/deployment/idunn/recipe.toml b/deployment/idunn/recipe.toml index 0995fa03..fd0bcbf2 100644 --- a/deployment/idunn/recipe.toml +++ b/deployment/idunn/recipe.toml @@ -6,14 +6,14 @@ target = "ratatoskr" # tarball was built from, which is not this commit. source_stamp_environment = "RATATOSKR_BUILD_COMMIT" -# Release dist f562f8fae9a294e04354801538ed7a595133f480: the output of build-prod-dist.sh (live config check passed), packed +# Release dist d62be29fd4b245bd1303454022ace86c4f762d02: the output of build-prod-dist.sh (live config check passed), packed # as dist/ at the top of one gzip tar. The tree carries the repo's own config.json; what is served is the operator's # carried file, which Idunn copies beside dist/ and the vhost aliases over the tree's (a vhost without that alias would # serve the repo config). [[external_inputs]] id = "dist-tarball" -url = "https://eureka.gamecult.org/forge/GameCult/Ratatoskr/releases/download/dist-f562f8fa/ratatoskr-f562f8fa-dist.tar.gz" -sha256 = "ec4f4fc3e64dfeb7ba6509b386d2a5efc318211f66de663c061e1240b1f610f0" +url = "https://eureka.gamecult.org/forge/GameCult/Ratatoskr/releases/download/dist-d62be29f/ratatoskr-d62be29f-dist.tar.gz" +sha256 = "dd04634f82d081004941c71545ba43b8d5c40dbf97fb5643d9f4f24940b6afe8" runner = "unpack" destination = "release/dist.tar.gz"