@aura3d/rendering 3.0.1 → 4.0.2

package/dist/post/shaders/exposure.glsl.js

@@ -0,0 +1,115 @@
+/**
+ * PRD-03 §8.9 — S8 auto-exposure (GPU only, zero readbacks).
+ *
+ * Chain: `EXPOSURE_LUMA_LOG_GLSL` writes `log2(max(luma, 1e-5))` into a
+ * quarter-res R16F surface (landed as rgba32f in the transitional pool —
+ * ≥ spec precision, .r channel) with a centre-weighted or average metering
+ * mask; `EXPOSURE_REDUCE_GLSL` box-averages 2× per draw until 1×1;
+ * `EXPOSURE_ADAPT_GLSL` integrates toward the target EV in a 1×1 ping-pong:
+ *
+ *   ev = mix(evPrev, clamp(-avgLog2 + log2(0.18) + comp, minEv, maxEv),
+ *            1 - exp(-dt * speed))
+ *
+ * with `speed` = speedUp when brightening, speedDown when darkening.
+ * `EXPOSURE_MUL_GLSL` then multiplies the HDR frame by `exp2(ev)` — the
+ * S10-composite `autoExp` factor applied as its own linear-HDR draw on the
+ * transitional chain, so the fused OUT still receives its §6.4 exposure.
+ */
+/** S8 pass 1: log2 luma at 1/4 res; `AURA_EXPOSURE_CENTER_WEIGHTED` masks. */
+export const EXPOSURE_LUMA_LOG_GLSL = /* glsl */ `#version 300 es
+precision highp float;
+uniform sampler2D u_hdr;
+uniform vec2 u_texelSize;      // 1 / HDR size
+uniform int u_centerWeighted;  // 1 = centre-weighted metering, 0 = average
+in vec2 v_uv;
+out vec4 outColor;
+
+void main() {
+	// One output texel covers a 4×4 block of source texels; average the block.
+	vec4 acc = vec4(0.0);
+	for (int y = 0; y < 4; y++) {
+		for (int x = 0; x < 4; x++) {
+			vec2 uv = v_uv + (vec2(float(x), float(y)) - 1.5) * u_texelSize;
+			acc.rgb += texture(u_hdr, uv).rgb;
+			acc.a += 1.0;
+		}
+	}
+	vec3 c = acc.rgb / max(acc.a, 1.0);
+	float luma = max(dot(c, vec3(0.2126, 0.7152, 0.0722)), 1e-5);
+	// Centre-weighted: w = 1 - (d^2), clamped — an 18% gray card reads weight 1
+	// at frame centre and falls to 0 at the corners.
+	vec2 centered = v_uv - 0.5;
+	float w = u_centerWeighted == 1 ? max(0.0, 1.0 - dot(centered, centered) * 4.0) : 1.0;
+	outColor = vec4(log2(luma) * w, w, 0.0, 1.0);
+}
+`;
+/** S8 reduce: 4-tap box average of the previous mip (weighted sum in .rg). */
+export const EXPOSURE_REDUCE_GLSL = /* glsl */ `#version 300 es
+precision highp float;
+uniform sampler2D u_source;
+uniform vec2 u_texelSize;      // 1 / source size
+in vec2 v_uv;
+out vec4 outColor;
+
+void main() {
+	vec4 sum = texture(u_source, v_uv + vec2(-0.5, -0.5) * u_texelSize)
+		+ texture(u_source, v_uv + vec2( 0.5, -0.5) * u_texelSize)
+		+ texture(u_source, v_uv + vec2(-0.5,  0.5) * u_texelSize)
+		+ texture(u_source, v_uv + vec2( 0.5,  0.5) * u_texelSize);
+	outColor = sum * 0.25;
+}
+`;
+/**
+ * S8 adapt: 1×1 ping-pong. `u_prev` is last frame's EV texel; `u_avg` is the
+ * reduced texel (r = Σ log2 luma · w, g = Σ w). `u_hasPrev` boots the first
+ * frame straight to target (no transient from an arbitrary 0 start).
+ */
+export const EXPOSURE_ADAPT_GLSL = /* glsl */ `#version 300 es
+precision highp float;
+uniform sampler2D u_prev;
+uniform sampler2D u_avg;
+uniform float u_dt;
+uniform float u_speedUp;
+uniform float u_speedDown;
+uniform float u_minEv;
+uniform float u_maxEv;
+uniform float u_compensationEv;
+uniform int u_hasPrev;
+out vec4 outColor;
+
+void main() {
+	vec4 avg = texelFetch(u_avg, ivec2(0), 0);
+	float avgLog2 = avg.r / max(avg.g, 1e-4);   // Σ(l·w)/Σw — weighted mean
+	float target = clamp(-avgLog2 + log2(0.18) + u_compensationEv, u_minEv, u_maxEv);
+	float prev = texelFetch(u_prev, ivec2(0), 0).r;
+	float speed = target > prev ? u_speedUp : u_speedDown;
+	float ev = u_hasPrev == 1 ? mix(prev, target, 1.0 - exp(-u_dt * speed)) : target;
+	outColor = vec4(ev, 0.0, 0.0, 1.0);
+}
+`;
+/** S8 apply: `outColor = hdr * exp2(ev)` — the composite's autoExp factor. */
+export const EXPOSURE_MUL_GLSL = /* glsl */ `#version 300 es
+precision highp float;
+uniform sampler2D u_hdr;
+uniform sampler2D u_ev;
+in vec2 v_uv;
+out vec4 outColor;
+
+void main() {
+	float ev = texelFetch(u_ev, ivec2(0), 0).r;
+	vec4 c = texture(u_hdr, v_uv);
+	outColor = vec4(c.rgb * exp2(ev), c.a);
+}
+`;
+/**
+ * JS mirror of the adapt step — the unit test proves the shader's `mix`
+ * formula and speed selection byte-for-byte against this reference.
+ */
+export function adaptEv(prev, avgLog2, options) {
+    const target = Math.min(Math.max(-avgLog2 + Math.log2(0.18) + options.compensationEv, options.minEv), options.maxEv);
+    if (!options.hasPrev)
+        return target;
+    const speed = target > prev ? options.speedUp : options.speedDown;
+    return prev + (target - prev) * (1 - Math.exp(-options.dt * speed));
+}
+//# sourceMappingURL=exposure.glsl.js.map

package/dist/post/shaders/exposure.glsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"exposure.glsl.js","sourceRoot":"","sources":["../../../../../../packages/rendering/src/post/shaders/exposure.glsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,8EAA8E;AAC9E,MAAM,CAAC,MAAM,sBAAsB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;CA0BhD,CAAC;AAEF,8EAA8E;AAC9E,MAAM,CAAC,MAAM,oBAAoB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;CAc9C,CAAC;AAEF;;;;GAIG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;CAsB7C,CAAC;AAEF,8EAA8E;AAC9E,MAAM,CAAC,MAAM,iBAAiB,GAAG,UAAU,CAAC;;;;;;;;;;;;CAY3C,CAAC;AAEF;;;GAGG;AACH,MAAM,UAAU,OAAO,CAAC,IAAY,EAAE,OAAe,EAAE,OAItD;IACC,MAAM,MAAM,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,OAAO,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC,cAAc,EAAE,OAAO,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC,KAAK,CAAC,CAAC;IACrH,IAAI,CAAC,OAAO,CAAC,OAAO;QAAE,OAAO,MAAM,CAAC;IACpC,MAAM,KAAK,GAAG,MAAM,GAAG,IAAI,CAAC,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,OAAO,CAAC,SAAS,CAAC;IAClE,OAAO,IAAI,GAAG,CAAC,MAAM,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,OAAO,CAAC,EAAE,GAAG,KAAK,CAAC,CAAC,CAAC;AACtE,CAAC"}

package/dist/post/shaders/exposure.wgsl.d.ts

@@ -0,0 +1,16 @@
+/**
+ * PRD-03 §8.9 Phase 7 — S8 auto-exposure WGSL twins (GPU only, zero
+ * readbacks). Same chain as the GLSL twins: quarter-res log2-luma
+ * (centre-weighted or average mask) → box-reduce to 1×1 → EV ping-pong
+ * adapt (`has_prev` boots to target; speed = speedUp when brightening,
+ * speedDown when darkening) → `hdr * exp2(ev)`.
+ */
+/** S8 pass 1: log2 luma at 1/4 res; `center_weighted` masks. */
+export declare const EXPOSURE_LUMA_LOG_WGSL = "struct ExposureLumaParams {\n  texel_size: vec2<f32>,   // 1 / HDR size\n  center_weighted: i32,    // 1 = centre-weighted metering, 0 = average\n  _pad: f32,\n};\n\n@group(0) @binding(0) var<uniform> u_params: ExposureLumaParams;\n@group(0) @binding(1) var u_hdr_tex: texture_2d<f32>;\n@group(0) @binding(2) var u_hdr_smp: sampler;\n\n@fragment\nfn fs_exposure_luma_log(@location(0) uv: vec2<f32>) -> @location(0) vec4<f32> {\n  // One output texel covers a 4\u00D74 block of source texels; average the block.\n  var acc = vec4<f32>(0.0);\n  for (var y = 0; y < 4; y = y + 1) {\n    for (var x = 0; x < 4; x = x + 1) {\n      let tap_uv = uv + (vec2<f32>(f32(x), f32(y)) - vec2<f32>(1.5)) * u_params.texel_size;\n      acc = vec4<f32>(acc.rgb + textureSampleLevel(u_hdr_tex, u_hdr_smp, tap_uv, 0.0).rgb, acc.a + 1.0);\n    }\n  }\n  let c = acc.rgb / max(acc.a, 1.0);\n  let luma = max(dot(c, vec3<f32>(0.2126, 0.7152, 0.0722)), 1e-5);\n  // Centre-weighted: w = 1 - (d\u00B2), clamped \u2014 an 18% gray card reads weight 1\n  // at frame centre and falls to 0 at the corners.\n  let centered = uv - vec2<f32>(0.5);\n  let w = select(1.0, max(0.0, 1.0 - dot(centered, centered) * 4.0), u_params.center_weighted == 1);\n  return vec4<f32>(log2(luma) * w, w, 0.0, 1.0);\n}\n";
+/** S8 reduce: 4-tap box average of the previous mip (weighted sum in .rg). */
+export declare const EXPOSURE_REDUCE_WGSL = "struct ExposureReduceParams {\n  texel_size: vec2<f32>,   // 1 / source size\n  _pad0: vec2<f32>,\n};\n\n@group(0) @binding(0) var<uniform> u_params: ExposureReduceParams;\n@group(0) @binding(1) var u_source_tex: texture_2d<f32>;\n@group(0) @binding(2) var u_source_smp: sampler;\n\n@fragment\nfn fs_exposure_reduce(@location(0) uv: vec2<f32>) -> @location(0) vec4<f32> {\n  let sum = textureSampleLevel(u_source_tex, u_source_smp, uv + vec2<f32>(-0.5, -0.5) * u_params.texel_size, 0.0)\n    + textureSampleLevel(u_source_tex, u_source_smp, uv + vec2<f32>(0.5, -0.5) * u_params.texel_size, 0.0)\n    + textureSampleLevel(u_source_tex, u_source_smp, uv + vec2<f32>(-0.5, 0.5) * u_params.texel_size, 0.0)\n    + textureSampleLevel(u_source_tex, u_source_smp, uv + vec2<f32>(0.5, 0.5) * u_params.texel_size, 0.0);\n  return sum * 0.25;\n}\n";
+/** S8 adapt: 1×1 ping-pong; `has_prev == 1` integrates, else boots to target. */
+export declare const EXPOSURE_ADAPT_WGSL = "struct ExposureAdaptParams {\n  dt: f32,\n  speed_up: f32,\n  speed_down: f32,\n  min_ev: f32,\n  max_ev: f32,\n  compensation_ev: f32,\n  has_prev: i32,\n  _pad: f32,\n};\n\n@group(0) @binding(0) var<uniform> u_params: ExposureAdaptParams;\n@group(0) @binding(1) var u_prev_tex: texture_2d<f32>;\n@group(0) @binding(2) var u_avg_tex: texture_2d<f32>;\n\n@fragment\nfn fs_exposure_adapt(@builtin(position) frag_coord: vec4<f32>) -> @location(0) vec4<f32> {\n  let avg = textureLoad(u_avg_tex, vec2<i32>(0), 0);\n  let avg_log2 = avg.r / max(avg.g, 1e-4);   // \u03A3(l\u00B7w)/\u03A3w \u2014 weighted mean\n  // WGSL-reserved keyword: the GLSL twin's \"target\" is \"target_ev\" here.\n  let target_ev = clamp(-avg_log2 + log2(0.18) + u_params.compensation_ev, u_params.min_ev, u_params.max_ev);\n  let prev = textureLoad(u_prev_tex, vec2<i32>(0), 0).r;\n  let speed = select(u_params.speed_down, u_params.speed_up, target_ev > prev);\n  let ev = select(target_ev, mix(prev, target_ev, 1.0 - exp(-u_params.dt * speed)), u_params.has_prev == 1);\n  return vec4<f32>(ev, 0.0, 0.0, 1.0);\n}\n";
+/** S8 apply: `out = hdr * exp2(ev)` — the composite's autoExp factor. */
+export declare const EXPOSURE_MUL_WGSL = "@group(0) @binding(1) var u_hdr_tex: texture_2d<f32>;\n@group(0) @binding(2) var u_hdr_smp: sampler;\n@group(0) @binding(3) var u_ev_tex: texture_2d<f32>;\n\n@fragment\nfn fs_exposure_mul(@location(0) uv: vec2<f32>) -> @location(0) vec4<f32> {\n  let ev = textureLoad(u_ev_tex, vec2<i32>(0), 0).r;\n  let c = textureSampleLevel(u_hdr_tex, u_hdr_smp, uv, 0.0);\n  return vec4<f32>(c.rgb * exp2(ev), c.a);\n}\n";
+//# sourceMappingURL=exposure.wgsl.d.ts.map

package/dist/post/shaders/exposure.wgsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exposure.wgsl.d.ts","sourceRoot":"","sources":["../../../../../../packages/rendering/src/post/shaders/exposure.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,gEAAgE;AAChE,eAAO,MAAM,sBAAsB,+vCA4BlC,CAAC;AAEF,8EAA8E;AAC9E,eAAO,MAAM,oBAAoB,00BAiBhC,CAAC;AAEF,iFAAiF;AACjF,eAAO,MAAM,mBAAmB,skCA0B/B,CAAC;AAEF,yEAAyE;AACzE,eAAO,MAAM,iBAAiB,6ZAU7B,CAAC"}

package/dist/post/shaders/exposure.wgsl.js

@@ -0,0 +1,97 @@
+/**
+ * PRD-03 §8.9 Phase 7 — S8 auto-exposure WGSL twins (GPU only, zero
+ * readbacks). Same chain as the GLSL twins: quarter-res log2-luma
+ * (centre-weighted or average mask) → box-reduce to 1×1 → EV ping-pong
+ * adapt (`has_prev` boots to target; speed = speedUp when brightening,
+ * speedDown when darkening) → `hdr * exp2(ev)`.
+ */
+/** S8 pass 1: log2 luma at 1/4 res; `center_weighted` masks. */
+export const EXPOSURE_LUMA_LOG_WGSL = /* wgsl */ `struct ExposureLumaParams {
+  texel_size: vec2<f32>,   // 1 / HDR size
+  center_weighted: i32,    // 1 = centre-weighted metering, 0 = average
+  _pad: f32,
+};
+
+@group(0) @binding(0) var<uniform> u_params: ExposureLumaParams;
+@group(0) @binding(1) var u_hdr_tex: texture_2d<f32>;
+@group(0) @binding(2) var u_hdr_smp: sampler;
+
+@fragment
+fn fs_exposure_luma_log(@location(0) uv: vec2<f32>) -> @location(0) vec4<f32> {
+  // One output texel covers a 4×4 block of source texels; average the block.
+  var acc = vec4<f32>(0.0);
+  for (var y = 0; y < 4; y = y + 1) {
+    for (var x = 0; x < 4; x = x + 1) {
+      let tap_uv = uv + (vec2<f32>(f32(x), f32(y)) - vec2<f32>(1.5)) * u_params.texel_size;
+      acc = vec4<f32>(acc.rgb + textureSampleLevel(u_hdr_tex, u_hdr_smp, tap_uv, 0.0).rgb, acc.a + 1.0);
+    }
+  }
+  let c = acc.rgb / max(acc.a, 1.0);
+  let luma = max(dot(c, vec3<f32>(0.2126, 0.7152, 0.0722)), 1e-5);
+  // Centre-weighted: w = 1 - (d²), clamped — an 18% gray card reads weight 1
+  // at frame centre and falls to 0 at the corners.
+  let centered = uv - vec2<f32>(0.5);
+  let w = select(1.0, max(0.0, 1.0 - dot(centered, centered) * 4.0), u_params.center_weighted == 1);
+  return vec4<f32>(log2(luma) * w, w, 0.0, 1.0);
+}
+`;
+/** S8 reduce: 4-tap box average of the previous mip (weighted sum in .rg). */
+export const EXPOSURE_REDUCE_WGSL = /* wgsl */ `struct ExposureReduceParams {
+  texel_size: vec2<f32>,   // 1 / source size
+  _pad0: vec2<f32>,
+};
+
+@group(0) @binding(0) var<uniform> u_params: ExposureReduceParams;
+@group(0) @binding(1) var u_source_tex: texture_2d<f32>;
+@group(0) @binding(2) var u_source_smp: sampler;
+
+@fragment
+fn fs_exposure_reduce(@location(0) uv: vec2<f32>) -> @location(0) vec4<f32> {
+  let sum = textureSampleLevel(u_source_tex, u_source_smp, uv + vec2<f32>(-0.5, -0.5) * u_params.texel_size, 0.0)
+    + textureSampleLevel(u_source_tex, u_source_smp, uv + vec2<f32>(0.5, -0.5) * u_params.texel_size, 0.0)
+    + textureSampleLevel(u_source_tex, u_source_smp, uv + vec2<f32>(-0.5, 0.5) * u_params.texel_size, 0.0)
+    + textureSampleLevel(u_source_tex, u_source_smp, uv + vec2<f32>(0.5, 0.5) * u_params.texel_size, 0.0);
+  return sum * 0.25;
+}
+`;
+/** S8 adapt: 1×1 ping-pong; `has_prev == 1` integrates, else boots to target. */
+export const EXPOSURE_ADAPT_WGSL = /* wgsl */ `struct ExposureAdaptParams {
+  dt: f32,
+  speed_up: f32,
+  speed_down: f32,
+  min_ev: f32,
+  max_ev: f32,
+  compensation_ev: f32,
+  has_prev: i32,
+  _pad: f32,
+};
+
+@group(0) @binding(0) var<uniform> u_params: ExposureAdaptParams;
+@group(0) @binding(1) var u_prev_tex: texture_2d<f32>;
+@group(0) @binding(2) var u_avg_tex: texture_2d<f32>;
+
+@fragment
+fn fs_exposure_adapt(@builtin(position) frag_coord: vec4<f32>) -> @location(0) vec4<f32> {
+  let avg = textureLoad(u_avg_tex, vec2<i32>(0), 0);
+  let avg_log2 = avg.r / max(avg.g, 1e-4);   // Σ(l·w)/Σw — weighted mean
+  // WGSL-reserved keyword: the GLSL twin's "target" is "target_ev" here.
+  let target_ev = clamp(-avg_log2 + log2(0.18) + u_params.compensation_ev, u_params.min_ev, u_params.max_ev);
+  let prev = textureLoad(u_prev_tex, vec2<i32>(0), 0).r;
+  let speed = select(u_params.speed_down, u_params.speed_up, target_ev > prev);
+  let ev = select(target_ev, mix(prev, target_ev, 1.0 - exp(-u_params.dt * speed)), u_params.has_prev == 1);
+  return vec4<f32>(ev, 0.0, 0.0, 1.0);
+}
+`;
+/** S8 apply: `out = hdr * exp2(ev)` — the composite's autoExp factor. */
+export const EXPOSURE_MUL_WGSL = /* wgsl */ `@group(0) @binding(1) var u_hdr_tex: texture_2d<f32>;
+@group(0) @binding(2) var u_hdr_smp: sampler;
+@group(0) @binding(3) var u_ev_tex: texture_2d<f32>;
+
+@fragment
+fn fs_exposure_mul(@location(0) uv: vec2<f32>) -> @location(0) vec4<f32> {
+  let ev = textureLoad(u_ev_tex, vec2<i32>(0), 0).r;
+  let c = textureSampleLevel(u_hdr_tex, u_hdr_smp, uv, 0.0);
+  return vec4<f32>(c.rgb * exp2(ev), c.a);
+}
+`;
+//# sourceMappingURL=exposure.wgsl.js.map

package/dist/post/shaders/exposure.wgsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"exposure.wgsl.js","sourceRoot":"","sources":["../../../../../../packages/rendering/src/post/shaders/exposure.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,gEAAgE;AAChE,MAAM,CAAC,MAAM,sBAAsB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4BhD,CAAC;AAEF,8EAA8E;AAC9E,MAAM,CAAC,MAAM,oBAAoB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;CAiB9C,CAAC;AAEF,iFAAiF;AACjF,MAAM,CAAC,MAAM,mBAAmB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;CA0B7C,CAAC;AAEF,yEAAyE;AACzE,MAAM,CAAC,MAAM,iBAAiB,GAAG,UAAU,CAAC;;;;;;;;;;CAU3C,CAAC"}

package/dist/post/shaders/finalize.glsl.d.ts

@@ -0,0 +1,17 @@
+/**
+ * PRD-03 §6.1 S12 / §8.15 — the finalize pass.
+ *
+ * Writes the default framebuffer: film grain (display space, luma-gated by
+ * `luminanceResponse`), then FSR1 RCAS sharpening when TAA sharpness > 0 or
+ * renderScale < 1 (limit 0.25), then the triangular-PDF dither — the last
+ * write to the 8-bit output.
+ *
+ * `FINALIZE_FXAA_FUSED_GLSL` is the §6.1 fuse: when post-AA is FXAA, S10b
+ * (display LUT + vignette), S11 (r185 FXAA) and S12 collapse into one draw.
+ * The fused program reads luma from `.a` (S10b writes `luma(disp)` there) so
+ * the FXAA taps never re-run the grade — the fix for today's per-tap
+ * `finalColorAt` re-evaluation (`WebGL2Device.ts:3611-3631`).
+ */
+export declare const FINALIZE_GLSL = "#version 300 es\nprecision highp float;\nuniform sampler2D u_source;\nuniform vec2 u_texelSize;\nuniform float u_frame;\nuniform float u_grainIntensity;\nuniform float u_grainSize;\nuniform float u_grainLuminanceResponse;\nuniform float u_rcasSharpness;    // 0 disables; FSR1 limit 0.25\nin vec2 v_uv;\nout vec4 outColor;\n\n\nfloat linearizeDepth(float d, float n, float f, bool ortho) {\n  float z = d * 2.0 - 1.0;\n  return ortho ? mix(n, f, d) : (2.0 * n * f) / (f + n - z * (f - n));\n}\n\nuvec2 pcg2d(uvec2 v) {\n  v = v * 1664525u + 1013904223u;\n  v.x += v.y * 1664525u;\n  v.y += v.x * 1664525u;\n  v ^= v >> 16u;\n  v.x += v.y * 1664525u;\n  v.y += v.x * 1664525u;\n  v ^= v >> 16u;\n  return v;\n}\n\n// Triangular-PDF dither: (rand0 + rand1 - 1) / 255 \u2192 \u00B11 LSB of 8-bit output.\nfloat triangularDither(vec2 fragCoord, float frame) {\n  uvec2 seed = uvec2(fragCoord) + uvec2(uint(frame) * 747796405u);\n  vec2 rand = vec2(pcg2d(seed)) / 4294967296.0;\n  return (rand.x + rand.y - 1.0) / 255.0;\n}\n\n\nfloat luma709(vec3 c) { return dot(c, vec3(0.2126, 0.7152, 0.0722)); }\n\nvec3 rcas(sampler2D tex, vec2 uv, vec2 texel, float sharpness) {\n  // FSR1 RCAS: single-pass adaptive sharpen over the 4-ring neighbourhood.\n  vec3 e = texture(tex, uv).rgb;\n  vec3 cross = (\n    texture(tex, uv + vec2(0.0, -texel.y)).rgb +\n    texture(tex, uv + vec2(0.0, texel.y)).rgb +\n    texture(tex, uv + vec2(-texel.x, 0.0)).rgb +\n    texture(tex, uv + vec2(texel.x, 0.0)).rgb\n  ) * 0.25;\n  float sharp = min(sharpness, 0.25);\n  return clamp(e + (e - cross) * sharp, 0.0, 1.0);\n}\n\nfloat filmGrain(vec2 fragCoord, float frame, float intensity, float size, float luminanceResponse, float lumaValue) {\n  uvec2 seed = uvec2(fragCoord * size) + uvec2(uint(frame) * 747796405u);\n  vec2 rnd = vec2(pcg2d(seed)) / 4294967296.0;\n  return (rnd.x - 0.5) * intensity * mix(1.0, 1.0 - lumaValue, luminanceResponse);\n}\n\n\nvoid main() {\n  vec3 disp = u_rcasSharpness > 0.0\n    ? rcas(u_source, v_uv, u_texelSize, u_rcasSharpness)\n    : texture(u_source, v_uv).rgb;\n  disp += filmGrain(gl_FragCoord.xy, u_frame, u_grainIntensity, u_grainSize, u_grainLuminanceResponse, luma709(disp));\n  disp += triangularDither(gl_FragCoord.xy, u_frame);\n  outColor = vec4(clamp(disp, 0.0, 1.0), 1.0);\n}\n";
+export declare const FINALIZE_FXAA_FUSED_GLSL = "#version 300 es\nprecision highp float;\n// GLSL ES 3.00 has no default precision for sampler3D (CI: \"'sampler3D' : No precision specified\").\nprecision highp sampler3D;\n#define AURA_LUMA_ALPHA 1\nuniform sampler2D u_source;\nuniform sampler3D u_lut3d;\nuniform int u_hasLut;\nuniform vec2 u_texelSize;\nuniform vec2 u_outputTexel;\nuniform float u_frame;\nuniform float u_grainIntensity;\nuniform float u_grainSize;\nuniform float u_grainLuminanceResponse;\nuniform float u_vignetteIntensity;\nuniform float u_vignetteSmoothness;\nuniform float u_vignetteRoundness;\nuniform vec3 u_vignetteColor;\nuniform vec2 u_resolution;\nin vec2 v_uv;\nout vec4 outColor;\n\n// S10b inline: the FXAA taps sample the display-graded source \u2014 each tap is\n// one LUT fetch + vignette, not a re-run of the analytic grade. Forward\n// declaration so the AURA_FXAA_SAMPLE hook (inside FXAA_185_FNS_GLSL) resolves.\nvec4 sampleGraded(sampler2D tex, vec2 uv);\n#define AURA_FXAA_SAMPLE(tex, uvSample) sampleGraded(tex, uvSample)\n\n#define EDGE_STEP_COUNT 6\n#define EDGE_GUESS 8.0\n#define EDGE_STEPS 1.0, 1.5, 2.0, 2.0, 2.0, 4.0\nconst float edgeSteps[EDGE_STEP_COUNT] = float[EDGE_STEP_COUNT]( EDGE_STEPS );\n\nfloat _ContrastThreshold = 0.0312;\nfloat _RelativeThreshold = 0.063;\nfloat _SubpixelBlending = 1.0;\n\n#ifndef AURA_FXAA_SAMPLE\n#define AURA_FXAA_SAMPLE(tex, uv) texture(tex, uv)\n#endif\n\nvec4 Sample( sampler2D tex2D, vec2 uv ) {\n  return AURA_FXAA_SAMPLE( tex2D, uv );\n}\n\nfloat SampleLuminance( sampler2D tex2D, vec2 uv ) {\n#if AURA_LUMA_ALPHA\n  return AURA_FXAA_SAMPLE( tex2D, uv ).a;\n#else\n  return dot( Sample( tex2D, uv ).rgb, vec3( 0.3, 0.59, 0.11 ) );\n#endif\n}\n\nfloat SampleLuminance( sampler2D tex2D, vec2 texSize, vec2 uv, float uOffset, float vOffset ) {\n  uv += texSize * vec2(uOffset, vOffset);\n  return SampleLuminance(tex2D, uv);\n}\n\nstruct LuminanceData {\n  float m, n, e, s, w;\n  float ne, nw, se, sw;\n  float highest, lowest, contrast;\n};\n\nLuminanceData SampleLuminanceNeighborhood( sampler2D tex2D, vec2 texSize, vec2 uv ) {\n  LuminanceData l;\n  l.m = SampleLuminance( tex2D, uv );\n  l.n = SampleLuminance( tex2D, texSize, uv,  0.0,  1.0 );\n  l.e = SampleLuminance( tex2D, texSize, uv,  1.0,  0.0 );\n  l.s = SampleLuminance( tex2D, texSize, uv,  0.0, -1.0 );\n  l.w = SampleLuminance( tex2D, texSize, uv, -1.0,  0.0 );\n\n  l.ne = SampleLuminance( tex2D, texSize, uv,  1.0,  1.0 );\n  l.nw = SampleLuminance( tex2D, texSize, uv, -1.0,  1.0 );\n  l.se = SampleLuminance( tex2D, texSize, uv,  1.0, -1.0 );\n  l.sw = SampleLuminance( tex2D, texSize, uv, -1.0, -1.0 );\n\n  l.highest = max( max( max( max( l.n, l.e ), l.s ), l.w ), l.m );\n  l.lowest = min( min( min( min( l.n, l.e ), l.s ), l.w ), l.m );\n  l.contrast = l.highest - l.lowest;\n  return l;\n}\n\nbool ShouldSkipPixel( LuminanceData l ) {\n  float threshold = max( _ContrastThreshold, _RelativeThreshold * l.highest );\n  return l.contrast < threshold;\n}\n\nfloat DeterminePixelBlendFactor( LuminanceData l ) {\n  float f = 2.0 * ( l.n + l.e + l.s + l.w );\n  f += l.ne + l.nw + l.se + l.sw;\n  f *= 1.0 / 12.0;\n  f = abs( f - l.m );\n  f = clamp( f / l.contrast, 0.0, 1.0 );\n\n  float blendFactor = smoothstep( 0.0, 1.0, f );\n  return blendFactor * blendFactor * _SubpixelBlending;\n}\n\nstruct EdgeData {\n  bool isHorizontal;\n  float pixelStep;\n  float oppositeLuminance, gradient;\n};\n\nEdgeData DetermineEdge( vec2 texSize, LuminanceData l ) {\n  EdgeData e;\n  float horizontal =\n    abs( l.n + l.s - 2.0 * l.m ) * 2.0 +\n    abs( l.ne + l.se - 2.0 * l.e ) +\n    abs( l.nw + l.sw - 2.0 * l.w );\n  float vertical =\n    abs( l.e + l.w - 2.0 * l.m ) * 2.0 +\n    abs( l.ne + l.nw - 2.0 * l.n ) +\n    abs( l.se + l.sw - 2.0 * l.s );\n  e.isHorizontal = horizontal >= vertical;\n\n  float pLuminance = e.isHorizontal ? l.n : l.e;\n  float nLuminance = e.isHorizontal ? l.s : l.w;\n  float pGradient = abs( pLuminance - l.m );\n  float nGradient = abs( nLuminance - l.m );\n\n  e.pixelStep = e.isHorizontal ? texSize.y : texSize.x;\n\n  if (pGradient < nGradient) {\n    e.pixelStep = -e.pixelStep;\n    e.oppositeLuminance = nLuminance;\n    e.gradient = nGradient;\n  } else {\n    e.oppositeLuminance = pLuminance;\n    e.gradient = pGradient;\n  }\n\n  return e;\n}\n\nfloat DetermineEdgeBlendFactor( sampler2D tex2D, vec2 texSize, LuminanceData l, EdgeData e, vec2 uv ) {\n  vec2 uvEdge = uv;\n  vec2 edgeStep;\n  if (e.isHorizontal) {\n    uvEdge.y += e.pixelStep * 0.5;\n    edgeStep = vec2( texSize.x, 0.0 );\n  } else {\n    uvEdge.x += e.pixelStep * 0.5;\n    edgeStep = vec2( 0.0, texSize.y );\n  }\n\n  float edgeLuminance = ( l.m + e.oppositeLuminance ) * 0.5;\n  float gradientThreshold = e.gradient * 0.25;\n\n  vec2 puv = uvEdge + edgeStep * edgeSteps[0];\n  float pLuminanceDelta = SampleLuminance( tex2D, puv ) - edgeLuminance;\n  bool pAtEnd = abs( pLuminanceDelta ) >= gradientThreshold;\n\n  for ( int i = 1; i < EDGE_STEP_COUNT && !pAtEnd; i++ ) {\n    puv += edgeStep * edgeSteps[i];\n    pLuminanceDelta = SampleLuminance( tex2D, puv ) - edgeLuminance;\n    pAtEnd = abs( pLuminanceDelta ) >= gradientThreshold;\n  }\n\n  if ( !pAtEnd ) {\n    puv += edgeStep * EDGE_GUESS;\n  }\n\n  vec2 nuv = uvEdge - edgeStep * edgeSteps[0];\n  float nLuminanceDelta = SampleLuminance( tex2D, nuv ) - edgeLuminance;\n  bool nAtEnd = abs( nLuminanceDelta ) >= gradientThreshold;\n\n  for ( int i = 1; i < EDGE_STEP_COUNT && !nAtEnd; i++ ) {\n    nuv -= edgeStep * edgeSteps[i];\n    nLuminanceDelta = SampleLuminance( tex2D, nuv ) - edgeLuminance;\n    nAtEnd = abs( nLuminanceDelta ) >= gradientThreshold;\n  }\n\n  if ( !nAtEnd ) {\n    nuv -= edgeStep * EDGE_GUESS;\n  }\n\n  float pDistance, nDistance;\n  if ( e.isHorizontal ) {\n    pDistance = puv.x - uv.x;\n    nDistance = uv.x - nuv.x;\n  } else {\n    pDistance = puv.y - uv.y;\n    nDistance = uv.y - nuv.y;\n  }\n\n  float shortestDistance;\n  bool deltaSign;\n  if ( pDistance <= nDistance ) {\n    shortestDistance = pDistance;\n    deltaSign = pLuminanceDelta >= 0.0;\n  } else {\n    shortestDistance = nDistance;\n    deltaSign = nLuminanceDelta >= 0.0;\n  }\n\n  if ( deltaSign == ( l.m - edgeLuminance >= 0.0 ) ) {\n    return 0.0;\n  }\n\n  return 0.5 - shortestDistance / ( pDistance + nDistance );\n}\n\nvec4 ApplyFXAA( sampler2D tex2D, vec2 texSize, vec2 uv ) {\n  LuminanceData luminance = SampleLuminanceNeighborhood( tex2D, texSize, uv );\n  if ( ShouldSkipPixel( luminance ) ) {\n    return Sample( tex2D, uv );\n  }\n\n  float pixelBlend = DeterminePixelBlendFactor( luminance );\n  EdgeData edge = DetermineEdge( texSize, luminance );\n  float edgeBlend = DetermineEdgeBlendFactor( tex2D, texSize, luminance, edge, uv );\n  float finalBlend = max( pixelBlend, edgeBlend );\n\n  if (edge.isHorizontal) {\n    uv.y += edge.pixelStep * finalBlend;\n  } else {\n    uv.x += edge.pixelStep * finalBlend;\n  }\n\n  return Sample( tex2D, uv );\n}\n\n\n\nfloat linearizeDepth(float d, float n, float f, bool ortho) {\n  float z = d * 2.0 - 1.0;\n  return ortho ? mix(n, f, d) : (2.0 * n * f) / (f + n - z * (f - n));\n}\n\nuvec2 pcg2d(uvec2 v) {\n  v = v * 1664525u + 1013904223u;\n  v.x += v.y * 1664525u;\n  v.y += v.x * 1664525u;\n  v ^= v >> 16u;\n  v.x += v.y * 1664525u;\n  v.y += v.x * 1664525u;\n  v ^= v >> 16u;\n  return v;\n}\n\n// Triangular-PDF dither: (rand0 + rand1 - 1) / 255 \u2192 \u00B11 LSB of 8-bit output.\nfloat triangularDither(vec2 fragCoord, float frame) {\n  uvec2 seed = uvec2(fragCoord) + uvec2(uint(frame) * 747796405u);\n  vec2 rand = vec2(pcg2d(seed)) / 4294967296.0;\n  return (rand.x + rand.y - 1.0) / 255.0;\n}\n\n\nfloat luma709(vec3 c) { return dot(c, vec3(0.2126, 0.7152, 0.0722)); }\n\nvec3 rcas(sampler2D tex, vec2 uv, vec2 texel, float sharpness) {\n  // FSR1 RCAS: single-pass adaptive sharpen over the 4-ring neighbourhood.\n  vec3 e = texture(tex, uv).rgb;\n  vec3 cross = (\n    texture(tex, uv + vec2(0.0, -texel.y)).rgb +\n    texture(tex, uv + vec2(0.0, texel.y)).rgb +\n    texture(tex, uv + vec2(-texel.x, 0.0)).rgb +\n    texture(tex, uv + vec2(texel.x, 0.0)).rgb\n  ) * 0.25;\n  float sharp = min(sharpness, 0.25);\n  return clamp(e + (e - cross) * sharp, 0.0, 1.0);\n}\n\nfloat filmGrain(vec2 fragCoord, float frame, float intensity, float size, float luminanceResponse, float lumaValue) {\n  uvec2 seed = uvec2(fragCoord * size) + uvec2(uint(frame) * 747796405u);\n  vec2 rnd = vec2(pcg2d(seed)) / 4294967296.0;\n  return (rnd.x - 0.5) * intensity * mix(1.0, 1.0 - lumaValue, luminanceResponse);\n}\n\n\nvec4 sampleGraded(sampler2D tex, vec2 uv) {\n  vec4 c = texture(tex, uv);\n  vec3 disp = c.rgb;\n  if (u_hasLut != 0) {\n    disp = texture(u_lut3d, clamp(disp, 0.0, 1.0)).rgb;\n  }\n  if (u_vignetteIntensity > 0.0) {\n    vec2 p = (uv - 0.5) * 2.0;\n    p.x *= (u_resolution.x / u_resolution.y) * u_vignetteRoundness;\n    float len = length(p) * u_vignetteIntensity;\n    disp *= mix(vec3(1.0), u_vignetteColor, pow(clamp(len, 0.0, 1.0), u_vignetteSmoothness));\n  }\n  return vec4(disp, luma709(disp));\n}\n\nvoid main() {\n  vec2 uv = gl_FragCoord.xy * u_outputTexel;\n  vec4 color = ApplyFXAA(u_source, u_texelSize, uv);\n  vec3 disp = color.rgb;\n  disp += filmGrain(gl_FragCoord.xy, u_frame, u_grainIntensity, u_grainSize, u_grainLuminanceResponse, luma709(disp));\n  disp += triangularDither(gl_FragCoord.xy, u_frame);\n  outColor = vec4(clamp(disp, 0.0, 1.0), 1.0);\n}\n";
+//# sourceMappingURL=finalize.glsl.d.ts.map

package/dist/post/shaders/finalize.glsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"finalize.glsl.d.ts","sourceRoot":"","sources":["../../../../../../packages/rendering/src/post/shaders/finalize.glsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AA4BH,eAAO,MAAM,aAAa,owEAuBzB,CAAC;AAEF,eAAO,MAAM,wBAAwB,2uSAwDpC,CAAC"}

package/dist/post/shaders/finalize.glsl.js

@@ -0,0 +1,120 @@
+/**
+ * PRD-03 §6.1 S12 / §8.15 — the finalize pass.
+ *
+ * Writes the default framebuffer: film grain (display space, luma-gated by
+ * `luminanceResponse`), then FSR1 RCAS sharpening when TAA sharpness > 0 or
+ * renderScale < 1 (limit 0.25), then the triangular-PDF dither — the last
+ * write to the 8-bit output.
+ *
+ * `FINALIZE_FXAA_FUSED_GLSL` is the §6.1 fuse: when post-AA is FXAA, S10b
+ * (display LUT + vignette), S11 (r185 FXAA) and S12 collapse into one draw.
+ * The fused program reads luma from `.a` (S10b writes `luma(disp)` there) so
+ * the FXAA taps never re-run the grade — the fix for today's per-tap
+ * `finalColorAt` re-evaluation (`WebGL2Device.ts:3611-3631`).
+ */
+import { POST_COMMON_GLSL } from "./common.glsl.js";
+import { FXAA_185_FNS_GLSL } from "./fxaa.glsl.js";
+const FINALIZE_FNS_GLSL = /* glsl */ `
+float luma709(vec3 c) { return dot(c, vec3(0.2126, 0.7152, 0.0722)); }
+
+vec3 rcas(sampler2D tex, vec2 uv, vec2 texel, float sharpness) {
+  // FSR1 RCAS: single-pass adaptive sharpen over the 4-ring neighbourhood.
+  vec3 e = texture(tex, uv).rgb;
+  vec3 cross = (
+    texture(tex, uv + vec2(0.0, -texel.y)).rgb +
+    texture(tex, uv + vec2(0.0, texel.y)).rgb +
+    texture(tex, uv + vec2(-texel.x, 0.0)).rgb +
+    texture(tex, uv + vec2(texel.x, 0.0)).rgb
+  ) * 0.25;
+  float sharp = min(sharpness, 0.25);
+  return clamp(e + (e - cross) * sharp, 0.0, 1.0);
+}
+
+float filmGrain(vec2 fragCoord, float frame, float intensity, float size, float luminanceResponse, float lumaValue) {
+  uvec2 seed = uvec2(fragCoord * size) + uvec2(uint(frame) * 747796405u);
+  vec2 rnd = vec2(pcg2d(seed)) / 4294967296.0;
+  return (rnd.x - 0.5) * intensity * mix(1.0, 1.0 - lumaValue, luminanceResponse);
+}
+`;
+export const FINALIZE_GLSL = /* glsl */ `#version 300 es
+precision highp float;
+uniform sampler2D u_source;
+uniform vec2 u_texelSize;
+uniform float u_frame;
+uniform float u_grainIntensity;
+uniform float u_grainSize;
+uniform float u_grainLuminanceResponse;
+uniform float u_rcasSharpness;    // 0 disables; FSR1 limit 0.25
+in vec2 v_uv;
+out vec4 outColor;
+
+${POST_COMMON_GLSL}
+${FINALIZE_FNS_GLSL}
+
+void main() {
+  vec3 disp = u_rcasSharpness > 0.0
+    ? rcas(u_source, v_uv, u_texelSize, u_rcasSharpness)
+    : texture(u_source, v_uv).rgb;
+  disp += filmGrain(gl_FragCoord.xy, u_frame, u_grainIntensity, u_grainSize, u_grainLuminanceResponse, luma709(disp));
+  disp += triangularDither(gl_FragCoord.xy, u_frame);
+  outColor = vec4(clamp(disp, 0.0, 1.0), 1.0);
+}
+`;
+export const FINALIZE_FXAA_FUSED_GLSL = /* glsl */ `#version 300 es
+precision highp float;
+// GLSL ES 3.00 has no default precision for sampler3D (CI: "'sampler3D' : No precision specified").
+precision highp sampler3D;
+#define AURA_LUMA_ALPHA 1
+uniform sampler2D u_source;
+uniform sampler3D u_lut3d;
+uniform int u_hasLut;
+uniform vec2 u_texelSize;
+uniform vec2 u_outputTexel;
+uniform float u_frame;
+uniform float u_grainIntensity;
+uniform float u_grainSize;
+uniform float u_grainLuminanceResponse;
+uniform float u_vignetteIntensity;
+uniform float u_vignetteSmoothness;
+uniform float u_vignetteRoundness;
+uniform vec3 u_vignetteColor;
+uniform vec2 u_resolution;
+in vec2 v_uv;
+out vec4 outColor;
+
+// S10b inline: the FXAA taps sample the display-graded source — each tap is
+// one LUT fetch + vignette, not a re-run of the analytic grade. Forward
+// declaration so the AURA_FXAA_SAMPLE hook (inside FXAA_185_FNS_GLSL) resolves.
+vec4 sampleGraded(sampler2D tex, vec2 uv);
+#define AURA_FXAA_SAMPLE(tex, uvSample) sampleGraded(tex, uvSample)
+
+${FXAA_185_FNS_GLSL}
+
+${POST_COMMON_GLSL}
+${FINALIZE_FNS_GLSL}
+
+vec4 sampleGraded(sampler2D tex, vec2 uv) {
+  vec4 c = texture(tex, uv);
+  vec3 disp = c.rgb;
+  if (u_hasLut != 0) {
+    disp = texture(u_lut3d, clamp(disp, 0.0, 1.0)).rgb;
+  }
+  if (u_vignetteIntensity > 0.0) {
+    vec2 p = (uv - 0.5) * 2.0;
+    p.x *= (u_resolution.x / u_resolution.y) * u_vignetteRoundness;
+    float len = length(p) * u_vignetteIntensity;
+    disp *= mix(vec3(1.0), u_vignetteColor, pow(clamp(len, 0.0, 1.0), u_vignetteSmoothness));
+  }
+  return vec4(disp, luma709(disp));
+}
+
+void main() {
+  vec2 uv = gl_FragCoord.xy * u_outputTexel;
+  vec4 color = ApplyFXAA(u_source, u_texelSize, uv);
+  vec3 disp = color.rgb;
+  disp += filmGrain(gl_FragCoord.xy, u_frame, u_grainIntensity, u_grainSize, u_grainLuminanceResponse, luma709(disp));
+  disp += triangularDither(gl_FragCoord.xy, u_frame);
+  outColor = vec4(clamp(disp, 0.0, 1.0), 1.0);
+}
+`;
+//# sourceMappingURL=finalize.glsl.js.map

package/dist/post/shaders/finalize.glsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"finalize.glsl.js","sourceRoot":"","sources":["../../../../../../packages/rendering/src/post/shaders/finalize.glsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AACpD,OAAO,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAEnD,MAAM,iBAAiB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;CAqBpC,CAAC;AAEF,MAAM,CAAC,MAAM,aAAa,GAAG,UAAU,CAAC;;;;;;;;;;;;EAYtC,gBAAgB;EAChB,iBAAiB;;;;;;;;;;CAUlB,CAAC;AAEF,MAAM,CAAC,MAAM,wBAAwB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4BjD,iBAAiB;;EAEjB,gBAAgB;EAChB,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;CAyBlB,CAAC"}

package/dist/post/shaders/finalize.wgsl.d.ts

@@ -0,0 +1,13 @@
+/**
+ * PRD-03 §6.1 S12 / §8.15 Phase 7 — finalize WGSL twins.
+ *
+ * `FINALIZE_WGSL`: film grain (luma-gated), FSR1 RCAS sharpen (limit 0.25),
+ * triangular-PDF dither — the last write to the 8-bit output.
+ * `FINALIZE_FXAA_FUSED_WGSL`: the §6.1 fuse — S10b (LUT + vignette) + S11
+ * r185 FXAA + S12 in one draw; the FXAA taps sample the display-graded
+ * source through the consumer-side `fxaa_sample` hook with
+ * `FXAA_LUMA_ALPHA = 1` (luma rides in `.a`, never re-runs the grade).
+ */
+export declare const FINALIZE_WGSL = "struct FinalizeParams {\n  texel_size: vec2<f32>,\n  frame: f32,\n  grain_intensity: f32,\n  grain_size: f32,\n  grain_luminance_response: f32,\n  rcas_sharpness: f32,     // 0 disables; FSR1 limit 0.25\n  _pad: vec3<f32>,\n};\n\n@group(0) @binding(0) var<uniform> u_params: FinalizeParams;\n@group(0) @binding(1) var u_source_tex: texture_2d<f32>;\n@group(0) @binding(2) var u_source_smp: sampler;\n\n\nfn linearize_depth(d: f32, n: f32, f: f32, ortho: bool) -> f32 {\n  let z = d * 2.0 - 1.0;\n  return select((2.0 * n * f) / (f + n - z * (f - n)), mix(n, f, d), ortho);\n}\n\nfn pcg2d(v_in: vec2<u32>) -> vec2<u32> {\n  var v = v_in * vec2<u32>(1664525u) + vec2<u32>(1013904223u);\n  v.x = v.x + v.y * 1664525u;\n  v.y = v.y + v.x * 1664525u;\n  v = v ^ (v >> vec2<u32>(16u));\n  v.x = v.x + v.y * 1664525u;\n  v.y = v.y + v.x * 1664525u;\n  v = v ^ (v >> vec2<u32>(16u));\n  return v;\n}\n\n// Triangular-PDF dither: (rand0 + rand1 - 1) / 255 \u2192 \u00B11 LSB of 8-bit output.\nfn triangular_dither(frag_coord: vec2<f32>, frame: f32) -> f32 {\n  let seed = vec2<u32>(frag_coord) + vec2<u32>(u32(frame) * 747796405u);\n  let rand = vec2<f32>(pcg2d(seed)) / 4294967296.0;\n  return (rand.x + rand.y - 1.0) / 255.0;\n}\n\n\nfn luma709(c: vec3<f32>) -> f32 { return dot(c, vec3<f32>(0.2126, 0.7152, 0.0722)); }\n\nfn rcas(tex: texture_2d<f32>, smp: sampler, uv: vec2<f32>, texel: vec2<f32>, sharpness: f32) -> vec3<f32> {\n  // FSR1 RCAS: single-pass adaptive sharpen over the 4-ring neighbourhood.\n  let e = textureSampleLevel(tex, smp, uv, 0.0).rgb;\n  let cross = (\n    textureSampleLevel(tex, smp, uv + vec2<f32>(0.0, -texel.y), 0.0).rgb +\n    textureSampleLevel(tex, smp, uv + vec2<f32>(0.0, texel.y), 0.0).rgb +\n    textureSampleLevel(tex, smp, uv + vec2<f32>(-texel.x, 0.0), 0.0).rgb +\n    textureSampleLevel(tex, smp, uv + vec2<f32>(texel.x, 0.0), 0.0).rgb\n  ) * 0.25;\n  let sharp = min(sharpness, 0.25);\n  return clamp(e + (e - cross) * sharp, vec3<f32>(0.0), vec3<f32>(1.0));\n}\n\nfn film_grain(frag_coord: vec2<f32>, frame: f32, intensity: f32, size: f32, luminance_response: f32, luma_value: f32) -> f32 {\n  let seed = vec2<u32>(frag_coord * size) + vec2<u32>(u32(frame) * 747796405u);\n  let rnd = vec2<f32>(pcg2d(seed)) / 4294967296.0;\n  return (rnd.x - 0.5) * intensity * mix(1.0, 1.0 - luma_value, luminance_response);\n}\n\n\n@fragment\nfn fs_finalize(@location(0) uv: vec2<f32>, @builtin(position) frag_coord: vec4<f32>) -> @location(0) vec4<f32> {\n  var disp = select(textureSampleLevel(u_source_tex, u_source_smp, uv, 0.0).rgb,\n                    rcas(u_source_tex, u_source_smp, uv, u_params.texel_size, u_params.rcas_sharpness),\n                    u_params.rcas_sharpness > 0.0);\n  disp = disp + vec3<f32>(film_grain(frag_coord.xy, u_params.frame, u_params.grain_intensity,\n    u_params.grain_size, u_params.grain_luminance_response, luma709(disp)));\n  disp = disp + vec3<f32>(triangular_dither(frag_coord.xy, u_params.frame));\n  return vec4<f32>(clamp(disp, vec3<f32>(0.0), vec3<f32>(1.0)), 1.0);\n}\n";
+export declare const FINALIZE_FXAA_FUSED_WGSL = "// FXAA_LUMA_ALPHA = 1: the FXAA taps read luma from the alpha channel\n// (the S10b grade writes luma(disp) there) \u2014 the fix for the legacy per-tap\n// finalColorAt re-evaluation (WebGL2Device.ts:3611-3631).\noverride FXAA_LUMA_ALPHA: i32 = 1;\n\nstruct FinalizeFusedParams {\n  texel_size: vec2<f32>,\n  output_texel: vec2<f32>,\n  has_lut: i32,\n  frame: f32,\n  grain_intensity: f32,\n  grain_size: f32,\n  grain_luminance_response: f32,\n  vignette_intensity: f32,\n  vignette_smoothness: f32,\n  vignette_roundness: f32,\n  vignette_color: vec3<f32>,\n  _pad0: f32,\n  resolution: vec2<f32>,\n  _pad1: vec2<f32>,\n};\n\n@group(0) @binding(0) var<uniform> u_params: FinalizeFusedParams;\n@group(0) @binding(1) var u_source_tex: texture_2d<f32>;\n@group(0) @binding(2) var u_source_smp: sampler;\n@group(0) @binding(3) var u_lut3d_tex: texture_3d<f32>;\n@group(0) @binding(4) var u_lut3d_smp: sampler;\n\n\nfn linearize_depth(d: f32, n: f32, f: f32, ortho: bool) -> f32 {\n  let z = d * 2.0 - 1.0;\n  return select((2.0 * n * f) / (f + n - z * (f - n)), mix(n, f, d), ortho);\n}\n\nfn pcg2d(v_in: vec2<u32>) -> vec2<u32> {\n  var v = v_in * vec2<u32>(1664525u) + vec2<u32>(1013904223u);\n  v.x = v.x + v.y * 1664525u;\n  v.y = v.y + v.x * 1664525u;\n  v = v ^ (v >> vec2<u32>(16u));\n  v.x = v.x + v.y * 1664525u;\n  v.y = v.y + v.x * 1664525u;\n  v = v ^ (v >> vec2<u32>(16u));\n  return v;\n}\n\n// Triangular-PDF dither: (rand0 + rand1 - 1) / 255 \u2192 \u00B11 LSB of 8-bit output.\nfn triangular_dither(frag_coord: vec2<f32>, frame: f32) -> f32 {\n  let seed = vec2<u32>(frag_coord) + vec2<u32>(u32(frame) * 747796405u);\n  let rand = vec2<f32>(pcg2d(seed)) / 4294967296.0;\n  return (rand.x + rand.y - 1.0) / 255.0;\n}\n\n\nfn luma709(c: vec3<f32>) -> f32 { return dot(c, vec3<f32>(0.2126, 0.7152, 0.0722)); }\n\nfn rcas(tex: texture_2d<f32>, smp: sampler, uv: vec2<f32>, texel: vec2<f32>, sharpness: f32) -> vec3<f32> {\n  // FSR1 RCAS: single-pass adaptive sharpen over the 4-ring neighbourhood.\n  let e = textureSampleLevel(tex, smp, uv, 0.0).rgb;\n  let cross = (\n    textureSampleLevel(tex, smp, uv + vec2<f32>(0.0, -texel.y), 0.0).rgb +\n    textureSampleLevel(tex, smp, uv + vec2<f32>(0.0, texel.y), 0.0).rgb +\n    textureSampleLevel(tex, smp, uv + vec2<f32>(-texel.x, 0.0), 0.0).rgb +\n    textureSampleLevel(tex, smp, uv + vec2<f32>(texel.x, 0.0), 0.0).rgb\n  ) * 0.25;\n  let sharp = min(sharpness, 0.25);\n  return clamp(e + (e - cross) * sharp, vec3<f32>(0.0), vec3<f32>(1.0));\n}\n\nfn film_grain(frag_coord: vec2<f32>, frame: f32, intensity: f32, size: f32, luminance_response: f32, luma_value: f32) -> f32 {\n  let seed = vec2<u32>(frag_coord * size) + vec2<u32>(u32(frame) * 747796405u);\n  let rnd = vec2<f32>(pcg2d(seed)) / 4294967296.0;\n  return (rnd.x - 0.5) * intensity * mix(1.0, 1.0 - luma_value, luminance_response);\n}\n\nconst EDGE_STEP_COUNT: i32 = 6;\nconst EDGE_GUESS: f32 = 8.0;\nconst EDGE_STEPS = array<f32, 6>(1.0, 1.5, 2.0, 2.0, 2.0, 4.0);\n\nconst CONTRAST_THRESHOLD: f32 = 0.0312;\nconst RELATIVE_THRESHOLD: f32 = 0.063;\nconst SUBPIXEL_BLENDING: f32 = 1.0;\n\nfn fxaa_sample_color(tex: texture_2d<f32>, smp: sampler, uv: vec2<f32>) -> vec4<f32> {\n  return fxaa_sample(tex, smp, uv);\n}\n\nfn fxaa_sample_luminance(tex: texture_2d<f32>, smp: sampler, uv: vec2<f32>) -> f32 {\n  if (FXAA_LUMA_ALPHA == 1) {\n    return fxaa_sample(tex, smp, uv).a;\n  }\n  return dot(fxaa_sample_color(tex, smp, uv).rgb, vec3<f32>(0.3, 0.59, 0.11));\n}\n\nfn fxaa_sample_luminance_offset(tex: texture_2d<f32>, smp: sampler, tex_size: vec2<f32>, uv: vec2<f32>, u_offset: f32, v_offset: f32) -> f32 {\n  return fxaa_sample_luminance(tex, smp, uv + tex_size * vec2<f32>(u_offset, v_offset));\n}\n\nstruct LuminanceData {\n  m: f32,\n  n: f32,\n  e: f32,\n  s: f32,\n  w: f32,\n  ne: f32,\n  nw: f32,\n  se: f32,\n  sw: f32,\n  highest: f32,\n  lowest: f32,\n  contrast: f32,\n};\n\nfn sample_luminance_neighborhood(tex: texture_2d<f32>, smp: sampler, tex_size: vec2<f32>, uv: vec2<f32>) -> LuminanceData {\n  var l: LuminanceData;\n  l.m = fxaa_sample_luminance(tex, smp, uv);\n  l.n = fxaa_sample_luminance_offset(tex, smp, tex_size, uv, 0.0, 1.0);\n  l.e = fxaa_sample_luminance_offset(tex, smp, tex_size, uv, 1.0, 0.0);\n  l.s = fxaa_sample_luminance_offset(tex, smp, tex_size, uv, 0.0, -1.0);\n  l.w = fxaa_sample_luminance_offset(tex, smp, tex_size, uv, -1.0, 0.0);\n\n  l.ne = fxaa_sample_luminance_offset(tex, smp, tex_size, uv, 1.0, 1.0);\n  l.nw = fxaa_sample_luminance_offset(tex, smp, tex_size, uv, -1.0, 1.0);\n  l.se = fxaa_sample_luminance_offset(tex, smp, tex_size, uv, 1.0, -1.0);\n  l.sw = fxaa_sample_luminance_offset(tex, smp, tex_size, uv, -1.0, -1.0);\n\n  l.highest = max(max(max(max(l.n, l.e), l.s), l.w), l.m);\n  l.lowest = min(min(min(min(l.n, l.e), l.s), l.w), l.m);\n  l.contrast = l.highest - l.lowest;\n  return l;\n}\n\nfn should_skip_pixel(l: LuminanceData) -> bool {\n  let threshold = max(CONTRAST_THRESHOLD, RELATIVE_THRESHOLD * l.highest);\n  return l.contrast < threshold;\n}\n\nfn determine_pixel_blend_factor(l: LuminanceData) -> f32 {\n  var f = 2.0 * (l.n + l.e + l.s + l.w);\n  f = f + l.ne + l.nw + l.se + l.sw;\n  f = f * (1.0 / 12.0);\n  f = abs(f - l.m);\n  f = clamp(f / l.contrast, 0.0, 1.0);\n\n  let blend_factor = smoothstep(0.0, 1.0, f);\n  return blend_factor * blend_factor * SUBPIXEL_BLENDING;\n}\n\nstruct EdgeData {\n  is_horizontal: bool,\n  pixel_step: f32,\n  opposite_luminance: f32,\n  gradient: f32,\n};\n\nfn determine_edge(tex_size: vec2<f32>, l: LuminanceData) -> EdgeData {\n  var e: EdgeData;\n  let horizontal =\n    abs(l.n + l.s - 2.0 * l.m) * 2.0 +\n    abs(l.ne + l.se - 2.0 * l.e) +\n    abs(l.nw + l.sw - 2.0 * l.w);\n  let vertical =\n    abs(l.e + l.w - 2.0 * l.m) * 2.0 +\n    abs(l.ne + l.nw - 2.0 * l.n) +\n    abs(l.se + l.sw - 2.0 * l.s);\n  e.is_horizontal = horizontal >= vertical;\n\n  let p_luminance = select(l.e, l.n, e.is_horizontal);\n  let n_luminance = select(l.w, l.s, e.is_horizontal);\n  let p_gradient = abs(p_luminance - l.m);\n  let n_gradient = abs(n_luminance - l.m);\n\n  e.pixel_step = select(tex_size.x, tex_size.y, e.is_horizontal);\n\n  if (p_gradient < n_gradient) {\n    e.pixel_step = -e.pixel_step;\n    e.opposite_luminance = n_luminance;\n    e.gradient = n_gradient;\n  } else {\n    e.opposite_luminance = p_luminance;\n    e.gradient = p_gradient;\n  }\n\n  return e;\n}\n\nfn determine_edge_blend_factor(tex: texture_2d<f32>, smp: sampler, tex_size: vec2<f32>, l: LuminanceData, e: EdgeData, uv: vec2<f32>) -> f32 {\n  var uv_edge = uv;\n  var edge_step: vec2<f32>;\n  if (e.is_horizontal) {\n    uv_edge.y = uv_edge.y + e.pixel_step * 0.5;\n    edge_step = vec2<f32>(tex_size.x, 0.0);\n  } else {\n    uv_edge.x = uv_edge.x + e.pixel_step * 0.5;\n    edge_step = vec2<f32>(0.0, tex_size.y);\n  }\n\n  let edge_luminance = (l.m + e.opposite_luminance) * 0.5;\n  let gradient_threshold = e.gradient * 0.25;\n\n  var puv = uv_edge + edge_step * EDGE_STEPS[0];\n  var p_luminance_delta = fxaa_sample_luminance(tex, smp, puv) - edge_luminance;\n  var p_at_end = abs(p_luminance_delta) >= gradient_threshold;\n\n  for (var i = 1; i < EDGE_STEP_COUNT && !p_at_end; i = i + 1) {\n    puv = puv + edge_step * EDGE_STEPS[i];\n    p_luminance_delta = fxaa_sample_luminance(tex, smp, puv) - edge_luminance;\n    p_at_end = abs(p_luminance_delta) >= gradient_threshold;\n  }\n\n  if (!p_at_end) {\n    puv = puv + edge_step * EDGE_GUESS;\n  }\n\n  var nuv = uv_edge - edge_step * EDGE_STEPS[0];\n  var n_luminance_delta = fxaa_sample_luminance(tex, smp, nuv) - edge_luminance;\n  var n_at_end = abs(n_luminance_delta) >= gradient_threshold;\n\n  for (var i = 1; i < EDGE_STEP_COUNT && !n_at_end; i = i + 1) {\n    nuv = nuv - edge_step * EDGE_STEPS[i];\n    n_luminance_delta = fxaa_sample_luminance(tex, smp, nuv) - edge_luminance;\n    n_at_end = abs(n_luminance_delta) >= gradient_threshold;\n  }\n\n  if (!n_at_end) {\n    nuv = nuv - edge_step * EDGE_GUESS;\n  }\n\n  var p_distance: f32;\n  var n_distance: f32;\n  if (e.is_horizontal) {\n    p_distance = puv.x - uv.x;\n    n_distance = uv.x - nuv.x;\n  } else {\n    p_distance = puv.y - uv.y;\n    n_distance = uv.y - nuv.y;\n  }\n\n  var shortest_distance: f32;\n  var delta_sign: bool;\n  if (p_distance <= n_distance) {\n    shortest_distance = p_distance;\n    delta_sign = p_luminance_delta >= 0.0;\n  } else {\n    shortest_distance = n_distance;\n    delta_sign = n_luminance_delta >= 0.0;\n  }\n\n  if (delta_sign == (l.m - edge_luminance >= 0.0)) {\n    return 0.0;\n  }\n\n  return 0.5 - shortest_distance / (p_distance + n_distance);\n}\n\nfn apply_fxaa(tex: texture_2d<f32>, smp: sampler, tex_size: vec2<f32>, uv_in: vec2<f32>) -> vec4<f32> {\n  let luminance = sample_luminance_neighborhood(tex, smp, tex_size, uv_in);\n  if (should_skip_pixel(luminance)) {\n    return fxaa_sample_color(tex, smp, uv_in);\n  }\n\n  let pixel_blend = determine_pixel_blend_factor(luminance);\n  let edge = determine_edge(tex_size, luminance);\n  let edge_blend = determine_edge_blend_factor(tex, smp, tex_size, luminance, edge, uv_in);\n  let final_blend = max(pixel_blend, edge_blend);\n\n  var uv = uv_in;\n  if (edge.is_horizontal) {\n    uv.y = uv.y + edge.pixel_step * final_blend;\n  } else {\n    uv.x = uv.x + edge.pixel_step * final_blend;\n  }\n\n  return fxaa_sample_color(tex, smp, uv);\n}\n\n\n// S10b inline: the FXAA taps sample the display-graded source \u2014 each tap is\n// one LUT fetch + vignette, not a re-run of the analytic grade. This is the\n// consumer-side fxaa_sample hook the shared FXAA set resolves against.\nfn fxaa_sample(tex: texture_2d<f32>, smp: sampler, uv: vec2<f32>) -> vec4<f32> {\n  let c = textureSampleLevel(tex, smp, uv, 0.0);\n  var disp = c.rgb;\n  if (u_params.has_lut != 0) {\n    disp = textureSampleLevel(u_lut3d_tex, u_lut3d_smp, clamp(disp, vec3<f32>(0.0), vec3<f32>(1.0)), 0.0).rgb;\n  }\n  if (u_params.vignette_intensity > 0.0) {\n    var p = (uv - vec2<f32>(0.5)) * 2.0;\n    p.x = p.x * (u_params.resolution.x / u_params.resolution.y) * u_params.vignette_roundness;\n    let len = length(p) * u_params.vignette_intensity;\n    disp = disp * mix(vec3<f32>(1.0), u_params.vignette_color, pow(clamp(len, 0.0, 1.0), u_params.vignette_smoothness));\n  }\n  return vec4<f32>(disp, luma709(disp));\n}\n\n@fragment\nfn fs_finalize_fxaa_fused(@builtin(position) frag_coord: vec4<f32>) -> @location(0) vec4<f32> {\n  let uv = frag_coord.xy * u_params.output_texel;\n  let color = apply_fxaa(u_source_tex, u_source_smp, u_params.texel_size, uv);\n  var disp = color.rgb;\n  disp = disp + vec3<f32>(film_grain(frag_coord.xy, u_params.frame, u_params.grain_intensity,\n    u_params.grain_size, u_params.grain_luminance_response, luma709(disp)));\n  disp = disp + vec3<f32>(triangular_dither(frag_coord.xy, u_params.frame));\n  return vec4<f32>(clamp(disp, vec3<f32>(0.0), vec3<f32>(1.0)), 1.0);\n}\n";
+//# sourceMappingURL=finalize.wgsl.d.ts.map

package/dist/post/shaders/finalize.wgsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"finalize.wgsl.d.ts","sourceRoot":"","sources":["../../../../../../packages/rendering/src/post/shaders/finalize.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AA4BH,eAAO,MAAM,aAAa,2+FA2BzB,CAAC;AAEF,eAAO,MAAM,wBAAwB,8rVA4DpC,CAAC"}

package/dist/post/shaders/finalize.wgsl.js

@@ -0,0 +1,124 @@
+/**
+ * PRD-03 §6.1 S12 / §8.15 Phase 7 — finalize WGSL twins.
+ *
+ * `FINALIZE_WGSL`: film grain (luma-gated), FSR1 RCAS sharpen (limit 0.25),
+ * triangular-PDF dither — the last write to the 8-bit output.
+ * `FINALIZE_FXAA_FUSED_WGSL`: the §6.1 fuse — S10b (LUT + vignette) + S11
+ * r185 FXAA + S12 in one draw; the FXAA taps sample the display-graded
+ * source through the consumer-side `fxaa_sample` hook with
+ * `FXAA_LUMA_ALPHA = 1` (luma rides in `.a`, never re-runs the grade).
+ */
+import { FXAA_185_FNS_WGSL } from "./fxaa.wgsl.js";
+import { POST_COMMON_WGSL } from "./common.wgsl.js";
+const FINALIZE_FNS_WGSL = /* wgsl */ `
+fn luma709(c: vec3<f32>) -> f32 { return dot(c, vec3<f32>(0.2126, 0.7152, 0.0722)); }
+
+fn rcas(tex: texture_2d<f32>, smp: sampler, uv: vec2<f32>, texel: vec2<f32>, sharpness: f32) -> vec3<f32> {
+  // FSR1 RCAS: single-pass adaptive sharpen over the 4-ring neighbourhood.
+  let e = textureSampleLevel(tex, smp, uv, 0.0).rgb;
+  let cross = (
+    textureSampleLevel(tex, smp, uv + vec2<f32>(0.0, -texel.y), 0.0).rgb +
+    textureSampleLevel(tex, smp, uv + vec2<f32>(0.0, texel.y), 0.0).rgb +
+    textureSampleLevel(tex, smp, uv + vec2<f32>(-texel.x, 0.0), 0.0).rgb +
+    textureSampleLevel(tex, smp, uv + vec2<f32>(texel.x, 0.0), 0.0).rgb
+  ) * 0.25;
+  let sharp = min(sharpness, 0.25);
+  return clamp(e + (e - cross) * sharp, vec3<f32>(0.0), vec3<f32>(1.0));
+}
+
+fn film_grain(frag_coord: vec2<f32>, frame: f32, intensity: f32, size: f32, luminance_response: f32, luma_value: f32) -> f32 {
+  let seed = vec2<u32>(frag_coord * size) + vec2<u32>(u32(frame) * 747796405u);
+  let rnd = vec2<f32>(pcg2d(seed)) / 4294967296.0;
+  return (rnd.x - 0.5) * intensity * mix(1.0, 1.0 - luma_value, luminance_response);
+}
+`;
+export const FINALIZE_WGSL = /* wgsl */ `struct FinalizeParams {
+  texel_size: vec2<f32>,
+  frame: f32,
+  grain_intensity: f32,
+  grain_size: f32,
+  grain_luminance_response: f32,
+  rcas_sharpness: f32,     // 0 disables; FSR1 limit 0.25
+  _pad: vec3<f32>,
+};
+
+@group(0) @binding(0) var<uniform> u_params: FinalizeParams;
+@group(0) @binding(1) var u_source_tex: texture_2d<f32>;
+@group(0) @binding(2) var u_source_smp: sampler;
+
+${POST_COMMON_WGSL}
+${FINALIZE_FNS_WGSL}
+
+@fragment
+fn fs_finalize(@location(0) uv: vec2<f32>, @builtin(position) frag_coord: vec4<f32>) -> @location(0) vec4<f32> {
+  var disp = select(textureSampleLevel(u_source_tex, u_source_smp, uv, 0.0).rgb,
+                    rcas(u_source_tex, u_source_smp, uv, u_params.texel_size, u_params.rcas_sharpness),
+                    u_params.rcas_sharpness > 0.0);
+  disp = disp + vec3<f32>(film_grain(frag_coord.xy, u_params.frame, u_params.grain_intensity,
+    u_params.grain_size, u_params.grain_luminance_response, luma709(disp)));
+  disp = disp + vec3<f32>(triangular_dither(frag_coord.xy, u_params.frame));
+  return vec4<f32>(clamp(disp, vec3<f32>(0.0), vec3<f32>(1.0)), 1.0);
+}
+`;
+export const FINALIZE_FXAA_FUSED_WGSL = /* wgsl */ `// FXAA_LUMA_ALPHA = 1: the FXAA taps read luma from the alpha channel
+// (the S10b grade writes luma(disp) there) — the fix for the legacy per-tap
+// finalColorAt re-evaluation (WebGL2Device.ts:3611-3631).
+override FXAA_LUMA_ALPHA: i32 = 1;
+
+struct FinalizeFusedParams {
+  texel_size: vec2<f32>,
+  output_texel: vec2<f32>,
+  has_lut: i32,
+  frame: f32,
+  grain_intensity: f32,
+  grain_size: f32,
+  grain_luminance_response: f32,
+  vignette_intensity: f32,
+  vignette_smoothness: f32,
+  vignette_roundness: f32,
+  vignette_color: vec3<f32>,
+  _pad0: f32,
+  resolution: vec2<f32>,
+  _pad1: vec2<f32>,
+};
+
+@group(0) @binding(0) var<uniform> u_params: FinalizeFusedParams;
+@group(0) @binding(1) var u_source_tex: texture_2d<f32>;
+@group(0) @binding(2) var u_source_smp: sampler;
+@group(0) @binding(3) var u_lut3d_tex: texture_3d<f32>;
+@group(0) @binding(4) var u_lut3d_smp: sampler;
+
+${POST_COMMON_WGSL}
+${FINALIZE_FNS_WGSL}
+${FXAA_185_FNS_WGSL}
+
+// S10b inline: the FXAA taps sample the display-graded source — each tap is
+// one LUT fetch + vignette, not a re-run of the analytic grade. This is the
+// consumer-side fxaa_sample hook the shared FXAA set resolves against.
+fn fxaa_sample(tex: texture_2d<f32>, smp: sampler, uv: vec2<f32>) -> vec4<f32> {
+  let c = textureSampleLevel(tex, smp, uv, 0.0);
+  var disp = c.rgb;
+  if (u_params.has_lut != 0) {
+    disp = textureSampleLevel(u_lut3d_tex, u_lut3d_smp, clamp(disp, vec3<f32>(0.0), vec3<f32>(1.0)), 0.0).rgb;
+  }
+  if (u_params.vignette_intensity > 0.0) {
+    var p = (uv - vec2<f32>(0.5)) * 2.0;
+    p.x = p.x * (u_params.resolution.x / u_params.resolution.y) * u_params.vignette_roundness;
+    let len = length(p) * u_params.vignette_intensity;
+    disp = disp * mix(vec3<f32>(1.0), u_params.vignette_color, pow(clamp(len, 0.0, 1.0), u_params.vignette_smoothness));
+  }
+  return vec4<f32>(disp, luma709(disp));
+}
+
+@fragment
+fn fs_finalize_fxaa_fused(@builtin(position) frag_coord: vec4<f32>) -> @location(0) vec4<f32> {
+  let uv = frag_coord.xy * u_params.output_texel;
+  let color = apply_fxaa(u_source_tex, u_source_smp, u_params.texel_size, uv);
+  var disp = color.rgb;
+  disp = disp + vec3<f32>(film_grain(frag_coord.xy, u_params.frame, u_params.grain_intensity,
+    u_params.grain_size, u_params.grain_luminance_response, luma709(disp)));
+  disp = disp + vec3<f32>(triangular_dither(frag_coord.xy, u_params.frame));
+  return vec4<f32>(clamp(disp, vec3<f32>(0.0), vec3<f32>(1.0)), 1.0);
+}
+`;
+//# sourceMappingURL=finalize.wgsl.js.map

package/dist/post/shaders/finalize.wgsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"finalize.wgsl.js","sourceRoot":"","sources":["../../../../../../packages/rendering/src/post/shaders/finalize.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AACnD,OAAO,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAEpD,MAAM,iBAAiB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;CAqBpC,CAAC;AAEF,MAAM,CAAC,MAAM,aAAa,GAAG,UAAU,CAAC;;;;;;;;;;;;;;EActC,gBAAgB;EAChB,iBAAiB;;;;;;;;;;;;CAYlB,CAAC;AAEF,MAAM,CAAC,MAAM,wBAAwB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4BjD,gBAAgB;EAChB,iBAAiB;EACjB,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8BlB,CAAC"}