@driftengine/core 4.3.0 → 4.4.1

package/src/render/shaders/depth.ts

@@ -1,4 +1,5 @@
 import { resolveConditionals } from './conditionals.ts';
+import { CUTOUT_COVERAGE_GLSL } from './cutoutCoverage.ts';
 import { SKINNING_GLSL } from './skinning.ts';
 import { CHANNEL_ATTRIBUTE, CHANNEL_BEND } from './vertexChannel.ts';
 
@@ -56,7 +57,22 @@ ${CHANNEL_ATTRIBUTE}
 ${CHANNEL_BEND}
 #endif
 
+#if CUTOUT
+/*
+ * **What a cutout caster adds, and where.** The UV at location 5, where every mesh carries it; two
+ * uniforms declared after every other, so no field of the plain variant moves and a binder written
+ * against it stays right for this one; and two outputs after vLightPosition, which keeps location 0.
+ */
+layout(location = 5) in vec2 aUv;
+uniform vec2 uUvScale;
+uniform float uAlphaCutout;
+#endif
+
 out vec4 vLightPosition;
+#if CUTOUT
+out vec2 vUv;
+flat out float vAlphaCutout;
+#endif
 
 void main() {
 #if SKINNED
@@ -80,20 +96,24 @@ void main() {
 #endif
   vLightPosition = uLightViewProj * vec4(bent, world.w);
   gl_Position = vLightPosition;
+#if CUTOUT
+  vUv = aUv * uUvScale;
+  vAlphaCutout = uAlphaCutout;
+#endif
 }
 `;
 
 /** The rigid variant: the world, a prop, a mesh with no rig behind it. */
 export const DEPTH_VERT = resolveConditionals(
   DEPTH_VERT_SOURCE,
-  { SKINNED: false, INSTANCED: false },
+  { SKINNED: false, INSTANCED: false, CUTOUT: false },
   'depth',
 );
 
 /** The skinned variant, which reads a joint palette and moves the vertex by it. */
 export const DEPTH_SKINNED_VERT = resolveConditionals(
   DEPTH_VERT_SOURCE,
-  { SKINNED: true, INSTANCED: false },
+  { SKINNED: true, INSTANCED: false, CUTOUT: false },
   'depth-skinned',
 );
 
@@ -107,10 +127,32 @@ export const DEPTH_SKINNED_VERT = resolveConditionals(
  */
 export const DEPTH_INSTANCED_VERT = resolveConditionals(
   DEPTH_VERT_SOURCE,
-  { SKINNED: false, INSTANCED: true },
+  { SKINNED: false, INSTANCED: true, CUTOUT: false },
   'depth-instanced',
 );
 
+/**
+ * The variants a cutout caster casts through: a leaf card, a chain link, a fence, whose shape is in
+ * its texture's alpha rather than in its geometry.
+ *
+ * **Variants, not a uniform gate on the plain program**, for this file's own reason: a gate would
+ * need the UV, a varying and a bound texture on every opaque caster, and a branch on a varying is
+ * not provably uniform, which forbids the implicit derivative the sample below wants. A variant
+ * leaves every opaque caster byte for byte as it was. What it costs is one more program each, and
+ * a skinned cutout, which nothing has asked for, is not among them.
+ */
+export const DEPTH_CUTOUT_VERT = resolveConditionals(
+  DEPTH_VERT_SOURCE,
+  { SKINNED: false, INSTANCED: false, CUTOUT: true },
+  'depth-cutout',
+);
+
+export const DEPTH_INSTANCED_CUTOUT_VERT = resolveConditionals(
+  DEPTH_VERT_SOURCE,
+  { SKINNED: false, INSTANCED: true, CUTOUT: true },
+  'depth-instanced-cutout',
+);
+
 export const DEPTH_FRAG = `#version 300 es
 precision highp float;
 in vec4 vLightPosition;
@@ -129,3 +171,38 @@ void main() {
   }
 }
 `;
+
+/**
+ * The cutout caster's depth: the plain pass, and a texel of alpha under the cutoff writes nothing.
+ *
+ * **The sample is the first statement, in uniform control flow**, so its implicit derivative picks
+ * the mip the shadow map's texel footprint wants; inside a branch it would be undefined (AGENTS.md,
+ * 2026-08-07). The peel's own sample becomes an explicit-level fetch for the same reason, and is
+ * bit for bit what it was: that map has one level and a nearest sampler. The discard is last, so
+ * nothing samples after it.
+ *
+ * `uCutoutMap` is declared after `uPreviousShadowMap`, so the peel keeps its bindings and the cutout
+ * map takes the next.
+ */
+export const DEPTH_CUTOUT_FRAG = `#version 300 es
+precision highp float;
+in vec4 vLightPosition;
+in vec2 vUv;
+flat in float vAlphaCutout;
+
+uniform highp sampler2D uPreviousShadowMap;
+uniform int uPeelShadowLayer;
+uniform highp sampler2D uCutoutMap;
+${CUTOUT_COVERAGE_GLSL}
+void main() {
+  /* Credited for its mip level as the surface's own test is, so a leaf casts the shape it draws. */
+  float alpha = cutoutAlpha(texture(uCutoutMap, vUv).a, vUv * vec2(textureSize(uCutoutMap, 0)));
+  if (uPeelShadowLayer != 0) {
+    vec3 p = vLightPosition.xyz / vLightPosition.w;
+    vec2 uv = p.xy * 0.5 + 0.5;
+    float previousDepth = textureLod(uPreviousShadowMap, uv, 0.0).r;
+    if (gl_FragCoord.z <= previousDepth + 0.00001) discard;
+  }
+  if (alpha < vAlphaCutout) discard;
+}
+`;

package/src/render/shaders/exposure.ts

@@ -0,0 +1,128 @@
+/**
+ * Eye adaptation: the frame's own brightness, measured on the GPU and followed over time.
+ *
+ * **A fixed exposure is right for one view and wrong for the next.** A courtyard with the sun on
+ * its upper walls and its floor in the shade of a 19 m wall is several stops darker at ground level
+ * than from the gallery, and an exposure set for one draws the other either clipped or black. A
+ * camera meters and an eye adapts; this does both, from the finished scene, with no readback.
+ *
+ * **Two passes, both tiny.** The meter writes a 32×32 grid, each texel the mean of 8×8 taps of log
+ * luminance over its share of the frame. The adaptation reads all 1,024 of them in one texel,
+ * averages them into the frame's log-mean luminance, and moves the held value toward it by a blend
+ * the caller's frame time decides. The composite reads the held value and scales the scene toward
+ * middle grey. Log luminance, because an eye's response is to ratios: one sunlit pixel beside a
+ * dark frame should not set the exposure the way an arithmetic mean lets it.
+ *
+ * What it gives up is metering by region: every pixel counts the same, so a small bright window in
+ * a dark room pulls less than a photographer's spot meter would. What would change it is a scene
+ * that needs a subject held at a brightness, and the answer then is a centre weight in the meter.
+ */
+
+/** Texels a side in the meter's grid, and taps a side within each. */
+export const METER_GRID = 32;
+export const METER_TAPS = 8;
+/** The luminance the meter clamps to, in stops: a black pixel is not minus infinity. */
+export const METER_MIN_LOG2 = -12;
+export const METER_MAX_LOG2 = 8;
+/** What full adaptation brings the frame's log-mean luminance to: middle grey. */
+export const ADAPTED_KEY = 0.18;
+/** The furthest adaptation moves the exposure either way, in stops. A black loading screen is not a
+ *  reason to multiply the next frame by a thousand. */
+export const ADAPT_RANGE_STOPS = 6;
+/**
+ * How fast the held brightness follows the measured one, per second: 1.5 closes about 78% of the
+ * way in a second. An eye takes longer to open than to close, and a camera's meter is faster than
+ * either; one rate is what a scene that cuts between shots can predict.
+ */
+export const ADAPT_RATE = 1.5;
+
+export const EXPOSURE_METER_FRAG = `#version 300 es
+precision highp float;
+
+in vec2 vUv;
+
+/** The finished scene, in scene light, before any exposure or curve. */
+uniform highp sampler2D uScene;
+
+out float fragColor;
+
+void main() {
+  /* This texel's corner, and taps spread evenly over its share of the frame. */
+  vec2 corner = vUv - vec2(0.5 / ${METER_GRID.toFixed(1)});
+  float sum = 0.0;
+  for (int y = 0; y < ${METER_TAPS}; y++) {
+    for (int x = 0; x < ${METER_TAPS}; x++) {
+      vec2 uv = corner + (vec2(float(x), float(y)) + 0.5) / ${(METER_GRID * METER_TAPS).toFixed(1)};
+      vec3 c = textureLod(uScene, uv, 0.0).rgb;
+      float luma = dot(c, vec3(0.2126, 0.7152, 0.0722));
+      sum += clamp(log2(max(luma, 1e-8)), ${METER_MIN_LOG2.toFixed(1)}, ${METER_MAX_LOG2.toFixed(1)});
+    }
+  }
+  fragColor = sum / ${(METER_TAPS * METER_TAPS).toFixed(1)};
+}
+`;
+
+export const EXPOSURE_ADAPT_FRAG = `#version 300 es
+precision highp float;
+
+/** The meter's grid of log luminances. */
+uniform highp sampler2D uMeter;
+/** The brightness held from the frames before, in stops, one texel. */
+uniform highp sampler2D uHeld;
+/** How far toward this frame's measurement to move: 1 snaps, 0 holds. */
+uniform float uBlend;
+
+out float fragColor;
+
+void main() {
+  float sum = 0.0;
+  for (int y = 0; y < ${METER_GRID}; y++) {
+    for (int x = 0; x < ${METER_GRID}; x++) {
+      sum += texelFetch(uMeter, ivec2(x, y), 0).r;
+    }
+  }
+  float measured = sum / ${(METER_GRID * METER_GRID).toFixed(1)};
+  float held = texelFetch(uHeld, ivec2(0, 0), 0).r;
+  fragColor = mix(held, measured, uBlend);
+}
+`;
+
+/**
+ * `uAutoExposure`, `uExposureHeld` and `autoExposureGain`, for the composite. The gain scales scene
+ * light before the tone curve, toward the key by the fraction the caller asked for.
+ */
+export const AUTO_EXPOSURE_GLSL = `
+/** How far the frame adapts toward middle grey, 0 to 1. 0 is off and the whole of the off path. */
+uniform float uAutoExposure;
+/** The held log-mean luminance, in stops, one texel. */
+uniform highp sampler2D uExposureHeld;
+
+float autoExposureGain() {
+  if (uAutoExposure <= 0.0) return 1.0;
+  float held = texelFetch(uExposureHeld, ivec2(0, 0), 0).r;
+  float stops = uAutoExposure * (${Math.log2(ADAPTED_KEY).toFixed(6)} - held);
+  return exp2(clamp(stops, -${ADAPT_RANGE_STOPS.toFixed(1)}, ${ADAPT_RANGE_STOPS.toFixed(1)}));
+}
+`;
+
+/**
+ * The fraction of the way toward this frame's measurement to move, after `dtSec` seconds. A cut,
+ * or a first frame with nothing held, snaps.
+ */
+export function adaptBlend(dtSec: number, snap: boolean): number {
+  if (snap) return 1;
+  if (!(dtSec > 0)) return 0;
+  return 1 - Math.exp(-ADAPT_RATE * dtSec);
+}
+
+/** The scene's gain for a held log-mean `heldLog2` at `strength`, as the composite computes it. */
+export function autoExposureGain(heldLog2: number, strength: number): number {
+  if (!(strength > 0)) return 1;
+  const stops = strength * (Math.log2(ADAPTED_KEY) - heldLog2);
+  return 2 ** Math.min(Math.max(stops, -ADAPT_RANGE_STOPS), ADAPT_RANGE_STOPS);
+}
+
+/** An adaptation strength as the shader takes it: 0 to 1, anything else off. */
+export function clampAutoExposure(strength: number): number {
+  return Number.isFinite(strength) ? Math.min(Math.max(strength, 0), 1) : 0;
+}

package/src/render/shaders/filmLook.ts

@@ -0,0 +1,111 @@
+/**
+ * The lens and the print: a vignette in scene light, and grain in display values.
+ *
+ * **The vignette is the lens's, so it acts on light rather than on the picture.** A lens loses light
+ * toward its corners by roughly the fourth power of the cosine of the angle off axis, which for a
+ * point `r` from the centre is `1 / (1 + k r^2)^2`. Applied to scene light before the tone curve,
+ * a bright corner rolls off through the curve's shoulder the way a photographed one does, where a
+ * vignette painted over the finished picture greys it. `r` is measured to the frame's corner on a
+ * circle, not an ellipse, so a wide window is not darker at its sides than at its top.
+ *
+ * **The grain is the print's, so it acts on display values after the grade and the veil.** It is
+ * one value a pixel, the same on all three channels, weighted toward the midtones where film shows
+ * it and kept faint in deep shadow and highlight, where adding it would lift black and grey white.
+ * It also dithers: a dark gradient quantised to eight bits bands, and a noise of a few levels breaks
+ * the bands up. **The seed is the caller's**, because the engine takes time from its caller: a held
+ * capture passes the same seed and is identical run to run, and a playing scene passes a new one
+ * each frame and the grain moves as film does.
+ *
+ * Zero strength for each is the whole of its off path: a branch on a uniform, and the frame is what
+ * it was byte for byte.
+ */
+
+/**
+ * `uVignette`, `uGrain`, `withVignette` and `withGrain`. The rush composite includes it once.
+ *
+ * `withVignette` takes the pixel's coordinate and the scene's size, since a distance to the corner
+ * has to know the aspect. `withGrain` takes the fragment's integer position, so the grain is one
+ * value a pixel whatever the resolution.
+ */
+export const FILM_LOOK_GLSL = `
+/** How strongly the lens darkens its corners: 0 is none, 0.5 about 1.2 stops at the corner. */
+uniform float uVignette;
+/** x: the grain's amplitude in display values, 0 for none. y: this frame's seed, the caller's. */
+uniform vec2 uGrain;
+
+vec3 withVignette(vec3 c, vec2 uv, vec2 size) {
+  if (uVignette <= 0.0) return c;
+  vec2 d = (uv - 0.5) * size;
+  vec2 corner = 0.5 * size;
+  float r2 = dot(d, d) / dot(corner, corner);
+  float falloff = 1.0 + uVignette * r2;
+  return c / (falloff * falloff);
+}
+
+float grainNoise(uvec2 p, uint seed) {
+  uint h = p.x * 1664525u + p.y * 1013904223u + seed * 2654435769u;
+  h ^= h >> 16u;
+  h *= 2246822519u;
+  h ^= h >> 13u;
+  h *= 3266489917u;
+  h ^= h >> 16u;
+  return float(h) * (1.0 / 4294967295.0);
+}
+
+vec3 withGrain(vec3 c, vec2 fragCoord) {
+  if (uGrain.x <= 0.0) return c;
+  float luma = dot(clamp(c, 0.0, 1.0), vec3(0.2126, 0.7152, 0.0722));
+  float weight = 0.25 + 3.0 * luma * (1.0 - luma);
+  float n = grainNoise(uvec2(fragCoord), uint(uGrain.y)) - 0.5;
+  return c + vec3(2.0 * n * uGrain.x * weight);
+}
+`;
+
+/**
+ * The vignette's factor at `uv` on a `width` by `height` frame, as the shader computes it.
+ * The shader's arithmetic written out once more, so a test can pin it to hand-derived values.
+ */
+export function vignetteFactor(
+  u: number,
+  v: number,
+  width: number,
+  height: number,
+  strength: number,
+): number {
+  if (strength <= 0) return 1;
+  const dx = (u - 0.5) * width;
+  const dy = (v - 0.5) * height;
+  const r2 = (dx * dx + dy * dy) / (0.25 * (width * width + height * height));
+  const falloff = 1 + strength * r2;
+  return 1 / (falloff * falloff);
+}
+
+/** How much of the grain a display luminance takes: full in the midtones, a quarter at the ends. */
+export function grainWeight(luma: number): number {
+  const l = Math.min(Math.max(luma, 0), 1);
+  return 0.25 + 3 * l * (1 - l);
+}
+
+/** 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 ' +
+  '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.';
+
+/** A vignette strength as the shader takes it: 0 to 4, anything else off. */
+export function clampVignette(strength: number): number {
+  return Number.isFinite(strength) ? Math.min(Math.max(strength, 0), 4) : 0;
+}
+
+/** A grain amplitude in display values: 0 to 0.5, anything else off. */
+export function clampGrain(strength: number): number {
+  return Number.isFinite(strength) ? Math.min(Math.max(strength, 0), 0.5) : 0;
+}
+
+/**
+ * A seed as the shader reads it: a whole number below 2^24, which a 32-bit float carries exactly,
+ * so the same seed is the same grain on both backends. Any number a caller has is accepted.
+ */
+export function grainSeed(seed: number): number {
+  return Number.isFinite(seed) ? Math.floor(Math.abs(seed)) % 16777216 : 0;
+}

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

@@ -68,10 +68,13 @@ float shadowFactor(float directionalNdl) {
   // Near a surface's own light terminator its direct-light term is already
   // approaching zero, while the orthographic projection of that surface
   // collapses toward a line. No finite contact-safe bias can represent that
-  // slope reliably. Fade only the shadow modulation through this narrow band;
-  // the Lambert term still supplies the physically dominant falloff.
+  // slope reliably, so through this band the fine filter below hands over to the
+  // coarse test after it. \`directionalNdl\` is the surface's own, before any normal
+  // map: the band is about the receiving plane, and a map's tilt says nothing about it.
   float receiverFade = smoothstep(0.08, 0.20, directionalNdl);
-  if (receiverFade <= 0.0) return 1.0;
+  /* A surface turned from the light takes none of it, so there is nothing to shadow; what reads
+     this there is the emissive share, which has always seen such a surface as unshadowed. */
+  if (directionalNdl <= 0.0) return 1.0;
 
   // The receiver stays at its real position, computed above. A normal offset changes
   // direction at a hard mesh edge and tears one continuous shadow where it crosses from
@@ -104,6 +107,34 @@ float shadowFactor(float directionalNdl) {
   );
   if (lowElevationFade <= 0.0) return 1.0;
 
+  /*
+   * **The coarse test: is there anything a metre or more between this point and the sun.**
+   *
+   * One tap at the receiver's own texel, with a metre of tolerance where the filter below allows
+   * fourteen centimetres. It cannot see a contact shadow, and it does not need the plane's slope:
+   * a grazing plane's own depth moves about a centimetre times the tangent of its angle to the
+   * light across a texel, which stays under a metre down to a hundredth of n·l on a map with
+   * centimetre texels. What it does see is a roof.
+   *
+   * **This band used to return fully lit**, on the argument that the Lambert term was already
+   * near zero there. Under a high sun that is every vertical wall: at 70° of elevation a wall's
+   * n·l is at most 0.34, and one turned from the sun's bearing sits inside the band. A gallery's
+   * back wall under its vault took the sun through the vault, and so did the faces of its
+   * columns, which read as lit stone in shade; with a normal map carrying that n·l per texel it
+   * was a field of white specks. What would make this wrong is a map whose texels are tens of
+   * centimetres, where a grazing plane's own depth moves more than the tolerance and the band
+   * draws the acne it exists to avoid.
+   */
+  float coarseCompare = p.z - 1.0 / uShadowDepthSpan;
+  float coarse =
+    directionalVisibility(p.z, coarseCompare, textureLod(uStaticShadowMap, p.xy, 0.0).r) *
+    directionalVisibility(p.z, coarseCompare, textureLod(uDynamicShadowMap, p.xy, 0.0).r);
+  if (uPeeledShadowEnabled != 0) {
+    coarse *= directionalVisibility(p.z, coarseCompare, textureLod(uPeeledShadowMap, p.xy, 0.0).r);
+  }
+  float strength = uShadowStrength * edgeFade * lowElevationFade;
+  if (receiverFade <= 0.0) return mix(1.0, coarse, strength);
+
   float texel = 1.35 / uShadowMapSize;
   /*
    * How far the plane compensation below may carry a tap's depth, in the map's own units.
@@ -182,7 +213,7 @@ float shadowFactor(float directionalNdl) {
   // conventional one-depth map would discard; movers remain independent too.
   float lit = staticLit * peeledLit * dynamicLit;
 
-  return mix(1.0, lit, uShadowStrength * edgeFade * lowElevationFade * receiverFade);
+  return mix(1.0, mix(coarse, lit, receiverFade), strength);
 }
 #endif
 

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

@@ -0,0 +1,75 @@
+/**
+ * DriftLight in the lit shader: how much of a pixel the summed light stands in for, and the summed
+ * light itself, read from the field's sparse volume.
+ *
+ * **The split is per pixel.** Inside the frame's completeness radius (`uDriftLight.y`, measured from
+ * the eye) every light that reaches the pixel was chosen, so it is shaded exactly; past it the
+ * volume stands in, and across the band before the radius the two crossfade. The choice was made
+ * about some centre, which need not be the eye; `uniforms.ts` takes the distance between the two
+ * off the radius, so a pixel inside it is inside the choice's radius too. A field light's
+ * exact contribution is scaled by the share left over (`main.ts`, where its weight's sign is read),
+ * so a light is counted once however the pixel is split.
+ *
+ * **One index fetch and two filtered ones.** The index finds the brick; the brick's four samples a
+ * side share their faces with the next brick's, so the hardware's trilinear lookup inside one is
+ * seamless across the join. The light texel carries in its fourth channel whether each sample is a
+ * sample at all, and dividing by the filtered value drops the samples buried in walls rather than
+ * blending their darkness into the surface. The lookup is nudged half a spacing along the normal,
+ * which keeps a surface reading the air in front of it rather than the wall it is part of.
+ *
+ * **Two vectors of uniforms, and the sizes read off the textures.** The lit stage sits two vectors
+ * under the 256 a reported part offers at eight lights, and the first cut of this, at five, took that
+ * part down a rung to four. So the grid's extent and the atlas's are what `textureSize` answers, and
+ * the radius is measured from `uCameraPos`, which the stage already has, rather than from a centre
+ * of its own. What it gives up is two integer queries a pixel past the radius.
+ *
+ * `textureLod` throughout, by the 2026-08-07 rule: this is reached through branches no compiler can
+ * prove uniform. Both samplers are declared `highp` because GLSL ES gives 3D samplers no default.
+ */
+export const DRIFT_LIGHT_GLSL = /* glsl */ `
+/** x how much of the summed light is in the frame (0 off), y the radius, z the band, w the scale. */
+uniform vec4 uDriftLight;
+/** xyz the first brick's first sample; w metres between samples, a third of a brick. */
+uniform vec4 uDriftLightOrigin;
+uniform highp usampler3D uDriftLightIndex;  // wgsl:share shadow
+uniform highp sampler3D uDriftLightAtlas;
+
+/** The share of this pixel's field light the volume stands in for: 0 inside the radius, 1 past it. */
+float driftLightShare(vec3 world) {
+  if (uDriftLight.x <= 0.0) return 0.0;
+  float away = distance(world, uCameraPos);
+  return smoothstep(uDriftLight.y - uDriftLight.z, uDriftLight.y, away) * uDriftLight.x;
+}
+
+/** The summed light arriving on a surface at \`world\` facing \`n\`. */
+vec3 driftLightIrradiance(vec3 world, vec3 n) {
+  float spacing = uDriftLightOrigin.w;
+  vec3 at = (world + n * (0.5 * spacing) - uDriftLightOrigin.xyz) / (3.0 * spacing);
+  ivec3 cell = ivec3(floor(at));
+  if (any(lessThan(cell, ivec3(0))) || any(greaterThanEqual(cell, textureSize(uDriftLightIndex, 0)))) {
+    return vec3(0.0);
+  }
+  uint id = texelFetch(uDriftLightIndex, cell, 0).r;
+  if (id == 0u) return vec3(0.0);
+  /* A brick is eight texels across (its light block, then its direction block) and four up and deep. */
+  ivec3 size = textureSize(uDriftLightAtlas, 0);
+  int brick = int(id) - 1;
+  int across = size.x / 8;
+  int down = size.y / 4;
+  vec3 corner = vec3(
+    float((brick % across) * 8),
+    float(((brick / across) % down) * 4),
+    float((brick / (across * down)) * 4)
+  );
+  vec3 texel = 1.0 / vec3(size);
+  vec3 inside = (at - vec3(cell)) * 3.0 + 0.5;
+  vec4 light = textureLod(uDriftLightAtlas, (corner + inside) * texel, 0.0);
+  if (light.a < 1e-3) return vec3(0.0);
+  vec4 toward = textureLod(uDriftLightAtlas, (corner + vec3(4.0, 0.0, 0.0) + inside) * texel, 0.0);
+  vec3 arriving = light.rgb / light.a;
+  vec3 from = toward.xyz / light.a;
+  /* Lambert for a single light, a quarter for light arriving from everywhere: see \`bake.ts\`. */
+  float facing = max(dot(n, from), 0.0) + (1.0 - min(length(from), 1.0)) * 0.25;
+  return arriving * facing;
+}
+`;

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

@@ -2,6 +2,7 @@ import { resolveConditionals } from '../conditionals.ts';
 import { OCTAHEDRAL_GLSL } from '../octahedral.ts';
 import { PROBEGRID_GLSL } from './probeGrid.ts';
 import { TANGENT_FRAME_GLSL } from '../tangentFrame.ts';
+import { CUTOUT_COVERAGE_GLSL } from '../cutoutCoverage.ts';
 import { preambleGlsl } from './preamble.ts';
 import { LOBES_GLSL } from './lobes.ts';
 import { POINTSHADOW_GLSL } from './pointShadow.ts';
@@ -10,6 +11,7 @@ import { MORPH_GLSL } from '../morph.ts';
 import { SKINNING_GLSL } from '../skinning.ts';
 import { SURFACE_GLSL } from './surface.ts';
 import { MAIN_GLSL } from './main.ts';
+import { DRIFT_LIGHT_GLSL } from './driftLight.ts';
 import { CHANNEL_ATTRIBUTE, CHANNEL_BEND } from '../vertexChannel.ts';
 import { FULL_LIGHT_BUDGET, type LightBudget } from '../../uniformVectorBudget.ts';
 
@@ -489,6 +491,9 @@ export function flatFrag(options: FlatShaderOptions): string {
        * and `main` is unconditional by construction.
        */
       TANGENT_FRAME_GLSL,
+      /* Unconditional for the same reason, and called only where a cutoff was asked for. */
+      CUTOUT_COVERAGE_GLSL,
+      DRIFT_LIGHT_GLSL,
       MAIN_GLSL,
     ].join('\n'),
     {

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

@@ -74,6 +74,19 @@ const float PENUMBRA_FADE = 1.6;
  */
 const float MAX_FILTER_RADIUS = 0.25;
 
+/**
+ * The weight below which a point light's shadow is not looked up at all.
+ *
+ * A light's shadow is blended toward none as the light falls off, \`mix(1, occl, weight)\` with the
+ * weight twice the falloff, so a shadow looked up under this floor changes at most three per cent
+ * of a light that has already all but faded: with the inverse-square falloff, past about eight
+ * metres from it. Measured on a lantern-lit courtyard, the lookups the floor skips were most of a
+ * night's frame: 14 ms of 26 at 1440p, a blocker tap and twelve filter taps for every light in every
+ * froxel. What it gives up is the last three per cent of a distant light's shadow, which the blend
+ * was already taking away; what would make it wrong is a falloff that stays strong far out.
+ */
+const float POINT_SHADOW_MIN_WEIGHT = 0.03;
+
 /**
  * How much of a self-lit surface's glow a lamp's shadow may take.
  *