@driftengine/core 4.12.0 → 4.13.0

package/dist/render/globalMediumPass.d.ts

@@ -97,6 +97,8 @@ export declare class GlobalMediumPass {
      * `(ONE, SRC_ALPHA)` on colour is `dst * transmittance + inscatter`; alpha is left alone with
      * `(ZERO, ONE)`, because the frame's own alpha is not the medium's to spend.
      */
-    compositeMedium(depth: WebGLTexture, frameWidth: number, frameHeight: number): void;
+    compositeMedium(depth: WebGLTexture, frameWidth: number, frameHeight: number, 
+    /** The renderer's `passGrade`: how the frame under the medium was graded. */
+    outputTransform?: number, outputExposure?: number): void;
     dispose(): void;
 }

package/dist/render/globalMediumPass.js

@@ -192,7 +192,9 @@ export class GlobalMediumPass {
      * `(ONE, SRC_ALPHA)` on colour is `dst * transmittance + inscatter`; alpha is left alone with
      * `(ZERO, ONE)`, because the frame's own alpha is not the medium's to spend.
      */
-    compositeMedium(depth, frameWidth, frameHeight) {
+    compositeMedium(depth, frameWidth, frameHeight, 
+    /** The renderer's `passGrade`: how the frame under the medium was graded. */
+    outputTransform = 0, outputExposure = 1) {
         if (this.target === null || this.unavailable)
             return;
         const { gl } = this;
@@ -215,6 +217,8 @@ export class GlobalMediumPass {
         this.mediumTexel[1] = 1 / Math.max(1, this.height);
         gl.uniform2fv(u['uMediumTexel'] ?? null, this.mediumTexel);
         gl.uniform4fv(u['uDepthToViewZ'] ?? null, this.depthToViewZ);
+        gl.uniform1i(u['uOutputTransform'] ?? null, outputTransform);
+        gl.uniform1f(u['uOutputExposure'] ?? null, outputExposure);
         gl.drawArrays(gl.TRIANGLES, 0, 3);
         gl.bindVertexArray(null);
         gl.activeTexture(gl.TEXTURE1);

package/dist/render/gradeColor.d.ts

@@ -0,0 +1,21 @@
+/**
+ * The forward grade on the CPU: what `applyOutputTransform` in `shaders/outputTransform.ts` does to
+ * a colour, for a colour no shader draws — a clear colour, written to a target before any pass runs.
+ *
+ * **Why a clear colour is graded at all.** Every pass grades what it draws when nothing after it
+ * will, so a colour handed to the renderer means one thing wherever it lands: linear light. A clear
+ * left as it was given is the one colour in the frame read as a display value, so a scene whose fog
+ * fades to its background colour fades to a different colour than the background it meets; with
+ * `hdrScene` the resolve grades the clear with everything else, and a frame without it has to agree.
+ *
+ * **A second copy of the curve, and what holds the two together** is the hand-derived values in
+ * `gradeColor.test.ts`, the same ones the shader's own constants give: the sRGB encode's two
+ * segments, the ACES fit through its two matrices, and the highlight shoulder. Code 4, the filmic
+ * curve, is the composite's alone, so a forward code never carries it (`forwardTransformCode`).
+ */
+import type { Vec3 } from '../math/color.ts';
+/**
+ * `color` graded by forward code `code` at `exposure` into `out`, which may be `color`: 0 leaves it
+ * as it is, 1 encodes it as sRGB, 2 runs ACES first and 3 the highlight shoulder. Allocates nothing.
+ */
+export declare function gradeColorInto(code: number, exposure: number, color: Readonly<Vec3>, out: Vec3): Vec3;

package/dist/render/gradeColor.js

@@ -0,0 +1,64 @@
+/* Columns as the shader's `mat3` reads them, written here as rows of the product. */
+const IN_R = [0.59719, 0.35458, 0.04823];
+const IN_G = [0.076, 0.90834, 0.01566];
+const IN_B = [0.0284, 0.13383, 0.83777];
+const OUT_R = [1.60475, -0.53108, -0.07367];
+const OUT_G = [-0.10208, 1.10813, -0.00605];
+const OUT_B = [-0.00327, -0.07276, 1.07602];
+/**
+ * `color` graded by forward code `code` at `exposure` into `out`, which may be `color`: 0 leaves it
+ * as it is, 1 encodes it as sRGB, 2 runs ACES first and 3 the highlight shoulder. Allocates nothing.
+ */
+export function gradeColorInto(code, exposure, color, out) {
+    let r = color[0];
+    let g = color[1];
+    let b = color[2];
+    if (code === 0) {
+        out[0] = r;
+        out[1] = g;
+        out[2] = b;
+        return out;
+    }
+    if (code === 2) {
+        const x = r * exposure;
+        const y = g * exposure;
+        const z = b * exposure;
+        const ir = fit(dot(IN_R, x, y, z));
+        const ig = fit(dot(IN_G, x, y, z));
+        const ib = fit(dot(IN_B, x, y, z));
+        r = clamp01(dot(OUT_R, ir, ig, ib));
+        g = clamp01(dot(OUT_G, ir, ig, ib));
+        b = clamp01(dot(OUT_B, ir, ig, ib));
+    }
+    else if (code === 3) {
+        r *= exposure;
+        g *= exposure;
+        b *= exposure;
+        const m = Math.max(r, g, b);
+        if (m > 0.8) {
+            const e = m - 0.8;
+            const k = (0.8 + (0.2 * e) / (e + 0.2)) / m;
+            r *= k;
+            g *= k;
+            b *= k;
+        }
+    }
+    out[0] = encode(r);
+    out[1] = encode(g);
+    out[2] = encode(b);
+    return out;
+}
+function dot(row, x, y, z) {
+    return row[0] * x + row[1] * y + row[2] * z;
+}
+/** The RRT and ODT fit, `rrtAndOdtFit` in the shader. */
+function fit(v) {
+    return (v * (v + 0.0245786) - 0.000090537) / (v * (0.983729 * v + 0.432951) + 0.238081);
+}
+/** Linear to sRGB, the piecewise form the shader uses. */
+function encode(c) {
+    return c <= 0.0031308 ? c * 12.92 : 1.055 * Math.max(c, 0) ** (1 / 2.4) - 0.055;
+}
+function clamp01(v) {
+    return v < 0 ? 0 : v > 1 ? 1 : v;
+}

package/dist/render/lightMatrix.d.ts

@@ -1,6 +1,19 @@
 import { mat4 } from 'gl-matrix';
 import type { Vec3 } from '../math/color.ts';
 export declare function computeLightMatrix(lightDir: Vec3, focusX: number, focusY: number, focusZ: number, radius: number, shadowMapSize: number, out: mat4): number;
+/**
+ * A directional light's matrix covering a box of known size whole: a model, a level, a room. The
+ * sphere around the box, at its centre, through `computeLightMatrix`, widened by the half texel the
+ * centre's snap may move it so a corner on the sphere stays inside. Returns the depth span, as that
+ * does.
+ *
+ * **For a scene whose extent is known rather than one that follows a viewer.** A radius chosen by
+ * eye around a guessed centre leaves part of the model outside the map, where it casts nothing; the
+ * bounds are the answer, and a loader has them. **What it gives up** is resolution where the box is
+ * large: the map's texels are spread over all of it, so a building's shadows are coarser than a
+ * focus on the viewer would draw them, which is what `computeLightMatrix` around the viewer is for.
+ */
+export declare function computeLightMatrixForBounds(lightDir: Vec3, min: Readonly<Vec3>, max: Readonly<Vec3>, shadowMapSize: number, out: mat4): number;
 /**
  * The depth an orthographic light matrix spans, in metres: what `computeLightMatrix` returns, read
  * back off any such matrix. Its depth row is the light's axis scaled by two over the span, so the

package/dist/render/lightMatrix.js

@@ -43,6 +43,23 @@ export function computeLightMatrix(lightDir, focusX, focusY, focusZ, radius, sha
     // to express its residual depth tolerance in stable world-space metres.
     return radius * 6;
 }
+/**
+ * A directional light's matrix covering a box of known size whole: a model, a level, a room. The
+ * sphere around the box, at its centre, through `computeLightMatrix`, widened by the half texel the
+ * centre's snap may move it so a corner on the sphere stays inside. Returns the depth span, as that
+ * does.
+ *
+ * **For a scene whose extent is known rather than one that follows a viewer.** A radius chosen by
+ * eye around a guessed centre leaves part of the model outside the map, where it casts nothing; the
+ * bounds are the answer, and a loader has them. **What it gives up** is resolution where the box is
+ * large: the map's texels are spread over all of it, so a building's shadows are coarser than a
+ * focus on the viewer would draw them, which is what `computeLightMatrix` around the viewer is for.
+ */
+export function computeLightMatrixForBounds(lightDir, min, max, shadowMapSize, out) {
+    const half = Math.hypot(max[0] - min[0], max[1] - min[1], max[2] - min[2]) / 2;
+    const radius = Math.max(half, 1e-3) * (1 + 2 / Math.max(shadowMapSize, 1));
+    return computeLightMatrix(lightDir, (min[0] + max[0]) / 2, (min[1] + max[1]) / 2, (min[2] + max[2]) / 2, radius, shadowMapSize, out);
+}
 /**
  * The depth an orthographic light matrix spans, in metres: what `computeLightMatrix` returns, read
  * back off any such matrix. Its depth row is the light's axis scaled by two over the span, so the

package/dist/render/passGrade.d.ts

@@ -0,0 +1,13 @@
+/**
+ * The `uOutputTransform` a pass uploads: `storing` inside a probe's face or a capture, `presented`
+ * once the frame's resolve has run, `resolveGrades` where that resolve applies the transform.
+ */
+export declare function passGradeCode(storing: boolean, presented: boolean, resolveGrades: boolean, outputTransform: string): number;
+/** The `uOutputExposure` beside it: the frame's exposure wherever the pass grades, else one. */
+export declare function passGradeExposure(storing: boolean, presented: boolean, resolveGrades: boolean, exposure: number): number;
+/**
+ * The code an interface draws with, given the pass's: the screen encode wherever the pass grades at
+ * all, and nothing where it does not. Never a curve, so never an exposure either: a screen-space
+ * caption, a panel or a 2D layer keeps the colour it was picked as whatever the scene is graded by.
+ */
+export declare function interfaceGrade(passCode: number): number;

package/dist/render/passGrade.js

@@ -0,0 +1,47 @@
+/**
+ * Which grade a pass applies to what it draws, decided once for both backends.
+ *
+ * **Every pass grades where nothing after it will**, so a colour handed to the renderer means linear
+ * light wherever it lands. Three facts decide where that is:
+ *
+ * - **A probe's face or a capture stores radiance** for something else to light with or to show, so
+ *   it is never graded. The frame grades what it reads of one; graded at the bake as well, the curve
+ *   would be applied twice.
+ * - **A frame whose resolve grades** (`hdrScene` over a scene target) leaves every pass before the
+ *   resolve linear, because grading early throws away the range the float target exists to keep.
+ * - **Past the present, a pass lands on the canvas the resolve has already written**, so nothing
+ *   after it will grade it and it grades itself with the frame's forward code, composite or not. An
+ *   interface drawn after `endFrame` escapes the screen-space chain; it does not escape the grade.
+ *
+ * **An interface takes the screen encode and not the curve** (`interfaceGrade`). A tone curve and
+ * an exposure are how a scene's light is brought to the screen, and a caption or a panel is not
+ * light: its colour was picked for the screen, so it is encoded wherever the frame is and comes out
+ * as picked under every transform, at every exposure. What it gives up is an interface drawn inside
+ * a frame whose resolve grades (`hdrScene`): that one is part of the picture the resolve tone maps,
+ * and is drawn after `endFrame` to stay out of it. What would make any of this wrong is a composite
+ * step running after the present, which none does.
+ */
+import { forwardTransformCode } from './vertexDefaults.js';
+/**
+ * The `uOutputTransform` a pass uploads: `storing` inside a probe's face or a capture, `presented`
+ * once the frame's resolve has run, `resolveGrades` where that resolve applies the transform.
+ */
+export function passGradeCode(storing, presented, resolveGrades, outputTransform) {
+    if (storing)
+        return 0;
+    return presented || !resolveGrades ? forwardTransformCode(outputTransform) : 0;
+}
+/** The `uOutputExposure` beside it: the frame's exposure wherever the pass grades, else one. */
+export function passGradeExposure(storing, presented, resolveGrades, exposure) {
+    if (storing)
+        return 1;
+    return presented || !resolveGrades ? exposure : 1;
+}
+/**
+ * The code an interface draws with, given the pass's: the screen encode wherever the pass grades at
+ * all, and nothing where it does not. Never a curve, so never an exposure either: a screen-space
+ * caption, a panel or a 2D layer keeps the colour it was picked as whatever the scene is graded by.
+ */
+export function interfaceGrade(passCode) {
+    return passCode === 0 ? 0 : 1;
+}

package/dist/render/plumeRenderer.d.ts

@@ -89,7 +89,7 @@ export declare class PlumeRenderer {
      * the sky at depth 1.0 under LEQUAL would otherwise overwrite anything drawn
      * against open background.
      */
-    draw(gl: WebGL2RenderingContext, camera: FrameView, timeSeconds: number, atmosphere: Atmosphere, underwaterEnabled: boolean, atmosphereCameraY: number, clipPlane: Float32Array | null, windX?: number, windZ?: number, originX?: number, originY?: number, originZ?: number): void;
+    draw(gl: WebGL2RenderingContext, camera: FrameView, timeSeconds: number, atmosphere: Atmosphere, underwaterEnabled: boolean, atmosphereCameraY: number, clipPlane: Float32Array | null, windX?: number, windZ?: number, originX?: number, originY?: number, originZ?: number, outputTransform?: number, outputExposure?: number): void;
     dispose(gl: WebGL2RenderingContext): void;
     /** Uploads one attribute and returns its buffer, for the rare one a caller can change. */
     private attach;

package/dist/render/plumeRenderer.js

@@ -93,7 +93,7 @@ export class PlumeRenderer {
      * the sky at depth 1.0 under LEQUAL would otherwise overwrite anything drawn
      * against open background.
      */
-    draw(gl, camera, timeSeconds, atmosphere, underwaterEnabled, atmosphereCameraY, clipPlane, windX = 0, windZ = 0, originX = 0, originY = 0, originZ = 0) {
+    draw(gl, camera, timeSeconds, atmosphere, underwaterEnabled, atmosphereCameraY, clipPlane, windX = 0, windZ = 0, originX = 0, originY = 0, originZ = 0, outputTransform = 0, outputExposure = 1) {
         if (this.indexCount === 0)
             return;
         const u = this.uniforms;
@@ -121,6 +121,9 @@ export class PlumeRenderer {
         gl.uniform1i(u['uClipEnabled'] ?? null, clipPlane === null ? 0 : 1);
         if (clipPlane !== null)
             gl.uniform4fv(u['uClipPlane'] ?? null, clipPlane);
+        /* The renderer's `passGrade`: the frame's, but none in a probe's face or a capture. */
+        gl.uniform1i(u['uOutputTransform'] ?? null, outputTransform);
+        gl.uniform1f(u['uOutputExposure'] ?? null, outputExposure);
         bindAtmosphere(gl, u, atmosphere, atmosphereCameraY, underwaterEnabled);
         gl.enable(gl.BLEND);
         if (this.blend === 'additive')

package/dist/render/renderQuality.d.ts

@@ -50,22 +50,35 @@ export type GlassShadows = 'full' | 'half' | 'off';
 export type SkinScattering = 'pre-integrated' | 'screen-space';
 export interface RenderQuality {
     /**
-     * The transfer curve applied at the end of every shaded pass.
-     *
-     * Construction-time, like every other quality control here, and `none` by default so
-     * no existing world changes by a single bit.
-     *
-     * **The symptom, written down because nobody searches for a transfer curve they do not know
-     * exists.** With `none`, values above 1 clip flat rather than rolling off, so a scene with
-     * bright sources against dark surroundings reads as crushed and desaturated: the highlights
-     * go to a hard white with no colour left in them and the midtones look muddy. That is
-     * reported by eye as "dark", "flat" or "not vivid", which sounds like a lighting problem, so
-     * that is where people look. A consumer built, tuned and shipped six worlds before anybody
-     * said the word. If a scene looks like that, try `outputTransform: 'aces'` with an
-     * `outputExposure` before touching a single light.
-     *
-     * The default stays `none`, and that is not the fault: a curve that changed every existing
-     * consumer's output would be far worse than one nobody found.
+     * The transfer curve applied at the end of every shaded pass. Construction-time, like every
+     * other quality control here.
+     *
+     * **`srgb` by default since 4.13.0, the encoding a display expects**: the light the renderer
+     * computes is linear, and a texture's colours are decoded to linear when they are read, so a
+     * frame written without encoding them back is a frame of linear values read as display values —
+     * every midtone far too dark. It is the encoding most renderers apply by default, so a model
+     * drawn here with no options reads as it does elsewhere. **What it gives up** is a highlight's
+     * colour: above 1 each channel clips on its own, so a bright saturated source goes to white
+     * rather than rolling off, which a curve with a shoulder (`aces`, `shoulder`) is for.
+     *
+     * **`none` was the default until 4.13.0, and it is the frame that reads as dark**: values
+     * written as they are computed, which is right only for a world whose colours were chosen by
+     * eye as display values and lit to match. It was reported by eye as "dark", "flat" or "not
+     * vivid", which sounds like a lighting problem, so that is where people looked; a consumer
+     * built, tuned and shipped six worlds under it before anybody said the word, and a model drawn
+     * from the manual came out darker than in any other engine. A world graded under it says
+     * `outputTransform: 'none'` and draws exactly as it did. **What would make `srgb` the wrong
+     * default** is a renderer whose colours are not linear, which this one's are not.
+     *
+     * **Every pass applies it where nothing after it will**, and the clear colour with them, so a
+     * colour handed to the renderer is linear wherever it lands: a frame with `hdrScene` is graded
+     * once at the resolve, and one without it is graded pass by pass to the same curve. A colour
+     * picked by eye is a display value, so it is stated through `srgbColor` (or a mesh built with
+     * `colorSpace: 'srgb'`), which gives back exactly the colour picked where a surface is lit at 1
+     * under `srgb`, and through the curve under a tone curve. **An interface** (screen text, a panel,
+     * the 2D layer) takes the screen encode and never the curve or the exposure, so its colours come
+     * out as picked under every transform; inside an `hdrScene` frame it is part of the picture the
+     * resolve grades, and is drawn after `endFrame` to stay out of the curve.
      */
     readonly outputTransform: OutputTransform;
     /**
@@ -259,9 +272,35 @@ export interface RenderQuality {
      * at a shadow's edge — that is what the blur is for.
      */
     readonly skinScattering: SkinScattering;
-    /** Horizontal world-space reach over which a directional shadow dissolves. */
+    /**
+     * How far a sun shadow may reach along the ground from its caster, in metres, before it
+     * dissolves. **Not a distance from the camera**: a shadow's own length, from where it leaves its
+     * caster to where it lands, fading from 35% of this to all of it.
+     *
+     * **1,000 since 4.13.0, so no building's shadow dissolves**: the fade starts at 350 m, past any
+     * wall, tower or canyon a shadow map covers at a useful resolution, so what bounds a shadow is
+     * its map, whose edge already fades. **What it gives up** is a way to hide a long shadow's
+     * stair-stepping at a low sun, which is what a short reach was for. It was 6 until 4.13.0: a
+     * tuning for short casters, which left a building's walls and arcades casting nothing on its
+     * floor under a high sun — the shadows vanished silently and read as random lighting. **What
+     * would make it wrong** is a scene whose shadows are too coarse to show at their full length;
+     * there a reach of the length that looks right is the setting, and the map around the viewer
+     * (`computeLightMatrix`) the better fix.
+     */
     readonly directionalShadowMaxDistance: number;
-    /** Maximum horizontal projection per vertical metre before low-angle shadows vanish. */
+    /**
+     * How low the sun may stand before its shadows fade, as the ground a metre of height may shadow:
+     * the sun's horizontal reach per vertical metre, so 1 is 45° of elevation and 60 about 1°. Every
+     * sun shadow fades from 65% of this to all of it.
+     *
+     * **60 since 4.13.0: shadows hold until the sun is about a degree above the horizon**, the
+     * stretch of a day when they are longest and most worth seeing. **What it gives up**: a sun on
+     * the horizon throws shadows kilometres long that a map can hold only as stripes, and the
+     * last degree is where they fade rather than show. It was 3 until 4.13.0, which dropped every
+     * sun shadow below about 18° — an evening without shadows. **What would make it wrong** is a
+     * scene whose low sun streaks; a smaller number here is the setting, at the cost of the
+     * shadows going earlier in the evening.
+     */
     readonly directionalShadowMaxSlope: number;
     /**
      * Metres a point light may drift from where its shadow was baked before re-baking.

package/dist/render/renderQuality.js

@@ -17,7 +17,7 @@ export const DIRECTIONAL_SHADOW_FADE_START = 0.65;
  * six times, while the directional map spends all of it on one focused area.
  */
 export const DEFAULT_RENDER_QUALITY = Object.freeze({
-    outputTransform: 'none',
+    outputTransform: 'srgb',
     outputExposure: 1,
     pointLightFalloff: 'smooth',
     /**
@@ -65,8 +65,8 @@ export const DEFAULT_RENDER_QUALITY = Object.freeze({
     glassShadows: 'full',
     pipelineCompile: 'wait',
     skinScattering: 'pre-integrated',
-    directionalShadowMaxDistance: 6,
-    directionalShadowMaxSlope: 3,
+    directionalShadowMaxDistance: 1000,
+    directionalShadowMaxSlope: 60,
     pointShadowRebakeDistance: 0.001,
     pointShadowFacesPerFrame: 2,
     /*

package/dist/render/sceneTarget.d.ts

@@ -303,6 +303,8 @@ export declare class SceneTarget {
         readonly transform: number;
         readonly exposure: number;
         readonly film?: Float32Array;
+        /** Whether the forward passes graded the scene because this resolve does not. */
+        readonly sceneGraded?: boolean;
     }, motion?: {
         readonly reprojection: Float32Array;
         readonly strength: number;

package/dist/render/sceneTarget.js

@@ -819,6 +819,7 @@ export class SceneTarget {
         gl.uniform1f(this.uniforms['uReach'] ?? null, reachUv);
         gl.uniform1i(this.uniforms['uOutputTransform'] ?? null, grade.transform);
         gl.uniform1f(this.uniforms['uOutputExposure'] ?? null, grade.exposure);
+        gl.uniform1i(this.uniforms['uSceneGraded'] ?? null, grade.sceneGraded === true ? 1 : 0);
         if (grade.film !== undefined) {
             gl.uniform4fv(this.uniforms['uFilmA'] ?? null, grade.film, 0, 4);
             gl.uniform4fv(this.uniforms['uFilmB'] ?? null, grade.film, 4, 4);

package/dist/render/sdfTextRenderer.d.ts

@@ -65,7 +65,7 @@ export declare class SdfTextRenderer {
      */
     /**
      * `outputTransform` and `outputExposure` come from the renderer rather than from here, because
-     * whether this pass grades depends on whether anything after it will. See `Renderer.gradeCode`.
+     * whether this pass grades depends on whether anything after it will. See `passGrade.ts`.
      */
     draw(viewProj: ReadonlyMat4, model: Float32Array, color: Vec3, opacity: number, outputTransform: number, outputExposure: number): boolean;
     dispose(): void;

package/dist/render/sdfTextRenderer.js

@@ -103,7 +103,7 @@ export class SdfTextRenderer {
      */
     /**
      * `outputTransform` and `outputExposure` come from the renderer rather than from here, because
-     * whether this pass grades depends on whether anything after it will. See `Renderer.gradeCode`.
+     * whether this pass grades depends on whether anything after it will. See `passGrade.ts`.
      */
     draw(viewProj, model, color, opacity, outputTransform, outputExposure) {
         if (this.layout.quadCount === 0 || opacity <= 0 || this.font === null || this.atlas === null) {

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

@@ -16,4 +16,4 @@
  * gets motion without direction. That is what separates a spell from a lamp on a
  * dimmer.
  */
-export declare const ARCANE_FRAG = "#version 300 es\nprecision highp float;\n\nin vec2 vUv;\nin float vSeed;\nin float vDistance;\nin vec3 vWorldPos;\n\nuniform float uTime;\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\nuniform int uNoiseOctaves;\nuniform vec4 uClipPlane;\nuniform int uClipEnabled;\n/** The caller's colour, so an aura shifts with the world's own palette. */\nuniform vec3 uTint;\n\nout vec4 outColor;\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\nvoid main() {\n  if (uClipEnabled != 0 && dot(vec4(vWorldPos, 1.0), uClipPlane) < 0.0) discard;\n\n  // Polar about the quad centre. This is the line that makes it an orb rather\n  // than a column; everything downstream reads radius and angle, never height.\n  float radius = length(vUv - 0.5) * 2.0;\n  if (radius >= 1.0) discard;\n\n  vec2 d = vUv - 0.5;\n  float angle = atan(d.y, d.x);\n  float t = uTime + vSeed * 37.0;\n\n  /*\n   * Two bands, turning opposite ways at different rates. Sampled in (angle, radius)\n   * space so the noise wraps around the disc instead of sliding across it \u2014 noise in\n   * UV space would drift off one edge and read as a texture being scrolled.\n   */\n  float inner = valueNoise(vec2(angle * 1.9 + t * 0.55, radius * 4.2));\n  float outer = valueNoise(vec2(angle * 3.1 - t * 0.34, radius * 2.6));\n  float swirl = inner * 0.62 + outer * 0.38;\n  if (uNoiseOctaves > 1) {\n    swirl = mix(swirl, swirl * valueNoise(vec2(angle * 6.3 + t * 0.9, radius * 8.0)) * 2.0, 0.35);\n  }\n\n  /*\n   * Core and corona as two separate falloffs rather than one curve. A single falloff\n   * gives a blob; what makes this read as *contained energy* is a small bright centre\n   * with a much wider, much fainter halo, so the object inside stays legible.\n   */\n  float core = 1.0 - smoothstep(0.0, 0.28, radius);\n  float corona = (1.0 - smoothstep(0.18, 1.0, radius)) * (0.35 + swirl * 0.65);\n  float body = core * 0.9 + corona;\n  if (body <= 0.02) discard;\n\n  // Hot centre through the tint to a dark rim, so the core reads as white-hot\n  // energy and the edge as the colour it is made of.\n  vec3 col = mix(uTint * 0.35, uTint, smoothstep(0.0, 0.55, body));\n  col = mix(col, vec3(1.0), smoothstep(0.82, 1.4, body));\n  col *= uTint;\n\n  float alpha = clamp(body * 1.6, 0.0, 1.0);\n  // Additive light must lose alpha as it scatters, or mixing its colour alone\n  // still makes a distant aura glow through fog and through water.\n  float fog = mediumFog(vDistance, vWorldPos.y);\n  col = mix(col, mediumColor(), fog);\n  alpha *= 1.0 - fog;\n\n  outColor = vec4(col, alpha);\n}\n";
+export declare const ARCANE_FRAG = "#version 300 es\nprecision highp float;\n\nin vec2 vUv;\nin float vSeed;\nin float vDistance;\nin vec3 vWorldPos;\n\nuniform float uTime;\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\nuniform int uNoiseOctaves;\nuniform vec4 uClipPlane;\nuniform int uClipEnabled;\n/* Before `uTint`, where fire and smoke declare it, so one field table serves all three. */\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/** The caller's colour, so an aura shifts with the world's own palette. */\nuniform vec3 uTint;\n\nout vec4 outColor;\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\nvoid main() {\n  if (uClipEnabled != 0 && dot(vec4(vWorldPos, 1.0), uClipPlane) < 0.0) discard;\n\n  // Polar about the quad centre. This is the line that makes it an orb rather\n  // than a column; everything downstream reads radius and angle, never height.\n  float radius = length(vUv - 0.5) * 2.0;\n  if (radius >= 1.0) discard;\n\n  vec2 d = vUv - 0.5;\n  float angle = atan(d.y, d.x);\n  float t = uTime + vSeed * 37.0;\n\n  /*\n   * Two bands, turning opposite ways at different rates. Sampled in (angle, radius)\n   * space so the noise wraps around the disc instead of sliding across it \u2014 noise in\n   * UV space would drift off one edge and read as a texture being scrolled.\n   */\n  float inner = valueNoise(vec2(angle * 1.9 + t * 0.55, radius * 4.2));\n  float outer = valueNoise(vec2(angle * 3.1 - t * 0.34, radius * 2.6));\n  float swirl = inner * 0.62 + outer * 0.38;\n  if (uNoiseOctaves > 1) {\n    swirl = mix(swirl, swirl * valueNoise(vec2(angle * 6.3 + t * 0.9, radius * 8.0)) * 2.0, 0.35);\n  }\n\n  /*\n   * Core and corona as two separate falloffs rather than one curve. A single falloff\n   * gives a blob; what makes this read as *contained energy* is a small bright centre\n   * with a much wider, much fainter halo, so the object inside stays legible.\n   */\n  float core = 1.0 - smoothstep(0.0, 0.28, radius);\n  float corona = (1.0 - smoothstep(0.18, 1.0, radius)) * (0.35 + swirl * 0.65);\n  float body = core * 0.9 + corona;\n  if (body <= 0.02) discard;\n\n  // Hot centre through the tint to a dark rim, so the core reads as white-hot\n  // energy and the edge as the colour it is made of.\n  vec3 col = mix(uTint * 0.35, uTint, smoothstep(0.0, 0.55, body));\n  col = mix(col, vec3(1.0), smoothstep(0.82, 1.4, body));\n  col *= uTint;\n\n  float alpha = clamp(body * 1.6, 0.0, 1.0);\n  // Additive light must lose alpha as it scatters, or mixing its colour alone\n  // still makes a distant aura glow through fog and through water.\n  float fog = mediumFog(vDistance, vWorldPos.y);\n  col = mix(col, mediumColor(), fog);\n  alpha *= 1.0 - fog;\n\n  /* Graded where nothing after this will grade it, as every pass is. The alpha is coverage. */\n  outColor = vec4(applyOutputTransform(col), alpha);\n}\n";

package/dist/render/shaders/arcane.js

@@ -1,4 +1,5 @@
 import { FOG_GLSL } from './fog.js';
+import { OUTPUT_TRANSFORM_GLSL } from './outputTransform.js';
 /**
  * An arcane aura: the volume a floating object sits inside.
  *
@@ -30,6 +31,8 @@ ${FOG_GLSL}
 uniform int uNoiseOctaves;
 uniform vec4 uClipPlane;
 uniform int uClipEnabled;
+/* Before \`uTint\`, where fire and smoke declare it, so one field table serves all three. */
+${OUTPUT_TRANSFORM_GLSL}
 /** The caller's colour, so an aura shifts with the world's own palette. */
 uniform vec3 uTint;
 
@@ -97,6 +100,7 @@ void main() {
   col = mix(col, mediumColor(), fog);
   alpha *= 1.0 - fog;
 
-  outColor = vec4(col, alpha);
+  /* Graded where nothing after this will grade it, as every pass is. The alpha is coverage. */
+  outColor = vec4(applyOutputTransform(col), alpha);
 }
 `;

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

@@ -14,4 +14,4 @@
  * gives an arc its three-dimensionality is the path, and the path is world-space.
  */
 export declare const BOLT_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/** Where this segment sits along its arc, the arc's envelope, its seed, its gain. */\nlayout(location = 3) in vec4 aArc;\n\nuniform mat4 uViewProj;\nuniform vec3 uCameraPos;\n/** Core half-width in metres, and how much of a pixel a far arc must still cover. */\nuniform float uWidth;\nuniform float uMinWidthPerMetre;\n\nout float vSide;\nout float vAlong;\nout float vFade;\nout float vSeed;\nout float vGain;\nout vec3 vWorldPos;\n\nvoid main() {\n  vec3 mid = mix(aFrom, aTo, aCorner.x);\n  vec3 dir = aTo - aFrom;\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\n   * segment points at the viewer, where any perpendicular is as good as another \u2014\n   * and where the 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 filament\n   * never thins below a pixel. Under a pixel a bright thin line does not get\n   * fainter, it *flickers* \u2014 the rasteriser catches it on some frames and not\n   * others \u2014 and a strobing artefact reads as a bug, not as lightning.\n   */\n  float halfWidth = max(uWidth, dist * uMinWidthPerMetre);\n  vec3 world = mid + across * aCorner.y * halfWidth;\n\n  vSide = aCorner.y;\n  vAlong = aArc.x;\n  vFade = aArc.y;\n  vSeed = aArc.z;\n  vGain = aArc.w;\n  vWorldPos = world;\n  gl_Position = uViewProj * vec4(world, 1.0);\n}\n";
-export declare const BOLT_FRAG = "#version 300 es\nprecision highp float;\n\nin float vSide;\nin float vAlong;\nin float vFade;\nin float vSeed;\nin float vGain;\nin vec3 vWorldPos;\n\nuniform float uTime;\n/** The saturating centre, and the glow it sits inside. */\nuniform vec3 uCoreColor;\nuniform vec3 uEdgeColor;\n/** How far past white the core is allowed to 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\nuniform vec3 uCameraPos;\n\nout vec4 outColor;\n\nfloat hash11(float p) {\n  return fract(sin(p * 12.9898) * 43758.5453123);\n}\n\nvoid main() {\n  /*\n   * Across the filament: 1 at the centre line, 0 at the quad's edge. Two powers\n   * of it are the entire look \u2014 a very tight one for the core and a loose one for\n   * the glow. A single falloff gives either a hard line with no atmosphere or a\n   * soft smudge with no filament.\n   */\n  /*\n   * Clamped, because a multisampled target shades a pixel on the quad's edge at its centre, which\n   * may lie outside the quad: there 'vSide' runs past one, 'across' goes negative, and 'pow' of a\n   * negative number is NaN. One NaN pixel is a dark speck; bloom then spreads it into a white disc\n   * the size of the blur. Found by a fight drawing short arcs at 4 samples.\n   */\n  float across = clamp(1.0 - abs(vSide), 0.0, 1.0);\n  float core = pow(across, 10.0);\n  /*\n   * A *wide* halo, deliberately. This exponent is the single biggest control over\n   * whether the effect reads as lightning or as a drawn line: a tight falloff gives a\n   * crisp filament with nothing around it, which is a wire, while a broad one bleeds\n   * light into the air the way an over-exposed discharge does on film. It is the\n   * closest thing to bloom available without a second pass.\n   */\n  float glow = pow(across, 1.1);\n\n  /*\n   * Stutter. An arc is not a steady light: it is re-established many times a\n   * second, and the eye reads a *constant* bright line as neon. Two frequencies\n   * so the pattern does not read as a sine, and per-arc phase from the seed so\n   * several arcs never blink together.\n   */\n  /*\n   * Stutter, but shallow. An arc is re-established many times a second and a perfectly\n   * steady bright line reads as neon \u2014 but too *much* flicker reads as a broken effect\n   * rather than as a discharge, and at the brief lifetime these now have, deep flicker\n   * mostly hides the bolt. The path itself is already being redrawn (see 'BoltPool'),\n   * which carries most of the crackle; this only keeps the brightness alive.\n   */\n  float t = uTime * 47.0 + vSeed * 17.0;\n  float stutter = 0.78 + 0.22 * (hash11(floor(t)) * 0.6 + hash11(floor(t * 2.37)) * 0.4);\n\n  /*\n   * The tip tapers. An arc that ends in a squared-off quad reads as a drawn\n   * segment; thinning toward the far end is what makes it read as a discharge\n   * dissipating into the air.\n   */\n  float taper = 1.0 - vAlong * 0.55;\n\n  float energy = vFade * stutter * taper * vGain;\n  vec3 lit = uEdgeColor * glow + uCoreColor * core * uCoreGain;\n\n  /*\n   * Distance dims it rather than tinting it toward the fog. A discharge emits;\n   * mixing it into the medium's colour is what a *surface* does, and doing that\n   * here turned a far bolt grey instead of faint.\n   */\n  float fog = mediumFog(distance(vWorldPos, uCameraPos), vWorldPos.y);\n  /*\n   * Alpha is 1, and the energy is already in the colour.\n   *\n   * The additive blend is 'SRC_ALPHA, ONE', so what reaches the framebuffer is\n   * 'rgb * a'. Putting the energy in both \u2014 which the first version did \u2014 squares it,\n   * and squaring a number below one is how an effect authored as blinding arrives as\n   * faint: at a typical energy of 0.5 it delivered a quarter of what it asked for.\n   * Every emissive material here has to pick one channel and mean it.\n   */\n  outColor = vec4(lit * energy * (1.0 - fog), 1.0);\n}\n";
+export declare const BOLT_FRAG = "#version 300 es\nprecision highp float;\n\nin float vSide;\nin float vAlong;\nin float vFade;\nin float vSeed;\nin float vGain;\nin vec3 vWorldPos;\n\nuniform float uTime;\n/** The saturating centre, and the glow it sits inside. */\nuniform vec3 uCoreColor;\nuniform vec3 uEdgeColor;\n/** How far past white the core is allowed to 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\nuniform vec3 uCameraPos;\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\nfloat hash11(float p) {\n  return fract(sin(p * 12.9898) * 43758.5453123);\n}\n\nvoid main() {\n  /*\n   * Across the filament: 1 at the centre line, 0 at the quad's edge. Two powers\n   * of it are the entire look \u2014 a very tight one for the core and a loose one for\n   * the glow. A single falloff gives either a hard line with no atmosphere or a\n   * soft smudge with no filament.\n   */\n  /*\n   * Clamped, because a multisampled target shades a pixel on the quad's edge at its centre, which\n   * may lie outside the quad: there 'vSide' runs past one, 'across' goes negative, and 'pow' of a\n   * negative number is NaN. One NaN pixel is a dark speck; bloom then spreads it into a white disc\n   * the size of the blur. Found by a fight drawing short arcs at 4 samples.\n   */\n  float across = clamp(1.0 - abs(vSide), 0.0, 1.0);\n  float core = pow(across, 10.0);\n  /*\n   * A *wide* halo, deliberately. This exponent is the single biggest control over\n   * whether the effect reads as lightning or as a drawn line: a tight falloff gives a\n   * crisp filament with nothing around it, which is a wire, while a broad one bleeds\n   * light into the air the way an over-exposed discharge does on film. It is the\n   * closest thing to bloom available without a second pass.\n   */\n  float glow = pow(across, 1.1);\n\n  /*\n   * Stutter. An arc is not a steady light: it is re-established many times a\n   * second, and the eye reads a *constant* bright line as neon. Two frequencies\n   * so the pattern does not read as a sine, and per-arc phase from the seed so\n   * several arcs never blink together.\n   */\n  /*\n   * Stutter, but shallow. An arc is re-established many times a second and a perfectly\n   * steady bright line reads as neon \u2014 but too *much* flicker reads as a broken effect\n   * rather than as a discharge, and at the brief lifetime these now have, deep flicker\n   * mostly hides the bolt. The path itself is already being redrawn (see 'BoltPool'),\n   * which carries most of the crackle; this only keeps the brightness alive.\n   */\n  float t = uTime * 47.0 + vSeed * 17.0;\n  float stutter = 0.78 + 0.22 * (hash11(floor(t)) * 0.6 + hash11(floor(t * 2.37)) * 0.4);\n\n  /*\n   * The tip tapers. An arc that ends in a squared-off quad reads as a drawn\n   * segment; thinning toward the far end is what makes it read as a discharge\n   * dissipating into the air.\n   */\n  float taper = 1.0 - vAlong * 0.55;\n\n  float energy = vFade * stutter * taper * vGain;\n  vec3 lit = uEdgeColor * glow + uCoreColor * core * uCoreGain;\n\n  /*\n   * Distance dims it rather than tinting it toward the fog. A discharge emits;\n   * mixing it into the medium's colour is what a *surface* does, and doing that\n   * here turned a far bolt grey instead of faint.\n   */\n  float fog = mediumFog(distance(vWorldPos, uCameraPos), vWorldPos.y);\n  /*\n   * Alpha is 1, and the energy is already in the colour.\n   *\n   * The additive blend is 'SRC_ALPHA, ONE', so what reaches the framebuffer is\n   * 'rgb * a'. Putting the energy in both \u2014 which the first version did \u2014 squares it,\n   * and squaring a number below one is how an effect authored as blinding arrives as\n   * faint: at a typical energy of 0.5 it delivered a quarter of what it asked for.\n   * Every emissive material here has to pick one channel and mean it.\n   */\n  /* Graded where nothing after this will grade it, as every pass is, light added included. */\n  outColor = vec4(applyOutputTransform(lit * energy * (1.0 - fog)), 1.0);\n}\n";

package/dist/render/shaders/bolt.js

@@ -1,4 +1,5 @@
 import { FOG_GLSL } from './fog.js';
+import { OUTPUT_TRANSFORM_GLSL } from './outputTransform.js';
 /**
  * Electrical arcs: a filament with a saturating core and a wide soft glow.
  *
@@ -92,6 +93,7 @@ ${FOG_GLSL}
 uniform vec3 uCameraPos;
 
 out vec4 outColor;
+${OUTPUT_TRANSFORM_GLSL}
 
 float hash11(float p) {
   return fract(sin(p * 12.9898) * 43758.5453123);
@@ -162,6 +164,7 @@ void main() {
    * faint: at a typical energy of 0.5 it delivered a quarter of what it asked for.
    * Every emissive material here has to pick one channel and mean it.
    */
-  outColor = vec4(lit * energy * (1.0 - fog), 1.0);
+  /* Graded where nothing after this will grade it, as every pass is, light added included. */
+  outColor = vec4(applyOutputTransform(lit * energy * (1.0 - fog)), 1.0);
 }
 `;