- raytracing scene example working with some traced output, some d3d warnings to fix and features still to add

Author: GBDixonAlex

plugins/ecs_examples/src/draw_cbuffer_instanced.rs

@@ -53,7 +53,8 @@ pub fn setup_draw_cbuffer_instanced(
     for mesh in meshes {
         let mut heap = device.create_heap(&gfx::HeapInfo {
             heap_type: gfx::HeapType::Shader,
-            num_descriptors: instance_count as usize
+            num_descriptors: instance_count as usize,
+            debug_name: Some("instance_buffer_heap".to_string())
         });
         let parent = commands.spawn(InstanceBatch {
             mesh: MeshComponent(mesh.clone()),

plugins/ecs_examples/src/dynamic_cubemap.rs

@@ -113,14 +113,11 @@ pub fn render_orbit_meshes(
 
     view.cmd_buf.set_heap(pipeline, &pmfx.shader_heap);
 
-    let mut mip = 0;
     for (world_matrix, mesh) in &mesh_draw_query {
         view.cmd_buf.push_render_constants(1, 12, 0, &world_matrix.0);
         view.cmd_buf.set_index_buffer(&mesh.0.ib);
         view.cmd_buf.set_vertex_buffer(&mesh.0.vb, 0);
         view.cmd_buf.draw_indexed_instanced(mesh.0.num_indices, 1, 0, 0, 0);
-
-        mip += 1;
     }
 
     Ok(())

plugins/ecs_examples/src/raytraced_shadows.rs

@@ -1,6 +1,8 @@
 // currently windows only because here we need a concrete gfx and os implementation
 #![cfg(target_os = "windows")]
 
+use hotline_rs::gfx::RaytracingTLAS;
+
 ///
 /// Raytraced Shadows
 /// 
@@ -43,9 +45,9 @@ pub fn blas_from_mesh(device: &mut ResMut<DeviceRes>, mesh: &pmfx::Mesh<gfx_plat
                     index_buffer: &mesh.ib,
                     vertex_buffer: &mesh.vb,
                     transform3x4: None,
-                    index_count: 3,
+                    index_count: mesh.num_indices as usize,
                     index_format: gfx::Format::R16u,
-                    vertex_count: 3,
+                    vertex_count: mesh.num_indices as usize,
                     vertex_format: gfx::Format::RGB32f,
                     vertex_stride: 56
                 }),
@@ -186,11 +188,11 @@ pub fn setup_raytraced_shadows_scene(
         blas_from_mesh(&mut device, &cube_mesh)?
     ));
 
-    commands.spawn((
+    commands.spawn(
         TLAS {
             tlas: None
         }
-    ));
+    );
 
     // 
 
@@ -250,8 +252,16 @@ pub fn animate_lights (
     Ok(())
 }
 
+// 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.
+// colors from rust compile output?
+
 #[export_compute_fn]
-pub fn render_meshes_raytraced(    
+pub fn render_meshes_raytraced(
+    device: ResMut<DeviceRes>,
     pmfx: &Res<PmfxRes>,
     pass: &pmfx::ComputePass<gfx_platform::Device>,
     tlas_query: Query<&TLAS>
@@ -262,35 +272,39 @@ pub fn render_meshes_raytraced(
     let output_size = pmfx.get_texture_2d_size("staging_output").expect("expected staging_output");
     let output_tex = pmfx.get_texture("staging_output").expect("expected staging_output");
 
-    let cam = pmfx.get_camera_constants("main_camera");
-    if let Ok(cam) = cam {
+    let camera = pmfx.get_camera_constants("main_camera");
+    if let Ok(camera) = camera {
         for t in &tlas_query {            
             if let Some(tlas) = &t.tlas {
 
                 // set pipeline
-                let rt_pipeline = pmfx.get_raytracing_pipeline(&pass.pass_pipline)?;
-                pass.cmd_buf.set_raytracing_pipeline(&rt_pipeline.pipeline);
-
-                // camera constants TODO:
-
-                // resource use constants
-                let using_slot = rt_pipeline.pipeline.get_pipeline_slot(0, 1, gfx::DescriptorType::PushConstants);
-                if let Some(slot) = using_slot {
-                    for i in 0..pass.use_indices.len() {
-                        let num_constants = gfx::num_32bit_constants(&pass.use_indices[i]);
-                        pass.cmd_buf.push_compute_constants(
-                            slot.index, 
-                            num_constants, 
-                            i as u32 * num_constants, 
-                            gfx::as_u8_slice(&pass.use_indices[i])
-                        );
-                    }
+                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
+                    let inv = camera.view_projection_matrix.inverse();
+                    pass.cmd_buf.push_compute_constants(slot.index, 16, 0, &inv);
+
+                    // output uav
+                    pass.cmd_buf.push_compute_constants(slot.index, 4, 16, gfx::as_u8_slice(&pass.use_indices[0].index));
                 }
 
-                pass.cmd_buf.set_heap(&rt_pipeline.pipeline, &pmfx.shader_heap);
+                // bind shader heap
+                if let Some(u0) = raytracing_pipeline.pipeline.get_pipeline_slot(0, 0, gfx::DescriptorType::UnorderedAccess) {
+                    pass.cmd_buf.set_binding(&raytracing_pipeline.pipeline, &pmfx.shader_heap, u0.index, 0);
+                }
+
+                // 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);
+                }
 
                 // dispatch
-                pass.cmd_buf.dispatch_rays(&rt_pipeline.sbt, gfx::Size3 {
+                pass.cmd_buf.dispatch_rays(&raytracing_pipeline.sbt, gfx::Size3 {
                     x: output_size.0 as u32,
                     y: output_size.1 as u32,
                     z: 1

plugins/export_macros/src/lib.rs

@@ -132,7 +132,6 @@ pub fn export_update_fn(attr: TokenStream, item: TokenStream) -> TokenStream {
             {} ({}).unwrap();
         }}).into_configs().{}
     }}", parsed.name, moves, parsed.name, pass, order);
-    let export_tokens : TokenStream = export_fn.parse().unwrap();
 
     let input = parse_macro_input!(item as ItemFn);
     let export_tokens : TokenStream = export_fn.parse().unwrap();

shaders/ecs.hlsl

@@ -137,8 +137,8 @@ StructuredBuffer<spot_light_data> spot_lights[] : register(t0, space4);
 StructuredBuffer<directional_light_data> directional_lights[] : register(t0, space5);
 StructuredBuffer<float4x4> shadow_matrices[] : register(t0, space6);
 
-// 
-RaytracingAccelerationStructure scene_tlas : register(t1, space0);
+// TODO_RT
+RaytracingAccelerationStructure scene_tlas : register(t69, space0);
 
 // textures 
 Texture2D textures[] : register(t0, space7);

shaders/material.hlsl

@@ -297,69 +297,53 @@ bool is_occluded(float3 origin, float3 direction, float tMin, float tMax)
 
 struct RayPayload
 {
-    float4 color;
+    float4 colour;
+};
+
+cbuffer ray_tracing_constants : register(b0) {
+    float4x4    inverse_wvp;
+    int4        output_uav_index;
 };
 
 [shader("raygeneration")]
 void scene_raygen_shader()
 {
-    float2 lerp_values = (float2)DispatchRaysIndex() / (float2)DispatchRaysDimensions();
-
-	/*
-    // Orthographic projection since we're raytracing in screen space.
-    float3 ray_dir = float3(0.0, 0.0, 1.0);
-    float3 origin = float3(
-        lerp(
-            raygen_constants.viewport.left, 
-            raygen_constants.viewport.right, 
-            lerp_values.x
-        ),
-        lerp(
-            raygen_constants.viewport.top, 
-            raygen_constants.viewport.bottom, 
-            lerp_values.y
-        ),
-        0.0f
-    );
+    //uv and ndc from dispatch dim
+    float2 uv = (float2)DispatchRaysIndex() / (float2)DispatchRaysDimensions();
+    float2 ndc = uv * 2.0 - 1.0;
 
+    // unproject ray
+    float4 near = float4(ndc.x, ndc.y, 0.0, 1.0);
+    float4 far = float4(ndc.x, ndc.y, 1.0, 1.0);
+    
+    float4 wnear = mul(inverse_wvp, near);
+    wnear /= wnear.w;
+    
+    float4 wfar = mul(inverse_wvp, far);
+    wfar /= wfar.w;
 
-    if (inside_viewport(origin.xy, raygen_constants.stencil))
-    {
-        // Trace the ray.
-        // Set the ray's extents.
-        RayDesc ray;
-        ray.Origin = origin;
-        ray.Direction = ray_dir;
-        
-        // Set TMin to a non-zero small value to avoid aliasing issues due to floating - point errors.
-        // TMin should be kept small to prevent missing geometry at close contact areas.
-        ray.TMin = 0.001;
-        ray.TMax = 10000.0;
-        RayPayload payload = { float4(0.0, 0.0, 1.0, 0.0) };
-        TraceRay(scene, RAY_FLAG_NONE, ~0, 0.0, 1.0, 0.0, ray, payload);
-
-        // Write the raytraced color to the output texture.
-        output_target[DispatchRaysIndex().xy] = payload.color;
-    }
-    else
-    {
-        // Render interpolated DispatchRaysIndex outside the stencil window
-        output_target[DispatchRaysIndex().xy] = float4(lerp_values, 1.0, 1.0);
-    }
-    */
-	
-	rw_textures[resources.input0.index][DispatchRaysIndex().xy] = float4(lerp_values, 1.0, 1.0);
+    // ray desc
+    RayDesc ray;
+    ray.Origin = wnear.xyz;
+    ray.Direction = normalize(wfar.xyz - wnear.xyz);
+    ray.TMin = 0.001;
+    ray.TMax = 10000.0;
+
+    RayPayload payload = { float4(0.0, 0.0, 1.0, 0.0) };
+    TraceRay(scene_tlas, RAY_FLAG_NONE, ~0, 0.0, 1.0, 0.0, ray, payload);
+
+	rw_textures[output_uav_index.x][DispatchRaysIndex().xy] = payload.colour;
 }
 
 [shader("closesthit")]
 void scene_closest_hit_shader(inout RayPayload payload, in BuiltInTriangleIntersectionAttributes attr)
 {
     float3 barycentrics = float3(1 - attr.barycentrics.x - attr.barycentrics.y, attr.barycentrics.x, attr.barycentrics.y);
-    payload.color = float4(float3(1.0, 1.0, 1.0) - barycentrics, 1.0);
+    payload.colour = float4(float3(1.0, 1.0, 1.0) - barycentrics, 1.0);
 }
 
 [shader("miss")]
 void scene_miss_shader(inout RayPayload payload)
 {
-    payload.color = float4(0.5, 0.5, 0.5, 1.0);
+    payload.colour = float4(0.5, 0.5, 0.5, 1.0);
 }

shaders/material.jsn

@@ -71,7 +71,7 @@
                 hit_groups: ["hit_group"],
             }
 			push_constants: [
-                resources
+                ray_tracing_constants
             ]
         }
         mesh_pbr_ibl: {

src/gfx.rs

@@ -169,6 +169,8 @@ pub struct HeapInfo {
     pub heap_type: HeapType,
     /// Total size of the heap in number of resources.
     pub num_descriptors: usize,
+    /// Optional debug name
+    pub debug_name: Option<String>
 }
 
 /// Options for heap types.
@@ -1258,6 +1260,14 @@ 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,
@@ -1392,9 +1402,9 @@ pub trait CmdBuf<D: Device>: Send + Sync + Clone {
     fn set_binding<T: Pipeline>(&self, pipeline: &T, heap: &D::Heap, slot: u32, offset: usize);
     // TODO:
     fn set_tlas(&self, tlas: &D::RaytracingTLAS);
-    /// Push a small amount of data into the command buffer for a render pipeline, num values and dest offset are the numbr of 32bit values
+    /// Push a small amount of data into the command buffer for a render pipeline, num values and dest offset are the number of 32bit values
     fn push_render_constants<T: Sized>(&self, slot: u32, num_values: u32, dest_offset: u32, data: &[T]);
-    /// Push a small amount of data into the command buffer for a compute pipeline, num values and dest offset are the numbr of 32bit values
+    /// Push a small amount of data into the command buffer for a compute pipeline, num values and dest offset are the number of 32bit values
     fn push_compute_constants<T: Sized>(&self, slot: u32, num_values: u32, dest_offset: u32, data: &[T]);
     /// Make a non-indexed draw call supplying vertex and instance counts
     fn draw_instanced(

src/gfx/d3d12.rs

@@ -1806,10 +1806,10 @@ impl super::Device for Device {
                 &HeapInfo {
                     heap_type: super::HeapType::Shader,
                     num_descriptors: info.shader_heap_size,
+                    debug_name: Some("device_shader_heap".to_string())
                 },
                 heap_id
             );
-            d3d12_debug_name!(shader_heap.heap, "device_shader_heap");
 
             // rtv
             heap_id += 1;
@@ -1818,10 +1818,10 @@ impl super::Device for Device {
                 &HeapInfo {
                     heap_type: super::HeapType::RenderTarget,
                     num_descriptors: info.render_target_heap_size,
+                    debug_name: Some("device_render_target_heap".to_string())
                 },
                 heap_id
             );
-            d3d12_debug_name!(rtv_heap.heap, "device_render_target_heap");
 
             // dsv
             heap_id += 1;
@@ -1830,10 +1830,10 @@ impl super::Device for Device {
                 &HeapInfo {
                     heap_type: super::HeapType::DepthStencil,
                     num_descriptors: info.depth_stencil_heap_size,
+                    debug_name: Some("device_depth_stencil_heap".to_string())
                 },
                 heap_id
             );
-            d3d12_debug_name!(dsv_heap.heap, "device_depth_stencil_heap");
 
             // query feature flags
             let mut feature_flags = DeviceFeatureFlags::NONE;
@@ -1889,7 +1889,13 @@ impl super::Device for Device {
 
     fn create_heap(&mut self, info: &HeapInfo) -> Heap {
         self.heap_id += 1; // bump heap id
-        create_heap(&self.device, info, self.heap_id)
+        let heap = create_heap(&self.device, info, self.heap_id);
+        if let Some(debug_name) = &info.debug_name {
+            unsafe {
+                d3d12_debug_name!(heap.heap, debug_name);
+            }
+        }
+        heap
     }
 
     fn create_query_heap(&self, info: &QueryHeapInfo) -> QueryHeap {

src/plugin.rs

@@ -99,6 +99,17 @@ impl reloader::ReloadResponder for PluginReloadResponder {
                 .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!")
+            */
+            
             Command::new("cargo")
                 .current_dir(&self.path)
                 .arg("build")

src/pmfx.rs

@@ -351,7 +351,7 @@ struct RaytracingShaderBindingTableInfo {
 }
 
 #[derive(Clone)]
-enum PipelineType {
+pub enum PipelineType {
     None,
     Render,
     Compute,
@@ -983,6 +983,7 @@ impl<D> Pmfx<D> where D: gfx::Device {
         let shader_heap = device.create_heap(&gfx::HeapInfo {
             heap_type: gfx::HeapType::Shader,
             num_descriptors: shader_heap_size,
+            debug_name: Some("pmfx_shader_heap".to_string())
         });
         Pmfx {
             pmfx: File::new(),