@driftengine/core 3.61.0

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

@@ -0,0 +1,37 @@
+/**
+ * The grade every forward pass applies when it is the last one to touch the frame.
+ *
+ * **One GLSL string rather than a copy in each program**, for the reason `fog.ts` gives about
+ * itself and for a sharper one here: this is not a look, it is a *conversion*, and two passes
+ * converting differently is a scene where the smoke and the wall it drifts past disagree about
+ * what a colour means. That is exactly the state this engine was in until this file existed.
+ * `flat.ts` carried the whole thing privately, and `renderer.ts` said so in its own words at the
+ * mesh pass's upload site: *"full grading needs the composite. Without it the sky, the
+ * particles, the film and the water are still ungraded beside a world that is."*
+ *
+ * **What that costs a consumer with no composite, which is the case this closes.** A pass that
+ * writes linear values into an 8-bit target has them read back as if they were already display
+ * values, which is not a subtle shift: `#ff8d72` reaches the screen as `(255, 68, 43)` instead
+ * of `(213, 125, 97)`, a saturated red where the author asked for a warm salmon, and it clips.
+ * Found on a site port whose sparkle field went from additive and fogged, where it was too dim
+ * to show, to alpha blended and unfogged, where it was the brightest thing in the frame.
+ *
+ * **Blending happens after this, in display space, and that is the same thing three.js does.**
+ * three.js tone maps and converts inside every material's own fragment stage, so a blended draw
+ * there composites graded against graded too. It is a real difference from grading once at a
+ * composite, where blending happens in scene units, and it is the difference a consumer asks
+ * for when it turns the composite off.
+ *
+ * **A pass must apply this only when it is genuinely last.** With a scene target the resolve
+ * grades, so a pass that also graded would apply a curve to its own output; every upload site
+ * gates on the same `gradeHere` the mesh pass uses.
+ */
+/**
+ * `uOutputTransform` and `uOutputExposure`, the fit, and `applyOutputTransform`.
+ *
+ * Declares its own two uniforms, so including it is the whole of what a fragment stage has to
+ * do besides calling it. Both are ints and floats rather than defines because the choice is a
+ * caller's, per draw, and a permutation per output transform would double a pipeline count for
+ * a branch that costs one compare.
+ */
+export declare const OUTPUT_TRANSFORM_GLSL = "\n/** 0 none, 1 sRGB, 2 ACES 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 * 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\nvec3 applyOutputTransform(vec3 c) {\n  if (uOutputTransform == 0) return c;\n  if (uOutputTransform == 2) c = acesFilmic(c);\n  return linearToSrgb(c);\n}\n";

package/dist/render/shaders/outputTransform.js

@@ -0,0 +1,106 @@
+/**
+ * The grade every forward pass applies when it is the last one to touch the frame.
+ *
+ * **One GLSL string rather than a copy in each program**, for the reason `fog.ts` gives about
+ * itself and for a sharper one here: this is not a look, it is a *conversion*, and two passes
+ * converting differently is a scene where the smoke and the wall it drifts past disagree about
+ * what a colour means. That is exactly the state this engine was in until this file existed.
+ * `flat.ts` carried the whole thing privately, and `renderer.ts` said so in its own words at the
+ * mesh pass's upload site: *"full grading needs the composite. Without it the sky, the
+ * particles, the film and the water are still ungraded beside a world that is."*
+ *
+ * **What that costs a consumer with no composite, which is the case this closes.** A pass that
+ * writes linear values into an 8-bit target has them read back as if they were already display
+ * values, which is not a subtle shift: `#ff8d72` reaches the screen as `(255, 68, 43)` instead
+ * of `(213, 125, 97)`, a saturated red where the author asked for a warm salmon, and it clips.
+ * Found on a site port whose sparkle field went from additive and fogged, where it was too dim
+ * to show, to alpha blended and unfogged, where it was the brightest thing in the frame.
+ *
+ * **Blending happens after this, in display space, and that is the same thing three.js does.**
+ * three.js tone maps and converts inside every material's own fragment stage, so a blended draw
+ * there composites graded against graded too. It is a real difference from grading once at a
+ * composite, where blending happens in scene units, and it is the difference a consumer asks
+ * for when it turns the composite off.
+ *
+ * **A pass must apply this only when it is genuinely last.** With a scene target the resolve
+ * grades, so a pass that also graded would apply a curve to its own output; every upload site
+ * gates on the same `gradeHere` the mesh pass uses.
+ */
+/**
+ * `uOutputTransform` and `uOutputExposure`, the fit, and `applyOutputTransform`.
+ *
+ * Declares its own two uniforms, so including it is the whole of what a fragment stage has to
+ * do besides calling it. Both are ints and floats rather than defines because the choice is a
+ * caller's, per draw, and a permutation per output transform would double a pipeline count for
+ * a branch that costs one compare.
+ */
+export const OUTPUT_TRANSFORM_GLSL = `
+/** 0 none, 1 sRGB, 2 ACES then sRGB. See renderQuality.ts. */
+uniform int uOutputTransform;
+/** Scales the scene into the tone curve. 1 is the reference grade. See renderQuality.ts. */
+uniform float uOutputExposure;
+
+/*
+ * ACES: the reference fit, not the cheap one.
+ *
+ * This was Narkowicz's single rational function, on the argument that the difference from
+ * the reference curve is invisible next to the gain. That argument holds for a look and
+ * fails for a *match*, which is what this option is for — aces exists so a world ported
+ * from three.js reads the same, and three.js applies the full fit: into AP1 through
+ * ACESInputMat, the RRT and ODT together, then back out through ACESOutputMat.
+ *
+ * The two curves are not a shade apart. Narkowicz is markedly brighter through the
+ * midtones, which is exactly where an interior scene lives, and it is a large part of a
+ * measured ~1.7x that survived correcting the colour space and the missing Lambert pi.
+ * An approximation of a standard is the wrong thing to hold when the standard is the
+ * specification.
+ */
+vec3 rrtAndOdtFit(vec3 v) {
+  vec3 a = v * (v + 0.0245786) - 0.000090537;
+  vec3 b = v * (0.983729 * v + 0.4329510) + 0.238081;
+  return a / b;
+}
+
+vec3 acesFilmic(vec3 x) {
+  /*
+   * Exposure first, because a tone curve is only defined relative to one.
+   *
+   * The reference RRT and ODT are graded for a dark cinema. Every renderer that ships ACES
+   * scales its input to suit whatever it is actually shown on, and the factor each one
+   * picks is a *look*, not a standard - so this engine takes no position and reads it from
+   * the caller. Neutral by default, which is the reference grade unmodified. three.js's own
+   * pick is 1 / 0.6, for a consumer matching one.
+   */
+  x *= uOutputExposure;
+  // Columns, as GLSL reads them: sRGB -> XYZ -> D65_2_D60 -> AP1 -> RRT_SAT.
+  const mat3 ACES_INPUT = mat3(
+    0.59719, 0.07600, 0.02840,
+    0.35458, 0.90834, 0.13383,
+    0.04823, 0.01566, 0.83777
+  );
+  // ODT_SAT -> XYZ -> D60_2_D65 -> sRGB.
+  const mat3 ACES_OUTPUT = mat3(
+     1.60475, -0.10208, -0.00327,
+    -0.53108,  1.10813, -0.07276,
+    -0.07367, -0.00605,  1.07602
+  );
+  return clamp(ACES_OUTPUT * rrtAndOdtFit(ACES_INPUT * x), 0.0, 1.0);
+}
+
+/*
+ * Linear to sRGB. The piecewise form rather than a plain pow: the linear toe near black
+ * is where banding lives in an 8-bit buffer, and the cheap approximation puts it in the
+ * wrong place.
+ */
+vec3 linearToSrgb(vec3 c) {
+  vec3 low = c * 12.92;
+  vec3 high = 1.055 * pow(max(c, vec3(0.0)), vec3(1.0 / 2.4)) - 0.055;
+  return mix(high, low, step(c, vec3(0.0031308)));
+}
+
+vec3 applyOutputTransform(vec3 c) {
+  if (uOutputTransform == 0) return c;
+  if (uOutputTransform == 2) c = acesFilmic(c);
+  return linearToSrgb(c);
+}
+`;

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

@@ -0,0 +1,17 @@
+/**
+ * A flat, blended rectangle in screen space.
+ *
+ * The engine could draw a solid rectangle two ways before this and neither is one:
+ * `beginInset` clears a box to a colour, which is opaque by definition, and
+ * `TextRenderer.setPlate` builds the rectangle out of one lit *cube per cell* — right
+ * for a keycap two cells tall, and at panel size a grid of seams: a plate made that
+ * way reads as messy rather than as plain.
+ *
+ * So: two triangles, one colour, one alpha, no lighting and no geometry. What a caller
+ * wants when it needs somewhere to read type against.
+ *
+ * Coordinates are **CSS pixels with a top-left origin**, the same convention
+ * `InsetRect` uses and the same one a caller laying out an overlay already has.
+ */
+export declare const PANEL_VERT = "#version 300 es\nlayout(location = 0) in vec2 aCorner;\n\n/** left, top, width, height, in CSS pixels from the top-left of the viewport. */\nuniform vec4 uRect;\nuniform vec2 uViewport;\n/**\n * Clip space, as the backend drawing this defines it. Identity on WebGL2.\n *\n * Like the text pass, this builds its own clip position and never multiplies by a camera, so the\n * correction every other draw carries in its view-projection cannot reach it. Without it the\n * generated vertex shader's Y negation stands uncancelled and the panel lands mirrored about\n * the middle of the frame \u2014 a bar drawn at 82% of the height appearing at 18% of it.\n */\nuniform mat4 uClipCorrection;\n\nvoid main() {\n  vec2 px = uRect.xy + aCorner * uRect.zw;\n  // Into clip space, flipping y: the caller counts down from the top and GL counts up.\n  vec2 ndc = vec2(px.x / uViewport.x * 2.0 - 1.0, 1.0 - px.y / uViewport.y * 2.0);\n  gl_Position = uClipCorrection * vec4(ndc, 0.0, 1.0);\n}\n";
+export declare const PANEL_FRAG = "#version 300 es\nprecision highp float;\n\nuniform vec3 uColor;\nuniform float uAlpha;\n\nout vec4 outColor;\n\nvoid main() {\n  outColor = vec4(uColor, uAlpha);\n}\n";

package/dist/render/shaders/panel.js

@@ -0,0 +1,50 @@
+/**
+ * A flat, blended rectangle in screen space.
+ *
+ * The engine could draw a solid rectangle two ways before this and neither is one:
+ * `beginInset` clears a box to a colour, which is opaque by definition, and
+ * `TextRenderer.setPlate` builds the rectangle out of one lit *cube per cell* — right
+ * for a keycap two cells tall, and at panel size a grid of seams: a plate made that
+ * way reads as messy rather than as plain.
+ *
+ * So: two triangles, one colour, one alpha, no lighting and no geometry. What a caller
+ * wants when it needs somewhere to read type against.
+ *
+ * Coordinates are **CSS pixels with a top-left origin**, the same convention
+ * `InsetRect` uses and the same one a caller laying out an overlay already has.
+ */
+export const PANEL_VERT = `#version 300 es
+layout(location = 0) in vec2 aCorner;
+
+/** left, top, width, height, in CSS pixels from the top-left of the viewport. */
+uniform vec4 uRect;
+uniform vec2 uViewport;
+/**
+ * Clip space, as the backend drawing this defines it. Identity on WebGL2.
+ *
+ * Like the text pass, this builds its own clip position and never multiplies by a camera, so the
+ * correction every other draw carries in its view-projection cannot reach it. Without it the
+ * generated vertex shader's Y negation stands uncancelled and the panel lands mirrored about
+ * the middle of the frame — a bar drawn at 82% of the height appearing at 18% of it.
+ */
+uniform mat4 uClipCorrection;
+
+void main() {
+  vec2 px = uRect.xy + aCorner * uRect.zw;
+  // Into clip space, flipping y: the caller counts down from the top and GL counts up.
+  vec2 ndc = vec2(px.x / uViewport.x * 2.0 - 1.0, 1.0 - px.y / uViewport.y * 2.0);
+  gl_Position = uClipCorrection * vec4(ndc, 0.0, 1.0);
+}
+`;
+export const PANEL_FRAG = `#version 300 es
+precision highp float;
+
+uniform vec3 uColor;
+uniform float uAlpha;
+
+out vec4 outColor;
+
+void main() {
+  outColor = vec4(uColor, uAlpha);
+}
+`;

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

@@ -0,0 +1,82 @@
+/**
+ * Particle materials: soft smoke, hot sparks, and unlit motes.
+ *
+ * One vertex program, three fragment programs, and the split is the same one the
+ * plumes already make — `PLUME_VERT` places a volume and the fragment decides
+ * whether it is fire or smoke. Here the vertex program places a particle as a
+ * **camera-facing quad**, or as a world-fixed cross of two when a caller asks, and
+ * the fragment decides whether it is a puff of grit, an ember, or an unlit point.
+ *
+ * **The cross was the only option and then the default, and is now neither.** The
+ * argument for it is the one `plumeRenderer` records at length, and it is a real
+ * one: a billboard has no parallax, so orbiting a plume shows the identical
+ * silhouette from every angle and the whole effect swivels as a sheet, where two
+ * fixed blades genuinely bring one broadside as the other goes edge-on. What that
+ * argument leaves out is what the going-edge-on blade *draws*. It does not fade as
+ * it turns; it compresses, and a sprite compressed into a one-pixel column spends
+ * its entire brightness in that column. On smoke it hides inside the noise. On an
+ * additive spark it is a bright straight line through the middle of every particle,
+ * which is how it was finally caught. `uCameraFacing` carries the full account and
+ * the terms of the trade for anyone who wants the blades back.
+ *
+ * **These replace drawing particles through the foliage shader**, which is what
+ * every effect built on `ParticlePool` used to do. Grass is opaque, lit
+ * two-sided, and has no opacity channel — so a grain of smoke was a solid cube
+ * lit like a leaf, and its "fade" was its colour being driven to black — which reads
+ * as squared-off smoke that never had a shader of its own, against fire that did.
+ * This is that missing quality: a soft body eroded by
+ * the same value noise, an honest alpha, and real lighting.
+ */
+/**
+ * Blades in the cross, and the vertices and indices that costs.
+ *
+ * Still two under `facing: 'camera'`, where the second is collapsed to zero area in the
+ * vertex stage rather than dropped here — so one pair of buffers serves both facings and a
+ * batch chooses per pool. See `uCameraFacing`.
+ */
+export declare const PARTICLE_BLADES = 2;
+export declare const PARTICLE_VERTS: number;
+export declare const PARTICLE_INDICES: number;
+export declare const PARTICLE_VERT = "#version 300 es\n/** Per-vertex: the quad corner, and which blade of the cross it belongs to. */\nlayout(location = 0) in vec2 aCorner;\nlayout(location = 1) in float aBlade;\n/** Per-instance. */\nlayout(location = 2) in vec3 aPos;\nlayout(location = 3) in float aSize;\nlayout(location = 4) in float aSpin;\nlayout(location = 5) in vec3 aColor;\n/** Opacity, age as a share of life, and this particle's own seed. */\nlayout(location = 6) in float aAlpha;\nlayout(location = 7) in float aAge;\nlayout(location = 8) in float aSeed;\nlayout(location = 9) in vec3 aVelocity;\n\nuniform mat4 uViewProj;\nuniform vec3 uCameraPos;\n/**\n * How far a particle is stretched along its own motion, in seconds of travel.\n *\n * Zero for smoke, which has no direction worth seeing. A spark is the opposite\n * case: an ember crossing a metre in a frame drawn as a round dot reads as a\n * floating pixel, and the same ember drawn as a short streak along its velocity\n * reads as a thrown spark. The eye gets its motion cue from the shape.\n */\nuniform float uStretchSec;\n/**\n * 1 to turn a single quad to face the camera, 0 to draw the world-fixed cross.\n *\n * **Camera-facing is the default, and the cross is the option.** It was the other way\n * round until a caller drew an additive glow with a camera looking down -Z and got a\n * bright straight line through the middle of every sprite. The cross is two blades at\n * right angles in *world* space: blade 0 spans X, blade 1 spans Z. Look down either\n * axis and that blade is edge-on, and a disc squeezed into a one-pixel column does not\n * lose the energy it was drawn with \u2014 it puts all of it in that column. Alpha-blended\n * smoke half hides it behind its own noise. Additive has nothing to hide it with.\n *\n * Fading a blade out as it turns edge-on fixes that one case and not the matching one:\n * both blades contain world Y, so a camera looking straight down sees *both* edge-on\n * and the puff is a plus sign of two lines, or nothing at all once they are faded. A\n * camera-facing quad has no angle at which it thins, which is why it is what particle\n * systems generally draw.\n *\n * The cross is still worth keeping. Two blades give real parallax when a camera moves\n * through a puff, and that is a volume cue a single quad cannot fake \u2014 worth having in\n * a ground-level world whose camera never looks far off the horizontal, where the\n * edge-on blade stays a thin sliver inside soft smoke rather than a line across a\n * spark. It also costs a brightness that swings with the view: a cross covers one\n * sprite of area seen down an axis and about 1.4 seen from the diagonal, so a puff\n * quietly pulses as the camera orbits it. A camera-facing quad covers the same area\n * from everywhere.\n */\nuniform float uCameraFacing;\n\nout vec2 vUv;\nout vec3 vColor;\nout float vAlpha;\nout float vAge;\nout float vSeed;\nout vec3 vWorldPos;\nout vec3 vNormal;\n\nvoid main() {\n  float s = sin(aSpin);\n  float c = cos(aSpin);\n  // Roll within the blade's own plane, so the two blades never look like one\n  // rigid object turning.\n  vec2 rolled = vec2(aCorner.x * c - aCorner.y * s, aCorner.x * s + aCorner.y * c);\n\n  /*\n   * The plane the corners are laid out in, built from the particle's centre rather than\n   * from the corner being transformed, so all four corners of a quad share one basis and\n   * the quad stays planar and rectangular.\n   */\n  vec3 across;\n  vec3 up;\n  float bladeGain;\n  if (uCameraFacing > 0.5) {\n    vec3 toCamera = normalize(uCameraPos - aPos);\n    /* Any reference not parallel to the view. World up serves everywhere except looking\n       straight up or down it, where the two are the same line and the cross product\n       vanishes; +Z takes over there. */\n    vec3 reference = abs(toCamera.y) > 0.999 ? vec3(0.0, 0.0, 1.0) : vec3(0.0, 1.0, 0.0);\n    across = normalize(cross(reference, toCamera));\n    up = cross(toCamera, across);\n    /*\n     * One quad, not two. Both blades face the camera here, so they would land on exactly\n     * the same pixels and the second would be nothing but the first drawn again: double\n     * the fill for double the brightness no caller asked for. Collapsing it to zero area\n     * costs nothing \u2014 the rasteriser drops a degenerate triangle before it shades \u2014 and\n     * leaves the vertex and index buffers the shape both backends already build, so a\n     * batch picks its facing without either one rebuilding its geometry.\n     */\n    bladeGain = aBlade < 0.5 ? 1.0 : 0.0;\n  } else {\n    across = aBlade < 0.5 ? vec3(1.0, 0.0, 0.0) : vec3(0.0, 0.0, 1.0);\n    up = vec3(0.0, 1.0, 0.0);\n    bladeGain = 1.0;\n  }\n  vec3 offset = (across * rolled.x + up * rolled.y) * aSize;\n\n  /*\n   * Stretched along travel. Applied as an extra displacement on the component of\n   * the corner that already points along the motion, so a stationary particle is\n   * untouched and a fast one lengthens without also getting fatter.\n   */\n  if (uStretchSec > 0.0) {\n    vec3 travel = aVelocity * uStretchSec;\n    float along = dot(normalize(offset + vec3(1e-6)), normalize(travel + vec3(1e-6)));\n    offset += travel * along * 0.5;\n  }\n\n  /* bladeGain applied here, after the stretch rather than before it, so a dropped blade\n     is degenerate whatever the stretch added: all four of its corners land on aPos. */\n  vec3 world = aPos + offset * bladeGain;\n  vUv = aCorner;\n  vColor = aColor;\n  vAlpha = aAlpha;\n  vAge = aAge;\n  vSeed = aSeed;\n  vWorldPos = world;\n  /*\n   * The blade's own facing, flipped toward the viewer. A cross has no meaningful\n   * outward normal, and a puff of smoke is not a surface \u2014 but it does have to be\n   * *lit*, and a normal facing the camera is the standard, honest cheat for a\n   * volume approximated by cards: it makes the puff read as a lump catching light\n   * from wherever the light is, rather than as a flat panel that goes black at\n   * some angles.\n   */\n  vec3 face = cross(across, up);\n  vec3 toEye = normalize(uCameraPos - world);\n  vNormal = dot(face, toEye) < 0.0 ? -face : face;\n\n  gl_Position = uViewProj * vec4(world, 1.0);\n}\n";
+/**
+ * Smoke, grit and dust: a soft body eroded by noise, alpha blended, and lit.
+ *
+ * Lit by the sun, the ambient *and* the nearby point lights, which is the half
+ * the foliage path could never do. A drift at night beside a brazier threw grey
+ * grit whatever the brazier was doing, because grass has no point-light term —
+ * 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  float t = (pointY - uFogEyeY) * uFogHeightFalloff;\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(t) < 1e-4 ? 1e-4 : t;\n  float air = 1.0 - exp(-uFogDensity * dist * (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. 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 * 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\nvec3 applyOutputTransform(vec3 c) {\n  if (uOutputTransform == 0) return c;\n  if (uOutputTransform == 2) c = acesFilmic(c);\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";
+/**
+ * Sparks and embers: additive, hot in the middle, and stretched along travel.
+ *
+ * No lighting at all, deliberately — a spark *is* a light source, and shading it
+ * 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  float t = (pointY - uFogEyeY) * uFogHeightFalloff;\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(t) < 1e-4 ? 1e-4 : t;\n  float air = 1.0 - exp(-uFogDensity * dist * (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. 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 * 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\nvec3 applyOutputTransform(vec3 c) {\n  if (uOutputTransform == 0) return c;\n  if (uOutputTransform == 2) c = acesFilmic(c);\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.
+ *
+ * **What neither existing material could draw.** `'spark'` is unlit but additive — its
+ * fragment stage folds its whole brightness into colour and always writes alpha 1, because
+ * additive blending is `rgb * a` and a real alpha there would double the energy (the note at
+ * the end of `PARTICLE_SPARK_FRAG` explains why). `'smoke'` has a real, varying alpha, but pays
+ * for it with lighting it can never turn off. A point that is unlit *and* genuinely
+ * translucent — what three.js's `PointsMaterial` draws, and what drei's `Sparkles` is built on
+ * — was not expressible by either.
+ *
+ * No noise, no core-and-halo split: a mote is not a body being eroded and it is not
+ * incandescent, so borrowing either shape would draw the wrong material behind the right blend
+ * state. This is the plainest fragment stage in the file on purpose — a soft round point whose
+ * colour is nothing but its own vColor and whose opacity is nothing but its own vAlpha.
+ *
+ * **Fog is the one thing this material still asks the caller about.** A mote is the one
+ * particle a scene legitimately wants both ways: dust caught in a shaft of light recedes into
+ * haze exactly like anything else out there, but a field of them meant to read as flat, close
+ * atmosphere — the look this exists for — must not. `'spark'` and `'smoke'` take no such
+ * 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  float t = (pointY - uFogEyeY) * uFogHeightFalloff;\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(t) < 1e-4 ? 1e-4 : t;\n  float air = 1.0 - exp(-uFogDensity * dist * (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. 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 * 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\nvec3 applyOutputTransform(vec3 c) {\n  if (uOutputTransform == 0) return c;\n  if (uOutputTransform == 2) c = acesFilmic(c);\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";