@aura3d/engine 3.0.0 → 4.0.0

package/dist/rendering/post/shaders/displayGrade.glsl.js

@@ -0,0 +1,80 @@
+/**
+ * PRD-03 §6.7 S10b — the display-grade fetch, fused into S11/S12.
+ *
+ * Runs after the OutputPass boundary on display-referred RGBA8: one
+ * trilinear `texture(u_lut3d, disp)` fetch applies contrast / saturation /
+ * vibrance / the user `.cube`, then vignette (roundness-aspect corrected).
+ * Output alpha carries `luma(disp)` so the S11 FXAA pass reads luminance
+ * from `.a` instead of recomputing it per tap.
+ */
+export const DISPLAY_GRADE_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;
+uniform sampler2D u_source;
+uniform sampler3D u_lut3d;
+uniform int u_hasLut;
+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;
+
+float luma(vec3 c) { return dot(c, vec3(0.2126, 0.7152, 0.0722)); }
+
+void main() {
+  vec3 disp = texture(u_source, v_uv).rgb;
+  if (u_hasLut != 0) {
+    disp = texture(u_lut3d, clamp(disp, 0.0, 1.0)).rgb;
+  }
+  if (u_vignetteIntensity > 0.0) {
+    // §8.12: roundness-aspect corrected len, mix toward vignetteColor.
+    vec2 p = (v_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));
+  }
+  outColor = vec4(disp, luma(disp));
+}
+`;
+/**
+ * Display-grade bake: one draw per slice into the 65³ RGBA8 TEXTURE_3D with
+ * `framebufferTextureLayer`. Applies contrast (pivot 0.5), saturation,
+ * vibrance and the optional user `.cube` sample, in the display domain —
+ * the same math the analytic grade would apply per pixel.
+ */
+export const LUT_BAKE_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;
+uniform sampler3D u_userLut;
+uniform int u_hasUserLut;
+uniform float u_lutIntensity;
+uniform float u_contrast;
+uniform float u_saturation;
+uniform float u_vibrance;
+uniform float u_slice;          // b texel, [0,1]
+in vec2 v_uv;
+out vec4 outColor;
+
+float luma(vec3 c) { return dot(c, vec3(0.2126, 0.7152, 0.0722)); }
+
+void main() {
+  vec3 disp = vec3(v_uv, u_slice);
+  // Contrast, pivot 0.5 — same shape as the legacy present grade.
+  vec3 graded = clamp(disp * u_contrast + vec3(0.5 - 0.5 * u_contrast), 0.0, 1.0);
+  // Vibrance: boost scales with distance from luma, folded into saturation
+  // (verbatim from the legacy present grade).
+  float l = luma(graded);
+  float distanceFromLuma = min(1.0, abs(graded.r - l) + abs(graded.g - l) + abs(graded.b - l));
+  float sat = u_saturation + (u_vibrance == 0.0 ? 0.0 : u_vibrance * (1.0 - distanceFromLuma));
+  graded = clamp(vec3(l) + (graded - vec3(l)) * sat, 0.0, 1.0);
+  if (u_hasUserLut != 0) {
+    graded = mix(graded, texture(u_userLut, graded).rgb, clamp(u_lutIntensity, 0.0, 1.0));
+  }
+  outColor = vec4(graded, 1.0);
+}
+`;
+//# sourceMappingURL=displayGrade.glsl.js.map

package/dist/rendering/post/shaders/displayGrade.glsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"displayGrade.glsl.js","sourceRoot":"","sources":["../../../../../../packages/rendering/src/post/shaders/displayGrade.glsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,MAAM,CAAC,MAAM,kBAAkB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+B5C,CAAC;AAEF;;;;;GAKG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+BvC,CAAC"}

package/dist/rendering/post/shaders/displayGrade.wgsl.d.ts

@@ -0,0 +1,9 @@
+/**
+ * PRD-03 §6.7 S10b Phase 7 — display-grade WGSL twins.
+ * DISPLAY_GRADE: trilinear 33³ LUT + vignette on display-referred rgba8;
+ * alpha carries `luma(disp)` so S11 FXAA reads luminance from `.a`.
+ * LUT_BAKE: per-slice grade bake into the TEXTURE_3D.
+ */
+export declare const DISPLAY_GRADE_WGSL = "struct DisplayGradeParams {\n  has_lut: i32,\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: DisplayGradeParams;\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\nfn display_luma(c: vec3<f32>) -> f32 { return dot(c, vec3<f32>(0.2126, 0.7152, 0.0722)); }\n\n@fragment\nfn fs_display_grade(@location(0) uv: vec2<f32>) -> @location(0) vec4<f32> {\n  var disp = textureSampleLevel(u_source_tex, u_source_smp, uv, 0.0).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    // \u00A78.12: roundness-aspect corrected len, mix toward vignetteColor.\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, display_luma(disp));\n}\n";
+export declare const LUT_BAKE_WGSL = "struct LutBakeParams {\n  has_user_lut: i32,\n  lut_intensity: f32,\n  contrast: f32,\n  saturation: f32,\n  vibrance: f32,\n  slice: f32,              // b texel, [0,1]\n  _pad: vec2<f32>,\n};\n\n@group(0) @binding(0) var<uniform> u_params: LutBakeParams;\n@group(0) @binding(1) var u_user_lut_tex: texture_3d<f32>;\n@group(0) @binding(2) var u_user_lut_smp: sampler;\n\nfn display_luma(c: vec3<f32>) -> f32 { return dot(c, vec3<f32>(0.2126, 0.7152, 0.0722)); }\n\n@fragment\nfn fs_lut_bake(@location(0) uv: vec2<f32>) -> @location(0) vec4<f32> {\n  let disp = vec3<f32>(uv, u_params.slice);\n  // Contrast, pivot 0.5 \u2014 same shape as the legacy present grade.\n  var graded = clamp(disp * u_params.contrast + vec3<f32>(0.5 - 0.5 * u_params.contrast), vec3<f32>(0.0), vec3<f32>(1.0));\n  // Vibrance: boost scales with distance from luma, folded into saturation\n  // (verbatim from the legacy present grade).\n  let l = display_luma(graded);\n  let distance_from_luma = min(1.0, abs(graded.r - l) + abs(graded.g - l) + abs(graded.b - l));\n  let sat = u_params.saturation + select(u_params.vibrance * (1.0 - distance_from_luma), 0.0, u_params.vibrance == 0.0);\n  graded = clamp(vec3<f32>(l) + (graded - vec3<f32>(l)) * sat, vec3<f32>(0.0), vec3<f32>(1.0));\n  if (u_params.has_user_lut != 0) {\n    graded = mix(graded, textureSampleLevel(u_user_lut_tex, u_user_lut_smp, graded, 0.0).rgb, clamp(u_params.lut_intensity, 0.0, 1.0));\n  }\n  return vec4<f32>(graded, 1.0);\n}\n";
+//# sourceMappingURL=displayGrade.wgsl.d.ts.map

package/dist/rendering/post/shaders/displayGrade.wgsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"displayGrade.wgsl.d.ts","sourceRoot":"","sources":["../../../../../../packages/rendering/src/post/shaders/displayGrade.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,eAAO,MAAM,kBAAkB,u4CAkC9B,CAAC;AAEF,eAAO,MAAM,aAAa,88CAgCzB,CAAC"}

package/dist/rendering/post/shaders/displayGrade.wgsl.js

@@ -0,0 +1,75 @@
+/**
+ * PRD-03 §6.7 S10b Phase 7 — display-grade WGSL twins.
+ * DISPLAY_GRADE: trilinear 33³ LUT + vignette on display-referred rgba8;
+ * alpha carries `luma(disp)` so S11 FXAA reads luminance from `.a`.
+ * LUT_BAKE: per-slice grade bake into the TEXTURE_3D.
+ */
+export const DISPLAY_GRADE_WGSL = /* wgsl */ `struct DisplayGradeParams {
+  has_lut: i32,
+  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: DisplayGradeParams;
+@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;
+
+fn display_luma(c: vec3<f32>) -> f32 { return dot(c, vec3<f32>(0.2126, 0.7152, 0.0722)); }
+
+@fragment
+fn fs_display_grade(@location(0) uv: vec2<f32>) -> @location(0) vec4<f32> {
+  var disp = textureSampleLevel(u_source_tex, u_source_smp, uv, 0.0).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) {
+    // §8.12: roundness-aspect corrected len, mix toward vignetteColor.
+    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, display_luma(disp));
+}
+`;
+export const LUT_BAKE_WGSL = /* wgsl */ `struct LutBakeParams {
+  has_user_lut: i32,
+  lut_intensity: f32,
+  contrast: f32,
+  saturation: f32,
+  vibrance: f32,
+  slice: f32,              // b texel, [0,1]
+  _pad: vec2<f32>,
+};
+
+@group(0) @binding(0) var<uniform> u_params: LutBakeParams;
+@group(0) @binding(1) var u_user_lut_tex: texture_3d<f32>;
+@group(0) @binding(2) var u_user_lut_smp: sampler;
+
+fn display_luma(c: vec3<f32>) -> f32 { return dot(c, vec3<f32>(0.2126, 0.7152, 0.0722)); }
+
+@fragment
+fn fs_lut_bake(@location(0) uv: vec2<f32>) -> @location(0) vec4<f32> {
+  let disp = vec3<f32>(uv, u_params.slice);
+  // Contrast, pivot 0.5 — same shape as the legacy present grade.
+  var graded = clamp(disp * u_params.contrast + vec3<f32>(0.5 - 0.5 * u_params.contrast), vec3<f32>(0.0), vec3<f32>(1.0));
+  // Vibrance: boost scales with distance from luma, folded into saturation
+  // (verbatim from the legacy present grade).
+  let l = display_luma(graded);
+  let distance_from_luma = min(1.0, abs(graded.r - l) + abs(graded.g - l) + abs(graded.b - l));
+  let sat = u_params.saturation + select(u_params.vibrance * (1.0 - distance_from_luma), 0.0, u_params.vibrance == 0.0);
+  graded = clamp(vec3<f32>(l) + (graded - vec3<f32>(l)) * sat, vec3<f32>(0.0), vec3<f32>(1.0));
+  if (u_params.has_user_lut != 0) {
+    graded = mix(graded, textureSampleLevel(u_user_lut_tex, u_user_lut_smp, graded, 0.0).rgb, clamp(u_params.lut_intensity, 0.0, 1.0));
+  }
+  return vec4<f32>(graded, 1.0);
+}
+`;
+//# sourceMappingURL=displayGrade.wgsl.js.map

package/dist/rendering/post/shaders/displayGrade.wgsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"displayGrade.wgsl.js","sourceRoot":"","sources":["../../../../../../packages/rendering/src/post/shaders/displayGrade.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,MAAM,CAAC,MAAM,kBAAkB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkC5C,CAAC;AAEF,MAAM,CAAC,MAAM,aAAa,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgCvC,CAAC"}

package/dist/rendering/post/shaders/dof.glsl.d.ts

@@ -0,0 +1,25 @@
+/**
+ * PRD-03 §8.7 — S6 depth of field (WebGL2).
+ *
+ * Circle of confusion in pixels (thin-lens, all lengths in mm):
+ *
+ *   cocPx = A · f · (z − zf) / (z · (zf − f)) · (heightPx / sensorMm)
+ *
+ * with A = f / N (aperture diameter). Worked anchor (PRD): f=50 mm, N=2.8,
+ * zf=3 m, z=30 m on a 1080 px frame → |coc| ≈ 12.3 px.
+ *
+ * Passes:
+ *   DOF_PREFILTER_GLSL — half-res: rgb = 2×2 box of the HDR color, a = signed cocPx
+ *     (positive = far field, negative = near field), clamped to maxBlurPx.
+ *   DOF_NEAR_TILE_GLSL — 8 px tiles of the half-res map: maximum near-field
+ *     magnitude (−min(coc)) so the gather can dilate foreground bokeh.
+ *   DOF_GATHER_GLSL   — half-res Vogel-disc gather, DOF_RINGS rings ×8 taps;
+ *     background taps scatter by their own CoC, near-field taps by the
+ *     tile-dilated near CoC.
+ *   DOF_COMPOSITE_GLSL — full-res `smoothstep(|coc|, 1, 2)` blend.
+ */
+export declare const DOF_PREFILTER_GLSL = "#version 300 es\nprecision highp float;\n\nuniform highp sampler2D u_color;\nuniform highp sampler2D u_linearDepth;\nuniform float u_focusDistance;  // metres\nuniform float u_focalLengthMm;\nuniform float u_fStop;\nuniform float u_sensorHeightMm;\nuniform float u_frameHeightPx;  // full-res height\nuniform float u_maxBlurPx;\nout vec4 o_color;\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\nvoid main() {\n  ivec2 pixel = ivec2(gl_FragCoord.xy);\n  // u_color is the FULL-res HDR target: box-average its 2\u00D72 block (03-S15 \u2014\n  // a texelFetch at the half-res index read only the lower-left quadrant).\n  ivec2 fullMax = textureSize(u_color, 0) - 1;\n  ivec2 base = pixel * 2;\n  vec3 color = 0.25 * (\n    texelFetch(u_color, clamp(base, ivec2(0), fullMax), 0).rgb +\n    texelFetch(u_color, clamp(base + ivec2(1, 0), ivec2(0), fullMax), 0).rgb +\n    texelFetch(u_color, clamp(base + ivec2(0, 1), ivec2(0), fullMax), 0).rgb +\n    texelFetch(u_color, clamp(base + ivec2(1, 1), ivec2(0), fullMax), 0).rgb);\n  float z = texelFetch(u_linearDepth, clamp(base, ivec2(0), textureSize(u_linearDepth, 0) - 1), 0).r;\n  float f = u_focalLengthMm;\n  float aperture = f / max(u_fStop, 0.01);\n  float zMm = max(z * 1000.0, 1.0);\n  float zfMm = u_focusDistance * 1000.0;\n  float cocMm = aperture * f * (zMm - zfMm) / (zMm * max(zfMm - f, 1.0));\n  float cocPx = clamp(cocMm * (u_frameHeightPx / u_sensorHeightMm), -u_maxBlurPx, u_maxBlurPx);\n  // Sky (linear Z at far) never blurs.\n  cocPx = zMm >= 9.9e5 ? 0.0 : cocPx;\n  o_color = vec4(color, cocPx);\n}\n";
+export declare const DOF_NEAR_TILE_GLSL = "#version 300 es\nprecision highp float;\n\nuniform highp sampler2D u_prefilter; // half-res, .a = signed cocPx\nout vec4 o_color;\n\nvoid main() {\n  ivec2 tile = ivec2(gl_FragCoord.xy);\n  ivec2 size = textureSize(u_prefilter, 0);\n  float near_ = 0.0;\n  for (int y = 0; y < 8; y += 1) for (int x = 0; x < 8; x += 1) {\n    ivec2 p = tile * 8 + ivec2(x, y);\n    if (p.x >= size.x || p.y >= size.y) continue;\n    float coc = texelFetch(u_prefilter, p, 0).a;\n    near_ = max(near_, -coc); // near field is the negative-CoC side\n  }\n  o_color = vec4(near_, 0.0, 0.0, 1.0);\n}\n";
+export declare const DOF_GATHER_GLSL = "#version 300 es\nprecision highp float;\n\nuniform highp sampler2D u_prefilter; // half-res color + signed coc\nuniform highp sampler2D u_nearTile;  // 8px tiles, .r = near |coc|\nuniform float u_maxBlurPx;           // full-res px (CoC diameter)\nout vec4 o_color;\n\nconst float DOF_HALF_RES_RADIUS = 0.25;\n\nvoid main() {\n  ivec2 pixel = ivec2(gl_FragCoord.xy);\n  ivec2 size = textureSize(u_prefilter, 0);\n  vec4 center = texelFetch(u_prefilter, pixel, 0);\n  float centerCoc = center.a;\n  float centerNear = texelFetch(u_nearTile, pixel / 8, 0).r;\n  // .a is the full-res CoC *diameter* in px: the half-res disc radius is\n  // diameter / 2 (radius) / 2 (half res) = 0.25 \u00B7 |coc| (03-S15 \u2014 0.5 drew a\n  // bokeh twice the thin-lens diameter).\n  float radius = max(abs(centerCoc), centerNear) * DOF_HALF_RES_RADIUS;\n  vec3 sum = center.rgb;\n  float wsum = 1.0;\n  const int RINGS = DOF_RINGS;\n  for (int ring = 1; ring <= RINGS; ring += 1) {\n    for (int s = 0; s < 8; s += 1) {\n      float angle = 2.39996323 * float(ring * 8 + s); // golden-angle Vogel disc\n      vec2 dir = vec2(cos(angle), sin(angle));\n      ivec2 tap = clamp(pixel + ivec2(dir * radius * (float(ring) / float(RINGS)) + vec2(0.5)), ivec2(0), size - 1);\n      vec4 t = texelFetch(u_prefilter, tap, 0);\n      float tapNear = texelFetch(u_nearTile, tap / 8, 0).r;\n      // A tap contributes when its own blur reaches this pixel, or when the\n      // tile's near field does (foreground bleeds over sharp background).\n      float reach = max(abs(t.a), tapNear) * DOF_HALF_RES_RADIUS;\n      float w = clamp((reach + 0.5) / max(length(vec2(tap - pixel)), 0.5), 0.0, 1.0);\n      sum += t.rgb * w;\n      wsum += w;\n    }\n  }\n  o_color = vec4(sum / wsum, centerCoc);\n}\n";
+export declare const DOF_COMPOSITE_GLSL = "#version 300 es\nprecision highp float;\n\nuniform highp sampler2D u_color;   // full-res HDR\nuniform highp sampler2D u_blurred; // half-res gather (.a = signed cocPx)\nout vec4 o_color;\n\nvoid main() {\n  ivec2 pixel = ivec2(gl_FragCoord.xy);\n  vec4 src = texelFetch(u_color, pixel, 0);\n  vec4 blur = texture(u_blurred, (vec2(pixel) + 0.5) / vec2(textureSize(u_color, 0)));\n  o_color = vec4(mix(src.rgb, blur.rgb, smoothstep(1.0, 2.0, abs(blur.a))), src.a);\n}\n";
+//# sourceMappingURL=dof.glsl.d.ts.map

package/dist/rendering/post/shaders/dof.glsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dof.glsl.d.ts","sourceRoot":"","sources":["../../../../../../packages/rendering/src/post/shaders/dof.glsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAQH,eAAO,MAAM,kBAAkB,grEAmC9B,CAAC;AAEF,eAAO,MAAM,kBAAkB,0kBAgB9B,CAAC;AAEF,eAAO,MAAM,eAAe,gvDAsC3B,CAAC;AAEF,eAAO,MAAM,kBAAkB,ydAW9B,CAAC"}

package/dist/rendering/post/shaders/dof.glsl.js

@@ -0,0 +1,129 @@
+/**
+ * PRD-03 §8.7 — S6 depth of field (WebGL2).
+ *
+ * Circle of confusion in pixels (thin-lens, all lengths in mm):
+ *
+ *   cocPx = A · f · (z − zf) / (z · (zf − f)) · (heightPx / sensorMm)
+ *
+ * with A = f / N (aperture diameter). Worked anchor (PRD): f=50 mm, N=2.8,
+ * zf=3 m, z=30 m on a 1080 px frame → |coc| ≈ 12.3 px.
+ *
+ * Passes:
+ *   DOF_PREFILTER_GLSL — half-res: rgb = 2×2 box of the HDR color, a = signed cocPx
+ *     (positive = far field, negative = near field), clamped to maxBlurPx.
+ *   DOF_NEAR_TILE_GLSL — 8 px tiles of the half-res map: maximum near-field
+ *     magnitude (−min(coc)) so the gather can dilate foreground bokeh.
+ *   DOF_GATHER_GLSL   — half-res Vogel-disc gather, DOF_RINGS rings ×8 taps;
+ *     background taps scatter by their own CoC, near-field taps by the
+ *     tile-dilated near CoC.
+ *   DOF_COMPOSITE_GLSL — full-res `smoothstep(|coc|, 1, 2)` blend.
+ */
+import { POST_COMMON_GLSL } from "./common.glsl.js";
+const HEADER = `#version 300 es
+precision highp float;
+`;
+export const DOF_PREFILTER_GLSL = /* glsl */ `${HEADER}
+uniform highp sampler2D u_color;
+uniform highp sampler2D u_linearDepth;
+uniform float u_focusDistance;  // metres
+uniform float u_focalLengthMm;
+uniform float u_fStop;
+uniform float u_sensorHeightMm;
+uniform float u_frameHeightPx;  // full-res height
+uniform float u_maxBlurPx;
+out vec4 o_color;
+
+${POST_COMMON_GLSL}
+
+void main() {
+  ivec2 pixel = ivec2(gl_FragCoord.xy);
+  // u_color is the FULL-res HDR target: box-average its 2×2 block (03-S15 —
+  // a texelFetch at the half-res index read only the lower-left quadrant).
+  ivec2 fullMax = textureSize(u_color, 0) - 1;
+  ivec2 base = pixel * 2;
+  vec3 color = 0.25 * (
+    texelFetch(u_color, clamp(base, ivec2(0), fullMax), 0).rgb +
+    texelFetch(u_color, clamp(base + ivec2(1, 0), ivec2(0), fullMax), 0).rgb +
+    texelFetch(u_color, clamp(base + ivec2(0, 1), ivec2(0), fullMax), 0).rgb +
+    texelFetch(u_color, clamp(base + ivec2(1, 1), ivec2(0), fullMax), 0).rgb);
+  float z = texelFetch(u_linearDepth, clamp(base, ivec2(0), textureSize(u_linearDepth, 0) - 1), 0).r;
+  float f = u_focalLengthMm;
+  float aperture = f / max(u_fStop, 0.01);
+  float zMm = max(z * 1000.0, 1.0);
+  float zfMm = u_focusDistance * 1000.0;
+  float cocMm = aperture * f * (zMm - zfMm) / (zMm * max(zfMm - f, 1.0));
+  float cocPx = clamp(cocMm * (u_frameHeightPx / u_sensorHeightMm), -u_maxBlurPx, u_maxBlurPx);
+  // Sky (linear Z at far) never blurs.
+  cocPx = zMm >= 9.9e5 ? 0.0 : cocPx;
+  o_color = vec4(color, cocPx);
+}
+`;
+export const DOF_NEAR_TILE_GLSL = /* glsl */ `${HEADER}
+uniform highp sampler2D u_prefilter; // half-res, .a = signed cocPx
+out vec4 o_color;
+
+void main() {
+  ivec2 tile = ivec2(gl_FragCoord.xy);
+  ivec2 size = textureSize(u_prefilter, 0);
+  float near_ = 0.0;
+  for (int y = 0; y < 8; y += 1) for (int x = 0; x < 8; x += 1) {
+    ivec2 p = tile * 8 + ivec2(x, y);
+    if (p.x >= size.x || p.y >= size.y) continue;
+    float coc = texelFetch(u_prefilter, p, 0).a;
+    near_ = max(near_, -coc); // near field is the negative-CoC side
+  }
+  o_color = vec4(near_, 0.0, 0.0, 1.0);
+}
+`;
+export const DOF_GATHER_GLSL = /* glsl */ `${HEADER}
+uniform highp sampler2D u_prefilter; // half-res color + signed coc
+uniform highp sampler2D u_nearTile;  // 8px tiles, .r = near |coc|
+uniform float u_maxBlurPx;           // full-res px (CoC diameter)
+out vec4 o_color;
+
+const float DOF_HALF_RES_RADIUS = 0.25;
+
+void main() {
+  ivec2 pixel = ivec2(gl_FragCoord.xy);
+  ivec2 size = textureSize(u_prefilter, 0);
+  vec4 center = texelFetch(u_prefilter, pixel, 0);
+  float centerCoc = center.a;
+  float centerNear = texelFetch(u_nearTile, pixel / 8, 0).r;
+  // .a is the full-res CoC *diameter* in px: the half-res disc radius is
+  // diameter / 2 (radius) / 2 (half res) = 0.25 · |coc| (03-S15 — 0.5 drew a
+  // bokeh twice the thin-lens diameter).
+  float radius = max(abs(centerCoc), centerNear) * DOF_HALF_RES_RADIUS;
+  vec3 sum = center.rgb;
+  float wsum = 1.0;
+  const int RINGS = DOF_RINGS;
+  for (int ring = 1; ring <= RINGS; ring += 1) {
+    for (int s = 0; s < 8; s += 1) {
+      float angle = 2.39996323 * float(ring * 8 + s); // golden-angle Vogel disc
+      vec2 dir = vec2(cos(angle), sin(angle));
+      ivec2 tap = clamp(pixel + ivec2(dir * radius * (float(ring) / float(RINGS)) + vec2(0.5)), ivec2(0), size - 1);
+      vec4 t = texelFetch(u_prefilter, tap, 0);
+      float tapNear = texelFetch(u_nearTile, tap / 8, 0).r;
+      // A tap contributes when its own blur reaches this pixel, or when the
+      // tile's near field does (foreground bleeds over sharp background).
+      float reach = max(abs(t.a), tapNear) * DOF_HALF_RES_RADIUS;
+      float w = clamp((reach + 0.5) / max(length(vec2(tap - pixel)), 0.5), 0.0, 1.0);
+      sum += t.rgb * w;
+      wsum += w;
+    }
+  }
+  o_color = vec4(sum / wsum, centerCoc);
+}
+`;
+export const DOF_COMPOSITE_GLSL = /* glsl */ `${HEADER}
+uniform highp sampler2D u_color;   // full-res HDR
+uniform highp sampler2D u_blurred; // half-res gather (.a = signed cocPx)
+out vec4 o_color;
+
+void main() {
+  ivec2 pixel = ivec2(gl_FragCoord.xy);
+  vec4 src = texelFetch(u_color, pixel, 0);
+  vec4 blur = texture(u_blurred, (vec2(pixel) + 0.5) / vec2(textureSize(u_color, 0)));
+  o_color = vec4(mix(src.rgb, blur.rgb, smoothstep(1.0, 2.0, abs(blur.a))), src.a);
+}
+`;
+//# sourceMappingURL=dof.glsl.js.map

package/dist/rendering/post/shaders/dof.glsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dof.glsl.js","sourceRoot":"","sources":["../../../../../../packages/rendering/src/post/shaders/dof.glsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAEpD,MAAM,MAAM,GAAG;;CAEd,CAAC;AAEF,MAAM,CAAC,MAAM,kBAAkB,GAAG,UAAU,CAAC,GAAG,MAAM;;;;;;;;;;;EAWpD,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;CAwBjB,CAAC;AAEF,MAAM,CAAC,MAAM,kBAAkB,GAAG,UAAU,CAAC,GAAG,MAAM;;;;;;;;;;;;;;;;CAgBrD,CAAC;AAEF,MAAM,CAAC,MAAM,eAAe,GAAG,UAAU,CAAC,GAAG,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsClD,CAAC;AAEF,MAAM,CAAC,MAAM,kBAAkB,GAAG,UAAU,CAAC,GAAG,MAAM;;;;;;;;;;;CAWrD,CAAC"}

package/dist/rendering/post/shaders/dof.wgsl.d.ts

@@ -0,0 +1,11 @@
+/**
+ * PRD-03 §8.7 Phase 7 — S6 depth of field WGSL twins. Thin-lens CoC in px
+ * (`A · f · (z − zf) / (z · (zf − f)) · heightPx/sensorMm`, all mm); half-res
+ * prefilter → 8px near-field tile max → Vogel-disc gather (`DOF_RINGS`
+ * pipeline-overridable, default 3) → full-res smoothstep composite.
+ */
+export declare const DOF_PREFILTER_WGSL = "struct DofPrefilterParams {\n  focus_distance: f32,     // metres\n  focal_length_mm: f32,\n  f_stop: f32,\n  sensor_height_mm: f32,\n  frame_height_px: f32,    // full-res height\n  max_blur_px: f32,\n  _pad: vec2<f32>,\n};\n\n@group(0) @binding(0) var<uniform> u_params: DofPrefilterParams;\n@group(0) @binding(1) var u_color_tex: texture_2d<f32>;\n@group(0) @binding(2) var u_linear_depth_tex: texture_2d<f32>;\n\n@fragment\nfn fs_dof_prefilter(@builtin(position) frag_coord: vec4<f32>) -> @location(0) vec4<f32> {\n  let pixel = vec2<i32>(frag_coord.xy);\n  // Full-res HDR source: box-average its 2\u00D72 block (03-S15, GLSL parity).\n  let full_max = vec2<i32>(textureDimensions(u_color_tex)) - vec2<i32>(1);\n  let base = pixel * 2;\n  let color = 0.25 * (\n    textureLoad(u_color_tex, clamp(base, vec2<i32>(0), full_max), 0).rgb +\n    textureLoad(u_color_tex, clamp(base + vec2<i32>(1, 0), vec2<i32>(0), full_max), 0).rgb +\n    textureLoad(u_color_tex, clamp(base + vec2<i32>(0, 1), vec2<i32>(0), full_max), 0).rgb +\n    textureLoad(u_color_tex, clamp(base + vec2<i32>(1, 1), vec2<i32>(0), full_max), 0).rgb);\n  let z = textureLoad(u_linear_depth_tex,\n    clamp(base, vec2<i32>(0), vec2<i32>(textureDimensions(u_linear_depth_tex)) - vec2<i32>(1)), 0).r;\n  let f = u_params.focal_length_mm;\n  let aperture = f / max(u_params.f_stop, 0.01);\n  let z_mm = max(z * 1000.0, 1.0);\n  let zf_mm = u_params.focus_distance * 1000.0;\n  let coc_mm = aperture * f * (z_mm - zf_mm) / (z_mm * max(zf_mm - f, 1.0));\n  var coc_px = clamp(coc_mm * (u_params.frame_height_px / u_params.sensor_height_mm), -u_params.max_blur_px, u_params.max_blur_px);\n  // Sky (linear Z at far) never blurs.\n  coc_px = select(coc_px, 0.0, z_mm >= 9.9e5);\n  return vec4<f32>(color, coc_px);\n}\n";
+export declare const DOF_NEAR_TILE_WGSL = "@group(0) @binding(1) var u_prefilter_tex: texture_2d<f32>; // half-res, .a = signed cocPx\n\n@fragment\nfn fs_dof_near_tile(@builtin(position) frag_coord: vec4<f32>) -> @location(0) vec4<f32> {\n  let tile = vec2<i32>(frag_coord.xy);\n  let size = vec2<i32>(textureDimensions(u_prefilter_tex));\n  var near_coc = 0.0;\n  for (var y = 0; y < 8; y = y + 1) {\n    for (var x = 0; x < 8; x = x + 1) {\n      let p = tile * 8 + vec2<i32>(x, y);\n      if (p.x >= size.x || p.y >= size.y) { continue; }\n      let coc = textureLoad(u_prefilter_tex, p, 0).a;\n      near_coc = max(near_coc, -coc); // near field is the negative-CoC side\n    }\n  }\n  return vec4<f32>(near_coc, 0.0, 0.0, 1.0);\n}\n";
+export declare const DOF_GATHER_WGSL = "// DOF_RINGS \u2014 pipeline-overridable gather rings (3 = High, 2 = Medium).\noverride DOF_RINGS: i32 = 3;\nconst DOF_HALF_RES_RADIUS: f32 = 0.25;\n\nstruct DofGatherParams {\n  max_blur_px: f32,        // full-res px (CoC diameter)\n  _pad: vec3<f32>,\n};\n\n@group(0) @binding(0) var<uniform> u_params: DofGatherParams;\n@group(0) @binding(1) var u_prefilter_tex: texture_2d<f32>; // half-res color + signed coc\n@group(0) @binding(2) var u_near_tile_tex: texture_2d<f32>;  // 8px tiles, .r = near |coc|\n\n@fragment\nfn fs_dof_gather(@builtin(position) frag_coord: vec4<f32>) -> @location(0) vec4<f32> {\n  let pixel = vec2<i32>(frag_coord.xy);\n  let size = vec2<i32>(textureDimensions(u_prefilter_tex));\n  let center = textureLoad(u_prefilter_tex, pixel, 0);\n  let center_coc = center.a;\n  let center_near = textureLoad(u_near_tile_tex, pixel / 8, 0).r;\n  // Full-res CoC diameter \u2192 half-res disc radius (03-S15, GLSL parity).\n  let radius = max(abs(center_coc), center_near) * DOF_HALF_RES_RADIUS;\n  var sum = center.rgb;\n  var wsum = 1.0;\n  for (var ring = 1; ring <= DOF_RINGS; ring = ring + 1) {\n    for (var s = 0; s < 8; s = s + 1) {\n      let angle = 2.39996323 * f32(ring * 8 + s); // golden-angle Vogel disc\n      let dir = vec2<f32>(cos(angle), sin(angle));\n      let tap = clamp(pixel + vec2<i32>(dir * radius * (f32(ring) / f32(DOF_RINGS)) + vec2<f32>(0.5)),\n        vec2<i32>(0), size - vec2<i32>(1));\n      let t = textureLoad(u_prefilter_tex, tap, 0);\n      let tap_near = textureLoad(u_near_tile_tex, tap / 8, 0).r;\n      // A tap contributes when its own blur reaches this pixel, or when the\n      // tile's near field does (foreground bleeds over sharp background).\n      let reach = max(abs(t.a), tap_near) * DOF_HALF_RES_RADIUS;\n      let w = clamp((reach + 0.5) / max(length(vec2<f32>(tap - pixel)), 0.5), 0.0, 1.0);\n      sum = sum + t.rgb * w;\n      wsum = wsum + w;\n    }\n  }\n  return vec4<f32>(sum / wsum, center_coc);\n}\n";
+export declare const DOF_COMPOSITE_WGSL = "@group(0) @binding(1) var u_color_tex: texture_2d<f32>;   // full-res HDR\n@group(0) @binding(2) var u_blurred_tex: texture_2d<f32>;  // half-res gather (.a = signed cocPx)\n@group(0) @binding(3) var u_blurred_smp: sampler;\n\n@fragment\nfn fs_dof_composite(@builtin(position) frag_coord: vec4<f32>) -> @location(0) vec4<f32> {\n  let pixel = vec2<i32>(frag_coord.xy);\n  let src = textureLoad(u_color_tex, pixel, 0);\n  let blur = textureSampleLevel(u_blurred_tex, u_blurred_smp,\n    (vec2<f32>(pixel) + vec2<f32>(0.5)) / vec2<f32>(textureDimensions(u_color_tex)), 0.0);\n  return vec4<f32>(mix(src.rgb, blur.rgb, smoothstep(1.0, 2.0, abs(blur.a))), src.a);\n}\n";
+//# sourceMappingURL=dof.wgsl.d.ts.map

package/dist/rendering/post/shaders/dof.wgsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dof.wgsl.d.ts","sourceRoot":"","sources":["../../../../../../packages/rendering/src/post/shaders/dof.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,eAAO,MAAM,kBAAkB,0vDAqC9B,CAAC;AAEF,eAAO,MAAM,kBAAkB,2rBAiB9B,CAAC;AAEF,eAAO,MAAM,eAAe,o8DA0C3B,CAAC;AAEF,eAAO,MAAM,kBAAkB,6pBAY9B,CAAC"}

package/dist/rendering/post/shaders/dof.wgsl.js

@@ -0,0 +1,119 @@
+/**
+ * PRD-03 §8.7 Phase 7 — S6 depth of field WGSL twins. Thin-lens CoC in px
+ * (`A · f · (z − zf) / (z · (zf − f)) · heightPx/sensorMm`, all mm); half-res
+ * prefilter → 8px near-field tile max → Vogel-disc gather (`DOF_RINGS`
+ * pipeline-overridable, default 3) → full-res smoothstep composite.
+ */
+export const DOF_PREFILTER_WGSL = /* wgsl */ `struct DofPrefilterParams {
+  focus_distance: f32,     // metres
+  focal_length_mm: f32,
+  f_stop: f32,
+  sensor_height_mm: f32,
+  frame_height_px: f32,    // full-res height
+  max_blur_px: f32,
+  _pad: vec2<f32>,
+};
+
+@group(0) @binding(0) var<uniform> u_params: DofPrefilterParams;
+@group(0) @binding(1) var u_color_tex: texture_2d<f32>;
+@group(0) @binding(2) var u_linear_depth_tex: texture_2d<f32>;
+
+@fragment
+fn fs_dof_prefilter(@builtin(position) frag_coord: vec4<f32>) -> @location(0) vec4<f32> {
+  let pixel = vec2<i32>(frag_coord.xy);
+  // Full-res HDR source: box-average its 2×2 block (03-S15, GLSL parity).
+  let full_max = vec2<i32>(textureDimensions(u_color_tex)) - vec2<i32>(1);
+  let base = pixel * 2;
+  let color = 0.25 * (
+    textureLoad(u_color_tex, clamp(base, vec2<i32>(0), full_max), 0).rgb +
+    textureLoad(u_color_tex, clamp(base + vec2<i32>(1, 0), vec2<i32>(0), full_max), 0).rgb +
+    textureLoad(u_color_tex, clamp(base + vec2<i32>(0, 1), vec2<i32>(0), full_max), 0).rgb +
+    textureLoad(u_color_tex, clamp(base + vec2<i32>(1, 1), vec2<i32>(0), full_max), 0).rgb);
+  let z = textureLoad(u_linear_depth_tex,
+    clamp(base, vec2<i32>(0), vec2<i32>(textureDimensions(u_linear_depth_tex)) - vec2<i32>(1)), 0).r;
+  let f = u_params.focal_length_mm;
+  let aperture = f / max(u_params.f_stop, 0.01);
+  let z_mm = max(z * 1000.0, 1.0);
+  let zf_mm = u_params.focus_distance * 1000.0;
+  let coc_mm = aperture * f * (z_mm - zf_mm) / (z_mm * max(zf_mm - f, 1.0));
+  var coc_px = clamp(coc_mm * (u_params.frame_height_px / u_params.sensor_height_mm), -u_params.max_blur_px, u_params.max_blur_px);
+  // Sky (linear Z at far) never blurs.
+  coc_px = select(coc_px, 0.0, z_mm >= 9.9e5);
+  return vec4<f32>(color, coc_px);
+}
+`;
+export const DOF_NEAR_TILE_WGSL = /* wgsl */ `@group(0) @binding(1) var u_prefilter_tex: texture_2d<f32>; // half-res, .a = signed cocPx
+
+@fragment
+fn fs_dof_near_tile(@builtin(position) frag_coord: vec4<f32>) -> @location(0) vec4<f32> {
+  let tile = vec2<i32>(frag_coord.xy);
+  let size = vec2<i32>(textureDimensions(u_prefilter_tex));
+  var near_coc = 0.0;
+  for (var y = 0; y < 8; y = y + 1) {
+    for (var x = 0; x < 8; x = x + 1) {
+      let p = tile * 8 + vec2<i32>(x, y);
+      if (p.x >= size.x || p.y >= size.y) { continue; }
+      let coc = textureLoad(u_prefilter_tex, p, 0).a;
+      near_coc = max(near_coc, -coc); // near field is the negative-CoC side
+    }
+  }
+  return vec4<f32>(near_coc, 0.0, 0.0, 1.0);
+}
+`;
+export const DOF_GATHER_WGSL = /* wgsl */ `// DOF_RINGS — pipeline-overridable gather rings (3 = High, 2 = Medium).
+override DOF_RINGS: i32 = 3;
+const DOF_HALF_RES_RADIUS: f32 = 0.25;
+
+struct DofGatherParams {
+  max_blur_px: f32,        // full-res px (CoC diameter)
+  _pad: vec3<f32>,
+};
+
+@group(0) @binding(0) var<uniform> u_params: DofGatherParams;
+@group(0) @binding(1) var u_prefilter_tex: texture_2d<f32>; // half-res color + signed coc
+@group(0) @binding(2) var u_near_tile_tex: texture_2d<f32>;  // 8px tiles, .r = near |coc|
+
+@fragment
+fn fs_dof_gather(@builtin(position) frag_coord: vec4<f32>) -> @location(0) vec4<f32> {
+  let pixel = vec2<i32>(frag_coord.xy);
+  let size = vec2<i32>(textureDimensions(u_prefilter_tex));
+  let center = textureLoad(u_prefilter_tex, pixel, 0);
+  let center_coc = center.a;
+  let center_near = textureLoad(u_near_tile_tex, pixel / 8, 0).r;
+  // Full-res CoC diameter → half-res disc radius (03-S15, GLSL parity).
+  let radius = max(abs(center_coc), center_near) * DOF_HALF_RES_RADIUS;
+  var sum = center.rgb;
+  var wsum = 1.0;
+  for (var ring = 1; ring <= DOF_RINGS; ring = ring + 1) {
+    for (var s = 0; s < 8; s = s + 1) {
+      let angle = 2.39996323 * f32(ring * 8 + s); // golden-angle Vogel disc
+      let dir = vec2<f32>(cos(angle), sin(angle));
+      let tap = clamp(pixel + vec2<i32>(dir * radius * (f32(ring) / f32(DOF_RINGS)) + vec2<f32>(0.5)),
+        vec2<i32>(0), size - vec2<i32>(1));
+      let t = textureLoad(u_prefilter_tex, tap, 0);
+      let tap_near = textureLoad(u_near_tile_tex, tap / 8, 0).r;
+      // A tap contributes when its own blur reaches this pixel, or when the
+      // tile's near field does (foreground bleeds over sharp background).
+      let reach = max(abs(t.a), tap_near) * DOF_HALF_RES_RADIUS;
+      let w = clamp((reach + 0.5) / max(length(vec2<f32>(tap - pixel)), 0.5), 0.0, 1.0);
+      sum = sum + t.rgb * w;
+      wsum = wsum + w;
+    }
+  }
+  return vec4<f32>(sum / wsum, center_coc);
+}
+`;
+export const DOF_COMPOSITE_WGSL = /* wgsl */ `@group(0) @binding(1) var u_color_tex: texture_2d<f32>;   // full-res HDR
+@group(0) @binding(2) var u_blurred_tex: texture_2d<f32>;  // half-res gather (.a = signed cocPx)
+@group(0) @binding(3) var u_blurred_smp: sampler;
+
+@fragment
+fn fs_dof_composite(@builtin(position) frag_coord: vec4<f32>) -> @location(0) vec4<f32> {
+  let pixel = vec2<i32>(frag_coord.xy);
+  let src = textureLoad(u_color_tex, pixel, 0);
+  let blur = textureSampleLevel(u_blurred_tex, u_blurred_smp,
+    (vec2<f32>(pixel) + vec2<f32>(0.5)) / vec2<f32>(textureDimensions(u_color_tex)), 0.0);
+  return vec4<f32>(mix(src.rgb, blur.rgb, smoothstep(1.0, 2.0, abs(blur.a))), src.a);
+}
+`;
+//# sourceMappingURL=dof.wgsl.js.map

package/dist/rendering/post/shaders/dof.wgsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dof.wgsl.js","sourceRoot":"","sources":["../../../../../../packages/rendering/src/post/shaders/dof.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,MAAM,CAAC,MAAM,kBAAkB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqC5C,CAAC;AAEF,MAAM,CAAC,MAAM,kBAAkB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;CAiB5C,CAAC;AAEF,MAAM,CAAC,MAAM,eAAe,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0CzC,CAAC;AAEF,MAAM,CAAC,MAAM,kBAAkB,GAAG,UAAU,CAAC;;;;;;;;;;;;CAY5C,CAAC"}

package/dist/rendering/post/shaders/exposure.glsl.d.ts

@@ -0,0 +1,43 @@
+/**
+ * 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 declare const EXPOSURE_LUMA_LOG_GLSL = "#version 300 es\nprecision highp float;\nuniform sampler2D u_hdr;\nuniform vec2 u_texelSize;      // 1 / HDR size\nuniform int u_centerWeighted;  // 1 = centre-weighted metering, 0 = average\nin vec2 v_uv;\nout vec4 outColor;\n\nvoid main() {\n\t// One output texel covers a 4\u00D74 block of source texels; average the block.\n\tvec4 acc = vec4(0.0);\n\tfor (int y = 0; y < 4; y++) {\n\t\tfor (int x = 0; x < 4; x++) {\n\t\t\tvec2 uv = v_uv + (vec2(float(x), float(y)) - 1.5) * u_texelSize;\n\t\t\tacc.rgb += texture(u_hdr, uv).rgb;\n\t\t\tacc.a += 1.0;\n\t\t}\n\t}\n\tvec3 c = acc.rgb / max(acc.a, 1.0);\n\tfloat luma = max(dot(c, vec3(0.2126, 0.7152, 0.0722)), 1e-5);\n\t// Centre-weighted: w = 1 - (d^2), clamped \u2014 an 18% gray card reads weight 1\n\t// at frame centre and falls to 0 at the corners.\n\tvec2 centered = v_uv - 0.5;\n\tfloat w = u_centerWeighted == 1 ? max(0.0, 1.0 - dot(centered, centered) * 4.0) : 1.0;\n\toutColor = vec4(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_GLSL = "#version 300 es\nprecision highp float;\nuniform sampler2D u_source;\nuniform vec2 u_texelSize;      // 1 / source size\nin vec2 v_uv;\nout vec4 outColor;\n\nvoid main() {\n\tvec4 sum = texture(u_source, v_uv + vec2(-0.5, -0.5) * u_texelSize)\n\t\t+ texture(u_source, v_uv + vec2( 0.5, -0.5) * u_texelSize)\n\t\t+ texture(u_source, v_uv + vec2(-0.5,  0.5) * u_texelSize)\n\t\t+ texture(u_source, v_uv + vec2( 0.5,  0.5) * u_texelSize);\n\toutColor = sum * 0.25;\n}\n";
+/**
+ * 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 declare const EXPOSURE_ADAPT_GLSL = "#version 300 es\nprecision highp float;\nuniform sampler2D u_prev;\nuniform sampler2D u_avg;\nuniform float u_dt;\nuniform float u_speedUp;\nuniform float u_speedDown;\nuniform float u_minEv;\nuniform float u_maxEv;\nuniform float u_compensationEv;\nuniform int u_hasPrev;\nout vec4 outColor;\n\nvoid main() {\n\tvec4 avg = texelFetch(u_avg, ivec2(0), 0);\n\tfloat avgLog2 = avg.r / max(avg.g, 1e-4);   // \u03A3(l\u00B7w)/\u03A3w \u2014 weighted mean\n\tfloat target = clamp(-avgLog2 + log2(0.18) + u_compensationEv, u_minEv, u_maxEv);\n\tfloat prev = texelFetch(u_prev, ivec2(0), 0).r;\n\tfloat speed = target > prev ? u_speedUp : u_speedDown;\n\tfloat ev = u_hasPrev == 1 ? mix(prev, target, 1.0 - exp(-u_dt * speed)) : target;\n\toutColor = vec4(ev, 0.0, 0.0, 1.0);\n}\n";
+/** S8 apply: `outColor = hdr * exp2(ev)` — the composite's autoExp factor. */
+export declare const EXPOSURE_MUL_GLSL = "#version 300 es\nprecision highp float;\nuniform sampler2D u_hdr;\nuniform sampler2D u_ev;\nin vec2 v_uv;\nout vec4 outColor;\n\nvoid main() {\n\tfloat ev = texelFetch(u_ev, ivec2(0), 0).r;\n\tvec4 c = texture(u_hdr, v_uv);\n\toutColor = vec4(c.rgb * exp2(ev), c.a);\n}\n";
+/**
+ * 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 declare function adaptEv(prev: number, avgLog2: number, options: {
+    readonly dt: number;
+    readonly minEv: number;
+    readonly maxEv: number;
+    readonly speedUp: number;
+    readonly speedDown: number;
+    readonly compensationEv: number;
+    readonly hasPrev: boolean;
+}): number;
+//# sourceMappingURL=exposure.glsl.d.ts.map

package/dist/rendering/post/shaders/exposure.glsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exposure.glsl.d.ts","sourceRoot":"","sources":["../../../../../../packages/rendering/src/post/shaders/exposure.glsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,8EAA8E;AAC9E,eAAO,MAAM,sBAAsB,49BA0BlC,CAAC;AAEF,8EAA8E;AAC9E,eAAO,MAAM,oBAAoB,udAchC,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,2wBAsB/B,CAAC;AAEF,8EAA8E;AAC9E,eAAO,MAAM,iBAAiB,oRAY7B,CAAC;AAEF;;;GAGG;AACH,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE;IAC9D,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACpE,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IACtF,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;CAC3B,GAAG,MAAM,CAKT"}