- add create_tlas_with_heap function

Author: GBDixonAlex

plugins/ecs_examples/src/raytraced_shadows.rs

@@ -193,8 +193,6 @@ pub fn setup_raytraced_shadows_scene(
             tlas: None
         }
     );
-
-    // 
 
     Ok(())
 }
@@ -225,10 +223,12 @@ pub fn setup_raytraced_shadows_tlas(
                         blas: &blas.blas
                     }
                 );
-                let tlas = device.create_raytracing_tlas(&gfx::RaytracingTLASInfo {
+                let tlas = device.create_raytracing_tlas_with_heap(&gfx::RaytracingTLASInfo {
                     instances: &instances,
-                    build_flags: gfx::AccelerationStructureBuildFlags::PREFER_FAST_TRACE
-                })?;
+                    build_flags: gfx::AccelerationStructureBuildFlags::PREFER_FAST_TRACE,
+                    },
+                    &mut pmfx.shader_heap
+                )?;
 
                 t.tlas = Some(tlas);
             }
@@ -253,7 +253,7 @@ pub fn animate_lights (
 }
 
 // TODO_RT
-// create tlas with heap?
+
 // update tlas
 // mesh vertex count
 // fix: Ignoring InitialState D3D12_RESOURCE_STATE_COPY_DEST. Buffers are effectively created in state D3D12_RESOURCE_STATE_COMMON.
@@ -276,12 +276,10 @@ pub fn render_meshes_raytraced(
     if let Ok(camera) = camera {
         for t in &tlas_query {            
             if let Some(tlas) = &t.tlas {
-
                 // set pipeline
                 let raytracing_pipeline = pmfx.get_raytracing_pipeline(&pass.pass_pipline)?;
                 pass.cmd_buf.set_raytracing_pipeline(&raytracing_pipeline.pipeline);
 
-                
                 let slot = raytracing_pipeline.pipeline.get_pipeline_slot(0, 0, gfx::DescriptorType::PushConstants);
                 if let Some(slot) = slot {
                     // camera constants
@@ -300,7 +298,7 @@ pub fn render_meshes_raytraced(
                 // bind tlas on t1 (device heap)
                 let srv0 =  tlas.get_srv_index().expect("expect tlas to have an srv");
                 if let Some(t0) = raytracing_pipeline.pipeline.get_pipeline_slot(69, 0, gfx::DescriptorType::ShaderResource) {
-                    pass.cmd_buf.set_binding(&raytracing_pipeline.pipeline, device.get_shader_heap(), t0.index, srv0);
+                    pass.cmd_buf.set_binding(&raytracing_pipeline.pipeline, &pmfx.shader_heap, t0.index, srv0);
                 }
 
                 // dispatch

src/gfx.rs

@@ -1260,14 +1260,12 @@ pub trait Device: 'static + Send + Sync + Sized + Any + Clone {
         &mut self,
         info: &RaytracingBLASInfo<Self>
     ) -> Result<Self::RaytracingBLAS, Error>;
-    /*
     /// Create a top level acceleration structure from array of `RaytracingInstanceInfo` with specificed heap
     fn create_raytracing_tlas_with_heap(
         &mut self,
         info: &RaytracingTLASInfo<Self>,
         heap: &mut Self::Heap
     ) -> Result<Self::RaytracingTLAS, Error>;
-    */
     /// Create a top level acceleration structure from array of `RaytracingInstanceInfo`
     fn create_raytracing_tlas(
         &mut self,

src/gfx/d3d12.rs

@@ -3434,11 +3434,11 @@ impl super::Device for Device {
         }
     }
 
-    fn create_raytracing_tlas(
+    fn create_raytracing_tlas_with_heap(
         &mut self,
-        info: &RaytracingTLASInfo<Self>
+        info: &RaytracingTLASInfo<Self>,
+        heap: &mut Heap
     ) -> result::Result<RaytracingTLAS, super::Error> {
-
         // pack 24: 8 bits
         let pack_24_8 = |a, b| {
             (a & 0x00ffffff) | ((b & 0x000000ff) << 24)
@@ -3458,15 +3458,17 @@ impl super::Device for Device {
 
         // create upload buffer for instance descs
         let stride = std::mem::size_of::<D3D12_RAYTRACING_INSTANCE_DESC>();
-        let instance_buffer = self.create_buffer(&BufferInfo {
+        let instance_buffer = self.create_buffer_with_heap(&BufferInfo {
             usage: super::BufferUsage::UPLOAD,
             cpu_access: super::CpuAccessFlags::NONE,
             format: super::Format::Unknown,
             stride: std::mem::size_of::<D3D12_RAYTRACING_INSTANCE_DESC>(),
             num_elements: num_instances,
             initial_state: super::ResourceState::GenericRead
-        }, Some(instance_descs.as_slice()))
-        .expect(format!("hotline_rs::gfx::d3d12: failed to create a scratch buffer for raytracing blas of size {}", stride * num_instances).as_str());
+            }, 
+            Some(instance_descs.as_slice()),
+            heap
+        ).expect(format!("hotline_rs::gfx::d3d12: failed to create a scratch buffer for raytracing blas of size {}", stride * num_instances).as_str());
 
         // create acceleration structure inputs
         let inputs = D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_INPUTS {
@@ -3489,25 +3491,31 @@ impl super::Device for Device {
         };
 
         // UAV scratch buffer
-        let scratch_buffer = self.create_buffer::<u8>(&BufferInfo {
+        let scratch_buffer = self.create_buffer_with_heap::<u8>(&BufferInfo {
             usage: super::BufferUsage::UNORDERED_ACCESS | super::BufferUsage::BUFFER_ONLY,
             cpu_access: super::CpuAccessFlags::NONE,
             format: super::Format::Unknown,
             stride: prebuild_info.ScratchDataSizeInBytes as usize,
             num_elements: 1,
             initial_state: super::ResourceState::UnorderedAccess
-        }, None)
+            },
+            None,
+            heap
+        )
         .expect(format!("hotline_rs::gfx::d3d12: failed to create a scratch buffer for raytracing tlas of size {}", prebuild_info.ScratchDataSizeInBytes).as_str());
 
         // UAV buffer the tlas
-        let tlas_buffer = self.create_buffer::<u8>(&BufferInfo {
+        let tlas_buffer = self.create_buffer_with_heap::<u8>(&BufferInfo {
             usage: super::BufferUsage::UNORDERED_ACCESS | super::BufferUsage::ACCELERATION_STRUCTURE,
             cpu_access: super::CpuAccessFlags::NONE,
             format: super::Format::Unknown,
             stride: prebuild_info.ResultDataMaxSizeInBytes as usize,
             num_elements: 1,
             initial_state: super::ResourceState::AccelerationStructure
-        }, None).expect(format!("hotline_rs::gfx::d3d12: failed to create a tlas of size {}", prebuild_info.ScratchDataSizeInBytes).as_str());
+            }, 
+            None,
+            heap
+        ).expect(format!("hotline_rs::gfx::d3d12: failed to create a tlas of size {}", prebuild_info.ScratchDataSizeInBytes).as_str());
 
         // create tlas desc
         let tlas_desc = D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_DESC {
@@ -3535,6 +3543,16 @@ impl super::Device for Device {
         })
     }
 
+    fn create_raytracing_tlas(
+        &mut self,
+        info: &RaytracingTLASInfo<Self>
+    ) -> result::Result<RaytracingTLAS, super::Error> {
+        let mut heap = std::mem::take(&mut self.shader_heap).unwrap();
+        let result = self.create_raytracing_tlas_with_heap(info, &mut heap);
+        self.shader_heap = Some(heap);
+        result
+    }
+
     fn create_indirect_render_command<T: Sized>(
         &mut self, 
         arguments: Vec<super::IndirectArgument>,

src/plugin.rs

@@ -98,21 +98,11 @@ impl reloader::ReloadResponder for PluginReloadResponder {
                 .output()
                 .expect("hotline::hot_lib:: hot lib failed to build!")
         }
-        else {
-            /*
-            let hotline_path = super::get_data_path("../..");
-            let pmbuild = super::get_data_path("../../hotline-data/pmbuild.cmd");
-            std::process::Command::new(pmbuild)
-                .current_dir(hotline_path)
-                .arg("win32-debug")
-                .arg("-plugins")
-                .output()
-                .expect("hotline::hot_lib:: hot pmfx failed to compile!")
-            */
-            
+        else {            
             Command::new("cargo")
                 .current_dir(&self.path)
                 .arg("build")
+                .env("CARGO_TERM_COLOR", "always")
                 .arg("-p")
                 .arg(&self.name)
                 .output()

todo.txt

@@ -44,6 +44,8 @@
 // build
 
 // DONE:
+// x create tlas with heap?
+// x raytraced triangle
 // x test shader compilation with mac changes
 // x update pmbuild
 // x omni shadow map