@driftengine/core 4.12.0 → 4.13.0

package/src/render/passGrade.ts

@@ -0,0 +1,58 @@
+/**
+ * Which grade a pass applies to what it draws, decided once for both backends.
+ *
+ * **Every pass grades where nothing after it will**, so a colour handed to the renderer means linear
+ * light wherever it lands. Three facts decide where that is:
+ *
+ * - **A probe's face or a capture stores radiance** for something else to light with or to show, so
+ *   it is never graded. The frame grades what it reads of one; graded at the bake as well, the curve
+ *   would be applied twice.
+ * - **A frame whose resolve grades** (`hdrScene` over a scene target) leaves every pass before the
+ *   resolve linear, because grading early throws away the range the float target exists to keep.
+ * - **Past the present, a pass lands on the canvas the resolve has already written**, so nothing
+ *   after it will grade it and it grades itself with the frame's forward code, composite or not. An
+ *   interface drawn after `endFrame` escapes the screen-space chain; it does not escape the grade.
+ *
+ * **An interface takes the screen encode and not the curve** (`interfaceGrade`). A tone curve and
+ * an exposure are how a scene's light is brought to the screen, and a caption or a panel is not
+ * light: its colour was picked for the screen, so it is encoded wherever the frame is and comes out
+ * as picked under every transform, at every exposure. What it gives up is an interface drawn inside
+ * a frame whose resolve grades (`hdrScene`): that one is part of the picture the resolve tone maps,
+ * and is drawn after `endFrame` to stay out of it. What would make any of this wrong is a composite
+ * step running after the present, which none does.
+ */
+import { forwardTransformCode } from './vertexDefaults.ts';
+
+/**
+ * The `uOutputTransform` a pass uploads: `storing` inside a probe's face or a capture, `presented`
+ * once the frame's resolve has run, `resolveGrades` where that resolve applies the transform.
+ */
+export function passGradeCode(
+  storing: boolean,
+  presented: boolean,
+  resolveGrades: boolean,
+  outputTransform: string,
+): number {
+  if (storing) return 0;
+  return presented || !resolveGrades ? forwardTransformCode(outputTransform) : 0;
+}
+
+/** The `uOutputExposure` beside it: the frame's exposure wherever the pass grades, else one. */
+export function passGradeExposure(
+  storing: boolean,
+  presented: boolean,
+  resolveGrades: boolean,
+  exposure: number,
+): number {
+  if (storing) return 1;
+  return presented || !resolveGrades ? exposure : 1;
+}
+
+/**
+ * The code an interface draws with, given the pass's: the screen encode wherever the pass grades at
+ * all, and nothing where it does not. Never a curve, so never an exposure either: a screen-space
+ * caption, a panel or a 2D layer keeps the colour it was picked as whatever the scene is graded by.
+ */
+export function interfaceGrade(passCode: number): number {
+  return passCode === 0 ? 0 : 1;
+}

package/src/render/plumeRenderer.ts

@@ -173,6 +173,8 @@ export class PlumeRenderer {
     originX = 0,
     originY = 0,
     originZ = 0,
+    outputTransform = 0,
+    outputExposure = 1,
   ): void {
     if (this.indexCount === 0) return;
     const u = this.uniforms;
@@ -200,6 +202,9 @@ export class PlumeRenderer {
     gl.uniform3f(u['uTint'] ?? null, this.tint[0], this.tint[1], this.tint[2]);
     gl.uniform1i(u['uClipEnabled'] ?? null, clipPlane === null ? 0 : 1);
     if (clipPlane !== null) gl.uniform4fv(u['uClipPlane'] ?? null, clipPlane);
+    /* The renderer's `passGrade`: the frame's, but none in a probe's face or a capture. */
+    gl.uniform1i(u['uOutputTransform'] ?? null, outputTransform);
+    gl.uniform1f(u['uOutputExposure'] ?? null, outputExposure);
     bindAtmosphere(gl, u, atmosphere, atmosphereCameraY, underwaterEnabled);
 
     gl.enable(gl.BLEND);

package/src/render/renderQuality.ts

@@ -61,22 +61,35 @@ export type SkinScattering = 'pre-integrated' | 'screen-space';
 
 export interface RenderQuality {
   /**
-   * The transfer curve applied at the end of every shaded pass.
-   *
-   * Construction-time, like every other quality control here, and `none` by default so
-   * no existing world changes by a single bit.
-   *
-   * **The symptom, written down because nobody searches for a transfer curve they do not know
-   * exists.** With `none`, values above 1 clip flat rather than rolling off, so a scene with
-   * bright sources against dark surroundings reads as crushed and desaturated: the highlights
-   * go to a hard white with no colour left in them and the midtones look muddy. That is
-   * reported by eye as "dark", "flat" or "not vivid", which sounds like a lighting problem, so
-   * that is where people look. A consumer built, tuned and shipped six worlds before anybody
-   * said the word. If a scene looks like that, try `outputTransform: 'aces'` with an
-   * `outputExposure` before touching a single light.
-   *
-   * The default stays `none`, and that is not the fault: a curve that changed every existing
-   * consumer's output would be far worse than one nobody found.
+   * The transfer curve applied at the end of every shaded pass. Construction-time, like every
+   * other quality control here.
+   *
+   * **`srgb` by default since 4.13.0, the encoding a display expects**: the light the renderer
+   * computes is linear, and a texture's colours are decoded to linear when they are read, so a
+   * frame written without encoding them back is a frame of linear values read as display values —
+   * every midtone far too dark. It is the encoding most renderers apply by default, so a model
+   * drawn here with no options reads as it does elsewhere. **What it gives up** is a highlight's
+   * colour: above 1 each channel clips on its own, so a bright saturated source goes to white
+   * rather than rolling off, which a curve with a shoulder (`aces`, `shoulder`) is for.
+   *
+   * **`none` was the default until 4.13.0, and it is the frame that reads as dark**: values
+   * written as they are computed, which is right only for a world whose colours were chosen by
+   * eye as display values and lit to match. It was reported by eye as "dark", "flat" or "not
+   * vivid", which sounds like a lighting problem, so that is where people looked; a consumer
+   * built, tuned and shipped six worlds under it before anybody said the word, and a model drawn
+   * from the manual came out darker than in any other engine. A world graded under it says
+   * `outputTransform: 'none'` and draws exactly as it did. **What would make `srgb` the wrong
+   * default** is a renderer whose colours are not linear, which this one's are not.
+   *
+   * **Every pass applies it where nothing after it will**, and the clear colour with them, so a
+   * colour handed to the renderer is linear wherever it lands: a frame with `hdrScene` is graded
+   * once at the resolve, and one without it is graded pass by pass to the same curve. A colour
+   * picked by eye is a display value, so it is stated through `srgbColor` (or a mesh built with
+   * `colorSpace: 'srgb'`), which gives back exactly the colour picked where a surface is lit at 1
+   * under `srgb`, and through the curve under a tone curve. **An interface** (screen text, a panel,
+   * the 2D layer) takes the screen encode and never the curve or the exposure, so its colours come
+   * out as picked under every transform; inside an `hdrScene` frame it is part of the picture the
+   * resolve grades, and is drawn after `endFrame` to stay out of the curve.
    */
   readonly outputTransform: OutputTransform;
   /**
@@ -270,9 +283,35 @@ export interface RenderQuality {
    * at a shadow's edge — that is what the blur is for.
    */
   readonly skinScattering: SkinScattering;
-  /** Horizontal world-space reach over which a directional shadow dissolves. */
+  /**
+   * How far a sun shadow may reach along the ground from its caster, in metres, before it
+   * dissolves. **Not a distance from the camera**: a shadow's own length, from where it leaves its
+   * caster to where it lands, fading from 35% of this to all of it.
+   *
+   * **1,000 since 4.13.0, so no building's shadow dissolves**: the fade starts at 350 m, past any
+   * wall, tower or canyon a shadow map covers at a useful resolution, so what bounds a shadow is
+   * its map, whose edge already fades. **What it gives up** is a way to hide a long shadow's
+   * stair-stepping at a low sun, which is what a short reach was for. It was 6 until 4.13.0: a
+   * tuning for short casters, which left a building's walls and arcades casting nothing on its
+   * floor under a high sun — the shadows vanished silently and read as random lighting. **What
+   * would make it wrong** is a scene whose shadows are too coarse to show at their full length;
+   * there a reach of the length that looks right is the setting, and the map around the viewer
+   * (`computeLightMatrix`) the better fix.
+   */
   readonly directionalShadowMaxDistance: number;
-  /** Maximum horizontal projection per vertical metre before low-angle shadows vanish. */
+  /**
+   * How low the sun may stand before its shadows fade, as the ground a metre of height may shadow:
+   * the sun's horizontal reach per vertical metre, so 1 is 45° of elevation and 60 about 1°. Every
+   * sun shadow fades from 65% of this to all of it.
+   *
+   * **60 since 4.13.0: shadows hold until the sun is about a degree above the horizon**, the
+   * stretch of a day when they are longest and most worth seeing. **What it gives up**: a sun on
+   * the horizon throws shadows kilometres long that a map can hold only as stripes, and the
+   * last degree is where they fade rather than show. It was 3 until 4.13.0, which dropped every
+   * sun shadow below about 18° — an evening without shadows. **What would make it wrong** is a
+   * scene whose low sun streaks; a smaller number here is the setting, at the cost of the
+   * shadows going earlier in the evening.
+   */
   readonly directionalShadowMaxSlope: number;
   /**
    * Metres a point light may drift from where its shadow was baked before re-baking.
@@ -958,7 +997,7 @@ export const DIRECTIONAL_SHADOW_FADE_START = 0.65;
  * six times, while the directional map spends all of it on one focused area.
  */
 export const DEFAULT_RENDER_QUALITY: Readonly<RenderQuality> = Object.freeze({
-  outputTransform: 'none',
+  outputTransform: 'srgb',
   outputExposure: 1,
   pointLightFalloff: 'smooth',
   /**
@@ -1006,8 +1045,8 @@ export const DEFAULT_RENDER_QUALITY: Readonly<RenderQuality> = Object.freeze({
   glassShadows: 'full',
   pipelineCompile: 'wait',
   skinScattering: 'pre-integrated',
-  directionalShadowMaxDistance: 6,
-  directionalShadowMaxSlope: 3,
+  directionalShadowMaxDistance: 1000,
+  directionalShadowMaxSlope: 60,
   pointShadowRebakeDistance: 0.001,
   pointShadowFacesPerFrame: 2,
   /*

package/src/render/sceneTarget.ts

@@ -785,6 +785,8 @@ export class SceneTarget {
       readonly transform: number;
       readonly exposure: number;
       readonly film?: Float32Array;
+      /** Whether the forward passes graded the scene because this resolve does not. */
+      readonly sceneGraded?: boolean;
     } = {
       transform: 0,
       exposure: 1,
@@ -1030,6 +1032,7 @@ 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);
+    gl.uniform1i(this.uniforms['uSceneGraded'] ?? null, grade.sceneGraded === true ? 1 : 0);
     if (grade.film !== undefined) {
       gl.uniform4fv(this.uniforms['uFilmA'] ?? null, grade.film, 0, 4);
       gl.uniform4fv(this.uniforms['uFilmB'] ?? null, grade.film, 4, 4);

package/src/render/sdfTextRenderer.ts

@@ -112,7 +112,7 @@ export class SdfTextRenderer {
    */
   /**
    * `outputTransform` and `outputExposure` come from the renderer rather than from here, because
-   * whether this pass grades depends on whether anything after it will. See `Renderer.gradeCode`.
+   * whether this pass grades depends on whether anything after it will. See `passGrade.ts`.
    */
   draw(
     viewProj: ReadonlyMat4,

package/src/render/shaders/arcane.ts

@@ -1,4 +1,5 @@
 import { FOG_GLSL } from './fog.ts';
+import { OUTPUT_TRANSFORM_GLSL } from './outputTransform.ts';
 
 /**
  * An arcane aura: the volume a floating object sits inside.
@@ -31,6 +32,8 @@ ${FOG_GLSL}
 uniform int uNoiseOctaves;
 uniform vec4 uClipPlane;
 uniform int uClipEnabled;
+/* Before \`uTint\`, where fire and smoke declare it, so one field table serves all three. */
+${OUTPUT_TRANSFORM_GLSL}
 /** The caller's colour, so an aura shifts with the world's own palette. */
 uniform vec3 uTint;
 
@@ -98,6 +101,7 @@ void main() {
   col = mix(col, mediumColor(), fog);
   alpha *= 1.0 - fog;
 
-  outColor = vec4(col, alpha);
+  /* Graded where nothing after this will grade it, as every pass is. The alpha is coverage. */
+  outColor = vec4(applyOutputTransform(col), alpha);
 }
 `;

package/src/render/shaders/bolt.ts

@@ -1,4 +1,5 @@
 import { FOG_GLSL } from './fog.ts';
+import { OUTPUT_TRANSFORM_GLSL } from './outputTransform.ts';
 
 /**
  * Electrical arcs: a filament with a saturating core and a wide soft glow.
@@ -95,6 +96,7 @@ ${FOG_GLSL}
 uniform vec3 uCameraPos;
 
 out vec4 outColor;
+${OUTPUT_TRANSFORM_GLSL}
 
 float hash11(float p) {
   return fract(sin(p * 12.9898) * 43758.5453123);
@@ -165,6 +167,7 @@ void main() {
    * faint: at a typical energy of 0.5 it delivered a quarter of what it asked for.
    * Every emissive material here has to pick one channel and mean it.
    */
-  outColor = vec4(lit * energy * (1.0 - fog), 1.0);
+  /* Graded where nothing after this will grade it, as every pass is, light added included. */
+  outColor = vec4(applyOutputTransform(lit * energy * (1.0 - fog)), 1.0);
 }
 `;

package/src/render/shaders/caustics.ts

@@ -1,5 +1,6 @@
 import { GERSTNER_GLSL } from './gerstner.ts';
 import { FOG_GLSL } from './fog.ts';
+import { OUTPUT_TRANSFORM_GLSL } from './outputTransform.ts';
 
 /**
  * Light off water, projected onto what covers it.
@@ -78,6 +79,7 @@ uniform float uMaxDrop;
 ${FOG_GLSL}
 
 out vec4 outColor;
+${OUTPUT_TRANSFORM_GLSL}
 
 ${GERSTNER_GLSL}
 
@@ -164,6 +166,7 @@ void main() {
   float fog = mediumFog(distance(vWorldPos, uCameraPos), vWorldPos.y);
 
   // Additive: this is light arriving at a surface that is already shaded.
-  outColor = vec4(uTint * (caustic * uStrength * reach * (1.0 - fog)), 1.0);
+  /* Graded where nothing after this will grade it, as every pass is, light added included. */
+  outColor = vec4(applyOutputTransform(uTint * (caustic * uStrength * reach * (1.0 - fog))), 1.0);
 }
 `;

package/src/render/shaders/decalProject.ts

@@ -24,6 +24,7 @@
  */
 
 import { glslIsFarDepth } from '../depthConvention.ts';
+import { LINEAR_TO_SRGB_GLSL } from './outputTransform.ts';
 
 export const DECAL_PROJECT_FRAG = `#version 300 es
 precision highp float;
@@ -63,7 +64,9 @@ uniform float uDecalOpacity;
 uniform float uDecalFacingCos;
 /** How much of the mark's radius is edge. */
 uniform float uDecalSoftness;
-
+/** How the frame under the marks was graded, 0 where the resolve grades it. See renderQuality.ts. */
+uniform int uOutputTransform;
+${LINEAR_TO_SRGB_GLSL}
 out vec4 fragColor;
 
 void main() {
@@ -122,6 +125,13 @@ void main() {
   mark *= ${glslIsFarDepth('stored')} ? 0.0 : 1.0;
 
   /* White is the identity of a multiply, so a pixel the projector missed changes nothing. */
-  fragColor = vec4(mix(vec3(1.0), uDecalColor, mark * uDecalOpacity), 1.0);
+  vec3 multiply = mix(vec3(1.0), uDecalColor, mark * uDecalOpacity);
+  /*
+   * **The multiply as an encoded pixel takes it**, where the frame was graded before this: the
+   * receiver is a display value, and darkening its light by a factor is darkening the display value
+   * by that factor encoded — exact through the sRGB encode, whose power carries a product through,
+   * and close through a curve, which bends it. A frame graded at the resolve multiplies linear light.
+   */
+  fragColor = vec4(mix(multiply, linearToSrgb(multiply), float(uOutputTransform != 0)), 1.0);
 }
 `;

package/src/render/shaders/film.ts

@@ -1,4 +1,5 @@
 import { FOG_GLSL } from './fog.ts';
+import { OUTPUT_TRANSFORM_GLSL } from './outputTransform.ts';
 
 /**
  * A thin, wet, iridescent film lying on a surface.
@@ -122,6 +123,7 @@ uniform float uFilmRoughness;
 uniform float uFilmRoughnessCycles;
 
 out vec4 fragColor;
+${OUTPUT_TRANSFORM_GLSL}
 
 /** A hue wheel, without a texture. Standard 6-segment ramp. */
 vec3 hue(float h) {
@@ -199,6 +201,19 @@ void main() {
   vec3 base = vTint * 0.9;
   vec3 color = base + sheen * uSheen * (0.22 + grazing * 0.75);
 
+  /*
+   * **Graded before the mirror is mixed in**, as every pass grades what it draws when nothing after
+   * it will, because the mirror's own passes graded what it holds. The fog that used to follow the
+   * mirror distributes over the mix, so the film's own colour is fogged and graded here, and what
+   * the mirror shows is fogged toward the same air, graded, where it is mixed in below.
+   */
+  // The same fog every other pass applies — and now literally the same code, which
+  // it was not: this ran its own curve while claiming otherwise, so a slick receded
+  // at a different rate than the deck it was lying on.
+  float fog = mediumFog(length(uCameraPos - vWorld), vWorld.y);
+  vec3 gradedAir = applyOutputTransform(mediumColor());
+  vec3 graded = applyOutputTransform(mix(color, mediumColor(), fog));
+
   /*
    * The mirrored scene, under the sheen rather than instead of it.
    *
@@ -208,7 +223,7 @@ void main() {
    *
    * Weighted by the grazing term as well as by strength, because that is what a reflection does:
    * a wet surface underfoot shows almost nothing and the same surface down the street shows the
-   * whole scene. Added before the fog so the image recedes with everything else in the frame.
+   * whole scene. Fogged as the film is, so the image recedes with everything else in the frame.
    */
   if (uReflectionEnabled != 0 && uReflectionStrength > 0.0 && vReflectionClip.w > 0.0) {
     vec2 reflectionUv = vReflectionClip.xy / vReflectionClip.w * 0.5 + 0.5;
@@ -254,15 +269,13 @@ void main() {
       valid = min(valid, smoothstep(0.0, 0.025, min(movedBorder.x, movedBorder.y)));
     }
     vec3 mirrored = textureLod(uReflectionMap, clamp(reflectionUv, 0.0, 1.0), 0.0).rgb;
-    color = mix(color, mirrored, valid * uReflectionStrength * (0.25 + grazing * 0.75));
+    graded = mix(
+      graded,
+      mix(mirrored, gradedAir, fog),
+      valid * uReflectionStrength * (0.25 + grazing * 0.75)
+    );
   }
 
-  // The same fog every other pass applies — and now literally the same code, which
-  // it was not: this ran its own curve while claiming otherwise, so a slick receded
-  // at a different rate than the deck it was lying on.
-  float fog = mediumFog(length(uCameraPos - vWorld), vWorld.y);
-  color = mix(color, mediumColor(), fog);
-
   /*
    * Alpha from coverage, squared.
    *
@@ -280,6 +293,6 @@ void main() {
    */
   float coverage = clamp(vCoverage, 0.0, 1.0);
   float alpha = mix(coverage * coverage, coverage, 0.65) * 0.92;
-  fragColor = vec4(color, alpha);
+  fragColor = vec4(graded, alpha);
 }
 `;

package/src/render/shaders/fire.ts

@@ -1,4 +1,5 @@
 import { FOG_GLSL } from './fog.ts';
+import { OUTPUT_TRANSFORM_GLSL } from './outputTransform.ts';
 
 /**
  * Procedural flames: camera-facing quads whose shape and colour come entirely
@@ -116,6 +117,7 @@ uniform vec4 uClipPlane;
 uniform int uClipEnabled;
 
 out vec4 outColor;
+${OUTPUT_TRANSFORM_GLSL}
 
 float hash21(vec2 p) {
   return fract(sin(dot(p, vec2(127.1, 311.7))) * 43758.5453123);
@@ -175,6 +177,7 @@ void main() {
   col = mix(col, mediumColor(), fog);
   alpha *= 1.0 - fog;
 
-  outColor = vec4(col, alpha);
+  /* Graded where nothing after this will grade it, as every pass is. The alpha is coverage. */
+  outColor = vec4(applyOutputTransform(col), alpha);
 }
 `;

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

@@ -22,10 +22,9 @@ float layerExtras() { return uLayers[1].y; }
 vec3 layerTint(int i) { return vec3(1.0); }
 vec2 layerRanges(int i, vec2 roughMetal) { return roughMetal; }
 vec3 layerStrengthen(int i, vec3 texel) { return texel; }
-float layerSpecular(int i, float own) { return own; }
+float layerNamedSpecular(int i) { return -1.0; }
 float layerRepeatDown(int i, float across) { return across; }
-float layerOcclusionStrength() { return 0.0; }
-bool layerOcclusionAmbient() { return false; }
+vec2 layerOcclusionStrengths() { return vec2(0.0); }
 vec2 layerOcclusionRange() { return vec2(0.0, 1.0); }
 `;
   }
@@ -35,7 +34,7 @@ const bool LAYER_LOOKS = true;  // wgsl:override
 /*
  * Fifteen vectors, as surfaceLayerLooks.ts packs them: the array layer each of the five reads, base
  * first (floats 0 to 4); where the maps beyond the layers start (5), the mesh occlusion's strength
- * (6) and whether it darkens the ambient light rather than the colour (7); then two vectors a
+ * on the colour, from 0 up (6), and on the ambient light (7); then two vectors a
  * layer, base first: its tint (x y z) and normal strength (w), then its roughness range (x to y)
  * and metalness range (z to w); then each layer's specular, -1 for the surface's own (48 to 52), its
  * repeat down (53 to 57), and the occlusion's range (58 to 59).
@@ -83,13 +82,10 @@ vec3 layerStrengthen(int i, vec3 texel) {
   return texel;
 }
 
-/* The layer's specular, or the surface's own where it names none. */
-float layerSpecular(int i, float own) {
-  if (LAYER_LOOKS) {
-    float named = layerLook(48 + i);
-    return named < 0.0 ? own : named;
-  }
-  return own;
+/* The specular the layer names, or -1 where it names none and the surface's own stands. */
+float layerNamedSpecular(int i) {
+  if (LAYER_LOOKS) return layerLook(48 + i);
+  return -1.0;
 }
 
 /* The layer's repeat down, which is its repeat across unless it gave two. */
@@ -98,14 +94,10 @@ float layerRepeatDown(int i, float across) {
   return across;
 }
 
-float layerOcclusionStrength() {
-  if (LAYER_LOOKS) return uLayerLooks[1].z;
-  return 0.0;
-}
-
-bool layerOcclusionAmbient() {
-  if (LAYER_LOOKS) return uLayerLooks[1].w > 0.5;
-  return false;
+/* The mesh occlusion's strength on the colour (x), from 0 up, and on the ambient light (y). */
+vec2 layerOcclusionStrengths() {
+  if (LAYER_LOOKS) return uLayerLooks[1].zw;
+  return vec2(0.0);
 }
 
 vec2 layerOcclusionRange() {

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

@@ -61,8 +61,12 @@ ${layerLooksGlsl(looks)}
 /* Each layer's share of this point, the base's and layers 1 to 4's: worked out once, in layeredBegin. */
 float lShareBase;
 vec4 lShare;
-/* What an occlusion read at the mesh's coordinates leaves of this point, 1 where none: layeredBegin. */
-float lMeshOcclusion;
+/*
+ * What an occlusion read at the mesh's coordinates leaves of this point's colour and of its ambient
+ * light, 1 where none: layeredBegin.
+ */
+float lColorOcclusion;
+float lAmbientOcclusion;
 
 bool layered() {
   return uLayers[1].y > 0.5;
@@ -103,15 +107,18 @@ vec4 layerPick(float layer) {
 void layeredBegin() {
   /*
    * The occlusion at the mesh's coordinates, once: the ORM array's layer past the layers and past
-   * any mask and added mask it carries, spread over its range and taken at its strength.
+   * any mask and added mask it carries, spread over its range and taken at each strength. The
+   * colour's may pass 1, darkening faster than the occlusion does, and is held at black.
    */
-  lMeshOcclusion = 1.0;
-  float strength = layerOcclusionStrength();
-  if (strength > 0.0) {
+  lColorOcclusion = 1.0;
+  lAmbientOcclusion = 1.0;
+  vec2 strength = layerOcclusionStrengths();
+  if (strength.x > 0.0 || strength.y > 0.0) {
     float at = layerExtras() + (abs(uLayers[1].w - 1.0) < 0.5 ? 1.0 : 0.0) + (uLayers[2].z > 0.5 ? 1.0 : 0.0);
     vec2 range = layerOcclusionRange();
-    float occlusion = mix(range.x, range.y, texture(uOrmMap, vec3(vUv.xy, at)).r);
-    lMeshOcclusion = mix(1.0, occlusion, strength);
+    float bare = 1.0 - mix(range.x, range.y, texture(uOrmMap, vec3(vUv.xy, at)).r);
+    lColorOcclusion = max(0.0, 1.0 - strength.x * bare);
+    lAmbientOcclusion = 1.0 - strength.y * bare;
   }
   vec4 m = layerWeights();
   if (uLayers[2].z > 0.5) {
@@ -158,7 +165,7 @@ vec3 layeredColor(vec3 color) {
 
 /*
  * Colour by the shares, each layer's tinted, and the base layer's coverage, which a cutout reads;
- * then darkened by the occlusion at the mesh's coordinates, where it is the colour that takes it.
+ * then darkened by the occlusion at the mesh's coordinates, at the colour's strength.
  */
 vec4 layeredAlbedo() {
   vec4 sum = vec4(0.0);
@@ -168,28 +175,36 @@ vec4 layeredAlbedo() {
     sum.rgb += t.rgb * layerTint(i) * layerShare(i);
     if (i == 0) sum.a = t.a;
   }
-  if (!layerOcclusionAmbient()) sum.rgb *= lMeshOcclusion;
+  sum.rgb *= lColorOcclusion;
   return sum;
 }
 
-/* What the ambient light keeps: the occlusion at the mesh's coordinates, where it takes it. */
+/* What the ambient light keeps: the occlusion at the mesh's coordinates, at the ambient's strength. */
 float layeredAmbient() {
-  return layerOcclusionAmbient() ? lMeshOcclusion : 1.0;
+  return lAmbientOcclusion;
 }
 
 /*
- * The specular by the shares, each layer's own or the surface's where it names none. The surface's
- * own, untouched, where no material has asked for looks: shares summing to one in floating point
- * are not quite one, and a layered material that names nothing must draw exactly as before.
+ * The specular by the shares: each layer's named one at its share, and the surface's own over the
+ * layers naming none, once at most. Under a summed blend the shares add past 1 where the weights
+ * do, and a surface whose layers leave the specular to it reflects its own, not its own times that
+ * sum; under a blend laid over, the shares never pass 1 and this is the sum it always was. What it
+ * gives up: named speculars still add as their colours do, so a summed blend that names them
+ * reflects their sum. The surface's own, untouched, where no material has asked for looks: shares
+ * summing to one in floating point are not quite one, and a layered material that names nothing
+ * must draw exactly as before.
  */
 float layeredSpecular(float own) {
   if (LAYER_LOOKS) {
-    float sum = 0.0;
+    float named = 0.0;
+    float unnamed = 0.0;
     for (int i = 0; i < 5; i++) {
       if (float(i) >= uLayers[1].y) break;
-      sum += layerSpecular(i, own) * layerShare(i);
+      float specular = layerNamedSpecular(i);
+      if (specular < 0.0) unnamed += layerShare(i);
+      else named += specular * layerShare(i);
     }
-    return sum;
+    return named + own * min(unnamed, 1.0);
   }
   return own;
 }

package/src/render/shaders/flock.ts

@@ -1,3 +1,4 @@
+import { OUTPUT_TRANSFORM_GLSL } from './outputTransform.ts';
 /**
  * Birds: two triangles each, circling on a path computed entirely in the vertex
  * shader.
@@ -96,8 +97,10 @@ precision highp float;
 in float vShade;
 uniform vec3 uTint;
 out vec4 outColor;
+${OUTPUT_TRANSFORM_GLSL}
 
 void main() {
-  outColor = vec4(uTint * vShade, 1.0);
+  /* Graded where nothing after this will grade it, as every pass is. */
+  outColor = vec4(applyOutputTransform(uTint * vShade), 1.0);
 }
 `;