@driftengine/core 4.13.4 → 4.13.5

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,10 +3,19 @@
  * 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 light from every side
- * takes 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.
+ *
+ * **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
@@ -30,8 +39,10 @@ const float HAIR_F0 = ${HAIR_F0.toFixed(9)};
 const float HAIR_MIN_BETA = ${HAIR_MIN_BETA.toFixed(3)};
 const float HAIR_AREA = ${HAIR_AREA.toFixed(3)};
 
-/* This texel's tilt, and the share of light from every side it returns: gathered 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;
+float hSpecular;
 vec3 hAround;
 
 /** A longitudinal lobe: a normalised Gaussian of width \`beta\` at \`x\` from its centre. */
@@ -69,7 +80,7 @@ void hairLobes(vec3 l, float grow, float backlit) {
   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));
@@ -116,8 +127,21 @@ vec3 hairIndirect() {
   return min(vec3(1.0), 2.0 * (mSpecular + mDiffuse));
 }
 
-void hairSurface() {
+/**
+ * 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();
 }
 

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

@@ -835,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
@@ -2090,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

@@ -236,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);
 }

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.
  *

package/src/render/shaders/fog.ts

@@ -31,37 +31,77 @@
  * at the eye times `(1 − e⁻ᵗ)/t`, with `t` the height climbed in scale heights. The eye
  * density and `1/H` arrive precomputed from `bindAtmosphere`.
  *
- * `uFogEyeY` rather than `uCameraPos.y` because two of the seven programs (the plumes)
- * never needed the camera position in their fragment stage, and a block that declares
- * everything it uses can be pasted anywhere.
+ * `uFogMedium.z`, the eye's height, rather than `uCameraPos.y`, because two of the seven
+ * programs (the plumes) never needed the camera position in their fragment stage, and a block
+ * that declares everything it uses can be pasted anywhere.
  */
 export const FOG_GLSL = `
 uniform vec3 uFogColor;
-/** Extinction per metre **at the camera's own height**, not at the base. */
-uniform float uFogDensity;
-/** Reciprocal scale height of the haze, per metre. 0 is a uniform medium. */
-uniform float uFogHeightFalloff;
-/** The camera's height, so a fragment's own height is one subtraction away. */
-uniform float uFogEyeY;
+/**
+ * The haze: its extinction per metre **at the camera's own height**, not at the base; its
+ * reciprocal scale height per metre, 0 for a uniform medium; the camera's height, so a fragment's
+ * own height is one subtraction away; and the water column's own density.
+ *
+ * **Four numbers in one vector rather than four uniforms**, and the reason is a phone: a scalar
+ * costs a whole row of the uniform grid, and the lit stage at its eight-light rung must fit the 256
+ * rows an Adreno 740 offers (uniformVectorBudget.ts). Packed, the haze's eight scalars cost two
+ * rows where they cost eight, which is what paid for the second layer and the sun's glow below.
+ */
+uniform vec4 uFogMedium;
+/** Where haze begins, where a linear ramp is total, and the mode: 0 a medium, 1 a ramp. */
+uniform vec4 uFogRange;
 uniform vec3 uUnderwaterColor;
-uniform float uUnderwaterFogDensity;
 uniform float uUnderwaterFactor;
-/** 0 integrates a medium (Beer-Lambert); 1 ramps linearly between near and far. */
-uniform int uFogMode;
-/** Linear mode only: where haze begins, and where it is total. */
-uniform float uFogNear;
-uniform float uFogFar;
+/**
+ * The second layer's extinction per metre at the camera's height and its falloff; then the least of
+ * a surface the haze must leave, Atmosphere.fogMaxOpacity's complement, and the distance past which
+ * it hides nothing (0 is none). **Every lane is none at zero**, and so are uFogGlow's: a program a
+ * binder never wrote these into draws the haze it drew before they existed, rather than none.
+ */
+uniform vec4 uFogLayer2;
+/** The sun's glow in the haze: its colour, black for none, and the exponent of its lobe. */
+uniform vec4 uFogGlow;
+/** Surface → the glow's light, and how far past the haze's start the glow begins. */
+uniform vec4 uFogGlowDir;
 
 /** What distance converges toward: the day's haze, or the water column. */
 vec3 mediumColor() {
   return mix(uFogColor, uUnderwaterColor, uUnderwaterFactor);
 }
 
+/**
+ * The haze's optical depth from where it begins along the ray to a point at height pointY, dist
+ * metres away: each layer's density at the eye carried over what is left of the ray, with the
+ * second layer only where there is one. The fog and the sun's glow both integrate it.
+ */
+float hazeDepth(float dist, float pointY) {
+  // Where the medium begins along the ray: uFogRange.x, the linear mode's slot, which this mode
+  // never read before Atmosphere.fogStart. The ray is integrated from there on, at the density
+  // of that point; at a start of 0 every term is the one it always was. See render/fog.ts.
+  float start = min(uFogRange.x, dist);
+  float before = dist > 0.0 ? start / dist : 0.0;
+  float t = (pointY - uFogMedium.z) * uFogMedium.y;
+  float rest = t * (1.0 - before);
+  // (1 - e^-t)/t, which tends to 1 as the ray levels out. Guarded rather than
+  // branched: at t = 0 the quotient is 0/0, and 1e-4 of a scale height is 8 mm.
+  float denom = abs(rest) < 1e-4 ? 1e-4 : rest;
+  float depth = uFogMedium.x * exp(-t * before) * (dist - start) * (1.0 - exp(-denom)) / denom;
+  if (uFogLayer2.x > 0.0) {
+    float t2 = (pointY - uFogMedium.z) * uFogLayer2.y;
+    float rest2 = t2 * (1.0 - before);
+    float denom2 = abs(rest2) < 1e-4 ? 1e-4 : rest2;
+    depth += uFogLayer2.x * exp(-t2 * before) * (dist - start) * (1.0 - exp(-denom2)) / denom2;
+  }
+  return depth;
+}
+
 /**
  * How much of a surface standing at height pointY, dist metres away, is lost to
  * the medium in between. 0 is perfectly clear, 1 is the medium's own colour.
  */
 float mediumFog(float dist, float pointY) {
+  /* Past the cutoff the air hides nothing, in either mode; the water column keeps its own law. */
+  bool cut = uFogLayer2.w > 0.0 && dist > uFogLayer2.w;
   /*
    * A depth ramp rather than a medium, for worlds authored against one.
    *
@@ -77,30 +117,39 @@ float mediumFog(float dist, float pointY) {
    * Height falloff has no meaning here and is ignored: a ramp is defined on distance
    * alone.
    */
-  if (uFogMode == 1) {
-    float span = max(uFogFar - uFogNear, 1e-4);
-    float ramp = clamp((dist - uFogNear) / span, 0.0, 1.0);
+  if (uFogRange.z == 1.0) {
+    float span = max(uFogRange.y - uFogRange.x, 1e-4);
+    float ramp = cut ? 0.0 : min(clamp((dist - uFogRange.x) / span, 0.0, 1.0), 1.0 - uFogLayer2.z);
     if (uUnderwaterFactor <= 0.0) return ramp;
-    float wetLinear = uUnderwaterFogDensity * dist;
+    float wetLinear = uFogMedium.w * dist;
     return mix(ramp, 1.0 - exp2(-wetLinear * wetLinear * 1.442695), uUnderwaterFactor);
   }
 
-  // Where the medium begins along the ray: uFogNear, the linear mode's slot, which this mode
-  // never read before Atmosphere.fogStart. The ray is integrated from there on, at the density
-  // of that point; at a start of 0 every term is the one it always was. See render/fog.ts.
-  float start = min(uFogNear, dist);
-  float before = dist > 0.0 ? start / dist : 0.0;
-  float t = (pointY - uFogEyeY) * uFogHeightFalloff;
-  float rest = t * (1.0 - before);
-  // (1 - e^-t)/t, which tends to 1 as the ray levels out. Guarded rather than
-  // branched: at t = 0 the quotient is 0/0, and 1e-4 of a scale height is 8 mm.
-  float denom = abs(rest) < 1e-4 ? 1e-4 : rest;
-  float air =
-    1.0 - exp(-uFogDensity * exp(-t * before) * (dist - start) * (1.0 - exp(-denom)) / denom);
+  // Beer-Lambert through both layers, leaving at least uFogLayer2.z of the surface: a floor on
+  // what survives rather than a ceiling on the depth, so the curve keeps its shape above it.
+  float air = cut ? 0.0 : 1.0 - max(exp(-hazeDepth(dist, pointY)), uFogLayer2.z);
   if (uUnderwaterFactor <= 0.0) return air;
   // Water is its own medium and keeps its own curve, so crossing the surface
   // changes nothing about how the water column reads.
-  float wet = uUnderwaterFogDensity * dist;
+  float wet = uFogMedium.w * dist;
   return mix(air, 1.0 - exp2(-wet * wet * 1.442695), uUnderwaterFactor);
 }
+
+/**
+ * The sun's light the haze scatters toward the eye along a ray to a point at height pointY, dist
+ * metres away in the direction toPoint: added to a surface after its fog, never mixed. A lobe of
+ * cos^exponent about the light, by as much of the ray past the glow's own start as the haze hides —
+ * the haze's depth per metre carried over that stretch. None in a linear ramp, past the cutoff, or
+ * under water, which keeps its own medium.
+ */
+vec3 mediumGlow(float dist, float pointY, vec3 toPoint) {
+  if (uFogRange.z == 1.0 || max(max(uFogGlow.r, uFogGlow.g), uFogGlow.b) <= 0.0) return vec3(0.0);
+  if (uFogLayer2.w > 0.0 && dist > uFogLayer2.w) return vec3(0.0);
+  float span = dist - min(uFogRange.x, dist);
+  if (span <= 0.0) return vec3(0.0);
+  float perMetre = hazeDepth(dist, pointY) / span;
+  float hidden = 1.0 - exp(-perMetre * max(span - uFogGlowDir.w, 0.0));
+  float lobe = pow(clamp(dot(toPoint, uFogGlowDir.xyz), 0.0, 1.0), uFogGlow.a);
+  return uFogGlow.rgb * (lobe * hidden * (1.0 - uUnderwaterFactor));
+}
 `;