@aura3d/rendering 3.0.1 → 4.0.2

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

@@ -0,0 +1,70 @@
+/**
+ * PRD-03 §8.5 — S4 god rays for the v2 post chain (WebGL2, half-res RGBA16F).
+ *
+ * Radial light-shaft march replacing the CPU `volumetricLightPixels` path
+ * (which cost ~0.5 fps in Deep Recovery):
+ *   occlusion src  = (linZ ≥ far·0.999 || luma(hdr) > 4.0) ? hdr.rgb : 0
+ *                    + (sky ? light-disk mask smoothstep(r1, r0, |uv − lightUv|) : 0)
+ *   march          = samples taps from uv toward lightUv, weight decay^i·weight
+ *   output         = accum · color · intensity · offScreenFade
+ *   offScreenFade  = saturate(1 − (max(|lightUv−0.5|) − 0.5)·4) · step(0, lightClip.w)
+ *
+ * The half-res output is added into HDR by the S10 composite. On the v2 path
+ * this supersedes `VolumetricFog.ts:105-144` (lane 07, deletion = Q-07-1).
+ */
+const HEADER = `#version 300 es
+precision highp float;
+`;
+export const GODRAYS_GLSL = /* glsl */ `${HEADER}
+uniform sampler2D u_hdr;             // half-res HDR input
+uniform highp sampler2D u_depthHalf; // half-res linear depth (.r)
+uniform float u_far;
+uniform vec2 u_lightUv;              // projected light position, uv space
+uniform float u_lightClipW;          // clip-space w of the projected light
+uniform vec3 u_color;                // light shaft tint
+uniform float u_intensity;
+uniform float u_decay;
+uniform float u_weight;
+uniform float u_diskOuter;           // r1: disk feather outer radius (uv)
+uniform float u_diskInner;           // r0: disk core radius (uv)
+out vec4 o_color;
+
+#ifndef AURA_GODRAY_SAMPLES
+#define AURA_GODRAY_SAMPLES 32
+#endif
+
+void main() {
+  vec2 uv = gl_FragCoord.xy / vec2(textureSize(u_hdr, 0));
+  vec2 dir = u_lightUv - uv;
+  float dist = length(dir);
+  vec2 stepUv = dist > 0.0 ? dir / float(AURA_GODRAY_SAMPLES) : vec2(0.0);
+
+  // Off-screen / behind-camera fade: step(0, w) zeroes lights behind the eye,
+  // the linear ramp fades across 25% uv past the frame edge.
+  float offScreen = clamp(1.0 - (max(abs(u_lightUv.x - 0.5), abs(u_lightUv.y - 0.5)) - 0.5) * 4.0, 0.0, 1.0)
+                  * step(0.0, u_lightClipW);
+
+  float marchWeight = u_weight;
+  vec3 accum = vec3(0.0);
+  vec2 sampleUv = uv;
+  for (int i = 0; i < AURA_GODRAY_SAMPLES; ++i) {
+    sampleUv += stepUv;
+    vec4 hdr = textureLod(u_hdr, sampleUv, 0.0);
+    float linZ = textureLod(u_depthHalf, sampleUv, 0.0).r;
+    bool sky = linZ >= u_far * 0.999;
+    float luma = dot(hdr.rgb, vec3(0.2126, 0.7152, 0.0722));
+    // Emitters: sky pixels (the "gap" through occluders) or HDR highlights.
+    vec3 src = (sky || luma > 4.0) ? hdr.rgb : vec3(0.0);
+    // The sun disk emits only where the sky is unoccluded. #1185 multiplied
+    // the whole source by the disk mask: with a dim sky that leaves nothing
+    // to emit, and the S4-isolated A/B measured S4 on == S4 off (GPU run
+    // 38163537496). The original additive disk emitted through occluders.
+    if (sky) src += vec3(smoothstep(u_diskOuter, u_diskInner, length(sampleUv - u_lightUv)));
+    accum += marchWeight * src;
+    marchWeight *= u_decay;
+  }
+
+  o_color = vec4(accum * u_color * u_intensity * offScreen, 1.0);
+}
+`;
+//# sourceMappingURL=godrays.glsl.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"godrays.glsl.js","sourceRoot":"","sources":["../../../../../../packages/rendering/src/post/shaders/godrays.glsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,MAAM,MAAM,GAAG;;CAEd,CAAC;AAEF,MAAM,CAAC,MAAM,YAAY,GAAG,UAAU,CAAC,GAAG,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmD/C,CAAC"}

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

@@ -0,0 +1,8 @@
+/**
+ * PRD-03 §8.5 Phase 7 — S4 god rays WGSL twin (half-res RGBA16F radial
+ * light-shaft march). Same occlusion/march/off-screen-fade math as the
+ * GLSL twin; the GL twin's `#define AURA_GODRAY_SAMPLES` becomes the
+ * pipeline-overridable `override AURA_GODRAY_SAMPLES` (default 32).
+ */
+export declare const GODRAYS_WGSL = "// AURA_GODRAY_SAMPLES \u2014 pipeline-overridable tier constant (default 32).\noverride AURA_GODRAY_SAMPLES: i32 = 32;\n\nstruct GodraysParams {\n  far: f32,\n  light_uv: vec2<f32>,\n  light_clip_w: f32,\n  color: vec3<f32>,\n  intensity: f32,\n  decay: f32,\n  weight: f32,\n  disk_outer: f32,         // r1: disk feather outer radius (uv)\n  disk_inner: f32,         // r0: disk core radius (uv)\n};\n\n@group(0) @binding(0) var<uniform> u_params: GodraysParams;\n@group(0) @binding(1) var u_hdr_tex: texture_2d<f32>;        // half-res HDR input\n@group(0) @binding(2) var u_hdr_smp: sampler;\n@group(0) @binding(3) var u_depth_half_tex: texture_2d<f32>; // half-res linear depth (.r)\n@group(0) @binding(4) var u_depth_half_smp: sampler;\n\n@fragment\nfn fs_godrays(@builtin(position) frag_coord: vec4<f32>) -> @location(0) vec4<f32> {\n  let uv = frag_coord.xy / vec2<f32>(textureDimensions(u_hdr_tex));\n  let dir = u_params.light_uv - uv;\n  let dist = length(dir);\n  let step_uv = select(vec2<f32>(0.0), dir / f32(AURA_GODRAY_SAMPLES), dist > 0.0);\n\n  // Off-screen / behind-camera fade: step(0, w) zeroes lights behind the eye,\n  // the linear ramp fades across 25% uv past the frame edge.\n  let off_screen = clamp(1.0 - (max(abs(u_params.light_uv.x - 0.5), abs(u_params.light_uv.y - 0.5)) - 0.5) * 4.0, 0.0, 1.0)\n    * step(0.0, u_params.light_clip_w);\n\n  var march_weight = u_params.weight;\n  var accum = vec3<f32>(0.0);\n  var sample_uv = uv;\n  for (var i = 0; i < AURA_GODRAY_SAMPLES; i = i + 1) {\n    sample_uv = sample_uv + step_uv;\n    let hdr = textureSampleLevel(u_hdr_tex, u_hdr_smp, sample_uv, 0.0);\n    let lin_z = textureSampleLevel(u_depth_half_tex, u_depth_half_smp, sample_uv, 0.0).r;\n    let sky = lin_z >= u_params.far * 0.999;\n    let luma = dot(hdr.rgb, vec3<f32>(0.2126, 0.7152, 0.0722));\n    // Emitters: sky pixels (the \"gap\" through occluders) or HDR highlights.\n    var src = select(vec3<f32>(0.0), hdr.rgb, sky || luma > 4.0);\n    // The sun disk emits only where the sky is unoccluded.\n    if (sky) { src = src + vec3<f32>(smoothstep(u_params.disk_outer, u_params.disk_inner, length(sample_uv - u_params.light_uv))); }\n    accum = accum + march_weight * src;\n    march_weight = march_weight * u_params.decay;\n  }\n\n  return vec4<f32>(accum * u_params.color * u_params.intensity * off_screen, 1.0);\n}\n";
+//# sourceMappingURL=godrays.wgsl.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"godrays.wgsl.d.ts","sourceRoot":"","sources":["../../../../../../packages/rendering/src/post/shaders/godrays.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,eAAO,MAAM,YAAY,i0EAoDxB,CAAC"}

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

@@ -0,0 +1,60 @@
+/**
+ * PRD-03 §8.5 Phase 7 — S4 god rays WGSL twin (half-res RGBA16F radial
+ * light-shaft march). Same occlusion/march/off-screen-fade math as the
+ * GLSL twin; the GL twin's `#define AURA_GODRAY_SAMPLES` becomes the
+ * pipeline-overridable `override AURA_GODRAY_SAMPLES` (default 32).
+ */
+export const GODRAYS_WGSL = /* wgsl */ `// AURA_GODRAY_SAMPLES — pipeline-overridable tier constant (default 32).
+override AURA_GODRAY_SAMPLES: i32 = 32;
+
+struct GodraysParams {
+  far: f32,
+  light_uv: vec2<f32>,
+  light_clip_w: f32,
+  color: vec3<f32>,
+  intensity: f32,
+  decay: f32,
+  weight: f32,
+  disk_outer: f32,         // r1: disk feather outer radius (uv)
+  disk_inner: f32,         // r0: disk core radius (uv)
+};
+
+@group(0) @binding(0) var<uniform> u_params: GodraysParams;
+@group(0) @binding(1) var u_hdr_tex: texture_2d<f32>;        // half-res HDR input
+@group(0) @binding(2) var u_hdr_smp: sampler;
+@group(0) @binding(3) var u_depth_half_tex: texture_2d<f32>; // half-res linear depth (.r)
+@group(0) @binding(4) var u_depth_half_smp: sampler;
+
+@fragment
+fn fs_godrays(@builtin(position) frag_coord: vec4<f32>) -> @location(0) vec4<f32> {
+  let uv = frag_coord.xy / vec2<f32>(textureDimensions(u_hdr_tex));
+  let dir = u_params.light_uv - uv;
+  let dist = length(dir);
+  let step_uv = select(vec2<f32>(0.0), dir / f32(AURA_GODRAY_SAMPLES), dist > 0.0);
+
+  // Off-screen / behind-camera fade: step(0, w) zeroes lights behind the eye,
+  // the linear ramp fades across 25% uv past the frame edge.
+  let off_screen = clamp(1.0 - (max(abs(u_params.light_uv.x - 0.5), abs(u_params.light_uv.y - 0.5)) - 0.5) * 4.0, 0.0, 1.0)
+    * step(0.0, u_params.light_clip_w);
+
+  var march_weight = u_params.weight;
+  var accum = vec3<f32>(0.0);
+  var sample_uv = uv;
+  for (var i = 0; i < AURA_GODRAY_SAMPLES; i = i + 1) {
+    sample_uv = sample_uv + step_uv;
+    let hdr = textureSampleLevel(u_hdr_tex, u_hdr_smp, sample_uv, 0.0);
+    let lin_z = textureSampleLevel(u_depth_half_tex, u_depth_half_smp, sample_uv, 0.0).r;
+    let sky = lin_z >= u_params.far * 0.999;
+    let luma = dot(hdr.rgb, vec3<f32>(0.2126, 0.7152, 0.0722));
+    // Emitters: sky pixels (the "gap" through occluders) or HDR highlights.
+    var src = select(vec3<f32>(0.0), hdr.rgb, sky || luma > 4.0);
+    // The sun disk emits only where the sky is unoccluded.
+    if (sky) { src = src + vec3<f32>(smoothstep(u_params.disk_outer, u_params.disk_inner, length(sample_uv - u_params.light_uv))); }
+    accum = accum + march_weight * src;
+    march_weight = march_weight * u_params.decay;
+  }
+
+  return vec4<f32>(accum * u_params.color * u_params.intensity * off_screen, 1.0);
+}
+`;
+//# sourceMappingURL=godrays.wgsl.js.map

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

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

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

@@ -0,0 +1,29 @@
+/**
+ * PRD-03 §8.4 / §6.3 — S2 GTAO for the v2 post chain (WebGL2, half-res R8).
+ *
+ * AO kernel ported from three r185 `examples/jsm/shaders/GTAOShader.js`
+ * (MIT): per-slice tangent-frame construction, horizon cosine search and the
+ * `nx·nxb + ny·nyb` cosine-weighted arc integral are verbatim. The differences
+ * the PRD pins:
+ *   - slice directions `AURA_GTAO_DIRECTIONS` ∈ {2, 4} and horizon samples
+ *     `AURA_GTAO_STEPS` ∈ {4, 6} are compile-time tier constants (C-27);
+ *   - slice rotation comes from a 4×4 interleaved-gradient noise plus the
+ *     TAA frame index (`u_frameIndex`), not a noise texture;
+ *   - the march is screen-space: `radiusPx = radius · projScale / viewZ`
+ *     clamped to 4..96 px, `steps` taps along each direction, sampling the
+ *     S1 half-res (min) linear depth;
+ *   - distance falloff `saturate((radius − d) / (falloff · radius))`
+ *     attenuates the horizon cosine;
+ *   - normals are reconstructed from linear depth with the 5-tap
+ *     smallest-discontinuity method (Turánszki) — r185
+ *     `computeNormalFromDepth` verbatim; no normal MRT.
+ *
+ * Output: R8 visibility (1 = unoccluded). Sky / far plane writes 1.
+ *
+ * Uniforms: `u_linearDepthHalf` (S1 RG32F half-res, `.r` = min),
+ * `u_projMatrix` (view→clip), `u_invProjMatrix` (clip→view), `u_near`,
+ * `u_far`, `u_radius` (metres), `u_intensity`, `u_falloff`,
+ * `u_distanceExponent`, `u_thickness`, `u_frameIndex`.
+ */
+export declare const GTAO_GLSL = "#version 300 es\nprecision highp float;\n\nuniform highp sampler2D u_linearDepthHalf;   // S1 RG32F, .r = min viewZ\nuniform mat4 u_projMatrix;\nuniform mat4 u_invProjMatrix;\nuniform float u_near;\nuniform float u_far;\nuniform bool u_ortho;\nuniform float u_radius;\nuniform float u_intensity;\nuniform float u_falloff;\nuniform float u_distanceExponent;\nuniform float u_thickness;\nuniform int u_frameIndex;\nout vec4 o_color;\n\n#ifndef AURA_GTAO_DIRECTIONS\n#define AURA_GTAO_DIRECTIONS 4\n#endif\n#ifndef AURA_GTAO_STEPS\n#define AURA_GTAO_STEPS 4\n#endif\n\nconst float PI = 3.141592653589793;\nconst float GOLDEN_ANGLE = 2.39996322972865332;\n\n// 4\u00D74 interleaved-gradient noise (same generator as IGN, tiled).\nfloat ign4(vec2 fragCoord) {\n  vec2 p = mod(fragCoord, 4.0);\n  return fract(52.9829189 * fract(dot(p, vec2(0.06711056, 0.00583715))));\n}\n\nfloat fetchViewZ(ivec2 p) {\n  return texelFetch(u_linearDepthHalf, clamp(p, ivec2(0), textureSize(u_linearDepthHalf, 0) - 1), 0).r;\n}\n\nvec3 getViewPosition(vec2 uv, float viewZ) {\n  // viewZ is optical-axis depth, positive in front of the camera.\n  if (u_ortho) {\n    // Orthographic: rays are parallel, so x/y do not scale with depth.\n    // Unproject the pixel at any depth and set z directly. (The perspective\n    // ray-scale below turned every floor pixel's position into a point on a\n    // ray through the origin, so flat floors read as occluded: open floor\n    // 34% darker on GPU run 38141069039.)\n    vec4 view = u_invProjMatrix * vec4(uv * 2.0 - 1.0, 0.0, 1.0);\n    return vec3(view.xy / view.w, -viewZ);\n  }\n  // Perspective: shoot the ndc.xy ray to the far plane, normalize to unit\n  // view-depth, scale by viewZ.\n  vec4 view = u_invProjMatrix * vec4(uv * 2.0 - 1.0, 1.0, 1.0);\n  vec3 ray = view.xyz / view.w;\n  return ray * (viewZ / -ray.z);\n}\n\n// 5-tap smallest-discontinuity normal (three r185 computeNormalFromDepth,\n// operating on linear viewZ directly).\nvec3 computeNormalFromDepth(ivec2 p, vec2 texel) {\n  vec2 size = vec2(textureSize(u_linearDepthHalf, 0));\n  float c0 = fetchViewZ(p);\n  float l2 = fetchViewZ(p - ivec2(2, 0));\n  float l1 = fetchViewZ(p - ivec2(1, 0));\n  float r1 = fetchViewZ(p + ivec2(1, 0));\n  float r2 = fetchViewZ(p + ivec2(2, 0));\n  float b2 = fetchViewZ(p - ivec2(0, 2));\n  float b1 = fetchViewZ(p - ivec2(0, 1));\n  float t1 = fetchViewZ(p + ivec2(0, 1));\n  float t2 = fetchViewZ(p + ivec2(0, 2));\n  float dl = abs((2.0 * l1 - l2) - c0);\n  float dr = abs((2.0 * r1 - r2) - c0);\n  float db = abs((2.0 * b1 - b2) - c0);\n  float dt = abs((2.0 * t1 - t2) - c0);\n  vec2 uv = vec2(p) * texel;\n  vec3 ce = getViewPosition(uv, c0);\n  vec3 dpdx = (dl < dr) ? ce - getViewPosition(uv - vec2(texel.x, 0.0), l1)\n                        : -ce + getViewPosition(uv + vec2(texel.x, 0.0), r1);\n  vec3 dpdy = (db < dt) ? ce - getViewPosition(uv - vec2(0.0, texel.y), b1)\n                        : -ce + getViewPosition(uv + vec2(0.0, texel.y), t1);\n  return normalize(cross(dpdx, dpdy));\n}\n\nvoid main() {\n  ivec2 p = ivec2(gl_FragCoord.xy);\n  vec2 size = vec2(textureSize(u_linearDepthHalf, 0));\n  vec2 texel = 1.0 / size;\n  float viewZ = fetchViewZ(p);\n  if (viewZ >= u_far * 0.999) { o_color = vec4(1.0); return; }\n\n  vec2 uv = gl_FragCoord.xy * texel;\n  vec3 viewPos = getViewPosition(uv, viewZ);\n  vec3 viewNormal = computeNormalFromDepth(p, texel);\n  // #1185's orthographic +Z view direction made GTAO a no-op (contact\n  // darkening 0, GPU run 38151583035); reverted until the slice math is\n  // proven for orthographic cameras.\n  vec3 viewDir = normalize(-viewPos);\n\n  // radius metres \u2192 pixels at this depth, clamped to the march budget.\n  float projScale = u_projMatrix[1][1] * size.y * 0.5;\n  // Orthographic projection has no 1/z: P[1][1] maps view units to ndc directly.\n  float radiusPx = clamp(u_radius * projScale / (u_ortho ? 1.0 : viewZ), 4.0, 96.0);\n\n  float jitter = ign4(gl_FragCoord.xy) + float(u_frameIndex) * GOLDEN_ANGLE;\n  float ao = 0.0;\n  const int DIRECTIONS = AURA_GTAO_DIRECTIONS;\n  const int STEPS = AURA_GTAO_STEPS;\n\n  for (int i = 0; i < DIRECTIONS; ++i) {\n    float angle = (float(i) + jitter) / float(DIRECTIONS) * PI;\n    vec2 dir = vec2(cos(angle), sin(angle));\n\n    // Per-slice tangent frame (r185): screen-space dir \u2192 view-space slice,\n    // unprojecting the 2D direction by the projection focal scales.\n    vec3 sliceDirView = normalize(vec3(dir.x / u_projMatrix[0][0],\n                                       dir.y / u_projMatrix[1][1], 0.0));\n    vec3 sliceBitangent = normalize(cross(sliceDirView, viewDir));\n    vec3 sliceTangent = cross(sliceBitangent, viewDir);\n    vec3 normalInSlice = normalize(viewNormal - sliceBitangent * dot(viewNormal, sliceBitangent));\n    vec3 tangentToNormalInSlice = cross(normalInSlice, sliceBitangent);\n    vec2 cosHorizons = vec2(dot(viewDir, tangentToNormalInSlice),\n                            dot(viewDir, -tangentToNormalInSlice));\n\n    for (int j = 0; j < STEPS; ++j) {\n      float t = pow(float(j + 1) / float(STEPS), u_distanceExponent);\n      vec2 sampleOffset = dir * radiusPx * t * texel;\n\n      vec2 sampleUvPos = uv + sampleOffset;\n      float sampleZ = textureLod(u_linearDepthHalf, sampleUvPos, 0.0).r;\n      vec3 viewDelta = getViewPosition(sampleUvPos, sampleZ) - viewPos;\n      float d = length(viewDelta);\n      if (d < u_radius && abs(viewDelta.z) < u_thickness) {\n        float sampleCosHorizon = dot(viewDir, normalize(viewDelta));\n        cosHorizons.x = max(cosHorizons.x,\n          sampleCosHorizon * clamp((u_radius - d) / (u_falloff * u_radius), 0.0, 1.0));\n      }\n\n      vec2 sampleUvNeg = uv - sampleOffset;\n      float sampleZ2 = textureLod(u_linearDepthHalf, sampleUvNeg, 0.0).r;\n      vec3 viewDelta2 = getViewPosition(sampleUvNeg, sampleZ2) - viewPos;\n      float d2 = length(viewDelta2);\n      if (d2 < u_radius && abs(viewDelta2.z) < u_thickness) {\n        float sampleCosHorizon2 = dot(viewDir, normalize(viewDelta2));\n        cosHorizons.y = max(cosHorizons.y,\n          sampleCosHorizon2 * clamp((u_radius - d2) / (u_falloff * u_radius), 0.0, 1.0));\n      }\n    }\n\n    vec2 sinHorizons = sqrt(1.0 - cosHorizons * cosHorizons);\n    float nx = dot(normalInSlice, sliceTangent);\n    float ny = dot(normalInSlice, viewDir);\n    float nxb = 0.5 * (acos(cosHorizons.y) - acos(cosHorizons.x)\n                     + sinHorizons.x * cosHorizons.x - sinHorizons.y * cosHorizons.y);\n    float nyb = 0.5 * (2.0 - cosHorizons.x * cosHorizons.x - cosHorizons.y * cosHorizons.y);\n    ao += nx * nxb + ny * nyb;\n  }\n\n  ao = clamp(ao / float(DIRECTIONS), 0.0, 1.0);\n  // visibility \u2192 occlusion strength (u_intensity 1 = full AO).\n  ao = mix(1.0, ao, clamp(u_intensity, 0.0, 1.0));\n  o_color = vec4(ao, 0.0, 0.0, 1.0);\n}\n";
+//# sourceMappingURL=gtao.glsl.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"gtao.glsl.d.ts","sourceRoot":"","sources":["../../../../../../packages/rendering/src/post/shaders/gtao.glsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAMH,eAAO,MAAM,SAAS,mtNA8JrB,CAAC"}

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

@@ -0,0 +1,190 @@
+/**
+ * PRD-03 §8.4 / §6.3 — S2 GTAO for the v2 post chain (WebGL2, half-res R8).
+ *
+ * AO kernel ported from three r185 `examples/jsm/shaders/GTAOShader.js`
+ * (MIT): per-slice tangent-frame construction, horizon cosine search and the
+ * `nx·nxb + ny·nyb` cosine-weighted arc integral are verbatim. The differences
+ * the PRD pins:
+ *   - slice directions `AURA_GTAO_DIRECTIONS` ∈ {2, 4} and horizon samples
+ *     `AURA_GTAO_STEPS` ∈ {4, 6} are compile-time tier constants (C-27);
+ *   - slice rotation comes from a 4×4 interleaved-gradient noise plus the
+ *     TAA frame index (`u_frameIndex`), not a noise texture;
+ *   - the march is screen-space: `radiusPx = radius · projScale / viewZ`
+ *     clamped to 4..96 px, `steps` taps along each direction, sampling the
+ *     S1 half-res (min) linear depth;
+ *   - distance falloff `saturate((radius − d) / (falloff · radius))`
+ *     attenuates the horizon cosine;
+ *   - normals are reconstructed from linear depth with the 5-tap
+ *     smallest-discontinuity method (Turánszki) — r185
+ *     `computeNormalFromDepth` verbatim; no normal MRT.
+ *
+ * Output: R8 visibility (1 = unoccluded). Sky / far plane writes 1.
+ *
+ * Uniforms: `u_linearDepthHalf` (S1 RG32F half-res, `.r` = min),
+ * `u_projMatrix` (view→clip), `u_invProjMatrix` (clip→view), `u_near`,
+ * `u_far`, `u_radius` (metres), `u_intensity`, `u_falloff`,
+ * `u_distanceExponent`, `u_thickness`, `u_frameIndex`.
+ */
+const HEADER = `#version 300 es
+precision highp float;
+`;
+export const GTAO_GLSL = /* glsl */ `${HEADER}
+uniform highp sampler2D u_linearDepthHalf;   // S1 RG32F, .r = min viewZ
+uniform mat4 u_projMatrix;
+uniform mat4 u_invProjMatrix;
+uniform float u_near;
+uniform float u_far;
+uniform bool u_ortho;
+uniform float u_radius;
+uniform float u_intensity;
+uniform float u_falloff;
+uniform float u_distanceExponent;
+uniform float u_thickness;
+uniform int u_frameIndex;
+out vec4 o_color;
+
+#ifndef AURA_GTAO_DIRECTIONS
+#define AURA_GTAO_DIRECTIONS 4
+#endif
+#ifndef AURA_GTAO_STEPS
+#define AURA_GTAO_STEPS 4
+#endif
+
+const float PI = 3.141592653589793;
+const float GOLDEN_ANGLE = 2.39996322972865332;
+
+// 4×4 interleaved-gradient noise (same generator as IGN, tiled).
+float ign4(vec2 fragCoord) {
+  vec2 p = mod(fragCoord, 4.0);
+  return fract(52.9829189 * fract(dot(p, vec2(0.06711056, 0.00583715))));
+}
+
+float fetchViewZ(ivec2 p) {
+  return texelFetch(u_linearDepthHalf, clamp(p, ivec2(0), textureSize(u_linearDepthHalf, 0) - 1), 0).r;
+}
+
+vec3 getViewPosition(vec2 uv, float viewZ) {
+  // viewZ is optical-axis depth, positive in front of the camera.
+  if (u_ortho) {
+    // Orthographic: rays are parallel, so x/y do not scale with depth.
+    // Unproject the pixel at any depth and set z directly. (The perspective
+    // ray-scale below turned every floor pixel's position into a point on a
+    // ray through the origin, so flat floors read as occluded: open floor
+    // 34% darker on GPU run 38141069039.)
+    vec4 view = u_invProjMatrix * vec4(uv * 2.0 - 1.0, 0.0, 1.0);
+    return vec3(view.xy / view.w, -viewZ);
+  }
+  // Perspective: shoot the ndc.xy ray to the far plane, normalize to unit
+  // view-depth, scale by viewZ.
+  vec4 view = u_invProjMatrix * vec4(uv * 2.0 - 1.0, 1.0, 1.0);
+  vec3 ray = view.xyz / view.w;
+  return ray * (viewZ / -ray.z);
+}
+
+// 5-tap smallest-discontinuity normal (three r185 computeNormalFromDepth,
+// operating on linear viewZ directly).
+vec3 computeNormalFromDepth(ivec2 p, vec2 texel) {
+  vec2 size = vec2(textureSize(u_linearDepthHalf, 0));
+  float c0 = fetchViewZ(p);
+  float l2 = fetchViewZ(p - ivec2(2, 0));
+  float l1 = fetchViewZ(p - ivec2(1, 0));
+  float r1 = fetchViewZ(p + ivec2(1, 0));
+  float r2 = fetchViewZ(p + ivec2(2, 0));
+  float b2 = fetchViewZ(p - ivec2(0, 2));
+  float b1 = fetchViewZ(p - ivec2(0, 1));
+  float t1 = fetchViewZ(p + ivec2(0, 1));
+  float t2 = fetchViewZ(p + ivec2(0, 2));
+  float dl = abs((2.0 * l1 - l2) - c0);
+  float dr = abs((2.0 * r1 - r2) - c0);
+  float db = abs((2.0 * b1 - b2) - c0);
+  float dt = abs((2.0 * t1 - t2) - c0);
+  vec2 uv = vec2(p) * texel;
+  vec3 ce = getViewPosition(uv, c0);
+  vec3 dpdx = (dl < dr) ? ce - getViewPosition(uv - vec2(texel.x, 0.0), l1)
+                        : -ce + getViewPosition(uv + vec2(texel.x, 0.0), r1);
+  vec3 dpdy = (db < dt) ? ce - getViewPosition(uv - vec2(0.0, texel.y), b1)
+                        : -ce + getViewPosition(uv + vec2(0.0, texel.y), t1);
+  return normalize(cross(dpdx, dpdy));
+}
+
+void main() {
+  ivec2 p = ivec2(gl_FragCoord.xy);
+  vec2 size = vec2(textureSize(u_linearDepthHalf, 0));
+  vec2 texel = 1.0 / size;
+  float viewZ = fetchViewZ(p);
+  if (viewZ >= u_far * 0.999) { o_color = vec4(1.0); return; }
+
+  vec2 uv = gl_FragCoord.xy * texel;
+  vec3 viewPos = getViewPosition(uv, viewZ);
+  vec3 viewNormal = computeNormalFromDepth(p, texel);
+  // #1185's orthographic +Z view direction made GTAO a no-op (contact
+  // darkening 0, GPU run 38151583035); reverted until the slice math is
+  // proven for orthographic cameras.
+  vec3 viewDir = normalize(-viewPos);
+
+  // radius metres → pixels at this depth, clamped to the march budget.
+  float projScale = u_projMatrix[1][1] * size.y * 0.5;
+  // Orthographic projection has no 1/z: P[1][1] maps view units to ndc directly.
+  float radiusPx = clamp(u_radius * projScale / (u_ortho ? 1.0 : viewZ), 4.0, 96.0);
+
+  float jitter = ign4(gl_FragCoord.xy) + float(u_frameIndex) * GOLDEN_ANGLE;
+  float ao = 0.0;
+  const int DIRECTIONS = AURA_GTAO_DIRECTIONS;
+  const int STEPS = AURA_GTAO_STEPS;
+
+  for (int i = 0; i < DIRECTIONS; ++i) {
+    float angle = (float(i) + jitter) / float(DIRECTIONS) * PI;
+    vec2 dir = vec2(cos(angle), sin(angle));
+
+    // Per-slice tangent frame (r185): screen-space dir → view-space slice,
+    // unprojecting the 2D direction by the projection focal scales.
+    vec3 sliceDirView = normalize(vec3(dir.x / u_projMatrix[0][0],
+                                       dir.y / u_projMatrix[1][1], 0.0));
+    vec3 sliceBitangent = normalize(cross(sliceDirView, viewDir));
+    vec3 sliceTangent = cross(sliceBitangent, viewDir);
+    vec3 normalInSlice = normalize(viewNormal - sliceBitangent * dot(viewNormal, sliceBitangent));
+    vec3 tangentToNormalInSlice = cross(normalInSlice, sliceBitangent);
+    vec2 cosHorizons = vec2(dot(viewDir, tangentToNormalInSlice),
+                            dot(viewDir, -tangentToNormalInSlice));
+
+    for (int j = 0; j < STEPS; ++j) {
+      float t = pow(float(j + 1) / float(STEPS), u_distanceExponent);
+      vec2 sampleOffset = dir * radiusPx * t * texel;
+
+      vec2 sampleUvPos = uv + sampleOffset;
+      float sampleZ = textureLod(u_linearDepthHalf, sampleUvPos, 0.0).r;
+      vec3 viewDelta = getViewPosition(sampleUvPos, sampleZ) - viewPos;
+      float d = length(viewDelta);
+      if (d < u_radius && abs(viewDelta.z) < u_thickness) {
+        float sampleCosHorizon = dot(viewDir, normalize(viewDelta));
+        cosHorizons.x = max(cosHorizons.x,
+          sampleCosHorizon * clamp((u_radius - d) / (u_falloff * u_radius), 0.0, 1.0));
+      }
+
+      vec2 sampleUvNeg = uv - sampleOffset;
+      float sampleZ2 = textureLod(u_linearDepthHalf, sampleUvNeg, 0.0).r;
+      vec3 viewDelta2 = getViewPosition(sampleUvNeg, sampleZ2) - viewPos;
+      float d2 = length(viewDelta2);
+      if (d2 < u_radius && abs(viewDelta2.z) < u_thickness) {
+        float sampleCosHorizon2 = dot(viewDir, normalize(viewDelta2));
+        cosHorizons.y = max(cosHorizons.y,
+          sampleCosHorizon2 * clamp((u_radius - d2) / (u_falloff * u_radius), 0.0, 1.0));
+      }
+    }
+
+    vec2 sinHorizons = sqrt(1.0 - cosHorizons * cosHorizons);
+    float nx = dot(normalInSlice, sliceTangent);
+    float ny = dot(normalInSlice, viewDir);
+    float nxb = 0.5 * (acos(cosHorizons.y) - acos(cosHorizons.x)
+                     + sinHorizons.x * cosHorizons.x - sinHorizons.y * cosHorizons.y);
+    float nyb = 0.5 * (2.0 - cosHorizons.x * cosHorizons.x - cosHorizons.y * cosHorizons.y);
+    ao += nx * nxb + ny * nyb;
+  }
+
+  ao = clamp(ao / float(DIRECTIONS), 0.0, 1.0);
+  // visibility → occlusion strength (u_intensity 1 = full AO).
+  ao = mix(1.0, ao, clamp(u_intensity, 0.0, 1.0));
+  o_color = vec4(ao, 0.0, 0.0, 1.0);
+}
+`;
+//# sourceMappingURL=gtao.glsl.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"gtao.glsl.js","sourceRoot":"","sources":["../../../../../../packages/rendering/src/post/shaders/gtao.glsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,MAAM,MAAM,GAAG;;CAEd,CAAC;AAEF,MAAM,CAAC,MAAM,SAAS,GAAG,UAAU,CAAC,GAAG,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8J5C,CAAC"}

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

@@ -0,0 +1,13 @@
+/**
+ * PRD-03 §8.4 / §6.3 Phase 7 — S2 GTAO WGSL twin (half-res R8).
+ *
+ * Verbatim math of the GLSL twin (three r185 GTAOShader port): per-slice
+ * tangent frame, horizon cosine search, cosine-weighted arc integral,
+ * 4×4 IGN slice rotation + frame index, screen-space march
+ * `radiusPx = radius · projScale / viewZ` clamped 4..96, distance falloff,
+ * 5-tap smallest-discontinuity normal. The `#define`d tier constants become
+ * pipeline-overridable `override`s (defaults: DIRECTIONS 4, STEPS 4).
+ * Output: R8 visibility (1 = unoccluded).
+ */
+export declare const GTAO_WGSL = "// AURA_GTAO_DIRECTIONS \u2208 {2, 4} / AURA_GTAO_STEPS \u2208 {4, 6} \u2014 pipeline-overridable.\noverride AURA_GTAO_DIRECTIONS: i32 = 4;\noverride AURA_GTAO_STEPS: i32 = 4;\n\nstruct GtaoParams {\n  proj_matrix: mat4x4<f32>,\n  inv_proj_matrix: mat4x4<f32>,\n  near: f32,\n  far: f32,\n  radius: f32,\n  intensity: f32,\n  falloff: f32,\n  distance_exponent: f32,\n  thickness: f32,\n  frame_index: i32,\n  // 1 = orthographic (parallel rays, no 1/z screen scale); was padding.\n  ortho: i32,\n  _pad: vec2<f32>,\n};\n\n@group(0) @binding(0) var<uniform> u_params: GtaoParams;\n@group(0) @binding(1) var u_linear_depth_half_tex: texture_2d<f32>; // S1 RG32F, .r = min viewZ\n@group(0) @binding(2) var u_linear_depth_half_smp: sampler;\n\nconst PI: f32 = 3.141592653589793;\nconst GOLDEN_ANGLE: f32 = 2.39996322972865332;\n\n// 4\u00D74 interleaved-gradient noise (same generator as IGN, tiled).\nfn ign4(frag_coord: vec2<f32>) -> f32 {\n  let p = frag_coord - 4.0 * floor(frag_coord / 4.0);\n  return fract(52.9829189 * fract(dot(p, vec2<f32>(0.06711056, 0.00583715))));\n}\n\nfn fetch_view_z(p: vec2<i32>) -> f32 {\n  return textureLoad(u_linear_depth_half_tex,\n    clamp(p, vec2<i32>(0), vec2<i32>(textureDimensions(u_linear_depth_half_tex)) - vec2<i32>(1)), 0).r;\n}\n\nfn get_view_position(uv: vec2<f32>, view_z: f32) -> vec3<f32> {\n  if (u_params.ortho != 0) {\n    // Orthographic: parallel rays; unproject at any depth, set z directly.\n    let o = u_params.inv_proj_matrix * vec4<f32>(uv * 2.0 - vec2<f32>(1.0), 0.0, 1.0);\n    return vec3<f32>(o.xy / o.w, -view_z);\n  }\n  // Perspective: shoot the ndc.xy ray to the far plane, normalize to unit\n  // view-depth, scale by viewZ.\n  let view = u_params.inv_proj_matrix * vec4<f32>(uv * 2.0 - vec2<f32>(1.0), 1.0, 1.0);\n  let ray = view.xyz / view.w;\n  return ray * (view_z / -ray.z);\n}\n\n// 5-tap smallest-discontinuity normal (three r185 computeNormalFromDepth,\n// operating on linear viewZ directly).\nfn compute_normal_from_depth(p: vec2<i32>, texel: vec2<f32>) -> vec3<f32> {\n  let c0 = fetch_view_z(p);\n  let l2 = fetch_view_z(p - vec2<i32>(2, 0));\n  let l1 = fetch_view_z(p - vec2<i32>(1, 0));\n  let r1 = fetch_view_z(p + vec2<i32>(1, 0));\n  let r2 = fetch_view_z(p + vec2<i32>(2, 0));\n  let b2 = fetch_view_z(p - vec2<i32>(0, 2));\n  let b1 = fetch_view_z(p - vec2<i32>(0, 1));\n  let t1 = fetch_view_z(p + vec2<i32>(0, 1));\n  let t2 = fetch_view_z(p + vec2<i32>(0, 2));\n  let dl = abs((2.0 * l1 - l2) - c0);\n  let dr = abs((2.0 * r1 - r2) - c0);\n  let db = abs((2.0 * b1 - b2) - c0);\n  let dt = abs((2.0 * t1 - t2) - c0);\n  let uv = vec2<f32>(p) * texel;\n  let ce = get_view_position(uv, c0);\n  let dpdx = select(-ce + get_view_position(uv + vec2<f32>(texel.x, 0.0), r1),\n                    ce - get_view_position(uv - vec2<f32>(texel.x, 0.0), l1), dl < dr);\n  let dpdy = select(-ce + get_view_position(uv + vec2<f32>(0.0, texel.y), t1),\n                    ce - get_view_position(uv - vec2<f32>(0.0, texel.y), b1), db < dt);\n  return normalize(cross(dpdx, dpdy));\n}\n\n@fragment\nfn fs_gtao(@builtin(position) frag_coord: vec4<f32>) -> @location(0) vec4<f32> {\n  let p = vec2<i32>(frag_coord.xy);\n  let size = vec2<f32>(textureDimensions(u_linear_depth_half_tex));\n  let texel = vec2<f32>(1.0) / size;\n  let view_z = fetch_view_z(p);\n  if (view_z >= u_params.far * 0.999) { return vec4<f32>(1.0); }\n\n  let uv = frag_coord.xy * texel;\n  let view_pos = get_view_position(uv, view_z);\n  let view_normal = compute_normal_from_depth(p, texel);\n  let view_dir = normalize(-view_pos);\n\n  // radius metres \u2192 pixels at this depth, clamped to the march budget.\n  let proj_scale = u_params.proj_matrix[1][1] * size.y * 0.5;\n  let radius_px = clamp(u_params.radius * proj_scale / select(view_z, 1.0, u_params.ortho != 0), 4.0, 96.0);\n\n  let jitter = ign4(frag_coord.xy) + f32(u_params.frame_index) * GOLDEN_ANGLE;\n  var ao = 0.0;\n\n  for (var i = 0; i < AURA_GTAO_DIRECTIONS; i = i + 1) {\n    let angle = (f32(i) + jitter) / f32(AURA_GTAO_DIRECTIONS) * PI;\n    let dir = vec2<f32>(cos(angle), sin(angle));\n\n    // Per-slice tangent frame (r185): screen-space dir \u2192 view-space slice,\n    // unprojecting the 2D direction by the projection focal scales.\n    let slice_dir_view = normalize(vec3<f32>(dir.x / u_params.proj_matrix[0][0],\n                                             dir.y / u_params.proj_matrix[1][1], 0.0));\n    let slice_bitangent = normalize(cross(slice_dir_view, view_dir));\n    let slice_tangent = cross(slice_bitangent, view_dir);\n    let normal_in_slice = normalize(view_normal - slice_bitangent * dot(view_normal, slice_bitangent));\n    let tangent_to_normal_in_slice = cross(normal_in_slice, slice_bitangent);\n    var cos_horizons = vec2<f32>(dot(view_dir, tangent_to_normal_in_slice),\n                                 dot(view_dir, -tangent_to_normal_in_slice));\n\n    for (var j = 0; j < AURA_GTAO_STEPS; j = j + 1) {\n      let t = pow(f32(j + 1) / f32(AURA_GTAO_STEPS), u_params.distance_exponent);\n      let sample_offset = dir * radius_px * t * texel;\n\n      let sample_uv_pos = uv + sample_offset;\n      let sample_z = textureSampleLevel(u_linear_depth_half_tex, u_linear_depth_half_smp, sample_uv_pos, 0.0).r;\n      let view_delta = get_view_position(sample_uv_pos, sample_z) - view_pos;\n      let d = length(view_delta);\n      if (d < u_params.radius && abs(view_delta.z) < u_params.thickness) {\n        let sample_cos_horizon = dot(view_dir, normalize(view_delta));\n        cos_horizons.x = max(cos_horizons.x,\n          sample_cos_horizon * clamp((u_params.radius - d) / (u_params.falloff * u_params.radius), 0.0, 1.0));\n      }\n\n      let sample_uv_neg = uv - sample_offset;\n      let sample_z2 = textureSampleLevel(u_linear_depth_half_tex, u_linear_depth_half_smp, sample_uv_neg, 0.0).r;\n      let view_delta2 = get_view_position(sample_uv_neg, sample_z2) - view_pos;\n      let d2 = length(view_delta2);\n      if (d2 < u_params.radius && abs(view_delta2.z) < u_params.thickness) {\n        let sample_cos_horizon2 = dot(view_dir, normalize(view_delta2));\n        cos_horizons.y = max(cos_horizons.y,\n          sample_cos_horizon2 * clamp((u_params.radius - d2) / (u_params.falloff * u_params.radius), 0.0, 1.0));\n      }\n    }\n\n    let sin_horizons = sqrt(vec2<f32>(1.0) - cos_horizons * cos_horizons);\n    let nx = dot(normal_in_slice, slice_tangent);\n    let ny = dot(normal_in_slice, view_dir);\n    let nxb = 0.5 * (acos(cos_horizons.y) - acos(cos_horizons.x)\n                     + sin_horizons.x * cos_horizons.x - sin_horizons.y * cos_horizons.y);\n    let nyb = 0.5 * (2.0 - cos_horizons.x * cos_horizons.x - cos_horizons.y * cos_horizons.y);\n    ao = ao + nx * nxb + ny * nyb;\n  }\n\n  ao = clamp(ao / f32(AURA_GTAO_DIRECTIONS), 0.0, 1.0);\n  // visibility \u2192 occlusion strength (u_intensity 1 = full AO).\n  ao = mix(1.0, ao, clamp(u_params.intensity, 0.0, 1.0));\n  return vec4<f32>(ao, 0.0, 0.0, 1.0);\n}\n";
+//# sourceMappingURL=gtao.wgsl.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"gtao.wgsl.d.ts","sourceRoot":"","sources":["../../../../../../packages/rendering/src/post/shaders/gtao.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,eAAO,MAAM,SAAS,02NAsJrB,CAAC"}

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

@@ -0,0 +1,163 @@
+/**
+ * PRD-03 §8.4 / §6.3 Phase 7 — S2 GTAO WGSL twin (half-res R8).
+ *
+ * Verbatim math of the GLSL twin (three r185 GTAOShader port): per-slice
+ * tangent frame, horizon cosine search, cosine-weighted arc integral,
+ * 4×4 IGN slice rotation + frame index, screen-space march
+ * `radiusPx = radius · projScale / viewZ` clamped 4..96, distance falloff,
+ * 5-tap smallest-discontinuity normal. The `#define`d tier constants become
+ * pipeline-overridable `override`s (defaults: DIRECTIONS 4, STEPS 4).
+ * Output: R8 visibility (1 = unoccluded).
+ */
+export const GTAO_WGSL = /* wgsl */ `// AURA_GTAO_DIRECTIONS ∈ {2, 4} / AURA_GTAO_STEPS ∈ {4, 6} — pipeline-overridable.
+override AURA_GTAO_DIRECTIONS: i32 = 4;
+override AURA_GTAO_STEPS: i32 = 4;
+
+struct GtaoParams {
+  proj_matrix: mat4x4<f32>,
+  inv_proj_matrix: mat4x4<f32>,
+  near: f32,
+  far: f32,
+  radius: f32,
+  intensity: f32,
+  falloff: f32,
+  distance_exponent: f32,
+  thickness: f32,
+  frame_index: i32,
+  // 1 = orthographic (parallel rays, no 1/z screen scale); was padding.
+  ortho: i32,
+  _pad: vec2<f32>,
+};
+
+@group(0) @binding(0) var<uniform> u_params: GtaoParams;
+@group(0) @binding(1) var u_linear_depth_half_tex: texture_2d<f32>; // S1 RG32F, .r = min viewZ
+@group(0) @binding(2) var u_linear_depth_half_smp: sampler;
+
+const PI: f32 = 3.141592653589793;
+const GOLDEN_ANGLE: f32 = 2.39996322972865332;
+
+// 4×4 interleaved-gradient noise (same generator as IGN, tiled).
+fn ign4(frag_coord: vec2<f32>) -> f32 {
+  let p = frag_coord - 4.0 * floor(frag_coord / 4.0);
+  return fract(52.9829189 * fract(dot(p, vec2<f32>(0.06711056, 0.00583715))));
+}
+
+fn fetch_view_z(p: vec2<i32>) -> f32 {
+  return textureLoad(u_linear_depth_half_tex,
+    clamp(p, vec2<i32>(0), vec2<i32>(textureDimensions(u_linear_depth_half_tex)) - vec2<i32>(1)), 0).r;
+}
+
+fn get_view_position(uv: vec2<f32>, view_z: f32) -> vec3<f32> {
+  if (u_params.ortho != 0) {
+    // Orthographic: parallel rays; unproject at any depth, set z directly.
+    let o = u_params.inv_proj_matrix * vec4<f32>(uv * 2.0 - vec2<f32>(1.0), 0.0, 1.0);
+    return vec3<f32>(o.xy / o.w, -view_z);
+  }
+  // Perspective: shoot the ndc.xy ray to the far plane, normalize to unit
+  // view-depth, scale by viewZ.
+  let view = u_params.inv_proj_matrix * vec4<f32>(uv * 2.0 - vec2<f32>(1.0), 1.0, 1.0);
+  let ray = view.xyz / view.w;
+  return ray * (view_z / -ray.z);
+}
+
+// 5-tap smallest-discontinuity normal (three r185 computeNormalFromDepth,
+// operating on linear viewZ directly).
+fn compute_normal_from_depth(p: vec2<i32>, texel: vec2<f32>) -> vec3<f32> {
+  let c0 = fetch_view_z(p);
+  let l2 = fetch_view_z(p - vec2<i32>(2, 0));
+  let l1 = fetch_view_z(p - vec2<i32>(1, 0));
+  let r1 = fetch_view_z(p + vec2<i32>(1, 0));
+  let r2 = fetch_view_z(p + vec2<i32>(2, 0));
+  let b2 = fetch_view_z(p - vec2<i32>(0, 2));
+  let b1 = fetch_view_z(p - vec2<i32>(0, 1));
+  let t1 = fetch_view_z(p + vec2<i32>(0, 1));
+  let t2 = fetch_view_z(p + vec2<i32>(0, 2));
+  let dl = abs((2.0 * l1 - l2) - c0);
+  let dr = abs((2.0 * r1 - r2) - c0);
+  let db = abs((2.0 * b1 - b2) - c0);
+  let dt = abs((2.0 * t1 - t2) - c0);
+  let uv = vec2<f32>(p) * texel;
+  let ce = get_view_position(uv, c0);
+  let dpdx = select(-ce + get_view_position(uv + vec2<f32>(texel.x, 0.0), r1),
+                    ce - get_view_position(uv - vec2<f32>(texel.x, 0.0), l1), dl < dr);
+  let dpdy = select(-ce + get_view_position(uv + vec2<f32>(0.0, texel.y), t1),
+                    ce - get_view_position(uv - vec2<f32>(0.0, texel.y), b1), db < dt);
+  return normalize(cross(dpdx, dpdy));
+}
+
+@fragment
+fn fs_gtao(@builtin(position) frag_coord: vec4<f32>) -> @location(0) vec4<f32> {
+  let p = vec2<i32>(frag_coord.xy);
+  let size = vec2<f32>(textureDimensions(u_linear_depth_half_tex));
+  let texel = vec2<f32>(1.0) / size;
+  let view_z = fetch_view_z(p);
+  if (view_z >= u_params.far * 0.999) { return vec4<f32>(1.0); }
+
+  let uv = frag_coord.xy * texel;
+  let view_pos = get_view_position(uv, view_z);
+  let view_normal = compute_normal_from_depth(p, texel);
+  let view_dir = normalize(-view_pos);
+
+  // radius metres → pixels at this depth, clamped to the march budget.
+  let proj_scale = u_params.proj_matrix[1][1] * size.y * 0.5;
+  let radius_px = clamp(u_params.radius * proj_scale / select(view_z, 1.0, u_params.ortho != 0), 4.0, 96.0);
+
+  let jitter = ign4(frag_coord.xy) + f32(u_params.frame_index) * GOLDEN_ANGLE;
+  var ao = 0.0;
+
+  for (var i = 0; i < AURA_GTAO_DIRECTIONS; i = i + 1) {
+    let angle = (f32(i) + jitter) / f32(AURA_GTAO_DIRECTIONS) * PI;
+    let dir = vec2<f32>(cos(angle), sin(angle));
+
+    // Per-slice tangent frame (r185): screen-space dir → view-space slice,
+    // unprojecting the 2D direction by the projection focal scales.
+    let slice_dir_view = normalize(vec3<f32>(dir.x / u_params.proj_matrix[0][0],
+                                             dir.y / u_params.proj_matrix[1][1], 0.0));
+    let slice_bitangent = normalize(cross(slice_dir_view, view_dir));
+    let slice_tangent = cross(slice_bitangent, view_dir);
+    let normal_in_slice = normalize(view_normal - slice_bitangent * dot(view_normal, slice_bitangent));
+    let tangent_to_normal_in_slice = cross(normal_in_slice, slice_bitangent);
+    var cos_horizons = vec2<f32>(dot(view_dir, tangent_to_normal_in_slice),
+                                 dot(view_dir, -tangent_to_normal_in_slice));
+
+    for (var j = 0; j < AURA_GTAO_STEPS; j = j + 1) {
+      let t = pow(f32(j + 1) / f32(AURA_GTAO_STEPS), u_params.distance_exponent);
+      let sample_offset = dir * radius_px * t * texel;
+
+      let sample_uv_pos = uv + sample_offset;
+      let sample_z = textureSampleLevel(u_linear_depth_half_tex, u_linear_depth_half_smp, sample_uv_pos, 0.0).r;
+      let view_delta = get_view_position(sample_uv_pos, sample_z) - view_pos;
+      let d = length(view_delta);
+      if (d < u_params.radius && abs(view_delta.z) < u_params.thickness) {
+        let sample_cos_horizon = dot(view_dir, normalize(view_delta));
+        cos_horizons.x = max(cos_horizons.x,
+          sample_cos_horizon * clamp((u_params.radius - d) / (u_params.falloff * u_params.radius), 0.0, 1.0));
+      }
+
+      let sample_uv_neg = uv - sample_offset;
+      let sample_z2 = textureSampleLevel(u_linear_depth_half_tex, u_linear_depth_half_smp, sample_uv_neg, 0.0).r;
+      let view_delta2 = get_view_position(sample_uv_neg, sample_z2) - view_pos;
+      let d2 = length(view_delta2);
+      if (d2 < u_params.radius && abs(view_delta2.z) < u_params.thickness) {
+        let sample_cos_horizon2 = dot(view_dir, normalize(view_delta2));
+        cos_horizons.y = max(cos_horizons.y,
+          sample_cos_horizon2 * clamp((u_params.radius - d2) / (u_params.falloff * u_params.radius), 0.0, 1.0));
+      }
+    }
+
+    let sin_horizons = sqrt(vec2<f32>(1.0) - cos_horizons * cos_horizons);
+    let nx = dot(normal_in_slice, slice_tangent);
+    let ny = dot(normal_in_slice, view_dir);
+    let nxb = 0.5 * (acos(cos_horizons.y) - acos(cos_horizons.x)
+                     + sin_horizons.x * cos_horizons.x - sin_horizons.y * cos_horizons.y);
+    let nyb = 0.5 * (2.0 - cos_horizons.x * cos_horizons.x - cos_horizons.y * cos_horizons.y);
+    ao = ao + nx * nxb + ny * nyb;
+  }
+
+  ao = clamp(ao / f32(AURA_GTAO_DIRECTIONS), 0.0, 1.0);
+  // visibility → occlusion strength (u_intensity 1 = full AO).
+  ao = mix(1.0, ao, clamp(u_params.intensity, 0.0, 1.0));
+  return vec4<f32>(ao, 0.0, 0.0, 1.0);
+}
+`;
+//# sourceMappingURL=gtao.wgsl.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"gtao.wgsl.js","sourceRoot":"","sources":["../../../../../../packages/rendering/src/post/shaders/gtao.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,MAAM,CAAC,MAAM,SAAS,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsJnC,CAAC"}

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

@@ -0,0 +1,22 @@
+/**
+ * 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)`.
+ */
+export declare const GTAO_DENOISE_GLSL = "#version 300 es\nprecision highp float;\n\nuniform sampler2D u_ao;              // half-res R8\nuniform highp sampler2D u_depthHalf; // half-res linear depth (.r)\nuniform vec2 u_dir;                  // (texel.x, 0) then (0, texel.y)\nout vec4 o_color;\n\n\n// 5-tap gaussian (sigma 1.0) \u00D7 exponential depth term exp(-|dz|/(0.05*z)).\nfloat aoWeight(float dz, float z, float g) {\n  return g * exp(-abs(dz) / max(0.05 * z, 1e-4));\n}\nconst float GAUSS_5[5] = float[5](0.06136, 0.24477, 0.38774, 0.24477, 0.06136);\n\n\nvoid main() {\n  ivec2 p = ivec2(gl_FragCoord.xy);\n  vec2 texel = vec2(textureSize(u_ao, 0));\n  float centerAo = texelFetch(u_ao, p, 0).r;\n  float centerZ = texelFetch(u_depthHalf, p, 0).r;\n  float total = GAUSS_5[2];\n  float sum = centerAo * GAUSS_5[2];\n  for (int i = -2; i <= 2; ++i) {\n    if (i == 0) continue;\n    ivec2 s = p + ivec2(u_dir * texel * float(i));\n    s = clamp(s, ivec2(0), ivec2(texel) - 1);\n    float z = texelFetch(u_depthHalf, s, 0).r;\n    float w = aoWeight(z - centerZ, centerZ, GAUSS_5[i + 2]);\n    sum += texelFetch(u_ao, s, 0).r * w;\n    total += w;\n  }\n  o_color = vec4(sum / total, 0.0, 0.0, 1.0);\n}\n";
+export declare const GTAO_APPLY_GLSL = "#version 300 es\nprecision highp float;\n\nuniform sampler2D u_hdr;             // full-res HDR (linear)\nuniform sampler2D u_ao;              // denoised half-res R8\nuniform highp sampler2D u_depthFull; // full-res linear depth\nuniform highp sampler2D u_depthHalf;\nuniform float u_far;\nuniform float u_aoFallbackStrength;\nuniform bool u_aoMultiBounce;\nout vec4 o_color;\n\n// 5-tap gaussian (sigma 1.0) \u00D7 exponential depth term exp(-|dz|/(0.05*z)).\nfloat aoWeight(float dz, float z, float g) {\n  return g * exp(-abs(dz) / max(0.05 * z, 1e-4));\n}\nconst float GAUSS_5[5] = float[5](0.06136, 0.24477, 0.38774, 0.24477, 0.06136);\n\n// Jimenez 2016 multi-bounce polynomial, albedoProxy \u03C1 = 0.5.\nfloat aoMultiBounce(float ao) {\n  float a = 2.0404 * 0.5 - 0.3324;\n  float b = -4.7951 * 0.5 + 0.6417;\n  float 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.\nfloat upsampleAo(vec2 uvHalf, float fullZ, vec2 halfSize) {\n  vec2 p = uvHalf * halfSize - 0.5;\n  ivec2 p0 = ivec2(floor(p));\n  vec2 f = p - vec2(p0);\n  float sum = 0.0;\n  float total = 0.0;\n  for (int y = 0; y < 2; ++y) {\n    for (int x = 0; x < 2; ++x) {\n      ivec2 s = clamp(p0 + ivec2(x, y), ivec2(0), ivec2(halfSize) - 1);\n      float z = texelFetch(u_depthHalf, s, 0).r;\n      float w = aoWeight(z - fullZ, fullZ,\n                         (x == 0 ? 1.0 - f.x : f.x) * (y == 0 ? 1.0 - f.y : f.y));\n      sum += texelFetch(u_ao, s, 0).r * w;\n      total += w;\n    }\n  }\n  return total > 0.0 ? sum / total : 1.0;\n}\n\nvoid main() {\n  ivec2 p = ivec2(gl_FragCoord.xy);\n  vec4 hdr = texelFetch(u_hdr, p, 0);\n  float fullZ = texelFetch(u_depthFull, p, 0).r;\n  vec2 halfSize = vec2(textureSize(u_ao, 0));\n  vec2 uvHalf = gl_FragCoord.xy / vec2(textureSize(u_hdr, 0));\n  float ao = upsampleAo(uvHalf, fullZ, halfSize);\n  float aoMB = u_aoMultiBounce ? aoMultiBounce(ao) : ao;\n\n  float sky = step(u_far * 0.999, fullZ);\n  float w;\n  if (hdr.a >= 1.5) {\n    // Tagged generated-program pixel: alpha = 2 + f_ind (prd03.indirectFraction).\n    w = clamp(hdr.a - 2.0, 0.0, 1.0);\n  } else {\n    // Legacy / custom-shader pixel: no f_ind, conservative fallback.\n    float luma = dot(hdr.rgb, vec3(0.2126, 0.7152, 0.0722));\n    w = u_aoFallbackStrength * step(luma, 4.0);\n  }\n  w *= 1.0 - sky;\n  hdr.rgb *= mix(1.0, aoMB, w);\n  hdr.a = min(hdr.a, 1.0);\n  o_color = hdr;\n}\n";
+//# sourceMappingURL=gtaoDenoise.glsl.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"gtaoDenoise.glsl.d.ts","sourceRoot":"","sources":["../../../../../../packages/rendering/src/post/shaders/gtaoDenoise.glsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAcH,eAAO,MAAM,iBAAiB,0pCA0B7B,CAAC;AAEF,eAAO,MAAM,eAAe,8/EA+D3B,CAAC"}