@woosh/meep-engine 3.60.5 → 3.60.7

package/src/shade/renderer/postprocess/gtao/fragment_shader_gtao.js

@@ -6,7 +6,6 @@ import { chunk_project_view_position_from_depth } from "../../shader/chunk/camer
 import { chunk_get_view_space_depth } from "../../shader/chunk/depth/chunk_get_view_space_depth.js";
 import { chunk_mat4_extract_position } from "../../shader/chunk/geometry/mat4/chunk_mat4_extract_position.js";
 import { chunk_decode_g_buffer_normal } from "../../shader/chunk/geometry/normal/chunk_decode_g_buffer_normal.js";
-import { chunk_encode_g_buffer_normal } from "../../shader/chunk/geometry/normal/chunk_encode_g_buffer_normal.js";
 import { chunk_v3_matrix4_rotate } from "../../shader/chunk/geometry/vec3/chunk_v3_matrix4_rotate.js";
 import { chunk_fast_acos } from "../../shader/chunk/math/fast/chunk_fast_acos.js";
 import { PI_DECLARATION } from "../../shader/chunk/math/PI_DECLARATION.js";
@@ -95,16 +94,11 @@ const SLICE_COUNT = ${QUALITY_SETTINGS.slices};
 
 const STEPS = ${QUALITY_SETTINGS.steps};
 
-struct Output{
-    @location(0) visibility: vec2<f32>, // first 2 moment
-    @location(1) bent_normal: vec2<u32>, // octahedral encoding
-}
-
 @fragment
 fn main(
     @builtin(position) coord: vec4<f32>,
     @location(0) uv: vec2<f32>,
-) -> Output {
+) -> @location(0) vec4<f32> {
 
     // fadeout precompute optimisation
     const falloffRange = ${GTAO_EFFECT_FALLOFF_RANGE} * ${GTAO_EFFECT_RADIUS};
@@ -160,7 +154,22 @@ fn main(
            
     // this is the min distance to start sampling from to avoid sampling from the center pixel (no useful data obtained from sampling center pixel)
     let minS = pixelTooCloseThreshold / screenspaceRadius;
-    
+
+    // The slices' angle is measured around the view ray, from view-space x made perpendicular to it: at the
+    // screen's centre that is the screen's own x, as the paper has it. The ray never runs along x inside a frustum.
+    let slice_basis_x = normalize(vec3(1.0, 0.0, 0.0) - view_direction_vs * view_direction_vs.x);
+    let slice_basis_y = cross(view_direction_vs, slice_basis_x);
+
+    // This texel through the projection, reading only the entries a projection fills, as
+    // project_view_position_from_depth reads its inverse: x from x and z, y from y and z, w from z. The TAA
+    // jitter is in the z column of a perspective, the translation column of an orthographic one.
+    let projection = camera.projection_matrix;
+    let center_clip_xy = vec2(
+        fma(position_vs.x, projection[0][0], fma(position_vs.z, projection[2][0], projection[3][0])),
+        fma(position_vs.y, projection[1][1], fma(position_vs.z, projection[2][1], projection[3][1])),
+    );
+    let center_clip_w = fma(position_vs.z, projection[2][3], projection[3][3]);
+
     const INV_SLICE_COUNT = 1.0 / f32(SLICE_COUNT);
        
     for (var slice = 0; slice < SLICE_COUNT; slice++) {
@@ -173,12 +182,24 @@ fn main(
         let cosPhi = cos(phi);
         let sinPhi = sin(phi);
         
-        let omega = vec2(cosPhi, -sinPhi) * screenspaceRadius;
-        
-        // line 8 from the paper
-        let sliceViewDir = vec3(cosPhi, sinPhi, 0.0);
+        // line 8 from the paper, with phi the slice's angle around this texel's own view ray: the integral below
+        // is written in that angle. The paper takes phi on screen, which is the same angle only at the screen's
+        // centre; off it, slices spread evenly on screen bunch around the view ray, the two of a frame stop
+        // cancelling, and an open plane's bent normal leans by degrees towards the screen's edges.
+        let sliceViewDir = cosPhi * slice_basis_x + sinPhi * slice_basis_y;
         let sliceWorldDir = v3_matrix4_rotate(sliceViewDir, camera.view_matrix_inverse);
 
+        // The slice's plane holds the view ray, so on screen it is a line through this texel, along the
+        // projection's derivative in the slice's direction: (d(clip.xy) * clip.w - clip.xy * d(clip.w)) / clip.w^2,
+        // its scale dropped, into uv and then pixels.
+        let slice_clip_xy = vec2(
+            fma(sliceViewDir.x, projection[0][0], sliceViewDir.z * projection[2][0]),
+            fma(sliceViewDir.y, projection[1][1], sliceViewDir.z * projection[2][1]),
+        );
+        let slice_clip_w = sliceViewDir.z * projection[2][3];
+        let slice_screen = (slice_clip_xy * center_clip_w - center_clip_xy * slice_clip_w) * vec2(0.5, -0.5) * vec2<f32>(ViewportSize);
+        let omega = normalize(slice_screen) * screenspaceRadius;
+
         // line 9 from the paper
         // NOTE: optimized with FMA, readability suffers
         let orthoWorldDir = fma( vec3( -dot(sliceWorldDir, view_direction_ws) ), view_direction_ws, sliceWorldDir );
@@ -230,7 +251,7 @@ fn main(
             // approx lines 21-22 from the paper, unrolled
             var sampleOffset = s * omega;
 
-            // omega = vec2(cosPhi, -sinPhi) * screenspaceRadius has length screenspaceRadius
+            // omega is a unit screen direction times screenspaceRadius, so has length screenspaceRadius
             let sampleOffsetLength = s * screenspaceRadius;
             let mipLevel = gtao_compute_mip_level(sampleOffsetLength);
 
@@ -318,12 +339,10 @@ fn main(
     visibility = max(0.03, visibility);		
     
     bent_normal = normalize(bent_normal);
-        
-    var out: Output;
-    out.visibility = vec2(visibility, visibility * visibility);
-    out.bent_normal = encode_g_buffer_normal( bent_normal );
-    
-    return out;
+
+    // The bend, not the bent normal: what the horizons add to the shading normal. Unoccluded it is exactly
+    // zero, so the filters downstream can average it without averaging away the normal map's detail.
+    return vec4(visibility, bent_normal - view_normal_ws);
 }
 `, [
         chunk_get_view_space_depth,
@@ -331,7 +350,6 @@ fn main(
         PI_HALF_DECLARATION,
 
         chunk_decode_g_buffer_normal,
-        chunk_encode_g_buffer_normal,
         chunk_spatio_temporal_noise_r2_64,
 
         chunk_fast_acos,
@@ -357,9 +375,10 @@ export const fragment_shader_gtao = new ImageShader({
     targets: [
         {
             label: "Occlusion",
-            // first 2 moments of visibility
-            format: "rg16float",
-            clearValue: [1, 1], // Stores visibility, so 1 == not occluded
+            // visibility, and the world-space bend: bent normal minus shading normal
+            format: "rgba16float",
+            // Background is skipped, so it keeps the clear: not occluded, not bent.
+            clearValue: [1, 0, 0, 0],
             blend: BlendState.from({
                 color: {
                     operation: "add",
@@ -368,10 +387,5 @@ export const fragment_shader_gtao = new ImageShader({
                 }
             })
         },
-        {
-            label: "Bent Normals",
-            // Direction is encoded with octahedral
-            format: "rg16uint",
-        },
     ]
 });

package/src/shade/renderer/postprocess/gtao/fragment_shader_gtao_with_irradiance.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fragment_shader_gtao_with_irradiance.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/gtao/fragment_shader_gtao_with_irradiance.js"],"names":[],"mappings":"AA2XA,+DAkCG;4BA5YyB,6BAA6B"}
+{"version":3,"file":"fragment_shader_gtao_with_irradiance.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/gtao/fragment_shader_gtao_with_irradiance.js"],"names":[],"mappings":"AA2YA,+DAkCG;4BA7ZyB,6BAA6B"}