@driftengine/core 4.8.6 → 4.9.0

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

@@ -23,6 +23,52 @@ float areaSignedForm(vec3 n, vec3 centre, vec3 right, vec3 up, vec2 halfSize) {
   return quadFormFactor(n, vWorldPos, c0, c1, c2, c3);
 }
 
+/**
+ * How far along one of a rectangle's axes a fragment still sees it past the barn door on that axis's
+ * positive edge: \`p\` the fragment's place along the axis, \`height\` its height above the
+ * rectangle's plane, \`halfSize\` the rectangle's half extent, and the door's tip \`tipOut\` beyond
+ * the edge and \`tipUp\` above the plane. Points of the rectangle past the answer are hidden.
+ *
+ * Above the tip, the tip's shadow on the plane as seen from the fragment is the limit. Below it, a
+ * fragment beside the door and outside its line is hidden from all of it, and one inside the door's
+ * reach is hidden from none of it.
+ */
+float barnDoorLimit(float p, float height, float halfSize, float tipOut, float tipUp) {
+  float tipAt = halfSize + tipOut;
+  if (height > tipUp) return (height * tipAt - tipUp * p) / (height - tipUp);
+  if (p > halfSize && height * tipOut < tipUp * (p - halfSize)) return -1e9;
+  return 1e9;
+}
+
+/**
+ * The part of a rectangle a fragment sees past its barn doors, written into \`centre\` and
+ * \`halfSize\` as the smaller rectangle that is left, or false where the doors hide all of it.
+ * \`doors\` is the cosine of their angle from the normal and their length; a length of 0 is no doors.
+ * Each axis is clipped by its own two doors, which is what makes this four projections and a min.
+ */
+bool areaBarnDoors(inout vec3 centre, vec3 right, vec3 up, inout vec2 halfSize, vec2 doors) {
+  if (doors.y <= 0.0) return true;
+  vec3 toFragment = vWorldPos - centre;
+  float height = dot(toFragment, cross(right, up));
+  /* Behind the emitting side: nothing to clip, and the form factor already answers it. */
+  if (height <= 0.0) return true;
+  float tipOut = doors.y * sqrt(max(1.0 - doors.x * doors.x, 0.0));
+  float tipUp = doors.y * doors.x;
+  vec2 p = vec2(dot(toFragment, right), dot(toFragment, up));
+  vec2 hi = vec2(
+    min(halfSize.x, barnDoorLimit(p.x, height, halfSize.x, tipOut, tipUp)),
+    min(halfSize.y, barnDoorLimit(p.y, height, halfSize.y, tipOut, tipUp))
+  );
+  vec2 lo = vec2(
+    max(-halfSize.x, -barnDoorLimit(-p.x, height, halfSize.x, tipOut, tipUp)),
+    max(-halfSize.y, -barnDoorLimit(-p.y, height, halfSize.y, tipOut, tipUp))
+  );
+  if (hi.x <= lo.x || hi.y <= lo.y) return false;
+  centre += right * (0.5 * (lo.x + hi.x)) + up * (0.5 * (lo.y + hi.y));
+  halfSize = 0.5 * (hi - lo);
+  return true;
+}
+
 /**
  * What one rectangle of colour \`color\` and form factor \`form\` adds to the lamps' two sums, open
  * and shadowed by \`occl\` and \`glass\`.

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

@@ -29,7 +29,14 @@ vec4 glassUnmix(vec4 mip, float centreClarity) {
  * about which optional code a lit program carries. See `litSwitchesGlsl`.
  */
 export type LitSwitch =
-  'GLASS_SHADOWS' | 'CLUSTERED_LIGHTS' | 'LIGHT_FIXTURES' | 'SURFACE_EFFECTS' | 'DRIFT_LIGHT';
+  | 'GLASS_SHADOWS'
+  | 'CLUSTERED_LIGHTS'
+  | 'LIGHT_FIXTURES'
+  | 'SURFACE_EFFECTS'
+  | 'DRIFT_LIGHT'
+  | '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> {
@@ -39,6 +46,9 @@ export function noLitSwitches(): Record<LitSwitch, boolean> {
     LIGHT_FIXTURES: false,
     SURFACE_EFFECTS: false,
     DRIFT_LIGHT: false,
+    PHYSICAL_SPECULAR: false,
+    SURFACE_OVERLAY: false,
+    REFLECTION_MAPS: false,
   };
 }
 
@@ -61,7 +71,8 @@ export interface LitSwitches {
  * first uses them — a measured profile or a cookie, a material with an effects table, a DriftLight
  * volume — and then on for good; see `PipelineCache.enable` and the WebGL2 renderer's rebuild.
  * Measured on RADV against the lit shader with glass already out: 6,852 instructions and 120
- * registers, 4,641 and 96 with all four out.
+ * registers, 4,641 and 96 with all four out. `PHYSICAL_SPECULAR` is a sixth, declared with the
+ * models so that theirs keep their ids (`modelsGlsl`).
  */
 export function litSwitchesGlsl(switches: LitSwitches): string {
   return /* glsl */ `

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

@@ -14,11 +14,13 @@ import { CLOTH_BINDING_GLSL } from '../clothBinding.ts';
 import { SKINNING_GLSL } from '../skinning.ts';
 import { SURFACE_GLSL } from './surface.ts';
 import { MAIN_GLSL } from './main.ts';
-import { MODELS_GLSL } from './models.ts';
+import { modelsGlsl } from './models.ts';
 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';
 
@@ -245,6 +247,15 @@ void main() {
 #endif
 #if INSTANCED
   mat4 model = mat4(aInstanceModel0, aInstanceModel1, aInstanceModel2, aInstanceModel3);
+  /*
+   * **The bottom row is the instance's texture cell** (\`MeshInstances.uvRegions\`), which an
+   * affine placement leaves free: read, and rebuilt as the \`[0, 0, 0, 1]\` it stands for.
+   */
+  vec4 instanceCell = vec4(model[0].w, model[1].w, model[2].w, model[3].w);
+  model[0].w = 0.0;
+  model[1].w = 0.0;
+  model[2].w = 0.0;
+  model[3].w = 1.0;
   vec3 tint = aInstanceTint.rgb;
   if (LIGHTMAP_REGIONS) tint = vec3(1.0);
 #else
@@ -293,7 +304,12 @@ void main() {
   vColor = aColor * tint;
   vEmissive = aEmissive;
   vSpecular = aSpecular;
+#if INSTANCED
+  /* The instance's cell first, then the material's scale and offset. */
+  vUv = vec3((aUv.xy * instanceCell.xy + instanceCell.zw) * uUvScale + uUvOffset, aUv.z);
+#else
   vUv = vec3(aUv.xy * uUvScale + uUvOffset, aUv.z);
+#endif
   vEmissiveColor = aEmissiveColor;
   vRoughness = aRoughness;
   vGrain = aGrain;
@@ -449,6 +465,21 @@ export interface FlatShaderOptions {
   readonly surfaceEffects?: boolean;
   /** Whether it reads a DriftLight volume. True when absent. See `litSwitchesGlsl`. */
   readonly driftLight?: boolean;
+  /**
+   * Whether it carries GGX's own highlight for a material that asks (`physicalSpecular`). True
+   * 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.
    *
@@ -593,7 +624,11 @@ export function flatFrag(options: FlatShaderOptions): string {
       DRIFT_LIGHT_GLSL,
       SURFACE_EFFECTS_GLSL,
       /* Depth zero and after the tangent frame and the lobes it calls; see models.ts. */
-      MODELS_GLSL,
+      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/lobes.ts

@@ -30,6 +30,55 @@ export const EMISSIVE_SHADOW_SHARE = 0.55;
  */
 export const MIN_LOBE_ALPHA = 0.01;
 
+/**
+ * Karis's fit to the split-sum environment BRDF, as GLSL: the lit stage's, and the screen-space
+ * reflection's when a surface asks for its Fresnel (`ReflectiveSurface.fresnel`). One text, so the
+ * two cannot drift.
+ */
+export const ENV_BRDF_GLSL = `/**
+ * The other half of the split-sum approximation: what fraction of an environment a surface returns.
+ *
+ * The convolution decides *what* a surface reflects at a given roughness; this decides *how much*.
+ * Before it the amount was fresnel times one-minus-roughness, which is a curve somebody chose
+ * standing in for an integral.
+ *
+ * Karis's analytic fit to the environment BRDF, so there is **no lookup texture and no texture
+ * unit**: a few multiply-adds against roughness and the view angle. x scales the surface's own
+ * reflectance at normal incidence and y is the additive grazing term, so a smooth dielectric at
+ * f0 0.04 returns about 0.046 head-on and approaches 1 at the edge, which is what a dielectric
+ * does. At roughness 1 it returns about 0.016 rather than the zero one-minus-roughness gave, which
+ * is the substantive difference: a fully rough dielectric does reflect its surroundings.
+ *
+ * **It replaces the Fresnel factor as well as the thinning**, because the fit already contains the
+ * angular dependence; multiplying by a separate Fresnel term would apply it twice.
+ *
+ * **How much this is worth was measured, and it is worth less than it looks on a dark room.**
+ * On demo/dev/ibl.html?ladder=1 the whole ladder moved by at most 0.2 of 255 when the old term was
+ * replaced. That is not the term failing: at high roughness the surface reads the coarsest levels
+ * of the chain, and in a room of five dark walls and one bright one those levels are dark, so a
+ * weight three times larger against a near-zero radiance is still near zero. It is worth much more
+ * against a bright environment, which is what a loaded sky is and what no captured room here is.
+ *
+ * **A warning about reading that page, paid for once.** The ladder falls about five-fold from
+ * mirror to rough, and that reads as energy being lost. It is not: a mirror concentrates the one
+ * bright wall into a sharp image and a rough surface averages it against five dark ones, so the
+ * falloff is the room's own content. The normalised falloff also happens to track one-minus-
+ * roughness closely, which made the old term look like the cause — and removing that term entirely
+ * changed nothing, which is what settled it. Perturb before believing a match.
+ *
+ * **What it costs** is a fit rather than the integral: the published error is around one per cent
+ * of the tabulated term, far below what an eight-bit frame can show. **What would make it wrong**
+ * is a material model this shader does not have — a clearcoat or a sheen lobe carries its own BRDF
+ * and its own integral, and this fit is Trowbridge-Reitz with Smith masking and nothing else.
+ */
+vec2 envBrdfApprox(float ndv, float roughness) {
+  const vec4 c0 = vec4(-1.0, -0.0275, -0.572, 0.022);
+  const vec4 c1 = vec4(1.0, 0.0425, 1.04, -0.04);
+  vec4 r = roughness * c0 + c1;
+  float a004 = min(r.x * r.x, exp2(-9.28 * ndv)) * r.x + r.y;
+  return vec2(-1.04, 1.04) * a004 + r.zw;
+}`;
+
 export const LOBES_GLSL = `float shadowReach(float distance, float maxDistance) {
   return 1.0 - smoothstep(
     maxDistance * ${POINT_SHADOW_FADE_START.toFixed(2)},
@@ -156,49 +205,7 @@ float sphereLobe(float ndh, float roughness, float sourceRadius, float dist) {
   return energy * (w2 * w2) / max(d * d, 1e-8);
 }
 
-/**
- * The other half of the split-sum approximation: what fraction of an environment a surface returns.
- *
- * The convolution decides *what* a surface reflects at a given roughness; this decides *how much*.
- * Before it the amount was fresnel times one-minus-roughness, which is a curve somebody chose
- * standing in for an integral.
- *
- * Karis's analytic fit to the environment BRDF, so there is **no lookup texture and no texture
- * unit**: a few multiply-adds against roughness and the view angle. x scales the surface's own
- * reflectance at normal incidence and y is the additive grazing term, so a smooth dielectric at
- * f0 0.04 returns about 0.046 head-on and approaches 1 at the edge, which is what a dielectric
- * does. At roughness 1 it returns about 0.016 rather than the zero one-minus-roughness gave, which
- * is the substantive difference: a fully rough dielectric does reflect its surroundings.
- *
- * **It replaces the Fresnel factor as well as the thinning**, because the fit already contains the
- * angular dependence; multiplying by a separate Fresnel term would apply it twice.
- *
- * **How much this is worth was measured, and it is worth less than it looks on a dark room.**
- * On demo/dev/ibl.html?ladder=1 the whole ladder moved by at most 0.2 of 255 when the old term was
- * replaced. That is not the term failing: at high roughness the surface reads the coarsest levels
- * of the chain, and in a room of five dark walls and one bright one those levels are dark, so a
- * weight three times larger against a near-zero radiance is still near zero. It is worth much more
- * against a bright environment, which is what a loaded sky is and what no captured room here is.
- *
- * **A warning about reading that page, paid for once.** The ladder falls about five-fold from
- * mirror to rough, and that reads as energy being lost. It is not: a mirror concentrates the one
- * bright wall into a sharp image and a rough surface averages it against five dark ones, so the
- * falloff is the room's own content. The normalised falloff also happens to track one-minus-
- * roughness closely, which made the old term look like the cause — and removing that term entirely
- * changed nothing, which is what settled it. Perturb before believing a match.
- *
- * **What it costs** is a fit rather than the integral: the published error is around one per cent
- * of the tabulated term, far below what an eight-bit frame can show. **What would make it wrong**
- * is a material model this shader does not have — a clearcoat or a sheen lobe carries its own BRDF
- * and its own integral, and this fit is Trowbridge-Reitz with Smith masking and nothing else.
- */
-vec2 envBrdfApprox(float ndv, float roughness) {
-  const vec4 c0 = vec4(-1.0, -0.0275, -0.572, 0.022);
-  const vec4 c1 = vec4(1.0, 0.0425, 1.04, -0.04);
-  vec4 r = roughness * c0 + c1;
-  float a004 = min(r.x * r.x, exp2(-9.28 * ndv)) * r.x + r.y;
-  return vec2(-1.04, 1.04) * a004 + r.zw;
-}
+${ENV_BRDF_GLSL}
 
 /**
  * How much of a prefiltered environment a surface returns, with the light that bounces more than

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
@@ -543,7 +555,7 @@ export const MAIN_GLSL = `void main() {
      * specularLobe's header argues for at length.
      */
     float sunVoH = max(dot(normalize(uCameraPos - vWorldPos), halfway), 0.0);
-    vec3 sunSpec = mix(specColor, vec3(1.0), pow(1.0 - sunVoH, 5.0) * metal);
+    vec3 sunSpec = highlightTint(specColor, sunVoH, metal);
     /*
      * **Held back until after the environment blend, because that blend is a mix and would
      * otherwise erase this.**
@@ -562,8 +574,12 @@ export const MAIN_GLSL = `void main() {
      * Zero for the whole world that carries no specular attribute and no metalness, exactly as
      * before: \`sunSpec\` is \`vec3(vSpecular)\` at metal 0 and \`vSpecular\` defaults to 0.
      */
-    vec3 sunHighlight =
-      sunColor * specularLobe(max(dot(n, halfway), 0.0), surfaceRoughness) * sunSpec * sunShade * sunFacing;
+    /* GGX's own where the surface asks (\`physicalSpecular\`): the sun is a point, so nothing widens it. */
+    float sunNdh = max(dot(n, halfway), 0.0);
+    float sunLobe = physicalSpecular()
+      ? physicalLobe(sunNdh, ndl, dot(n, normalize(uCameraPos - vWorldPos)), surfaceRoughness, 0.0, 1.0)
+      : specularLobe(sunNdh, surfaceRoughness);
+    vec3 sunHighlight = sunColor * sunLobe * sunSpec * sunShade * sunFacing;
     if (modelled) sunHighlight = sunModelSpecular;
     /*
      * The dielectric's share goes in here, where it has always gone, so the environment blend
@@ -912,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 —
@@ -1067,6 +1092,10 @@ export const MAIN_GLSL = `void main() {
       float cookie;
       /* The light's lighting channels, a mask: 1 unless it names others. See \`uLightIesAxis\`. */
       float lightChannels = 1.0;
+      /* The light's own falloff exponent, or 0 for the frame's falloff. See \`uLightCone\`. */
+      float lightExponent = 0.0;
+      /* A clustered rectangle's barn doors: their cosine and length, none at 0. See \`areaBarnDoors\`. */
+      vec2 areaDoors = vec2(0.0);
       /*
        * **A rectangle in the froxel table** — one past the fixed arm's \`maxAreaLights\` — which
        * its record says with a negative radius, its reach negated. Its fields come out of the
@@ -1117,8 +1146,8 @@ export const MAIN_GLSL = `void main() {
       lightWeight = sizeAndWeight.y;
       /*
        * **The fixture, read only for a light that has one.** What a plain light's record holds in
-       * the last three texels is exactly these values, so a light carrying no shadow slot, cone,
-       * profile or cookie shades the same whether they are read or assumed, and at heavy overlap
+       * the last four texels is exactly these values, so a light carrying no shadow slot, cone,
+       * profile, cookie, channels or falloff of its own shades the same whether they are read or assumed, and at heavy overlap
        * reading them was a third of the pass. A branch on a value from a texture around
        * \`texelFetch\` is not the 2026-08-07 case: an integer fetch takes no derivative.
        *
@@ -1138,6 +1167,7 @@ export const MAIN_GLSL = `void main() {
           uvec4 rec2 = clusterTexel(record + 2);
           uvec4 rec3 = clusterTexel(record + 3);
           uvec4 rec4 = clusterTexel(record + 4);
+          uvec4 rec5 = clusterTexel(record + 5);
           shadowSlot = clusteredArea ? -1 : int(uintBitsToFloat(rec2.x));
           areaTwoSided = uintBitsToFloat(rec2.x);
           lightDir = vec3(
@@ -1150,6 +1180,8 @@ export const MAIN_GLSL = `void main() {
           iesAxis = vec3(
             uintBitsToFloat(rec4.x), uintBitsToFloat(rec4.y), uintBitsToFloat(rec4.z));
           lightChannels = uintBitsToFloat(rec4.w);
+          lightExponent = uintBitsToFloat(rec5.x);
+          areaDoors = vec2(uintBitsToFloat(rec5.y), uintBitsToFloat(rec5.z));
         }
       }
       } else {
@@ -1162,7 +1194,8 @@ export const MAIN_GLSL = `void main() {
       lightWeight = uLightWeight[i];
       shadowSlot = i;
       lightDir = uLightDir[i];
-      lightCone = uLightCone[i];
+      lightCone = uLightCone[i].xy;
+      lightExponent = uLightCone[i].z;
       iesProfile = uLightIesProfile[i];
       iesAxis = uLightIesAxis[i].xyz;
       lightChannels = uLightIesAxis[i].w;
@@ -1188,12 +1221,15 @@ export const MAIN_GLSL = `void main() {
        * froxel it is binned into has no edge in the picture.
        */
       if (clusteredArea) {
-        float areaForm = areaSignedForm(n, lightPos, lightDir, iesAxis, lightCone);
+        vec3 seenCentre = lightPos;
+        vec2 seenHalf = lightCone;
+        if (!areaBarnDoors(seenCentre, lightDir, iesAxis, seenHalf, areaDoors)) continue;
+        float areaForm = areaSignedForm(n, seenCentre, lightDir, iesAxis, seenHalf);
         float areaWindow = clamp(1.0 - pow(length(lightPos - vWorldPos) / max(lightRadius, 1e-4), 4.0), 0.0, 1.0);
         areaForm = mix(max(0.0, areaForm), abs(areaForm), areaTwoSided);
         if (areaForm > 0.0) {
           areaLightAdd(
-            lightPos, lightDir, iesAxis, lightCone, lightColor * (areaWindow * areaWindow), areaForm,
+            seenCentre, lightDir, iesAxis, seenHalf, lightColor * (areaWindow * areaWindow), areaForm,
             1.0, vec3(1.0), n, albedo, metal, specColor, surfaceRoughness, modelled,
             lampOpen, lampShadowed
           );
@@ -1244,7 +1280,16 @@ export const MAIN_GLSL = `void main() {
        * same way three.js windows its own, so the light still ends where it says it does.
        */
       float falloff;
-      if (uLightFalloff == 1) {
+      /*
+       * **A light may name its own falloff, and then it is Unreal's for a light without
+       * inverse-square falloff**: \`(1 - (d/R)^2)^n\` with no distance term, so a fill authored to
+       * light a whole hall across a hundred metres does, where the inverse square would have it
+       * gone a few metres out. Zero is the frame's own rule below, which every light was before.
+       */
+      if (lightExponent > 0.0) {
+        float reach = dist / max(lightRadius, 1e-4);
+        falloff = pow(clamp(1.0 - reach * reach, 0.0, 1.0), lightExponent);
+      } else if (uLightFalloff == 1) {
         float window = clamp(1.0 - pow(dist / max(lightRadius, 1e-4), 4.0), 0.0, 1.0);
         falloff = window * window / max(dist * dist, 0.01);
       } else {
@@ -1507,7 +1552,11 @@ export const MAIN_GLSL = `void main() {
         photometric = mix(1.0, iesGain, step(0.0, iesProfile));
       }
 
-      float shape = (uLightFalloff == 1 ? falloff : falloff * falloff) * coneFalloff * photometric;
+      /* A light's own exponent already is its whole curve; the frame's smooth rule squares its own. */
+      float shape =
+        (lightExponent > 0.0 || uLightFalloff == 1 ? falloff : falloff * falloff) *
+        coneFalloff *
+        photometric;
       glassGlow += lightColor * backNdl * shape * lightWeight * shaded * lampGlass;
       if (ndl <= 0.0 && !modelledBehind) continue;
       /*
@@ -1584,16 +1633,15 @@ export const MAIN_GLSL = `void main() {
       if (vSpecular > 0.0 || metal > 0.0) {
         vec3 toEyeLamp = normalize(uCameraPos - vWorldPos);
         vec3 lampHalfway = normalize(toLight / max(dist, 1e-4) + toEyeLamp);
-        /* The same grazing whitening the sun's highlight takes, and zero at metal 0. */
-        vec3 lampSpec = mix(
-          specColor,
-          vec3(1.0),
-          pow(1.0 - max(dot(toEyeLamp, lampHalfway), 0.0), 5.0) * metal
-        );
+        /* The same grazing whitening the sun's highlight takes, and zero at metal 0 for the look. */
+        vec3 lampSpec = highlightTint(specColor, max(dot(toEyeLamp, lampHalfway), 0.0), metal);
+        /* The look's lobe, or GGX's own where the surface asks for it: see \`physicalLobe\`. */
+        float lampNdh = max(dot(n, lampHalfway), 0.0);
+        float lampLobe = physicalSpecular()
+          ? physicalLobe(lampNdh, ndl, dot(n, toEyeLamp), surfaceRoughness, lightSourceRadius, dist)
+          : sphereLobe(lampNdh, surfaceRoughness, lightSourceRadius, dist);
         /* Held back with the diffuse half, and shadowed by the same term it always was. */
-        vec3 lampHighlight =
-          lightColor * sphereLobe(max(dot(n, lampHalfway), 0.0), surfaceRoughness, lightSourceRadius, dist)
-          * lampSpec * shape * lightWeight;
+        vec3 lampHighlight = lightColor * lampLobe * lampSpec * shape * lightWeight;
         lampOpen += lampHighlight;
         lampShadowed += lampHighlight * shaded * lampGlass;
       }
@@ -1637,10 +1685,18 @@ export const MAIN_GLSL = `void main() {
       vec3 centre = uAreaLightPos[a];
       vec3 right = uAreaLightRight[a];
       vec3 up = uAreaLightUp[a];
-      vec2 halfSize = uAreaLightSize[a];
+      vec2 halfSize = uAreaLightSize[a].xy;
+      /*
+       * **The part of the rectangle this fragment sees past its barn doors** (\`areaBarnDoors\`),
+       * which its light and highlight come from. Its shadow keeps the whole rectangle's centre and
+       * size below, because that is what its map was baked from.
+       */
+      vec3 seenCentre = centre;
+      vec2 seenHalf = halfSize;
+      if (!areaBarnDoors(seenCentre, right, up, seenHalf, uAreaLightSize[a].zw)) continue;
 
       /* The form factor and its sign, which is the sidedness: see \`areaSignedForm\`. */
-      float signedForm = areaSignedForm(n, centre, right, up, halfSize);
+      float signedForm = areaSignedForm(n, seenCentre, right, up, seenHalf);
       float form = mix(max(0.0, signedForm), abs(signedForm), uAreaLightTwoSided[a]);
       /* The form factor is linear in the normal, so the one seen from behind is its negation. */
       float backForm = glassTransmission > 0.0
@@ -1757,7 +1813,7 @@ export const MAIN_GLSL = `void main() {
       if (form <= 0.0) continue;
       /* The diffuse, the model's answer or the lobe integrated over the rectangle: see areaLight.ts. */
       areaLightAdd(
-        centre, right, up, halfSize, uAreaLightColor[a], form, areaOccl, areaGlass,
+        seenCentre, right, up, seenHalf, uAreaLightColor[a], form, areaOccl, areaGlass,
         n, albedo, metal, specColor, surfaceRoughness, modelled, lampOpen, lampShadowed
       );
     }
@@ -1905,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
     /*
@@ -2103,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);
 }
 `;