@driftengine/core 4.8.7 → 4.9.0

package/src/render/renderQuality.ts

@@ -1,5 +1,6 @@
 /** Construction-time GPU quality controls shared by every renderer resource. */
 
+import type { FrameReflections } from './frameReflections.ts';
 import { MAX_AREA_LIGHTS } from './areaLights.ts';
 import { MAX_GLOBAL_MEDIUM_STEPS } from './globalMedium.ts';
 import { MAX_POINT_LIGHTS } from './lightBudget.ts';
@@ -26,8 +27,14 @@ import { PREFILTER_SAMPLE_COUNTS } from './prefilterEnvMap.ts';
  * red where `srgb` clips each channel and turns its core pink and wide. It is the curve a ported
  * game's own resolve applied — for a port that has to match one — and it has none of ACES's toe or
  * desaturation. See `HIGHLIGHT_SHOULDER_GLSL` for the arithmetic.
+ *
+ * `filmic` is a film curve shaped by five numbers — a slope, a toe, a shoulder and how far black
+ * and white clip — that holds a mid grey of 0.18 at 0.18 where `aces` gives about 0.11, so a look
+ * graded against such a curve is matched by its numbers (`setFilmicCurve`) rather than by a lookup
+ * table. Applied by the composite alone, so it needs `screenEffects` and `hdrScene`; without them
+ * every pass grades with `aces` and the renderer says so once. See `filmicCurve.ts`.
  */
-export type OutputTransform = 'none' | 'srgb' | 'aces' | 'shoulder';
+export type OutputTransform = 'none' | 'srgb' | 'aces' | 'shoulder' | 'filmic';
 
 /**
  * The three settings whose accepted values are a closed set, written as one.
@@ -355,6 +362,18 @@ export interface RenderQuality {
    * eight-bit and this buys only the consistent grading.
    */
   readonly hdrScene: boolean;
+  /**
+   * Ask for a high dynamic range display: a canvas whose highlights run past paper white to as
+   * far as the display allows, where it reports one. Off by default.
+   *
+   * **Asked for, not assumed.** It needs WebGPU, a display reporting a high dynamic range, and a
+   * composite that holds the light to give it (`screenEffects` and `hdrScene`); where any of those
+   * is missing the frame goes out as it always did and the renderer says which in
+   * `displayRangeReason`. `displayRange` is the answer a game reads to choose a look graded for the
+   * output it got. `setDisplayLuminance` sets how far above paper white the highlights may reach.
+   * WebGL2 has no extended-range canvas to draw into, so there it is always the standard range.
+   */
+  readonly highDynamicRange: boolean;
   /** Camera-depth water tint and scattering across every visible pass. */
   readonly underwaterAtmosphere: boolean;
   /** Procedural noise octaves evaluated by plume shaders. */
@@ -522,14 +541,14 @@ export interface RenderQuality {
    */
   readonly sceneSamples: number;
   /**
-   * Camera motion blur, 0 to 1. Off by default.
+   * Motion blur, 0 to 1. Off by default.
    *
-   * Camera rather than per-object, and that is a decision rather than a stage. Per-object
-   * blur needs a velocity buffer: every mesh writing its own screen-space motion into a
-   * second render target, so a second set of matrices per draw and a wider G-buffer, which
-   * is a structural change to a forward renderer that writes one colour target. Camera blur
-   * needs only the previous view-projection, which is one matrix, and it covers the case
-   * that actually matters — a camera whipping round a turntable or through a world.
+   * By the camera's motion everywhere, and **by each drawn object's own motion where a
+   * reconstruction draws one** (DriftTR, WebGPU): a mover's pixels smear along its path while a
+   * still stage stays sharp. Elsewhere a velocity buffer would be every mesh writing its motion into
+   * a second target — a structural change to a forward renderer — so those frames blur by the
+   * camera alone, which needs only the previous view-projection, and say so once when a draw names
+   * where it was. `setCameraMotionBlur` is the per-frame dial and the longest smear.
    *
    * Runs inside the composite pass, so it costs a depth sample and eight taps on the pixels
    * that are moving and nothing on a still frame. Needs `screenEffects`, since without the
@@ -580,6 +599,18 @@ export interface RenderQuality {
    * Needs `screenEffects`, since the resolve composites over the finished scene.
    */
   readonly orderIndependent: boolean;
+  /**
+   * Every opaque lit surface reflects the frame by its own material: a ray marched against the
+   * frame's depth swaps the probes' share of each pixel for what it finds, at the pixel's own
+   * roughness and reflectance, and a surface past `maxRoughness` keeps the probes alone. Off by
+   * default; `true` for the defaults, or the numbers. See `frameReflections.ts`.
+   *
+   * Needs `screenEffects` and `hdrScene`, since the swap is made in scene light, and a frame of one
+   * sample; it says once where it cannot be drawn. What it costs on WebGPU is every opaque lit draw
+   * a second time without its lamps, into two half-float targets, and a march per reflective pixel;
+   * on WebGL2 the same two targets, written beside the colour by the opaque lit draws themselves.
+   */
+  readonly screenSpaceReflections: boolean | FrameReflections;
   /**
    * Depth of field: how wide the blur may reach, as a fraction of the frame's height. Off by
    * default.
@@ -964,9 +995,11 @@ export const DEFAULT_RENDER_QUALITY: Readonly<RenderQuality> = Object.freeze({
   sceneSamples: 1,
   planarReflections: false,
   hdrScene: false,
+  highDynamicRange: false,
   cameraMotionBlur: 0,
   temporalAa: false,
   orderIndependent: false,
+  screenSpaceReflections: false,
   depthOfField: 0,
   reconstruction: 0,
   indirectLight: false,
@@ -1126,12 +1159,15 @@ export function resolveRenderQuality(options: RenderQualityOptions = {}): Readon
     ),
     planarReflections: options.planarReflections ?? DEFAULT_RENDER_QUALITY.planarReflections,
     hdrScene: options.hdrScene ?? DEFAULT_RENDER_QUALITY.hdrScene,
+    highDynamicRange: options.highDynamicRange ?? DEFAULT_RENDER_QUALITY.highDynamicRange,
     cameraMotionBlur: Math.min(
       1,
       Math.max(0, options.cameraMotionBlur ?? DEFAULT_RENDER_QUALITY.cameraMotionBlur),
     ),
     temporalAa: options.temporalAa ?? DEFAULT_RENDER_QUALITY.temporalAa,
     orderIndependent: options.orderIndependent ?? DEFAULT_RENDER_QUALITY.orderIndependent,
+    screenSpaceReflections:
+      options.screenSpaceReflections ?? DEFAULT_RENDER_QUALITY.screenSpaceReflections,
     /* Off, or a ratio at least 1.3 and at most 2 — never a number between zero and the range. */
     reconstruction: resolveReconstruction(options.reconstruction),
     indirectLight: options.indirectLight ?? DEFAULT_RENDER_QUALITY.indirectLight,

package/src/render/sceneTarget.ts

@@ -1,5 +1,6 @@
 import { glSceneDepthFormat } from './depthConvention.ts';
 import { clampGrain, clampVignette, grainSeed } from './shaders/filmLook.ts';
+import { FRINGE_FLOATS, resolveFringe } from './shaders/fringe.ts';
 import { AmbientOcclusionPass } from './ambientOcclusionPass.ts';
 import { ExposurePass } from './exposurePass.ts';
 import { clampAutoExposure } from './shaders/exposure.ts';
@@ -99,6 +100,8 @@ export class SceneTarget {
   private gradeStrength = 0;
   /** The lens and the print, held like the grade. See `filmLook.ts`. */
   private vignette = 0;
+  /** The lens's colour fringe: red's and green's pull and where it begins. See `fringe.ts`. */
+  private readonly fringe = new Float32Array(FRINGE_FLOATS);
   private grain = 0;
   private grainSeed = 0;
   /** Eye adaptation: how far, and this frame's time step. See `Renderer.setAutoExposure`. */
@@ -702,6 +705,11 @@ export class SceneTarget {
     this.vignette = clampVignette(strength);
   }
 
+  /** The lens's colour fringe, held until changed. See `Renderer.setChromaticAberration`. */
+  setChromaticAberration(intensity: number, start: number): void {
+    resolveFringe(intensity, start, this.fringe);
+  }
+
   /** The print's grain and this frame's seed, held until changed. See `Renderer.setFilmGrain`. */
   setFilmGrain(strength: number, seed: number): void {
     this.grain = clampGrain(strength);
@@ -769,8 +777,15 @@ export class SceneTarget {
   resolve(
     strength: number,
     reachUv: number,
-    /* The grade, applied here because this is the last pass. See RUSH_FRAG's own note. */
-    grade: { readonly transform: number; readonly exposure: number } = {
+    /*
+     * The grade, applied here because this is the last pass. See RUSH_FRAG's own note. `film` is
+     * the `filmic` curve's eight constants (`resolveFilmicCurve`), read only under transform 4.
+     */
+    grade: {
+      readonly transform: number;
+      readonly exposure: number;
+      readonly film?: Float32Array;
+    } = {
       transform: 0,
       exposure: 1,
     },
@@ -1012,6 +1027,12 @@ export class SceneTarget {
     gl.uniform1f(this.uniforms['uReach'] ?? null, reachUv);
     gl.uniform1i(this.uniforms['uOutputTransform'] ?? null, grade.transform);
     gl.uniform1f(this.uniforms['uOutputExposure'] ?? null, grade.exposure);
+    if (grade.film !== undefined) {
+      gl.uniform4fv(this.uniforms['uFilmA'] ?? null, grade.film, 0, 4);
+      gl.uniform4fv(this.uniforms['uFilmB'] ?? null, grade.film, 4, 4);
+    }
+    /* A standard range always here: see `Renderer.displayRange`. */
+    gl.uniform1f(this.uniforms['uDisplayHeadroom'] ?? null, 1);
 
     /*
      * Depth on its own unit, and the reprojection with it. Bound every frame rather than
@@ -1113,6 +1134,12 @@ export class SceneTarget {
       this.uniforms['uLocalExposure'] ?? null,
       localGrid === null ? 0 : this.localExposure,
     );
+    /* Each object's own motion is WebGPU's under a reconstruction; here the scene stands in on
+       unit 7 and the flag says not to read it, so the camera's motion alone blurs. */
+    gl.activeTexture(gl.TEXTURE7);
+    gl.bindTexture(gl.TEXTURE_2D, scene);
+    gl.uniform1i(this.uniforms['uMotion'] ?? null, 7);
+    gl.uniform1f(this.uniforms['uObjectMotion'] ?? null, 0);
     gl.activeTexture(gl.TEXTURE0);
 
     /* No unit and no texture: a flat colour, not a sample. Uploaded unconditionally — two
@@ -1122,6 +1149,7 @@ export class SceneTarget {
     gl.uniform3fv(this.uniforms['uVeilColor'] ?? null, veilColor);
     gl.uniform1f(this.uniforms['uVeilAlpha'] ?? null, veilAlpha);
     gl.uniform1f(this.uniforms['uVignette'] ?? null, this.vignette);
+    gl.uniform3fv(this.uniforms['uFringe'] ?? null, this.fringe);
     gl.uniform2f(this.uniforms['uGrain'] ?? null, this.grain, this.grainSeed);
 
     gl.bindVertexArray(this.vao);

package/src/render/screenSpaceReflection.ts

@@ -27,6 +27,11 @@ import type { DecalBox } from './decalProjector.ts';
  * which is the same price the temporal row declined for a velocity buffer. A caller declares a
  * `ReflectiveSurface` instead: a box, and a facing rule for which surfaces inside it reflect. It is
  * the shape `DecalProjector` already has, for the same reason.
+ *
+ * **Or every surface by its own material**, where the renderer was built with
+ * `screenSpaceReflections`: the lit stage leaves two maps of what it reflected — not a G-buffer, the
+ * environment's share and its tint, which is all a swap needs — and the same trace runs in a
+ * material mode over every pixel. See `frameReflections.ts`.
  */
 
 /**

package/src/render/shaders/filmLook.ts

@@ -88,7 +88,8 @@ export function grainWeight(luma: number): number {
 
 /** Both backends' words when there is no composite to apply the look in. */
 export const FILM_LOOK_WITHOUT_COMPOSITE =
-  '[driftengine] setVignette and setFilmGrain need `screenEffects`: without a composite every ' +
+  '[driftengine] setVignette, setFilmGrain and setChromaticAberration need `screenEffects`: ' +
+  'without a composite every ' +
   'pass is the last thing to touch the frame, so there is no one place to apply a lens or a ' +
   'print. The look was not applied.';
 

package/src/render/shaders/flat/glassTint.ts

@@ -34,7 +34,9 @@ export type LitSwitch =
   | 'LIGHT_FIXTURES'
   | 'SURFACE_EFFECTS'
   | 'DRIFT_LIGHT'
-  | 'PHYSICAL_SPECULAR';
+  | 'PHYSICAL_SPECULAR'
+  | 'SURFACE_OVERLAY'
+  | 'REFLECTION_MAPS';
 
 /** Every switch off: what a renderer starts from before its profile and its content say otherwise. */
 export function noLitSwitches(): Record<LitSwitch, boolean> {
@@ -45,6 +47,8 @@ export function noLitSwitches(): Record<LitSwitch, boolean> {
     SURFACE_EFFECTS: false,
     DRIFT_LIGHT: false,
     PHYSICAL_SPECULAR: false,
+    SURFACE_OVERLAY: false,
+    REFLECTION_MAPS: false,
   };
 }
 

package/src/render/shaders/flat/index.ts

@@ -19,6 +19,8 @@ import { AREA_LIGHT_GLSL } from './areaLight.ts';
 import { NORMAL_MAP_GLSL } from './normalMap.ts';
 import { DRIFT_LIGHT_GLSL } from './driftLight.ts';
 import { SURFACE_EFFECTS_GLSL } from './surfaceEffects.ts';
+import { overlayGlsl } from './overlay.ts';
+import { reflectionSurfaceGlsl } from './reflectionSurface.ts';
 import { CHANNEL_ATTRIBUTE, CHANNEL_BEND } from '../vertexChannel.ts';
 import { FULL_LIGHT_BUDGET, type LightBudget } from '../../uniformVectorBudget.ts';
 
@@ -468,6 +470,16 @@ export interface FlatShaderOptions {
    * when absent. See `modelsGlsl`.
    */
   readonly physicalSpecular?: boolean;
+  /**
+   * Whether it carries a draw's surface overlay, `uOverlay` and all (`setSurfaceOverlay`). True
+   * when absent. See `overlayGlsl`.
+   */
+  readonly surfaceOverlay?: boolean;
+  /**
+   * Whether the frame's own draws write the reflection maps beside their colour: WebGL2's way to
+   * the frame's materials' reflections. True when absent. See `reflectionSurfaceGlsl`.
+   */
+  readonly reflectionMaps?: boolean;
   /**
    * How many point lights this build declares room for. `MAX_POINT_LIGHTS` when absent.
    *
@@ -613,6 +625,10 @@ export function flatFrag(options: FlatShaderOptions): string {
       SURFACE_EFFECTS_GLSL,
       /* Depth zero and after the tangent frame and the lobes it calls; see models.ts. */
       modelsGlsl(options.physicalSpecular ?? true),
+      /* After the models, so its switch takes the next id; depth zero, as main calls it. */
+      overlayGlsl(options.surfaceOverlay ?? true),
+      /* After the overlay, so its switch takes the next id. See reflectionSurface.ts. */
+      reflectionSurfaceGlsl(options.reflectionMaps ?? true),
       /* After the models, whose answer to a rectangle it asks for. See areaLight.ts. */
       AREA_LIGHT_GLSL,
       MAIN_GLSL,

package/src/render/shaders/flat/main.ts

@@ -26,6 +26,10 @@ export const MAIN_GLSL = `void main() {
   vec2 fxDx = dFdx(surfaceAt.xy);
   vec2 fxDy = dFdy(surfaceAt.xy);
   if (uWriteMode.y != 0.0 && !ditherKeeps(uWriteMode.y)) discard;
+  /* A draw's dissolve cuts the surface away before anything is shaded: overlay.ts. */
+  if (SURFACE_OVERLAY) {
+    if (overlayCuts(surfaceAt.xy)) discard;
+  }
 
   /*
    * Surface colour and its coverage, resolved before anything else — including before it is
@@ -140,6 +144,11 @@ export const MAIN_GLSL = `void main() {
   }
 
   vec3 lit = albedo;
+  /* How much of the environment the frame shows here, and how a found reflection would land:
+     reflectionSurface.ts. None where nothing is reflected. */
+  vec3 reflectedProbe = vec3(0.0);
+  vec3 reflectedTint = vec3(0.0);
+  float reflectedRoughness = 1.0;
   /* Skin's diffuse, held before emission for the screen-space blur's own pass: models.ts. */
   vec3 diffuseAlone = vec3(0.0);
   /* The light arriving at a glass pane from behind it, gathered in each light loop below and added
@@ -187,7 +196,10 @@ export const MAIN_GLSL = `void main() {
      * right: a mipped colour image, sampled under uniform control flow, exactly as uAlbedo is
      * below. The rule is about non-uniform branches, and this branch is on a uniform.
      */
+    vec3 unmapped = n;
     if (uNormalStrength > 0.0) n = normalMapped(n, surfaceAt);
+    /* A draw's wrinkles, by region, over whatever the map made: overlay.ts. */
+    if (SURFACE_OVERLAY) n = overlayWrinkle(n, unmapped, surfaceAt.xy);
 
     /*
      * Microscopic relief: the surface's own texture, as a turn of the normal rather than a change
@@ -916,6 +928,15 @@ export const MAIN_GLSL = `void main() {
         environment * mix(vec3(1.0), albedo, metal),
         weight
       );
+      reflectedTint = mix(vec3(1.0), albedo, metal) * weight;
+      reflectedProbe = environment * reflectedTint;
+      reflectedRoughness = surfaceRoughness;
+    }
+    /* The reflection pass's surface half leaves here, before the lamps: reflectionSurface.ts. */
+    if (REFLECTION_SURFACE) {
+      reflectionSurfaceOut(reflectedProbe, reflectedTint, reflectedRoughness, ormOcclusion,
+        reflectionAir());
+      return;
     }
     /*
      * The sun's highlight, on top of whatever the surface reflects rather than underneath it —
@@ -1940,6 +1961,9 @@ export const MAIN_GLSL = `void main() {
       * mix(1.0, min(lightShade, sunShade), EMISSIVE_SHADOW_SHARE) * fxGlow;
     /* And a lit window's glow, which the scene's lit share already times: not gated on night. */
     lit += windowGlow * uEmission.x;
+    /* And a draw's overlay: its rim, its dissolve's band and the colour laid over. Not gated on the
+       night, as emission is: a glow the surface wears rather than light it gives off. overlay.ts. */
+    if (SURFACE_OVERLAY) lit += overlayGlow(surfaceAt.xy, n);
 
 #if NIGHT_EMISSIVE
     /*
@@ -2138,6 +2162,10 @@ export const MAIN_GLSL = `void main() {
     return;
   }
 
+  /* WebGL2's frame writes the reflection maps itself, with the fog already reckoned above. */
+  if (REFLECTION_MAPS) {
+    reflectionSurfaceOut(reflectedProbe, reflectedTint, reflectedRoughness, ormOcclusion, fog);
+  }
   outColor = vec4(shaded, alpha);
 }
 `;

package/src/render/shaders/flat/overlay.ts

@@ -0,0 +1,117 @@
+/**
+ * A draw's surface overlay in the lit stage: the rim, the dissolve and the wrinkles
+ * `surfaceOverlay.ts` packs into `uOverlay`. Called from `main` at three places — the dissolve's cut
+ * before anything is shaded, the wrinkles after the normal map, and the glow beside emission.
+ *
+ * **A lit switch, `SURFACE_OVERLAY`**, off until a draw first sets an overlay and then on for good,
+ * as `litSwitchesGlsl`'s are; declared after the models so every switch before it keeps its id.
+ * Compiled out, the three calls are stubs and the fifteen vectors are not declared at all, which is
+ * what lets WebGL2 build a lit program without them on a device that has no room.
+ *
+ * **Images come from the atlas bound where the frame's refraction copy goes**, which an opaque draw
+ * never reads; a draw that refracts or is glass reads that copy there, so its overlay reads no image
+ * (`overlayImagesBound`). Each image is read by `textureLod` at level 0: several are reached under a
+ * branch on a per-pixel value, and the atlas carries no chain anyway.
+ */
+export function overlayGlsl(on: boolean): string {
+  if (!on) {
+    return /* glsl */ `
+const bool SURFACE_OVERLAY = false;  // wgsl:override
+bool overlayCuts(vec2 uv) { return false; }
+vec3 overlayWrinkle(vec3 mapped, vec3 unmapped, vec2 uv) { return mapped; }
+vec3 overlayGlow(vec2 uv, vec3 n) { return vec3(0.0); }
+`;
+  }
+  return /* glsl */ `
+/* Whether this program carries a draw's overlay. Off but where one has been set: overlay.ts. */
+const bool SURFACE_OVERLAY = true;  // wgsl:override
+/* The overlay's fifteen vectors; packSurfaceOverlay in surfaceOverlay.ts says what each holds. */
+uniform vec4 uOverlay[15];
+
+/* Whether the atlas is what the refraction slot holds: not where this draw refracts or is glass. */
+bool overlayImagesBound() {
+  return uSeeThrough.x <= 0.0 && uSeeThrough.z <= 0.0;
+}
+
+/* One image of the atlas at uv, repeated within its region; zero where the region has no size. */
+vec4 overlayImage(vec4 region, vec2 uv) {
+  if (region.x <= 0.0) return vec4(0.0);
+  return textureLod(uRefractScene, region.zw + fract(uv) * region.xy, 0.0);
+}
+
+/* The dissolve's noise at uv, and whether the draw dissolves at all: -1 where it does not. */
+float overlayDissolveNoise(vec2 uv) {
+  if (uOverlay[6].x <= 0.0 || uOverlay[7].z <= 0.0) return -1.0;
+  if (!overlayImagesBound()) return -1.0;
+  return overlayImage(uOverlay[6], uv * uOverlay[7].xy).r;
+}
+
+/* Whether the dissolve cuts this fragment away: where its noise is under the threshold, or all of
+   it at a threshold of 1. */
+bool overlayCuts(vec2 uv) {
+  float noise = overlayDissolveNoise(uv);
+  if (noise < 0.0) return false;
+  return noise < uOverlay[7].z || uOverlay[7].z >= 1.0;
+}
+
+/*
+ * The wrinkle normal blended into the mapped one by the two masks' channels times the six weights,
+ * in the frame the normal map is read in. **Under uniform control flow up to the frame**, which
+ * takes derivatives: every branch before it is on the overlay's numbers alone, and the weight a
+ * pixel takes is a mix rather than a branch.
+ */
+vec3 overlayWrinkle(vec3 mapped, vec3 unmapped, vec2 uv) {
+  if (uOverlay[10].x <= 0.0 || !overlayImagesBound()) return mapped;
+  mat3 tbn = tangentFrame(unmapped, vWorldPos, vUv.xy, vTangent, vHasTangents);
+  vec3 a = overlayImage(uOverlay[11], uv).rgb;
+  vec3 b = overlayImage(uOverlay[12], uv).rgb;
+  float weight = clamp(
+    dot(a, uOverlay[13].xyz) + dot(b, vec3(uOverlay[13].w, uOverlay[14].xy)), 0.0, 1.0);
+  vec3 wrinkle = overlayImage(uOverlay[10], uv).xyz * 2.0 - 1.0;
+  /* z rebuilt where none is stored, as normalMapped does: see normalMap.ts. */
+  wrinkle.z = wrinkle.z > 0.0 ? wrinkle.z : sqrt(max(0.0, 1.0 - dot(wrinkle.xy, wrinkle.xy)));
+  return normalize(mix(mapped, normalize(tbn * wrinkle), weight));
+}
+
+/*
+ * The rim's place on the screen, 0 to 1 up its height and its width in the same units: from view
+ * space and the projection's tangent, not from gl_FragCoord, whose y runs up on one backend and
+ * down on the other (the 2026-08-17 rule), and whose scale is a render target's, not the screen's.
+ */
+vec2 overlayScreen() {
+  vec4 eye = uView * vec4(vWorldPos, 1.0);
+  float depth = max(-eye.z, 1e-4) * uClusterFrustum.z;
+  return vec2(eye.x / depth + uClusterFrustum.w, eye.y / depth + 1.0) * 0.5;
+}
+
+/* What the overlay adds to the light the surface gives off: the dissolve's band, the colour laid
+   over through its noise, and the rim. Zero where the draw sets none of them. */
+vec3 overlayGlow(vec2 uv, vec3 n) {
+  vec3 glow = vec3(0.0);
+  float noise = overlayDissolveNoise(uv);
+  if (noise >= 0.0) {
+    float band = 1.0 - clamp((noise - uOverlay[7].z) / uOverlay[7].w, 0.0, 1.0);
+    glow += uOverlay[8].rgb * uOverlay[8].w * band + uOverlay[9].rgb * uOverlay[9].w * noise;
+  }
+  float strength = uOverlay[0].w;
+  if (strength > 0.0) {
+    vec3 toEye = normalize(uCameraPos - vWorldPos);
+    float edge = pow(1.0 - clamp(dot(n, toEye), 0.0, 1.0), max(uOverlay[1].x, 1e-4));
+    float up = pow(clamp(n.y * 0.5 + 0.5, 0.0, 1.0), max(uOverlay[1].y, 1e-4));
+    float rim = pow(edge * up, max(uOverlay[1].z, 1e-4));
+    float time = uSurfaceScene.x;
+    if (uOverlay[2].x > 0.0 && overlayImagesBound()) {
+      vec2 at = overlayScreen() * uOverlay[3].z + uOverlay[3].xy * time;
+      rim *= overlayImage(uOverlay[2], at).r;
+    }
+    rim = min(rim, 1.0);
+    rim *= mix(uOverlay[4].x, uOverlay[4].y, 0.5 + 0.5 * sin(uOverlay[3].w * time));
+    if (uOverlay[5].x > 0.0 && overlayImagesBound()) {
+      rim *= 1.0 - uOverlay[1].w * overlayImage(uOverlay[5], uv).r;
+    }
+    glow += uOverlay[0].rgb * strength * rim;
+  }
+  return glow;
+}
+`;
+}

package/src/render/shaders/flat/pointShadow.ts

@@ -342,7 +342,7 @@ float areaShadow(
 ${LAMP_GLASS_GLSL}
 #endif
 
-out vec4 outColor;
+layout(location = 0) out vec4 outColor;
 
 ${OUTPUT_TRANSFORM_GLSL}
 

package/src/render/shaders/flat/reflectionSurface.ts

@@ -0,0 +1,61 @@
+/**
+ * What the lit stage leaves for a reflection traced in the frame: how much of the environment each
+ * pixel shows, and how a reflection found in the frame would land there instead. Read by the
+ * reflection pass (`screenSpaceReflection.ts`), which swaps the one for the other where its ray
+ * finds something.
+ *
+ * **The swap is exact because the lit stage's own blend is a mix**: `lit = mix(lit, environment ·
+ * tint, weight)` leaves `environment · tint · weight` of the probe in the frame, and a reflection
+ * found in the frame belongs there with the same tint and the same weight. So the frame gains
+ * `(found · tint − environment · tint) · weight` and nothing else moves: the diffuse the blend
+ * already took its share from keeps it. Both are carried the rest of the way the shaded colour
+ * goes — the occlusion, the water and the medium in front of the surface — so the swap lands in the
+ * frame's own units.
+ *
+ * **Two outputs beside the colour, written by every lit draw and kept only where a target is
+ * bound.** WebGL2 binds them during opaque lit draws alone; WebGPU's frame pass binds none, and a
+ * second pass replays the frame's opaque draws into them with `REFLECTION_SURFACE` on, which leaves
+ * before the lamps (`main`). What it gives up is a vector of arithmetic on every lit pixel whether
+ * or not anything reads it.
+ */
+export function reflectionSurfaceGlsl(maps: boolean): string {
+  return /* glsl */ `
+/*
+ * Whether this pipeline is the reflection pass's surface half: the frame's opaque draws again,
+ * against the depth they wrote, leaving the two outputs below and no light. Off in every other
+ * pipeline, and set from the key as skin's halves are. See reflectionSurface.ts.
+ */
+const bool REFLECTION_SURFACE = false;  // wgsl:override
+/*
+ * Whether the frame's own draws write the two outputs as well: WebGL2's arrangement, on where the
+ * frame's materials' reflections are, and off in every WebGPU pipeline, which replays the draws
+ * instead. A lit switch, so a program that does not write them carries nothing live across the
+ * lamps for them.
+ */
+const bool REFLECTION_MAPS = ${maps ? 'true' : 'false'};  // wgsl:override
+/* The environment as the frame shows it, and the surface's roughness in w. */
+layout(location = 1) out vec4 outReflectedProbe;
+/* What a reflection found in the frame is multiplied by to land where the environment did. */
+layout(location = 2) out vec4 outReflectedTint;
+
+/* How much of the surface the medium in front of it leaves: the fog block below's own measure. */
+float reflectionAir() {
+  return uFogEnabled != 0 ? mediumFog(distance(vWorldPos, uCameraPos), vWorldPos.y) : 0.0;
+}
+
+/*
+ * The two outputs, carried through what the shaded colour meets after the blend: its occlusion,
+ * the water, and the air, as \`main\` applies them. \`air\` is the fog the caller has already
+ * reckoned, so the frame's own draws pay for it once.
+ */
+void reflectionSurfaceOut(vec3 probe, vec3 tint, float roughness, float occlusion, float air) {
+  vec3 keep = vec3(occlusion * (1.0 - air));
+  if (uFogEnabled != 0) {
+    vec3 waterTransmission = vec3(0.42) + uUnderwaterColor * 2.0;
+    keep *= mix(vec3(1.0), waterTransmission, uUnderwaterFactor * 0.55);
+  }
+  outReflectedProbe = vec4(probe * keep, roughness);
+  outReflectedTint = vec4(tint * keep, 1.0);
+}
+`;
+}

package/src/render/shaders/fog.ts

@@ -85,11 +85,18 @@ float mediumFog(float dist, float pointY) {
     return mix(ramp, 1.0 - exp2(-wetLinear * wetLinear * 1.442695), uUnderwaterFactor);
   }
 
+  // Where the medium begins along the ray: uFogNear, the linear mode's slot, which this mode
+  // never read before Atmosphere.fogStart. The ray is integrated from there on, at the density
+  // of that point; at a start of 0 every term is the one it always was. See render/fog.ts.
+  float start = min(uFogNear, dist);
+  float before = dist > 0.0 ? start / dist : 0.0;
   float t = (pointY - uFogEyeY) * uFogHeightFalloff;
+  float rest = t * (1.0 - before);
   // (1 - e^-t)/t, which tends to 1 as the ray levels out. Guarded rather than
   // branched: at t = 0 the quotient is 0/0, and 1e-4 of a scale height is 8 mm.
-  float denom = abs(t) < 1e-4 ? 1e-4 : t;
-  float air = 1.0 - exp(-uFogDensity * dist * (1.0 - exp(-denom)) / denom);
+  float denom = abs(rest) < 1e-4 ? 1e-4 : rest;
+  float air =
+    1.0 - exp(-uFogDensity * exp(-t * before) * (dist - start) * (1.0 - exp(-denom)) / denom);
   if (uUnderwaterFactor <= 0.0) return air;
   // Water is its own medium and keeps its own curve, so crossing the surface
   // changes nothing about how the water column reads.

package/src/render/shaders/fringe.ts

@@ -0,0 +1,59 @@
+/**
+ * Chromatic aberration: a lens bending each colour by its own amount, so red and green land a
+ * little nearer the centre than blue toward the frame's edges.
+ *
+ * **Linear in wavelength, from an offset outward.** A simple lens's dispersion is close to linear
+ * in wavelength over the visible range, so red (611 nm) and green (549 nm) are pulled toward the
+ * centre by their distance from blue (464 nm), which is drawn where it is. Nothing moves inside
+ * `start` — a share of the half-frame, 0 at the centre — and the pull grows linearly past it,
+ * scaled so that the frame's edge takes the whole of `intensity`, which is a percentage.
+ *
+ * **What it gives up**: it re-reads the scene at the composite's first sample, so the camera's
+ * motion blur and the depth of field, which re-read the scene themselves, carry less of the fringe
+ * where they are strong. A pass of its own after both would carry it whole, at a full-frame read
+ * and write a frame. **What would make that wrong** is a game that blurs heavily and fringes
+ * heavily at once, where the colour edges would be seen to soften with the blur.
+ */
+
+/** How many floats `resolveFringe` fills: the red pull, the green pull, and where they begin. */
+export const FRINGE_FLOATS = 3;
+
+/** The primaries' wavelengths, nanometres. */
+const RED_NM = 611.3;
+const GREEN_NM = 549.1;
+const BLUE_NM = 464.3;
+/** The lens's dispersion per nanometre, the constant that makes `intensity` a percentage. */
+const PER_NM = 0.007;
+
+/**
+ * The fringe's three numbers, into `out`: how far red and green are pulled toward the centre at
+ * the frame's edge, as a share of the half-frame, and the start offset. `intensity` 0 or below is
+ * none; a start of 1 or more is none too, since nothing then lies past it. Not finite is none.
+ */
+export function resolveFringe(intensity: number, start: number, out: Float32Array): void {
+  const at = Number.isFinite(start) ? Math.min(Math.max(start, 0), 1) : 0;
+  const amount = Number.isFinite(intensity) && intensity > 0 && at < 1 ? intensity * 0.01 : 0;
+  /* Divided only where there is something to divide: at a start of 1 this is 0 over 0. */
+  const reach = amount > 0 ? amount / (1 - at) : 0;
+  out[0] = reach * PER_NM * (RED_NM - BLUE_NM);
+  out[1] = reach * PER_NM * (GREEN_NM - BLUE_NM);
+  out[2] = at;
+}
+
+/**
+ * `withFringe(scene)`: the scene's colour with red and green read again where the lens put them.
+ * Reads `uScene` and `vUv`, which the including stage declares, and `uFringe`, which this declares.
+ */
+export const FRINGE_GLSL = `
+/** Red's and green's pull at the frame's edge, and where it begins: see shaders/fringe.ts. */
+uniform vec3 uFringe;
+
+vec3 withFringe(vec3 scene) {
+  if (uFringe.x <= 0.0) return scene;
+  vec2 lens = vUv * 2.0 - 1.0;
+  vec2 past = sign(lens) * clamp(abs(lens) - uFringe.z, 0.0, 1.0);
+  vec2 red = (lens - past * uFringe.x) * 0.5 + 0.5;
+  vec2 green = (lens - past * uFringe.y) * 0.5 + 0.5;
+  return vec3(textureLod(uScene, red, 0.0).r, textureLod(uScene, green, 0.0).g, scene.b);
+}
+`;