@aura3d/rendering 3.0.1 → 4.0.0

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

@@ -0,0 +1,375 @@
+/**
+ * PRD-03 §8.14 Phase 7 — SMAA 1x WGSL twins (three passes, verbatim port of
+ * the GLSL twins, themselves three r185 `SMAAShader.js` — MIT; WebGL port of
+ * SMAA v2.8 by the three.js authors, algorithm by Jorge Jimenez et al.).
+ *
+ * three's vertex-computed `vOffset`/`vPixcoord` varyings are pure functions
+ * of uv + texel size — computed fragment-side, identical math.
+ * `SMAASampleLevelZeroOffset` = `textureLevel(tex, uv + offset·texel, 0)`.
+ * `u_resolution` is the texel size `vec2(1/w, 1/h)` (same value as the GL
+ * twin's `u_resolution`; three names it `resolution`).
+ * AreaTex/SearchTex arrive from the `post/smaa/` lazy chunk — areaTex needs
+ * a linear sampler, searchTex point (declared as separate samplers).
+ */
+/** Pass 1 — `SMAAColorEdgeDetectionPS` (colour edges, threshold 0.1). */
+export const SMAA_EDGES_WGSL = /* wgsl */ `const SMAA_THRESHOLD: f32 = 0.1;
+
+struct SmaaEdgesParams {
+  resolution: vec2<f32>,   // texel size 1/w, 1/h
+  _pad: vec2<f32>,
+};
+
+@group(0) @binding(0) var<uniform> u_params: SmaaEdgesParams;
+@group(0) @binding(1) var u_color_tex: texture_2d<f32>;
+@group(0) @binding(2) var u_color_smp: sampler;
+
+fn smaa_color_edge_detection(texcoord: vec2<f32>, offset: array<vec4<f32>, 3>, color_tex: texture_2d<f32>, color_smp: sampler) -> vec4<f32> {
+  let threshold = vec2<f32>(SMAA_THRESHOLD, SMAA_THRESHOLD);
+
+  // Calculate color deltas:
+  var delta: vec4<f32>;
+  let c = textureSampleLevel(color_tex, color_smp, texcoord, 0.0).rgb;
+
+  let c_left = textureSampleLevel(color_tex, color_smp, offset[0].xy, 0.0).rgb;
+  var t = abs(c - c_left);
+  delta.x = max(max(t.r, t.g), t.b);
+
+  let c_top = textureSampleLevel(color_tex, color_smp, offset[0].zw, 0.0).rgb;
+  t = abs(c - c_top);
+  delta.y = max(max(t.r, t.g), t.b);
+
+  // We do the usual threshold:
+  var edges = step(threshold, delta.xy);
+
+  // Then discard if there is no edge:
+  if (dot(edges, vec2<f32>(1.0, 1.0)) == 0.0) {
+    discard;
+  }
+
+  // Calculate right and bottom deltas:
+  let c_right = textureSampleLevel(color_tex, color_smp, offset[1].xy, 0.0).rgb;
+  t = abs(c - c_right);
+  delta.z = max(max(t.r, t.g), t.b);
+
+  let c_bottom = textureSampleLevel(color_tex, color_smp, offset[1].zw, 0.0).rgb;
+  t = abs(c - c_bottom);
+  delta.w = max(max(t.r, t.g), t.b);
+
+  // Calculate the maximum delta in the direct neighborhood:
+  var max_delta = max(max(max(delta.x, delta.y), delta.z), delta.w);
+
+  // Calculate left-left and top-top deltas:
+  let c_left_left = textureSampleLevel(color_tex, color_smp, offset[2].xy, 0.0).rgb;
+  t = abs(c - c_left_left);
+  delta.z = max(max(t.r, t.g), t.b);
+
+  let c_top_top = textureSampleLevel(color_tex, color_smp, offset[2].zw, 0.0).rgb;
+  t = abs(c - c_top_top);
+  delta.w = max(max(t.r, t.g), t.b);
+
+  // Calculate the final maximum delta:
+  max_delta = max(max(max_delta, delta.z), delta.w);
+
+  // Local contrast adaptation in action:
+  edges = edges * step(vec2<f32>(0.5 * max_delta), delta.xy);
+
+  return vec4<f32>(edges, 0.0, 0.0);
+}
+
+@fragment
+fn fs_smaa_edges(@location(0) uv: vec2<f32>) -> @location(0) vec4<f32> {
+  // three's SMAAEdgeDetectionVS offsets, computed fragment-side (identical
+  // values — the offsets are a pure function of texcoord + resolution).
+  let v_offset0 = uv.xyxy + u_params.resolution.xyxy * vec4<f32>(-1.0, 0.0, 0.0, 1.0);
+  let v_offset1 = uv.xyxy + u_params.resolution.xyxy * vec4<f32>(1.0, 0.0, 0.0, -1.0);
+  let v_offset2 = uv.xyxy + u_params.resolution.xyxy * vec4<f32>(-2.0, 0.0, 0.0, 2.0);
+  let v_offset = array<vec4<f32>, 3>(v_offset0, v_offset1, v_offset2);
+  return smaa_color_edge_detection(uv, v_offset, u_color_tex, u_color_smp);
+}
+`;
+/** Pass 2 — `SMAABlendingWeightCalculationPS` (max search 8, no diagonal). */
+export const SMAA_WEIGHTS_WGSL = /* wgsl */ `const SMAA_MAX_SEARCH_STEPS: i32 = 8;
+const SMAA_AREATEX_MAX_DISTANCE: f32 = 16.0;
+const SMAA_AREATEX_PIXEL_SIZE: vec2<f32> = vec2<f32>(1.0 / 160.0, 1.0 / 560.0);
+const SMAA_AREATEX_SUBTEX_SIZE: f32 = 1.0 / 7.0;
+
+struct SmaaWeightsParams {
+  resolution: vec2<f32>,   // texel size 1/w, 1/h
+  _pad: vec2<f32>,
+};
+
+@group(0) @binding(0) var<uniform> u_params: SmaaWeightsParams;
+@group(0) @binding(1) var u_edges_tex: texture_2d<f32>;   // the pass-1 edges surface (three tDiffuse)
+@group(0) @binding(2) var u_edges_smp: sampler;
+@group(0) @binding(3) var u_area_tex: texture_2d<f32>;
+@group(0) @binding(4) var u_area_smp: sampler;            // linear
+@group(0) @binding(5) var u_search_tex: texture_2d<f32>;
+@group(0) @binding(6) var u_search_smp: sampler;          // point/nearest
+
+fn smaa_sample_level_zero_offset(tex: texture_2d<f32>, smp: sampler, coord: vec2<f32>, offset: vec2<i32>) -> vec4<f32> {
+  return textureSampleLevel(tex, smp, coord + vec2<f32>(offset) * u_params.resolution, 0.0);
+}
+
+fn smaa_search_length(search_tex: texture_2d<f32>, search_smp: sampler, e: vec2<f32>, bias: f32, scale: f32) -> f32 {
+  // Not required if searchTex accesses are set to point:
+  // float2 SEARCH_TEX_PIXEL_SIZE = 1.0 / float2(66.0, 33.0);
+  // e = float2(bias, 0.0) + 0.5 * SEARCH_TEX_PIXEL_SIZE +
+  //     e * float2(scale, 1.0) * float2(64.0, 32.0) * SEARCH_TEX_PIXEL_SIZE;
+  var e2 = e;
+  e2.r = bias + e.r * scale;
+  return 255.0 * textureSampleLevel(search_tex, search_smp, e2, 0.0).r;
+}
+
+fn smaa_search_x_left(edges_tex: texture_2d<f32>, edges_smp: sampler, search_tex: texture_2d<f32>, search_smp: sampler, texcoord_in: vec2<f32>, end_coord: f32) -> f32 {
+  /**
+   * @PSEUDO_GATHER4
+   * This texcoord has been offset by (-0.25, -0.125) in the vertex shader to
+   * sample between edge, thus fetching four edges in a row.
+   * Sampling with different offsets in each direction allows to disambiguate
+   * which edges are active from the four fetched ones.
+   */
+  var e = vec2<f32>(0.0, 1.0);
+  var texcoord = texcoord_in;
+
+  for (var i = 0; i < SMAA_MAX_SEARCH_STEPS; i = i + 1) { // WebGL port note: Changed while to for
+    e = textureSampleLevel(edges_tex, edges_smp, texcoord, 0.0).rg;
+    texcoord = texcoord - vec2<f32>(2.0, 0.0) * u_params.resolution;
+    if (!(texcoord.x > end_coord && e.g > 0.8281 && e.r == 0.0)) { break; }
+  }
+
+  // We correct the previous (-0.25, -0.125) offset we applied:
+  texcoord.x = texcoord.x + 0.25 * u_params.resolution.x;
+
+  // The searches are bias by 1, so adjust the coords accordingly:
+  texcoord.x = texcoord.x + u_params.resolution.x;
+
+  // Disambiguate the length added by the last step:
+  texcoord.x = texcoord.x + 2.0 * u_params.resolution.x; // Undo last step
+  texcoord.x = texcoord.x - u_params.resolution.x * smaa_search_length(search_tex, search_smp, e, 0.0, 0.5);
+
+  return texcoord.x;
+}
+
+fn smaa_search_x_right(edges_tex: texture_2d<f32>, edges_smp: sampler, search_tex: texture_2d<f32>, search_smp: sampler, texcoord_in: vec2<f32>, end_coord: f32) -> f32 {
+  var e = vec2<f32>(0.0, 1.0);
+  var texcoord = texcoord_in;
+
+  for (var i = 0; i < SMAA_MAX_SEARCH_STEPS; i = i + 1) {
+    e = textureSampleLevel(edges_tex, edges_smp, texcoord, 0.0).rg;
+    texcoord = texcoord + vec2<f32>(2.0, 0.0) * u_params.resolution;
+    if (!(texcoord.x < end_coord && e.g > 0.8281 && e.r == 0.0)) { break; }
+  }
+
+  texcoord.x = texcoord.x - 0.25 * u_params.resolution.x;
+  texcoord.x = texcoord.x - u_params.resolution.x;
+  texcoord.x = texcoord.x - 2.0 * u_params.resolution.x;
+  texcoord.x = texcoord.x + u_params.resolution.x * smaa_search_length(search_tex, search_smp, e, 0.5, 0.5);
+
+  return texcoord.x;
+}
+
+fn smaa_search_y_up(edges_tex: texture_2d<f32>, edges_smp: sampler, search_tex: texture_2d<f32>, search_smp: sampler, texcoord_in: vec2<f32>, end_coord: f32) -> f32 {
+  var e = vec2<f32>(1.0, 0.0);
+  var texcoord = texcoord_in;
+
+  for (var i = 0; i < SMAA_MAX_SEARCH_STEPS; i = i + 1) {
+    e = textureSampleLevel(edges_tex, edges_smp, texcoord, 0.0).rg;
+    texcoord = texcoord + vec2<f32>(0.0, 2.0) * u_params.resolution; // WebGL port note: Changed sign
+    if (!(texcoord.y > end_coord && e.r > 0.8281 && e.g == 0.0)) { break; }
+  }
+
+  texcoord.y = texcoord.y - 0.25 * u_params.resolution.y; // WebGL port note: Changed sign
+  texcoord.y = texcoord.y - u_params.resolution.y; // WebGL port note: Changed sign
+  texcoord.y = texcoord.y - 2.0 * u_params.resolution.y; // WebGL port note: Changed sign
+  texcoord.y = texcoord.y + u_params.resolution.y * smaa_search_length(search_tex, search_smp, vec2<f32>(e.g, e.r), 0.0, 0.5); // WebGL port note: Changed sign
+
+  return texcoord.y;
+}
+
+fn smaa_search_y_down(edges_tex: texture_2d<f32>, edges_smp: sampler, search_tex: texture_2d<f32>, search_smp: sampler, texcoord_in: vec2<f32>, end_coord: f32) -> f32 {
+  var e = vec2<f32>(1.0, 0.0);
+  var texcoord = texcoord_in;
+
+  for (var i = 0; i < SMAA_MAX_SEARCH_STEPS; i = i + 1) {
+    e = textureSampleLevel(edges_tex, edges_smp, texcoord, 0.0).rg;
+    texcoord = texcoord - vec2<f32>(0.0, 2.0) * u_params.resolution; // WebGL port note: Changed sign
+    if (!(texcoord.y < end_coord && e.r > 0.8281 && e.g == 0.0)) { break; }
+  }
+
+  texcoord.y = texcoord.y + 0.25 * u_params.resolution.y; // WebGL port note: Changed sign
+  texcoord.y = texcoord.y + u_params.resolution.y; // WebGL port note: Changed sign
+  texcoord.y = texcoord.y + 2.0 * u_params.resolution.y; // WebGL port note: Changed sign
+  texcoord.y = texcoord.y - u_params.resolution.y * smaa_search_length(search_tex, search_smp, vec2<f32>(e.g, e.r), 0.5, 0.5); // WebGL port note: Changed sign
+
+  return texcoord.y;
+}
+
+fn smaa_area(area_tex: texture_2d<f32>, area_smp: sampler, dist: vec2<f32>, e1: f32, e2: f32, offset: f32) -> vec2<f32> {
+  // Rounding prevents precision errors of bilinear filtering:
+  var texcoord = SMAA_AREATEX_MAX_DISTANCE * round(4.0 * vec2<f32>(e1, e2)) + dist;
+
+  // We do a scale and bias for mapping to texel space:
+  texcoord = SMAA_AREATEX_PIXEL_SIZE * texcoord + (0.5 * SMAA_AREATEX_PIXEL_SIZE);
+
+  // Move to proper place, according to the subpixel offset:
+  texcoord.y = texcoord.y + SMAA_AREATEX_SUBTEX_SIZE * offset;
+
+  return textureSampleLevel(area_tex, area_smp, texcoord, 0.0).rg;
+}
+
+fn smaa_blending_weight_calculation(texcoord: vec2<f32>, pixcoord: vec2<f32>, offset: array<vec4<f32>, 3>, edges_tex: texture_2d<f32>, edges_smp: sampler, area_tex: texture_2d<f32>, area_smp: sampler, search_tex: texture_2d<f32>, search_smp: sampler, subsample_indices: vec4<i32>) -> vec4<f32> {
+  var weights = vec4<f32>(0.0, 0.0, 0.0, 0.0);
+
+  let e = textureSampleLevel(edges_tex, edges_smp, texcoord, 0.0).rg;
+
+  if (e.g > 0.0) { // Edge at north
+    var d: vec2<f32>;
+
+    // Find the distance to the left:
+    var coords: vec2<f32>;
+    coords.x = smaa_search_x_left(edges_tex, edges_smp, search_tex, search_smp, offset[0].xy, offset[2].x);
+    coords.y = offset[1].y; // offset[1].y = texcoord.y - 0.25 * resolution.y (@CROSSING_OFFSET)
+    d.x = coords.x;
+
+    // Now fetch the left crossing edges, two at a time using bilinear
+    // filtering. Sampling at -0.25 (see @CROSSING_OFFSET) enables to
+    // discern what value each edge has:
+    let e1 = textureSampleLevel(edges_tex, edges_smp, coords, 0.0).r;
+
+    // Find the distance to the right:
+    coords.x = smaa_search_x_right(edges_tex, edges_smp, search_tex, search_smp, offset[0].zw, offset[2].y);
+    d.y = coords.x;
+
+    // We want the distances to be in pixel units (doing this here allow to
+    // better interleave arithmetic and memory accesses):
+    d = d / u_params.resolution.x - vec2<f32>(pixcoord.x);
+
+    // smaa_area below needs a sqrt, as the areas texture is compressed
+    // quadratically:
+    let sqrt_d = sqrt(abs(d));
+
+    // Fetch the right crossing edges:
+    coords.y = coords.y - 1.0 * u_params.resolution.y; // WebGL port note: Added
+    let e2 = smaa_sample_level_zero_offset(edges_tex, edges_smp, coords, vec2<i32>(1, 0)).r;
+
+    // Ok, we know how this pattern looks like, now it is time for getting
+    // the actual area:
+    let area = smaa_area(area_tex, area_smp, sqrt_d, e1, e2, f32(subsample_indices.y));
+    weights.x = area.x;
+    weights.y = area.y;
+  }
+
+  if (e.r > 0.0) { // Edge at west
+    var d: vec2<f32>;
+
+    // Find the distance to the top:
+    var coords: vec2<f32>;
+
+    coords.y = smaa_search_y_up(edges_tex, edges_smp, search_tex, search_smp, offset[1].xy, offset[2].z);
+    coords.x = offset[0].x; // offset[1].x = texcoord.x - 0.25 * resolution.x;
+    d.x = coords.y;
+
+    // Fetch the top crossing edges:
+    let e1 = textureSampleLevel(edges_tex, edges_smp, coords, 0.0).g;
+
+    // Find the distance to the bottom:
+    coords.y = smaa_search_y_down(edges_tex, edges_smp, search_tex, search_smp, offset[1].zw, offset[2].w);
+    d.y = coords.y;
+
+    // We want the distances to be in pixel units:
+    d = d / u_params.resolution.y - vec2<f32>(pixcoord.y);
+
+    // smaa_area below needs a sqrt, as the areas texture is compressed
+    // quadratically:
+    let sqrt_d = sqrt(abs(d));
+
+    // Fetch the bottom crossing edges:
+    coords.y = coords.y - 1.0 * u_params.resolution.y; // WebGL port note: Added
+    let e2 = smaa_sample_level_zero_offset(edges_tex, edges_smp, coords, vec2<i32>(0, 1)).g;
+
+    // Get the area for this direction:
+    let area = smaa_area(area_tex, area_smp, sqrt_d, e1, e2, f32(subsample_indices.x));
+    weights.z = area.x;
+    weights.w = area.y;
+  }
+
+  return weights;
+}
+
+@fragment
+fn fs_smaa_weights(@location(0) uv: vec2<f32>) -> @location(0) vec4<f32> {
+  // three's SMAABlendingWeightCalculationVS varyings, computed fragment-side.
+  let v_pixcoord = uv / u_params.resolution;
+  let v_offset0 = uv.xyxy + u_params.resolution.xyxy * vec4<f32>(-0.25, 0.125, 1.25, 0.125);
+  let v_offset1 = uv.xyxy + u_params.resolution.xyxy * vec4<f32>(-0.125, 0.25, -0.125, -1.25);
+  let v_offset2 = vec4<f32>(v_offset0.xz, v_offset1.yw) + vec4<f32>(-2.0, 2.0, -2.0, 2.0) * u_params.resolution.xxyy * f32(SMAA_MAX_SEARCH_STEPS);
+  let v_offset = array<vec4<f32>, 3>(v_offset0, v_offset1, v_offset2);
+  return smaa_blending_weight_calculation(uv, v_pixcoord, v_offset, u_edges_tex, u_edges_smp, u_area_tex, u_area_smp, u_search_tex, u_search_smp, vec4<i32>(0));
+}
+`;
+/** Pass 3 — `SMAANeighborhoodBlendingPS` (`u_weights` = three `tDiffuse`, `u_color` = three `tColor`). */
+export const SMAA_BLEND_WGSL = /* wgsl */ `struct SmaaBlendParams {
+  resolution: vec2<f32>,   // texel size 1/w, 1/h
+  _pad: vec2<f32>,
+};
+
+@group(0) @binding(0) var<uniform> u_params: SmaaBlendParams;
+@group(0) @binding(1) var u_weights_tex: texture_2d<f32>;  // three tDiffuse — the blend-weights surface
+@group(0) @binding(2) var u_weights_smp: sampler;
+@group(0) @binding(3) var u_color_tex: texture_2d<f32>;    // three tColor — the colour surface
+@group(0) @binding(4) var u_color_smp: sampler;
+
+fn smaa_neighborhood_blending(texcoord_in: vec2<f32>, offset: array<vec4<f32>, 2>, color_tex: texture_2d<f32>, color_smp: sampler, blend_tex: texture_2d<f32>, blend_smp: sampler) -> vec4<f32> {
+  // Fetch the blending weights for current pixel:
+  var a: vec4<f32>;
+  let axz = textureSampleLevel(blend_tex, blend_smp, texcoord_in, 0.0).xz;
+  a.x = axz.x;
+  a.z = axz.y;
+  a.y = textureSampleLevel(blend_tex, blend_smp, offset[1].zw, 0.0).g;
+  a.w = textureSampleLevel(blend_tex, blend_smp, offset[1].xy, 0.0).a;
+
+  // Is there any blending weight with a value greater than 0.0?
+  if (dot(a, vec4<f32>(1.0, 1.0, 1.0, 1.0)) < 1e-5) {
+    return textureSampleLevel(color_tex, color_smp, texcoord_in, 0.0);
+  } else {
+    // Up to 4 lines can be crossing a pixel (one through each edge). We
+    // favor blending by choosing the line with the maximum weight for each
+    // direction:
+    var offset: vec2<f32>;
+    offset.x = select(-a.b, a.a, a.a > a.b); // left vs. right
+    offset.y = select(a.r, -a.g, a.g > a.r); // top vs. bottom // WebGL port note: Changed signs
+
+    // Then we go in the direction that has the maximum weight:
+    if (abs(offset.x) > abs(offset.y)) { // horizontal vs. vertical
+      offset.y = 0.0;
+    } else {
+      offset.x = 0.0;
+    }
+
+    // Fetch the opposite color and lerp by hand:
+    var texcoord = texcoord_in;
+    var c = textureSampleLevel(color_tex, color_smp, texcoord, 0.0);
+    texcoord = texcoord + sign(offset) * u_params.resolution;
+    let c_op = textureSampleLevel(color_tex, color_smp, texcoord, 0.0);
+    let s = select(abs(offset.y), abs(offset.x), abs(offset.x) > abs(offset.y));
+
+    // WebGL port note: Added gamma correction
+    c = vec4<f32>(pow(c.xyz, vec3<f32>(2.2)), c.w);
+    let c_op_gamma = pow(c_op.xyz, vec3<f32>(2.2));
+    var mixed = mix(c, vec4<f32>(c_op_gamma, c_op.w), s);
+    mixed = vec4<f32>(pow(mixed.xyz, vec3<f32>(1.0 / 2.2)), mixed.w);
+
+    return mixed;
+  }
+}
+
+@fragment
+fn fs_smaa_blend(@location(0) uv: vec2<f32>) -> @location(0) vec4<f32> {
+  // three's SMAANeighborhoodBlendingVS varyings, computed fragment-side.
+  let v_offset0 = uv.xyxy + u_params.resolution.xyxy * vec4<f32>(-1.0, 0.0, 0.0, 1.0);
+  let v_offset1 = uv.xyxy + u_params.resolution.xyxy * vec4<f32>(1.0, 0.0, 0.0, -1.0);
+  let v_offset = array<vec4<f32>, 2>(v_offset0, v_offset1);
+  return smaa_neighborhood_blending(uv, v_offset, u_color_tex, u_color_smp, u_weights_tex, u_weights_smp);
+}
+`;
+//# sourceMappingURL=smaa.wgsl.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"smaa.wgsl.js","sourceRoot":"","sources":["../../../../../../packages/rendering/src/post/shaders/smaa.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,yEAAyE;AACzE,MAAM,CAAC,MAAM,eAAe,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0EzC,CAAC;AAEF,8EAA8E;AAC9E,MAAM,CAAC,MAAM,iBAAiB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0N3C,CAAC;AAEF,0GAA0G;AAC1G,MAAM,CAAC,MAAM,eAAe,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+DzC,CAAC"}

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

@@ -0,0 +1,23 @@
+/**
+ * PRD-03 §8.6 — S5 temporal anti-aliasing resolve (WebGL2).
+ *
+ * Per the PRD: reproject history by the closest-depth 3×3 velocity
+ * (velocityDilate pass), fetch history through the 5-tap Catmull-Rom kernel
+ * ported verbatim from the legacy `taaProgram` accumulation path, clip the
+ * reconstructed history against the current 3×3 neighborhood in YCoCg with
+ * `μ ± γσ` (clip, not clamp — box sides move with the distribution), a
+ * motion-dependent `γ = mix(0.5, varianceGamma, (1 − motionFactor)²)`, a
+ * depth disocclusion test `|prevLinZ − expectedZ| > 0.1·z → weight 0`, a
+ * feedback weight `mix(feedbackMin, feedbackMax, 1 − saturate(|v|·size/2px))`
+ * with the reactive mask biasing feedback to 0.5, and a Karis-weighted HDR
+ * resolve so >1.0 history cannot streak.
+ *
+ * `TAA_RESOLVE_GLSL` runs at render resolution writing the new history.
+ * `TAA_UPSCALE_GLSL` (§8.6 TAAU, when pipeline.renderScale < 1) then
+ * reconstructs that resolved frame at display resolution with a 9-tap
+ * Blackman-Harris kernel — a single-pass EASU-style upsample.
+ */
+export declare const TAA_RESOLVE_GLSL = "#version 300 es\nprecision highp float;\n\nuniform highp sampler2D u_current;        // jittered HDR current frame\nuniform highp sampler2D u_history;        // last resolved frame\nuniform highp sampler2D u_velocityDilate; // vec4(vx, vy, linZCurr, _)\nuniform highp sampler2D u_linZPrev;       // last frame's linear depth (.r)\nuniform sampler2D u_reactive;             // C-14 reactive mask (or 1\u00D71 zero)\nuniform bool u_hasReactive;\nuniform bool u_hasHistory;\nuniform float u_feedbackMin;\nuniform float u_feedbackMax;\nuniform float u_varianceGamma;\nout vec4 o_color;\n\nvec4 cubicWeights(float f) {\n  float f2 = f * f, f3 = f2 * f;\n  return vec4(-0.5*f + f2 - 0.5*f3, 1.0 - 2.5*f2 + 1.5*f3, 0.5*f + 2.0*f2 - 1.5*f3, -0.5*f2 + 0.5*f3);\n}\n\n// \u00A78.6: Catmull-Rom history fetch (ported from the legacy accumulation path).\nvec4 historyAt(vec2 uv) {\n  ivec2 size = textureSize(u_history, 0);\n  vec2 position = uv * vec2(size) - 0.5;\n  ivec2 base = ivec2(floor(position));\n  vec4 wx = cubicWeights(fract(position.x)), wy = cubicWeights(fract(position.y));\n  vec4 result = vec4(0.0);\n  for (int y = 0; y < 4; y++) for (int x = 0; x < 4; x++) {\n    result += texelFetch(u_history, clamp(base + ivec2(x - 1, y - 1), ivec2(0), size - 1), 0) * wx[x] * wy[y];\n  }\n  return result;\n}\n\nvec3 rgbToYCoCg(vec3 c) { return vec3(c.r * 0.25 + c.g * 0.5 + c.b * 0.25, c.r * 0.5 - c.b * 0.5, -c.r * 0.25 + c.g * 0.5 - c.b * 0.25); }\nvec3 ycocgToRgb(vec3 c) { return vec3(c.x + c.y - c.z, c.x + c.z, c.x - c.y - c.z); }\nfloat luma(vec3 c) { return dot(c, vec3(0.2126, 0.7152, 0.0722)); }\n\nvoid main() {\n  ivec2 pixel = ivec2(gl_FragCoord.xy);\n  ivec2 size = textureSize(u_current, 0);\n  vec2 uv = (vec2(pixel) + 0.5) / vec2(size);\n\n  vec4 velTex = texelFetch(u_velocityDilate, pixel, 0);\n  vec2 velocity = velTex.rg;\n  vec2 uvPrev = uv - velocity;\n\n  // Current pixel + Karis-weighted 3\u00D73 neighborhood stats in YCoCg.\n  vec3 current = texelFetch(u_current, pixel, 0).rgb;\n  vec3 mu = vec3(0.0), m2 = vec3(0.0);\n  float wsum = 0.0;\n  for (int y = -1; y <= 1; y += 1) for (int x = -1; x <= 1; x += 1) {\n    vec3 tap = texelFetch(u_current, clamp(pixel + ivec2(x, y), ivec2(0), size - 1), 0).rgb;\n    // Karis weight tames HDR fireflies inside the clip box.\n    float w = 1.0 / (1.0 + luma(tap));\n    vec3 yc = rgbToYCoCg(tap);\n    mu += yc * w;\n    m2 += yc * yc * w;\n    wsum += w;\n  }\n  mu /= wsum;\n  vec3 sigma = sqrt(max(m2 / wsum - mu * mu, vec3(0.0)));\n\n  if (!u_hasHistory) {\n    o_color = vec4(current, 1.0);\n    return;\n  }\n\n  // A static texel reprojects onto itself: read it directly. Resampling it\n  // through the Catmull-Rom kernel every frame was measured (promote-run\n  // probes on prd03-taa) to pull history ~0.09 px per frame, so at 0.97\n  // feedback a static 1-px line drifted a full pixel and rang below it.\n  vec3 history = length(velocity * vec2(size)) < 1e-3\n    ? texelFetch(u_history, clamp(pixel, ivec2(0), textureSize(u_history, 0) - 1), 0).rgb\n    : historyAt(uvPrev).rgb;\n  vec3 historyYc = rgbToYCoCg(history);\n\n  // Motion-scaled variance: fast pixels trust the box more (\u03B3\u21920.5).\n  float motionPx = length(velocity * vec2(size));\n  float motionFactor = clamp(motionPx / 2.0, 0.0, 1.0);\n  float gamma = mix(0.5, u_varianceGamma, (1.0 - motionFactor) * (1.0 - motionFactor));\n  vec3 lo = mu - gamma * sigma;\n  vec3 hi = mu + gamma * sigma;\n  historyYc = clamp(historyYc, lo, hi);\n  history = ycocgToRgb(historyYc);\n\n  // Disocclusion: |prevLinZ \u2212 expectedZ| > 0.1\u00B7z \u2192 drop history.\n  bool outOfBounds = any(lessThan(uvPrev, vec2(0.0))) || any(greaterThanEqual(uvPrev, vec2(1.0)));\n  float zCurr = velTex.b;\n  // The test spans the previous frame's 3\u00D73 depth range around the\n  // reprojected texel: sub-pixel jitter moves thin geometry (1-px lines,\n  // silhouettes) on/off a texel every frame, and a single-tap compare read\n  // that coverage change as a disocclusion \u2014 history was dropped on every\n  // edge texel and the \"resolve\" degenerated to the last jittered frame.\n  ivec2 zSize = textureSize(u_linZPrev, 0);\n  ivec2 prevPixel = ivec2(clamp(uvPrev, vec2(0.0), vec2(1.0)) * vec2(zSize));\n  float zPrevMin = 3.4e38, zPrevMax = 0.0;\n  for (int y = -1; y <= 1; y += 1) for (int x = -1; x <= 1; x += 1) {\n    float zTap = texelFetch(u_linZPrev, clamp(prevPixel + ivec2(x, y), ivec2(0), zSize - 1), 0).r;\n    zPrevMin = min(zPrevMin, zTap);\n    zPrevMax = max(zPrevMax, zTap);\n  }\n  bool disoccluded = zCurr < zPrevMin - 0.1 * zCurr || zCurr > zPrevMax + 0.1 * zCurr;\n\n  // Reactive mask (C-14) overrides accumulation; absent the attachment, a\n  // luminance delta between current and reprojected history is the proxy.\n  float reactive = texture(u_reactive, uv).r;\n  if (!u_hasReactive) {\n    reactive = abs(luma(current) - luma(history)) > 0.5 ? 1.0 : 0.0;\n  }\n\n  float feedback = mix(u_feedbackMin, u_feedbackMax, 1.0 - clamp(motionPx / 2.0, 0.0, 1.0));\n  feedback = mix(feedback, 0.5, clamp(reactive, 0.0, 1.0));\n  if (outOfBounds || disoccluded) feedback = 0.0;\n\n  vec3 resolved = mix(current, history, feedback);\n  o_color = vec4(max(resolved, vec3(0.0)), 1.0);\n}\n";
+/** §8.6 TAAU: 9-tap Blackman-Harris reconstruct of the render-res resolved frame. */
+export declare const TAA_UPSCALE_GLSL = "#version 300 es\nprecision highp float;\n\nuniform highp sampler2D u_resolved; // render-res TAA output (this frame)\nuniform vec2 u_renderSize;          // render resolution (input texel space)\nuniform vec2 u_outputSize;          // display resolution (draw target size)\nout vec4 o_color;\n\nfloat blackmanHarris(float x) {\n  // N=9 window kernel, |x| \u2208 [0, 1.5] inside the 3\u00D73 footprint.\n  float ax = abs(x) / 1.5;\n  if (ax >= 1.0) return 0.0;\n  return 0.35875 + 0.48829 * cos(3.14159265 * ax) + 0.14128 * cos(2.0 * 3.14159265 * ax) + 0.01168 * cos(3.0 * 3.14159265 * ax);\n}\n\nvoid main() {\n  // Output pixel \u2192 render-res source position.\n  vec2 srcPos = (gl_FragCoord.xy / u_outputSize) * u_renderSize - 0.5;\n  ivec2 base = ivec2(floor(srcPos));\n  vec2 f = srcPos - vec2(base);\n  vec3 sum = vec3(0.0);\n  float wsum = 0.0;\n  ivec2 rSize = ivec2(u_renderSize);\n  for (int y = -1; y <= 1; y += 1) for (int x = -1; x <= 1; x += 1) {\n    float w = blackmanHarris(float(x) - f.x) * blackmanHarris(float(y) - f.y);\n    sum += texelFetch(u_resolved, clamp(base + ivec2(x, y), ivec2(0), rSize - 1), 0).rgb * w;\n    wsum += w;\n  }\n  o_color = vec4(sum / max(wsum, 1e-6), 1.0);\n}\n";
+//# sourceMappingURL=taa.glsl.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"taa.glsl.d.ts","sourceRoot":"","sources":["../../../../../../packages/rendering/src/post/shaders/taa.glsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAMH,eAAO,MAAM,gBAAgB,6nKAmH5B,CAAC;AAEF,qFAAqF;AACrF,eAAO,MAAM,gBAAgB,+rCA4B5B,CAAC"}

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

@@ -0,0 +1,169 @@
+/**
+ * PRD-03 §8.6 — S5 temporal anti-aliasing resolve (WebGL2).
+ *
+ * Per the PRD: reproject history by the closest-depth 3×3 velocity
+ * (velocityDilate pass), fetch history through the 5-tap Catmull-Rom kernel
+ * ported verbatim from the legacy `taaProgram` accumulation path, clip the
+ * reconstructed history against the current 3×3 neighborhood in YCoCg with
+ * `μ ± γσ` (clip, not clamp — box sides move with the distribution), a
+ * motion-dependent `γ = mix(0.5, varianceGamma, (1 − motionFactor)²)`, a
+ * depth disocclusion test `|prevLinZ − expectedZ| > 0.1·z → weight 0`, a
+ * feedback weight `mix(feedbackMin, feedbackMax, 1 − saturate(|v|·size/2px))`
+ * with the reactive mask biasing feedback to 0.5, and a Karis-weighted HDR
+ * resolve so >1.0 history cannot streak.
+ *
+ * `TAA_RESOLVE_GLSL` runs at render resolution writing the new history.
+ * `TAA_UPSCALE_GLSL` (§8.6 TAAU, when pipeline.renderScale < 1) then
+ * reconstructs that resolved frame at display resolution with a 9-tap
+ * Blackman-Harris kernel — a single-pass EASU-style upsample.
+ */
+const HEADER = `#version 300 es
+precision highp float;
+`;
+export const TAA_RESOLVE_GLSL = /* glsl */ `${HEADER}
+uniform highp sampler2D u_current;        // jittered HDR current frame
+uniform highp sampler2D u_history;        // last resolved frame
+uniform highp sampler2D u_velocityDilate; // vec4(vx, vy, linZCurr, _)
+uniform highp sampler2D u_linZPrev;       // last frame's linear depth (.r)
+uniform sampler2D u_reactive;             // C-14 reactive mask (or 1×1 zero)
+uniform bool u_hasReactive;
+uniform bool u_hasHistory;
+uniform float u_feedbackMin;
+uniform float u_feedbackMax;
+uniform float u_varianceGamma;
+out vec4 o_color;
+
+vec4 cubicWeights(float f) {
+  float f2 = f * f, f3 = f2 * f;
+  return vec4(-0.5*f + f2 - 0.5*f3, 1.0 - 2.5*f2 + 1.5*f3, 0.5*f + 2.0*f2 - 1.5*f3, -0.5*f2 + 0.5*f3);
+}
+
+// §8.6: Catmull-Rom history fetch (ported from the legacy accumulation path).
+vec4 historyAt(vec2 uv) {
+  ivec2 size = textureSize(u_history, 0);
+  vec2 position = uv * vec2(size) - 0.5;
+  ivec2 base = ivec2(floor(position));
+  vec4 wx = cubicWeights(fract(position.x)), wy = cubicWeights(fract(position.y));
+  vec4 result = vec4(0.0);
+  for (int y = 0; y < 4; y++) for (int x = 0; x < 4; x++) {
+    result += texelFetch(u_history, clamp(base + ivec2(x - 1, y - 1), ivec2(0), size - 1), 0) * wx[x] * wy[y];
+  }
+  return result;
+}
+
+vec3 rgbToYCoCg(vec3 c) { return vec3(c.r * 0.25 + c.g * 0.5 + c.b * 0.25, c.r * 0.5 - c.b * 0.5, -c.r * 0.25 + c.g * 0.5 - c.b * 0.25); }
+vec3 ycocgToRgb(vec3 c) { return vec3(c.x + c.y - c.z, c.x + c.z, c.x - c.y - c.z); }
+float luma(vec3 c) { return dot(c, vec3(0.2126, 0.7152, 0.0722)); }
+
+void main() {
+  ivec2 pixel = ivec2(gl_FragCoord.xy);
+  ivec2 size = textureSize(u_current, 0);
+  vec2 uv = (vec2(pixel) + 0.5) / vec2(size);
+
+  vec4 velTex = texelFetch(u_velocityDilate, pixel, 0);
+  vec2 velocity = velTex.rg;
+  vec2 uvPrev = uv - velocity;
+
+  // Current pixel + Karis-weighted 3×3 neighborhood stats in YCoCg.
+  vec3 current = texelFetch(u_current, pixel, 0).rgb;
+  vec3 mu = vec3(0.0), m2 = vec3(0.0);
+  float wsum = 0.0;
+  for (int y = -1; y <= 1; y += 1) for (int x = -1; x <= 1; x += 1) {
+    vec3 tap = texelFetch(u_current, clamp(pixel + ivec2(x, y), ivec2(0), size - 1), 0).rgb;
+    // Karis weight tames HDR fireflies inside the clip box.
+    float w = 1.0 / (1.0 + luma(tap));
+    vec3 yc = rgbToYCoCg(tap);
+    mu += yc * w;
+    m2 += yc * yc * w;
+    wsum += w;
+  }
+  mu /= wsum;
+  vec3 sigma = sqrt(max(m2 / wsum - mu * mu, vec3(0.0)));
+
+  if (!u_hasHistory) {
+    o_color = vec4(current, 1.0);
+    return;
+  }
+
+  // A static texel reprojects onto itself: read it directly. Resampling it
+  // through the Catmull-Rom kernel every frame was measured (promote-run
+  // probes on prd03-taa) to pull history ~0.09 px per frame, so at 0.97
+  // feedback a static 1-px line drifted a full pixel and rang below it.
+  vec3 history = length(velocity * vec2(size)) < 1e-3
+    ? texelFetch(u_history, clamp(pixel, ivec2(0), textureSize(u_history, 0) - 1), 0).rgb
+    : historyAt(uvPrev).rgb;
+  vec3 historyYc = rgbToYCoCg(history);
+
+  // Motion-scaled variance: fast pixels trust the box more (γ→0.5).
+  float motionPx = length(velocity * vec2(size));
+  float motionFactor = clamp(motionPx / 2.0, 0.0, 1.0);
+  float gamma = mix(0.5, u_varianceGamma, (1.0 - motionFactor) * (1.0 - motionFactor));
+  vec3 lo = mu - gamma * sigma;
+  vec3 hi = mu + gamma * sigma;
+  historyYc = clamp(historyYc, lo, hi);
+  history = ycocgToRgb(historyYc);
+
+  // Disocclusion: |prevLinZ − expectedZ| > 0.1·z → drop history.
+  bool outOfBounds = any(lessThan(uvPrev, vec2(0.0))) || any(greaterThanEqual(uvPrev, vec2(1.0)));
+  float zCurr = velTex.b;
+  // The test spans the previous frame's 3×3 depth range around the
+  // reprojected texel: sub-pixel jitter moves thin geometry (1-px lines,
+  // silhouettes) on/off a texel every frame, and a single-tap compare read
+  // that coverage change as a disocclusion — history was dropped on every
+  // edge texel and the "resolve" degenerated to the last jittered frame.
+  ivec2 zSize = textureSize(u_linZPrev, 0);
+  ivec2 prevPixel = ivec2(clamp(uvPrev, vec2(0.0), vec2(1.0)) * vec2(zSize));
+  float zPrevMin = 3.4e38, zPrevMax = 0.0;
+  for (int y = -1; y <= 1; y += 1) for (int x = -1; x <= 1; x += 1) {
+    float zTap = texelFetch(u_linZPrev, clamp(prevPixel + ivec2(x, y), ivec2(0), zSize - 1), 0).r;
+    zPrevMin = min(zPrevMin, zTap);
+    zPrevMax = max(zPrevMax, zTap);
+  }
+  bool disoccluded = zCurr < zPrevMin - 0.1 * zCurr || zCurr > zPrevMax + 0.1 * zCurr;
+
+  // Reactive mask (C-14) overrides accumulation; absent the attachment, a
+  // luminance delta between current and reprojected history is the proxy.
+  float reactive = texture(u_reactive, uv).r;
+  if (!u_hasReactive) {
+    reactive = abs(luma(current) - luma(history)) > 0.5 ? 1.0 : 0.0;
+  }
+
+  float feedback = mix(u_feedbackMin, u_feedbackMax, 1.0 - clamp(motionPx / 2.0, 0.0, 1.0));
+  feedback = mix(feedback, 0.5, clamp(reactive, 0.0, 1.0));
+  if (outOfBounds || disoccluded) feedback = 0.0;
+
+  vec3 resolved = mix(current, history, feedback);
+  o_color = vec4(max(resolved, vec3(0.0)), 1.0);
+}
+`;
+/** §8.6 TAAU: 9-tap Blackman-Harris reconstruct of the render-res resolved frame. */
+export const TAA_UPSCALE_GLSL = /* glsl */ `${HEADER}
+uniform highp sampler2D u_resolved; // render-res TAA output (this frame)
+uniform vec2 u_renderSize;          // render resolution (input texel space)
+uniform vec2 u_outputSize;          // display resolution (draw target size)
+out vec4 o_color;
+
+float blackmanHarris(float x) {
+  // N=9 window kernel, |x| ∈ [0, 1.5] inside the 3×3 footprint.
+  float ax = abs(x) / 1.5;
+  if (ax >= 1.0) return 0.0;
+  return 0.35875 + 0.48829 * cos(3.14159265 * ax) + 0.14128 * cos(2.0 * 3.14159265 * ax) + 0.01168 * cos(3.0 * 3.14159265 * ax);
+}
+
+void main() {
+  // Output pixel → render-res source position.
+  vec2 srcPos = (gl_FragCoord.xy / u_outputSize) * u_renderSize - 0.5;
+  ivec2 base = ivec2(floor(srcPos));
+  vec2 f = srcPos - vec2(base);
+  vec3 sum = vec3(0.0);
+  float wsum = 0.0;
+  ivec2 rSize = ivec2(u_renderSize);
+  for (int y = -1; y <= 1; y += 1) for (int x = -1; x <= 1; x += 1) {
+    float w = blackmanHarris(float(x) - f.x) * blackmanHarris(float(y) - f.y);
+    sum += texelFetch(u_resolved, clamp(base + ivec2(x, y), ivec2(0), rSize - 1), 0).rgb * w;
+    wsum += w;
+  }
+  o_color = vec4(sum / max(wsum, 1e-6), 1.0);
+}
+`;
+//# sourceMappingURL=taa.glsl.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"taa.glsl.js","sourceRoot":"","sources":["../../../../../../packages/rendering/src/post/shaders/taa.glsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,MAAM,MAAM,GAAG;;CAEd,CAAC;AAEF,MAAM,CAAC,MAAM,gBAAgB,GAAG,UAAU,CAAC,GAAG,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmHnD,CAAC;AAEF,qFAAqF;AACrF,MAAM,CAAC,MAAM,gBAAgB,GAAG,UAAU,CAAC,GAAG,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4BnD,CAAC"}

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

@@ -0,0 +1,10 @@
+/**
+ * PRD-03 §8.6 Phase 7 — S5 TAA resolve WGSL twins: closest-depth-3×3
+ * reprojection, 5-tap Catmull-Rom history fetch, YCoCg `μ ± γσ` clip
+ * (γ motion-dependent), 0.1·z disocclusion test, motion/reactive feedback,
+ * Karis-weighted HDR resolve. `TAA_UPSCALE_WGSL` is the §8.6 TAAU 9-tap
+ * Blackman-Harris reconstruct.
+ */
+export declare const TAA_RESOLVE_WGSL = "struct TaaResolveParams {\n  has_reactive: i32,\n  has_history: i32,\n  feedback_min: f32,\n  feedback_max: f32,\n  variance_gamma: f32,\n  _pad: vec3<f32>,\n};\n\n@group(0) @binding(0) var<uniform> u_params: TaaResolveParams;\n@group(0) @binding(1) var u_current_tex: texture_2d<f32>;         // jittered HDR current frame\n@group(0) @binding(2) var u_history_tex: texture_2d<f32>;         // last resolved frame\n@group(0) @binding(3) var u_velocity_dilate_tex: texture_2d<f32>; // vec4(vx, vy, linZCurr, _)\n@group(0) @binding(4) var u_lin_z_prev_tex: texture_2d<f32>;      // last frame's linear depth (.r)\n@group(0) @binding(5) var u_lin_z_prev_smp: sampler;\n@group(0) @binding(6) var u_reactive_tex: texture_2d<f32>;        // C-14 reactive mask (or 1\u00D71 zero)\n@group(0) @binding(7) var u_reactive_smp: sampler;\n\nfn cubic_weights(f: f32) -> vec4<f32> {\n  let f2 = f * f;\n  let f3 = f2 * f;\n  return vec4<f32>(-0.5 * f + f2 - 0.5 * f3, 1.0 - 2.5 * f2 + 1.5 * f3,\n                   0.5 * f + 2.0 * f2 - 1.5 * f3, -0.5 * f2 + 0.5 * f3);\n}\n\n// \u00A78.6: Catmull-Rom history fetch (ported from the legacy accumulation path).\nfn history_at(uv: vec2<f32>) -> vec4<f32> {\n  let size = vec2<i32>(textureDimensions(u_history_tex));\n  let position = uv * vec2<f32>(size) - vec2<f32>(0.5);\n  let base = vec2<i32>(floor(position));\n  let wx = cubic_weights(fract(position.x));\n  let wy = cubic_weights(fract(position.y));\n  var result = vec4<f32>(0.0);\n  for (var y = 0; y < 4; y = y + 1) {\n    for (var x = 0; x < 4; x = x + 1) {\n      result = result + textureLoad(u_history_tex,\n        clamp(base + vec2<i32>(x - 1, y - 1), vec2<i32>(0), size - vec2<i32>(1)), 0) * wx[x] * wy[y];\n    }\n  }\n  return result;\n}\n\nfn rgb_to_ycocg(c: vec3<f32>) -> vec3<f32> {\n  return vec3<f32>(c.r * 0.25 + c.g * 0.5 + c.b * 0.25,\n                   c.r * 0.5 - c.b * 0.5,\n                   -c.r * 0.25 + c.g * 0.5 - c.b * 0.25);\n}\nfn ycocg_to_rgb(c: vec3<f32>) -> vec3<f32> {\n  return vec3<f32>(c.x + c.y - c.z, c.x + c.z, c.x - c.y - c.z);\n}\nfn taa_luma(c: vec3<f32>) -> f32 { return dot(c, vec3<f32>(0.2126, 0.7152, 0.0722)); }\n\n@fragment\nfn fs_taa_resolve(@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_current_tex));\n  let uv = (vec2<f32>(pixel) + vec2<f32>(0.5)) / vec2<f32>(size);\n\n  let vel_tex = textureLoad(u_velocity_dilate_tex, pixel, 0);\n  let velocity = vel_tex.rg;\n  let uv_prev = uv - velocity;\n\n  // Current pixel + Karis-weighted 3\u00D73 neighborhood stats in YCoCg.\n  let current = textureLoad(u_current_tex, pixel, 0).rgb;\n  var mu = vec3<f32>(0.0);\n  var m2 = vec3<f32>(0.0);\n  var wsum = 0.0;\n  for (var y = -1; y <= 1; y = y + 1) {\n    for (var x = -1; x <= 1; x = x + 1) {\n      let tap = textureLoad(u_current_tex,\n        clamp(pixel + vec2<i32>(x, y), vec2<i32>(0), size - vec2<i32>(1)), 0).rgb;\n      // Karis weight tames HDR fireflies inside the clip box.\n      let w = 1.0 / (1.0 + taa_luma(tap));\n      let yc = rgb_to_ycocg(tap);\n      mu = mu + yc * w;\n      m2 = m2 + yc * yc * w;\n      wsum = wsum + w;\n    }\n  }\n  mu = mu / wsum;\n  let sigma = sqrt(max(m2 / wsum - mu * mu, vec3<f32>(0.0)));\n\n  if (u_params.has_history == 0) {\n    return vec4<f32>(current, 1.0);\n  }\n\n  // Static texel: direct read (GLSL twin \u2014 no per-frame resample drift).\n  let hist_size = vec2<i32>(textureDimensions(u_history_tex));\n  let history = select(history_at(uv_prev).rgb,\n    textureLoad(u_history_tex, clamp(pixel, vec2<i32>(0), hist_size - vec2<i32>(1)), 0).rgb,\n    length(velocity * vec2<f32>(size)) < 1e-3);\n  var history_yc = rgb_to_ycocg(history);\n\n  // Motion-scaled variance: fast pixels trust the box more (\u03B3\u21920.5).\n  let motion_px = length(velocity * vec2<f32>(size));\n  let motion_factor = clamp(motion_px / 2.0, 0.0, 1.0);\n  let gamma = mix(0.5, u_params.variance_gamma, (1.0 - motion_factor) * (1.0 - motion_factor));\n  let lo = mu - gamma * sigma;\n  let hi = mu + gamma * sigma;\n  history_yc = clamp(history_yc, lo, hi);\n  let history_rgb = ycocg_to_rgb(history_yc);\n\n  // Disocclusion: |prevLinZ \u2212 expectedZ| > 0.1\u00B7z \u2192 drop history.\n  let out_of_bounds = any(uv_prev < vec2<f32>(0.0)) || any(uv_prev >= vec2<f32>(1.0));\n  let z_curr = vel_tex.b;\n  // 3\u00D73 previous-depth range around the reprojected texel (GLSL twin):\n  // sub-pixel jitter moving thin geometry on/off a texel is coverage, not\n  // disocclusion, and must not drop history.\n  let z_size = vec2<i32>(textureDimensions(u_lin_z_prev_tex, 0));\n  let prev_pixel = vec2<i32>(clamp(uv_prev, vec2<f32>(0.0), vec2<f32>(1.0)) * vec2<f32>(z_size));\n  // Centre tap through the bound sampler (keeps binding 5 live for an\n  // 'auto' pipeline layout), then the 3\u00D73 texel range.\n  let z_prev_centre = textureSampleLevel(u_lin_z_prev_tex, u_lin_z_prev_smp,\n    clamp(uv_prev, vec2<f32>(0.0), vec2<f32>(1.0)), 0.0).r;\n  var z_prev_min = z_prev_centre;\n  var z_prev_max = z_prev_centre;\n  for (var zy = -1; zy <= 1; zy = zy + 1) {\n    for (var zx = -1; zx <= 1; zx = zx + 1) {\n      let z_tap = textureLoad(u_lin_z_prev_tex, clamp(prev_pixel + vec2<i32>(zx, zy), vec2<i32>(0), z_size - vec2<i32>(1)), 0).r;\n      z_prev_min = min(z_prev_min, z_tap);\n      z_prev_max = max(z_prev_max, z_tap);\n    }\n  }\n  let disoccluded = z_curr < z_prev_min - 0.1 * z_curr || z_curr > z_prev_max + 0.1 * z_curr;\n\n  // Reactive mask (C-14) overrides accumulation; absent the attachment, a\n  // luminance delta between current and reprojected history is the proxy.\n  var reactive = textureSampleLevel(u_reactive_tex, u_reactive_smp, uv, 0.0).r;\n  if (u_params.has_reactive == 0) {\n    reactive = select(0.0, 1.0, abs(taa_luma(current) - taa_luma(history_rgb)) > 0.5);\n  }\n\n  var feedback = mix(u_params.feedback_min, u_params.feedback_max, 1.0 - clamp(motion_px / 2.0, 0.0, 1.0));\n  feedback = mix(feedback, 0.5, clamp(reactive, 0.0, 1.0));\n  if (out_of_bounds || disoccluded) { feedback = 0.0; }\n\n  let resolved = mix(current, history_rgb, feedback);\n  return vec4<f32>(max(resolved, vec3<f32>(0.0)), 1.0);\n}\n";
+export declare const TAA_UPSCALE_WGSL = "struct TaaUpscaleParams {\n  render_size: vec2<f32>,   // render resolution (input texel space)\n  output_size: vec2<f32>,   // display resolution (draw target size)\n};\n\n@group(0) @binding(0) var<uniform> u_params: TaaUpscaleParams;\n@group(0) @binding(1) var u_resolved_tex: texture_2d<f32>; // render-res TAA output (this frame)\n\nfn blackman_harris(x: f32) -> f32 {\n  // N=9 window kernel, |x| \u2208 [0, 1.5] inside the 3\u00D73 footprint.\n  let ax = abs(x) / 1.5;\n  if (ax >= 1.0) { return 0.0; }\n  return 0.35875 + 0.48829 * cos(3.14159265 * ax)\n    + 0.14128 * cos(2.0 * 3.14159265 * ax)\n    + 0.01168 * cos(3.0 * 3.14159265 * ax);\n}\n\n@fragment\nfn fs_taa_upscale(@builtin(position) frag_coord: vec4<f32>) -> @location(0) vec4<f32> {\n  // Output pixel \u2192 render-res source position.\n  let src_pos = (frag_coord.xy / u_params.output_size) * u_params.render_size - vec2<f32>(0.5);\n  let base = vec2<i32>(floor(src_pos));\n  let f = src_pos - vec2<f32>(base);\n  var sum = vec3<f32>(0.0);\n  var wsum = 0.0;\n  let r_size = vec2<i32>(u_params.render_size);\n  for (var y = -1; y <= 1; y = y + 1) {\n    for (var x = -1; x <= 1; x = x + 1) {\n      let w = blackman_harris(f32(x) - f.x) * blackman_harris(f32(y) - f.y);\n      sum = sum + textureLoad(u_resolved_tex,\n        clamp(base + vec2<i32>(x, y), vec2<i32>(0), r_size - vec2<i32>(1)), 0).rgb * w;\n      wsum = wsum + w;\n    }\n  }\n  return vec4<f32>(sum / max(wsum, 1e-6), 1.0);\n}\n";
+//# sourceMappingURL=taa.wgsl.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"taa.wgsl.d.ts","sourceRoot":"","sources":["../../../../../../packages/rendering/src/post/shaders/taa.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,eAAO,MAAM,gBAAgB,6lMA2I5B,CAAC;AAEF,eAAO,MAAM,gBAAgB,i8CAoC5B,CAAC"}