@woosh/meep-engine 3.17.1 → 3.18.0

package/src/shade/renderer/particles/shaders/chunk_particle_emitter_world_sphere.js

@@ -1,23 +0,0 @@
-import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
-import { chunk_particle_emitter } from "../data/chunk_particle_emitter.js";
-
-/**
- * An emitter's bounds sphere in world space: the centre through the node's matrix, the radius
- * scaled by the largest axis scale the matrix carries.
- *
- * The axes are read as transformed unit vectors rather than as matrix columns — the same numbers,
- * in a form the WGSL emulator also evaluates. Shared by the tick pass (frustum culling of spawning)
- * and the AVBOIT occupancy pass (which depth slices the emitter's particles can reach), so both
- * test the same sphere.
- *
- * @type {CodeChunk}
- */
-export const chunk_particle_emitter_world_sphere = CodeChunk.from(/* language=wgsl */ `
-fn particle_emitter_world_sphere(em : ParticleEmitter, transform : mat4x4<f32>) -> vec4<f32> {
-    let center = (transform * vec4<f32>(em.bounds_center, 1.0)).xyz;
-    let sx = length((transform * vec4<f32>(1.0, 0.0, 0.0, 0.0)).xyz);
-    let sy = length((transform * vec4<f32>(0.0, 1.0, 0.0, 0.0)).xyz);
-    let sz = length((transform * vec4<f32>(0.0, 0.0, 1.0, 0.0)).xyz);
-    return vec4<f32>(center, em.bounds_radius * max(sx, max(sy, sz)));
-}
-`, [chunk_particle_emitter]);

package/src/shade/renderer/postprocess/ssr/reproject/shader_ffx_denoiser_reflections_reproject.js

@@ -1,457 +0,0 @@
-import { chunk_unpack_float16_4 } from "../../../shader/chunk/binary/chunk_unpack_float16_4.js";
-import { chunk_rgb_to_luminance } from "../../../shader/chunk/color/chunk_rgb_to_luminance.js";
-import { chunk_dot2 } from "../../../shader/chunk/math/chunk_dot2.js";
-import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
-
-/**
- * An unfinished translation of the FidelityFX reflection denoiser's reprojection pass.
- *
- * Not yet a shader, and not yet valid WGSL: the body still carries HLSL spellings the port has not
- * reached (`FfxFloat16x4`, `FfxInt32x2`, `FFX_GROUP_MEMORY_BARRIER`), and `main` is an empty stub
- * with no `@compute` and no `@workgroup_size`. It was a `ComputeShader` here until the workgroup
- * size started being read out of the WGSL, which is a question this source cannot answer; it stays
- * a chunk until someone finishes the port and writes the entry point.
- *
- * The bindings it will want are one texture, `tRadiance`.
- *
- * @see https://github.com/GPUOpen-LibrariesAndSDKs/FidelityFX-SDK/blob/1bbe66e7ea0d358e84af4471a90aa9c35b583de0/sdk/include/FidelityFX/gpu/denoiser/ffx_denoiser_reflections_reproject.h
- * @type {CodeChunk}
- */
-export const chunk_ffx_denoiser_reflections_reproject = CodeChunk.from(
-    //language=WGSL
-    `
-
-var<workgroup> g_ffx_dnsr_shared_0:array< array< u32, 16>, 16 >;
-var<workgroup> g_ffx_dnsr_shared_1:array< array< u32, 16>, 16 >;
-
-struct FFX_DNSR_Reflections_NeighborhoodSample {
-     radiance:vec3<f32>
-};
-
-fn FFX_DNSR_Reflections_LoadFromGroupSharedMemory( idx:vec2<i32> ) -> FFX_DNSR_Reflections_NeighborhoodSample{
-     let packed_radiance          = vec2(g_ffx_dnsr_shared_0[idx.y][idx.x], g_ffx_dnsr_shared_1[idx.y][idx.x]);
-    let unpacked_radiance        = unpack_float16_4(packed_radiance);
-
-    var neighborSample:FFX_DNSR_Reflections_NeighborhoodSample;
-    
-    neighborSample.radiance = unpacked_radiance.xyz;
-    
-    return neighborSample;
-}
-
-fn FFX_DNSR_Reflections_StoreInGroupSharedMemory(
-    group_thread_id:vec2<i32>,  
-    radiance:vec3<f32>
-) {
-    g_ffx_dnsr_shared_0[group_thread_id.y][group_thread_id.x]     = pack2x16float(radiance.xy);
-    g_ffx_dnsr_shared_1[group_thread_id.y][group_thread_id.x]     = pack2x16float(radiance.zz);
-}
-
-fn FFX_DNSR_Reflections_StoreInGroupSharedMemory(
-    group_thread_id:vec2<i32>,  
-    radiance_variance:vec4<f32>
-) {
-    g_ffx_dnsr_shared_0[group_thread_id.y][group_thread_id.x]     = pack2x16float(radiance_variance.xy);
-    g_ffx_dnsr_shared_1[group_thread_id.y][group_thread_id.x]     = pack2x16float(radiance_variance.zw);
-}
-
-fn FFX_DNSR_Reflections_InitializeGroupSharedMemory(
-    dispatch_thread_id:vec2<i32>,
-    group_thread_id:vec2<i32>,
-    screen_size:vec2<i32>
-) {
-      // Load 16x16 region into shared memory using 4 8x8 blocks.
-    const offset = array<vec2<i32>, 4>(
-        vec2(0, 0),
-        vec2(8, 0),
-        vec2(0, 8),
-        vec2(8, 8)
-    );
-
-    // Intermediate storage registers to cache the result of all loads
-    var radiance: array<vec3<f32>, 4>;
-
-    // Start in the upper left corner of the 16x16 region.
-    dispatch_thread_id -= 4;
-
-    // First store all loads in registers
-    for (var i = 0; i < 4; i++) {
-        radiance[i] = textureLoad(tRadiance, dispatch_thread_id + offset[i], 0).rgb;
-    }
-
-    // Then move all registers to FFX_GROUPSHARED memory
-    for (var j = 0; j < 4; j++) {
-        FFX_DNSR_Reflections_StoreInGroupSharedMemory(group_thread_id + offset[j], radiance[j]); // X
-    }
-}
-
-fn FFX_DNSR_Reflections_LoadFromGroupSharedMemoryRaw( idx: vec2<i32>) -> vec4<f32> {
-    let packed_radiance = vec2(g_ffx_dnsr_shared_0[idx.y][idx.x], g_ffx_dnsr_shared_1[idx.y][idx.x]);
-    return unpack_float16_4(packed_radiance);
-}
-
-fn FFX_DNSR_Reflections_GetLuminanceWeight( val : vec3<f32> ) -> f32{
-    let luma   = rgb_to_luminance(val.xyz);
-    let weight = max(exp(-luma * FFX_DNSR_REFLECTIONS_AVG_RADIANCE_LUMINANCE_WEIGHT), 1.0e-2);
-    return weight;
-}
-
-// TODO unnecessary, shouldbe removed
-fn FFX_DNSR_Reflections_GetSurfaceReprojection(
-    dispatch_thread_id:vec2<i32>,
-    uv:vec2<f32>,
-    motion_vector:vec2<f32>,
-) {
-    // Reflector position reprojection
-    let history_uv = uv + motion_vector;
-    return history_uv;
-}
-
-fn FFX_DNSR_Reflections_GetHitPositionReprojection(
-    dispatch_thread_id:vec2<i32>,
-    uv:vec2<f32>,
-    reflected_ray_length:f32
-) -> vec2<f32>{
-
-}
-    let  z             = FFX_DNSR_Reflections_LoadDepth(dispatch_thread_id);
-    var view_space_ray = FFX_DNSR_Reflections_ScreenSpaceToViewSpace(FfxFloat32x3(uv, z));
-
-    // We start out with reconstructing the ray length in view space.
-    // This includes the portion from the camera to the reflecting surface as well as the portion from the surface to the hit position.
-    let surface_depth = length(view_space_ray);
-    let ray_length    = surface_depth + reflected_ray_length;
-
-    // We then perform a parallax correction by shooting a ray
-    // of the same length "straight through" the reflecting surface
-    // and reprojecting the tip of that ray to the previous frame.
-    view_space_ray /= surface_depth; // == normalize(view_space_ray)
-    view_space_ray *= ray_length;
-    
-    // This is the "fake" hit position if we would follow the ray straight through the surface.
-    let world_hit_position =
-        FFX_DNSR_Reflections_ViewSpaceToWorldSpace(vec4(view_space_ray, 1.0)); 
-   
-    let prev_hit_position = FFX_DNSR_Reflections_WorldSpaceToScreenSpacePrevious(world_hit_position);
-    let history_uv        = prev_hit_position.xy;
-  
-    return history_uv;
-}
-
-fn FFX_DNSR_Reflections_GetDisocclusionFactor(
-    normal:vec3<f32>,
-    history_normal:vec3<f32>,
-    linear_depth:f32,
-    history_linear_depth:f32
-) -> f32{
-    let factor =  exp(-abs(1.0f - max(0.0f, dot(normal, history_normal))) * FFX_DNSR_REFLECTIONS_DISOCCLUSION_NORMAL_WEIGHT) 
-                        * exp(-abs(history_linear_depth - linear_depth) / linear_depth * FFX_DNSR_REFLECTIONS_DISOCCLUSION_DEPTH_WEIGHT);
-    return factor;
-}
-
-struct FFX_DNSR_Reflections_Moments {
-    mean:vec3<f32>;
-    variance: vec3<f32>;
-};
-
-fn FFX_DNSR_Reflections_EstimateLocalNeighborhoodInGroup( group_thread_id: vec2<i32> ) -> FFX_DNSR_Reflections_Moments{
-    var estimate: FFX_DNSR_Reflections_Moments;
-    
-    estimate.mean                 = vec3(0.0f, 0.0f, 0.0f);
-    estimate.variance             = vec3(0.0f, 0.0f, 0.0f);
-    
-    var accumulated_weight = 0.0f;
-    
-    for (var j = -FFX_DNSR_REFLECTIONS_LOCAL_NEIGHBORHOOD_RADIUS; j <= FFX_DNSR_REFLECTIONS_LOCAL_NEIGHBORHOOD_RADIUS; j++) {
-        for (var i = -FFX_DNSR_REFLECTIONS_LOCAL_NEIGHBORHOOD_RADIUS; i <= FFX_DNSR_REFLECTIONS_LOCAL_NEIGHBORHOOD_RADIUS; i++) {
-         
-            let new_idx  = group_thread_id + vec2(i, j);
-            let radiance = FFX_DNSR_Reflections_LoadFromGroupSharedMemory(new_idx).radiance;
-            let weight   = FFX_DNSR_Reflections_LocalNeighborhoodKernelWeight(f32(i)) * FFX_DNSR_Reflections_LocalNeighborhoodKernelWeight(f32(j));
-           
-            accumulated_weight  += weight;
-            estimate.mean       += radiance * weight;
-            estimate.variance   += radiance * radiance * weight;
-            
-        }
-    }
-    estimate.mean     /= accumulated_weight;
-    estimate.variance /= accumulated_weight;
-
-    estimate.variance = abs(estimate.variance - estimate.mean * estimate.mean);
-    return estimate;
-}
-
-fn FFX_DNSR_Reflections_PickReprojection(
-    dispatch_thread_id:vec2<i32>,  
-    group_thread_id:vec2<i32>,     
-    screen_size:vec2<u32>,         
-    roughness:f32,           
-    ray_length:f32,          
-    disocclusion_factor:ptr<function, f32>, 
-    reprojection_uv: ptr<function, vec2<f32>>,     
-    reprojection: ptr<function, vec3<f32>>
-) {
-
-    let local_neighborhood = FFX_DNSR_Reflections_EstimateLocalNeighborhoodInGroup(group_thread_id);
-
-    let uv     = vec2(dispatch_thread_id.x + 0.5, dispatch_thread_id.y + 0.5) / screen_size;
-    let normal = FFX_DNSR_Reflections_LoadWorldSpaceNormal(dispatch_thread_id);
-    var history_normal:vec3<f32>;
-    var history_linear_depth:f32;
-
-    {
-        let motion_vector             = FFX_DNSR_Reflections_LoadMotionVector(dispatch_thread_id);
-        let surface_reprojection_uv   = FFX_DNSR_Reflections_GetSurfaceReprojection(dispatch_thread_id, uv, motion_vector);
-        let hit_reprojection_uv       = FFX_DNSR_Reflections_GetHitPositionReprojection(dispatch_thread_id, uv, ray_length);
-        let surface_normal            = FFX_DNSR_Reflections_SampleWorldSpaceNormalHistory(surface_reprojection_uv);
-        let hit_normal                = FFX_DNSR_Reflections_SampleWorldSpaceNormalHistory(hit_reprojection_uv);
-        let surface_history           = FFX_DNSR_Reflections_SampleRadianceHistory(surface_reprojection_uv);
-        let hit_history               = FFX_DNSR_Reflections_SampleRadianceHistory(hit_reprojection_uv);
-        let hit_normal_similarity     = dot(normalize(hit_normal), normalize(normal));
-        let surface_normal_similarity = dot(normalize(surface_normal), normalize(normal));
-        let hit_roughness             = FFX_DNSR_Reflections_SampleRoughnessHistory(hit_reprojection_uv);
-        let surface_roughness         = FFX_DNSR_Reflections_SampleRoughnessHistory(surface_reprojection_uv);
-
-        // Choose reprojection uv based on similarity to the local neighborhood.
-        if (hit_normal_similarity > FFX_DNSR_REFLECTIONS_REPROJECTION_NORMAL_SIMILARITY_THRESHOLD  // Candidate for mirror reflection parallax
-            && hit_normal_similarity + 1.0e-3 > surface_normal_similarity                          //
-            && abs(hit_roughness - roughness) < abs(surface_roughness - roughness) + 1.0e-3        //
-        ) {
-            history_normal                      = hit_normal;
-           
-            let hit_history_depth        = FFX_DNSR_Reflections_SampleDepthHistory(hit_reprojection_uv);
-            let hit_history_linear_depth = FFX_DNSR_Reflections_GetLinearDepth(hit_reprojection_uv, hit_history_depth);
-           
-            history_linear_depth                = hit_history_linear_depth;
-            reprojection_uv                     = hit_reprojection_uv;
-            reprojection                        = hit_history;
-        } else {
-            // Reject surface reprojection based on simple distance
-            if (dot2(surface_history - local_neighborhood.mean) <
-                FFX_DNSR_REFLECTIONS_REPROJECT_SURFACE_DISCARD_VARIANCE_WEIGHT * length(local_neighborhood.variance)
-            ) {
-                
-                history_normal                          = surface_normal;
-                
-                let surface_history_depth        = FFX_DNSR_Reflections_SampleDepthHistory(surface_reprojection_uv);
-                let surface_history_linear_depth = FFX_DNSR_Reflections_GetLinearDepth(surface_reprojection_uv, surface_history_depth);
-                
-                history_linear_depth                    = surface_history_linear_depth;
-                reprojection_uv                         = surface_reprojection_uv;
-                reprojection                            = surface_history;
-                
-            } else {
-                disocclusion_factor = FfxFloat16(0.0f);
-                return;
-            }
-        }
-    }
-    
-    let depth        = FFX_DNSR_Reflections_LoadDepth(dispatch_thread_id);
-    let linear_depth = FFX_DNSR_Reflections_GetLinearDepth(uv, depth);
-    
-    // Determine disocclusion factor based on history
-    disocclusion_factor = FFX_DNSR_Reflections_GetDisocclusionFactor(normal, history_normal, linear_depth, history_linear_depth);
-
-    if (disocclusion_factor > FFX_DNSR_REFLECTIONS_DISOCCLUSION_THRESHOLD){
-        // Early out, good enough
-        return;
-    }
-    
-    // Try to find the closest sample in the vicinity if we are not convinced of a disocclusion
-    if (disocclusion_factor < FFX_DNSR_REFLECTIONS_DISOCCLUSION_THRESHOLD) {
-    
-        var    closest_uv    = reprojection_uv;
-        var    dudv          = 1.0 / vec2<f32>(screen_size);
-        
-        const search_radius = 1;
-        
-        for (FfxInt32 y = -search_radius; y <= search_radius; y++) {
-            for (FfxInt32 x = -search_radius; x <= search_radius; x++) {
-            
-                let uv                   = reprojection_uv + vec2(f32(x), f32(y)) * dudv;
-                let history_normal       = FFX_DNSR_Reflections_SampleWorldSpaceNormalHistory(uv);
-                let history_depth        = FFX_DNSR_Reflections_SampleDepthHistory(uv);
-                let history_linear_depth = FFX_DNSR_Reflections_GetLinearDepth(uv, history_depth);
-                let weight               = FFX_DNSR_Reflections_GetDisocclusionFactor(normal, history_normal, linear_depth, history_linear_depth);
-                
-                if (weight > disocclusion_factor) {
-                    disocclusion_factor = weight;
-                    closest_uv          = uv;
-                    reprojection_uv     = closest_uv;
-                }
-                
-            }
-        }
-        
-        reprojection = FFX_DNSR_Reflections_SampleRadianceHistory(reprojection_uv);
-        
-    }
-
-    // Rare slow path - triggered only on the edges.
-    // Try to get rid of potential leaks at bilinear interpolation level.
-    if (disocclusion_factor < FFX_DNSR_REFLECTIONS_DISOCCLUSION_THRESHOLD) {
-        // If we've got a discarded history, try to construct a better sample out of 2x2 interpolation neighborhood
-        // Helps quite a bit on the edges in movement
-        let   uvx                    = fract(vec2<f32>(screen_size.x) * reprojection_uv.x + 0.5);
-        let   uvy                    = fract(vec2<f32>(screen_size.y) * reprojection_uv.y + 0.5);
-        
-        let   reproject_texel_coords = vec2(screen_size * reprojection_uv - 0.5);
-        
-        FfxFloat16x3 reprojection00         = FFX_DNSR_Reflections_LoadRadianceHistory(reproject_texel_coords + vec2(0, 0));
-        FfxFloat16x3 reprojection10         = FFX_DNSR_Reflections_LoadRadianceHistory(reproject_texel_coords + vec2(1, 0));
-        FfxFloat16x3 reprojection01         = FFX_DNSR_Reflections_LoadRadianceHistory(reproject_texel_coords + vec2(0, 1));
-        FfxFloat16x3 reprojection11         = FFX_DNSR_Reflections_LoadRadianceHistory(reproject_texel_coords + vec2(1, 1));
-        
-        FfxFloat16x3 normal00               = FFX_DNSR_Reflections_LoadWorldSpaceNormalHistory(reproject_texel_coords + FfxInt32x2(0, 0));
-        FfxFloat16x3 normal10               = FFX_DNSR_Reflections_LoadWorldSpaceNormalHistory(reproject_texel_coords + FfxInt32x2(1, 0));
-        FfxFloat16x3 normal01               = FFX_DNSR_Reflections_LoadWorldSpaceNormalHistory(reproject_texel_coords + FfxInt32x2(0, 1));
-        FfxFloat16x3 normal11               = FFX_DNSR_Reflections_LoadWorldSpaceNormalHistory(reproject_texel_coords + FfxInt32x2(1, 1));
-        
-        FfxFloat32   depth00                = FFX_DNSR_Reflections_GetLinearDepth(reprojection_uv, FFX_DNSR_Reflections_LoadDepthHistory(reproject_texel_coords + FfxInt32x2(0, 0)));
-        FfxFloat32   depth10                = FFX_DNSR_Reflections_GetLinearDepth(reprojection_uv, FFX_DNSR_Reflections_LoadDepthHistory(reproject_texel_coords + FfxInt32x2(1, 0)));
-        FfxFloat32   depth01                = FFX_DNSR_Reflections_GetLinearDepth(reprojection_uv, FFX_DNSR_Reflections_LoadDepthHistory(reproject_texel_coords + FfxInt32x2(0, 1)));
-        FfxFloat32   depth11                = FFX_DNSR_Reflections_GetLinearDepth(reprojection_uv, FFX_DNSR_Reflections_LoadDepthHistory(reproject_texel_coords + FfxInt32x2(1, 1)));
-        
-        var w:vec4<f32>;
-        
-        // Initialize with occlusion weights
-        w.x = FFX_DNSR_Reflections_GetDisocclusionFactor(normal, normal00, linear_depth, depth00) > FFX_DNSR_REFLECTIONS_DISOCCLUSION_THRESHOLD / 2.0f ? FfxFloat16(1.0f) : FfxFloat16(0.0f);
-        w.y = FFX_DNSR_Reflections_GetDisocclusionFactor(normal, normal10, linear_depth, depth10) > FFX_DNSR_REFLECTIONS_DISOCCLUSION_THRESHOLD / 2.0f ? FfxFloat16(1.0f) : FfxFloat16(0.0f);
-        w.z = FFX_DNSR_Reflections_GetDisocclusionFactor(normal, normal01, linear_depth, depth01) > FFX_DNSR_REFLECTIONS_DISOCCLUSION_THRESHOLD / 2.0f ? FfxFloat16(1.0f) : FfxFloat16(0.0f);
-        w.w = FFX_DNSR_Reflections_GetDisocclusionFactor(normal, normal11, linear_depth, depth11) > FFX_DNSR_REFLECTIONS_DISOCCLUSION_THRESHOLD / 2.0f ? FfxFloat16(1.0f) : FfxFloat16(0.0f);
-       
-        // And then mix in bilinear weights
-        w.x           = w.x * (1.0 - uvx) * (1.0 - uvy);
-        w.y           = w.y * (uvx) * (1.0 - uvy);
-        w.z           = w.z * (1.0 - uvx) * (uvy);
-        w.w           = w.w * (uvx) * (uvy);
-        
-        let ws = max(w.x + w.y + w.z + w.w, 1.0e-3);
-        
-        // normalize
-        w /= ws;
-
-        var history_normal:vec3<f32>;
-        var history_linear_depth:f32;
-        
-        reprojection         = reprojection00 * w.x + reprojection10 * w.y + reprojection01 * w.z + reprojection11 * w.w;
-        history_linear_depth = depth00 * w.x + depth10 * w.y + depth01 * w.z + depth11 * w.w;
-        history_normal       = normal00 * w.x + normal10 * w.y + normal01 * w.z + normal11 * w.w;
-        disocclusion_factor  = FFX_DNSR_Reflections_GetDisocclusionFactor(normal, history_normal, linear_depth, history_linear_depth);
-    }
-    
-    disocclusion_factor = disocclusion_factor < FFX_DNSR_REFLECTIONS_DISOCCLUSION_THRESHOLD ? 0.0f : disocclusion_factor;
-}
-
-fn FFX_DNSR_Reflections_Reproject(
-
-FfxInt32x2 dispatch_thread_id,
-FfxInt32x2 group_thread_id,
-FfxUInt32x2 screen_size,
-FfxFloat32 temporal_stability_factor,
-FfxInt32 max_samples
-
-) {
-    FFX_DNSR_Reflections_InitializeGroupSharedMemory(dispatch_thread_id, group_thread_id, FfxInt32x2(screen_size));
-    FFX_GROUP_MEMORY_BARRIER;
-
-    group_thread_id += 4; // Center threads in FFX_GROUPSHARED memory
-
-    FfxFloat16       variance    = FfxFloat16(1.0f);
-    FfxFloat16       num_samples = FfxFloat16(0.0f);
-    FfxFloat16       roughness   = FFX_DNSR_Reflections_LoadRoughness(dispatch_thread_id);
-    FfxFloat32x3     normal      = FFX_DNSR_Reflections_LoadWorldSpaceNormal(dispatch_thread_id);
-    FfxFloat16x3     radiance    = FFX_DNSR_Reflections_LoadRadiance(dispatch_thread_id);
-    const FfxFloat16 ray_length  = FFX_DNSR_Reflections_LoadRayLength(dispatch_thread_id);
-
-    if (FFX_DNSR_Reflections_IsGlossyReflection(roughness)) {
-        FfxFloat16  disocclusion_factor;
-        FfxFloat32x2      reprojection_uv;
-        FfxFloat16x3 reprojection;
-        FFX_DNSR_Reflections_PickReprojection(/*in*/ dispatch_thread_id,
-                                              /* in */ group_thread_id,
-                                              /* in */ screen_size,
-                                              /* in */ roughness,
-                                              /* in */ ray_length,
-                                              /* out */ disocclusion_factor,
-                                              /* out */ reprojection_uv,
-                                              /* out */ reprojection);
-        if ( (reprojection_uv.x > 0.0f) && (reprojection_uv.y > 0.0f) && (reprojection_uv.x < 1.0f) && (reprojection_uv.y< 1.0f)) {
-            FfxFloat16 prev_variance = FFX_DNSR_Reflections_SampleVarianceHistory(reprojection_uv);
-            num_samples              = FFX_DNSR_Reflections_SampleNumSamplesHistory(reprojection_uv) * disocclusion_factor;
-            FfxFloat16 s_max_samples = FfxFloat16(max(8.0f, FfxFloat16(max_samples) * FFX_DNSR_REFLECTIONS_SAMPLES_FOR_ROUGHNESS(roughness)));
-            num_samples              = min(s_max_samples, num_samples + FfxFloat16(1.0f));
-            FfxFloat16 new_variance  = FFX_DNSR_Reflections_ComputeTemporalVariance(radiance.xyz, reprojection.xyz);
-            if (disocclusion_factor < FFX_DNSR_REFLECTIONS_DISOCCLUSION_THRESHOLD) {
-                FFX_DNSR_Reflections_StoreRadianceReprojected(dispatch_thread_id, FfxFloat16x3(0.0f, 0.0f, 0.0f));
-                FFX_DNSR_Reflections_StoreVariance(dispatch_thread_id, FfxFloat16(1.0f));
-                FFX_DNSR_Reflections_StoreNumSamples(dispatch_thread_id, FfxFloat16(1.0f));
-            } else {
-                FfxFloat16 variance_mix = ffxLerp(new_variance, prev_variance, FfxFloat16(1.0f / num_samples));
-                FFX_DNSR_Reflections_StoreRadianceReprojected(dispatch_thread_id, reprojection);
-                FFX_DNSR_Reflections_StoreVariance(dispatch_thread_id, variance_mix);
-                FFX_DNSR_Reflections_StoreNumSamples(dispatch_thread_id, num_samples);
-                // Mix in reprojection for radiance mip computation 
-                radiance = ffxLerp(radiance, reprojection, FfxFloat16(0.3f));
-            }
-        } else {
-            FFX_DNSR_Reflections_StoreRadianceReprojected(dispatch_thread_id, FfxFloat16x3(0.0f, 0.0f, 0.0f));
-            FFX_DNSR_Reflections_StoreVariance(dispatch_thread_id, FfxFloat16(1.0f));
-            FFX_DNSR_Reflections_StoreNumSamples(dispatch_thread_id, FfxFloat16(1.0f));
-        }
-    }
-    
-    // Downsample 8x8 -> 1 radiance using FFX_GROUPSHARED memory
-    // Initialize FFX_GROUPSHARED array for downsampling
-    FfxFloat16 weight = FFX_DNSR_Reflections_GetLuminanceWeight(radiance.xyz);
-    radiance.xyz *= weight;
-    if ( (dispatch_thread_id.x >= screen_size.x) || (dispatch_thread_id.y >= screen_size.y) || any(isinf(radiance)) || any(isnan(radiance)) || (weight > FfxFloat16(1.0e3))) {
-        radiance = vec3(0.0f, 0.0f, 0.0f);
-        weight   = 0.0f;
-    }
-
-    group_thread_id -= 4; // Center threads in FFX_GROUPSHARED memory
-
-    FFX_DNSR_Reflections_StoreInGroupSharedMemory(group_thread_id, FfxFloat16x4(radiance.xyz, weight));
-    FFX_GROUP_MEMORY_BARRIER;
-
-    for (FfxInt32 i = 2; i <= 8; i = i * 2) {
-    
-    }
-        FfxInt32 ox = group_thread_id.x * i;
-        FfxInt32 oy = group_thread_id.y * i;
-        FfxInt32 ix = group_thread_id.x * i + i / 2;
-        FfxInt32 iy = group_thread_id.y * i + i / 2;
-        
-        if (ix < 8 && iy < 8) {
-            FfxFloat16x4 rad_weight00 = FFX_DNSR_Reflections_LoadFromGroupSharedMemoryRaw(FfxInt32x2(ox, oy));
-            FfxFloat16x4 rad_weight10 = FFX_DNSR_Reflections_LoadFromGroupSharedMemoryRaw(FfxInt32x2(ox, iy));
-            FfxFloat16x4 rad_weight01 = FFX_DNSR_Reflections_LoadFromGroupSharedMemoryRaw(FfxInt32x2(ix, oy));
-            FfxFloat16x4 rad_weight11 = FFX_DNSR_Reflections_LoadFromGroupSharedMemoryRaw(FfxInt32x2(ix, iy));
-            FfxFloat16x4 sum          = rad_weight00 + rad_weight01 + rad_weight10 + rad_weight11;
-            FFX_DNSR_Reflections_StoreInGroupSharedMemory(FfxInt32x2(ox, oy), sum);
-        }
-        
-        FFX_GROUP_MEMORY_BARRIER;
-    }
-
-    if ((group_thread_id.x == 0) && (group_thread_id.y == 0)) {
-        FfxFloat16x4    sum          = FFX_DNSR_Reflections_LoadFromGroupSharedMemoryRaw(FfxInt32x2(0, 0));
-        FfxFloat16      weight_acc   = max(sum.w, FfxFloat16(1.0e-3));
-        FfxFloat32x3    radiance_avg = sum.xyz / weight_acc;
-        FFX_DNSR_Reflections_StoreAverageRadiance(dispatch_thread_id.xy / 8, FfxFloat16x3(radiance_avg));
-    }
-    
-}
-
-fn main(){
-
-}
-    `, [
-        chunk_unpack_float16_4,
-        chunk_rgb_to_luminance,
-        chunk_dot2,
-    ]
-);