@woosh/meep-engine 3.60.5 → 3.60.6

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

@@ -1,5 +1,10 @@
 import { DEPTH_STENCIL_FOREGROUND_ONLY } from "../../depth/DEPTH_STENCIL_FOREGROUND_ONLY.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_f16_round_stochastic } from "../../shader/chunk/math/chunk_f16_round_stochastic.js";
 import { chunk_get_std_dev } from "../../shader/chunk/math/statistics/chunk_get_std_dev.js";
+import { chunk_hash_to_float01 } from "../../shader/chunk/random/chunk_hash_to_float01.js";
+import { chunk_pcg3d } from "../../shader/chunk/random/pcg/chunk_pcg3d.js";
 import {
     chunk_texture_sample_catmullrom_hardware_5tap_uv
 } from "../../shader/chunk/texture/sample/chunk_texture_sample_catmullrom_hardware_5tap_uv.js";
@@ -8,107 +13,174 @@ import { ImageShader } from "../../shader/ImageShader.js";
 import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
 import { ShaderDescriptor } from "../../shader/ShaderDescriptor.js";
 import { SAMPLER_LINEAR_UPSCALE } from "../../texture/SAMPLER_LINEAR_UPSCALE.js";
-import { f32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { f32, u32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
 import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
 import { chunk_taa_velocity_confidence } from "../taa/shader_taa.js";
 import { chunk_taa_get_velocity } from "../velocity/chunk_taa_get_velocity.js";
 
 const AO_REPROJECT_SETTINGS_STRUCT = WebGPUStruct.from({
     /**
-     * 1 to blend against the history, 0 to take this frame's moments alone: the first frame, a reset,
-     * or a frame that does not follow the one the history was written on.
+     * 1 to blend against the history, 0 to take this frame's alone: the first frame, a reset, or a frame that
+     * does not follow the one the history was written on.
      */
     history_validity: f32,
+    /**
+     * Seeds the stochastic rounding of the history's store, fresh each frame.
+     */
+    frame_index: u32,
 });
 
 const resources = new ShaderResourceSetDescriptor();
 
-// per-pass, 4 bytes, read-only: immediate data rather than a uniform buffer.
+// per-pass, 8 bytes, read-only: immediate data rather than a uniform buffer.
 resources.setImmediate("settings", AO_REPROJECT_SETTINGS_STRUCT);
 resources.createGroup()
     .addTexture("tInput")
     .addTexture("tVelocity")
     .addTexture("tOcclusion")
+    .addTexture("tNormal", "uint")
+    // last frame's G-buffer normal, at the size last frame was drawn at
+    .addTexture("tNormalPrevious", "uint")
     .addTexture("tHistory","float")
     .addSampler("sLinear", "filtering", SAMPLER_LINEAR_UPSCALE)
 
 const body = CodeChunk.from(
 //language=WGSL
     `
-fn compute_center_moments(
-    input_center: vec2<f32>,
+struct NeighbourhoodStatistics {
+    // visibility's first two moments
+    moments: vec2<f32>,
+    // the bend's mean, and the mean of its squared length
+    bend: vec3<f32>,
+    bend_square: f32,
+}
+
+fn compute_center_statistics(
+    input_center: vec4<f32>,
     input_coord: vec2<i32>,
     input_texture: texture_2d<f32>,
-) -> vec2<f32>{
-    
+) -> NeighbourhoodStatistics {
+
     const offsets = array< vec2<i32>, 8 >(
       vec2( -1, -1 ),
       vec2(  0, -1 ),
-      vec2(  1, -1 ), 
-      
-      vec2( -1,  0 ), 
-      vec2(  1,  0 ), 
-      
+      vec2(  1, -1 ),
+
+      vec2( -1,  0 ),
+      vec2(  1,  0 ),
+
       vec2( -1,  1 ),
-      vec2(  0,  1 ), 
-      vec2(  1,  1 ), 
+      vec2(  0,  1 ),
+      vec2(  1,  1 ),
    );
-    
+
     const iteratorMax = 8;
     const rcp_divider = 1.f / 9.f;
 
     var moments = vec2(input_center.x, input_center.x * input_center.x);
-    
+
+    var bend = input_center.yzw;
+    var bend_square = dot(input_center.yzw, input_center.yzw);
+
     for (var  i = 0; i < iteratorMax; i++ ) {
         let new_st = input_coord + offsets[ i ];
 
-        let texel = textureLoad(input_texture, new_st, 0 ).rg;
-        
+        let texel = textureLoad(input_texture, new_st, 0 );
+
         moments += vec2(texel.x, texel.x * texel.x);
+        bend += texel.yzw;
+        bend_square += dot(texel.yzw, texel.yzw);
     }
-    
-    return moments * rcp_divider;
+
+    return NeighbourhoodStatistics(moments * rcp_divider, bend * rcp_divider, bend_square * rcp_divider);
+}
+
+// A face this far from another is another surface: half a right angle, as UE's Lumen takes it
+// (r.Lumen.ScreenProbeGather.Temporal.NormalThreshold). A tessellated curve's faces sit well inside it, a
+// crease's well outside.
+const SAME_SURFACE_COS = 0.70710678;
+
+// 1 where the history texel at tap was written on this texel's surface, by its face normal: last frame's
+fn history_texel_on_surface(tap: vec2<i32>, size: vec2<i32>, face_normal: vec3<f32>) -> f32 {
+    let history_face_normal = decode_g_buffer_normal(textureLoad(tNormalPrevious, clamp(tap, vec2(0), size - 1), 0).zw);
+
+    return select(0.0, 1.0, dot(history_face_normal, face_normal) >= SAME_SURFACE_COS);
+}
+
+// The share of the history's bilinear footprint written on this texel's surface, read where the history is, in
+// the previous normal's own grid.
+fn history_surface_agreement(prev_uv: vec2<f32>, face_normal: vec3<f32>) -> f32 {
+    let size = vec2<i32>(textureDimensions(tNormalPrevious));
+
+    let st = prev_uv * vec2<f32>(size) - 0.5;
+    let origin = vec2<i32>(floor(st));
+    let f = st - floor(st);
+
+    let weights = vec4(
+        (1.0 - f.x) * (1.0 - f.y),
+        f.x * (1.0 - f.y),
+        (1.0 - f.x) * f.y,
+        f.x * f.y,
+    );
+
+    let on_surface = vec4(
+        history_texel_on_surface(origin, size, face_normal),
+        history_texel_on_surface(origin + vec2(1, 0), size, face_normal),
+        history_texel_on_surface(origin + vec2(0, 1), size, face_normal),
+        history_texel_on_surface(origin + vec2(1, 1), size, face_normal),
+    );
+
+    return dot(weights, on_surface);
+}
+
+struct Output {
+    // visibility and the bend, accumulated: next frame's history
+    @location(0) history: vec4<f32>,
+    // the bent normal, octahedral as the G-buffer's normals are
+    @location(1) bent_normal: vec2<u32>,
 }
 
 @fragment
 fn main(
     @builtin(position) coord: vec4<f32>,
     @location(0) uv: vec2<f32>,
-) -> @location(0) vec2<f32> {
+) -> Output {
     let screenST = vec2<i32>( coord.xy );
-    
+
     let resolution = textureDimensions(tInput);
-    
+
     let occlusion_confidence = textureLoad(tOcclusion, screenST, 0).r;
-    let current_moments = textureLoad(tInput, screenST, 0).rg;
-    
+    let current = textureLoad(tInput, screenST, 0);
+    let encoded_normal = textureLoad(tNormal, screenST, 0);
+    let shading_normal = decode_g_buffer_normal(encoded_normal.xy);
+
     // get velocity
     let velocity = taa_get_velocity( tVelocity, screenST );
-    
+
     let velocity_confidence = taa_velocity_confidence(velocity);
-    
-    
+
+
     // prev frame ST
     let prevFrameScreenST = coord.xy - velocity.xy;
-    
+
     const MIN_VARIANCE = 0.5f; // under motion
     const MAX_VARIANCE = 1.2f; // no motion
 
     let variance_scale = mix( MIN_VARIANCE, MAX_VARIANCE, velocity_confidence * velocity_confidence ) ;
-    
-    
+
+
     let history_within_screen = all( prevFrameScreenST >= vec2(0.0) ) && all( prevFrameScreenST < vec2f(resolution )) ;
-    
-    
+
+
     let confidence = velocity_confidence * occlusion_confidence * select(0.0, 1.0,history_within_screen) * settings.history_validity;
 
-    
-    var output: vec2<f32>;
-    
+
+    var resolved: vec4<f32>;
+
     if(
         confidence <= 0.001
     ) {
-         output = current_moments;
+         resolved = current;
     }else{
 
         // a uv over this frame's size: the history keeps the size it was written at across a
@@ -116,51 +188,81 @@ fn main(
         let prev_uv = prevFrameScreenST / vec2<f32>(resolution);
 
         let history = texture_sample_catmullrom_hardware_5tap_uv(tHistory, sLinear, prev_uv);
-        let history_moments = history.rg;
 
         // AABB sigma is calibrated against the spatially pre-filtered input.
         // The small spatial denoise upstream is what makes this clamp meaningful:
         // it stabilises the neighbourhood so the AABB is a tight, non-jittery
         // ghosting bound rather than chasing per-frame noise. (Standard
         // pre-blur-then-clamp pattern from SVGF-style and TAA literature.)
-        let filtered_center_moments = compute_center_moments( current_moments, screenST, tInput);
+        let statistics = compute_center_statistics( current, screenST, tInput);
 
-        let sigma = get_std_dev(filtered_center_moments.x, filtered_center_moments.y) * variance_scale;
+        let sigma = get_std_dev(statistics.moments.x, statistics.moments.y) * variance_scale;
 
         // clamp history mean to neighborhood AABB
-        let input_min = filtered_center_moments.x - sigma ;
-        let input_max = filtered_center_moments.x + sigma ;
+        let clamped_visibility = clamp(history.x, statistics.moments.x - sigma, statistics.moments.x + sigma);
+
+        // The bend is clamped to a ball about the neighbourhood's mean bend, its radius the same multiple of
+        // the bend's deviation as the visibility's box takes of its own. The bend is not a unit vector, so its
+        // variance has no cancellation to fight: a neighbourhood of one value has none, and clamps the history
+        // onto it.
+        let bend_variance = max(statistics.bend_square - dot(statistics.bend, statistics.bend), 0.0);
+        let bend_radius = sqrt(bend_variance) * variance_scale;
 
-        let clamped_history_m1 = clamp(history_moments.x, input_min, input_max);
+        let bend_offset = history.yzw - statistics.bend;
+        let bend_offset_length = length(bend_offset);
 
-        // Preserve history's variance under the mean clamp:
-        //   m2 = E[X²] = E[X]² + Var(X), so adjust m2 to track the clamped mean while
-        //   retaining the variance the temporal accumulator has built up.
-        let history_variance = max(history_moments.y - history_moments.x * history_moments.x, 0.0);
-        let clamped_history_m2 = clamped_history_m1 * clamped_history_m1 + history_variance;
+        // past the radius the offset's length is positive, so the division is safe where it is taken
+        let clamped_bend = select(
+            history.yzw,
+            statistics.bend + bend_offset * (bend_radius / bend_offset_length),
+            bend_offset_length > bend_radius
+        );
 
-        // Note: deliberately do NOT gate history_weight on history_variance.
+        // Note: deliberately do NOT gate history_weight on the neighbourhood's variance.
         // Mixing a clamped history mean with a current mean injects cross-term
         // variance (w·(1-w)·(Δmean)²) that compounds through the EMA whenever
         // history hasn't converged. Letting that drive history_confidence down
-        // collapses temporal accumulation. The AABB clamp already constrains
-        // ghosting; rely on it instead and trust history at a fixed rate.
+        // collapses temporal accumulation. The clamps already constrain
+        // ghosting; rely on them instead and trust history at a fixed rate.
         const HISTORY_WEIGHT_MAX = 0.95;
 
         let history_weight = HISTORY_WEIGHT_MAX * occlusion_confidence;
 
-        let resolved = mix(
-            current_moments,
-            vec2(clamped_history_m1, clamped_history_m2),
-            history_weight
-        );
+        // A bend means something only against the normal it was measured on. A texel on a crease lands on
+        // either side from frame to frame as the projection jitters, so its history holds the other surface's
+        // bend, which added to this surface's normal tilts the bent normal towards that surface: a line along
+        // every crease. The bend takes the history only for the share written on this texel's own surface.
+        // Visibility is not measured against the normal, and keeps all of it.
+        let surface_agreement = history_surface_agreement(prev_uv, decode_g_buffer_normal(encoded_normal.zw));
 
-        output = resolved;
+        resolved = vec4(
+            mix(current.x, clamped_visibility, history_weight),
+            mix(current.yzw, clamped_bend, history_weight * surface_agreement),
+        );
 
     }
-    
-    
-    return output;
+
+    // Halves round toward zero on the devices measured, so a blend stored as one stalls short of its target by
+    // up to a ULP over the history's 5% step. Rounded stochastically, it lands on its target in expectation.
+    let hash = pcg3d(vec3<u32>(vec2<u32>(screenST), settings.frame_index));
+    let noise = vec4<f32>(
+        hash_to_float01(hash.x),
+        hash_to_float01(hash.y),
+        hash_to_float01(hash.z),
+        hash_to_float01(pcg3d(hash).x),
+    );
+
+    // The bend rides on this frame's own shading normal, so the history adds nothing of the normal map's detail
+    // of the texels it was resampled from. An extreme bend can cancel the normal; the normal stands in then.
+    let bent = shading_normal + resolved.yzw;
+    let bent_length = length(bent);
+
+    var out: Output;
+
+    out.history = f16_round_stochastic(resolved, noise);
+    out.bent_normal = encode_g_buffer_normal(select(shading_normal, bent / bent_length, bent_length > 1e-4));
+
+    return out;
 }
     `,
     [
@@ -168,8 +270,28 @@ fn main(
         chunk_taa_velocity_confidence,
         chunk_texture_sample_catmullrom_hardware_5tap_uv,
         chunk_get_std_dev,
+        chunk_decode_g_buffer_normal,
+        chunk_encode_g_buffer_normal,
+        chunk_f16_round_stochastic,
+        chunk_pcg3d,
+        chunk_hash_to_float01,
     ]
 );
+
+/**
+ * Accumulates GTAO over time: visibility, and the bend that makes the bent normal.
+ *
+ * The bend takes the history only where the history was written on this texel's surface, by the face normals of
+ * `tNormalPrevious` — last frame's G-buffer normal — against this frame's.
+ *
+ * `tInput`, `tHistory` and the first target are `rgba16float`: visibility in `x`, and in `yzw` the world-space
+ * bend — the bent normal minus the shading normal. Each is clamped to this frame's 3x3 neighbourhood before it
+ * blends, visibility to a box and the bend to a ball. The second target is the bent normal itself,
+ * `normalize(shading normal + bend)`, octahedral in `rg16uint` as the G-buffer normal is, which is what lighting
+ * reads.
+ *
+ * @type {ImageShader}
+ */
 export const ao_reproject_shader = new ImageShader({
     descriptor: ShaderDescriptor.from({
         label: "AO Reproject",
@@ -177,10 +299,16 @@ export const ao_reproject_shader = new ImageShader({
         resources,
     }),
     depthStencil: DEPTH_STENCIL_FOREGROUND_ONLY,
-    targets: [{
-        format: "rg16float",
-        // Background is skipped, so it keeps the clear: moments of visibility 1 (not occluded), zero variance.
-        // This is also next frame's history, whose filtered fetch reaches across silhouettes.
-        clearValue: [1, 1],
-    }]
-})
+    targets: [
+        {
+            format: "rgba16float",
+            // Background is skipped, so it keeps the clear: not occluded, not bent.
+            // This is also next frame's history, whose filtered fetch reaches across silhouettes.
+            clearValue: [1, 0, 0, 0],
+        },
+        {
+            label: "Bent Normals",
+            format: "rg16uint",
+        },
+    ]
+})

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

@@ -1 +1 @@
-{"version":3,"file":"fragment_shader_gtao.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/gtao/fragment_shader_gtao.js"],"names":[],"mappings":"AA2VA,+CA6BG;4BAzWyB,6BAA6B"}
+{"version":3,"file":"fragment_shader_gtao.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/gtao/fragment_shader_gtao.js"],"names":[],"mappings":"AA6WA,+CAyBG;4BAxXyB,6BAA6B"}

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":"AA0YA,+DAkCG;4BA5ZyB,6BAA6B"}