@driftengine/core 4.13.4 → 4.13.5

package/src/render/atmosphere.ts

@@ -12,6 +12,44 @@ export interface UnderwaterAtmosphere {
   transitionDepth: number;
 }
 
+/**
+ * A layer of haze: how thick it is where it is thickest, and how fast it thins above that.
+ *
+ * In natural units, as `fogDensity` is: a haze authored in base two, its surviving light
+ * `2^(−∫ρ)` and its density falling as `2^(−f·Δy)`, is the layer `density: ρ · (ln 2)²`,
+ * `heightFalloff: f · ln 2` here — the integral of base two's exponential carries one `ln 2` of its
+ * own, and the transmittance's base the other.
+ */
+export interface FogLayer {
+  /** Extinction per metre at `baseY`. */
+  density: number;
+  /** Reciprocal scale height, per metre: 0 is a layer of even density. */
+  heightFalloff: number;
+  /** The height it is thickest at. */
+  baseY: number;
+}
+
+/**
+ * The sun's light scattered toward the eye by the haze: a glow in the sun's direction, as dust and
+ * droplets throw forward what they catch.
+ *
+ * Added to what the haze returns rather than mixed with it, by as much of the ray past `start` as
+ * the haze hides: a mountain range seen into a low sun burns gold at its distance, and the
+ * figures a few metres off do not. **What it gives up** is the light's own shape: the glow is a
+ * lobe about one direction, `cos^exponent` of the angle from it, not light scattered along the
+ * ray through the shadows the sun's map knows of — the global medium is that one.
+ */
+export interface FogSunGlow {
+  /** The glow looking straight along `direction` through haze that hides everything. */
+  color: Vec3;
+  /** How tight the glow is about the sun: the cosine of the angle from it, to this power. */
+  exponent: number;
+  /** Metres past the haze's own start before the glow begins. Default 0. */
+  start?: number;
+  /** Surface → the light the glow surrounds. Absent, the environment's `directionalDir`. */
+  direction?: Vec3;
+}
+
 /** Atmosphere fields shared by every visible render pass. */
 export interface Atmosphere {
   fogColor: Vec3;
@@ -60,6 +98,31 @@ export interface Atmosphere {
    * between the camera and the start, which a real medium has; that is the point of it.
    */
   fogStart?: number;
+  /**
+   * The medium only: a second layer of haze, summed with the first along every ray, each its own
+   * density, height and falloff. Absent, one layer.
+   *
+   * Two layers are what a valley with a ground mist under a high summer haze is: one thin and
+   * tall, one dense and hugging the floor. One layer must pick one of the two scale heights, and
+   * either gets the other's half of the picture wrong.
+   */
+  fogLayer2?: FogLayer | null;
+  /**
+   * The most of a surface the haze may hide, 0 to 1. Absent or 1, all of it.
+   *
+   * Below 1 a far mountain keeps that much of itself however much air lies between, which is how a
+   * scene keeps a skyline readable behind a haze that should hide everything nearer the ground.
+   * **What it gives up** is physics: no medium has a floor on what survives it.
+   */
+  fogMaxOpacity?: number;
+  /**
+   * Metres from the camera past which the haze hides nothing: a surface further away, the sky
+   * included, is drawn clear. Absent or 0, none. For a sky or a backdrop that brings its own
+   * haze painted in, which the medium would otherwise lay a second time.
+   */
+  fogCutoff?: number;
+  /** The medium only: the sun's light scattered toward the eye by the haze. Absent, none. */
+  fogSunGlow?: FogSunGlow | null;
   underwater: UnderwaterAtmosphere | null;
 }
 
@@ -89,6 +152,16 @@ export function fogDensityAtEye(atmosphere: Atmosphere, cameraY: number): number
  */
 export interface ResolvedAtmosphere {
   readonly fogColor: Float32Array;
+  /**
+   * Four floats: 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, `fogMaxOpacity`'s complement, and the cutoff
+   * distance. **Every lane is none at zero**, so a pass that never wrote them draws as before.
+   */
+  readonly fogLayer2: Float32Array;
+  /** Four floats: the sun glow's colour, black for none, and its exponent. */
+  readonly fogGlow: Float32Array;
+  /** Four floats: surface → the glow's light, and how far past the haze's start the glow begins. */
+  readonly fogGlowDir: Float32Array;
   fogDensity: number;
   fogHeightFalloff: number;
   fogEyeY: number;
@@ -109,7 +182,7 @@ export interface ResolvedAtmosphere {
  * it; nothing here allocates and nothing is shared between them.
  */
 export function resolveAtmosphere(
-  atmosphere: Atmosphere,
+  atmosphere: Atmosphere & { readonly directionalDir?: ArrayLike<number> },
   cameraY: number,
   underwaterEnabled: boolean,
   out: ResolvedAtmosphere,
@@ -163,22 +236,77 @@ export function resolveAtmosphere(
   out.underwaterColor.set(underwater === null ? atmosphere.fogColor : underwater.color);
   out.underwaterFogDensity = underwater === null ? atmosphere.fogDensity : underwater.fogDensity;
   out.underwaterFactor = factor;
+  resolveHazeExtras(atmosphere, cameraY, out);
   return out;
 }
 
+/**
+ * The second layer, the haze's limits and the sun's glow, into `out`: the layer and the glow only
+ * in the medium, since a linear ramp has neither a density nor a ray to integrate, and every slot
+ * written whatever is asked, so nothing a shader reads keeps what an earlier frame left in it.
+ */
+function resolveHazeExtras(
+  atmosphere: Atmosphere & { readonly directionalDir?: ArrayLike<number> },
+  cameraY: number,
+  out: ResolvedAtmosphere,
+): void {
+  const medium = atmosphere.fogMode !== 'linear';
+  const layer = medium ? (atmosphere.fogLayer2 ?? null) : null;
+  const density = layer === null ? 0 : Math.max(0, layer.density);
+  /* The second layer at the camera's height, as `fogDensityAtEye` puts the first. */
+  out.fogLayer2[0] =
+    density > 0 && layer !== null
+      ? density * Math.exp(-(cameraY - layer.baseY) * layer.heightFalloff)
+      : 0;
+  out.fogLayer2[1] = density > 0 && layer !== null ? layer.heightFalloff : 0;
+  const most = atmosphere.fogMaxOpacity;
+  out.fogLayer2[2] =
+    most !== undefined && Number.isFinite(most) ? 1 - Math.min(1, Math.max(0, most)) : 0;
+  const cutoff = atmosphere.fogCutoff;
+  out.fogLayer2[3] = cutoff !== undefined && Number.isFinite(cutoff) && cutoff > 0 ? cutoff : 0;
+
+  const glow = medium ? (atmosphere.fogSunGlow ?? null) : null;
+  const toward = glow?.direction ?? atmosphere.directionalDir;
+  const x = (toward?.[0] as number | undefined) ?? 0;
+  const y = (toward?.[1] as number | undefined) ?? 1;
+  const z = (toward?.[2] as number | undefined) ?? 0;
+  const length = Math.hypot(x, y, z);
+  const lit = glow !== null && length > 1e-6;
+  for (let c = 0; c < 3; c++) {
+    out.fogGlow[c] = lit && glow !== null ? Math.max(0, glow.color[c] as number) : 0;
+  }
+  /* Above zero, so the shader's pow never meets 0 to the 0: a lobe that flat is the whole sky. */
+  out.fogGlow[3] = lit && glow !== null ? Math.max(1e-3, glow.exponent) : 1;
+  out.fogGlowDir[0] = lit ? x / length : 0;
+  out.fogGlowDir[1] = lit ? y / length : 1;
+  out.fogGlowDir[2] = lit ? z / length : 0;
+  out.fogGlowDir[3] = lit && glow !== null ? Math.max(0, glow.start ?? 0) : 0;
+}
+
+/**
+ * A target for `resolveAtmosphere`, made once outside the frame loop: one factory, so a field added
+ * to the resolved medium is a field every holder of one gets rather than one each must remember.
+ */
+export function createResolvedAtmosphere(): ResolvedAtmosphere {
+  return {
+    fogColor: new Float32Array(3),
+    fogLayer2: new Float32Array(4),
+    fogGlow: new Float32Array(4),
+    fogGlowDir: new Float32Array(4),
+    underwaterColor: new Float32Array(3),
+    fogDensity: 0,
+    fogHeightFalloff: 0,
+    fogEyeY: 0,
+    fogMode: 0,
+    fogNear: 0,
+    fogFar: 1,
+    underwaterFogDensity: 0,
+    underwaterFactor: 0,
+  };
+}
+
 /** One per GL binder, refilled per call. See `resolveAtmosphere` on why it is not allocated. */
-const glResolved: ResolvedAtmosphere = {
-  fogColor: new Float32Array(3),
-  underwaterColor: new Float32Array(3),
-  fogDensity: 0,
-  fogHeightFalloff: 0,
-  fogEyeY: 0,
-  fogMode: 0,
-  fogNear: 0,
-  fogFar: 1,
-  underwaterFogDensity: 0,
-  underwaterFactor: 0,
-};
+const glResolved: ResolvedAtmosphere = createResolvedAtmosphere();
 
 /**
  * Bind the same camera medium to any shader that declares atmosphere uniforms.
@@ -195,13 +323,18 @@ export function bindAtmosphere(
   const m = resolveAtmosphere(atmosphere, cameraY, underwaterEnabled, glResolved);
 
   gl.uniform3fv(uniforms['uFogColor'] ?? null, m.fogColor);
-  gl.uniform1f(uniforms['uFogDensity'] ?? null, m.fogDensity);
-  gl.uniform1f(uniforms['uFogHeightFalloff'] ?? null, m.fogHeightFalloff);
-  gl.uniform1f(uniforms['uFogEyeY'] ?? null, m.fogEyeY);
-  gl.uniform1i(uniforms['uFogMode'] ?? null, m.fogMode);
-  gl.uniform1f(uniforms['uFogNear'] ?? null, m.fogNear);
-  gl.uniform1f(uniforms['uFogFar'] ?? null, m.fogFar);
+  /* Packed as `shaders/fog.ts` declares them, four to a row: see `uFogMedium` there for why. */
+  gl.uniform4f(
+    uniforms['uFogMedium'] ?? null,
+    m.fogDensity,
+    m.fogHeightFalloff,
+    m.fogEyeY,
+    m.underwaterFogDensity,
+  );
+  gl.uniform4f(uniforms['uFogRange'] ?? null, m.fogNear, m.fogFar, m.fogMode, 0);
   gl.uniform3fv(uniforms['uUnderwaterColor'] ?? null, m.underwaterColor);
-  gl.uniform1f(uniforms['uUnderwaterFogDensity'] ?? null, m.underwaterFogDensity);
   gl.uniform1f(uniforms['uUnderwaterFactor'] ?? null, m.underwaterFactor);
+  gl.uniform4fv(uniforms['uFogLayer2'] ?? null, m.fogLayer2);
+  gl.uniform4fv(uniforms['uFogGlow'] ?? null, m.fogGlow);
+  gl.uniform4fv(uniforms['uFogGlowDir'] ?? null, m.fogGlowDir);
 }

package/src/render/backend/webgl2/renderer.ts

@@ -42,14 +42,18 @@ import {
   resolveFrameReflections,
   type ResolvedFrameReflections,
 } from '../../frameReflections.ts';
+import { noEnvironmentMixing, resolveEnvironmentMixing } from '../../environmentMixing.ts';
 import { GlobalMediumPass } from '../../globalMediumPass.ts';
 import {
   DEFAULT_GLOBAL_MEDIUM,
   WEAK_GPU_MEDIUM_STEPS,
+  createResolvedMediumLamps,
   mediumActive,
   resolveGlobalMedium,
+  resolveGlobalMediumSettings,
+  resolveMediumLamps,
 } from '../../globalMedium.ts';
-import type { GlobalMediumOptions } from '../../globalMedium.ts';
+import type { GlobalMediumSettings, ResolvedGlobalMedium } from '../../globalMedium.ts';
 import { REFLECTION_EDGE_FADE, ReflectionQueue } from '../../screenSpaceReflection.ts';
 import type { ReflectiveSurface } from '../../screenSpaceReflection.ts';
 import { DecalQueue } from '../../decalQueue.ts';
@@ -86,6 +90,7 @@ import type {
   PassRegistry,
 } from '../../pass.ts';
 import type { Vec3 } from '../../../math/color.ts';
+import type { LocalExposureOptions } from '../../shaders/localExposure.ts';
 import { clamp } from '../../../math/scalar.ts';
 import { attachContextLoss } from '../../contextLoss.ts';
 import { isWeakGpuFamily, webgl2RendererName } from '../../gpuCapability.ts';
@@ -177,6 +182,8 @@ import {
   MODEL_MAP_TEXTURE_UNIT,
   MORPH_DELTA_TEXTURE_UNIT,
   SKIN_PALETTE_TEXTURE_UNIT,
+  createResolvedPointLights,
+  resolvePointLights,
 } from '../../lightBudget.ts';
 import {
   MODEL_PARAM_FLOATS,
@@ -528,6 +535,12 @@ export interface Environment extends Atmosphere {
    * every light. See `PointLightSource.falloffExponent`.
    */
   lightFalloffExponents?: Float32Array;
+  /**
+   * One per active light: how strongly it scatters in the global medium, a share of how strongly it
+   * lights a surface, beside `setGlobalMedium`'s `lampScatter`. Optional: absent is 1 for every
+   * light. See `PointLightSet.lightMediumScatter`.
+   */
+  lightMediumScatter?: Float32Array;
   /** One per active light: a row of the photometric atlas, or −1 for none. */
   lightIesProfiles: Float32Array;
   /**
@@ -1551,6 +1564,8 @@ export class WebGL2Renderer implements RendererApi {
    * vector on the device, so written whole, and kept here so a setter moving one keeps the others.
    */
   private readonly environmentDials = new Float32Array(3);
+  /** `uEnvironmentMixing` as it stands: see `setEnvironmentMixing`. None until a draw asks. */
+  private readonly environmentMixing = noEnvironmentMixing(new Float32Array(4));
   /** `uEmission` as it stands: the emissive gain and the night factor. */
   private readonly emission = new Float32Array([1, 0]);
   /** The ramp and each level's tint, as `resolveBloomResponse` writes them; the subtraction and white. */
@@ -4880,6 +4895,31 @@ export class WebGL2Renderer implements RendererApi {
     this.writeEnvironmentDials();
   }
 
+  /**
+   * How much of the light where the surfaces drawn next stand their reflection is brought to, for
+   * every surface, metal or not: what each reflects of the environment times
+   * `lerp(1, weight, smoothstep(roughnessLow, roughnessHigh, roughness))`. 1 is the default and
+   * identity; held until changed, and put back at `bindMeshPass`.
+   *
+   * **Why there is a weight at all**: a probe is captured at one place and seen from many, so a
+   * figure standing where the indirect light is twice what the probe saw reflects the probe at the
+   * probe's brightness and reads as dull against everything lit around it. `weight` is that
+   * ratio, the place's indirect light over the probe's own average, and a caller that knows both
+   * passes it; above 1 brightens, below dims. A mirror keeps the capture as it is, because its
+   * image is the point, and a rough surface, whose reflection is an average anyway, takes its
+   * place's light: the roughnesses say where between, 0.1 and 0.3 by default.
+   *
+   * Unlike `setEnvironmentGain`, which reaches metals only, and `setSurfaceReflectivity`, which
+   * stops at 1. **What it gives up** is a reflection that stays the probe's image on a rough
+   * surface: past the upper roughness it is the probe scaled to the light, not the place relit.
+   */
+  setEnvironmentMixing(weight: number, roughnessLow = 0.1, roughnessHigh = 0.3): void {
+    if (this.contextLost) return;
+    resolveEnvironmentMixing(weight, roughnessLow, roughnessHigh, this.environmentMixing);
+    this.materials.dirty();
+    this.writeFlatVector('uEnvironmentMixing', this.environmentMixing);
+  }
+
   /**
    * Kept as a no-op that says so once, because it was a stand-in for a term that now exists.
    *
@@ -8098,12 +8138,12 @@ export class WebGL2Renderer implements RendererApi {
    * two regions of one brightness band differ. Needs `screenEffects` and `hdrScene`, and says so
    * once rather than doing nothing. See `shaders/localExposure.ts`.
    */
-  setLocalExposure(strength: number): void {
+  setLocalExposure(setting: number | LocalExposureOptions): void {
     if (this.sceneTarget === null || !this.quality.hdrScene) {
-      this.warnLookWithoutComposite(strength);
+      this.warnLookWithoutComposite(typeof setting === 'number' ? setting : 1);
       return;
     }
-    this.sceneTarget.setLocalExposure(strength);
+    this.sceneTarget.setLocalExposure(setting);
   }
 
   /**
@@ -8214,21 +8254,19 @@ export class WebGL2Renderer implements RendererApi {
    * of the two that can put the shape of a doorway on a floor.
    */
   setGlobalMedium(
-    density: number,
-    albedo?: number,
+    density: number | GlobalMediumSettings,
+    albedo?: number | Vec3,
     anisotropy?: number,
     maxDistance?: number,
   ): void {
-    this.mediumOptions = resolveGlobalMedium({
-      density: Number.isFinite(density) ? density : 0,
-      albedo,
-      anisotropy,
-      maxDistance,
-    });
+    this.mediumOptions = resolveGlobalMediumSettings(density, albedo, anisotropy, maxDistance);
   }
 
   /** This frame's medium. Off until a caller says otherwise. See `setGlobalMedium`. */
-  private mediumOptions: GlobalMediumOptions = DEFAULT_GLOBAL_MEDIUM;
+  private mediumOptions: ResolvedGlobalMedium = resolveGlobalMedium(DEFAULT_GLOBAL_MEDIUM);
+  /** The lamps the medium is lit by, and the lit stage's lamps they come from, refilled a frame. */
+  private readonly mediumLamps = createResolvedMediumLamps();
+  private readonly mediumLights = createResolvedPointLights();
   /** Built on the first frame that asks for a medium, and never on one that does not. */
   private medium: GlobalMediumPass | null = null;
 
@@ -9081,6 +9119,15 @@ export class WebGL2Renderer implements RendererApi {
                so it is safe only because `sunShadow` is 0 whenever these maps do not exist. */
             sunShadows: this.sunShadows?.texture ?? this.emptyTexture2DArray,
             peeledEnabled: this.peelFilled,
+            /* The lit stage's lamps and the shadows it resolved for them, this frame's. */
+            lamps: resolveMediumLamps(
+              this.mediumOptions,
+              resolvePointLights(env, this.quality.pointLightFalloff, this.mediumLights),
+              this.pointShadows === null ? null : this.resolvedPointShadows,
+              env?.lightMediumScatter,
+              this.mediumLamps,
+            ),
+            pointShadows: this.pointShadowArray?.texture ?? this.emptyTexture2DArray,
           },
         );
         if (marched) {
@@ -9356,6 +9403,8 @@ export class WebGL2Renderer implements RendererApi {
     this.materialEnvironmentGain = null;
     this.environmentDials[1] = 0;
     this.environmentDials[2] = 1;
+    /* And no mixing, for the same reason. See `setEnvironmentMixing`. */
+    noEnvironmentMixing(this.environmentMixing);
     this.emission[0] = env.emissiveGain;
     this.emission[1] = env.nightFactor;
     /* The moving layer's own matrix, the first time a frame draws that layer with one. */
@@ -9612,6 +9661,7 @@ export class WebGL2Renderer implements RendererApi {
      * See `setSurfaceReflectivity` and `setEnvironmentGain`.
      */
     gl.uniform3fv(u['uEnvironmentDials'] ?? null, this.environmentDials);
+    gl.uniform4fv(u['uEnvironmentMixing'] ?? null, this.environmentMixing);
     /* And no relief unless a caller asks, for the same reason. */
     gl.uniform2f(u['uRelief'] ?? null, 0, 60);
     /* And no relief read off a surface texture either, for the same reason. */

package/src/render/backend/webgpu/gpuDrivenPass.ts

@@ -182,11 +182,11 @@ export const VERTEX_FLOATS = GPU_DRIVEN_VERTEX_FLOATS;
 /**
  * Floats the shading pass's frame block holds. Matches `FRAME_BLOCK_WGSL`'s `Frame`.
  *
- * Two matrices and fifteen vectors: the camera's, the light's, then the eye, the light's direction
+ * Two matrices and eighteen vectors: the camera's, the light's, then the eye, the light's direction
  * and colour, the sky, the ground, the target's size, the shadow's settings in two, the probe's in
- * two, the medium's four, and the visibility buffer's row.
+ * two, the medium's four, the visibility buffer's row, and the medium's last three after it.
  */
-const FRAME_FLOATS = 92;
+const FRAME_FLOATS = 104;
 
 /** Where each block starts in it, so the writer and the shader cannot drift apart. */
 const FRAME_LIGHT_VIEW_PROJ = 16;
@@ -205,6 +205,9 @@ const FRAME_FOG_UNDERWATER = 76;
 const FRAME_FOG_HEIGHT = 80;
 const FRAME_FOG_RANGE = 84;
 const FRAME_PITCH = 88;
+const FRAME_FOG_LIMITS = 92;
+const FRAME_FOG_GLOW = 96;
+const FRAME_FOG_GLOW_DIR = 100;
 
 /**
  * Pixels the internal width is rounded up to.
@@ -2693,6 +2696,20 @@ export class GpuDrivenPass implements PassDefinition {
     params[FRAME_FOG_RANGE + 1] = fog?.far ?? 0;
     params[FRAME_FOG_RANGE + 2] = fog?.mode ?? MEDIUM_FOG;
     params[FRAME_FOG_RANGE + 3] = fog?.underwaterDensity ?? 0;
+    /* The second layer, the floor, the cutoff and the glow: every one none at zero, as a view
+       written before they existed asks. */
+    params[FRAME_FOG_HEIGHT + 2] = fog?.density2 ?? 0;
+    params[FRAME_FOG_HEIGHT + 3] = fog?.heightFalloff2 ?? 0;
+    params[FRAME_FOG_LIMITS] = fog?.floor ?? 0;
+    params[FRAME_FOG_LIMITS + 1] = fog?.cutoff ?? 0;
+    params[FRAME_FOG_GLOW] = fog?.glowColour?.[0] ?? 0;
+    params[FRAME_FOG_GLOW + 1] = fog?.glowColour?.[1] ?? 0;
+    params[FRAME_FOG_GLOW + 2] = fog?.glowColour?.[2] ?? 0;
+    params[FRAME_FOG_GLOW + 3] = fog?.glowExponent ?? 1;
+    params[FRAME_FOG_GLOW_DIR] = fog?.glowDirection?.[0] ?? 0;
+    params[FRAME_FOG_GLOW_DIR + 1] = fog?.glowDirection?.[1] ?? 1;
+    params[FRAME_FOG_GLOW_DIR + 2] = fog?.glowDirection?.[2] ?? 0;
+    params[FRAME_FOG_GLOW_DIR + 3] = fog?.glowStart ?? 0;
     /* The scene's own decision about whether its grid supplies the ambient, as it is on the
        forward path: `ProbeBakeOptions.irradiance` reaches here as `PassEnvironment.irradiance`. */
     params[FRAME_ENVIRONMENT_MIX] = room !== null && room.irradiance ? 1 : 0;

package/src/render/backend/webgpu/mediumFields.ts

@@ -0,0 +1,87 @@
+/**
+ * The medium's fields, every uniform `shaders/fog.ts` declares, written into a pass's block by name
+ * from one resolved atmosphere.
+ *
+ * **One writer for every pass that fogs.** Ten passes wrote the same ten fields by hand, so a field
+ * the medium grows was ten places to remember and a pass that missed one read zero: the fourth
+ * point of the rule `AGENTS.md` dates 2026-08-13. A field a pass's shader never reads is compiled
+ * out of its block, so each is written only where the block holds it. An absent field is not an
+ * offset of zero, which is the first field of the block.
+ */
+import type { ResolvedAtmosphere } from '../../atmosphere.ts';
+import type { UniformFields } from './scatterPass.ts';
+import type { UniformRing } from './uniformRing.ts';
+
+/** A field's byte offset in the block, or -1 where the shader compiled it out. */
+function placed(fields: UniformFields, name: string): number {
+  return fields[name]?.offset ?? -1;
+}
+
+/** Into a block staged as floats, indexed in four-byte words. */
+export function writeMediumFields(
+  fields: UniformFields,
+  f: Float32Array,
+  m: ResolvedAtmosphere,
+): void {
+  let at = placed(fields, 'uFogColor');
+  if (at >= 0) f.set(m.fogColor, at / 4);
+  at = placed(fields, 'uFogMedium');
+  if (at >= 0) {
+    f[at / 4] = m.fogDensity;
+    f[at / 4 + 1] = m.fogHeightFalloff;
+    f[at / 4 + 2] = m.fogEyeY;
+    f[at / 4 + 3] = m.underwaterFogDensity;
+  }
+  at = placed(fields, 'uFogRange');
+  if (at >= 0) {
+    f[at / 4] = m.fogNear;
+    f[at / 4 + 1] = m.fogFar;
+    f[at / 4 + 2] = m.fogMode;
+    f[at / 4 + 3] = 0;
+  }
+  at = placed(fields, 'uUnderwaterColor');
+  if (at >= 0) f.set(m.underwaterColor, at / 4);
+  at = placed(fields, 'uUnderwaterFactor');
+  if (at >= 0) f[at / 4] = m.underwaterFactor;
+  at = placed(fields, 'uFogLayer2');
+  if (at >= 0) f.set(m.fogLayer2, at / 4);
+  at = placed(fields, 'uFogGlow');
+  if (at >= 0) f.set(m.fogGlow, at / 4);
+  at = placed(fields, 'uFogGlowDir');
+  if (at >= 0) f.set(m.fogGlowDir, at / 4);
+}
+
+/** Into one slot of a ring, at the fields' byte offsets. */
+export function writeMediumSlot(
+  ring: UniformRing,
+  slot: number,
+  fields: UniformFields,
+  m: ResolvedAtmosphere,
+): void {
+  let at = placed(fields, 'uFogColor');
+  if (at >= 0) ring.writeFloats(slot, at, m.fogColor);
+  at = placed(fields, 'uFogMedium');
+  if (at >= 0) {
+    ring.writeFloat(slot, at, m.fogDensity);
+    ring.writeFloat(slot, at + 4, m.fogHeightFalloff);
+    ring.writeFloat(slot, at + 8, m.fogEyeY);
+    ring.writeFloat(slot, at + 12, m.underwaterFogDensity);
+  }
+  at = placed(fields, 'uFogRange');
+  if (at >= 0) {
+    ring.writeFloat(slot, at, m.fogNear);
+    ring.writeFloat(slot, at + 4, m.fogFar);
+    ring.writeFloat(slot, at + 8, m.fogMode);
+    ring.writeFloat(slot, at + 12, 0);
+  }
+  at = placed(fields, 'uUnderwaterColor');
+  if (at >= 0) ring.writeFloats(slot, at, m.underwaterColor);
+  at = placed(fields, 'uUnderwaterFactor');
+  if (at >= 0) ring.writeFloat(slot, at, m.underwaterFactor);
+  at = placed(fields, 'uFogLayer2');
+  if (at >= 0) ring.writeFloats(slot, at, m.fogLayer2);
+  at = placed(fields, 'uFogGlow');
+  if (at >= 0) ring.writeFloats(slot, at, m.fogGlow);
+  at = placed(fields, 'uFogGlowDir');
+  if (at >= 0) ring.writeFloats(slot, at, m.fogGlowDir);
+}