@driftengine/core 4.13.3 → 4.13.5

package/dist/render/shaders/gpudriven/fog.wgsl.js

@@ -21,12 +21,43 @@ fn mediumColour() -> vec3<f32> {
   return mix(frame.fogColour.xyz, frame.fogUnderwater.xyz, frame.fogUnderwater.w);
 }
 
+/**
+ * The haze's optical depth from where it begins along the ray to a point at "pointY", "dist" metres
+ * away: each layer's density at the eye carried over what is left of the ray, the second only
+ * where there is one. mediumFog and mediumGlow both integrate it.
+ */
+fn hazeDepth(dist: f32, pointY: f32) -> f32 {
+  /* Where the medium begins along the ray: fogRange.x, the linear mode's near, which this mode
+     never read before Atmosphere.fogStart. Integrated from there on, at that point's density; at
+     a start of 0 every term is the one it always was. See render/fog.ts. */
+  let start = min(frame.fogRange.x, dist);
+  var before = 0.0;
+  if (dist > 0.0) { before = start / dist; }
+  let t = (pointY - frame.fogColour.w) * frame.fogHeight.x;
+  let 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. */
+  var denom = rest;
+  if (abs(rest) < 1e-4) { denom = 1e-4; }
+  var depth = frame.fogHeight.y * exp(-t * before) * (dist - start) * (1.0 - exp(-denom)) / denom;
+  if (frame.fogHeight.z > 0.0) {
+    let t2 = (pointY - frame.fogColour.w) * frame.fogHeight.w;
+    let rest2 = t2 * (1.0 - before);
+    var denom2 = rest2;
+    if (abs(rest2) < 1e-4) { denom2 = 1e-4; }
+    depth += frame.fogHeight.z * exp(-t2 * before) * (dist - start) * (1.0 - exp(-denom2)) / denom2;
+  }
+  return depth;
+}
+
 /**
  * How much of a surface at "pointY", "dist" metres away, is lost to the medium between.
  * 0 is perfectly clear, 1 is the medium's own colour.
  */
 fn mediumFog(dist: f32, pointY: f32) -> f32 {
   let underwaterFactor = frame.fogUnderwater.w;
+  /* Past the cutoff the air hides nothing, in either mode; the water column keeps its own law. */
+  let cut = frame.fogLimits.y > 0.0 && dist > frame.fogLimits.y;
   if (frame.fogRange.z == ${LINEAR_FOG}.0) {
     /*
      * A consumer asking for a hard cut writes far == near, and the guard is why that is a cut and
@@ -40,35 +71,48 @@ fn mediumFog(dist: f32, pointY: f32) -> f32 {
      * shape from the other direction on 2026-09-18: a device may assume NaN never arrives.
      */
     let span = max(frame.fogRange.y - frame.fogRange.x, 1e-4);
-    let ramp = clamp((dist - frame.fogRange.x) / span, 0.0, 1.0);
+    var ramp = min(clamp((dist - frame.fogRange.x) / span, 0.0, 1.0), 1.0 - frame.fogLimits.x);
+    if (cut) { ramp = 0.0; }
     if (underwaterFactor <= 0.0) { return ramp; }
     let wetLinear = frame.fogRange.w * dist;
     return mix(ramp, 1.0 - exp2(-wetLinear * wetLinear * 1.442695), underwaterFactor);
   }
 
-  /* Where the medium begins along the ray: fogRange.x, the linear mode's near, which this mode
-     never read before Atmosphere.fogStart. Integrated from there on, at that point's density; at
-     a start of 0 every term is the one it always was. See render/fog.ts. */
-  let start = min(frame.fogRange.x, dist);
-  var before = 0.0;
-  if (dist > 0.0) { before = start / dist; }
-  let t = (pointY - frame.fogColour.w) * frame.fogHeight.x;
-  let 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. */
-  var denom = rest;
-  if (abs(rest) < 1e-4) { denom = 1e-4; }
-  let air =
-    1.0 - exp(-frame.fogHeight.y * exp(-t * before) * (dist - start) * (1.0 - exp(-denom)) / denom);
+  /* Beer-Lambert through both layers, leaving at least fogLimits.x of the surface. */
+  var air = 1.0 - max(exp(-hazeDepth(dist, pointY)), frame.fogLimits.x);
+  if (cut) { air = 0.0; }
   if (underwaterFactor <= 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. */
   let wet = frame.fogRange.w * dist;
   return mix(air, 1.0 - exp2(-wet * wet * 1.442695), underwaterFactor);
 }
+
+/**
+ * The sun's light the haze scatters toward the eye along a ray to a point at "pointY", "dist"
+ * metres away in the unit direction "toPoint": added after the fog, never mixed. None in a linear
+ * ramp, past the cutoff or under water; render/fog.ts says the rest.
+ */
+fn mediumGlow(dist: f32, pointY: f32, toPoint: vec3<f32>) -> vec3<f32> {
+  if (frame.fogRange.z == ${LINEAR_FOG}.0) { return vec3<f32>(0.0); }
+  if (max(max(frame.fogGlow.x, frame.fogGlow.y), frame.fogGlow.z) <= 0.0) { return vec3<f32>(0.0); }
+  if (frame.fogLimits.y > 0.0 && dist > frame.fogLimits.y) { return vec3<f32>(0.0); }
+  let span = dist - min(frame.fogRange.x, dist);
+  if (span <= 0.0) { return vec3<f32>(0.0); }
+  let perMetre = hazeDepth(dist, pointY) / span;
+  let hidden = 1.0 - exp(-perMetre * max(span - frame.fogGlowDir.w, 0.0));
+  let lobe = pow(clamp(dot(toPoint, frame.fogGlowDir.xyz), 0.0, 1.0), frame.fogGlow.w);
+  return frame.fogGlow.xyz * (lobe * hidden * (1.0 - frame.fogUnderwater.w));
+}
 `;
-/** Floats a case of the fog check: distance, height, and the ten options. */
-export const FOG_CASE_FLOATS = 16;
+/**
+ * Floats a case of the fog check: distance, height, the ten options, the second layer, the floor
+ * and the cutoff, the glow's colour, exponent, direction and start, the ray's direction, and one
+ * spare.
+ */
+export const FOG_CASE_FLOATS = 32;
+/** Floats a case's answer: the fog, the colour, and the glow, and one spare. */
+export const FOG_RESULT_FLOATS = 8;
 /**
  * An entry point that does nothing but fog, so `gpu-parity.mjs` can compare the expression above
  * with `render/fog.ts` directly rather than through a shading pass that writes to a texture.
@@ -87,6 +131,12 @@ struct Frame {
   fogHeight: vec4<f32>,
   /** Linear near and far, the mode, and the water's own density. */
   fogRange: vec4<f32>,
+  /** The least of a surface the haze must leave, the cutoff, and two spare. */
+  fogLimits: vec4<f32>,
+  /** The sun glow's colour and exponent. */
+  fogGlow: vec4<f32>,
+  /** Surface → its light, and its start. */
+  fogGlowDir: vec4<f32>,
 }
 
 @group(0) @binding(0) var<storage, read> cases: array<f32>;
@@ -102,14 +152,22 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
   let pointY = cases[at + 1u];
   frame.fogColour = vec4<f32>(cases[at + 2u], cases[at + 3u], cases[at + 4u], cases[at + 5u]);
   frame.fogUnderwater = vec4<f32>(cases[at + 6u], cases[at + 7u], cases[at + 8u], cases[at + 9u]);
-  frame.fogHeight = vec4<f32>(cases[at + 10u], cases[at + 11u], 0.0, 0.0);
+  frame.fogHeight = vec4<f32>(cases[at + 10u], cases[at + 11u], cases[at + 16u], cases[at + 17u]);
   frame.fogRange = vec4<f32>(cases[at + 12u], cases[at + 13u], cases[at + 14u], cases[at + 15u]);
+  frame.fogLimits = vec4<f32>(cases[at + 18u], cases[at + 19u], 0.0, 0.0);
+  frame.fogGlow = vec4<f32>(cases[at + 20u], cases[at + 21u], cases[at + 22u], cases[at + 23u]);
+  frame.fogGlowDir = vec4<f32>(cases[at + 24u], cases[at + 25u], cases[at + 26u], cases[at + 27u]);
+  let toPoint = vec3<f32>(cases[at + 28u], cases[at + 29u], cases[at + 30u]);
 
-  let out = id.x * 4u;
+  let out = id.x * ${FOG_RESULT_FLOATS}u;
   results[out] = mediumFog(dist, pointY);
   let colour = mediumColour();
   results[out + 1u] = colour.x;
   results[out + 2u] = colour.y;
   results[out + 3u] = colour.z;
+  let glow = mediumGlow(dist, pointY, toPoint);
+  results[out + 4u] = glow.x;
+  results[out + 5u] = glow.y;
+  results[out + 6u] = glow.z;
 }
 `;

package/dist/render/shaders/gpudriven/frameBlock.wgsl.d.ts

@@ -10,4 +10,4 @@
  * `gpuDrivenPass.ts` writes it through the `FRAME_*` offsets beside `FRAME_FLOATS`, which are the
  * other half of this contract.
  */
-export declare const FRAME_BLOCK_WGSL = "\nstruct Frame {\n  viewProj: mat4x4<f32>,\n  /*\n   * The light's, corrected for the lookup rather than for the raster: x and y still in -1..1 and\n   * z already in 0..1. gpudriven/shadowCamera.ts carries why those are two different matrices.\n   */\n  lightViewProj: mat4x4<f32>,\n  eye: vec4<f32>,\n  lightDir: vec4<f32>,\n  lightColour: vec4<f32>,\n  sky: vec4<f32>,\n  ground: vec4<f32>,\n  /** width, height, the simulation time, and the latent layer's edge in texels. */\n  size: vec4<f32>,\n  /** The shadow: strength, map size, depth span, the distance it fades over. */\n  shadow: vec4<f32>,\n  /** Its remaining limits: the steepest sun that still casts, the tap count, and two spare. */\n  shadowLimits: vec4<f32>,\n  /** The probe: texels across level 0, the coarsest GGX level, the cosine level, and 1 if bound. */\n  environment: vec4<f32>,\n  /**\n   * How much of the hemispheric ambient the probe's irradiance replaces, the frame's emissive gain\n   * times its night factor, and two spare.\n   */\n  environmentMix: vec4<f32>,\n  /**\n   * The medium, in four blocks, and render/fog.ts is what reads them.\n   *\n   * **A frame that asks for nothing draws nothing**: a density of zero and the medium mode make\n   * mediumFog exactly zero at every distance, which is arithmetically the frame the pipeline drew\n   * before it had a haze at all.\n   */\n  /** rgb is the haze's colour, w is the eye's height. */\n  fogColour: vec4<f32>,\n  /** rgb is the water's colour, w is how far under it the camera is. */\n  fogUnderwater: vec4<f32>,\n  /** Reciprocal scale height, extinction per metre at the eye, and two spare. */\n  fogHeight: vec4<f32>,\n  /** Linear near and far, the mode, and the water's own density. */\n  fogRange: vec4<f32>,\n  /**\n   * The visibility buffer's row in texels \u2014 the width rounded up for the copy's row alignment \u2014\n   * and three spare. A pixel is found by this and placed by size.x, which is the width the raster\n   * drew at; the two differ on every frame whose width is not a multiple of sixty-four. Not\n   * \"target\", which WGSL reserves.\n   */\n  pitch: vec4<f32>,\n}\n";
+export declare const FRAME_BLOCK_WGSL = "\nstruct Frame {\n  viewProj: mat4x4<f32>,\n  /*\n   * The light's, corrected for the lookup rather than for the raster: x and y still in -1..1 and\n   * z already in 0..1. gpudriven/shadowCamera.ts carries why those are two different matrices.\n   */\n  lightViewProj: mat4x4<f32>,\n  eye: vec4<f32>,\n  lightDir: vec4<f32>,\n  lightColour: vec4<f32>,\n  sky: vec4<f32>,\n  ground: vec4<f32>,\n  /** width, height, the simulation time, and the latent layer's edge in texels. */\n  size: vec4<f32>,\n  /** The shadow: strength, map size, depth span, the distance it fades over. */\n  shadow: vec4<f32>,\n  /** Its remaining limits: the steepest sun that still casts, the tap count, and two spare. */\n  shadowLimits: vec4<f32>,\n  /** The probe: texels across level 0, the coarsest GGX level, the cosine level, and 1 if bound. */\n  environment: vec4<f32>,\n  /**\n   * How much of the hemispheric ambient the probe's irradiance replaces, the frame's emissive gain\n   * times its night factor, and two spare.\n   */\n  environmentMix: vec4<f32>,\n  /**\n   * The medium, in four blocks, and render/fog.ts is what reads them.\n   *\n   * **A frame that asks for nothing draws nothing**: a density of zero and the medium mode make\n   * mediumFog exactly zero at every distance, which is arithmetically the frame the pipeline drew\n   * before it had a haze at all.\n   */\n  /** rgb is the haze's colour, w is the eye's height. */\n  fogColour: vec4<f32>,\n  /** rgb is the water's colour, w is how far under it the camera is. */\n  fogUnderwater: vec4<f32>,\n  /**\n   * Reciprocal scale height and extinction per metre at the eye; then the second layer's\n   * extinction at the eye and its reciprocal scale height, zero for none.\n   */\n  fogHeight: vec4<f32>,\n  /** Linear near and far, the mode, and the water's own density. */\n  fogRange: vec4<f32>,\n  /**\n   * The visibility buffer's row in texels \u2014 the width rounded up for the copy's row alignment \u2014\n   * and three spare. A pixel is found by this and placed by size.x, which is the width the raster\n   * drew at; the two differ on every frame whose width is not a multiple of sixty-four. Not\n   * \"target\", which WGSL reserves.\n   */\n  pitch: vec4<f32>,\n  /**\n   * The rest of the medium, after the pitch so nothing above it moves: the least of a surface the\n   * haze must leave and the cutoff, both none at zero, and two spare; the sun glow's colour, black\n   * for none, and its exponent; and surface \u2192 its light, and its start. render/fog.ts reads them.\n   */\n  fogLimits: vec4<f32>,\n  fogGlow: vec4<f32>,\n  fogGlowDir: vec4<f32>,\n}\n";

package/dist/render/shaders/gpudriven/frameBlock.wgsl.js

@@ -47,7 +47,10 @@ struct Frame {
   fogColour: vec4<f32>,
   /** rgb is the water's colour, w is how far under it the camera is. */
   fogUnderwater: vec4<f32>,
-  /** Reciprocal scale height, extinction per metre at the eye, and two spare. */
+  /**
+   * Reciprocal scale height and extinction per metre at the eye; then the second layer's
+   * extinction at the eye and its reciprocal scale height, zero for none.
+   */
   fogHeight: vec4<f32>,
   /** Linear near and far, the mode, and the water's own density. */
   fogRange: vec4<f32>,
@@ -58,5 +61,13 @@ struct Frame {
    * "target", which WGSL reserves.
    */
   pitch: vec4<f32>,
+  /**
+   * The rest of the medium, after the pitch so nothing above it moves: the least of a surface the
+   * haze must leave and the cutoff, both none at zero, and two spare; the sun glow's colour, black
+   * for none, and its exponent; and surface → its light, and its start. render/fog.ts reads them.
+   */
+  fogLimits: vec4<f32>,
+  fogGlow: vec4<f32>,
+  fogGlowDir: vec4<f32>,
 }
 `;

package/dist/render/shaders/gpudriven/shade.wgsl.js

@@ -816,7 +816,9 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
    * point and for the same reason: fog is the air in front of the picture rather than a property
    * of the surface, so it is the last thing between a shaded colour and the frame.
    */
-  let hazed = mix(lit, mediumColour(), mediumFog(distance(world, frame.eye.xyz), world.y));
+  let dist = distance(world, frame.eye.xyz);
+  let hazed = mix(lit, mediumColour(), mediumFog(dist, world.y))
+    + mediumGlow(dist, world.y, normalize(world - frame.eye.xyz));
 
   textureStore(frameColour, vec2<u32>(x, y), vec4<f32>(hazed, 1.0));
 }

package/dist/render/shaders/line.d.ts

@@ -15,4 +15,4 @@
  * draws.
  */
 export declare const LINE_VERT = "#version 300 es\nlayout(location = 0) in vec3 aFrom;\nlayout(location = 1) in vec3 aTo;\n/** Along the segment (0 or 1), and which side of it (-1 or +1). */\nlayout(location = 2) in vec2 aCorner;\n\nuniform mat4 uViewProj;\nuniform mat4 uModel;\nuniform vec3 uCameraPos;\n/** Half-width in metres, and how much of a pixel a far line must still cover. */\nuniform float uWidth;\nuniform float uMinWidthPerMetre;\n\nout float vSide;\nout vec3 vWorldPos;\n\nvoid main() {\n  /*\n   * Through the model matrix before anything else, unlike an arc, whose endpoints are\n   * world-space by nature. A line is usually attached to something that moves, and the\n   * alternative is making every caller transform its own points on the CPU each frame.\n   *\n   * The width is deliberately *not* scaled by the model. A stroke's weight is a property\n   * of how it is drawn rather than of the geometry it follows, so a card that shrinks\n   * keeps the same line weight, which is what a reader expects and what a designer means.\n   */\n  vec3 from = (uModel * vec4(aFrom, 1.0)).xyz;\n  vec3 to = (uModel * vec4(aTo, 1.0)).xyz;\n\n  vec3 mid = mix(from, to, aCorner.x);\n  vec3 dir = to - from;\n  float len = length(dir);\n  dir = len > 1e-6 ? dir / len : vec3(0.0, 1.0, 0.0);\n\n  vec3 view = mid - uCameraPos;\n  float dist = length(view);\n  view = dist > 1e-6 ? view / dist : vec3(0.0, 0.0, 1.0);\n\n  /*\n   * Across the segment and across the line of sight. Degenerate exactly when the segment\n   * points at the viewer, where any perpendicular is as good as another, and where the\n   * segment covers almost no screen anyway.\n   */\n  vec3 across = cross(dir, view);\n  float span = length(across);\n  across = span > 1e-4 ? across / span : normalize(cross(dir, vec3(0.0, 1.0, 0.0)) + vec3(1e-3));\n\n  /*\n   * A floor on the world-space width that grows with distance, so a stroke never thins\n   * below a pixel. Under a pixel a thin line does not get fainter, it *flickers*, because\n   * the rasteriser catches it on some frames and not others.\n   */\n  float halfWidth = max(uWidth, dist * uMinWidthPerMetre);\n  vec3 world = mid + across * aCorner.y * halfWidth;\n\n  vSide = aCorner.y;\n  vWorldPos = world;\n  gl_Position = uViewProj * vec4(world, 1.0);\n}\n";
-export declare const LINE_FRAG = "#version 300 es\nprecision highp float;\n\nin float vSide;\nin vec3 vWorldPos;\n\nuniform vec3 uColor;\nuniform float uOpacity;\nuniform vec3 uCameraPos;\n/**\n * How far in from the edge the stroke fades, as a fraction of its half-width. Zero is a\n * clean edge, one is a stroke that is soft all the way to its middle.\n */\nuniform float uSoftness;\n\n\nuniform vec3 uFogColor;\n/** Extinction per metre **at the camera's own height**, not at the base. */\nuniform float uFogDensity;\n/** Reciprocal scale height of the haze, per metre. 0 is a uniform medium. */\nuniform float uFogHeightFalloff;\n/** The camera's height, so a fragment's own height is one subtraction away. */\nuniform float uFogEyeY;\nuniform vec3 uUnderwaterColor;\nuniform float uUnderwaterFogDensity;\nuniform float uUnderwaterFactor;\n/** 0 integrates a medium (Beer-Lambert); 1 ramps linearly between near and far. */\nuniform int uFogMode;\n/** Linear mode only: where haze begins, and where it is total. */\nuniform float uFogNear;\nuniform float uFogFar;\n\n/** What distance converges toward: the day's haze, or the water column. */\nvec3 mediumColor() {\n  return mix(uFogColor, uUnderwaterColor, uUnderwaterFactor);\n}\n\n/**\n * How much of a surface standing at height pointY, dist metres away, is lost to\n * the medium in between. 0 is perfectly clear, 1 is the medium's own colour.\n */\nfloat mediumFog(float dist, float pointY) {\n  /*\n   * A depth ramp rather than a medium, for worlds authored against one.\n   *\n   * Beer-Lambert is the honest model and stays the default: it integrates something\n   * physically there, so extinction begins at the eye and never stops. A linear near/far\n   * fog is not that \u2014 it is a *look*, with a hard start distance before which the air is\n   * perfectly clear, and it is what the fixed-function pipeline offered and what several\n   * renderers still expose. Approximating one with the other is not a matter of tuning:\n   * matched at half occlusion, the exponential curve still lays haze over everything\n   * inside near, where the ramp lays none, and near-field colour desaturates toward the\n   * fog colour with nothing to show for it.\n   *\n   * Height falloff has no meaning here and is ignored: a ramp is defined on distance\n   * alone.\n   */\n  if (uFogMode == 1) {\n    float span = max(uFogFar - uFogNear, 1e-4);\n    float ramp = clamp((dist - uFogNear) / span, 0.0, 1.0);\n    if (uUnderwaterFactor <= 0.0) return ramp;\n    float wetLinear = uUnderwaterFogDensity * dist;\n    return mix(ramp, 1.0 - exp2(-wetLinear * wetLinear * 1.442695), uUnderwaterFactor);\n  }\n\n  // Where the medium begins along the ray: uFogNear, the linear mode's slot, which this mode\n  // never read before Atmosphere.fogStart. The ray is integrated from there on, at the density\n  // of that point; at a start of 0 every term is the one it always was. See render/fog.ts.\n  float start = min(uFogNear, dist);\n  float before = dist > 0.0 ? start / dist : 0.0;\n  float t = (pointY - uFogEyeY) * uFogHeightFalloff;\n  float rest = t * (1.0 - before);\n  // (1 - e^-t)/t, which tends to 1 as the ray levels out. Guarded rather than\n  // branched: at t = 0 the quotient is 0/0, and 1e-4 of a scale height is 8 mm.\n  float denom = abs(rest) < 1e-4 ? 1e-4 : rest;\n  float air =\n    1.0 - exp(-uFogDensity * exp(-t * before) * (dist - start) * (1.0 - exp(-denom)) / denom);\n  if (uUnderwaterFactor <= 0.0) return air;\n  // Water is its own medium and keeps its own curve, so crossing the surface\n  // changes nothing about how the water column reads.\n  float wet = uUnderwaterFogDensity * dist;\n  return mix(air, 1.0 - exp2(-wet * wet * 1.442695), uUnderwaterFactor);\n}\n\n\nout vec4 outColor;\n\n/** 0 none, 1 sRGB, 2 ACES then sRGB, 3 the highlight shoulder then sRGB. See renderQuality.ts. */\nuniform int uOutputTransform;\n/** Scales the scene into the tone curve. 1 is the reference grade. See renderQuality.ts. */\nuniform float uOutputExposure;\n\n/*\n * ACES: the reference fit, not the cheap one.\n *\n * This was Narkowicz's single rational function, on the argument that the difference from\n * the reference curve is invisible next to the gain. That argument holds for a look and\n * fails for a *match*, which is what this option is for \u2014 aces exists so a world ported\n * from three.js reads the same, and three.js applies the full fit: into AP1 through\n * ACESInputMat, the RRT and ODT together, then back out through ACESOutputMat.\n *\n * The two curves are not a shade apart. Narkowicz is markedly brighter through the\n * midtones, which is exactly where an interior scene lives, and it is a large part of a\n * measured ~1.7x that survived correcting the colour space and the missing Lambert pi.\n * An approximation of a standard is the wrong thing to hold when the standard is the\n * specification.\n */\nvec3 rrtAndOdtFit(vec3 v) {\n  vec3 a = v * (v + 0.0245786) - 0.000090537;\n  vec3 b = v * (0.983729 * v + 0.4329510) + 0.238081;\n  return a / b;\n}\n\nvec3 acesFilmic(vec3 x) {\n  /*\n   * Exposure first, because a tone curve is only defined relative to one.\n   *\n   * The reference RRT and ODT are graded for a dark cinema. Every renderer that ships ACES\n   * scales its input to suit whatever it is actually shown on, and the factor each one\n   * picks is a *look*, not a standard - so this engine takes no position and reads it from\n   * the caller. Neutral by default, which is the reference grade unmodified. three.js's own\n   * pick is 1 / 0.6, for a consumer matching one.\n   */\n  x *= uOutputExposure;\n  // Columns, as GLSL reads them: sRGB -> XYZ -> D65_2_D60 -> AP1 -> RRT_SAT.\n  const mat3 ACES_INPUT = mat3(\n    0.59719, 0.07600, 0.02840,\n    0.35458, 0.90834, 0.13383,\n    0.04823, 0.01566, 0.83777\n  );\n  // ODT_SAT -> XYZ -> D60_2_D65 -> sRGB.\n  const mat3 ACES_OUTPUT = mat3(\n     1.60475, -0.10208, -0.00327,\n    -0.53108,  1.10813, -0.07276,\n    -0.07367, -0.00605,  1.07602\n  );\n  return clamp(ACES_OUTPUT * rrtAndOdtFit(ACES_INPUT * x), 0.0, 1.0);\n}\n\n\n/*\n * Linear to sRGB. The piecewise form rather than a plain pow: the linear toe near black\n * is where banding lives in an 8-bit buffer, and the cheap approximation puts it in the\n * wrong place.\n */\nvec3 linearToSrgb(vec3 c) {\n  vec3 low = c * 12.92;\n  vec3 high = 1.055 * pow(max(c, vec3(0.0)), vec3(1.0 / 2.4)) - 0.055;\n  return mix(high, low, step(c, vec3(0.0031308)));\n}\n\n\nvec3 highlightShoulder(vec3 c) {\n  float m = max(c.r, max(c.g, c.b));\n  if (m <= 0.8) return c;\n  float e = m - 0.8;\n  return c * ((0.8 + 0.2 * e / (e + 0.2)) / m);\n}\n\nvec3 applyOutputTransform(vec3 c) {\n  if (uOutputTransform == 0) return c;\n  if (uOutputTransform == 2) c = acesFilmic(c);\n  if (uOutputTransform == 3) c = highlightShoulder(c * uOutputExposure);\n  return linearToSrgb(c);\n}\n\n\nvoid main() {\n  /*\n   * Coverage across the ribbon: one down the middle, falling to zero at both edges.\n   *\n   * The band is at least one pixel wide *in screen space*, which is what lets one shader\n   * draw a stroke of any width at any distance without either aliasing into a staircase or\n   * blurring into a smear. A constant band is tuned for one width and is wrong at the rest,\n   * which is the same argument `SDF_TEXT_FRAG` makes for the same reason.\n   */\n  float edge = 1.0 - abs(vSide);\n  float band = max(fwidth(vSide), uSoftness);\n  float coverage = smoothstep(0.0, band, edge);\n\n  /*\n   * Fogged like geometry, which is where this parts company with `bolt.ts`. That shader\n   * includes the same helpers and never calls them, because an arc is light arriving\n   * rather than a surface losing some of itself to the air on the way over. A drawn line\n   * is a thing in the world and recedes like one.\n   */\n  float fog = mediumFog(distance(vWorldPos, uCameraPos), vWorldPos.y);\n  vec3 color = mix(uColor, mediumColor(), fog);\n  outColor = vec4(applyOutputTransform(color), coverage * uOpacity);\n}\n";
+export declare const LINE_FRAG = "#version 300 es\nprecision highp float;\n\nin float vSide;\nin vec3 vWorldPos;\n\nuniform vec3 uColor;\nuniform float uOpacity;\nuniform vec3 uCameraPos;\n/**\n * How far in from the edge the stroke fades, as a fraction of its half-width. Zero is a\n * clean edge, one is a stroke that is soft all the way to its middle.\n */\nuniform float uSoftness;\n\n\nuniform vec3 uFogColor;\n/**\n * The haze: its extinction per metre **at the camera's own height**, not at the base; its\n * reciprocal scale height per metre, 0 for a uniform medium; the camera's height, so a fragment's\n * own height is one subtraction away; and the water column's own density.\n *\n * **Four numbers in one vector rather than four uniforms**, and the reason is a phone: a scalar\n * costs a whole row of the uniform grid, and the lit stage at its eight-light rung must fit the 256\n * rows an Adreno 740 offers (uniformVectorBudget.ts). Packed, the haze's eight scalars cost two\n * rows where they cost eight, which is what paid for the second layer and the sun's glow below.\n */\nuniform vec4 uFogMedium;\n/** Where haze begins, where a linear ramp is total, and the mode: 0 a medium, 1 a ramp. */\nuniform vec4 uFogRange;\nuniform vec3 uUnderwaterColor;\nuniform float uUnderwaterFactor;\n/**\n * The second layer's extinction per metre at the camera's height and its falloff; then the least of\n * a surface the haze must leave, Atmosphere.fogMaxOpacity's complement, and the distance past which\n * it hides nothing (0 is none). **Every lane is none at zero**, and so are uFogGlow's: a program a\n * binder never wrote these into draws the haze it drew before they existed, rather than none.\n */\nuniform vec4 uFogLayer2;\n/** The sun's glow in the haze: its colour, black for none, and the exponent of its lobe. */\nuniform vec4 uFogGlow;\n/** Surface \u2192 the glow's light, and how far past the haze's start the glow begins. */\nuniform vec4 uFogGlowDir;\n\n/** What distance converges toward: the day's haze, or the water column. */\nvec3 mediumColor() {\n  return mix(uFogColor, uUnderwaterColor, uUnderwaterFactor);\n}\n\n/**\n * The haze's optical depth from where it begins along the ray to a point at height pointY, dist\n * metres away: each layer's density at the eye carried over what is left of the ray, with the\n * second layer only where there is one. The fog and the sun's glow both integrate it.\n */\nfloat hazeDepth(float dist, float pointY) {\n  // Where the medium begins along the ray: uFogRange.x, the linear mode's slot, which this mode\n  // never read before Atmosphere.fogStart. The ray is integrated from there on, at the density\n  // of that point; at a start of 0 every term is the one it always was. See render/fog.ts.\n  float start = min(uFogRange.x, dist);\n  float before = dist > 0.0 ? start / dist : 0.0;\n  float t = (pointY - uFogMedium.z) * uFogMedium.y;\n  float rest = t * (1.0 - before);\n  // (1 - e^-t)/t, which tends to 1 as the ray levels out. Guarded rather than\n  // branched: at t = 0 the quotient is 0/0, and 1e-4 of a scale height is 8 mm.\n  float denom = abs(rest) < 1e-4 ? 1e-4 : rest;\n  float depth = uFogMedium.x * exp(-t * before) * (dist - start) * (1.0 - exp(-denom)) / denom;\n  if (uFogLayer2.x > 0.0) {\n    float t2 = (pointY - uFogMedium.z) * uFogLayer2.y;\n    float rest2 = t2 * (1.0 - before);\n    float denom2 = abs(rest2) < 1e-4 ? 1e-4 : rest2;\n    depth += uFogLayer2.x * exp(-t2 * before) * (dist - start) * (1.0 - exp(-denom2)) / denom2;\n  }\n  return depth;\n}\n\n/**\n * How much of a surface standing at height pointY, dist metres away, is lost to\n * the medium in between. 0 is perfectly clear, 1 is the medium's own colour.\n */\nfloat mediumFog(float dist, float pointY) {\n  /* Past the cutoff the air hides nothing, in either mode; the water column keeps its own law. */\n  bool cut = uFogLayer2.w > 0.0 && dist > uFogLayer2.w;\n  /*\n   * A depth ramp rather than a medium, for worlds authored against one.\n   *\n   * Beer-Lambert is the honest model and stays the default: it integrates something\n   * physically there, so extinction begins at the eye and never stops. A linear near/far\n   * fog is not that \u2014 it is a *look*, with a hard start distance before which the air is\n   * perfectly clear, and it is what the fixed-function pipeline offered and what several\n   * renderers still expose. Approximating one with the other is not a matter of tuning:\n   * matched at half occlusion, the exponential curve still lays haze over everything\n   * inside near, where the ramp lays none, and near-field colour desaturates toward the\n   * fog colour with nothing to show for it.\n   *\n   * Height falloff has no meaning here and is ignored: a ramp is defined on distance\n   * alone.\n   */\n  if (uFogRange.z == 1.0) {\n    float span = max(uFogRange.y - uFogRange.x, 1e-4);\n    float ramp = cut ? 0.0 : min(clamp((dist - uFogRange.x) / span, 0.0, 1.0), 1.0 - uFogLayer2.z);\n    if (uUnderwaterFactor <= 0.0) return ramp;\n    float wetLinear = uFogMedium.w * dist;\n    return mix(ramp, 1.0 - exp2(-wetLinear * wetLinear * 1.442695), uUnderwaterFactor);\n  }\n\n  // Beer-Lambert through both layers, leaving at least uFogLayer2.z of the surface: a floor on\n  // what survives rather than a ceiling on the depth, so the curve keeps its shape above it.\n  float air = cut ? 0.0 : 1.0 - max(exp(-hazeDepth(dist, pointY)), uFogLayer2.z);\n  if (uUnderwaterFactor <= 0.0) return air;\n  // Water is its own medium and keeps its own curve, so crossing the surface\n  // changes nothing about how the water column reads.\n  float wet = uFogMedium.w * dist;\n  return mix(air, 1.0 - exp2(-wet * wet * 1.442695), uUnderwaterFactor);\n}\n\n/**\n * The sun's light the haze scatters toward the eye along a ray to a point at height pointY, dist\n * metres away in the direction toPoint: added to a surface after its fog, never mixed. A lobe of\n * cos^exponent about the light, by as much of the ray past the glow's own start as the haze hides \u2014\n * the haze's depth per metre carried over that stretch. None in a linear ramp, past the cutoff, or\n * under water, which keeps its own medium.\n */\nvec3 mediumGlow(float dist, float pointY, vec3 toPoint) {\n  if (uFogRange.z == 1.0 || max(max(uFogGlow.r, uFogGlow.g), uFogGlow.b) <= 0.0) return vec3(0.0);\n  if (uFogLayer2.w > 0.0 && dist > uFogLayer2.w) return vec3(0.0);\n  float span = dist - min(uFogRange.x, dist);\n  if (span <= 0.0) return vec3(0.0);\n  float perMetre = hazeDepth(dist, pointY) / span;\n  float hidden = 1.0 - exp(-perMetre * max(span - uFogGlowDir.w, 0.0));\n  float lobe = pow(clamp(dot(toPoint, uFogGlowDir.xyz), 0.0, 1.0), uFogGlow.a);\n  return uFogGlow.rgb * (lobe * hidden * (1.0 - uUnderwaterFactor));\n}\n\n\nout vec4 outColor;\n\n/** 0 none, 1 sRGB, 2 ACES then sRGB, 3 the highlight shoulder then sRGB. See renderQuality.ts. */\nuniform int uOutputTransform;\n/** Scales the scene into the tone curve. 1 is the reference grade. See renderQuality.ts. */\nuniform float uOutputExposure;\n\n/*\n * ACES: the reference fit, not the cheap one.\n *\n * This was Narkowicz's single rational function, on the argument that the difference from\n * the reference curve is invisible next to the gain. That argument holds for a look and\n * fails for a *match*, which is what this option is for \u2014 aces exists so a world ported\n * from three.js reads the same, and three.js applies the full fit: into AP1 through\n * ACESInputMat, the RRT and ODT together, then back out through ACESOutputMat.\n *\n * The two curves are not a shade apart. Narkowicz is markedly brighter through the\n * midtones, which is exactly where an interior scene lives, and it is a large part of a\n * measured ~1.7x that survived correcting the colour space and the missing Lambert pi.\n * An approximation of a standard is the wrong thing to hold when the standard is the\n * specification.\n */\nvec3 rrtAndOdtFit(vec3 v) {\n  vec3 a = v * (v + 0.0245786) - 0.000090537;\n  vec3 b = v * (0.983729 * v + 0.4329510) + 0.238081;\n  return a / b;\n}\n\nvec3 acesFilmic(vec3 x) {\n  /*\n   * Exposure first, because a tone curve is only defined relative to one.\n   *\n   * The reference RRT and ODT are graded for a dark cinema. Every renderer that ships ACES\n   * scales its input to suit whatever it is actually shown on, and the factor each one\n   * picks is a *look*, not a standard - so this engine takes no position and reads it from\n   * the caller. Neutral by default, which is the reference grade unmodified. three.js's own\n   * pick is 1 / 0.6, for a consumer matching one.\n   */\n  x *= uOutputExposure;\n  // Columns, as GLSL reads them: sRGB -> XYZ -> D65_2_D60 -> AP1 -> RRT_SAT.\n  const mat3 ACES_INPUT = mat3(\n    0.59719, 0.07600, 0.02840,\n    0.35458, 0.90834, 0.13383,\n    0.04823, 0.01566, 0.83777\n  );\n  // ODT_SAT -> XYZ -> D60_2_D65 -> sRGB.\n  const mat3 ACES_OUTPUT = mat3(\n     1.60475, -0.10208, -0.00327,\n    -0.53108,  1.10813, -0.07276,\n    -0.07367, -0.00605,  1.07602\n  );\n  return clamp(ACES_OUTPUT * rrtAndOdtFit(ACES_INPUT * x), 0.0, 1.0);\n}\n\n\n/*\n * Linear to sRGB. The piecewise form rather than a plain pow: the linear toe near black\n * is where banding lives in an 8-bit buffer, and the cheap approximation puts it in the\n * wrong place.\n */\nvec3 linearToSrgb(vec3 c) {\n  vec3 low = c * 12.92;\n  vec3 high = 1.055 * pow(max(c, vec3(0.0)), vec3(1.0 / 2.4)) - 0.055;\n  return mix(high, low, step(c, vec3(0.0031308)));\n}\n\n\nvec3 highlightShoulder(vec3 c) {\n  float m = max(c.r, max(c.g, c.b));\n  if (m <= 0.8) return c;\n  float e = m - 0.8;\n  return c * ((0.8 + 0.2 * e / (e + 0.2)) / m);\n}\n\nvec3 applyOutputTransform(vec3 c) {\n  if (uOutputTransform == 0) return c;\n  if (uOutputTransform == 2) c = acesFilmic(c);\n  if (uOutputTransform == 3) c = highlightShoulder(c * uOutputExposure);\n  return linearToSrgb(c);\n}\n\n\nvoid main() {\n  /*\n   * Coverage across the ribbon: one down the middle, falling to zero at both edges.\n   *\n   * The band is at least one pixel wide *in screen space*, which is what lets one shader\n   * draw a stroke of any width at any distance without either aliasing into a staircase or\n   * blurring into a smear. A constant band is tuned for one width and is wrong at the rest,\n   * which is the same argument `SDF_TEXT_FRAG` makes for the same reason.\n   */\n  float edge = 1.0 - abs(vSide);\n  float band = max(fwidth(vSide), uSoftness);\n  float coverage = smoothstep(0.0, band, edge);\n\n  /*\n   * Fogged like geometry, which is where this parts company with `bolt.ts`. That shader\n   * includes the same helpers and never calls them, because an arc is light arriving\n   * rather than a surface losing some of itself to the air on the way over. A drawn line\n   * is a thing in the world and recedes like one.\n   */\n  float dist = distance(vWorldPos, uCameraPos);\n  float fog = mediumFog(dist, vWorldPos.y);\n  vec3 color =\n    mix(uColor, mediumColor(), fog) + mediumGlow(dist, vWorldPos.y, normalize(vWorldPos - uCameraPos));\n  outColor = vec4(applyOutputTransform(color), coverage * uOpacity);\n}\n";

package/dist/render/shaders/line.js

@@ -115,8 +115,10 @@ void main() {
    * rather than a surface losing some of itself to the air on the way over. A drawn line
    * is a thing in the world and recedes like one.
    */
-  float fog = mediumFog(distance(vWorldPos, uCameraPos), vWorldPos.y);
-  vec3 color = mix(uColor, mediumColor(), fog);
+  float dist = distance(vWorldPos, uCameraPos);
+  float fog = mediumFog(dist, vWorldPos.y);
+  vec3 color =
+    mix(uColor, mediumColor(), fog) + mediumGlow(dist, vWorldPos.y, normalize(vWorldPos - uCameraPos));
   outColor = vec4(applyOutputTransform(color), coverage * uOpacity);
 }
 `;

package/dist/render/shaders/localExposure.d.ts

@@ -14,7 +14,8 @@ export declare const LOCAL_RANGE_STOPS = 3;
  */
 export declare const EXPOSURE_LOCAL_FRAG: string;
 /**
- * The composite's half. Needs `AUTO_EXPOSURE_GLSL` before it, for the held brightness.
+ * The composite's half. Needs `AUTO_EXPOSURE_GLSL` and `uOutputExposure` before it, for the held
+ * brightness and the frame's exposure.
  *
  * A block is read clamped half a texel inside its own tiles, so the filter never reaches into the
  * neighbouring band's block. Every fetch is at level zero: the grid has one level, and the branch
@@ -31,5 +32,45 @@ export declare function localBin(pixelLog2: number): {
 export declare function sliceLocal(sumLower: number, countLower: number, sumUpper: number, countUpper: number, weight: number, tileMean: number): number;
 /** A region's gain for a local level and the frame's held one at `strength`, as the composite. */
 export declare function localExposureGain(localLog2: number, heldLog2: number, strength: number): number;
+/**
+ * Local exposure as a shape rather than one strength: each region turned about middle grey at the
+ * frame's exposure, the real-time form most engines expose.
+ *
+ * A region's level is its stops from that grey: it keeps `highlightContrast` of them where it is
+ * brighter and `shadowContrast` where it is darker, so 1 leaves it where it is and 0 brings it all
+ * the way to grey. A pixel keeps `detail` of its own stops from its region, so above 1 sharpens the
+ * texture inside a region a curve would have flattened. **What it gives up** is the held level the
+ * one-number form turns about: a frame metered far from grey, a night, is pulled toward grey rather
+ * than toward itself, which is what the form is for and what a caller holding a night dark leaves
+ * off.
+ */
+export interface LocalExposureOptions {
+    /** The share of a region's stops above middle grey it keeps. 1 is none moved. */
+    readonly highlightContrast: number;
+    /** The share it keeps below. */
+    readonly shadowContrast: number;
+    /** The share of a pixel's own stops from its region it keeps. Default 1. */
+    readonly detail?: number;
+    /** How far a region's level leans from its bilateral band toward its tile's mean. Default 0.4. */
+    readonly blurredBlend?: number;
+    /** Stops added to middle grey, the level regions turn about. Default 0. */
+    readonly middleGreyBias?: number;
+    /** The furthest a region moves either way, in stops. Default 8. */
+    readonly range?: number;
+}
+/** Floats `resolveLocalExposure` fills: `uLocalShape`, then `uLocalPivot`. */
+export declare const LOCAL_EXPOSURE_FLOATS = 8;
+/**
+ * Either form of `setLocalExposure` as the composite reads it, into `out`, and whether regions move
+ * at all. The one number is the shape it always was, both shares `1 − strength` about the held
+ * level, at most three stops: so a strength draws what it drew, to the bit.
+ */
+export declare function resolveLocalExposure(setting: number | LocalExposureOptions, out: Float32Array): boolean;
+/**
+ * A pixel's gain from either form, as the composite computes it: `pixelLog2` its own level,
+ * `localLog2` its region's before the blend, `tileMean` its tile's, `heldLog2` the frame's held
+ * brightness and `exposure` the frame's exposure, gain and all; `shape` is `resolveLocalExposure`'s.
+ */
+export declare function localExposureShapedGain(pixelLog2: number, localLog2: number, tileMean: number, heldLog2: number, exposure: number, shape: ArrayLike<number>): number;
 /** A local exposure strength as the shader takes it: 0 to 1, anything else off. */
 export declare function clampLocalExposure(strength: number): number;

package/dist/render/shaders/localExposure.js

@@ -26,7 +26,7 @@
  * whose drama is the contrast itself: a single shaft into a dark room wants the room dark, and the
  * strength is the caller's for that reason.
  */
-import { METER_GRID, METER_MAX_LOG2, METER_MIN_LOG2, METER_TAPS } from './exposure.js';
+import { ADAPTED_KEY, METER_GRID, METER_MAX_LOG2, METER_MIN_LOG2, METER_TAPS } from './exposure.js';
 /** Bands of log luminance, and how many stops each is wide. */
 export const LOCAL_BINS = 10;
 export const LOCAL_BIN_STOPS = (METER_MAX_LOG2 - METER_MIN_LOG2) / LOCAL_BINS;
@@ -78,15 +78,27 @@ void main() {
 }
 `;
 /**
- * The composite's half. Needs `AUTO_EXPOSURE_GLSL` before it, for the held brightness.
+ * The composite's half. Needs `AUTO_EXPOSURE_GLSL` and `uOutputExposure` before it, for the held
+ * brightness and the frame's exposure.
  *
  * A block is read clamped half a texel inside its own tiles, so the filter never reaches into the
  * neighbouring band's block. Every fetch is at level zero: the grid has one level, and the branch
  * on the strength above them is uniform but the pixel's band is not.
  */
 export const LOCAL_EXPOSURE_GLSL = `
-/** How far each region is brought toward the frame, 0 to 1. 0 is off and the whole of the off path. */
+/** Above 0 when regions move at all: 0 is off and the whole of the off path. */
 uniform float uLocalExposure;
+/**
+ * How regions move, as \`resolveLocalExposure\` packs it: the share of a region's stops from the
+ * pivot it keeps above the pivot and below it, each less one; the share of a pixel's own stops
+ * from its region it keeps, less one; and how far a region's level leans toward its tile's mean.
+ */
+uniform vec4 uLocalShape;
+/**
+ * What they move about: 1 for the frame's held brightness, 0 for middle grey at the frame's
+ * exposure; stops added to it; and the furthest a region moves either way.
+ */
+uniform vec4 uLocalPivot;
 /** The bilateral grid: a block of tiles per band of brightness, and one of the tiles' means. */
 uniform highp sampler2D uExposureLocal;
 
@@ -105,9 +117,15 @@ float localExposureGain(vec2 uv, vec3 light) {
   vec2 banded = mix(localBlock(uv, lower), localBlock(uv, upper), clamp(b - lower, 0.0, 1.0));
   float tileMean = localBlock(uv, ${LOCAL_BINS.toFixed(1)}).r;
   float bilateral = banded.y > 1e-3 ? banded.x / banded.y : tileMean;
-  float local = mix(bilateral, tileMean, ${LOCAL_BLURRED_BLEND.toFixed(1)});
-  float stops = uLocalExposure * (held - local);
-  return exp2(clamp(stops, -${LOCAL_RANGE_STOPS.toFixed(1)}, ${LOCAL_RANGE_STOPS.toFixed(1)}));
+  float local = mix(bilateral, tileMean, uLocalShape.w);
+  /* Middle grey at the frame's exposure, in the scene light the grid measured. */
+  float pivot = uLocalPivot.x > 0.5
+    ? held
+    : ${Math.log2(ADAPTED_KEY).toFixed(6)} - log2(max(autoExposureGain() * uOutputExposure, 1e-8));
+  pivot += uLocalPivot.y;
+  float keep = local > pivot ? uLocalShape.x : uLocalShape.y;
+  float stops = (local - pivot) * keep + (pixel - local) * uLocalShape.z;
+  return exp2(clamp(stops, -uLocalPivot.z, uLocalPivot.z));
 }
 `;
 const clamp = (value, low, high) => Math.min(Math.max(value, low), high);
@@ -132,6 +150,55 @@ export function localExposureGain(localLog2, heldLog2, strength) {
     const stops = strength * (heldLog2 - localLog2);
     return 2 ** clamp(stops, -LOCAL_RANGE_STOPS, LOCAL_RANGE_STOPS);
 }
+/** Floats `resolveLocalExposure` fills: `uLocalShape`, then `uLocalPivot`. */
+export const LOCAL_EXPOSURE_FLOATS = 8;
+/**
+ * Either form of `setLocalExposure` as the composite reads it, into `out`, and whether regions move
+ * at all. The one number is the shape it always was, both shares `1 − strength` about the held
+ * level, at most three stops: so a strength draws what it drew, to the bit.
+ */
+export function resolveLocalExposure(setting, out) {
+    if (typeof setting === 'number') {
+        const strength = clampLocalExposure(setting);
+        out[0] = -strength;
+        out[1] = -strength;
+        out[2] = 0;
+        out[3] = LOCAL_BLURRED_BLEND;
+        out[4] = 1;
+        out[5] = 0;
+        out[6] = LOCAL_RANGE_STOPS;
+        out[7] = 0;
+        return strength > 0;
+    }
+    const share = (value, fallback) => value !== undefined && Number.isFinite(value) ? Math.max(0, value) : fallback;
+    const highlight = share(setting.highlightContrast, 1);
+    const shadow = share(setting.shadowContrast, 1);
+    const detail = share(setting.detail, 1);
+    out[0] = highlight - 1;
+    out[1] = shadow - 1;
+    out[2] = detail - 1;
+    out[3] = clamp(share(setting.blurredBlend, LOCAL_BLURRED_BLEND), 0, 1);
+    out[4] = 0;
+    const bias = setting.middleGreyBias;
+    out[5] = bias !== undefined && Number.isFinite(bias) ? bias : 0;
+    out[6] = share(setting.range, 8);
+    out[7] = 0;
+    return highlight !== 1 || shadow !== 1 || detail !== 1;
+}
+/**
+ * A pixel's gain from either form, as the composite computes it: `pixelLog2` its own level,
+ * `localLog2` its region's before the blend, `tileMean` its tile's, `heldLog2` the frame's held
+ * brightness and `exposure` the frame's exposure, gain and all; `shape` is `resolveLocalExposure`'s.
+ */
+export function localExposureShapedGain(pixelLog2, localLog2, tileMean, heldLog2, exposure, shape) {
+    const local = localLog2 + (tileMean - localLog2) * shape[3];
+    const pivot = (shape[4] > 0.5 ? heldLog2 : Math.log2(ADAPTED_KEY) - Math.log2(exposure)) +
+        shape[5];
+    const keep = local > pivot ? shape[0] : shape[1];
+    const stops = (local - pivot) * keep + (pixelLog2 - local) * shape[2];
+    const range = shape[6];
+    return 2 ** clamp(stops, -range, range);
+}
 /** A local exposure strength as the shader takes it: 0 to 1, anything else off. */
 export function clampLocalExposure(strength) {
     return Number.isFinite(strength) ? clamp(strength, 0, 1) : 0;

package/dist/render/shaders/particle.d.ts

@@ -47,7 +47,7 @@ export declare const PARTICLE_VERT = "#version 300 es\n/** Per-vertex: the quad
  * and unlit smoke in a world lit by fires is the tell that gives an effect away
  * fastest. A puff catching a flame's colour is most of what makes it belong.
  */
-export declare const PARTICLE_SMOKE_FRAG = "#version 300 es\nprecision highp float;\n\nin vec2 vUv;\nin vec3 vColor;\nin float vAlpha;\nin float vAge;\nin float vSeed;\nin vec3 vWorldPos;\nin vec3 vNormal;\n\nuniform float uTime;\nuniform vec3 uDirectionalDir;\nuniform vec3 uDirectionalColor;\nuniform vec3 uAmbient;\nuniform vec3 uCameraPos;\nuniform int uNoiseOctaves;\n/** How strongly the noise eats into the puff. 0 is a plain soft ball. */\nuniform float uErosion;\n\n#define MAX_LIGHTS 16\nuniform int uLightCount;\nuniform vec3 uLightPos[MAX_LIGHTS];\nuniform vec3 uLightColor[MAX_LIGHTS];\nuniform float uLightRadius[MAX_LIGHTS];\n// How present each light is, 0 to 1. See pointLightSelection.ts.\nuniform float uLightWeight[MAX_LIGHTS];\n\n\nuniform vec3 uFogColor;\n/** Extinction per metre **at the camera's own height**, not at the base. */\nuniform float uFogDensity;\n/** Reciprocal scale height of the haze, per metre. 0 is a uniform medium. */\nuniform float uFogHeightFalloff;\n/** The camera's height, so a fragment's own height is one subtraction away. */\nuniform float uFogEyeY;\nuniform vec3 uUnderwaterColor;\nuniform float uUnderwaterFogDensity;\nuniform float uUnderwaterFactor;\n/** 0 integrates a medium (Beer-Lambert); 1 ramps linearly between near and far. */\nuniform int uFogMode;\n/** Linear mode only: where haze begins, and where it is total. */\nuniform float uFogNear;\nuniform float uFogFar;\n\n/** What distance converges toward: the day's haze, or the water column. */\nvec3 mediumColor() {\n  return mix(uFogColor, uUnderwaterColor, uUnderwaterFactor);\n}\n\n/**\n * How much of a surface standing at height pointY, dist metres away, is lost to\n * the medium in between. 0 is perfectly clear, 1 is the medium's own colour.\n */\nfloat mediumFog(float dist, float pointY) {\n  /*\n   * A depth ramp rather than a medium, for worlds authored against one.\n   *\n   * Beer-Lambert is the honest model and stays the default: it integrates something\n   * physically there, so extinction begins at the eye and never stops. A linear near/far\n   * fog is not that \u2014 it is a *look*, with a hard start distance before which the air is\n   * perfectly clear, and it is what the fixed-function pipeline offered and what several\n   * renderers still expose. Approximating one with the other is not a matter of tuning:\n   * matched at half occlusion, the exponential curve still lays haze over everything\n   * inside near, where the ramp lays none, and near-field colour desaturates toward the\n   * fog colour with nothing to show for it.\n   *\n   * Height falloff has no meaning here and is ignored: a ramp is defined on distance\n   * alone.\n   */\n  if (uFogMode == 1) {\n    float span = max(uFogFar - uFogNear, 1e-4);\n    float ramp = clamp((dist - uFogNear) / span, 0.0, 1.0);\n    if (uUnderwaterFactor <= 0.0) return ramp;\n    float wetLinear = uUnderwaterFogDensity * dist;\n    return mix(ramp, 1.0 - exp2(-wetLinear * wetLinear * 1.442695), uUnderwaterFactor);\n  }\n\n  // Where the medium begins along the ray: uFogNear, the linear mode's slot, which this mode\n  // never read before Atmosphere.fogStart. The ray is integrated from there on, at the density\n  // of that point; at a start of 0 every term is the one it always was. See render/fog.ts.\n  float start = min(uFogNear, dist);\n  float before = dist > 0.0 ? start / dist : 0.0;\n  float t = (pointY - uFogEyeY) * uFogHeightFalloff;\n  float rest = t * (1.0 - before);\n  // (1 - e^-t)/t, which tends to 1 as the ray levels out. Guarded rather than\n  // branched: at t = 0 the quotient is 0/0, and 1e-4 of a scale height is 8 mm.\n  float denom = abs(rest) < 1e-4 ? 1e-4 : rest;\n  float air =\n    1.0 - exp(-uFogDensity * exp(-t * before) * (dist - start) * (1.0 - exp(-denom)) / denom);\n  if (uUnderwaterFactor <= 0.0) return air;\n  // Water is its own medium and keeps its own curve, so crossing the surface\n  // changes nothing about how the water column reads.\n  float wet = uUnderwaterFogDensity * dist;\n  return mix(air, 1.0 - exp2(-wet * wet * 1.442695), uUnderwaterFactor);\n}\n\n\nfloat hash21(vec2 p) {\n  return fract(sin(dot(p, vec2(127.1, 311.7))) * 43758.5453123);\n}\n\nfloat valueNoise(vec2 p) {\n  vec2 i = floor(p);\n  vec2 f = fract(p);\n  vec2 u = f * f * (3.0 - 2.0 * f);\n  return mix(\n    mix(hash21(i), hash21(i + vec2(1.0, 0.0)), u.x),\n    mix(hash21(i + vec2(0.0, 1.0)), hash21(i + vec2(1.0, 1.0)), u.x),\n    u.y\n  );\n}\n\nfloat billow(vec2 p, float t, int octaves) {\n  float v = valueNoise(p * 2.4 + vec2(0.0, -t * 0.5)) * 0.62;\n  if (octaves == 1) return v / 0.62;\n  v += valueNoise(p * 5.1 + vec2(t * 0.15, -t * 0.8)) * 0.38;\n  return v / 1.0;\n}\n\n\nout vec4 outColor;\n\n/** 0 none, 1 sRGB, 2 ACES then sRGB, 3 the highlight shoulder then sRGB. See renderQuality.ts. */\nuniform int uOutputTransform;\n/** Scales the scene into the tone curve. 1 is the reference grade. See renderQuality.ts. */\nuniform float uOutputExposure;\n\n/*\n * ACES: the reference fit, not the cheap one.\n *\n * This was Narkowicz's single rational function, on the argument that the difference from\n * the reference curve is invisible next to the gain. That argument holds for a look and\n * fails for a *match*, which is what this option is for \u2014 aces exists so a world ported\n * from three.js reads the same, and three.js applies the full fit: into AP1 through\n * ACESInputMat, the RRT and ODT together, then back out through ACESOutputMat.\n *\n * The two curves are not a shade apart. Narkowicz is markedly brighter through the\n * midtones, which is exactly where an interior scene lives, and it is a large part of a\n * measured ~1.7x that survived correcting the colour space and the missing Lambert pi.\n * An approximation of a standard is the wrong thing to hold when the standard is the\n * specification.\n */\nvec3 rrtAndOdtFit(vec3 v) {\n  vec3 a = v * (v + 0.0245786) - 0.000090537;\n  vec3 b = v * (0.983729 * v + 0.4329510) + 0.238081;\n  return a / b;\n}\n\nvec3 acesFilmic(vec3 x) {\n  /*\n   * Exposure first, because a tone curve is only defined relative to one.\n   *\n   * The reference RRT and ODT are graded for a dark cinema. Every renderer that ships ACES\n   * scales its input to suit whatever it is actually shown on, and the factor each one\n   * picks is a *look*, not a standard - so this engine takes no position and reads it from\n   * the caller. Neutral by default, which is the reference grade unmodified. three.js's own\n   * pick is 1 / 0.6, for a consumer matching one.\n   */\n  x *= uOutputExposure;\n  // Columns, as GLSL reads them: sRGB -> XYZ -> D65_2_D60 -> AP1 -> RRT_SAT.\n  const mat3 ACES_INPUT = mat3(\n    0.59719, 0.07600, 0.02840,\n    0.35458, 0.90834, 0.13383,\n    0.04823, 0.01566, 0.83777\n  );\n  // ODT_SAT -> XYZ -> D60_2_D65 -> sRGB.\n  const mat3 ACES_OUTPUT = mat3(\n     1.60475, -0.10208, -0.00327,\n    -0.53108,  1.10813, -0.07276,\n    -0.07367, -0.00605,  1.07602\n  );\n  return clamp(ACES_OUTPUT * rrtAndOdtFit(ACES_INPUT * x), 0.0, 1.0);\n}\n\n\n/*\n * Linear to sRGB. The piecewise form rather than a plain pow: the linear toe near black\n * is where banding lives in an 8-bit buffer, and the cheap approximation puts it in the\n * wrong place.\n */\nvec3 linearToSrgb(vec3 c) {\n  vec3 low = c * 12.92;\n  vec3 high = 1.055 * pow(max(c, vec3(0.0)), vec3(1.0 / 2.4)) - 0.055;\n  return mix(high, low, step(c, vec3(0.0031308)));\n}\n\n\nvec3 highlightShoulder(vec3 c) {\n  float m = max(c.r, max(c.g, c.b));\n  if (m <= 0.8) return c;\n  float e = m - 0.8;\n  return c * ((0.8 + 0.2 * e / (e + 0.2)) / m);\n}\n\nvec3 applyOutputTransform(vec3 c) {\n  if (uOutputTransform == 0) return c;\n  if (uOutputTransform == 2) c = acesFilmic(c);\n  if (uOutputTransform == 3) c = highlightShoulder(c * uOutputExposure);\n  return linearToSrgb(c);\n}\n\n\nvoid main() {\n  /*\n   * A round, soft body first. 'smoothstep' rather than a hard disc: the edge is\n   * the entire difference between a puff and a sprite, and a cut-off circle reads\n   * as a decal however good the noise inside it is.\n   */\n  float r = length(vUv);\n  float body = 1.0 - smoothstep(0.35, 1.0, r);\n  if (body <= 0.0) discard;\n\n  /*\n   * Then eaten into by noise that drifts and coarsens as the puff ages, so it\n   * dissipates by *breaking up* rather than by uniformly thinning. Uniform\n   * thinning is what a fading sprite does, and it is what the old cube did.\n   */\n  float t = uTime * 0.55 + vSeed * 7.31;\n  float n = billow(vUv * (0.9 + vAge * 1.4) + vec2(vSeed * 3.7, 0.0), t, uNoiseOctaves);\n  float erode = mix(1.0, n, uErosion * (0.35 + vAge * 0.65));\n  float mask = clamp(body * erode, 0.0, 1.0);\n  // Feather the last of it out rather than letting a noise threshold flicker.\n  mask *= smoothstep(0.0, 0.25, mask);\n  if (mask <= 0.002) discard;\n\n  vec3 n3 = normalize(vNormal);\n  /*\n   * Wrapped diffuse. Smoke transmits as well as reflects, so the terminator on a\n   * puff sits well past 90\u00B0 \u2014 a hard 'max(dot, 0)' gives a lump with a black side,\n   * which is exactly the \"coloured box\" failure the fidelity rules name.\n   */\n  float ndl = dot(n3, uDirectionalDir) * 0.5 + 0.5;\n  vec3 lit = uAmbient + uDirectionalColor * ndl;\n\n  for (int i = 0; i < MAX_LIGHTS; i++) {\n    if (i >= uLightCount) break;\n    vec3 toLight = uLightPos[i] - vWorldPos;\n    float dist = length(toLight);\n    float radius = uLightRadius[i];\n    if (radius <= 0.0 || dist >= radius) continue;\n    float falloff = 1.0 - dist / radius;\n    float wrapped = dot(n3, toLight / max(dist, 1e-4)) * 0.5 + 0.5;\n    lit += uLightColor[i] * falloff * falloff * wrapped * uLightWeight[i];\n  }\n\n  vec3 shaded = vColor * lit;\n  float fog = mediumFog(distance(vWorldPos, uCameraPos), vWorldPos.y);\n  outColor = vec4(applyOutputTransform(mix(shaded, mediumColor(), fog)), mask * vAlpha);\n}\n";
+export declare const PARTICLE_SMOKE_FRAG = "#version 300 es\nprecision highp float;\n\nin vec2 vUv;\nin vec3 vColor;\nin float vAlpha;\nin float vAge;\nin float vSeed;\nin vec3 vWorldPos;\nin vec3 vNormal;\n\nuniform float uTime;\nuniform vec3 uDirectionalDir;\nuniform vec3 uDirectionalColor;\nuniform vec3 uAmbient;\nuniform vec3 uCameraPos;\nuniform int uNoiseOctaves;\n/** How strongly the noise eats into the puff. 0 is a plain soft ball. */\nuniform float uErosion;\n\n#define MAX_LIGHTS 16\nuniform int uLightCount;\nuniform vec3 uLightPos[MAX_LIGHTS];\nuniform vec3 uLightColor[MAX_LIGHTS];\nuniform float uLightRadius[MAX_LIGHTS];\n// How present each light is, 0 to 1. See pointLightSelection.ts.\nuniform float uLightWeight[MAX_LIGHTS];\n\n\nuniform vec3 uFogColor;\n/**\n * The haze: its extinction per metre **at the camera's own height**, not at the base; its\n * reciprocal scale height per metre, 0 for a uniform medium; the camera's height, so a fragment's\n * own height is one subtraction away; and the water column's own density.\n *\n * **Four numbers in one vector rather than four uniforms**, and the reason is a phone: a scalar\n * costs a whole row of the uniform grid, and the lit stage at its eight-light rung must fit the 256\n * rows an Adreno 740 offers (uniformVectorBudget.ts). Packed, the haze's eight scalars cost two\n * rows where they cost eight, which is what paid for the second layer and the sun's glow below.\n */\nuniform vec4 uFogMedium;\n/** Where haze begins, where a linear ramp is total, and the mode: 0 a medium, 1 a ramp. */\nuniform vec4 uFogRange;\nuniform vec3 uUnderwaterColor;\nuniform float uUnderwaterFactor;\n/**\n * The second layer's extinction per metre at the camera's height and its falloff; then the least of\n * a surface the haze must leave, Atmosphere.fogMaxOpacity's complement, and the distance past which\n * it hides nothing (0 is none). **Every lane is none at zero**, and so are uFogGlow's: a program a\n * binder never wrote these into draws the haze it drew before they existed, rather than none.\n */\nuniform vec4 uFogLayer2;\n/** The sun's glow in the haze: its colour, black for none, and the exponent of its lobe. */\nuniform vec4 uFogGlow;\n/** Surface \u2192 the glow's light, and how far past the haze's start the glow begins. */\nuniform vec4 uFogGlowDir;\n\n/** What distance converges toward: the day's haze, or the water column. */\nvec3 mediumColor() {\n  return mix(uFogColor, uUnderwaterColor, uUnderwaterFactor);\n}\n\n/**\n * The haze's optical depth from where it begins along the ray to a point at height pointY, dist\n * metres away: each layer's density at the eye carried over what is left of the ray, with the\n * second layer only where there is one. The fog and the sun's glow both integrate it.\n */\nfloat hazeDepth(float dist, float pointY) {\n  // Where the medium begins along the ray: uFogRange.x, the linear mode's slot, which this mode\n  // never read before Atmosphere.fogStart. The ray is integrated from there on, at the density\n  // of that point; at a start of 0 every term is the one it always was. See render/fog.ts.\n  float start = min(uFogRange.x, dist);\n  float before = dist > 0.0 ? start / dist : 0.0;\n  float t = (pointY - uFogMedium.z) * uFogMedium.y;\n  float rest = t * (1.0 - before);\n  // (1 - e^-t)/t, which tends to 1 as the ray levels out. Guarded rather than\n  // branched: at t = 0 the quotient is 0/0, and 1e-4 of a scale height is 8 mm.\n  float denom = abs(rest) < 1e-4 ? 1e-4 : rest;\n  float depth = uFogMedium.x * exp(-t * before) * (dist - start) * (1.0 - exp(-denom)) / denom;\n  if (uFogLayer2.x > 0.0) {\n    float t2 = (pointY - uFogMedium.z) * uFogLayer2.y;\n    float rest2 = t2 * (1.0 - before);\n    float denom2 = abs(rest2) < 1e-4 ? 1e-4 : rest2;\n    depth += uFogLayer2.x * exp(-t2 * before) * (dist - start) * (1.0 - exp(-denom2)) / denom2;\n  }\n  return depth;\n}\n\n/**\n * How much of a surface standing at height pointY, dist metres away, is lost to\n * the medium in between. 0 is perfectly clear, 1 is the medium's own colour.\n */\nfloat mediumFog(float dist, float pointY) {\n  /* Past the cutoff the air hides nothing, in either mode; the water column keeps its own law. */\n  bool cut = uFogLayer2.w > 0.0 && dist > uFogLayer2.w;\n  /*\n   * A depth ramp rather than a medium, for worlds authored against one.\n   *\n   * Beer-Lambert is the honest model and stays the default: it integrates something\n   * physically there, so extinction begins at the eye and never stops. A linear near/far\n   * fog is not that \u2014 it is a *look*, with a hard start distance before which the air is\n   * perfectly clear, and it is what the fixed-function pipeline offered and what several\n   * renderers still expose. Approximating one with the other is not a matter of tuning:\n   * matched at half occlusion, the exponential curve still lays haze over everything\n   * inside near, where the ramp lays none, and near-field colour desaturates toward the\n   * fog colour with nothing to show for it.\n   *\n   * Height falloff has no meaning here and is ignored: a ramp is defined on distance\n   * alone.\n   */\n  if (uFogRange.z == 1.0) {\n    float span = max(uFogRange.y - uFogRange.x, 1e-4);\n    float ramp = cut ? 0.0 : min(clamp((dist - uFogRange.x) / span, 0.0, 1.0), 1.0 - uFogLayer2.z);\n    if (uUnderwaterFactor <= 0.0) return ramp;\n    float wetLinear = uFogMedium.w * dist;\n    return mix(ramp, 1.0 - exp2(-wetLinear * wetLinear * 1.442695), uUnderwaterFactor);\n  }\n\n  // Beer-Lambert through both layers, leaving at least uFogLayer2.z of the surface: a floor on\n  // what survives rather than a ceiling on the depth, so the curve keeps its shape above it.\n  float air = cut ? 0.0 : 1.0 - max(exp(-hazeDepth(dist, pointY)), uFogLayer2.z);\n  if (uUnderwaterFactor <= 0.0) return air;\n  // Water is its own medium and keeps its own curve, so crossing the surface\n  // changes nothing about how the water column reads.\n  float wet = uFogMedium.w * dist;\n  return mix(air, 1.0 - exp2(-wet * wet * 1.442695), uUnderwaterFactor);\n}\n\n/**\n * The sun's light the haze scatters toward the eye along a ray to a point at height pointY, dist\n * metres away in the direction toPoint: added to a surface after its fog, never mixed. A lobe of\n * cos^exponent about the light, by as much of the ray past the glow's own start as the haze hides \u2014\n * the haze's depth per metre carried over that stretch. None in a linear ramp, past the cutoff, or\n * under water, which keeps its own medium.\n */\nvec3 mediumGlow(float dist, float pointY, vec3 toPoint) {\n  if (uFogRange.z == 1.0 || max(max(uFogGlow.r, uFogGlow.g), uFogGlow.b) <= 0.0) return vec3(0.0);\n  if (uFogLayer2.w > 0.0 && dist > uFogLayer2.w) return vec3(0.0);\n  float span = dist - min(uFogRange.x, dist);\n  if (span <= 0.0) return vec3(0.0);\n  float perMetre = hazeDepth(dist, pointY) / span;\n  float hidden = 1.0 - exp(-perMetre * max(span - uFogGlowDir.w, 0.0));\n  float lobe = pow(clamp(dot(toPoint, uFogGlowDir.xyz), 0.0, 1.0), uFogGlow.a);\n  return uFogGlow.rgb * (lobe * hidden * (1.0 - uUnderwaterFactor));\n}\n\n\nfloat hash21(vec2 p) {\n  return fract(sin(dot(p, vec2(127.1, 311.7))) * 43758.5453123);\n}\n\nfloat valueNoise(vec2 p) {\n  vec2 i = floor(p);\n  vec2 f = fract(p);\n  vec2 u = f * f * (3.0 - 2.0 * f);\n  return mix(\n    mix(hash21(i), hash21(i + vec2(1.0, 0.0)), u.x),\n    mix(hash21(i + vec2(0.0, 1.0)), hash21(i + vec2(1.0, 1.0)), u.x),\n    u.y\n  );\n}\n\nfloat billow(vec2 p, float t, int octaves) {\n  float v = valueNoise(p * 2.4 + vec2(0.0, -t * 0.5)) * 0.62;\n  if (octaves == 1) return v / 0.62;\n  v += valueNoise(p * 5.1 + vec2(t * 0.15, -t * 0.8)) * 0.38;\n  return v / 1.0;\n}\n\n\nout vec4 outColor;\n\n/** 0 none, 1 sRGB, 2 ACES then sRGB, 3 the highlight shoulder then sRGB. See renderQuality.ts. */\nuniform int uOutputTransform;\n/** Scales the scene into the tone curve. 1 is the reference grade. See renderQuality.ts. */\nuniform float uOutputExposure;\n\n/*\n * ACES: the reference fit, not the cheap one.\n *\n * This was Narkowicz's single rational function, on the argument that the difference from\n * the reference curve is invisible next to the gain. That argument holds for a look and\n * fails for a *match*, which is what this option is for \u2014 aces exists so a world ported\n * from three.js reads the same, and three.js applies the full fit: into AP1 through\n * ACESInputMat, the RRT and ODT together, then back out through ACESOutputMat.\n *\n * The two curves are not a shade apart. Narkowicz is markedly brighter through the\n * midtones, which is exactly where an interior scene lives, and it is a large part of a\n * measured ~1.7x that survived correcting the colour space and the missing Lambert pi.\n * An approximation of a standard is the wrong thing to hold when the standard is the\n * specification.\n */\nvec3 rrtAndOdtFit(vec3 v) {\n  vec3 a = v * (v + 0.0245786) - 0.000090537;\n  vec3 b = v * (0.983729 * v + 0.4329510) + 0.238081;\n  return a / b;\n}\n\nvec3 acesFilmic(vec3 x) {\n  /*\n   * Exposure first, because a tone curve is only defined relative to one.\n   *\n   * The reference RRT and ODT are graded for a dark cinema. Every renderer that ships ACES\n   * scales its input to suit whatever it is actually shown on, and the factor each one\n   * picks is a *look*, not a standard - so this engine takes no position and reads it from\n   * the caller. Neutral by default, which is the reference grade unmodified. three.js's own\n   * pick is 1 / 0.6, for a consumer matching one.\n   */\n  x *= uOutputExposure;\n  // Columns, as GLSL reads them: sRGB -> XYZ -> D65_2_D60 -> AP1 -> RRT_SAT.\n  const mat3 ACES_INPUT = mat3(\n    0.59719, 0.07600, 0.02840,\n    0.35458, 0.90834, 0.13383,\n    0.04823, 0.01566, 0.83777\n  );\n  // ODT_SAT -> XYZ -> D60_2_D65 -> sRGB.\n  const mat3 ACES_OUTPUT = mat3(\n     1.60475, -0.10208, -0.00327,\n    -0.53108,  1.10813, -0.07276,\n    -0.07367, -0.00605,  1.07602\n  );\n  return clamp(ACES_OUTPUT * rrtAndOdtFit(ACES_INPUT * x), 0.0, 1.0);\n}\n\n\n/*\n * Linear to sRGB. The piecewise form rather than a plain pow: the linear toe near black\n * is where banding lives in an 8-bit buffer, and the cheap approximation puts it in the\n * wrong place.\n */\nvec3 linearToSrgb(vec3 c) {\n  vec3 low = c * 12.92;\n  vec3 high = 1.055 * pow(max(c, vec3(0.0)), vec3(1.0 / 2.4)) - 0.055;\n  return mix(high, low, step(c, vec3(0.0031308)));\n}\n\n\nvec3 highlightShoulder(vec3 c) {\n  float m = max(c.r, max(c.g, c.b));\n  if (m <= 0.8) return c;\n  float e = m - 0.8;\n  return c * ((0.8 + 0.2 * e / (e + 0.2)) / m);\n}\n\nvec3 applyOutputTransform(vec3 c) {\n  if (uOutputTransform == 0) return c;\n  if (uOutputTransform == 2) c = acesFilmic(c);\n  if (uOutputTransform == 3) c = highlightShoulder(c * uOutputExposure);\n  return linearToSrgb(c);\n}\n\n\nvoid main() {\n  /*\n   * A round, soft body first. 'smoothstep' rather than a hard disc: the edge is\n   * the entire difference between a puff and a sprite, and a cut-off circle reads\n   * as a decal however good the noise inside it is.\n   */\n  float r = length(vUv);\n  float body = 1.0 - smoothstep(0.35, 1.0, r);\n  if (body <= 0.0) discard;\n\n  /*\n   * Then eaten into by noise that drifts and coarsens as the puff ages, so it\n   * dissipates by *breaking up* rather than by uniformly thinning. Uniform\n   * thinning is what a fading sprite does, and it is what the old cube did.\n   */\n  float t = uTime * 0.55 + vSeed * 7.31;\n  float n = billow(vUv * (0.9 + vAge * 1.4) + vec2(vSeed * 3.7, 0.0), t, uNoiseOctaves);\n  float erode = mix(1.0, n, uErosion * (0.35 + vAge * 0.65));\n  float mask = clamp(body * erode, 0.0, 1.0);\n  // Feather the last of it out rather than letting a noise threshold flicker.\n  mask *= smoothstep(0.0, 0.25, mask);\n  if (mask <= 0.002) discard;\n\n  vec3 n3 = normalize(vNormal);\n  /*\n   * Wrapped diffuse. Smoke transmits as well as reflects, so the terminator on a\n   * puff sits well past 90\u00B0 \u2014 a hard 'max(dot, 0)' gives a lump with a black side,\n   * which is exactly the \"coloured box\" failure the fidelity rules name.\n   */\n  float ndl = dot(n3, uDirectionalDir) * 0.5 + 0.5;\n  vec3 lit = uAmbient + uDirectionalColor * ndl;\n\n  for (int i = 0; i < MAX_LIGHTS; i++) {\n    if (i >= uLightCount) break;\n    vec3 toLight = uLightPos[i] - vWorldPos;\n    float dist = length(toLight);\n    float radius = uLightRadius[i];\n    if (radius <= 0.0 || dist >= radius) continue;\n    float falloff = 1.0 - dist / radius;\n    float wrapped = dot(n3, toLight / max(dist, 1e-4)) * 0.5 + 0.5;\n    lit += uLightColor[i] * falloff * falloff * wrapped * uLightWeight[i];\n  }\n\n  vec3 shaded = vColor * lit;\n  float dist = distance(vWorldPos, uCameraPos);\n  float fog = mediumFog(dist, vWorldPos.y);\n  vec3 glow = mediumGlow(dist, vWorldPos.y, normalize(vWorldPos - uCameraPos));\n  outColor = vec4(applyOutputTransform(mix(shaded, mediumColor(), fog) + glow), mask * vAlpha);\n}\n";
 /**
  * Sparks and embers: additive, hot in the middle, and stretched along travel.
  *
@@ -55,7 +55,7 @@ export declare const PARTICLE_SMOKE_FRAG = "#version 300 es\nprecision highp flo
  * is what turned the first version into a grey cube at night. The core is allowed
  * past white so it reads as incandescent rather than as a pale dot.
  */
-export declare const PARTICLE_SPARK_FRAG = "#version 300 es\nprecision highp float;\n\nin vec2 vUv;\nin vec3 vColor;\nin float vAlpha;\nin float vAge;\nin float vSeed;\nin vec3 vWorldPos;\nin vec3 vNormal;\n\nuniform float uTime;\nuniform vec3 uCameraPos;\n/** How far past white the centre may go. */\nuniform float uCoreGain;\n\nuniform vec3 uFogColor;\n/** Extinction per metre **at the camera's own height**, not at the base. */\nuniform float uFogDensity;\n/** Reciprocal scale height of the haze, per metre. 0 is a uniform medium. */\nuniform float uFogHeightFalloff;\n/** The camera's height, so a fragment's own height is one subtraction away. */\nuniform float uFogEyeY;\nuniform vec3 uUnderwaterColor;\nuniform float uUnderwaterFogDensity;\nuniform float uUnderwaterFactor;\n/** 0 integrates a medium (Beer-Lambert); 1 ramps linearly between near and far. */\nuniform int uFogMode;\n/** Linear mode only: where haze begins, and where it is total. */\nuniform float uFogNear;\nuniform float uFogFar;\n\n/** What distance converges toward: the day's haze, or the water column. */\nvec3 mediumColor() {\n  return mix(uFogColor, uUnderwaterColor, uUnderwaterFactor);\n}\n\n/**\n * How much of a surface standing at height pointY, dist metres away, is lost to\n * the medium in between. 0 is perfectly clear, 1 is the medium's own colour.\n */\nfloat mediumFog(float dist, float pointY) {\n  /*\n   * A depth ramp rather than a medium, for worlds authored against one.\n   *\n   * Beer-Lambert is the honest model and stays the default: it integrates something\n   * physically there, so extinction begins at the eye and never stops. A linear near/far\n   * fog is not that \u2014 it is a *look*, with a hard start distance before which the air is\n   * perfectly clear, and it is what the fixed-function pipeline offered and what several\n   * renderers still expose. Approximating one with the other is not a matter of tuning:\n   * matched at half occlusion, the exponential curve still lays haze over everything\n   * inside near, where the ramp lays none, and near-field colour desaturates toward the\n   * fog colour with nothing to show for it.\n   *\n   * Height falloff has no meaning here and is ignored: a ramp is defined on distance\n   * alone.\n   */\n  if (uFogMode == 1) {\n    float span = max(uFogFar - uFogNear, 1e-4);\n    float ramp = clamp((dist - uFogNear) / span, 0.0, 1.0);\n    if (uUnderwaterFactor <= 0.0) return ramp;\n    float wetLinear = uUnderwaterFogDensity * dist;\n    return mix(ramp, 1.0 - exp2(-wetLinear * wetLinear * 1.442695), uUnderwaterFactor);\n  }\n\n  // Where the medium begins along the ray: uFogNear, the linear mode's slot, which this mode\n  // never read before Atmosphere.fogStart. The ray is integrated from there on, at the density\n  // of that point; at a start of 0 every term is the one it always was. See render/fog.ts.\n  float start = min(uFogNear, dist);\n  float before = dist > 0.0 ? start / dist : 0.0;\n  float t = (pointY - uFogEyeY) * uFogHeightFalloff;\n  float rest = t * (1.0 - before);\n  // (1 - e^-t)/t, which tends to 1 as the ray levels out. Guarded rather than\n  // branched: at t = 0 the quotient is 0/0, and 1e-4 of a scale height is 8 mm.\n  float denom = abs(rest) < 1e-4 ? 1e-4 : rest;\n  float air =\n    1.0 - exp(-uFogDensity * exp(-t * before) * (dist - start) * (1.0 - exp(-denom)) / denom);\n  if (uUnderwaterFactor <= 0.0) return air;\n  // Water is its own medium and keeps its own curve, so crossing the surface\n  // changes nothing about how the water column reads.\n  float wet = uUnderwaterFogDensity * dist;\n  return mix(air, 1.0 - exp2(-wet * wet * 1.442695), uUnderwaterFactor);\n}\n\n\nfloat hash21(vec2 p) {\n  return fract(sin(dot(p, vec2(127.1, 311.7))) * 43758.5453123);\n}\n\nfloat valueNoise(vec2 p) {\n  vec2 i = floor(p);\n  vec2 f = fract(p);\n  vec2 u = f * f * (3.0 - 2.0 * f);\n  return mix(\n    mix(hash21(i), hash21(i + vec2(1.0, 0.0)), u.x),\n    mix(hash21(i + vec2(0.0, 1.0)), hash21(i + vec2(1.0, 1.0)), u.x),\n    u.y\n  );\n}\n\nfloat billow(vec2 p, float t, int octaves) {\n  float v = valueNoise(p * 2.4 + vec2(0.0, -t * 0.5)) * 0.62;\n  if (octaves == 1) return v / 0.62;\n  v += valueNoise(p * 5.1 + vec2(t * 0.15, -t * 0.8)) * 0.38;\n  return v / 1.0;\n}\n\n\nout vec4 outColor;\n\n/** 0 none, 1 sRGB, 2 ACES then sRGB, 3 the highlight shoulder then sRGB. See renderQuality.ts. */\nuniform int uOutputTransform;\n/** Scales the scene into the tone curve. 1 is the reference grade. See renderQuality.ts. */\nuniform float uOutputExposure;\n\n/*\n * ACES: the reference fit, not the cheap one.\n *\n * This was Narkowicz's single rational function, on the argument that the difference from\n * the reference curve is invisible next to the gain. That argument holds for a look and\n * fails for a *match*, which is what this option is for \u2014 aces exists so a world ported\n * from three.js reads the same, and three.js applies the full fit: into AP1 through\n * ACESInputMat, the RRT and ODT together, then back out through ACESOutputMat.\n *\n * The two curves are not a shade apart. Narkowicz is markedly brighter through the\n * midtones, which is exactly where an interior scene lives, and it is a large part of a\n * measured ~1.7x that survived correcting the colour space and the missing Lambert pi.\n * An approximation of a standard is the wrong thing to hold when the standard is the\n * specification.\n */\nvec3 rrtAndOdtFit(vec3 v) {\n  vec3 a = v * (v + 0.0245786) - 0.000090537;\n  vec3 b = v * (0.983729 * v + 0.4329510) + 0.238081;\n  return a / b;\n}\n\nvec3 acesFilmic(vec3 x) {\n  /*\n   * Exposure first, because a tone curve is only defined relative to one.\n   *\n   * The reference RRT and ODT are graded for a dark cinema. Every renderer that ships ACES\n   * scales its input to suit whatever it is actually shown on, and the factor each one\n   * picks is a *look*, not a standard - so this engine takes no position and reads it from\n   * the caller. Neutral by default, which is the reference grade unmodified. three.js's own\n   * pick is 1 / 0.6, for a consumer matching one.\n   */\n  x *= uOutputExposure;\n  // Columns, as GLSL reads them: sRGB -> XYZ -> D65_2_D60 -> AP1 -> RRT_SAT.\n  const mat3 ACES_INPUT = mat3(\n    0.59719, 0.07600, 0.02840,\n    0.35458, 0.90834, 0.13383,\n    0.04823, 0.01566, 0.83777\n  );\n  // ODT_SAT -> XYZ -> D60_2_D65 -> sRGB.\n  const mat3 ACES_OUTPUT = mat3(\n     1.60475, -0.10208, -0.00327,\n    -0.53108,  1.10813, -0.07276,\n    -0.07367, -0.00605,  1.07602\n  );\n  return clamp(ACES_OUTPUT * rrtAndOdtFit(ACES_INPUT * x), 0.0, 1.0);\n}\n\n\n/*\n * Linear to sRGB. The piecewise form rather than a plain pow: the linear toe near black\n * is where banding lives in an 8-bit buffer, and the cheap approximation puts it in the\n * wrong place.\n */\nvec3 linearToSrgb(vec3 c) {\n  vec3 low = c * 12.92;\n  vec3 high = 1.055 * pow(max(c, vec3(0.0)), vec3(1.0 / 2.4)) - 0.055;\n  return mix(high, low, step(c, vec3(0.0031308)));\n}\n\n\nvec3 highlightShoulder(vec3 c) {\n  float m = max(c.r, max(c.g, c.b));\n  if (m <= 0.8) return c;\n  float e = m - 0.8;\n  return c * ((0.8 + 0.2 * e / (e + 0.2)) / m);\n}\n\nvec3 applyOutputTransform(vec3 c) {\n  if (uOutputTransform == 0) return c;\n  if (uOutputTransform == 2) c = acesFilmic(c);\n  if (uOutputTransform == 3) c = highlightShoulder(c * uOutputExposure);\n  return linearToSrgb(c);\n}\n\n\nvoid main() {\n  float r = length(vUv);\n  if (r > 1.0) discard;\n\n  /*\n   * Two falloffs again \u2014 a tight core and a broad halo \u2014 because one gives either\n   * a hard dot or a soft smudge. The halo is what makes a shower of embers read\n   * as glowing air rather than as a scatter of points.\n   */\n  float core = pow(1.0 - clamp(r, 0.0, 1.0), 6.0);\n  float halo = pow(1.0 - clamp(r, 0.0, 1.0), 1.6);\n\n  /*\n   * Embers flicker as they tumble and cool. Per-particle phase from the seed, so\n   * a shower crackles instead of pulsing as one body.\n   */\n  float flick = 0.7 + 0.3 * valueNoise(vec2(uTime * 9.0 + vSeed * 13.0, vSeed));\n\n  // Cooling: the last of a spark's life is dimmer as well as smaller.\n  float cool = 1.0 - vAge * vAge;\n  float energy = (halo * 0.55 + core * uCoreGain) * flick * cool * vAlpha;\n\n  float fog = mediumFog(distance(vWorldPos, uCameraPos), vWorldPos.y);\n  energy *= 1.0 - fog;\n  /*\n   * Alpha 1, energy in the colour \u2014 see the note in 'bolt.ts'. Additive blending is\n   * 'rgb * a', so carrying the energy in both channels squares it and quietly halves\n   * every emissive effect in the game.\n   */\n  outColor = vec4(applyOutputTransform(vColor * energy), 1.0);\n}\n";
+export declare const PARTICLE_SPARK_FRAG = "#version 300 es\nprecision highp float;\n\nin vec2 vUv;\nin vec3 vColor;\nin float vAlpha;\nin float vAge;\nin float vSeed;\nin vec3 vWorldPos;\nin vec3 vNormal;\n\nuniform float uTime;\nuniform vec3 uCameraPos;\n/** How far past white the centre may go. */\nuniform float uCoreGain;\n\nuniform vec3 uFogColor;\n/**\n * The haze: its extinction per metre **at the camera's own height**, not at the base; its\n * reciprocal scale height per metre, 0 for a uniform medium; the camera's height, so a fragment's\n * own height is one subtraction away; and the water column's own density.\n *\n * **Four numbers in one vector rather than four uniforms**, and the reason is a phone: a scalar\n * costs a whole row of the uniform grid, and the lit stage at its eight-light rung must fit the 256\n * rows an Adreno 740 offers (uniformVectorBudget.ts). Packed, the haze's eight scalars cost two\n * rows where they cost eight, which is what paid for the second layer and the sun's glow below.\n */\nuniform vec4 uFogMedium;\n/** Where haze begins, where a linear ramp is total, and the mode: 0 a medium, 1 a ramp. */\nuniform vec4 uFogRange;\nuniform vec3 uUnderwaterColor;\nuniform float uUnderwaterFactor;\n/**\n * The second layer's extinction per metre at the camera's height and its falloff; then the least of\n * a surface the haze must leave, Atmosphere.fogMaxOpacity's complement, and the distance past which\n * it hides nothing (0 is none). **Every lane is none at zero**, and so are uFogGlow's: a program a\n * binder never wrote these into draws the haze it drew before they existed, rather than none.\n */\nuniform vec4 uFogLayer2;\n/** The sun's glow in the haze: its colour, black for none, and the exponent of its lobe. */\nuniform vec4 uFogGlow;\n/** Surface \u2192 the glow's light, and how far past the haze's start the glow begins. */\nuniform vec4 uFogGlowDir;\n\n/** What distance converges toward: the day's haze, or the water column. */\nvec3 mediumColor() {\n  return mix(uFogColor, uUnderwaterColor, uUnderwaterFactor);\n}\n\n/**\n * The haze's optical depth from where it begins along the ray to a point at height pointY, dist\n * metres away: each layer's density at the eye carried over what is left of the ray, with the\n * second layer only where there is one. The fog and the sun's glow both integrate it.\n */\nfloat hazeDepth(float dist, float pointY) {\n  // Where the medium begins along the ray: uFogRange.x, the linear mode's slot, which this mode\n  // never read before Atmosphere.fogStart. The ray is integrated from there on, at the density\n  // of that point; at a start of 0 every term is the one it always was. See render/fog.ts.\n  float start = min(uFogRange.x, dist);\n  float before = dist > 0.0 ? start / dist : 0.0;\n  float t = (pointY - uFogMedium.z) * uFogMedium.y;\n  float rest = t * (1.0 - before);\n  // (1 - e^-t)/t, which tends to 1 as the ray levels out. Guarded rather than\n  // branched: at t = 0 the quotient is 0/0, and 1e-4 of a scale height is 8 mm.\n  float denom = abs(rest) < 1e-4 ? 1e-4 : rest;\n  float depth = uFogMedium.x * exp(-t * before) * (dist - start) * (1.0 - exp(-denom)) / denom;\n  if (uFogLayer2.x > 0.0) {\n    float t2 = (pointY - uFogMedium.z) * uFogLayer2.y;\n    float rest2 = t2 * (1.0 - before);\n    float denom2 = abs(rest2) < 1e-4 ? 1e-4 : rest2;\n    depth += uFogLayer2.x * exp(-t2 * before) * (dist - start) * (1.0 - exp(-denom2)) / denom2;\n  }\n  return depth;\n}\n\n/**\n * How much of a surface standing at height pointY, dist metres away, is lost to\n * the medium in between. 0 is perfectly clear, 1 is the medium's own colour.\n */\nfloat mediumFog(float dist, float pointY) {\n  /* Past the cutoff the air hides nothing, in either mode; the water column keeps its own law. */\n  bool cut = uFogLayer2.w > 0.0 && dist > uFogLayer2.w;\n  /*\n   * A depth ramp rather than a medium, for worlds authored against one.\n   *\n   * Beer-Lambert is the honest model and stays the default: it integrates something\n   * physically there, so extinction begins at the eye and never stops. A linear near/far\n   * fog is not that \u2014 it is a *look*, with a hard start distance before which the air is\n   * perfectly clear, and it is what the fixed-function pipeline offered and what several\n   * renderers still expose. Approximating one with the other is not a matter of tuning:\n   * matched at half occlusion, the exponential curve still lays haze over everything\n   * inside near, where the ramp lays none, and near-field colour desaturates toward the\n   * fog colour with nothing to show for it.\n   *\n   * Height falloff has no meaning here and is ignored: a ramp is defined on distance\n   * alone.\n   */\n  if (uFogRange.z == 1.0) {\n    float span = max(uFogRange.y - uFogRange.x, 1e-4);\n    float ramp = cut ? 0.0 : min(clamp((dist - uFogRange.x) / span, 0.0, 1.0), 1.0 - uFogLayer2.z);\n    if (uUnderwaterFactor <= 0.0) return ramp;\n    float wetLinear = uFogMedium.w * dist;\n    return mix(ramp, 1.0 - exp2(-wetLinear * wetLinear * 1.442695), uUnderwaterFactor);\n  }\n\n  // Beer-Lambert through both layers, leaving at least uFogLayer2.z of the surface: a floor on\n  // what survives rather than a ceiling on the depth, so the curve keeps its shape above it.\n  float air = cut ? 0.0 : 1.0 - max(exp(-hazeDepth(dist, pointY)), uFogLayer2.z);\n  if (uUnderwaterFactor <= 0.0) return air;\n  // Water is its own medium and keeps its own curve, so crossing the surface\n  // changes nothing about how the water column reads.\n  float wet = uFogMedium.w * dist;\n  return mix(air, 1.0 - exp2(-wet * wet * 1.442695), uUnderwaterFactor);\n}\n\n/**\n * The sun's light the haze scatters toward the eye along a ray to a point at height pointY, dist\n * metres away in the direction toPoint: added to a surface after its fog, never mixed. A lobe of\n * cos^exponent about the light, by as much of the ray past the glow's own start as the haze hides \u2014\n * the haze's depth per metre carried over that stretch. None in a linear ramp, past the cutoff, or\n * under water, which keeps its own medium.\n */\nvec3 mediumGlow(float dist, float pointY, vec3 toPoint) {\n  if (uFogRange.z == 1.0 || max(max(uFogGlow.r, uFogGlow.g), uFogGlow.b) <= 0.0) return vec3(0.0);\n  if (uFogLayer2.w > 0.0 && dist > uFogLayer2.w) return vec3(0.0);\n  float span = dist - min(uFogRange.x, dist);\n  if (span <= 0.0) return vec3(0.0);\n  float perMetre = hazeDepth(dist, pointY) / span;\n  float hidden = 1.0 - exp(-perMetre * max(span - uFogGlowDir.w, 0.0));\n  float lobe = pow(clamp(dot(toPoint, uFogGlowDir.xyz), 0.0, 1.0), uFogGlow.a);\n  return uFogGlow.rgb * (lobe * hidden * (1.0 - uUnderwaterFactor));\n}\n\n\nfloat hash21(vec2 p) {\n  return fract(sin(dot(p, vec2(127.1, 311.7))) * 43758.5453123);\n}\n\nfloat valueNoise(vec2 p) {\n  vec2 i = floor(p);\n  vec2 f = fract(p);\n  vec2 u = f * f * (3.0 - 2.0 * f);\n  return mix(\n    mix(hash21(i), hash21(i + vec2(1.0, 0.0)), u.x),\n    mix(hash21(i + vec2(0.0, 1.0)), hash21(i + vec2(1.0, 1.0)), u.x),\n    u.y\n  );\n}\n\nfloat billow(vec2 p, float t, int octaves) {\n  float v = valueNoise(p * 2.4 + vec2(0.0, -t * 0.5)) * 0.62;\n  if (octaves == 1) return v / 0.62;\n  v += valueNoise(p * 5.1 + vec2(t * 0.15, -t * 0.8)) * 0.38;\n  return v / 1.0;\n}\n\n\nout vec4 outColor;\n\n/** 0 none, 1 sRGB, 2 ACES then sRGB, 3 the highlight shoulder then sRGB. See renderQuality.ts. */\nuniform int uOutputTransform;\n/** Scales the scene into the tone curve. 1 is the reference grade. See renderQuality.ts. */\nuniform float uOutputExposure;\n\n/*\n * ACES: the reference fit, not the cheap one.\n *\n * This was Narkowicz's single rational function, on the argument that the difference from\n * the reference curve is invisible next to the gain. That argument holds for a look and\n * fails for a *match*, which is what this option is for \u2014 aces exists so a world ported\n * from three.js reads the same, and three.js applies the full fit: into AP1 through\n * ACESInputMat, the RRT and ODT together, then back out through ACESOutputMat.\n *\n * The two curves are not a shade apart. Narkowicz is markedly brighter through the\n * midtones, which is exactly where an interior scene lives, and it is a large part of a\n * measured ~1.7x that survived correcting the colour space and the missing Lambert pi.\n * An approximation of a standard is the wrong thing to hold when the standard is the\n * specification.\n */\nvec3 rrtAndOdtFit(vec3 v) {\n  vec3 a = v * (v + 0.0245786) - 0.000090537;\n  vec3 b = v * (0.983729 * v + 0.4329510) + 0.238081;\n  return a / b;\n}\n\nvec3 acesFilmic(vec3 x) {\n  /*\n   * Exposure first, because a tone curve is only defined relative to one.\n   *\n   * The reference RRT and ODT are graded for a dark cinema. Every renderer that ships ACES\n   * scales its input to suit whatever it is actually shown on, and the factor each one\n   * picks is a *look*, not a standard - so this engine takes no position and reads it from\n   * the caller. Neutral by default, which is the reference grade unmodified. three.js's own\n   * pick is 1 / 0.6, for a consumer matching one.\n   */\n  x *= uOutputExposure;\n  // Columns, as GLSL reads them: sRGB -> XYZ -> D65_2_D60 -> AP1 -> RRT_SAT.\n  const mat3 ACES_INPUT = mat3(\n    0.59719, 0.07600, 0.02840,\n    0.35458, 0.90834, 0.13383,\n    0.04823, 0.01566, 0.83777\n  );\n  // ODT_SAT -> XYZ -> D60_2_D65 -> sRGB.\n  const mat3 ACES_OUTPUT = mat3(\n     1.60475, -0.10208, -0.00327,\n    -0.53108,  1.10813, -0.07276,\n    -0.07367, -0.00605,  1.07602\n  );\n  return clamp(ACES_OUTPUT * rrtAndOdtFit(ACES_INPUT * x), 0.0, 1.0);\n}\n\n\n/*\n * Linear to sRGB. The piecewise form rather than a plain pow: the linear toe near black\n * is where banding lives in an 8-bit buffer, and the cheap approximation puts it in the\n * wrong place.\n */\nvec3 linearToSrgb(vec3 c) {\n  vec3 low = c * 12.92;\n  vec3 high = 1.055 * pow(max(c, vec3(0.0)), vec3(1.0 / 2.4)) - 0.055;\n  return mix(high, low, step(c, vec3(0.0031308)));\n}\n\n\nvec3 highlightShoulder(vec3 c) {\n  float m = max(c.r, max(c.g, c.b));\n  if (m <= 0.8) return c;\n  float e = m - 0.8;\n  return c * ((0.8 + 0.2 * e / (e + 0.2)) / m);\n}\n\nvec3 applyOutputTransform(vec3 c) {\n  if (uOutputTransform == 0) return c;\n  if (uOutputTransform == 2) c = acesFilmic(c);\n  if (uOutputTransform == 3) c = highlightShoulder(c * uOutputExposure);\n  return linearToSrgb(c);\n}\n\n\nvoid main() {\n  float r = length(vUv);\n  if (r > 1.0) discard;\n\n  /*\n   * Two falloffs again \u2014 a tight core and a broad halo \u2014 because one gives either\n   * a hard dot or a soft smudge. The halo is what makes a shower of embers read\n   * as glowing air rather than as a scatter of points.\n   */\n  float core = pow(1.0 - clamp(r, 0.0, 1.0), 6.0);\n  float halo = pow(1.0 - clamp(r, 0.0, 1.0), 1.6);\n\n  /*\n   * Embers flicker as they tumble and cool. Per-particle phase from the seed, so\n   * a shower crackles instead of pulsing as one body.\n   */\n  float flick = 0.7 + 0.3 * valueNoise(vec2(uTime * 9.0 + vSeed * 13.0, vSeed));\n\n  // Cooling: the last of a spark's life is dimmer as well as smaller.\n  float cool = 1.0 - vAge * vAge;\n  float energy = (halo * 0.55 + core * uCoreGain) * flick * cool * vAlpha;\n\n  float fog = mediumFog(distance(vWorldPos, uCameraPos), vWorldPos.y);\n  energy *= 1.0 - fog;\n  /*\n   * Alpha 1, energy in the colour \u2014 see the note in 'bolt.ts'. Additive blending is\n   * 'rgb * a', so carrying the energy in both channels squares it and quietly halves\n   * every emissive effect in the game.\n   */\n  outColor = vec4(applyOutputTransform(vColor * energy), 1.0);\n}\n";
 /**
  * Dust motes and drifting glints: unlit, alpha blended, and fogged only when the caller asks.
  *
@@ -79,7 +79,7 @@ export declare const PARTICLE_SPARK_FRAG = "#version 300 es\nprecision highp flo
  * option and stay unconditionally fogged, matching every particle drawn before this material
  * existed; see `ParticleBatchOptions.fog`.
  */
-export declare const PARTICLE_MOTE_FRAG = "#version 300 es\nprecision highp float;\n\nin vec2 vUv;\nin vec3 vColor;\nin float vAlpha;\nin float vAge;\nin float vSeed;\nin vec3 vWorldPos;\nin vec3 vNormal;\n\nuniform vec3 uCameraPos;\n/**\n * Whether the fragment stage mixes toward the medium's own colour at all. 0 \u2014 what a batch\n * gets by leaving ParticleBatchOptions.fog unset \u2014 leaves vColor untouched by distance, which\n * is what a caller reaching for this material over 'spark'/'smoke' is usually asking for: an\n * unlit point drawn exactly as its own colour says. 1 mixes toward mediumColor() by\n * mediumFog(), the same medium every other pass in the frame recedes into.\n */\nuniform int uFogEnabled;\n\nuniform vec3 uFogColor;\n/** Extinction per metre **at the camera's own height**, not at the base. */\nuniform float uFogDensity;\n/** Reciprocal scale height of the haze, per metre. 0 is a uniform medium. */\nuniform float uFogHeightFalloff;\n/** The camera's height, so a fragment's own height is one subtraction away. */\nuniform float uFogEyeY;\nuniform vec3 uUnderwaterColor;\nuniform float uUnderwaterFogDensity;\nuniform float uUnderwaterFactor;\n/** 0 integrates a medium (Beer-Lambert); 1 ramps linearly between near and far. */\nuniform int uFogMode;\n/** Linear mode only: where haze begins, and where it is total. */\nuniform float uFogNear;\nuniform float uFogFar;\n\n/** What distance converges toward: the day's haze, or the water column. */\nvec3 mediumColor() {\n  return mix(uFogColor, uUnderwaterColor, uUnderwaterFactor);\n}\n\n/**\n * How much of a surface standing at height pointY, dist metres away, is lost to\n * the medium in between. 0 is perfectly clear, 1 is the medium's own colour.\n */\nfloat mediumFog(float dist, float pointY) {\n  /*\n   * A depth ramp rather than a medium, for worlds authored against one.\n   *\n   * Beer-Lambert is the honest model and stays the default: it integrates something\n   * physically there, so extinction begins at the eye and never stops. A linear near/far\n   * fog is not that \u2014 it is a *look*, with a hard start distance before which the air is\n   * perfectly clear, and it is what the fixed-function pipeline offered and what several\n   * renderers still expose. Approximating one with the other is not a matter of tuning:\n   * matched at half occlusion, the exponential curve still lays haze over everything\n   * inside near, where the ramp lays none, and near-field colour desaturates toward the\n   * fog colour with nothing to show for it.\n   *\n   * Height falloff has no meaning here and is ignored: a ramp is defined on distance\n   * alone.\n   */\n  if (uFogMode == 1) {\n    float span = max(uFogFar - uFogNear, 1e-4);\n    float ramp = clamp((dist - uFogNear) / span, 0.0, 1.0);\n    if (uUnderwaterFactor <= 0.0) return ramp;\n    float wetLinear = uUnderwaterFogDensity * dist;\n    return mix(ramp, 1.0 - exp2(-wetLinear * wetLinear * 1.442695), uUnderwaterFactor);\n  }\n\n  // Where the medium begins along the ray: uFogNear, the linear mode's slot, which this mode\n  // never read before Atmosphere.fogStart. The ray is integrated from there on, at the density\n  // of that point; at a start of 0 every term is the one it always was. See render/fog.ts.\n  float start = min(uFogNear, dist);\n  float before = dist > 0.0 ? start / dist : 0.0;\n  float t = (pointY - uFogEyeY) * uFogHeightFalloff;\n  float rest = t * (1.0 - before);\n  // (1 - e^-t)/t, which tends to 1 as the ray levels out. Guarded rather than\n  // branched: at t = 0 the quotient is 0/0, and 1e-4 of a scale height is 8 mm.\n  float denom = abs(rest) < 1e-4 ? 1e-4 : rest;\n  float air =\n    1.0 - exp(-uFogDensity * exp(-t * before) * (dist - start) * (1.0 - exp(-denom)) / denom);\n  if (uUnderwaterFactor <= 0.0) return air;\n  // Water is its own medium and keeps its own curve, so crossing the surface\n  // changes nothing about how the water column reads.\n  float wet = uUnderwaterFogDensity * dist;\n  return mix(air, 1.0 - exp2(-wet * wet * 1.442695), uUnderwaterFactor);\n}\n\n\nout vec4 outColor;\n\n/** 0 none, 1 sRGB, 2 ACES then sRGB, 3 the highlight shoulder then sRGB. See renderQuality.ts. */\nuniform int uOutputTransform;\n/** Scales the scene into the tone curve. 1 is the reference grade. See renderQuality.ts. */\nuniform float uOutputExposure;\n\n/*\n * ACES: the reference fit, not the cheap one.\n *\n * This was Narkowicz's single rational function, on the argument that the difference from\n * the reference curve is invisible next to the gain. That argument holds for a look and\n * fails for a *match*, which is what this option is for \u2014 aces exists so a world ported\n * from three.js reads the same, and three.js applies the full fit: into AP1 through\n * ACESInputMat, the RRT and ODT together, then back out through ACESOutputMat.\n *\n * The two curves are not a shade apart. Narkowicz is markedly brighter through the\n * midtones, which is exactly where an interior scene lives, and it is a large part of a\n * measured ~1.7x that survived correcting the colour space and the missing Lambert pi.\n * An approximation of a standard is the wrong thing to hold when the standard is the\n * specification.\n */\nvec3 rrtAndOdtFit(vec3 v) {\n  vec3 a = v * (v + 0.0245786) - 0.000090537;\n  vec3 b = v * (0.983729 * v + 0.4329510) + 0.238081;\n  return a / b;\n}\n\nvec3 acesFilmic(vec3 x) {\n  /*\n   * Exposure first, because a tone curve is only defined relative to one.\n   *\n   * The reference RRT and ODT are graded for a dark cinema. Every renderer that ships ACES\n   * scales its input to suit whatever it is actually shown on, and the factor each one\n   * picks is a *look*, not a standard - so this engine takes no position and reads it from\n   * the caller. Neutral by default, which is the reference grade unmodified. three.js's own\n   * pick is 1 / 0.6, for a consumer matching one.\n   */\n  x *= uOutputExposure;\n  // Columns, as GLSL reads them: sRGB -> XYZ -> D65_2_D60 -> AP1 -> RRT_SAT.\n  const mat3 ACES_INPUT = mat3(\n    0.59719, 0.07600, 0.02840,\n    0.35458, 0.90834, 0.13383,\n    0.04823, 0.01566, 0.83777\n  );\n  // ODT_SAT -> XYZ -> D60_2_D65 -> sRGB.\n  const mat3 ACES_OUTPUT = mat3(\n     1.60475, -0.10208, -0.00327,\n    -0.53108,  1.10813, -0.07276,\n    -0.07367, -0.00605,  1.07602\n  );\n  return clamp(ACES_OUTPUT * rrtAndOdtFit(ACES_INPUT * x), 0.0, 1.0);\n}\n\n\n/*\n * Linear to sRGB. The piecewise form rather than a plain pow: the linear toe near black\n * is where banding lives in an 8-bit buffer, and the cheap approximation puts it in the\n * wrong place.\n */\nvec3 linearToSrgb(vec3 c) {\n  vec3 low = c * 12.92;\n  vec3 high = 1.055 * pow(max(c, vec3(0.0)), vec3(1.0 / 2.4)) - 0.055;\n  return mix(high, low, step(c, vec3(0.0031308)));\n}\n\n\nvec3 highlightShoulder(vec3 c) {\n  float m = max(c.r, max(c.g, c.b));\n  if (m <= 0.8) return c;\n  float e = m - 0.8;\n  return c * ((0.8 + 0.2 * e / (e + 0.2)) / m);\n}\n\nvec3 applyOutputTransform(vec3 c) {\n  if (uOutputTransform == 0) return c;\n  if (uOutputTransform == 2) c = acesFilmic(c);\n  if (uOutputTransform == 3) c = highlightShoulder(c * uOutputExposure);\n  return linearToSrgb(c);\n}\n\n\nvoid main() {\n  /*\n   * One soft, round falloff \u2014 no erosion, no core past white, because this material draws\n   * neither a body being eaten by noise nor a light source. Squared rather than linear so the\n   * edge feathers instead of ramping, which is what keeps a field of these reading as dust\n   * rather than as a scatter of hard-edged discs.\n   */\n  float r = length(vUv);\n  float body = 1.0 - smoothstep(0.4, 1.0, r);\n  if (body <= 0.0) discard;\n  float alpha = body * body * vAlpha;\n  if (alpha <= 0.002) discard;\n\n  vec3 color = vColor;\n  if (uFogEnabled != 0) {\n    float fog = mediumFog(distance(vWorldPos, uCameraPos), vWorldPos.y);\n    color = mix(color, mediumColor(), fog);\n  }\n  /*\n   * A real alpha blend (SRC_ALPHA, ONE_MINUS_SRC_ALPHA) rather than spark's energy-in-colour\n   * trick: this point genuinely occludes what little is behind it instead of adding light to it.\n   */\n  outColor = vec4(applyOutputTransform(color), alpha);\n}\n";
+export declare const PARTICLE_MOTE_FRAG = "#version 300 es\nprecision highp float;\n\nin vec2 vUv;\nin vec3 vColor;\nin float vAlpha;\nin float vAge;\nin float vSeed;\nin vec3 vWorldPos;\nin vec3 vNormal;\n\nuniform vec3 uCameraPos;\n/**\n * Whether the fragment stage mixes toward the medium's own colour at all. 0 \u2014 what a batch\n * gets by leaving ParticleBatchOptions.fog unset \u2014 leaves vColor untouched by distance, which\n * is what a caller reaching for this material over 'spark'/'smoke' is usually asking for: an\n * unlit point drawn exactly as its own colour says. 1 mixes toward mediumColor() by\n * mediumFog(), the same medium every other pass in the frame recedes into.\n */\nuniform int uFogEnabled;\n\nuniform vec3 uFogColor;\n/**\n * The haze: its extinction per metre **at the camera's own height**, not at the base; its\n * reciprocal scale height per metre, 0 for a uniform medium; the camera's height, so a fragment's\n * own height is one subtraction away; and the water column's own density.\n *\n * **Four numbers in one vector rather than four uniforms**, and the reason is a phone: a scalar\n * costs a whole row of the uniform grid, and the lit stage at its eight-light rung must fit the 256\n * rows an Adreno 740 offers (uniformVectorBudget.ts). Packed, the haze's eight scalars cost two\n * rows where they cost eight, which is what paid for the second layer and the sun's glow below.\n */\nuniform vec4 uFogMedium;\n/** Where haze begins, where a linear ramp is total, and the mode: 0 a medium, 1 a ramp. */\nuniform vec4 uFogRange;\nuniform vec3 uUnderwaterColor;\nuniform float uUnderwaterFactor;\n/**\n * The second layer's extinction per metre at the camera's height and its falloff; then the least of\n * a surface the haze must leave, Atmosphere.fogMaxOpacity's complement, and the distance past which\n * it hides nothing (0 is none). **Every lane is none at zero**, and so are uFogGlow's: a program a\n * binder never wrote these into draws the haze it drew before they existed, rather than none.\n */\nuniform vec4 uFogLayer2;\n/** The sun's glow in the haze: its colour, black for none, and the exponent of its lobe. */\nuniform vec4 uFogGlow;\n/** Surface \u2192 the glow's light, and how far past the haze's start the glow begins. */\nuniform vec4 uFogGlowDir;\n\n/** What distance converges toward: the day's haze, or the water column. */\nvec3 mediumColor() {\n  return mix(uFogColor, uUnderwaterColor, uUnderwaterFactor);\n}\n\n/**\n * The haze's optical depth from where it begins along the ray to a point at height pointY, dist\n * metres away: each layer's density at the eye carried over what is left of the ray, with the\n * second layer only where there is one. The fog and the sun's glow both integrate it.\n */\nfloat hazeDepth(float dist, float pointY) {\n  // Where the medium begins along the ray: uFogRange.x, the linear mode's slot, which this mode\n  // never read before Atmosphere.fogStart. The ray is integrated from there on, at the density\n  // of that point; at a start of 0 every term is the one it always was. See render/fog.ts.\n  float start = min(uFogRange.x, dist);\n  float before = dist > 0.0 ? start / dist : 0.0;\n  float t = (pointY - uFogMedium.z) * uFogMedium.y;\n  float rest = t * (1.0 - before);\n  // (1 - e^-t)/t, which tends to 1 as the ray levels out. Guarded rather than\n  // branched: at t = 0 the quotient is 0/0, and 1e-4 of a scale height is 8 mm.\n  float denom = abs(rest) < 1e-4 ? 1e-4 : rest;\n  float depth = uFogMedium.x * exp(-t * before) * (dist - start) * (1.0 - exp(-denom)) / denom;\n  if (uFogLayer2.x > 0.0) {\n    float t2 = (pointY - uFogMedium.z) * uFogLayer2.y;\n    float rest2 = t2 * (1.0 - before);\n    float denom2 = abs(rest2) < 1e-4 ? 1e-4 : rest2;\n    depth += uFogLayer2.x * exp(-t2 * before) * (dist - start) * (1.0 - exp(-denom2)) / denom2;\n  }\n  return depth;\n}\n\n/**\n * How much of a surface standing at height pointY, dist metres away, is lost to\n * the medium in between. 0 is perfectly clear, 1 is the medium's own colour.\n */\nfloat mediumFog(float dist, float pointY) {\n  /* Past the cutoff the air hides nothing, in either mode; the water column keeps its own law. */\n  bool cut = uFogLayer2.w > 0.0 && dist > uFogLayer2.w;\n  /*\n   * A depth ramp rather than a medium, for worlds authored against one.\n   *\n   * Beer-Lambert is the honest model and stays the default: it integrates something\n   * physically there, so extinction begins at the eye and never stops. A linear near/far\n   * fog is not that \u2014 it is a *look*, with a hard start distance before which the air is\n   * perfectly clear, and it is what the fixed-function pipeline offered and what several\n   * renderers still expose. Approximating one with the other is not a matter of tuning:\n   * matched at half occlusion, the exponential curve still lays haze over everything\n   * inside near, where the ramp lays none, and near-field colour desaturates toward the\n   * fog colour with nothing to show for it.\n   *\n   * Height falloff has no meaning here and is ignored: a ramp is defined on distance\n   * alone.\n   */\n  if (uFogRange.z == 1.0) {\n    float span = max(uFogRange.y - uFogRange.x, 1e-4);\n    float ramp = cut ? 0.0 : min(clamp((dist - uFogRange.x) / span, 0.0, 1.0), 1.0 - uFogLayer2.z);\n    if (uUnderwaterFactor <= 0.0) return ramp;\n    float wetLinear = uFogMedium.w * dist;\n    return mix(ramp, 1.0 - exp2(-wetLinear * wetLinear * 1.442695), uUnderwaterFactor);\n  }\n\n  // Beer-Lambert through both layers, leaving at least uFogLayer2.z of the surface: a floor on\n  // what survives rather than a ceiling on the depth, so the curve keeps its shape above it.\n  float air = cut ? 0.0 : 1.0 - max(exp(-hazeDepth(dist, pointY)), uFogLayer2.z);\n  if (uUnderwaterFactor <= 0.0) return air;\n  // Water is its own medium and keeps its own curve, so crossing the surface\n  // changes nothing about how the water column reads.\n  float wet = uFogMedium.w * dist;\n  return mix(air, 1.0 - exp2(-wet * wet * 1.442695), uUnderwaterFactor);\n}\n\n/**\n * The sun's light the haze scatters toward the eye along a ray to a point at height pointY, dist\n * metres away in the direction toPoint: added to a surface after its fog, never mixed. A lobe of\n * cos^exponent about the light, by as much of the ray past the glow's own start as the haze hides \u2014\n * the haze's depth per metre carried over that stretch. None in a linear ramp, past the cutoff, or\n * under water, which keeps its own medium.\n */\nvec3 mediumGlow(float dist, float pointY, vec3 toPoint) {\n  if (uFogRange.z == 1.0 || max(max(uFogGlow.r, uFogGlow.g), uFogGlow.b) <= 0.0) return vec3(0.0);\n  if (uFogLayer2.w > 0.0 && dist > uFogLayer2.w) return vec3(0.0);\n  float span = dist - min(uFogRange.x, dist);\n  if (span <= 0.0) return vec3(0.0);\n  float perMetre = hazeDepth(dist, pointY) / span;\n  float hidden = 1.0 - exp(-perMetre * max(span - uFogGlowDir.w, 0.0));\n  float lobe = pow(clamp(dot(toPoint, uFogGlowDir.xyz), 0.0, 1.0), uFogGlow.a);\n  return uFogGlow.rgb * (lobe * hidden * (1.0 - uUnderwaterFactor));\n}\n\n\nout vec4 outColor;\n\n/** 0 none, 1 sRGB, 2 ACES then sRGB, 3 the highlight shoulder then sRGB. See renderQuality.ts. */\nuniform int uOutputTransform;\n/** Scales the scene into the tone curve. 1 is the reference grade. See renderQuality.ts. */\nuniform float uOutputExposure;\n\n/*\n * ACES: the reference fit, not the cheap one.\n *\n * This was Narkowicz's single rational function, on the argument that the difference from\n * the reference curve is invisible next to the gain. That argument holds for a look and\n * fails for a *match*, which is what this option is for \u2014 aces exists so a world ported\n * from three.js reads the same, and three.js applies the full fit: into AP1 through\n * ACESInputMat, the RRT and ODT together, then back out through ACESOutputMat.\n *\n * The two curves are not a shade apart. Narkowicz is markedly brighter through the\n * midtones, which is exactly where an interior scene lives, and it is a large part of a\n * measured ~1.7x that survived correcting the colour space and the missing Lambert pi.\n * An approximation of a standard is the wrong thing to hold when the standard is the\n * specification.\n */\nvec3 rrtAndOdtFit(vec3 v) {\n  vec3 a = v * (v + 0.0245786) - 0.000090537;\n  vec3 b = v * (0.983729 * v + 0.4329510) + 0.238081;\n  return a / b;\n}\n\nvec3 acesFilmic(vec3 x) {\n  /*\n   * Exposure first, because a tone curve is only defined relative to one.\n   *\n   * The reference RRT and ODT are graded for a dark cinema. Every renderer that ships ACES\n   * scales its input to suit whatever it is actually shown on, and the factor each one\n   * picks is a *look*, not a standard - so this engine takes no position and reads it from\n   * the caller. Neutral by default, which is the reference grade unmodified. three.js's own\n   * pick is 1 / 0.6, for a consumer matching one.\n   */\n  x *= uOutputExposure;\n  // Columns, as GLSL reads them: sRGB -> XYZ -> D65_2_D60 -> AP1 -> RRT_SAT.\n  const mat3 ACES_INPUT = mat3(\n    0.59719, 0.07600, 0.02840,\n    0.35458, 0.90834, 0.13383,\n    0.04823, 0.01566, 0.83777\n  );\n  // ODT_SAT -> XYZ -> D60_2_D65 -> sRGB.\n  const mat3 ACES_OUTPUT = mat3(\n     1.60475, -0.10208, -0.00327,\n    -0.53108,  1.10813, -0.07276,\n    -0.07367, -0.00605,  1.07602\n  );\n  return clamp(ACES_OUTPUT * rrtAndOdtFit(ACES_INPUT * x), 0.0, 1.0);\n}\n\n\n/*\n * Linear to sRGB. The piecewise form rather than a plain pow: the linear toe near black\n * is where banding lives in an 8-bit buffer, and the cheap approximation puts it in the\n * wrong place.\n */\nvec3 linearToSrgb(vec3 c) {\n  vec3 low = c * 12.92;\n  vec3 high = 1.055 * pow(max(c, vec3(0.0)), vec3(1.0 / 2.4)) - 0.055;\n  return mix(high, low, step(c, vec3(0.0031308)));\n}\n\n\nvec3 highlightShoulder(vec3 c) {\n  float m = max(c.r, max(c.g, c.b));\n  if (m <= 0.8) return c;\n  float e = m - 0.8;\n  return c * ((0.8 + 0.2 * e / (e + 0.2)) / m);\n}\n\nvec3 applyOutputTransform(vec3 c) {\n  if (uOutputTransform == 0) return c;\n  if (uOutputTransform == 2) c = acesFilmic(c);\n  if (uOutputTransform == 3) c = highlightShoulder(c * uOutputExposure);\n  return linearToSrgb(c);\n}\n\n\nvoid main() {\n  /*\n   * One soft, round falloff \u2014 no erosion, no core past white, because this material draws\n   * neither a body being eaten by noise nor a light source. Squared rather than linear so the\n   * edge feathers instead of ramping, which is what keeps a field of these reading as dust\n   * rather than as a scatter of hard-edged discs.\n   */\n  float r = length(vUv);\n  float body = 1.0 - smoothstep(0.4, 1.0, r);\n  if (body <= 0.0) discard;\n  float alpha = body * body * vAlpha;\n  if (alpha <= 0.002) discard;\n\n  vec3 color = vColor;\n  if (uFogEnabled != 0) {\n    float dist = distance(vWorldPos, uCameraPos);\n    float fog = mediumFog(dist, vWorldPos.y);\n    color = mix(color, mediumColor(), fog) + mediumGlow(dist, vWorldPos.y, normalize(vWorldPos - uCameraPos));\n  }\n  /*\n   * A real alpha blend (SRC_ALPHA, ONE_MINUS_SRC_ALPHA) rather than spark's energy-in-colour\n   * trick: this point genuinely occludes what little is behind it instead of adding light to it.\n   */\n  outColor = vec4(applyOutputTransform(color), alpha);\n}\n";
 /**
  * A textured sprite: an image a consumer supplies, a cell of it at a time, at the colour and opacity
  * each particle carries — what another engine's sprite renderer draws, and the material the three