disable hit distance antilag for now

TODO: Re-enable after NRD upgrade

Author: PixelDust22

crates/render/Cargo.toml

@@ -33,7 +33,7 @@ bytemuck = "1.13"
 
 # Processor dependencies
 shaderc = { version = "0.8", optional = true }
-playout = { path = "../../../playout", optional = true }
+playout = { git = "https://github.com/dust-engine/playout", optional = true }
 playout_macro = { path = "../../../playout/macro" }
 
 [features]

crates/render/src/noise.rs

@@ -43,7 +43,7 @@ impl BlueNoise {
             &self.unitvec3,
             &self.unitvec3_cosine,
         ];
-        for (i, (desc, handle)) in descriptors.iter_mut().zip(handles.iter()).enumerate() {
+        for (_i, (desc, handle)) in descriptors.iter_mut().zip(handles.iter()).enumerate() {
             let Some(img) = image_arrays.get(*handle) else {
                 return None;
             };

crates/render/src/pipeline/auto_exposure.rs

@@ -5,7 +5,7 @@ use bevy_ecs::{
     system::{lifetimeless::SRes, Resource, SystemParamItem},
     world::{FromWorld, Mut, World},
 };
-use rhyolite::{future::run, descriptor::DescriptorSetLayout};
+use rhyolite::{descriptor::DescriptorSetLayout, future::run};
 
 use rhyolite::BufferExt;
 use rhyolite::{

crates/render/src/pipeline/nrd.rs

@@ -133,7 +133,7 @@ impl NRDPipeline {
                 descriptor_type: vk::DescriptorType::SAMPLER,
                 descriptor_count: 1,
                 stage_flags: vk::ShaderStageFlags::COMPUTE,
-                p_immutable_samplers: sampler.raw()
+                p_immutable_samplers: sampler.raw(),
             })
             .collect();
 
@@ -769,9 +769,13 @@ impl Default for ReblurSettings {
         Self {
             common_settings: Default::default(),
             reblur_settings: nrd_sys::ReblurSettings {
+                antilag_hit_distance_settings: AntilagHitDistanceSettings {
+                    enable: false,
+                    ..Default::default()
+                },
                 antilag_intensity_settings: AntilagIntensitySettings {
                     sensitivity_to_darkness: 0.1,
-                    enable: true,
+                    enable: false,
                     ..Default::default()
                 },
                 ..Default::default()

crates/render/src/pipeline/standard.rs

@@ -18,8 +18,8 @@ use rand::Rng;
 use rhyolite::debug::DebugObject;
 use rhyolite::descriptor::DescriptorSetLayout;
 use rhyolite::future::{
-    run, use_shared_image, use_shared_resource_flipflop, use_shared_state, use_state,
-    GPUCommandFutureExt, SharedDeviceState, SharedDeviceStateHostContainer,
+    run, use_shared_image, use_shared_resource_flipflop, use_shared_state, GPUCommandFutureExt,
+    SharedDeviceState, SharedDeviceStateHostContainer,
 };
 use rhyolite::{
     accel_struct::AccelerationStructure,
@@ -74,7 +74,8 @@ impl RayTracingPipeline for StandardPipeline {
         }
     }
     fn pipeline_layout(device: &Arc<rhyolite::Device>) -> Arc<rhyolite::PipelineLayout> {
-        let set0 = playout_macro::layout!("../../../../../assets/shaders/headers/layout.playout", 0);
+        let set0 =
+            playout_macro::layout!("../../../../../assets/shaders/headers/layout.playout", 0);
         let set0 = DescriptorSetLayout::new(device.clone(), &set0, Default::default()).unwrap();
         Arc::new(
             rhyolite::PipelineLayout::new(
@@ -123,13 +124,16 @@ impl RayTracingPipeline for StandardPipeline {
                     asset_server.load("shaders/final_gather/ambient_occlusion.rgen"),
                     vk::ShaderStageFlags::RAYGEN_KHR,
                 ),
-                vec![SpecializedShader::for_shader(
-                    asset_server.load("shaders/final_gather/ambient_occlusion.rmiss"),
-                    vk::ShaderStageFlags::MISS_KHR,
-                ),SpecializedShader::for_shader(
-                    asset_server.load("shaders/final_gather/nee.rmiss"),
-                    vk::ShaderStageFlags::MISS_KHR,
-                )],
+                vec![
+                    SpecializedShader::for_shader(
+                        asset_server.load("shaders/final_gather/ambient_occlusion.rmiss"),
+                        vk::ShaderStageFlags::MISS_KHR,
+                    ),
+                    SpecializedShader::for_shader(
+                        asset_server.load("shaders/final_gather/nee.rmiss"),
+                        vk::ShaderStageFlags::MISS_KHR,
+                    ),
+                ],
                 Vec::new(),
             ),
             final_gather_ray_pipeline: RayTracingPipelineManager::new(
@@ -152,13 +156,16 @@ impl RayTracingPipeline for StandardPipeline {
                     asset_server.load("shaders/surfel/surfel.rgen"),
                     vk::ShaderStageFlags::RAYGEN_KHR,
                 ),
-                vec![SpecializedShader::for_shader(
-                    asset_server.load("shaders/surfel/surfel.rmiss"),
-                    vk::ShaderStageFlags::MISS_KHR,
-                ),SpecializedShader::for_shader(
-                    asset_server.load("shaders/surfel/nee.rmiss"),
-                    vk::ShaderStageFlags::MISS_KHR,
-                )],
+                vec![
+                    SpecializedShader::for_shader(
+                        asset_server.load("shaders/surfel/surfel.rmiss"),
+                        vk::ShaderStageFlags::MISS_KHR,
+                    ),
+                    SpecializedShader::for_shader(
+                        asset_server.load("shaders/surfel/nee.rmiss"),
+                        vk::ShaderStageFlags::MISS_KHR,
+                    ),
+                ],
                 Vec::new(),
             ),
             pipeline_sbt_manager,
@@ -170,7 +177,8 @@ impl RayTracingPipeline for StandardPipeline {
         params: &mut SystemParamItem<M::ShaderParameterParams>,
     ) -> crate::sbt::SbtIndex {
         self.primary_ray_pipeline.material_instance_added::<M>();
-        self.ambient_occlusion_ray_pipeline.material_instance_added::<M>();
+        self.ambient_occlusion_ray_pipeline
+            .material_instance_added::<M>();
         self.final_gather_ray_pipeline
             .material_instance_added::<M>();
         self.surfel_ray_pipeline.material_instance_added::<M>();
@@ -337,7 +345,7 @@ impl StandardPipeline {
             if !surfel_pool_buffer.inner().reused() {
                 fill_buffer(&mut surfel_pool_buffer, u32::MAX).await;
             }
-            let mut spatial_hash_buffer = use_shared_state(
+            let spatial_hash_buffer = use_shared_state(
                 using!(),
                 |_| {
                     allocator.create_device_buffer_uninit(

crates/render/src/pipeline/tone_mapping.rs

@@ -7,19 +7,18 @@ use bevy_ecs::{
 };
 use rhyolite::{
     ash::vk,
-    descriptor::{DescriptorPool, DescriptorSetWrite, DescriptorSetLayout},
+    descriptor::{DescriptorPool, DescriptorSetLayout, DescriptorSetWrite},
     future::{
         run, use_per_frame_state, DisposeContainer, GPUCommandFuture, RenderData, RenderImage,
         RenderRes,
     },
-    utils::{retainer::Retainer, format::{ColorSpacePrimaries, ColorSpaceTransferFunction}},
+    utils::{
+        format::{ColorSpacePrimaries, ColorSpaceTransferFunction},
+        retainer::Retainer,
+    },
     BufferExt, BufferLike, ComputePipeline, HasDevice, ImageViewExt, ImageViewLike, PipelineLayout,
 };
-use rhyolite::{
-    future::Disposable,
-    macros::commands,
-    utils::format::ColorSpace,
-};
+use rhyolite::{future::Disposable, macros::commands, utils::format::ColorSpace};
 use rhyolite_bevy::Queues;
 
 use crate::{CachedPipeline, PipelineCache, ShaderModule, SpecializedShader};
@@ -41,7 +40,6 @@ impl FromWorld for ToneMappingPipeline {
         let num_frame_in_flight = queues.num_frame_in_flight();
         let device = queues.device().clone();
 
-
         let set0 = playout_macro::layout!("../../../../../assets/shaders/tone_map.playout", 0);
         let set0 = DescriptorSetLayout::new(device.clone(), &set0, Default::default()).unwrap();
         let layout = Arc::new(
@@ -64,7 +62,7 @@ impl FromWorld for ToneMappingPipeline {
             pipeline: None,
             display_color_space_transfer_fn: ColorSpaceTransferFunction::LINEAR,
             desc_pool: Retainer::new(desc_pool),
-            scene_color_space: ColorSpacePrimaries::ACES_AP1
+            scene_color_space: ColorSpacePrimaries::ACES_AP1,
         }
     }
 }
@@ -95,31 +93,29 @@ impl ToneMappingPipeline {
             self.pipeline = None;
             self.display_color_space_transfer_fn = output_color_space.transfer_function;
         }
-        let pipeline = self
-            .pipeline
-            .get_or_insert_with(|| {
-                let mat = self
-                    .scene_color_space
-                    .to_color_space(&output_color_space.primaries);
-                let transfer_function = output_color_space.transfer_function as u32;
+        let pipeline = self.pipeline.get_or_insert_with(|| {
+            let mat = self
+                .scene_color_space
+                .to_color_space(&output_color_space.primaries);
+            let transfer_function = output_color_space.transfer_function as u32;
 
-                let shader = asset_server.load("shaders/tone_map.comp");
-                pipeline_cache.add_compute_pipeline(
-                    self.layout.clone(),
-                    SpecializedShader::for_shader(shader, vk::ShaderStageFlags::COMPUTE)
-                        .with_const(0, transfer_function)
-                        .with_const(1, mat.x_axis.x)
-                        .with_const(2, mat.x_axis.y)
-                        .with_const(3, mat.x_axis.z)
-                        .with_const(4, mat.y_axis.x)
-                        .with_const(5, mat.y_axis.y)
-                        .with_const(6, mat.y_axis.z)
-                        .with_const(7, mat.z_axis.x)
-                        .with_const(8, mat.z_axis.y)
-                        .with_const(9, mat.z_axis.z)
-                        .into(),
-                )
-            });
+            let shader = asset_server.load("shaders/tone_map.comp");
+            pipeline_cache.add_compute_pipeline(
+                self.layout.clone(),
+                SpecializedShader::for_shader(shader, vk::ShaderStageFlags::COMPUTE)
+                    .with_const(0, transfer_function)
+                    .with_const(1, mat.x_axis.x)
+                    .with_const(2, mat.x_axis.y)
+                    .with_const(3, mat.x_axis.z)
+                    .with_const(4, mat.y_axis.x)
+                    .with_const(5, mat.y_axis.y)
+                    .with_const(6, mat.y_axis.z)
+                    .with_const(7, mat.z_axis.x)
+                    .with_const(8, mat.z_axis.y)
+                    .with_const(9, mat.z_axis.z)
+                    .into(),
+            )
+        });
         let desc_pool = &mut self.desc_pool;
         commands! { move
             let Some(pipeline) = pipeline_cache.retrieve(pipeline, shader_assets) else {

crates/render/src/shader/glsl.rs

@@ -1,4 +1,4 @@
-use std::{collections::HashMap, path::{Path, PathBuf}};
+use std::{collections::HashMap, path::PathBuf};
 
 use bevy_app::Plugin;
 use bevy_asset::{
@@ -99,11 +99,18 @@ impl AssetLoader for GlslShadercCompiler {
                         continue;
                     }
                     let path = match ty {
-                        shaderc::IncludeType::Relative => ctx.path().parent().unwrap().join(&filename).join(included_filename),
+                        shaderc::IncludeType::Relative => ctx
+                            .path()
+                            .parent()
+                            .unwrap()
+                            .join(&filename)
+                            .join(included_filename),
                         shaderc::IncludeType::Standard => included_filename.into(),
                     };
                     let normalized_path = normalize_path(&path);
-                    let inc = ctx.load_direct(AssetPath::from_path(normalized_path)).await?;
+                    let inc = ctx
+                        .load_direct(AssetPath::from_path(normalized_path))
+                        .await?;
                     let source: &GlslShaderSource = inc.get().unwrap();
                     pending_sources.push((included_filename.to_string(), source.source.clone()));
                 }
@@ -303,4 +310,3 @@ impl AssetLoader for PlayoutGlslLoader {
         &["playout"]
     }
 }
-

crates/rhyolite/src/descriptor/layout.rs

@@ -1,6 +1,6 @@
 use crate::Device;
 use ash::{prelude::VkResult, vk};
-use std::{sync::Arc, collections::BTreeMap};
+use std::{collections::BTreeMap, sync::Arc};
 
 pub struct DescriptorSetLayout {
     device: Arc<Device>,
@@ -58,11 +58,10 @@ impl DescriptorSetLayout {
             }
         }
 
-
         Ok(Self {
             device,
             raw,
-            desc_types: desc_types.into_iter().collect()
+            desc_types: desc_types.into_iter().collect(),
         })
     }
     pub unsafe fn raw(&self) -> vk::DescriptorSetLayout {

crates/rhyolite/src/shader.rs

@@ -1,13 +1,13 @@
 use ash::prelude::VkResult;
 use ash::vk;
-use smallvec::SmallVec;
+
 use std::ffi::CStr;
 use std::fmt::Debug;
 use std::ops::Deref;
-use std::{collections::HashMap, sync::Arc};
+use std::sync::Arc;
 
 use crate::descriptor::DescriptorSetLayout;
-use crate::sampler::Sampler;
+
 use crate::{Device, HasDevice};
 
 pub struct SpirvShader<T: Deref<Target = [u32]>> {
@@ -74,7 +74,6 @@ impl Drop for ShaderModule {
     }
 }
 
-
 #[derive(Clone)]
 pub struct ShaderModuleEntryPoint {
     pub stage: vk::ShaderStageFlags,