rayzee 8.5.0 → 8.6.1

package/src/Processor/ToneMapCPU.js

@@ -1,197 +1,100 @@
 /**
- * CPU tone mapping functions matching Three.js ToneMappingFunctions.js (WebGPU).
- * Shared between OIDNDenoiser and AIUpscaler for consistent HDR → sRGB conversion.
+ * The readback half of the view transform: linear float pixels to display bytes, in the output
+ * pass's order. Shared by OIDN, the AI upscaler and `renderToBuffer`.
  *
- * All functions write tonemapped linear RGB [0,1] into the `out` array.
+ * The curves themselves live in `../Color/ViewTransforms.js`, declared beside their WGSL and TSL
+ * counterparts, because a saved image that differs from the viewport is the failure this file
+ * exists to prevent. What stays here is everything around the curve — exposure, the saturation
+ * grade, the transfer function and the byte rounding.
+ *
+ * ⚠️ Rounding is deliberately bug-compatible. This writes `srgb * 255 + 0.5` into a
+ * `Uint8ClampedArray`, which rounds again, so the result has always been half a level bright.
+ * `ToneMapGPU.js` reproduces it exactly. Dropping the extra half would shift every image.
  */
-import {
-	NoToneMapping, LinearToneMapping, ReinhardToneMapping,
-	CineonToneMapping, ACESFilmicToneMapping, AgXToneMapping, NeutralToneMapping
-} from 'three';
-
-const clamp01 = x => Math.min( Math.max( x, 0 ), 1 );
-
-function noToneMap( r, g, b, _exposure, out ) {
 
-	out[ 0 ] = clamp01( r );
-	out[ 1 ] = clamp01( g );
-	out[ 2 ] = clamp01( b );
-
-}
-
-function linearToneMap( r, g, b, exposure, out ) {
-
-	out[ 0 ] = clamp01( r * exposure );
-	out[ 1 ] = clamp01( g * exposure );
-	out[ 2 ] = clamp01( b * exposure );
-
-}
-
-function reinhardToneMap( r, g, b, exposure, out ) {
-
-	r *= exposure; g *= exposure; b *= exposure;
-	out[ 0 ] = clamp01( r / ( r + 1 ) );
-	out[ 1 ] = clamp01( g / ( g + 1 ) );
-	out[ 2 ] = clamp01( b / ( b + 1 ) );
-
-}
-
-function cineonToneMap( r, g, b, exposure, out ) {
-
-	r = Math.max( r * exposure - 0.004, 0 );
-	g = Math.max( g * exposure - 0.004, 0 );
-	b = Math.max( b * exposure - 0.004, 0 );
-	const f = c => Math.pow( ( c * ( 6.2 * c + 0.5 ) ) / ( c * ( 6.2 * c + 1.7 ) + 0.06 ), 2.2 );
-	out[ 0 ] = f( r );
-	out[ 1 ] = f( g );
-	out[ 2 ] = f( b );
-
-}
+import { NoToneMapping } from 'three';
+import { VIEW_TRANSFORMS, getViewTransform, onRegistryChange } from '../Color/ViewTransforms.js';
 
-function acesFilmicToneMap( r, g, b, exposure, out ) {
-
-	r = r * exposure / 0.6;
-	g = g * exposure / 0.6;
-	b = b * exposure / 0.6;
+/**
+ * Three.js clamps the fragment output with `.max( 0 )` *before* tone mapping (NodeMaterial.js,
+ * "force unsigned floats"), so the GPU curves never see a negative channel. The Compositor's
+ * saturation grade (default 1.2) drives complementary channels below zero on a third of a typical
+ * frame, and AgX/Neutral mix those negatives across channels instead of clipping them — measured
+ * 7-10 levels of shadow error against the viewport until the readback clamps the same way.
+ */
+const clampNegative = fn => ( r, g, b, exposure, out ) =>
+	fn( r > 0 ? r : 0, g > 0 ? g : 0, b > 0 ? b : 0, exposure, out );
 
-	let ir = 0.59719 * r + 0.35458 * g + 0.04823 * b;
-	let ig = 0.07600 * r + 0.90834 * g + 0.01566 * b;
-	let ib = 0.02840 * r + 0.13383 * g + 0.83777 * b;
+/**
+ * Three.js ToneMapping constant → CPU function.
+ *
+ * Rebuilt in place rather than replaced: callers hold this Map, and loading a config adds entries
+ * to it long after they captured it.
+ */
+export const TONE_MAP_FNS = new Map();
 
-	const fit = c => ( c * ( c + 0.0245786 ) - 0.000090537 ) / ( c * ( 0.983729 * c + 0.4329510 ) + 0.238081 );
-	ir = fit( ir ); ig = fit( ig ); ib = fit( ib );
+function rebuild() {
 
-	out[ 0 ] = clamp01( 1.60475 * ir - 0.53108 * ig - 0.07367 * ib );
-	out[ 1 ] = clamp01( - 0.10208 * ir + 1.10813 * ig - 0.00605 * ib );
-	out[ 2 ] = clamp01( - 0.00327 * ir - 0.07276 * ig + 1.07602 * ib );
+	TONE_MAP_FNS.clear();
+	for ( const t of VIEW_TRANSFORMS.values() ) TONE_MAP_FNS.set( t.id, clampNegative( t.cpu ) );
 
 }
 
-function agxToneMap( r, g, b, exposure, out ) {
-
-	r *= exposure; g *= exposure; b *= exposure;
-
-	let cr = 0.6274 * r + 0.3293 * g + 0.0433 * b;
-	let cg = 0.0691 * r + 0.9195 * g + 0.0113 * b;
-	let cb = 0.0164 * r + 0.0880 * g + 0.8956 * b;
-
-	let ar = 0.856627153315983 * cr + 0.0951212405381588 * cg + 0.0482516061458583 * cb;
-	let ag = 0.137318972929847 * cr + 0.761241990602591 * cg + 0.101439036467562 * cb;
-	let ab = 0.11189821299995 * cr + 0.0767994186031903 * cg + 0.811302368396859 * cb;
-
-	const AgxMinEv = - 12.47393, AgxMaxEv = 4.026069, range = AgxMaxEv - AgxMinEv;
-	ar = clamp01( ( Math.log2( Math.max( ar, 1e-10 ) ) - AgxMinEv ) / range );
-	ag = clamp01( ( Math.log2( Math.max( ag, 1e-10 ) ) - AgxMinEv ) / range );
-	ab = clamp01( ( Math.log2( Math.max( ab, 1e-10 ) ) - AgxMinEv ) / range );
-
-	const approx = x => {
-
-		const x2 = x * x, x4 = x2 * x2;
-		return 15.5 * x4 * x2 - 40.14 * x4 * x + 31.96 * x4 - 6.868 * x2 * x + 0.4298 * x2 + 0.1191 * x - 0.00232;
-
-	};
-
-	ar = approx( ar ); ag = approx( ag ); ab = approx( ab );
+rebuild();
+onRegistryChange( rebuild );
 
-	let or = 1.1271005818144368 * ar - 0.11060664309660323 * ag - 0.016493938717834573 * ab;
-	let og = - 0.1413297634984383 * ar + 1.157823702216272 * ag - 0.016493938717834257 * ab;
-	let ob = - 0.14132976349843826 * ar - 0.11060664309660294 * ag + 1.2519364065950405 * ab;
-
-	or = Math.pow( Math.max( 0, or ), 2.2 );
-	og = Math.pow( Math.max( 0, og ), 2.2 );
-	ob = Math.pow( Math.max( 0, ob ), 2.2 );
+/**
+ * Whether this transform already returned display-encoded colour.
+ *
+ * Three.js's seven curves return linear and the output pass encodes them. An OCIO view returns
+ * colour encoded for its own display — sRGB, Rec.1886 or PQ — and encoding that again is the
+ * single most visible way to get colour management wrong.
+ */
+export function isOutputEncoded( toneMapping ) {
 
-	out[ 0 ] = clamp01( 1.6605 * or - 0.5876 * og - 0.0728 * ob );
-	out[ 1 ] = clamp01( - 0.1246 * or + 1.1329 * og - 0.0083 * ob );
-	out[ 2 ] = clamp01( - 0.0182 * or - 0.1006 * og + 1.1187 * ob );
+	return getViewTransform( toneMapping )?.outputEncoded === true;
 
 }
 
-function neutralToneMap( r, g, b, exposure, out ) {
-
-	const StartCompression = 0.8 - 0.04;
-	const Desaturation = 0.15;
-
-	r *= exposure; g *= exposure; b *= exposure;
-
-	const x = Math.min( r, Math.min( g, b ) );
-	const offset = x < 0.08 ? x - 6.25 * x * x : 0.04;
-
-	r -= offset; g -= offset; b -= offset;
-
-	const peak = Math.max( r, Math.max( g, b ) );
-
-	if ( peak < StartCompression ) {
-
-		out[ 0 ] = r; out[ 1 ] = g; out[ 2 ] = b;
-		return;
-
-	}
-
-	const d = 1 - StartCompression;
-	const newPeak = 1 - d * d / ( peak + d - StartCompression );
-	const scale = newPeak / peak;
-	r *= scale; g *= scale; b *= scale;
-	const gFactor = 1 - 1 / ( Desaturation * ( peak - newPeak ) + 1 );
-
-	out[ 0 ] = r + ( newPeak - r ) * gFactor;
-	out[ 1 ] = g + ( newPeak - g ) * gFactor;
-	out[ 2 ] = b + ( newPeak - b ) * gFactor;
-
-}
+/** sRGB gamma (1/2.2) — fast pow approximation. Prefer `linearToSRGB` when matching three.js. */
+export const SRGB_GAMMA = 1 / 2.2;
 
 /**
- * Three.js clamps the fragment output with `.max( 0 )` *before* tone mapping
- * (NodeMaterial.js, "force unsigned floats"), so the GPU curves never see a negative
- * channel. Compositor's saturation grade (default 1.2) drives complementary channels
- * below zero on a third of a typical frame, and AgX/Neutral mix those negatives across
- * channels instead of clipping them — measured 7-10 levels of shadow error against the
- * viewport until the readback clamps the same way.
+ * Proper sRGB OETF, matching three.js `sRGBTransferOETF` (`1.055 * c^(1/2.4) - 0.055` with a
+ * `12.92 * c` linear segment below 0.0031308).
  */
-const clampNegative = fn => ( r, g, b, exposure, out ) =>
-	fn( r > 0 ? r : 0, g > 0 ? g : 0, b > 0 ? b : 0, exposure, out );
+export function linearToSRGB( c ) {
 
-/** Look-up table mapping Three.js ToneMapping constants to CPU functions. */
-export const TONE_MAP_FNS = new Map( [
-	[ NoToneMapping, clampNegative( noToneMap ) ],
-	[ LinearToneMapping, clampNegative( linearToneMap ) ],
-	[ ReinhardToneMapping, clampNegative( reinhardToneMap ) ],
-	[ CineonToneMapping, clampNegative( cineonToneMap ) ],
-	[ ACESFilmicToneMapping, clampNegative( acesFilmicToneMap ) ],
-	[ AgXToneMapping, clampNegative( agxToneMap ) ],
-	[ NeutralToneMapping, clampNegative( neutralToneMap ) ]
-] );
-
-/** sRGB gamma (1/2.2) — fast pow approximation. Prefer `linearToSRGB` when matching Three.js's output. */
-export const SRGB_GAMMA = 1 / 2.2;
+	return c <= 0.0031308 ? 12.92 * c : 1.055 * Math.pow( c, 1 / 2.4 ) - 0.055;
+
+}
 
 /**
- * Proper sRGB OETF, matching Three.js `sRGBTransferOETF` (`1.055 * c^(1/2.4) - 0.055`
- * with a `12.92 * c` linear segment below 0.0031308). Use this when the CPU readback
- * needs to match the WebGPU output pass's sRGB encoding.
+ * The transfer step, skipped for a transform that encoded its own output.
+ * @param {number} c - a single channel, post-curve
  */
-export function linearToSRGB( c ) {
+export function encodeForDisplay( c, toneMapping ) {
 
-	return c <= 0.0031308 ? 12.92 * c : 1.055 * Math.pow( c, 1 / 2.4 ) - 0.055;
+	return isOutputEncoded( toneMapping ) ? Math.min( Math.max( c, 0 ), 1 ) : linearToSRGB( c );
 
 }
 
 /**
  * Exposure as the WebGPU output pass applies it.
  *
- * Three.js applies `toneMappingExposure` *inside* ToneMappingNode's tone-mapping branch, and
- * that branch returns the colour untouched for NoToneMapping (ToneMappingNode.js: `if
- * ( toneMapping === NoToneMapping ) return colorNode`). So exposure is a no-op on screen there,
- * and a CPU readback that applies it anyway paints brighter than the viewport it replaces
- * (measured +33.6 % at exposure 2).
+ * Three.js applies `toneMappingExposure` *inside* ToneMappingNode's branch, and that branch
+ * returns the colour untouched for NoToneMapping (`if ( toneMapping === NoToneMapping ) return
+ * colorNode`). So exposure is a no-op on screen there, and a CPU readback that applied it anyway
+ * paints brighter than the viewport it replaces — measured +33.6 % at exposure 2.
  *
  * @param {number} exposure - renderer.toneMappingExposure
- * @param {number} toneMapping - Three.js ToneMapping constant
- * @returns {number}
+ * @param {number} toneMapping - a registered view transform id
  */
 export function effectiveExposure( exposure, toneMapping ) {
 
-	return toneMapping === NoToneMapping ? 1.0 : exposure;
+	const t = getViewTransform( toneMapping );
+	if ( ! t ) return toneMapping === NoToneMapping ? 1.0 : exposure;
+	return t.appliesExposure ? exposure : 1.0;
 
 }
 
@@ -202,7 +105,7 @@ const LUM_R = 0.2126, LUM_G = 0.7152, LUM_B = 0.0722;
  * Pre-tonemapping saturation adjustment matching Display's GPU shader:
  *   mix( vec3(luma), exposed, saturation )
  * Operates in-place on the `out` array (expects exposed linear RGB).
- * @param {Float32Array} out - [r, g, b] to adjust
+ * @param {Float32Array|number[]} out - [r, g, b] to adjust
  * @param {number} saturation - 1.0 = neutral
  */
 export function applySaturation( out, saturation ) {
@@ -216,13 +119,13 @@ export function applySaturation( out, saturation ) {
 }
 
 /**
- * Linear float RGBA → sRGB bytes, in the output pass's order: exposure, saturation, curve,
+ * Linear float RGBA → display bytes, in the output pass's order: exposure, saturation, curve,
  * transfer function. Not interchangeable — moving any step shifts every mid-tone.
  *
  * @param {Float32Array} linear - RGBA, 4 floats per pixel
  * @param {Object} options
  * @param {number} options.exposure - renderer.toneMappingExposure, raw
- * @param {number} options.toneMapping - Three.js ToneMapping constant
+ * @param {number} options.toneMapping - a registered view transform id
  * @param {number} [options.saturation=1]
  * @param {boolean} [options.preserveAlpha=false]
  * @returns {Uint8ClampedArray} RGBA bytes
@@ -231,6 +134,7 @@ export function toneMapToRGBA8( linear, { exposure, toneMapping, saturation = 1,
 
 	const curve = TONE_MAP_FNS.get( toneMapping ) ?? TONE_MAP_FNS.get( NoToneMapping );
 	const gain = effectiveExposure( exposure, toneMapping );
+	const encoded = isOutputEncoded( toneMapping );
 	const out = new Uint8ClampedArray( linear.length );
 	const scratch = [ 0, 0, 0 ];
 
@@ -243,9 +147,20 @@ export function toneMapToRGBA8( linear, { exposure, toneMapping, saturation = 1,
 		applySaturation( scratch, saturation );
 		curve( scratch[ 0 ], scratch[ 1 ], scratch[ 2 ], 1.0, scratch );
 
-		out[ i ] = linearToSRGB( scratch[ 0 ] ) * 255 + 0.5;
-		out[ i + 1 ] = linearToSRGB( scratch[ 1 ] ) * 255 + 0.5;
-		out[ i + 2 ] = linearToSRGB( scratch[ 2 ] ) * 255 + 0.5;
+		if ( encoded ) {
+
+			out[ i ] = scratch[ 0 ] * 255 + 0.5;
+			out[ i + 1 ] = scratch[ 1 ] * 255 + 0.5;
+			out[ i + 2 ] = scratch[ 2 ] * 255 + 0.5;
+
+		} else {
+
+			out[ i ] = linearToSRGB( scratch[ 0 ] ) * 255 + 0.5;
+			out[ i + 1 ] = linearToSRGB( scratch[ 1 ] ) * 255 + 0.5;
+			out[ i + 2 ] = linearToSRGB( scratch[ 2 ] ) * 255 + 0.5;
+
+		}
+
 		out[ i + 3 ] = preserveAlpha ? linear[ i + 3 ] * 255 + 0.5 : 255;
 
 	}

package/src/Processor/ToneMapGPU.js

@@ -1,157 +1,45 @@
 /**
- * The engine's tone curve in WGSL, and a pass that turns a packed rgba16float buffer into RGBA
- * bytes on the card.
+ * The engine's view transform in WGSL, and a pass that turns a packed rgba16float buffer into
+ * display bytes on the card.
  *
- * A mirror of `ToneMapCPU.js` — same curves, same order (exposure, saturation, curve, sRGB
- * transfer), same rounding. It exists because reading half-floats back and converting them in
- * JavaScript costs more than the neural upscale itself at production sizes. `bench:tonemap`
- * compares the two implementations on a real device and fails on any drift.
+ * A mirror of `ToneMapCPU.js` — same curves, same order (exposure, saturation, curve, transfer),
+ * same rounding. It exists because reading half-floats back and converting them in JavaScript
+ * costs more than the neural upscale itself at production sizes. `bench:upscale` compares the two
+ * implementations on a real device and fails on any drift.
+ *
+ * Both sides are generated from `../Color/ViewTransforms.js`, so a view baked from an OCIO config
+ * reaches this pass without anything here being edited — the shader is rebuilt when the registry
+ * moves, and each table-backed transform gets its own 3D texture binding.
  *
  * ⚠️ Rounding is deliberately bug-compatible. `toneMapToRGBA8` writes `srgb * 255 + 0.5` into a
- * `Uint8ClampedArray`, which rounds again — so the CPU has always been half a level bright. WGSL's
- * `round()` is round-half-to-even like the clamped array, so `round( srgb * 255 + 0.5 )` reproduces
- * it exactly, including black staying at 0. Dropping the extra half would shift every image against
- * the OIDN and Real-ESRGAN readbacks, which still go through the CPU function.
+ * `Uint8ClampedArray`, which rounds again, so the CPU has always been half a level bright. WGSL's
+ * `round()` is round-half-to-even like the clamped array, so `round( srgb * 255 + 0.5 )`
+ * reproduces it exactly, including black staying at 0.
  */
 
-import {
-	NoToneMapping, LinearToneMapping, ReinhardToneMapping,
-	CineonToneMapping, ACESFilmicToneMapping, AgXToneMapping, NeutralToneMapping
-} from 'three';
+import { buildToneMapWGSL, getRegistryVersion } from '../Color/ViewTransforms.js';
 
-/**
- * WGSL functions: `rayzee_tone_map( linearRGB, mode, exposure, saturation )` and
- * `rayzee_linear_to_srgb( rgb )`, plus `rayzee_to_u8( channel )`.
- *
- * `mode` is the Three.js ToneMapping constant, interpolated in from the import above so the two
- * sides cannot disagree about which number means which curve.
- */
-export const TONE_MAP_WGSL = /* wgsl */ `
-const TM_NONE: u32 = ${NoToneMapping}u;
-const TM_LINEAR: u32 = ${LinearToneMapping}u;
-const TM_REINHARD: u32 = ${ReinhardToneMapping}u;
-const TM_CINEON: u32 = ${CineonToneMapping}u;
-const TM_ACES: u32 = ${ACESFilmicToneMapping}u;
-const TM_AGX: u32 = ${AgXToneMapping}u;
-const TM_NEUTRAL: u32 = ${NeutralToneMapping}u;
-
-fn tm_reinhard( c: vec3<f32> ) -> vec3<f32> {
-	return clamp( c / ( c + vec3<f32>( 1.0 ) ), vec3<f32>( 0.0 ), vec3<f32>( 1.0 ) );
-}
+/** The caller owns bindings 0-2; tables start after them. */
+const TABLE_GROUP = 0;
+const FIRST_TABLE_BINDING = 3;
 
-fn tm_cineon( c0: vec3<f32> ) -> vec3<f32> {
-	let c = max( c0 - vec3<f32>( 0.004 ), vec3<f32>( 0.0 ) );
-	let v = ( c * ( 6.2 * c + vec3<f32>( 0.5 ) ) ) / ( c * ( 6.2 * c + vec3<f32>( 1.7 ) ) + vec3<f32>( 0.06 ) );
-	return pow( max( v, vec3<f32>( 0.0 ) ), vec3<f32>( 2.2 ) );
-}
+function currentShader() {
 
-fn tm_aces( c0: vec3<f32> ) -> vec3<f32> {
-	let c = c0 / 0.6;
-	let m_in = mat3x3<f32>(
-		vec3<f32>( 0.59719, 0.07600, 0.02840 ),
-		vec3<f32>( 0.35458, 0.90834, 0.13383 ),
-		vec3<f32>( 0.04823, 0.01566, 0.83777 ) );
-	let v = m_in * c;
-	let a = v * ( v + vec3<f32>( 0.0245786 ) ) - vec3<f32>( 0.000090537 );
-	let b = v * ( 0.983729 * v + vec3<f32>( 0.4329510 ) ) + vec3<f32>( 0.238081 );
-	let m_out = mat3x3<f32>(
-		vec3<f32>( 1.60475, -0.10208, -0.00327 ),
-		vec3<f32>( -0.53108, 1.10813, -0.07276 ),
-		vec3<f32>( -0.07367, -0.00605, 1.07602 ) );
-	return clamp( m_out * ( a / b ), vec3<f32>( 0.0 ), vec3<f32>( 1.0 ) );
-}
+	const { wgsl, bindings } = buildToneMapWGSL( { group: TABLE_GROUP, firstBinding: FIRST_TABLE_BINDING } );
+	return { wgsl, bindings, version: getRegistryVersion() };
 
-fn tm_agx( c0: vec3<f32> ) -> vec3<f32> {
-	let m_in = mat3x3<f32>(
-		vec3<f32>( 0.6274, 0.0691, 0.0164 ),
-		vec3<f32>( 0.3293, 0.9195, 0.0880 ),
-		vec3<f32>( 0.0433, 0.0113, 0.8956 ) );
-	let m_agx = mat3x3<f32>(
-		vec3<f32>( 0.856627153315983, 0.137318972929847, 0.11189821299995 ),
-		vec3<f32>( 0.0951212405381588, 0.761241990602591, 0.0767994186031903 ),
-		vec3<f32>( 0.0482516061458583, 0.101439036467562, 0.811302368396859 ) );
-
-	var v = m_agx * ( m_in * c0 );
-
-	let minEv = -12.47393;
-	let maxEv = 4.026069;
-	v = clamp( ( log2( max( v, vec3<f32>( 1e-10 ) ) ) - vec3<f32>( minEv ) ) / ( maxEv - minEv ),
-		vec3<f32>( 0.0 ), vec3<f32>( 1.0 ) );
-
-	let x2 = v * v;
-	let x4 = x2 * x2;
-	v = 15.5 * x4 * x2 - 40.14 * x4 * v + 31.96 * x4 - 6.868 * x2 * v + 0.4298 * x2 + 0.1191 * v
-		- vec3<f32>( 0.00232 );
-
-	let m_out = mat3x3<f32>(
-		vec3<f32>( 1.1271005818144368, -0.1413297634984383, -0.14132976349843826 ),
-		vec3<f32>( -0.11060664309660323, 1.157823702216272, -0.11060664309660294 ),
-		vec3<f32>( -0.016493938717834573, -0.016493938717834257, 1.2519364065950405 ) );
-	let o = pow( max( m_out * v, vec3<f32>( 0.0 ) ), vec3<f32>( 2.2 ) );
-
-	let m_srgb = mat3x3<f32>(
-		vec3<f32>( 1.6605, -0.1246, -0.0182 ),
-		vec3<f32>( -0.5876, 1.1329, -0.1006 ),
-		vec3<f32>( -0.0728, -0.0083, 1.1187 ) );
-	return clamp( m_srgb * o, vec3<f32>( 0.0 ), vec3<f32>( 1.0 ) );
 }
 
-fn tm_neutral( c0: vec3<f32> ) -> vec3<f32> {
-	let startCompression = 0.8 - 0.04;
-	let desaturation = 0.15;
-
-	let x = min( c0.r, min( c0.g, c0.b ) );
-	var offset = 0.04;
-	if ( x < 0.08 ) { offset = x - 6.25 * x * x; }
-	var c = c0 - vec3<f32>( offset );
-
-	let peak = max( c.r, max( c.g, c.b ) );
-	if ( peak < startCompression ) { return c; }
-
-	let d = 1.0 - startCompression;
-	let newPeak = 1.0 - d * d / ( peak + d - startCompression );
-	c = c * ( newPeak / peak );
-	let gFactor = 1.0 - 1.0 / ( desaturation * ( peak - newPeak ) + 1.0 );
-	return mix( c, vec3<f32>( newPeak ), gFactor );
-}
-
-// Three.js clamps the fragment output with max(0) before tone mapping, so the curves never see a
-// negative channel. The saturation grade drives channels below zero on much of a typical frame, and
-// AgX/Neutral mix negatives across channels instead of clipping them.
-fn rayzee_tone_curve( color: vec3<f32>, mode: u32 ) -> vec3<f32> {
-	let c = max( color, vec3<f32>( 0.0 ) );
-	if ( mode == TM_REINHARD ) { return tm_reinhard( c ); }
-	if ( mode == TM_CINEON ) { return tm_cineon( c ); }
-	if ( mode == TM_ACES ) { return tm_aces( c ); }
-	if ( mode == TM_AGX ) { return tm_agx( c ); }
-	if ( mode == TM_NEUTRAL ) { return tm_neutral( c ); }
-	return clamp( c, vec3<f32>( 0.0 ), vec3<f32>( 1.0 ) );
-}
-
-fn rayzee_tone_map( linearRGB: vec3<f32>, mode: u32, exposure: f32, saturation: f32 ) -> vec3<f32> {
-	// Three.js returns early for NoToneMapping without applying exposure, so a readback that applied
-	// it would paint brighter than the viewport it replaces.
-	var c = linearRGB * select( exposure, 1.0, mode == TM_NONE );
-	if ( saturation != 1.0 ) {
-		let luma = vec3<f32>( dot( c, vec3<f32>( 0.2126, 0.7152, 0.0722 ) ) );
-		c = luma + ( c - luma ) * saturation;
-	}
-	return rayzee_tone_curve( c, mode );
-}
-
-fn rayzee_linear_to_srgb( c: vec3<f32> ) -> vec3<f32> {
-	return select(
-		1.055 * pow( max( c, vec3<f32>( 0.0 ) ), vec3<f32>( 1.0 / 2.4 ) ) - vec3<f32>( 0.055 ),
-		12.92 * c,
-		c <= vec3<f32>( 0.0031308 ) );
-}
-
-fn rayzee_to_u8( srgb: vec3<f32> ) -> vec3<u32> {
-	return vec3<u32>( clamp( round( srgb * 255.0 + vec3<f32>( 0.5 ) ), vec3<f32>( 0.0 ), vec3<f32>( 255.0 ) ) );
-}
-`;
+/**
+ * `rayzee_tone_map( linearRGB, mode, exposure, saturation )`, `rayzee_encode( mapped, mode )` and
+ * `rayzee_to_u8( c )` for the registry as it stands right now.
+ *
+ * A snapshot, not a live value: `PackedToneMapper` regenerates its own copy when the registry
+ * changes. Exported for tests and for a host embedding the curve in its own pass.
+ */
+export const TONE_MAP_WGSL = currentShader().wgsl;
 
-const PACKED_WGSL = /* wgsl */ `
+const packedWGSL = transformWGSL => /* wgsl */ `
 struct Params {
 	width: u32,
 	height: u32,
@@ -165,7 +53,7 @@ struct Params {
 @group(0) @binding(1) var<storage, read_write> dst: array<u32>;
 @group(0) @binding(2) var<uniform> params: Params;
 
-${TONE_MAP_WGSL}
+${transformWGSL}
 
 @compute @workgroup_size(8, 8)
 fn main( @builtin(global_invocation_id) gid: vec3<u32> ) {
@@ -179,7 +67,7 @@ fn main( @builtin(global_invocation_id) gid: vec3<u32> ) {
 	let ba = unpack2x16float( src[ a + 1u ] );
 
 	let mapped = rayzee_tone_map( vec3<f32>( rg.x, rg.y, ba.x ), params.mode, params.exposure, params.saturation );
-	let b8 = rayzee_to_u8( rayzee_linear_to_srgb( mapped ) );
+	let b8 = rayzee_to_u8( rayzee_encode( mapped, params.mode ) );
 	dst[ gid.y * params.width + gid.x ] = b8.x | ( b8.y << 8u ) | ( b8.z << 16u ) | ( 255u << 24u );
 }
 `;
@@ -207,13 +95,91 @@ export class PackedToneMapper {
 		this._paramData = new ArrayBuffer( PARAMS_BYTES );
 		this._paramU32 = new Uint32Array( this._paramData );
 		this._paramF32 = new Float32Array( this._paramData );
+		this._shaderVersion = - 1;
+		this._bindings = [];
+		this._tables = new Map();
 		this.disposed = false;
 
 	}
 
+	/**
+	 * Rebuild the pipeline when the registry has moved.
+	 *
+	 * A config loaded after this pass was first compiled adds curves the compiled shader has never
+	 * heard of. Without this the readback silently falls through to the clamp and a saved image
+	 * comes back untone-mapped.
+	 */
+	_ensurePipeline() {
+
+		const { wgsl, bindings, version } = currentShader();
+		if ( this._pipeline && this._shaderVersion === version ) return;
+
+		this._bindings = bindings;
+		this._shaderVersion = version;
+		this._pipeline = this.device.createComputePipeline( {
+			label: this.label,
+			layout: 'auto',
+			compute: {
+				module: this.device.createShaderModule( { label: this.label, code: packedWGSL( wgsl ) } ),
+				entryPoint: 'main',
+			},
+		} );
+
+	}
+
+	/** One 3D texture per table-backed transform, uploaded once and kept until it is replaced. */
+	_ensureTables() {
+
+		const live = new Set();
+
+		for ( const { index, transform } of this._bindings ) {
+
+			const { data, size } = transform.table;
+			live.add( index );
+
+			const held = this._tables.get( index );
+			if ( held && held.data === data ) continue;
+
+			held?.texture.destroy();
+
+			const texture = this.device.createTexture( {
+				label: `${this.label}-${transform.wgslConst}`,
+				size: [ size, size, size ],
+				dimension: '3d',
+				format: 'rgba16float',
+				usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST,
+			} );
+
+			this.device.queue.writeTexture(
+				{ texture },
+				data,
+				{ bytesPerRow: size * 8, rowsPerImage: size },
+				[ size, size, size ]
+			);
+
+			this._tables.set( index, { texture, data, view: texture.createView() } );
+
+		}
+
+		for ( const [ index, held ] of this._tables ) {
+
+			if ( ! live.has( index ) ) {
+
+				held.texture.destroy();
+				this._tables.delete( index );
+
+			}
+
+		}
+
+	}
+
 	ensureSize( width, height ) {
 
-		if ( this.width === width && this.height === height && this._pipeline ) return;
+		this._ensurePipeline();
+		this._ensureTables();
+
+		if ( this.width === width && this.height === height && this._storage ) return;
 
 		this._releaseBuffers();
 
@@ -234,12 +200,6 @@ export class PackedToneMapper {
 			usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST,
 		} );
 
-		this._pipeline ??= this.device.createComputePipeline( {
-			label: this.label,
-			layout: 'auto',
-			compute: { module: this.device.createShaderModule( { label: this.label, code: PACKED_WGSL } ), entryPoint: 'main' },
-		} );
-
 		this.width = width;
 		this.height = height;
 
@@ -257,7 +217,12 @@ export class PackedToneMapper {
 	async toRGBA8( src, { exposure = 1, toneMapping = 0, saturation = 1, flipY = false } = {} ) {
 
 		if ( this.disposed ) throw new Error( 'PackedToneMapper: disposed' );
-		if ( ! this._pipeline ) throw new Error( 'PackedToneMapper: call ensureSize() first' );
+		if ( ! this._storage ) throw new Error( 'PackedToneMapper: call ensureSize() first' );
+
+		// A config can be loaded between two readbacks, so the registry is re-checked here rather
+		// than only on resize.
+		this._ensurePipeline();
+		this._ensureTables();
 
 		const { width, height } = this;
 
@@ -269,9 +234,13 @@ export class PackedToneMapper {
 		this._paramF32[ 5 ] = saturation;
 		this.device.queue.writeBuffer( this._params, 0, this._paramData );
 
+		const tableEntries = [ ...this._tables.entries() ]
+			.map( ( [ binding, held ] ) => ( { binding, resource: held.view } ) );
+
 		const group = this.device.createBindGroup( {
 			layout: this._pipeline.getBindGroupLayout( 0 ),
 			entries: [
+				...tableEntries,
 				{ binding: 0, resource: { buffer: src, size: width * height * 8 } },
 				{ binding: 1, resource: { buffer: this._storage } },
 				{ binding: 2, resource: { buffer: this._params } },
@@ -310,6 +279,8 @@ export class PackedToneMapper {
 		if ( this.disposed ) return;
 		this.disposed = true;
 		this._releaseBuffers();
+		for ( const held of this._tables.values() ) held.texture.destroy();
+		this._tables.clear();
 		this._pipeline = null;
 
 	}

package/src/RenderSettings.js

@@ -42,6 +42,7 @@ const SETTING_ROUTES = {
 	anamorphicRatio: { uniform: 'anamorphicRatio', reset: true },
 	samplingTechnique: { uniform: 'samplingTechnique', reset: true },
 	fireflyThreshold: { uniform: 'fireflyThreshold', reset: true },
+	shadowTerminatorOffset: { uniform: 'shadowTerminatorOffset', reset: true },
 	enableAlphaShadows: { uniform: 'enableAlphaShadows', reset: true },
 	// Adaptive sampling — whole-frame early-stop (useAdaptiveSampling) + per-pixel freeze (usePixelFreeze)
 	useAdaptiveSampling: { uniform: 'useAdaptiveSampling', reset: true },