@driftengine/core 4.13.3 → 4.13.5

package/src/render/hairLobes.ts

@@ -50,6 +50,17 @@ export const HAIR_MIN_BETA = 0.05;
  */
 export const HAIR_SCATTER_SPHERE = 1.33;
 
+/**
+ * How far every lobe is widened for light from every side, in radians: the angle a source would
+ * subtend to widen them as much, `sourceRadius / 2·dist` in `hairLight`'s terms.
+ *
+ * **0.2, the real-time form's own value**, which stands one direction in for the sphere: a lobe as
+ * narrow as a lamp's would put the whole sky's light into one highlight wherever the eye's
+ * direction happens to meet it. What it gives up is the sky's shape: a sun low in a clear sky and
+ * an even overcast light hair through the same widened lobes.
+ */
+export const HAIR_AREA = 0.2;
+
 /** How much the scatter term leans toward the strand's own direction rather than the pseudo-normal. */
 const KAJIYA_SHARE = 0.33;
 
@@ -80,7 +91,9 @@ export const HAIR_OUT = { r: 0, tt: 1, trt: 4, scatter: 7, length: 10 } as const
 /**
  * One light on a strand, in lamp units and unshadowed, into `out` (`HAIR_OUT`'s layout: R is grey,
  * the rest colours). `tangent`, `toLight` and `toEye` are unit vectors but for a tangent that could
- * not be made one, which comes in as zeros; `fibre` is the base colour.
+ * not be made one, which comes in as zeros; `fibre` is the base colour; `specular` is the strand's,
+ * the model map's red, which scales the reflected lobe by twice it, so 0.5 draws the lobe as the
+ * fit gives it and 0 is a strand that reflects nothing off its surface.
  *
  * **A lamp with a size widens every lobe by the angle it subtends**, `sourceRadius / 2·dist` as
  * `sphereLobe` takes it, and the lobes are normalised Gaussians, so a wider one carries the same
@@ -93,11 +106,103 @@ export function hairLight(
   fibre: Vec3,
   roughness: number,
   shift: number,
+  specular: number,
   scatter: number,
   backlit: number,
   sourceRadius: number,
   dist: number,
   out: Float64Array,
+): void {
+  const grow = sourceRadius / Math.max(2 * dist, 1e-3);
+  hairLobes(
+    tangent,
+    toLight,
+    toEye,
+    fibre,
+    roughness,
+    shift,
+    specular,
+    scatter,
+    backlit,
+    grow,
+    out,
+  );
+}
+
+/** The flattened eye `hairIndirect` lights a strand along, as the shader finds it. */
+const flattened = new Float64Array(3);
+
+/**
+ * The share of light from every side a strand returns, a colour into `out`, with the one
+ * direction's lobes it is made of into `lobes` (`HAIR_OUT`'s layout). `normal` is the surface's,
+ * which stands in for the flattened eye where the eye runs along the strand and there is none.
+ *
+ * **One direction for the sphere**: the eye flattened across the strand, `V − T(V·T)`, unshadowed,
+ * with no light from behind and so no transmitted lobe, every lobe widened by `HAIR_AREA`. Twice
+ * the sum, and at most all of what arrives. **Why twice**: the scatter's half is then
+ * `HAIR_SCATTER_SPHERE`, its own answer to an even sky — along the flattened eye its shape is
+ * `mix(1/2, 1, 0.33)`, 0.665, which doubled is that constant's 1.33 — so the lobes ride on a
+ * scatter the sphere's quadrature already holds to, and R and TRT are what the direction adds.
+ */
+export function hairIndirect(
+  tangent: ArrayLike<number>,
+  toEye: ArrayLike<number>,
+  normal: ArrayLike<number>,
+  fibre: Vec3,
+  roughness: number,
+  shift: number,
+  specular: number,
+  scatter: number,
+  lobes: Float64Array,
+  out: Float64Array,
+): void {
+  const along = dot(tangent, toEye);
+  let length2 = 0;
+  for (let c = 0; c < 3; c++) {
+    const across = (toEye[c] as number) - (tangent[c] as number) * along;
+    flattened[c] = across;
+    length2 += across * across;
+  }
+  for (let c = 0; c < 3; c++) {
+    flattened[c] =
+      length2 > 1e-8 ? (flattened[c] as number) / Math.sqrt(length2) : (normal[c] as number);
+  }
+  hairLobes(
+    tangent,
+    flattened,
+    toEye,
+    fibre,
+    roughness,
+    shift,
+    specular,
+    scatter,
+    0,
+    HAIR_AREA,
+    lobes,
+  );
+  for (let c = 0; c < 3; c++) {
+    const sum =
+      (lobes[HAIR_OUT.r] as number) +
+      (lobes[HAIR_OUT.tt + c] as number) +
+      (lobes[HAIR_OUT.trt + c] as number) +
+      (lobes[HAIR_OUT.scatter + c] as number);
+    out[c] = Math.min(1, 2 * sum);
+  }
+}
+
+/** `hairLight`'s arithmetic, every lobe widened by `grow` radians. */
+function hairLobes(
+  tangent: ArrayLike<number>,
+  toLight: ArrayLike<number>,
+  toEye: ArrayLike<number>,
+  fibre: Vec3,
+  roughness: number,
+  shift: number,
+  specular: number,
+  scatter: number,
+  backlit: number,
+  grow: number,
+  out: Float64Array,
 ): void {
   const sinI = clamp(dot(tangent, toLight), -1, 1);
   const sinO = clamp(dot(tangent, toEye), -1, 1);
@@ -124,14 +229,15 @@ export function hairLight(
   const cosPhi = lpvp / Math.sqrt(lp2 * vp2 + 1e-4);
   const cosHalfPhi = Math.sqrt(clamp(0.5 + 0.5 * cosPhi, 0, 1));
   const beta = Math.max(roughness * roughness, HAIR_MIN_BETA);
-  const grow = sourceRadius / Math.max(2 * dist, 1e-3);
   const x = sinI + sinO;
 
   const r =
     hairLongitudinal(beta + grow, x + 2 * shift) *
     0.25 *
     cosHalfPhi *
-    hairFresnel(Math.sqrt(clamp(0.5 + 0.5 * dot(toLight, toEye), 0, 1)));
+    hairFresnel(Math.sqrt(clamp(0.5 + 0.5 * dot(toLight, toEye), 0, 1))) *
+    2 *
+    specular;
 
   const a = 1 / (1.19 / cosD + 0.36 * cosD);
   const h = cosHalfPhi * (1 + a * (0.6 - 0.8 * cosPhi));

package/src/render/lightBudget.ts

@@ -427,6 +427,13 @@ export interface PointLightSet {
    * falls off as it did. See `PointLightSource.falloffExponent`.
    */
   readonly lightFalloffExponents?: Float32Array;
+  /**
+   * One per light: how strongly it scatters in the global medium, as a share of how strongly it
+   * lights a surface, beside `setGlobalMedium`'s `lampScatter` for every lamp at once. **Absent, or
+   * a short array, is 1 for every light.** A lamp turned up here lights a fog bank brighter than it
+   * lights the floor in it, which is how a lamp authored for its shaft rather than its pool reads.
+   */
+  readonly lightMediumScatter?: Float32Array;
 }
 
 /** Weights are optional per consumer; a short array means every light is fully present. */
@@ -637,6 +644,31 @@ export interface ResolvedPointLights {
   readonly heldWeights: Float32Array;
 }
 
+/**
+ * A target for `resolvePointLights`, made once outside the frame loop. Its arrays are references
+ * the resolve points at the caller's own or at the defaults, but for the four it owns.
+ */
+export function createResolvedPointLights(): ResolvedPointLights {
+  return {
+    count: 0,
+    falloff: 0,
+    positions: NO_POSITIONS,
+    colors: NO_COLORS,
+    radii: POINT_SOURCES,
+    sourceRadii: POINT_SOURCES,
+    weights: FULLY_PRESENT,
+    directions: NO_DIRECTIONS,
+    coneCos: OPEN_CONES,
+    iesProfiles: NO_PROFILES,
+    iesAxes: NO_IES_AXES,
+    cookies: NO_COOKIES,
+    axesAndChannels: new Float32Array(MAX_POINT_LIGHTS * 4),
+    conesAndFalloffs: new Float32Array(MAX_POINT_LIGHTS * 4),
+    heldSourceRadii: new Float32Array(MAX_POINT_LIGHTS),
+    heldWeights: new Float32Array(MAX_POINT_LIGHTS),
+  };
+}
+
 /** One per GL binder, refilled per call: holds references, allocates nothing. */
 const glLights: ResolvedPointLights = {
   count: 0,

package/src/render/sceneTarget.ts

@@ -4,7 +4,8 @@ import { FRINGE_FLOATS, resolveFringe } from './shaders/fringe.ts';
 import { AmbientOcclusionPass } from './ambientOcclusionPass.ts';
 import { ExposurePass } from './exposurePass.ts';
 import { clampAutoExposure } from './shaders/exposure.ts';
-import { clampLocalExposure } from './shaders/localExposure.ts';
+import { LOCAL_EXPOSURE_FLOATS, resolveLocalExposure } from './shaders/localExposure.ts';
+import type { LocalExposureOptions } from './shaders/localExposure.ts';
 import { BloomPass } from './bloomPass.ts';
 import {
   type ColourGradeLut,
@@ -107,8 +108,9 @@ export class SceneTarget {
   /** Eye adaptation: how far, and this frame's time step. See `Renderer.setAutoExposure`. */
   private autoExposure = 0;
   private autoExposureDt = 0;
-  /** How far each region is brought toward the frame. See `Renderer.setLocalExposure`. */
-  private localExposure = 0;
+  /** Whether regions move, and how, as `resolveLocalExposure` packs it. See `setLocalExposure`. */
+  private localExposure = false;
+  private readonly localExposureShape = new Float32Array(LOCAL_EXPOSURE_FLOATS);
   private exposure: ExposurePass | null = null;
   private width = 0;
   private height = 0;
@@ -722,9 +724,9 @@ export class SceneTarget {
     this.autoExposureDt = dtSec;
   }
 
-  /** How far each region is brought toward the frame. See `Renderer.setLocalExposure`. */
-  setLocalExposure(strength: number): void {
-    this.localExposure = clampLocalExposure(strength);
+  /** How regions are brought toward the frame. See `Renderer.setLocalExposure`. */
+  setLocalExposure(setting: number | LocalExposureOptions): void {
+    this.localExposure = resolveLocalExposure(setting, this.localExposureShape);
   }
 
   /** A new shot: the eye meters it afresh rather than easing in from the last one. */
@@ -1011,7 +1013,7 @@ export class SceneTarget {
      * reason: the composite consumes it. Off at zero strength, where nothing is allocated or drawn.
      */
     let heldExposure: WebGLTexture | null = null;
-    const local = this.localExposure > 0;
+    const local = this.localExposure;
     if ((this.autoExposure > 0 || local) && scene !== null) {
       this.exposure ??= new ExposurePass(gl);
       heldExposure = this.exposure.run(scene, this.autoExposureDt, local);
@@ -1136,10 +1138,12 @@ export class SceneTarget {
     gl.activeTexture(gl.TEXTURE6);
     gl.bindTexture(gl.TEXTURE_2D, localGrid ?? scene);
     gl.uniform1i(this.uniforms['uExposureLocal'] ?? null, 6);
-    gl.uniform1f(
-      this.uniforms['uLocalExposure'] ?? null,
-      localGrid === null ? 0 : this.localExposure,
-    );
+    gl.uniform1f(this.uniforms['uLocalExposure'] ?? null, localGrid === null ? 0 : 1);
+    /* Its shape only where it is on: off, the shader returns before reading it. */
+    if (localGrid !== null) {
+      gl.uniform4fv(this.uniforms['uLocalShape'] ?? null, this.localExposureShape, 0, 4);
+      gl.uniform4fv(this.uniforms['uLocalPivot'] ?? null, this.localExposureShape, 4, 4);
+    }
     /* 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);

package/src/render/shaders/film.ts

@@ -211,8 +211,11 @@ void main() {
   // 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 glow = mediumGlow(length(uCameraPos - vWorld), vWorld.y, normalize(vWorld - uCameraPos));
+  /* The air the mirror recedes into takes no glow: the mirror is mixed toward it by the fog, which
+     would lay the glow by the fog's share a second time over the surface's own. */
   vec3 gradedAir = applyOutputTransform(mediumColor());
-  vec3 graded = applyOutputTransform(mix(color, mediumColor(), fog));
+  vec3 graded = applyOutputTransform(mix(color, mediumColor(), fog) + glow);
 
   /*
    * The mirrored scene, under the sheen rather than instead of it.

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

@@ -11,20 +11,30 @@
  *
  * Lamps widen both of the lobe's widths by the source's angle, as `sphereLobe` widens the standard
  * lobe, with the energy kept; at strength 0 that is `sphereLobe` exactly.
+ *
+ * **A lift**, where the model asks for one: the distribution raised where it is bright, `D +
+ * min(3, D^1.5) · k`, which is how a brushed finish that reads as polished in its streak is
+ * authored. `k` is the model's `lift`, times the model map's alpha where one is bound, so it can
+ * vary texel by texel. Applied as a factor of the distribution at the half vector, so the
+ * peak-normalised lobe and the physical one lift alike. **What it gives up** is energy: a lifted
+ * lobe returns more than arrives, which is the look it is for.
  */
 export const ANISOTROPIC_GLSL = /* glsl */ `
-/* The stretch's frame and strength, gathered once with the surface. */
+/* The stretch's frame, strength and lift, gathered once with the surface. */
 vec3 aAlong;
 vec3 aAcross;
 float aStrength;
+float aLift;
 
 void anisotropicSurface() {
   vec2 direction = vec2(1.0, 0.0);
   float strength = uModelParams[0].x;
+  aLift = uModelParams[0].w;
   if (uModelParams[1].w > 0.0) {
     vec2 mapped = mMap.rg * 2.0 - 1.0;
     direction = dot(mapped, mapped) > 1e-8 ? normalize(mapped) : direction;
     strength *= mMap.b;
+    aLift *= mMap.a;
   }
   vec2 turned = vec2(
     direction.x * uModelParams[0].y - direction.y * uModelParams[0].z,
@@ -44,6 +54,17 @@ void anisotropicSurface() {
   aStrength = strength;
 }
 
+/**
+ * How much the lift brightens the lobe at a half vector, from the stretched distribution there, D,
+ * at widths \`along\` and \`across\` and \`d\` its denominator's root: \`(D + min(3, D^1.5) k) / D\`.
+ * anisotropicLiftFactor in anisotropicLobe.ts.
+ */
+float anisotropicLift(float along, float across, float d) {
+  if (aLift <= 0.0) return 1.0;
+  float distribution = 1.0 / max(3.14159265 * along * across * d * d, 1e-8);
+  return 1.0 + aLift * min(3.0 / distribution, sqrt(distribution));
+}
+
 /** The stretched lobe at a half vector, 1 at the mirror direction: anisotropicLobe.ts. */
 float anisotropicLobe(vec3 h, float sourceRadius, float dist) {
   float alpha = max(mRoughness * mRoughness, MIN_LOBE_ALPHA);
@@ -56,7 +77,7 @@ float anisotropicLobe(vec3 h, float sourceRadius, float dist) {
   float y = dot(aAcross, h) / acrossWide;
   float z = dot(mNormal, h);
   float d = x * x + y * y + z * z;
-  return energy / max(d * d, 1e-8);
+  return energy / max(d * d, 1e-8) * anisotropicLift(alongWide, acrossWide, d);
 }
 
 /**
@@ -74,7 +95,8 @@ float anisotropicPhysical(vec3 l, vec3 h, float ndl, float sourceRadius, float d
   float y = dot(aAcross, h) / across;
   float z = dot(mNormal, h);
   float d = x * x + y * y + z * z;
-  float distribution = 1.0 / max(3.14159265 * along * across * d * d, 1e-8);
+  float distribution =
+    1.0 / max(3.14159265 * along * across * d * d, 1e-8) * anisotropicLift(along, across, d);
   float ndv = max(dot(mNormal, mToEye), 1e-4);
   float viewed = ndl * length(vec3(along * dot(aAlong, mToEye), across * dot(aAcross, mToEye), ndv));
   float lit = ndv * length(vec3(along * dot(aAlong, l), across * dot(aAcross, l), ndl));

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

@@ -3,30 +3,47 @@
  * their tilted peaks, the transmitted lobe to the backlight, the sum to what a white strand
  * receives, and every term to a finite answer where the geometry degenerates.
  *
- * **The strand is the tangent, root to tip.** The model map's green turns each strand's tilt by up
- * to half of it either way (0.5 is none) and its blue is occlusion, which the sky, DriftLight and
- * the environment's reflection take and the lamps do not — their shadows are theirs to cast. The
- * red is not read: a colour from root to tip is the albedo map's to carry.
+ * **The strand is the tangent, root to tip**, unless the model map says otherwise. Its red is the
+ * strand's specular, which scales the reflected lobe by twice it, so 0.5 is the lobe as drawn and 0
+ * a root that reflects nothing; its green turns each strand's tilt by up to half of it either way
+ * (0.5 is none); and its blue is occlusion, which light from every side takes and the lamps do not
+ * — their shadows are theirs to cast. A colour from root to tip is the albedo map's to carry.
  *
- * **The environment** is the reflected lobe's: mirrored about a normal turned toward the eye across
- * the strand, which is the cone R lies on, at the strand's own Fresnel — the lobe integrates to it
- * over every direction of arrival. **What it gives up** is the two transmitted lobes against the
- * sky, which a head of hair lit from behind by an open sky would show as a rim; the lamps carry
- * them.
+ * **A strand's direction, texel by texel**, where the model has a \`directionOffset\`: that many
+ * layers past the one the other channels are read at, a direction in the surface's tangent frame —
+ * red along the tangent, green along the bitangent and blue out of the surface along its normal,
+ * each −1 to 1 as a normal map packs them — which the strand runs along instead of the tangent. So
+ * a card's strands can lean out of its plane, each its own way, as the strands it stands for do.
+ * **What it gives up** is the frame's own precision: eight bits a component turns a strand in
+ * steps of about half a degree, which the lobes, a few degrees wide, do not resolve.
+ *
+ * **Light from every side** — the sky, the probes, DriftLight — goes through the lobes rather than
+ * past them: they are evaluated once, for a light along the eye flattened across the strand, every
+ * lobe widened by \`HAIR_AREA\` as a source that large would widen it, and their sum taken as the
+ * share of that light the strand returns (\`hairIndirect\`). That is how a real-time hair model
+ * stands one direction in for the sphere: a strand returns most toward the eye what arrives from
+ * the eye's side of it, and the R and TRT lobes are what make a fibre gold rather than a wash of
+ * its scatter. The environment's reflection leaves hair out, because R already took its share.
+ *
+ * **What it gives up**: light from behind. The direction stands for the eye's side only, so there
+ * is no transmitted lobe in it, and a head of hair lit from behind by an open sky shows no rim
+ * from the sky; the lamps carry one. And the share is one direction's, not the sphere's integral,
+ * so it moves with the eye as the lobes do rather than holding still as an average would. **What
+ * would make it wrong** is hair seen mostly against its light, a head against a bright window,
+ * whose sky arrives through the strands rather than off them and wants the transmitted lobe back.
  */
-import { HAIR_F0, HAIR_MIN_BETA, HAIR_SCATTER_SPHERE } from '../../hairLobes.ts';
+import { HAIR_AREA, HAIR_F0, HAIR_MIN_BETA } from '../../hairLobes.ts';
 
 export const HAIR_GLSL = /* glsl */ `
 const float HAIR_F0 = ${HAIR_F0.toFixed(9)};
 const float HAIR_MIN_BETA = ${HAIR_MIN_BETA.toFixed(3)};
-const float HAIR_SCATTER_SPHERE = ${HAIR_SCATTER_SPHERE.toFixed(3)};
+const float HAIR_AREA = ${HAIR_AREA.toFixed(3)};
 
-/* This texel's tilt, gathered once with the surface. */
+/* This texel's tilt, its specular, and the share of light from every side it returns: gathered
+   with the surface. */
 float hShift;
-
-void hairSurface() {
-  hShift = uModelParams[0].x * (0.5 + mMap.g);
-}
+float hSpecular;
+vec3 hAround;
 
 /** A longitudinal lobe: a normalised Gaussian of width \`beta\` at \`x\` from its centre. */
 float hairLongitudinal(float beta, float x) {
@@ -38,14 +55,18 @@ float hairFresnel(float cosine) {
   return HAIR_F0 + (1.0 - HAIR_F0) * c * c * c * c * c;
 }
 
-/** The normal turned toward the eye across the strand: the scatter's and the environment's. */
+/** The normal turned toward the eye across the strand: the scatter's, and light from every side's. */
 vec3 hairAcross() {
   vec3 across = mToEye - mTangent * dot(mTangent, mToEye);
   float length2 = dot(across, across);
   return length2 > 1e-8 ? across * inversesqrt(length2) : mNormal;
 }
 
-void hairLight(vec3 l, float sourceRadius, float dist) {
+/**
+ * The lobes for light arriving along \`l\`, into \`mSpecular\` and \`mDiffuse\`: every lobe widened by
+ * \`grow\` radians, and the transmitted one scaled by \`backlit\`.
+ */
+void hairLobes(vec3 l, float grow, float backlit) {
   vec3 t = mTangent;
   float sinI = clamp(dot(t, l), -1.0, 1.0);
   float sinO = clamp(dot(t, mToEye), -1.0, 1.0);
@@ -56,17 +77,16 @@ void hairLight(vec3 l, float sourceRadius, float dist) {
   float cosPhi = dot(lp, vp) * inversesqrt(dot(lp, lp) * dot(vp, vp) + 1e-4);
   float cosHalfPhi = sqrt(clamp(0.5 + 0.5 * cosPhi, 0.0, 1.0));
   float beta = max(mRoughness * mRoughness, HAIR_MIN_BETA);
-  float grow = sourceRadius / max(2.0 * dist, 1e-3);
   float x = sinI + sinO;
 
   float r = hairLongitudinal(beta + grow, x + 2.0 * hShift) * 0.25 * cosHalfPhi
-    * hairFresnel(sqrt(clamp(0.5 + 0.5 * dot(l, mToEye), 0.0, 1.0)));
+    * hairFresnel(sqrt(clamp(0.5 + 0.5 * dot(l, mToEye), 0.0, 1.0))) * hSpecular;
 
   float a = 1.0 / (1.19 / cosD + 0.36 * cosD);
   float h = cosHalfPhi * (1.0 + a * (0.6 - 0.8 * cosPhi));
   float fTT = hairFresnel(cosD * sqrt(clamp(1.0 - h * h, 0.0, 1.0)));
   float tt = hairLongitudinal(0.5 * beta + grow, x - hShift) * exp(-3.65 * cosPhi - 3.98)
-    * (1.0 - fTT) * (1.0 - fTT) * uModelParams[0].z;
+    * (1.0 - fTT) * (1.0 - fTT) * backlit;
   float ttPower = 0.5 * sqrt(clamp(1.0 - h * h * a * a, 0.0, 1.0)) / cosD;
 
   float fTRT = hairFresnel(0.5 * cosD);
@@ -81,6 +101,11 @@ void hairLight(vec3 l, float sourceRadius, float dist) {
   mDiffuse = sqrt(mAlbedo) * uModelParams[0].y * mix(wrapped, 1.0 - abs(sinI), 0.33);
 }
 
+/** A lamp, or the sun at no size: widened by the angle it subtends, as \`sphereLobe\` takes it. */
+void hairLight(vec3 l, float sourceRadius, float dist) {
+  hairLobes(l, sourceRadius / max(2.0 * dist, 1e-3), uModelParams[0].z);
+}
+
 /**
  * A shadow on the scatter: light that reaches a strand in another's shadow has passed through
  * hair to get there, so a penumbra deepens toward the fibre's own hue.
@@ -90,13 +115,38 @@ vec3 hairShade(float shadow) {
   return shadow * pow(max(hue, vec3(1e-4)), vec3(1.0 - shadow));
 }
 
-/** Light from every side, through the scatter term: \`HAIR_SCATTER_SPHERE\` says why that number. */
-vec3 hairAround(vec3 light) {
-  return sqrt(mAlbedo) * (uModelParams[0].y * HAIR_SCATTER_SPHERE * mMap.b) * light;
+/**
+ * The share of light from every side a strand returns: the lobes for a light along the eye
+ * flattened across the strand, unshadowed, with nothing from behind and every lobe widened by
+ * \`HAIR_AREA\`, twice their sum and at most all of it. Twice, in this engine's units, because the
+ * lobes are per unit irradiance and the scatter's half is then exactly \`HAIR_SCATTER_SPHERE\`, its
+ * own average over the sphere: \`hairLobes.ts\` says why, and holds the arithmetic to it.
+ */
+vec3 hairIndirect() {
+  hairLobes(hairAcross(), HAIR_AREA, 0.0);
+  return min(vec3(1.0), 2.0 * (mSpecular + mDiffuse));
+}
+
+/**
+ * The strand at this texel: its tilt and specular from the model map, its direction from the layer
+ * \`directionOffset\` names where there is one, and then its share of light from every side, which
+ * reads all three. On a branch of uniforms alone, so the read's derivatives are in uniform flow; a
+ * direction that decodes to nothing keeps the tangent.
+ */
+void hairSurface(vec3 at) {
+  hShift = uModelParams[0].x * (0.5 + mMap.g);
+  hSpecular = 2.0 * mMap.r;
+  if (uModelParams[0].w > 0.0 && uModelParams[1].w > 0.0) {
+    vec3 d = texture(uModelMap, vec3(at.xy, at.z + uModelParams[0].w)).rgb * 2.0 - 1.0;
+    vec3 strand = mTangent * d.x + mBitangent * d.y + mNormal * d.z;
+    float length2 = dot(strand, strand);
+    if (length2 > 1e-4) mTangent = strand * inversesqrt(length2);
+  }
+  hAround = hairIndirect();
 }
 
-/** The reflected lobe's share of the environment: its Fresnel, which is what it integrates to. */
-float hairReflectance() {
-  return hairFresnel(dot(hairAcross(), mToEye)) * mMap.b;
+/** Light from every side, through the lobes, under the map's occlusion. */
+vec3 hairAround(vec3 light) {
+  return hAround * (mMap.b * light);
 }
 `;

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

@@ -695,8 +695,9 @@ export const MAIN_GLSL = `void main() {
      * branch it did not take before.
      */
     /* A model reflects its environment whatever the pass asked of the standard model: see
-       modelReflectance. On the switches alone, so the derivatives below stay in uniform flow. */
-    if (uEnvironmentDials.y > 0.0 || uMaterialFlags.y != 0 || modelled) {
+       modelReflectance. Hair takes none: modelReflects. On the switches alone, so the derivatives
+       below stay in uniform flow. */
+    if ((uEnvironmentDials.y > 0.0 || uMaterialFlags.y != 0 || modelled) && modelReflects()) {
       vec3 toEye = normalize(uCameraPos - vWorldPos);
       vec3 mirrored = reflect(-toEye, modelled ? modelReflectNormal(n) : n);
       vec3 environment = mix(uAmbientGround, uAmbient, mirrored.y * 0.5 + 0.5);
@@ -834,6 +835,19 @@ export const MAIN_GLSL = `void main() {
        * caller sets this.
        */
       environment *= mix(1.0, uEnvironmentDials.z, metal);
+      /*
+       * **And brought to the light where the surface stands**, metal or not: a probe is captured
+       * at one place and seen from many, so a rough surface standing in light twice what the probe
+       * saw takes twice its reflection, and a mirror keeps the capture as it is. The weight is the
+       * caller's, the place's indirect light over the probe's average; mixed in by roughness, with
+       * the smoothstep written out because GLSL leaves one over an empty range undefined. 0, the
+       * weight less one, is exactly the reflection there was.
+       */
+      if (uEnvironmentMixing.x != 0.0) {
+        float span = max(uEnvironmentMixing.z - uEnvironmentMixing.y, 1e-4);
+        float rough = clamp((surfaceRoughness - uEnvironmentMixing.y) / span, 0.0, 1.0);
+        environment *= 1.0 + uEnvironmentMixing.x * rough * rough * (3.0 - 2.0 * rough);
+      }
       float facing = 1.0 - max(dot(n, toEye), 0.0);
       /*
        * **A metal's Fresnel base is close to its albedo, not a dielectric's four percent.** Schlick
@@ -2089,8 +2103,14 @@ export const MAIN_GLSL = `void main() {
    * the medium's colour and adding it puts the haze into the frame twice — a glow by day drew as
    * a grey shape of itself, greyer the thicker the air.
    */
+  /* And the sun's glow in the haze, which a surface takes after its fog and an added light never
+     does: what is behind it already has it. */
+  vec3 glow = vec3(0.0);
+  if (uFogEnabled == 1) {
+    glow = mediumGlow(distance(vWorldPos, uCameraPos), vWorldPos.y, normalize(vWorldPos - uCameraPos));
+  }
   vec3 shaded = applyOutputTransform(
-    uFogEnabled == 2 ? lit * (1.0 - fog) : mix(lit, mediumColor(), fog));
+    uFogEnabled == 2 ? lit * (1.0 - fog) : mix(lit, mediumColor(), fog) + glow);
 
   /*
    * **Refraction: the scene behind this surface, bent and absorbed.**

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

@@ -12,8 +12,8 @@
  * **Where the models plug in.** `main` gathers the surface once (`modelSurface`), then asks at each
  * place light arrives: `modelLight` for the sun, each lamp and each rectangle, `modelAmbient` for
  * the sky and the probe's irradiance, `modelIrradiance` for DriftLight, `modelReflectNormal` and
- * `modelReflectance` for the environment's reflection. Each returns today's term for the standard
- * model, and each model's file is where its own answers are.
+ * `modelReflectance` for the environment's reflection, which `modelReflects` keeps from hair. Each
+ * returns today's term for the standard model, and each model's file is where its own answers are.
  *
  * **What a model returns from a light** is the two halves the standard terms are: a diffuse already
  * weighted by the angle of arrival, and a specular lobe in the engine's peak-normalised units (see
@@ -95,6 +95,15 @@ bool modelSeesBehind() {
   return false;
 }
 
+/**
+ * Whether the environment's reflection reaches this surface: every model's but hair's, whose share
+ * of it is in its light from every side (hair.ts).
+ */
+bool modelReflects() {
+  if (MODEL_HAIR) return false;
+  return true;
+}
+
 /* The surface a model shades, gathered once in main before any light reaches it. */
 vec3 mNormal;
 vec3 mToEye;
@@ -227,7 +236,7 @@ void modelSurface(vec3 n, vec3 albedo, float roughness, float metal, vec3 at) {
   mMap = vec4(0.5, 0.5, 1.0, 1.0);
   if (uModelParams[1].w > 0.0) mMap = texture(uModelMap, at);
   if (MODEL_ANISOTROPIC) anisotropicSurface();
-  if (MODEL_HAIR) hairSurface();
+  if (MODEL_HAIR) hairSurface(at);
   if (MODEL_SKIN) skinSurface();
   if (MODEL_EYE) eyeSurface(at);
 }
@@ -285,7 +294,6 @@ vec3 modelIrradiance(vec3 irradiance) {
 /** The normal the environment is reflected about: the surface's own, but for a stretched lobe. */
 vec3 modelReflectNormal(vec3 n) {
   if (MODEL_ANISOTROPIC) return anisotropicReflectNormal(n);
-  if (MODEL_HAIR) return hairAcross();
   return n;
 }
 
@@ -361,7 +369,6 @@ vec3 modelDiffuseOut(vec3 diffuse, float fog) {
  * what the standard model would.
  */
 float modelReflectance(float standard) {
-  if (MODEL_HAIR) return hairReflectance();
   if (MODEL_SKIN) return skinReflectance();
   if (MODEL_EYE) return eyeReflectance();
   return standard;

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

@@ -289,6 +289,13 @@ uniform vec3 uOrmScale; // wgsl:material
  */
 uniform vec3 uEnvironmentDials; // wgsl:material
 
+/**
+ * The environment a surface reflects brought to the light where it stands, for every surface:
+ * \`setEnvironmentMixing\`. x is the weight less one, so a program nothing wrote reflects as it did;
+ * y and z the roughnesses the weight is mixed in over, smooth to rough.
+ */
+uniform vec4 uEnvironmentMixing; // wgsl:material
+
 /**
  * Where a surface glows, and in what colour.
  *