@aura3d/rendering 3.0.1 → 4.0.0

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

@@ -0,0 +1,121 @@
+/**
+ * PRD-03 §8.4 — S2 GTAO denoise + joint-bilateral upsample/apply (WebGL2).
+ *
+ * `GTAO_DENOISE_GLSL` runs twice (H then V, `u_dir`): a 5-tap bilateral over
+ * the half-res R8 AO, `w_i = gauss_i · exp(−|Δz| / (0.05·z))` on the paired
+ * linear-depth texture.
+ *
+ * `GTAO_APPLY_GLSL` is the fused joint-bilateral upsample + apply: it reads
+ * the denoised half-res AO (2×2 taps depth-weighted against the full-res
+ * linear depth) and multiplies the full-res HDR per §6.3:
+ *   `hdr.rgb *= mix(1.0, aoMB, w)`
+ *   `aoMB = max(ao, ((ao·a + b)·ao + c)·ao)`   Jimenez 2016 multi-bounce,
+ *        a = 2.0404ρ−0.3324, b = −4.7951ρ+0.6417, c = 2.7552ρ+0.6903, ρ = 0.5
+ *   `w = (1 − sky) · clamp(hdr.a − 2, 0, 1)` on pixels tagged by the
+ *        `prd03.indirectFraction` forward feature (`hdr.a = 2 + f_ind`), else
+ *   `w = (1 − sky) · u_aoFallbackStrength · step(luma(hdr), 4.0)`
+ *        (legacy draws; conservative strength, see v2Stages),
+ *        with `sky = linZ ≥ far·0.999`. Alpha is restored to `min(a, 1)`.
+ */
+const HEADER = `#version 300 es
+precision highp float;
+`;
+const BILATERAL_WEIGHTS = /* glsl */ `
+// 5-tap gaussian (sigma 1.0) × exponential depth term exp(-|dz|/(0.05*z)).
+float aoWeight(float dz, float z, float g) {
+  return g * exp(-abs(dz) / max(0.05 * z, 1e-4));
+}
+const float GAUSS_5[5] = float[5](0.06136, 0.24477, 0.38774, 0.24477, 0.06136);
+`;
+export const GTAO_DENOISE_GLSL = /* glsl */ `${HEADER}
+uniform sampler2D u_ao;              // half-res R8
+uniform highp sampler2D u_depthHalf; // half-res linear depth (.r)
+uniform vec2 u_dir;                  // (texel.x, 0) then (0, texel.y)
+out vec4 o_color;
+
+${BILATERAL_WEIGHTS}
+
+void main() {
+  ivec2 p = ivec2(gl_FragCoord.xy);
+  vec2 texel = vec2(textureSize(u_ao, 0));
+  float centerAo = texelFetch(u_ao, p, 0).r;
+  float centerZ = texelFetch(u_depthHalf, p, 0).r;
+  float total = GAUSS_5[2];
+  float sum = centerAo * GAUSS_5[2];
+  for (int i = -2; i <= 2; ++i) {
+    if (i == 0) continue;
+    ivec2 s = p + ivec2(u_dir * texel * float(i));
+    s = clamp(s, ivec2(0), ivec2(texel) - 1);
+    float z = texelFetch(u_depthHalf, s, 0).r;
+    float w = aoWeight(z - centerZ, centerZ, GAUSS_5[i + 2]);
+    sum += texelFetch(u_ao, s, 0).r * w;
+    total += w;
+  }
+  o_color = vec4(sum / total, 0.0, 0.0, 1.0);
+}
+`;
+export const GTAO_APPLY_GLSL = /* glsl */ `${HEADER}
+uniform sampler2D u_hdr;             // full-res HDR (linear)
+uniform sampler2D u_ao;              // denoised half-res R8
+uniform highp sampler2D u_depthFull; // full-res linear depth
+uniform highp sampler2D u_depthHalf;
+uniform float u_far;
+uniform float u_aoFallbackStrength;
+uniform bool u_aoMultiBounce;
+out vec4 o_color;
+${BILATERAL_WEIGHTS}
+// Jimenez 2016 multi-bounce polynomial, albedoProxy ρ = 0.5.
+float aoMultiBounce(float ao) {
+  float a = 2.0404 * 0.5 - 0.3324;
+  float b = -4.7951 * 0.5 + 0.6417;
+  float c = 2.7552 * 0.5 + 0.6903;
+  return max(ao, ((ao * a + b) * ao + c) * ao);
+}
+
+// Joint-bilateral upsample: the four half-res taps around the bilinear
+// coordinate, weighted by depth similarity to the full-res texel.
+float upsampleAo(vec2 uvHalf, float fullZ, vec2 halfSize) {
+  vec2 p = uvHalf * halfSize - 0.5;
+  ivec2 p0 = ivec2(floor(p));
+  vec2 f = p - vec2(p0);
+  float sum = 0.0;
+  float total = 0.0;
+  for (int y = 0; y < 2; ++y) {
+    for (int x = 0; x < 2; ++x) {
+      ivec2 s = clamp(p0 + ivec2(x, y), ivec2(0), ivec2(halfSize) - 1);
+      float z = texelFetch(u_depthHalf, s, 0).r;
+      float w = aoWeight(z - fullZ, fullZ,
+                         (x == 0 ? 1.0 - f.x : f.x) * (y == 0 ? 1.0 - f.y : f.y));
+      sum += texelFetch(u_ao, s, 0).r * w;
+      total += w;
+    }
+  }
+  return total > 0.0 ? sum / total : 1.0;
+}
+
+void main() {
+  ivec2 p = ivec2(gl_FragCoord.xy);
+  vec4 hdr = texelFetch(u_hdr, p, 0);
+  float fullZ = texelFetch(u_depthFull, p, 0).r;
+  vec2 halfSize = vec2(textureSize(u_ao, 0));
+  vec2 uvHalf = gl_FragCoord.xy / vec2(textureSize(u_hdr, 0));
+  float ao = upsampleAo(uvHalf, fullZ, halfSize);
+  float aoMB = u_aoMultiBounce ? aoMultiBounce(ao) : ao;
+
+  float sky = step(u_far * 0.999, fullZ);
+  float w;
+  if (hdr.a >= 1.5) {
+    // Tagged generated-program pixel: alpha = 2 + f_ind (prd03.indirectFraction).
+    w = clamp(hdr.a - 2.0, 0.0, 1.0);
+  } else {
+    // Legacy / custom-shader pixel: no f_ind, conservative fallback.
+    float luma = dot(hdr.rgb, vec3(0.2126, 0.7152, 0.0722));
+    w = u_aoFallbackStrength * step(luma, 4.0);
+  }
+  w *= 1.0 - sky;
+  hdr.rgb *= mix(1.0, aoMB, w);
+  hdr.a = min(hdr.a, 1.0);
+  o_color = hdr;
+}
+`;
+//# sourceMappingURL=gtaoDenoise.glsl.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"gtaoDenoise.glsl.js","sourceRoot":"","sources":["../../../../../../packages/rendering/src/post/shaders/gtaoDenoise.glsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,MAAM,MAAM,GAAG;;CAEd,CAAC;AAEF,MAAM,iBAAiB,GAAG,UAAU,CAAC;;;;;;CAMpC,CAAC;AAEF,MAAM,CAAC,MAAM,iBAAiB,GAAG,UAAU,CAAC,GAAG,MAAM;;;;;;EAMnD,iBAAiB;;;;;;;;;;;;;;;;;;;;CAoBlB,CAAC;AAEF,MAAM,CAAC,MAAM,eAAe,GAAG,UAAU,CAAC,GAAG,MAAM;;;;;;;;;EASjD,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsDlB,CAAC"}

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

@@ -0,0 +1,11 @@
+/**
+ * PRD-03 §8.4 Phase 7 — S2 GTAO denoise + joint-bilateral upsample/apply
+ * WGSL twins. `GTAO_DENOISE_WGSL` runs twice (H then V). `GTAO_APPLY_WGSL`
+ * is the fused joint-bilateral upsample + §6.3 multiply
+ * (`hdr *= mix(1, aoMB, w)`; w = `clamp(hdr.a − 2, 0, 1)` on pixels tagged
+ * by `prd03.indirectFraction` (alpha = 2 + f_ind), else the conservative
+ * fallback `strength · step(luma, 4)`; both × (1 − sky); alpha → min(a, 1)).
+ */
+export declare const GTAO_DENOISE_WGSL = "struct GtaoDenoiseParams {\n  dir: vec2<f32>,          // (texel.x, 0) then (0, texel.y)\n  _pad: vec2<f32>,\n};\n\n@group(0) @binding(0) var<uniform> u_params: GtaoDenoiseParams;\n@group(0) @binding(1) var u_ao_tex: texture_2d<f32>;       // half-res R8\n@group(0) @binding(2) var u_depth_half_tex: texture_2d<f32>; // half-res linear depth (.r)\n\n\n// 5-tap gaussian (sigma 1.0) \u00D7 exponential depth term exp(-|dz|/(0.05*z)).\nfn ao_weight(dz: f32, z: f32, g: f32) -> f32 {\n  return g * exp(-abs(dz) / max(0.05 * z, 1e-4));\n}\nconst GAUSS_5 = array<f32, 5>(0.06136, 0.24477, 0.38774, 0.24477, 0.06136);\n\n\n@fragment\nfn fs_gtao_denoise(@builtin(position) frag_coord: vec4<f32>) -> @location(0) vec4<f32> {\n  let p = vec2<i32>(frag_coord.xy);\n  let texel = vec2<f32>(textureDimensions(u_ao_tex));\n  let center_ao = textureLoad(u_ao_tex, p, 0).r;\n  let center_z = textureLoad(u_depth_half_tex, p, 0).r;\n  var total = GAUSS_5[2];\n  var sum = center_ao * GAUSS_5[2];\n  for (var i = -2; i <= 2; i = i + 1) {\n    if (i == 0) { continue; }\n    var s = p + vec2<i32>(u_params.dir * texel * f32(i));\n    s = clamp(s, vec2<i32>(0), vec2<i32>(texel) - vec2<i32>(1));\n    let z = textureLoad(u_depth_half_tex, s, 0).r;\n    let w = ao_weight(z - center_z, center_z, GAUSS_5[i + 2]);\n    sum = sum + textureLoad(u_ao_tex, s, 0).r * w;\n    total = total + w;\n  }\n  return vec4<f32>(sum / total, 0.0, 0.0, 1.0);\n}\n";
+export declare const GTAO_APPLY_WGSL = "struct GtaoApplyParams {\n  far: f32,\n  ao_fallback_strength: f32,\n  ao_multi_bounce: i32,\n  ao_indirect_fraction: i32,  // AURA_AO_INDIRECT_FRACTION equivalent\n};\n\n@group(0) @binding(0) var<uniform> u_params: GtaoApplyParams;\n@group(0) @binding(1) var u_hdr_tex: texture_2d<f32>;        // full-res HDR (linear)\n@group(0) @binding(2) var u_ao_tex: texture_2d<f32>;         // denoised half-res R8\n@group(0) @binding(3) var u_depth_full_tex: texture_2d<f32>; // full-res linear depth\n@group(0) @binding(4) var u_depth_half_tex: texture_2d<f32>;\n\n\n// 5-tap gaussian (sigma 1.0) \u00D7 exponential depth term exp(-|dz|/(0.05*z)).\nfn ao_weight(dz: f32, z: f32, g: f32) -> f32 {\n  return g * exp(-abs(dz) / max(0.05 * z, 1e-4));\n}\nconst GAUSS_5 = array<f32, 5>(0.06136, 0.24477, 0.38774, 0.24477, 0.06136);\n\n\n// Jimenez 2016 multi-bounce polynomial, albedoProxy \u03C1 = 0.5.\nfn ao_multi_bounce(ao: f32) -> f32 {\n  let a = 2.0404 * 0.5 - 0.3324;\n  let b = -4.7951 * 0.5 + 0.6417;\n  let c = 2.7552 * 0.5 + 0.6903;\n  return max(ao, ((ao * a + b) * ao + c) * ao);\n}\n\n// Joint-bilateral upsample: the four half-res taps around the bilinear\n// coordinate, weighted by depth similarity to the full-res texel.\nfn upsample_ao(uv_half: vec2<f32>, full_z: f32, half_size: vec2<f32>) -> f32 {\n  let p = uv_half * half_size - vec2<f32>(0.5);\n  let p0 = vec2<i32>(floor(p));\n  let f = p - vec2<f32>(p0);\n  var sum = 0.0;\n  var total = 0.0;\n  for (var y = 0; y < 2; y = y + 1) {\n    for (var x = 0; x < 2; x = x + 1) {\n      let s = clamp(p0 + vec2<i32>(x, y), vec2<i32>(0), vec2<i32>(half_size) - vec2<i32>(1));\n      let z = textureLoad(u_depth_half_tex, s, 0).r;\n      let w = ao_weight(z - full_z, full_z,\n        select(f.x, 1.0 - f.x, x == 0) * select(f.y, 1.0 - f.y, y == 0));\n      sum = sum + textureLoad(u_ao_tex, s, 0).r * w;\n      total = total + w;\n    }\n  }\n  return select(1.0, sum / total, total > 0.0);\n}\n\n@fragment\nfn fs_gtao_apply(@builtin(position) frag_coord: vec4<f32>) -> @location(0) vec4<f32> {\n  let p = vec2<i32>(frag_coord.xy);\n  var hdr = textureLoad(u_hdr_tex, p, 0);\n  let full_z = textureLoad(u_depth_full_tex, p, 0).r;\n  let half_size = vec2<f32>(textureDimensions(u_ao_tex));\n  let uv_half = frag_coord.xy / vec2<f32>(textureDimensions(u_hdr_tex));\n  let ao = upsample_ao(uv_half, full_z, half_size);\n  let ao_mb = select(ao, ao_multi_bounce(ao), u_params.ao_multi_bounce != 0);\n\n  let sky = step(u_params.far * 0.999, full_z);\n  var w: f32;\n  if (hdr.a >= 1.5) {\n    // Tagged generated-program pixel: alpha = 2 + f_ind.\n    w = clamp(hdr.a - 2.0, 0.0, 1.0);\n  } else if (u_params.ao_indirect_fraction != 0) {\n    w = clamp(hdr.a, 0.0, 1.0);\n  } else {\n    let luma = dot(hdr.rgb, vec3<f32>(0.2126, 0.7152, 0.0722));\n    w = u_params.ao_fallback_strength * step(luma, 4.0);\n  }\n  w = w * (1.0 - sky);\n  hdr = vec4<f32>(hdr.rgb * mix(1.0, ao_mb, w), min(hdr.a, 1.0));\n  return hdr;\n}\n";
+//# sourceMappingURL=gtaoDenoise.wgsl.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"gtaoDenoise.wgsl.d.ts","sourceRoot":"","sources":["../../../../../../packages/rendering/src/post/shaders/gtaoDenoise.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAUH,eAAO,MAAM,iBAAiB,w5CA8B7B,CAAC;AAEF,eAAO,MAAM,eAAe,m6FAqE3B,CAAC"}

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

@@ -0,0 +1,117 @@
+/**
+ * PRD-03 §8.4 Phase 7 — S2 GTAO denoise + joint-bilateral upsample/apply
+ * WGSL twins. `GTAO_DENOISE_WGSL` runs twice (H then V). `GTAO_APPLY_WGSL`
+ * is the fused joint-bilateral upsample + §6.3 multiply
+ * (`hdr *= mix(1, aoMB, w)`; w = `clamp(hdr.a − 2, 0, 1)` on pixels tagged
+ * by `prd03.indirectFraction` (alpha = 2 + f_ind), else the conservative
+ * fallback `strength · step(luma, 4)`; both × (1 − sky); alpha → min(a, 1)).
+ */
+const BILATERAL = /* wgsl */ `
+// 5-tap gaussian (sigma 1.0) × exponential depth term exp(-|dz|/(0.05*z)).
+fn ao_weight(dz: f32, z: f32, g: f32) -> f32 {
+  return g * exp(-abs(dz) / max(0.05 * z, 1e-4));
+}
+const GAUSS_5 = array<f32, 5>(0.06136, 0.24477, 0.38774, 0.24477, 0.06136);
+`;
+export const GTAO_DENOISE_WGSL = /* wgsl */ `struct GtaoDenoiseParams {
+  dir: vec2<f32>,          // (texel.x, 0) then (0, texel.y)
+  _pad: vec2<f32>,
+};
+
+@group(0) @binding(0) var<uniform> u_params: GtaoDenoiseParams;
+@group(0) @binding(1) var u_ao_tex: texture_2d<f32>;       // half-res R8
+@group(0) @binding(2) var u_depth_half_tex: texture_2d<f32>; // half-res linear depth (.r)
+
+${BILATERAL}
+
+@fragment
+fn fs_gtao_denoise(@builtin(position) frag_coord: vec4<f32>) -> @location(0) vec4<f32> {
+  let p = vec2<i32>(frag_coord.xy);
+  let texel = vec2<f32>(textureDimensions(u_ao_tex));
+  let center_ao = textureLoad(u_ao_tex, p, 0).r;
+  let center_z = textureLoad(u_depth_half_tex, p, 0).r;
+  var total = GAUSS_5[2];
+  var sum = center_ao * GAUSS_5[2];
+  for (var i = -2; i <= 2; i = i + 1) {
+    if (i == 0) { continue; }
+    var s = p + vec2<i32>(u_params.dir * texel * f32(i));
+    s = clamp(s, vec2<i32>(0), vec2<i32>(texel) - vec2<i32>(1));
+    let z = textureLoad(u_depth_half_tex, s, 0).r;
+    let w = ao_weight(z - center_z, center_z, GAUSS_5[i + 2]);
+    sum = sum + textureLoad(u_ao_tex, s, 0).r * w;
+    total = total + w;
+  }
+  return vec4<f32>(sum / total, 0.0, 0.0, 1.0);
+}
+`;
+export const GTAO_APPLY_WGSL = /* wgsl */ `struct GtaoApplyParams {
+  far: f32,
+  ao_fallback_strength: f32,
+  ao_multi_bounce: i32,
+  ao_indirect_fraction: i32,  // AURA_AO_INDIRECT_FRACTION equivalent
+};
+
+@group(0) @binding(0) var<uniform> u_params: GtaoApplyParams;
+@group(0) @binding(1) var u_hdr_tex: texture_2d<f32>;        // full-res HDR (linear)
+@group(0) @binding(2) var u_ao_tex: texture_2d<f32>;         // denoised half-res R8
+@group(0) @binding(3) var u_depth_full_tex: texture_2d<f32>; // full-res linear depth
+@group(0) @binding(4) var u_depth_half_tex: texture_2d<f32>;
+
+${BILATERAL}
+
+// Jimenez 2016 multi-bounce polynomial, albedoProxy ρ = 0.5.
+fn ao_multi_bounce(ao: f32) -> f32 {
+  let a = 2.0404 * 0.5 - 0.3324;
+  let b = -4.7951 * 0.5 + 0.6417;
+  let c = 2.7552 * 0.5 + 0.6903;
+  return max(ao, ((ao * a + b) * ao + c) * ao);
+}
+
+// Joint-bilateral upsample: the four half-res taps around the bilinear
+// coordinate, weighted by depth similarity to the full-res texel.
+fn upsample_ao(uv_half: vec2<f32>, full_z: f32, half_size: vec2<f32>) -> f32 {
+  let p = uv_half * half_size - vec2<f32>(0.5);
+  let p0 = vec2<i32>(floor(p));
+  let f = p - vec2<f32>(p0);
+  var sum = 0.0;
+  var total = 0.0;
+  for (var y = 0; y < 2; y = y + 1) {
+    for (var x = 0; x < 2; x = x + 1) {
+      let s = clamp(p0 + vec2<i32>(x, y), vec2<i32>(0), vec2<i32>(half_size) - vec2<i32>(1));
+      let z = textureLoad(u_depth_half_tex, s, 0).r;
+      let w = ao_weight(z - full_z, full_z,
+        select(f.x, 1.0 - f.x, x == 0) * select(f.y, 1.0 - f.y, y == 0));
+      sum = sum + textureLoad(u_ao_tex, s, 0).r * w;
+      total = total + w;
+    }
+  }
+  return select(1.0, sum / total, total > 0.0);
+}
+
+@fragment
+fn fs_gtao_apply(@builtin(position) frag_coord: vec4<f32>) -> @location(0) vec4<f32> {
+  let p = vec2<i32>(frag_coord.xy);
+  var hdr = textureLoad(u_hdr_tex, p, 0);
+  let full_z = textureLoad(u_depth_full_tex, p, 0).r;
+  let half_size = vec2<f32>(textureDimensions(u_ao_tex));
+  let uv_half = frag_coord.xy / vec2<f32>(textureDimensions(u_hdr_tex));
+  let ao = upsample_ao(uv_half, full_z, half_size);
+  let ao_mb = select(ao, ao_multi_bounce(ao), u_params.ao_multi_bounce != 0);
+
+  let sky = step(u_params.far * 0.999, full_z);
+  var w: f32;
+  if (hdr.a >= 1.5) {
+    // Tagged generated-program pixel: alpha = 2 + f_ind.
+    w = clamp(hdr.a - 2.0, 0.0, 1.0);
+  } else if (u_params.ao_indirect_fraction != 0) {
+    w = clamp(hdr.a, 0.0, 1.0);
+  } else {
+    let luma = dot(hdr.rgb, vec3<f32>(0.2126, 0.7152, 0.0722));
+    w = u_params.ao_fallback_strength * step(luma, 4.0);
+  }
+  w = w * (1.0 - sky);
+  hdr = vec4<f32>(hdr.rgb * mix(1.0, ao_mb, w), min(hdr.a, 1.0));
+  return hdr;
+}
+`;
+//# sourceMappingURL=gtaoDenoise.wgsl.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"gtaoDenoise.wgsl.js","sourceRoot":"","sources":["../../../../../../packages/rendering/src/post/shaders/gtaoDenoise.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,MAAM,SAAS,GAAG,UAAU,CAAC;;;;;;CAM5B,CAAC;AAEF,MAAM,CAAC,MAAM,iBAAiB,GAAG,UAAU,CAAC;;;;;;;;;EAS1C,SAAS;;;;;;;;;;;;;;;;;;;;;CAqBV,CAAC;AAEF,MAAM,CAAC,MAAM,eAAe,GAAG,UAAU,CAAC;;;;;;;;;;;;;EAaxC,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwDV,CAAC"}

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

@@ -0,0 +1,21 @@
+/**
+ * PRD-03 §8.8 — S7 motion blur, McGuire 2012 tile reconstruction (WebGL2).
+ *
+ *   Pass 1 MB_TILE_MAX_GLSL   — per MB_TILE_SIZE tile: the velocity with the
+ *                               largest magnitude (direction preserved).
+ *   Pass 2 MB_NEIGHBOR_GLSL   — max of the 3×3 tile neighborhood so a fast
+ *                               object bleeds onto still pixels beside it.
+ *   Pass 3 MB_RECONSTRUCT_GLSL — per pixel: taps along the neighbor-max
+ *                               direction, soft depth compare (0.05 m) to
+ *                               keep background from being smeared by an
+ *                               unrelated foreground vector, IGN jitter.
+ *
+ * Velocity enters in UV units per frame; the driver scales it by
+ * `shutter · (targetFrameTime / actualFrameTime)` (C-23 timeScale goes into
+ * the authored shutter before it reaches this pass) and clamps to
+ * `maxBlurPx`.
+ */
+export declare const MB_TILE_MAX_GLSL = "#version 300 es\nprecision highp float;\n\nuniform highp sampler2D u_velocity; // dilated velocity (.rg), render res\nout vec4 o_color;\n\nvoid main() {\n  ivec2 tile = ivec2(gl_FragCoord.xy);\n  ivec2 size = textureSize(u_velocity, 0);\n  vec2 best = vec2(0.0);\n  float mag = 0.0;\n  for (int y = 0; y < MB_TILE_SIZE; y += 1) for (int x = 0; x < MB_TILE_SIZE; x += 1) {\n    ivec2 p = tile * MB_TILE_SIZE + ivec2(x, y);\n    if (p.x >= size.x || p.y >= size.y) continue;\n    vec2 v = texelFetch(u_velocity, p, 0).rg;\n    float m = dot(v, v);\n    if (m > mag) { mag = m; best = v; }\n  }\n  o_color = vec4(best, 0.0, 1.0);\n}\n";
+export declare const MB_NEIGHBOR_GLSL = "#version 300 es\nprecision highp float;\n\nuniform highp sampler2D u_tileMax;\nout vec4 o_color;\n\nvoid main() {\n  ivec2 tile = ivec2(gl_FragCoord.xy);\n  ivec2 size = textureSize(u_tileMax, 0);\n  vec2 best = vec2(0.0);\n  float mag = 0.0;\n  for (int y = -1; y <= 1; y += 1) for (int x = -1; x <= 1; x += 1) {\n    vec2 v = texelFetch(u_tileMax, clamp(tile + ivec2(x, y), ivec2(0), size - 1), 0).rg;\n    float m = dot(v, v);\n    if (m > mag) { mag = m; best = v; }\n  }\n  o_color = vec4(best, 0.0, 1.0);\n}\n";
+export declare const MB_RECONSTRUCT_GLSL = "#version 300 es\nprecision highp float;\n\nuniform highp sampler2D u_color;\nuniform highp sampler2D u_velocity;     // dilated velocity (.rg)\nuniform highp sampler2D u_neighbor;     // 3x3 tile max\nuniform highp sampler2D u_linearDepth;  // .r = viewZ metres\nuniform float u_shutter;                // authored shutter \u00B7 frameTime scale\nuniform float u_maxBlurPx;\nuniform int u_samples;                  // 8 | 12 | 16\nuniform int u_tileSize;\nuniform int u_frameIndex;\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\nfloat ign(vec2 pixel) {\n  // Interleaved gradient noise \u2014 per-pixel tap phase.\n  return fract(52.9829189 * fract(dot(pixel, vec2(0.06711056, 0.00583715)) + float(u_frameIndex) * 0.618034));\n}\n\nvoid main() {\n  ivec2 pixel = ivec2(gl_FragCoord.xy);\n  ivec2 size = textureSize(u_color, 0);\n  vec2 uv = (vec2(pixel) + 0.5) / vec2(size);\n  vec3 src = texelFetch(u_color, pixel, 0).rgb;\n  float zSelf = texelFetch(u_linearDepth, pixel, 0).r;\n\n  // Shutter\u00B7frame-time scale and pixel clamp happen once, on the tile vector.\n  vec2 tileV = texelFetch(u_neighbor, pixel / u_tileSize, 0).rg * u_shutter;\n  float maxLen = u_maxBlurPx / float(size.y);\n  if (length(tileV) > maxLen) tileV *= maxLen / length(tileV);\n\n  float jitter = ign(vec2(pixel));\n  vec3 sum = src;\n  float wsum = 1.0;\n  for (int i = 0; i < 16; i += 1) {\n    if (i >= u_samples) break;\n    float t = (float(i) + jitter) / float(u_samples - 1) - 0.5;\n    vec2 offset = tileV * t;\n    ivec2 tapPx = clamp(ivec2(floor((uv + offset) * vec2(size))), ivec2(0), size - 1);\n    vec3 c = texelFetch(u_color, tapPx, 0).rgb;\n    float zTap = texelFetch(u_linearDepth, tapPx, 0).r;\n    // Soft depth compare (0.05 m): taps on a different surface don't smear.\n    float depthW = clamp(1.0 - abs(zTap - zSelf) / 0.05, 0.0, 1.0);\n    // Coverage weight: a tap counts while the tile vector reaches it.\n    float reach = length(tileV) * abs(t);\n    float w = depthW * clamp(1.0 + length(tileV) * 0.5 - reach, 0.0, 1.0);\n    sum += c * w;\n    wsum += w;\n  }\n  o_color = vec4(sum / wsum, 1.0);\n}\n";
+//# sourceMappingURL=motionBlur.glsl.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"motionBlur.glsl.d.ts","sourceRoot":"","sources":["../../../../../../packages/rendering/src/post/shaders/motionBlur.glsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAQH,eAAO,MAAM,gBAAgB,4nBAkB5B,CAAC;AAEF,eAAO,MAAM,gBAAgB,wgBAgB5B,CAAC;AAEF,eAAO,MAAM,mBAAmB,ouFAmD/B,CAAC"}

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

@@ -0,0 +1,110 @@
+/**
+ * PRD-03 §8.8 — S7 motion blur, McGuire 2012 tile reconstruction (WebGL2).
+ *
+ *   Pass 1 MB_TILE_MAX_GLSL   — per MB_TILE_SIZE tile: the velocity with the
+ *                               largest magnitude (direction preserved).
+ *   Pass 2 MB_NEIGHBOR_GLSL   — max of the 3×3 tile neighborhood so a fast
+ *                               object bleeds onto still pixels beside it.
+ *   Pass 3 MB_RECONSTRUCT_GLSL — per pixel: taps along the neighbor-max
+ *                               direction, soft depth compare (0.05 m) to
+ *                               keep background from being smeared by an
+ *                               unrelated foreground vector, IGN jitter.
+ *
+ * Velocity enters in UV units per frame; the driver scales it by
+ * `shutter · (targetFrameTime / actualFrameTime)` (C-23 timeScale goes into
+ * the authored shutter before it reaches this pass) and clamps to
+ * `maxBlurPx`.
+ */
+import { POST_COMMON_GLSL } from "./common.glsl.js";
+const HEADER = `#version 300 es
+precision highp float;
+`;
+export const MB_TILE_MAX_GLSL = /* glsl */ `${HEADER}
+uniform highp sampler2D u_velocity; // dilated velocity (.rg), render res
+out vec4 o_color;
+
+void main() {
+  ivec2 tile = ivec2(gl_FragCoord.xy);
+  ivec2 size = textureSize(u_velocity, 0);
+  vec2 best = vec2(0.0);
+  float mag = 0.0;
+  for (int y = 0; y < MB_TILE_SIZE; y += 1) for (int x = 0; x < MB_TILE_SIZE; x += 1) {
+    ivec2 p = tile * MB_TILE_SIZE + ivec2(x, y);
+    if (p.x >= size.x || p.y >= size.y) continue;
+    vec2 v = texelFetch(u_velocity, p, 0).rg;
+    float m = dot(v, v);
+    if (m > mag) { mag = m; best = v; }
+  }
+  o_color = vec4(best, 0.0, 1.0);
+}
+`;
+export const MB_NEIGHBOR_GLSL = /* glsl */ `${HEADER}
+uniform highp sampler2D u_tileMax;
+out vec4 o_color;
+
+void main() {
+  ivec2 tile = ivec2(gl_FragCoord.xy);
+  ivec2 size = textureSize(u_tileMax, 0);
+  vec2 best = vec2(0.0);
+  float mag = 0.0;
+  for (int y = -1; y <= 1; y += 1) for (int x = -1; x <= 1; x += 1) {
+    vec2 v = texelFetch(u_tileMax, clamp(tile + ivec2(x, y), ivec2(0), size - 1), 0).rg;
+    float m = dot(v, v);
+    if (m > mag) { mag = m; best = v; }
+  }
+  o_color = vec4(best, 0.0, 1.0);
+}
+`;
+export const MB_RECONSTRUCT_GLSL = /* glsl */ `${HEADER}
+uniform highp sampler2D u_color;
+uniform highp sampler2D u_velocity;     // dilated velocity (.rg)
+uniform highp sampler2D u_neighbor;     // 3x3 tile max
+uniform highp sampler2D u_linearDepth;  // .r = viewZ metres
+uniform float u_shutter;                // authored shutter · frameTime scale
+uniform float u_maxBlurPx;
+uniform int u_samples;                  // 8 | 12 | 16
+uniform int u_tileSize;
+uniform int u_frameIndex;
+out vec4 o_color;
+
+${POST_COMMON_GLSL}
+
+float ign(vec2 pixel) {
+  // Interleaved gradient noise — per-pixel tap phase.
+  return fract(52.9829189 * fract(dot(pixel, vec2(0.06711056, 0.00583715)) + float(u_frameIndex) * 0.618034));
+}
+
+void main() {
+  ivec2 pixel = ivec2(gl_FragCoord.xy);
+  ivec2 size = textureSize(u_color, 0);
+  vec2 uv = (vec2(pixel) + 0.5) / vec2(size);
+  vec3 src = texelFetch(u_color, pixel, 0).rgb;
+  float zSelf = texelFetch(u_linearDepth, pixel, 0).r;
+
+  // Shutter·frame-time scale and pixel clamp happen once, on the tile vector.
+  vec2 tileV = texelFetch(u_neighbor, pixel / u_tileSize, 0).rg * u_shutter;
+  float maxLen = u_maxBlurPx / float(size.y);
+  if (length(tileV) > maxLen) tileV *= maxLen / length(tileV);
+
+  float jitter = ign(vec2(pixel));
+  vec3 sum = src;
+  float wsum = 1.0;
+  for (int i = 0; i < 16; i += 1) {
+    if (i >= u_samples) break;
+    float t = (float(i) + jitter) / float(u_samples - 1) - 0.5;
+    vec2 offset = tileV * t;
+    ivec2 tapPx = clamp(ivec2(floor((uv + offset) * vec2(size))), ivec2(0), size - 1);
+    vec3 c = texelFetch(u_color, tapPx, 0).rgb;
+    float zTap = texelFetch(u_linearDepth, tapPx, 0).r;
+    // Soft depth compare (0.05 m): taps on a different surface don't smear.
+    float depthW = clamp(1.0 - abs(zTap - zSelf) / 0.05, 0.0, 1.0);
+    // Coverage weight: a tap counts while the tile vector reaches it.
+    float reach = length(tileV) * abs(t);
+    float w = depthW * clamp(1.0 + length(tileV) * 0.5 - reach, 0.0, 1.0);
+    sum += c * w;
+    wsum += w;
+  }
+  o_color = vec4(sum / wsum, 1.0);
+}
+`;
+//# sourceMappingURL=motionBlur.glsl.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"motionBlur.glsl.js","sourceRoot":"","sources":["../../../../../../packages/rendering/src/post/shaders/motionBlur.glsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAEpD,MAAM,MAAM,GAAG;;CAEd,CAAC;AAEF,MAAM,CAAC,MAAM,gBAAgB,GAAG,UAAU,CAAC,GAAG,MAAM;;;;;;;;;;;;;;;;;;CAkBnD,CAAC;AAEF,MAAM,CAAC,MAAM,gBAAgB,GAAG,UAAU,CAAC,GAAG,MAAM;;;;;;;;;;;;;;;;CAgBnD,CAAC;AAEF,MAAM,CAAC,MAAM,mBAAmB,GAAG,UAAU,CAAC,GAAG,MAAM;;;;;;;;;;;;EAYrD,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuCjB,CAAC"}

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

@@ -0,0 +1,10 @@
+/**
+ * PRD-03 §8.8 Phase 7 — S7 motion blur WGSL twins, McGuire 2012 tile
+ * reconstruction: per-tile max velocity → 3×3 tile-neighborhood max →
+ * per-pixel taps along the neighbor-max direction with a soft depth
+ * compare (0.05 m) and IGN jitter. All inputs texelFetch-only.
+ */
+export declare const MB_TILE_MAX_WGSL = "// MB_TILE_SIZE \u2014 pipeline-overridable (authored motionBlur.tileSize, 16 default).\noverride MB_TILE_SIZE: i32 = 16;\n\n@group(0) @binding(1) var u_velocity_tex: texture_2d<f32>; // dilated velocity (.rg), render res\n\n@fragment\nfn fs_mb_tile_max(@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_velocity_tex));\n  var best = vec2<f32>(0.0);\n  var mag = 0.0;\n  for (var y = 0; y < MB_TILE_SIZE; y = y + 1) {\n    for (var x = 0; x < MB_TILE_SIZE; x = x + 1) {\n      let p = tile * MB_TILE_SIZE + vec2<i32>(x, y);\n      if (p.x >= size.x || p.y >= size.y) { continue; }\n      let v = textureLoad(u_velocity_tex, p, 0).rg;\n      let m = dot(v, v);\n      if (m > mag) { mag = m; best = v; }\n    }\n  }\n  return vec4<f32>(best, 0.0, 1.0);\n}\n";
+export declare const MB_NEIGHBOR_WGSL = "@group(0) @binding(1) var u_tile_max_tex: texture_2d<f32>;\n\n@fragment\nfn fs_mb_neighbor(@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_tile_max_tex));\n  var best = vec2<f32>(0.0);\n  var mag = 0.0;\n  for (var y = -1; y <= 1; y = y + 1) {\n    for (var x = -1; x <= 1; x = x + 1) {\n      let v = textureLoad(u_tile_max_tex, clamp(tile + vec2<i32>(x, y), vec2<i32>(0), size - vec2<i32>(1)), 0).rg;\n      let m = dot(v, v);\n      if (m > mag) { mag = m; best = v; }\n    }\n  }\n  return vec4<f32>(best, 0.0, 1.0);\n}\n";
+export declare const MB_RECONSTRUCT_WGSL = "struct MbReconstructParams {\n  shutter: f32,            // authored shutter \u00B7 frameTime scale\n  max_blur_px: f32,\n  samples: i32,            // 8 | 12 | 16\n  tile_size: i32,\n  frame_index: i32,\n  _pad: vec3<f32>,\n};\n\n@group(0) @binding(0) var<uniform> u_params: MbReconstructParams;\n@group(0) @binding(1) var u_color_tex: texture_2d<f32>;\n@group(0) @binding(2) var u_velocity_tex: texture_2d<f32>;     // dilated velocity (.rg)\n@group(0) @binding(3) var u_neighbor_tex: texture_2d<f32>;     // 3x3 tile max\n@group(0) @binding(4) var u_linear_depth_tex: texture_2d<f32>; // .r = viewZ metres\n\nfn mb_ign(pixel: vec2<f32>, frame_index: i32) -> f32 {\n  // Interleaved gradient noise \u2014 per-pixel tap phase.\n  return fract(52.9829189 * fract(dot(pixel, vec2<f32>(0.06711056, 0.00583715)) + f32(frame_index) * 0.618034));\n}\n\n@fragment\nfn fs_mb_reconstruct(@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_color_tex));\n  let uv = (vec2<f32>(pixel) + vec2<f32>(0.5)) / vec2<f32>(size);\n  let src = textureLoad(u_color_tex, pixel, 0).rgb;\n  let z_self = textureLoad(u_linear_depth_tex, pixel, 0).r;\n\n  // Shutter\u00B7frame-time scale and pixel clamp happen once, on the tile vector.\n  var tile_v = textureLoad(u_neighbor_tex, pixel / u_params.tile_size, 0).rg * u_params.shutter;\n  let max_len = u_params.max_blur_px / f32(size.y);\n  if (length(tile_v) > max_len) { tile_v = tile_v * (max_len / length(tile_v)); }\n\n  let jitter = mb_ign(vec2<f32>(pixel), u_params.frame_index);\n  var sum = src;\n  var wsum = 1.0;\n  for (var i = 0; i < 16; i = i + 1) {\n    if (i >= u_params.samples) { break; }\n    let t = (f32(i) + jitter) / f32(u_params.samples - 1) - 0.5;\n    let offset = tile_v * t;\n    let tap_px = clamp(vec2<i32>(floor((uv + offset) * vec2<f32>(size))), vec2<i32>(0), size - vec2<i32>(1));\n    let c = textureLoad(u_color_tex, tap_px, 0).rgb;\n    let z_tap = textureLoad(u_linear_depth_tex, tap_px, 0).r;\n    // Soft depth compare (0.05 m): taps on a different surface don't smear.\n    let depth_w = clamp(1.0 - abs(z_tap - z_self) / 0.05, 0.0, 1.0);\n    // Coverage weight: a tap counts while the tile vector reaches it.\n    let reach = length(tile_v) * abs(t);\n    let w = depth_w * clamp(1.0 + length(tile_v) * 0.5 - reach, 0.0, 1.0);\n    sum = sum + c * w;\n    wsum = wsum + w;\n  }\n  return vec4<f32>(sum / wsum, 1.0);\n}\n";
+//# sourceMappingURL=motionBlur.wgsl.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"motionBlur.wgsl.d.ts","sourceRoot":"","sources":["../../../../../../packages/rendering/src/post/shaders/motionBlur.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,eAAO,MAAM,gBAAgB,i2BAsB5B,CAAC;AAEF,eAAO,MAAM,gBAAgB,4nBAiB5B,CAAC;AAEF,eAAO,MAAM,mBAAmB,g8EAqD/B,CAAC"}

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

@@ -0,0 +1,102 @@
+/**
+ * PRD-03 §8.8 Phase 7 — S7 motion blur WGSL twins, McGuire 2012 tile
+ * reconstruction: per-tile max velocity → 3×3 tile-neighborhood max →
+ * per-pixel taps along the neighbor-max direction with a soft depth
+ * compare (0.05 m) and IGN jitter. All inputs texelFetch-only.
+ */
+export const MB_TILE_MAX_WGSL = /* wgsl */ `// MB_TILE_SIZE — pipeline-overridable (authored motionBlur.tileSize, 16 default).
+override MB_TILE_SIZE: i32 = 16;
+
+@group(0) @binding(1) var u_velocity_tex: texture_2d<f32>; // dilated velocity (.rg), render res
+
+@fragment
+fn fs_mb_tile_max(@builtin(position) frag_coord: vec4<f32>) -> @location(0) vec4<f32> {
+  let tile = vec2<i32>(frag_coord.xy);
+  let size = vec2<i32>(textureDimensions(u_velocity_tex));
+  var best = vec2<f32>(0.0);
+  var mag = 0.0;
+  for (var y = 0; y < MB_TILE_SIZE; y = y + 1) {
+    for (var x = 0; x < MB_TILE_SIZE; x = x + 1) {
+      let p = tile * MB_TILE_SIZE + vec2<i32>(x, y);
+      if (p.x >= size.x || p.y >= size.y) { continue; }
+      let v = textureLoad(u_velocity_tex, p, 0).rg;
+      let m = dot(v, v);
+      if (m > mag) { mag = m; best = v; }
+    }
+  }
+  return vec4<f32>(best, 0.0, 1.0);
+}
+`;
+export const MB_NEIGHBOR_WGSL = /* wgsl */ `@group(0) @binding(1) var u_tile_max_tex: texture_2d<f32>;
+
+@fragment
+fn fs_mb_neighbor(@builtin(position) frag_coord: vec4<f32>) -> @location(0) vec4<f32> {
+  let tile = vec2<i32>(frag_coord.xy);
+  let size = vec2<i32>(textureDimensions(u_tile_max_tex));
+  var best = vec2<f32>(0.0);
+  var mag = 0.0;
+  for (var y = -1; y <= 1; y = y + 1) {
+    for (var x = -1; x <= 1; x = x + 1) {
+      let v = textureLoad(u_tile_max_tex, clamp(tile + vec2<i32>(x, y), vec2<i32>(0), size - vec2<i32>(1)), 0).rg;
+      let m = dot(v, v);
+      if (m > mag) { mag = m; best = v; }
+    }
+  }
+  return vec4<f32>(best, 0.0, 1.0);
+}
+`;
+export const MB_RECONSTRUCT_WGSL = /* wgsl */ `struct MbReconstructParams {
+  shutter: f32,            // authored shutter · frameTime scale
+  max_blur_px: f32,
+  samples: i32,            // 8 | 12 | 16
+  tile_size: i32,
+  frame_index: i32,
+  _pad: vec3<f32>,
+};
+
+@group(0) @binding(0) var<uniform> u_params: MbReconstructParams;
+@group(0) @binding(1) var u_color_tex: texture_2d<f32>;
+@group(0) @binding(2) var u_velocity_tex: texture_2d<f32>;     // dilated velocity (.rg)
+@group(0) @binding(3) var u_neighbor_tex: texture_2d<f32>;     // 3x3 tile max
+@group(0) @binding(4) var u_linear_depth_tex: texture_2d<f32>; // .r = viewZ metres
+
+fn mb_ign(pixel: vec2<f32>, frame_index: i32) -> f32 {
+  // Interleaved gradient noise — per-pixel tap phase.
+  return fract(52.9829189 * fract(dot(pixel, vec2<f32>(0.06711056, 0.00583715)) + f32(frame_index) * 0.618034));
+}
+
+@fragment
+fn fs_mb_reconstruct(@builtin(position) frag_coord: vec4<f32>) -> @location(0) vec4<f32> {
+  let pixel = vec2<i32>(frag_coord.xy);
+  let size = vec2<i32>(textureDimensions(u_color_tex));
+  let uv = (vec2<f32>(pixel) + vec2<f32>(0.5)) / vec2<f32>(size);
+  let src = textureLoad(u_color_tex, pixel, 0).rgb;
+  let z_self = textureLoad(u_linear_depth_tex, pixel, 0).r;
+
+  // Shutter·frame-time scale and pixel clamp happen once, on the tile vector.
+  var tile_v = textureLoad(u_neighbor_tex, pixel / u_params.tile_size, 0).rg * u_params.shutter;
+  let max_len = u_params.max_blur_px / f32(size.y);
+  if (length(tile_v) > max_len) { tile_v = tile_v * (max_len / length(tile_v)); }
+
+  let jitter = mb_ign(vec2<f32>(pixel), u_params.frame_index);
+  var sum = src;
+  var wsum = 1.0;
+  for (var i = 0; i < 16; i = i + 1) {
+    if (i >= u_params.samples) { break; }
+    let t = (f32(i) + jitter) / f32(u_params.samples - 1) - 0.5;
+    let offset = tile_v * t;
+    let tap_px = clamp(vec2<i32>(floor((uv + offset) * vec2<f32>(size))), vec2<i32>(0), size - vec2<i32>(1));
+    let c = textureLoad(u_color_tex, tap_px, 0).rgb;
+    let z_tap = textureLoad(u_linear_depth_tex, tap_px, 0).r;
+    // Soft depth compare (0.05 m): taps on a different surface don't smear.
+    let depth_w = clamp(1.0 - abs(z_tap - z_self) / 0.05, 0.0, 1.0);
+    // Coverage weight: a tap counts while the tile vector reaches it.
+    let reach = length(tile_v) * abs(t);
+    let w = depth_w * clamp(1.0 + length(tile_v) * 0.5 - reach, 0.0, 1.0);
+    sum = sum + c * w;
+    wsum = wsum + w;
+  }
+  return vec4<f32>(sum / wsum, 1.0);
+}
+`;
+//# sourceMappingURL=motionBlur.wgsl.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"motionBlur.wgsl.js","sourceRoot":"","sources":["../../../../../../packages/rendering/src/post/shaders/motionBlur.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,MAAM,CAAC,MAAM,gBAAgB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;CAsB1C,CAAC;AAEF,MAAM,CAAC,MAAM,gBAAgB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;CAiB1C,CAAC;AAEF,MAAM,CAAC,MAAM,mBAAmB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqD7C,CAAC"}

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

@@ -0,0 +1,28 @@
+/**
+ * PRD-03 §8.14 — SMAA 1x ("medium"): three passes ported verbatim from three
+ * r185 `examples/jsm/shaders/SMAAShader.js` (MIT; WebGL port of SMAA v2.8 by
+ * the three.js authors, algorithm by Jorge Jimenez et al.).
+ *
+ * Conventions matching the rest of `post/shaders/`: `#version 300 es`,
+ * `in vec2 v_uv`, `out vec4 outColor`. three's vertex shaders only computed
+ * the `vOffset`/`vPixcoord` varyings — they are pure functions of `v_uv` and
+ * the texel-size uniform, so this port computes them in the fragment
+ * preamble (`SMAAEdgeDetectionVS` → `smaaOffsets*` below), byte-identical
+ * math. `texture2D(x, uv, 0.0)` → `texture(x, uv)` (LOD 0 = lod-0 chain
+ * rules do not apply to full-screen post targets; the v2 targets carry a
+ * single mip).
+ *
+ * `u_resolution` is the texel size `vec2(1/w, 1/h)` (three names it
+ * `resolution` and feeds `Vector2(1/w, 1/h)` — same value, pipeline name).
+ * AreaTex/SearchTex arrive from the `post/smaa/` lazy chunk.
+ */
+/** Pass 1 — `SMAAColorEdgeDetectionPS` (colour edges, threshold 0.1). */
+export declare const SMAA_EDGES_GLSL = "#version 300 es\nprecision highp float;\n#define SMAA_THRESHOLD 0.1\nuniform sampler2D u_color;\nuniform vec2 u_resolution;\nin vec2 v_uv;\nout vec4 outColor;\n\nvec4 SMAAColorEdgeDetectionPS( vec2 texcoord, vec4 offset[3], sampler2D colorTex ) {\n\tvec2 threshold = vec2( SMAA_THRESHOLD, SMAA_THRESHOLD );\n\n\t// Calculate color deltas:\n\tvec4 delta;\n\tvec3 C = texture( colorTex, texcoord ).rgb;\n\n\tvec3 Cleft = texture( colorTex, offset[0].xy ).rgb;\n\tvec3 t = abs( C - Cleft );\n\tdelta.x = max( max( t.r, t.g ), t.b );\n\n\tvec3 Ctop = texture( colorTex, offset[0].zw ).rgb;\n\tt = abs( C - Ctop );\n\tdelta.y = max( max( t.r, t.g ), t.b );\n\n\t// We do the usual threshold:\n\tvec2 edges = step( threshold, delta.xy );\n\n\t// Then discard if there is no edge:\n\tif ( dot( edges, vec2( 1.0, 1.0 ) ) == 0.0 )\n\t\tdiscard;\n\n\t// Calculate right and bottom deltas:\n\tvec3 Cright = texture( colorTex, offset[1].xy ).rgb;\n\tt = abs( C - Cright );\n\tdelta.z = max( max( t.r, t.g ), t.b );\n\n\tvec3 Cbottom  = texture( colorTex, offset[1].zw ).rgb;\n\tt = abs( C - Cbottom );\n\tdelta.w = max( max( t.r, t.g ), t.b );\n\n\t// Calculate the maximum delta in the direct neighborhood:\n\tfloat maxDelta = max( max( max( delta.x, delta.y ), delta.z ), delta.w );\n\n\t// Calculate left-left and top-top deltas:\n\tvec3 Cleftleft  = texture( colorTex, offset[2].xy ).rgb;\n\tt = abs( C - Cleftleft );\n\tdelta.z = max( max( t.r, t.g ), t.b );\n\n\tvec3 Ctoptop = texture( colorTex, offset[2].zw ).rgb;\n\tt = abs( C - Ctoptop );\n\tdelta.w = max( max( t.r, t.g ), t.b );\n\n\t// Calculate the final maximum delta:\n\tmaxDelta = max( max( maxDelta, delta.z ), delta.w );\n\n\t// Local contrast adaptation in action:\n\tedges.xy *= step( 0.5 * maxDelta, delta.xy );\n\n\treturn vec4( edges, 0.0, 0.0 );\n}\n\nvoid main() {\n\t// three's SMAAEdgeDetectionVS offsets, computed fragment-side (identical\n\t// values \u2014 the offsets are a pure function of texcoord + resolution).\n\tvec4 vOffset0 = v_uv.xyxy + u_resolution.xyxy * vec4( -1.0, 0.0, 0.0,  1.0 );\n\tvec4 vOffset1 = v_uv.xyxy + u_resolution.xyxy * vec4(  1.0, 0.0, 0.0, -1.0 );\n\tvec4 vOffset2 = v_uv.xyxy + u_resolution.xyxy * vec4( -2.0, 0.0, 0.0,  2.0 );\n\tvec4 vOffset[3] = vec4[3]( vOffset0, vOffset1, vOffset2 );\n\toutColor = SMAAColorEdgeDetectionPS( v_uv, vOffset, u_color );\n}\n";
+/**
+ * Pass 2 — `SMAABlendingWeightCalculationPS` (SMAA_MAX_SEARCH_STEPS 8,
+ * AreaTex 160×560 RG, SearchTex 66×33 R, no diagonal search).
+ */
+export declare const SMAA_WEIGHTS_GLSL = "#version 300 es\nprecision highp float;\n#define SMAA_MAX_SEARCH_STEPS 8\n#define SMAA_AREATEX_MAX_DISTANCE 16\n#define SMAA_AREATEX_PIXEL_SIZE ( 1.0 / vec2( 160.0, 560.0 ) )\n#define SMAA_AREATEX_SUBTEX_SIZE ( 1.0 / 7.0 )\n#define SMAASampleLevelZeroOffset( tex, coord, offset ) texture( tex, coord + vec2( offset ) * u_resolution )\n\nuniform sampler2D u_edges;   // the pass-1 edges surface (three tDiffuse)\nuniform sampler2D u_area;\nuniform sampler2D u_search;\nuniform vec2 u_resolution;\nin vec2 v_uv;\nout vec4 outColor;\n\nfloat SMAASearchLength( sampler2D searchTex, vec2 e, float bias, float scale ) {\n\t// Not required if searchTex accesses are set to point:\n\t// float2 SEARCH_TEX_PIXEL_SIZE = 1.0 / float2(66.0, 33.0);\n\t// e = float2(bias, 0.0) + 0.5 * SEARCH_TEX_PIXEL_SIZE +\n\t//     e * float2(scale, 1.0) * float2(64.0, 32.0) * SEARCH_TEX_PIXEL_SIZE;\n\te.r = bias + e.r * scale;\n\treturn 255.0 * texture( searchTex, e ).r;\n}\n\nfloat SMAASearchXLeft( sampler2D edgesTex, sampler2D searchTex, vec2 texcoord, float end ) {\n\t/**\n\t\t* @PSEUDO_GATHER4\n\t\t* This texcoord has been offset by (-0.25, -0.125) in the vertex shader to\n\t\t* sample between edge, thus fetching four edges in a row.\n\t\t* Sampling with different offsets in each direction allows to disambiguate\n\t\t* which edges are active from the four fetched ones.\n\t\t*/\n\tvec2 e = vec2( 0.0, 1.0 );\n\n\tfor ( int i = 0; i < SMAA_MAX_SEARCH_STEPS; i ++ ) { // WebGL port note: Changed while to for\n\t\te = texture( edgesTex, texcoord ).rg;\n\t\ttexcoord -= vec2( 2.0, 0.0 ) * u_resolution;\n\t\tif ( ! ( texcoord.x > end && e.g > 0.8281 && e.r == 0.0 ) ) break;\n\t}\n\n\t// We correct the previous (-0.25, -0.125) offset we applied:\n\ttexcoord.x += 0.25 * u_resolution.x;\n\n\t// The searches are bias by 1, so adjust the coords accordingly:\n\ttexcoord.x += u_resolution.x;\n\n\t// Disambiguate the length added by the last step:\n\ttexcoord.x += 2.0 * u_resolution.x; // Undo last step\n\ttexcoord.x -= u_resolution.x * SMAASearchLength(searchTex, e, 0.0, 0.5);\n\n\treturn texcoord.x;\n}\n\nfloat SMAASearchXRight( sampler2D edgesTex, sampler2D searchTex, vec2 texcoord, float end ) {\n\tvec2 e = vec2( 0.0, 1.0 );\n\n\tfor ( int i = 0; i < SMAA_MAX_SEARCH_STEPS; i ++ ) {\n\t\te = texture( edgesTex, texcoord ).rg;\n\t\ttexcoord += vec2( 2.0, 0.0 ) * u_resolution;\n\t\tif ( ! ( texcoord.x < end && e.g > 0.8281 && e.r == 0.0 ) ) break;\n\t}\n\n\ttexcoord.x -= 0.25 * u_resolution.x;\n\ttexcoord.x -= u_resolution.x;\n\ttexcoord.x -= 2.0 * u_resolution.x;\n\ttexcoord.x += u_resolution.x * SMAASearchLength( searchTex, e, 0.5, 0.5 );\n\n\treturn texcoord.x;\n}\n\nfloat SMAASearchYUp( sampler2D edgesTex, sampler2D searchTex, vec2 texcoord, float end ) {\n\tvec2 e = vec2( 1.0, 0.0 );\n\n\tfor ( int i = 0; i < SMAA_MAX_SEARCH_STEPS; i ++ ) {\n\t\te = texture( edgesTex, texcoord ).rg;\n\t\ttexcoord += vec2( 0.0, 2.0 ) * u_resolution; // WebGL port note: Changed sign\n\t\tif ( ! ( texcoord.y > end && e.r > 0.8281 && e.g == 0.0 ) ) break;\n\t}\n\n\ttexcoord.y -= 0.25 * u_resolution.y; // WebGL port note: Changed sign\n\ttexcoord.y -= u_resolution.y; // WebGL port note: Changed sign\n\ttexcoord.y -= 2.0 * u_resolution.y; // WebGL port note: Changed sign\n\ttexcoord.y += u_resolution.y * SMAASearchLength( searchTex, e.gr, 0.0, 0.5 ); // WebGL port note: Changed sign\n\n\treturn texcoord.y;\n}\n\nfloat SMAASearchYDown( sampler2D edgesTex, sampler2D searchTex, vec2 texcoord, float end ) {\n\tvec2 e = vec2( 1.0, 0.0 );\n\n\tfor ( int i = 0; i < SMAA_MAX_SEARCH_STEPS; i ++ ) {\n\t\te = texture( edgesTex, texcoord ).rg;\n\t\ttexcoord -= vec2( 0.0, 2.0 ) * u_resolution; // WebGL port note: Changed sign\n\t\tif ( ! ( texcoord.y < end && e.r > 0.8281 && e.g == 0.0 ) ) break;\n\t}\n\n\ttexcoord.y += 0.25 * u_resolution.y; // WebGL port note: Changed sign\n\ttexcoord.y += u_resolution.y; // WebGL port note: Changed sign\n\ttexcoord.y += 2.0 * u_resolution.y; // WebGL port note: Changed sign\n\ttexcoord.y -= u_resolution.y * SMAASearchLength( searchTex, e.gr, 0.5, 0.5 ); // WebGL port note: Changed sign\n\n\treturn texcoord.y;\n}\n\nvec2 SMAAArea( sampler2D areaTex, vec2 dist, float e1, float e2, float offset ) {\n\t// Rounding prevents precision errors of bilinear filtering:\n\tvec2 texcoord = float( SMAA_AREATEX_MAX_DISTANCE ) * round( 4.0 * vec2( e1, e2 ) ) + dist;\n\n\t// We do a scale and bias for mapping to texel space:\n\ttexcoord = SMAA_AREATEX_PIXEL_SIZE * texcoord + ( 0.5 * SMAA_AREATEX_PIXEL_SIZE );\n\n\t// Move to proper place, according to the subpixel offset:\n\ttexcoord.y += SMAA_AREATEX_SUBTEX_SIZE * offset;\n\n\treturn texture( areaTex, texcoord ).rg;\n}\n\nvec4 SMAABlendingWeightCalculationPS( vec2 texcoord, vec2 pixcoord, vec4 offset[ 3 ], sampler2D edgesTex, sampler2D areaTex, sampler2D searchTex, ivec4 subsampleIndices ) {\n\tvec4 weights = vec4( 0.0, 0.0, 0.0, 0.0 );\n\n\tvec2 e = texture( edgesTex, texcoord ).rg;\n\n\tif ( e.g > 0.0 ) { // Edge at north\n\t\tvec2 d;\n\n\t\t// Find the distance to the left:\n\t\tvec2 coords;\n\t\tcoords.x = SMAASearchXLeft( edgesTex, searchTex, offset[ 0 ].xy, offset[ 2 ].x );\n\t\tcoords.y = offset[ 1 ].y; // offset[1].y = texcoord.y - 0.25 * resolution.y (@CROSSING_OFFSET)\n\t\td.x = coords.x;\n\n\t\t// Now fetch the left crossing edges, two at a time using bilinear\n\t\t// filtering. Sampling at -0.25 (see @CROSSING_OFFSET) enables to\n\t\t// discern what value each edge has:\n\t\tfloat e1 = texture( edgesTex, coords ).r;\n\n\t\t// Find the distance to the right:\n\t\tcoords.x = SMAASearchXRight( edgesTex, searchTex, offset[ 0 ].zw, offset[ 2 ].y );\n\t\td.y = coords.x;\n\n\t\t// We want the distances to be in pixel units (doing this here allow to\n\t\t// better interleave arithmetic and memory accesses):\n\t\td = d / u_resolution.x - pixcoord.x;\n\n\t\t// SMAAArea below needs a sqrt, as the areas texture is compressed\n\t\t// quadratically:\n\t\tvec2 sqrt_d = sqrt( abs( d ) );\n\n\t\t// Fetch the right crossing edges:\n\t\tcoords.y -= 1.0 * u_resolution.y; // WebGL port note: Added\n\t\tfloat e2 = SMAASampleLevelZeroOffset( edgesTex, coords, ivec2( 1, 0 ) ).r;\n\n\t\t// Ok, we know how this pattern looks like, now it is time for getting\n\t\t// the actual area:\n\t\tweights.rg = SMAAArea( areaTex, sqrt_d, e1, e2, float( subsampleIndices.y ) );\n\t}\n\n\tif ( e.r > 0.0 ) { // Edge at west\n\t\tvec2 d;\n\n\t\t// Find the distance to the top:\n\t\tvec2 coords;\n\n\t\tcoords.y = SMAASearchYUp( edgesTex, searchTex, offset[ 1 ].xy, offset[ 2 ].z );\n\t\tcoords.x = offset[ 0 ].x; // offset[1].x = texcoord.x - 0.25 * resolution.x;\n\t\td.x = coords.y;\n\n\t\t// Fetch the top crossing edges:\n\t\tfloat e1 = texture( edgesTex, coords ).g;\n\n\t\t// Find the distance to the bottom:\n\t\tcoords.y = SMAASearchYDown( edgesTex, searchTex, offset[ 1 ].zw, offset[ 2 ].w );\n\t\td.y = coords.y;\n\n\t\t// We want the distances to be in pixel units:\n\t\td = d / u_resolution.y - pixcoord.y;\n\n\t\t// SMAAArea below needs a sqrt, as the areas texture is compressed\n\t\t// quadratically:\n\t\tvec2 sqrt_d = sqrt( abs( d ) );\n\n\t\t// Fetch the bottom crossing edges:\n\t\tcoords.y -= 1.0 * u_resolution.y; // WebGL port note: Added\n\t\tfloat e2 = SMAASampleLevelZeroOffset( edgesTex, coords, ivec2( 0, 1 ) ).g;\n\n\t\t// Get the area for this direction:\n\t\tweights.ba = SMAAArea( areaTex, sqrt_d, e1, e2, float( subsampleIndices.x ) );\n\t}\n\n\treturn weights;\n}\n\nvoid main() {\n\t// three's SMAABlendingWeightCalculationVS varyings, computed fragment-side.\n\tvec2 vPixcoord = v_uv / u_resolution;\n\tvec4 vOffset0 = v_uv.xyxy + u_resolution.xyxy * vec4( -0.25, 0.125, 1.25, 0.125 );\n\tvec4 vOffset1 = v_uv.xyxy + u_resolution.xyxy * vec4( -0.125, 0.25, -0.125, -1.25 );\n\tvec4 vOffset2 = vec4( vOffset0.xz, vOffset1.yw ) + vec4( -2.0, 2.0, -2.0, 2.0 ) * u_resolution.xxyy * float( SMAA_MAX_SEARCH_STEPS );\n\tvec4 vOffset[3] = vec4[3]( vOffset0, vOffset1, vOffset2 );\n\toutColor = SMAABlendingWeightCalculationPS( v_uv, vPixcoord, vOffset, u_edges, u_area, u_search, ivec4( 0 ) );\n}\n";
+/** Pass 3 — `SMAANeighborhoodBlendingPS` (`u_weights` = three `tDiffuse`, `u_color` = three `tColor`). */
+export declare const SMAA_BLEND_GLSL = "#version 300 es\nprecision highp float;\nuniform sampler2D u_weights;  // three tDiffuse \u2014 the blend-weights surface\nuniform sampler2D u_color;    // three tColor \u2014 the colour surface\nuniform vec2 u_resolution;\nin vec2 v_uv;\nout vec4 outColor;\n\nvec4 SMAANeighborhoodBlendingPS( vec2 texcoord, vec4 offset[ 2 ], sampler2D colorTex, sampler2D blendTex ) {\n\t// Fetch the blending weights for current pixel:\n\tvec4 a;\n\ta.xz = texture( blendTex, texcoord ).xz;\n\ta.y = texture( blendTex, offset[ 1 ].zw ).g;\n\ta.w = texture( blendTex, offset[ 1 ].xy ).a;\n\n\t// Is there any blending weight with a value greater than 0.0?\n\tif ( dot(a, vec4( 1.0, 1.0, 1.0, 1.0 )) < 1e-5 ) {\n\t\treturn texture( colorTex, texcoord );\n\t} else {\n\t\t// Up to 4 lines can be crossing a pixel (one through each edge). We\n\t\t// favor blending by choosing the line with the maximum weight for each\n\t\t// direction:\n\t\tvec2 offset;\n\t\toffset.x = a.a > a.b ? a.a : -a.b; // left vs. right\n\t\toffset.y = a.g > a.r ? -a.g : a.r; // top vs. bottom // WebGL port note: Changed signs\n\n\t\t// Then we go in the direction that has the maximum weight:\n\t\tif ( abs( offset.x ) > abs( offset.y )) { // horizontal vs. vertical\n\t\t\toffset.y = 0.0;\n\t\t} else {\n\t\t\toffset.x = 0.0;\n\t\t}\n\n\t\t// Fetch the opposite color and lerp by hand:\n\t\tvec4 C = texture( colorTex, texcoord );\n\t\ttexcoord += sign( offset ) * u_resolution;\n\t\tvec4 Cop = texture( colorTex, texcoord );\n\t\tfloat s = abs( offset.x ) > abs( offset.y ) ? abs( offset.x ) : abs( offset.y );\n\n\t\t// WebGL port note: Added gamma correction\n\t\tC.xyz = pow(C.xyz, vec3(2.2));\n\t\tCop.xyz = pow(Cop.xyz, vec3(2.2));\n\t\tvec4 mixed = mix(C, Cop, s);\n\t\tmixed.xyz = pow(mixed.xyz, vec3(1.0 / 2.2));\n\n\t\treturn mixed;\n\t}\n}\n\nvoid main() {\n\t// three's SMAANeighborhoodBlendingVS varyings, computed fragment-side.\n\tvec4 vOffset0 = v_uv.xyxy + u_resolution.xyxy * vec4( -1.0, 0.0, 0.0, 1.0 );\n\tvec4 vOffset1 = v_uv.xyxy + u_resolution.xyxy * vec4( 1.0, 0.0, 0.0, -1.0 );\n\tvec4 vOffset[2] = vec4[2]( vOffset0, vOffset1 );\n\toutColor = SMAANeighborhoodBlendingPS( v_uv, vOffset, u_color, u_weights );\n}\n";
+//# sourceMappingURL=smaa.glsl.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"smaa.glsl.d.ts","sourceRoot":"","sources":["../../../../../../packages/rendering/src/post/shaders/smaa.glsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,yEAAyE;AACzE,eAAO,MAAM,eAAe,8zEAqE3B,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,iBAAiB,k7PAyM7B,CAAC;AAEF,0GAA0G;AAC1G,eAAO,MAAM,eAAe,8pEAwD3B,CAAC"}