- working example of inline raytracing

GBDixonAlex · GBDixonAlex · commit 76b672a07b2d · 2025-03-23T16:01:43.000Z
diff --git a/config.jsn b/config.jsn
@@ -122,6 +122,9 @@
                 "-num_threads 1"
                 "-args"
                 "-Zpr"
+                "-Zi"
+                "-Qembed_debug"
+                "-Od"
             ]
         }
         pmfx_dev: {
diff --git a/plugins/ecs_examples/src/raytraced_shadows.rs b/plugins/ecs_examples/src/raytraced_shadows.rs
@@ -32,9 +32,9 @@ pub fn raytraced_shadows(client: &mut Client<gfx_platform::Device, os_platform::
             "animate_meshes",
             "animate_lights",
             "batch_lights",
-            "update_tlas"
+            "setup_tlas"
         ],
-        render_graph: "mesh_lit_rt_shadow",
+        render_graph: "mesh_lit_rt_shadow2",
         ..Default::default()
     }
 }
@@ -49,7 +49,7 @@ pub fn blas_from_mesh(device: &mut ResMut<DeviceRes>, mesh: &pmfx::Mesh<gfx_plat
                     transform3x4: None,
                     index_count: mesh.num_indices as usize,
                     index_format: gfx::Format::R16u,
-                    vertex_count: mesh.num_indices as usize,
+                    vertex_count: mesh.num_vertices as usize,
                     vertex_format: gfx::Format::RGB32f,
                     vertex_stride: 56
                 }),
@@ -66,7 +66,6 @@ pub fn setup_raytraced_shadows_scene(
     mut commands: Commands) -> Result<(), hotline_rs::Error> {
 
     let cube_mesh = hotline_rs::primitives::create_cube_mesh(&mut device.0);
-
     let tourus_mesh = hotline_rs::primitives::create_tourus_mesh(&mut device.0, 32);
     let teapot_mesh = hotline_rs::primitives::create_teapot_mesh(&mut device.0, 32);
     let tube_mesh = hotline_rs::primitives::create_tube_prism_mesh(&mut device.0, 32, 0, 32, true, true, 1.0, 0.66, 1.0);
@@ -202,7 +201,7 @@ pub fn setup_raytraced_shadows_scene(
 }
 
 #[export_update_fn]
-pub fn update_tlas(
+pub fn setup_tlas(
     mut device: ResMut<DeviceRes>,
     mut pmfx: ResMut<PmfxRes>,
     mut entities_query: Query<(&mut Position, &mut Scale, &mut Rotation, &BLAS)>,
@@ -235,6 +234,9 @@ pub fn update_tlas(
                 },
                 &mut pmfx.shader_heap
             )?;
+            let tlas_srv =  tlas.get_srv_index().expect("expect tlas to have an srv");
+            pmfx.push_constant_user_data[0] = tlas_srv as u32;
+            println!("tlas_srv = {tlas_srv}");
             t.tlas = Some(tlas);
         }
     }
@@ -255,13 +257,8 @@ pub fn animate_lights (
     Ok(())
 }
 
-// TODO_RT
-// update tlas
-// mesh vertex count
-// fix: Ignoring InitialState D3D12_RESOURCE_STATE_COPY_DEST. Buffers are effectively created in state D3D12_RESOURCE_STATE_COMMON.
-
 #[export_compute_fn]
-pub fn render_meshes_raytraced(
+pub fn update_tlas(
     mut device: ResMut<DeviceRes>,
     pmfx: &Res<PmfxRes>,
     pass: &pmfx::ComputePass<gfx_platform::Device>,
@@ -272,9 +269,6 @@ pub fn render_meshes_raytraced(
 
     let mut heap = pmfx.shader_heap.clone();
 
-    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");
-
     // update tlas
     for mut t in &mut tlas_query {
         let mut instances = Vec::new();
@@ -301,6 +295,31 @@ pub fn render_meshes_raytraced(
         }
     }
 
+    Ok(())
+}
+
+// TODO_RT
+// mesh vertex count
+// crash when switching demo
+
+// TODO clean
+// fix: Ignoring InitialState D3D12_RESOURCE_STATE_COPY_DEST. Buffers are effectively created in state D3D12_RESOURCE_STATE_COMMON.
+
+#[export_compute_fn]
+pub fn render_meshes_raytraced(
+    mut device: ResMut<DeviceRes>,
+    pmfx: &Res<PmfxRes>,
+    pass: &pmfx::ComputePass<gfx_platform::Device>,
+    mut entities_query: Query<(&mut Position, &mut Scale, &mut Rotation, &BLAS)>,
+    mut tlas_query: Query<&mut TLAS>,
+) -> Result<(), hotline_rs::Error> {
+    let pmfx = &pmfx.0;
+
+    let mut heap = pmfx.shader_heap.clone();
+
+    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 camera = pmfx.get_camera_constants("main_camera");
     if let Ok(camera) = camera {
         for t in &tlas_query {            
diff --git a/shaders/ecs.hlsl b/shaders/ecs.hlsl
@@ -82,6 +82,7 @@ struct world_buffer_info_data {
     uint2 directional_light;
     uint2 camera;
     uint2 shadow_matrix;
+    uint4 user_data;
 }
 
 // info to lookup shadow srv and matrix
diff --git a/shaders/material.hlsl b/shaders/material.hlsl
@@ -267,45 +267,44 @@ float4 ps_mesh_pbr_ibl(vs_output input) : SV_TARGET {
     return float4(((kd * max(diffuse, 0.0) + max(specular, 0.0))), 1.0);
 }
 
+struct RayPayload
+{
+    float4 col;
+};
+
+cbuffer ray_tracing_constants : register(b0) {
+    float4x4    inverse_wvp;
+    int4        resource_indices; // x = uav output, y = scene_tlas
+};
+
 // basic ray traced shadow
-bool is_occluded(float3 origin, float3 direction, float tMin, float tMax)
+bool is_occluded(float3 origin, float3 direction, float tmin, float tmax)
 {
-    RayQuery<RAY_FLAG_SKIP_PROCEDURAL_PRIMITIVES> rayQuery;
+    RayQuery<RAY_FLAG_CULL_NON_OPAQUE | RAY_FLAG_ACCEPT_FIRST_HIT_AND_END_SEARCH> ray_query;
 
     RayDesc desc;
     desc.Origin = origin;
-    desc.TMin = tMin;
+    desc.TMin = tmin;
     desc.Direction = direction;
-    desc.TMax = tMax;
+    desc.TMax = tmax;
 
-    rayQuery.TraceRayInline(
-        scene_tlas[resource_indices.y],
-        RAY_FLAG_ACCEPT_FIRST_HIT_AND_END_SEARCH,
-        0xFF,
+    ray_query.TraceRayInline(
+        scene_tlas[world_buffer_info.user_data.x],
+        RAY_FLAG_NONE,
+        0xff,
         desc
     );
 
-    while (rayQuery.Proceed()) // Traverse BVH
+    ray_query.Proceed();
+
+    if (ray_query.CommittedStatus() == COMMITTED_TRIANGLE_HIT)
     {
-        if (rayQuery.CommittedStatus() == COMMITTED_TRIANGLE_HIT)
-        {
-            return true; // Something is occluding
-        }
+        return true;
     }
 
-    return false; // No occlusion
+    return false;
 }
 
-struct RayPayload
-{
-    float4 col;
-};
-
-cbuffer ray_tracing_constants : register(b0) {
-    float4x4    inverse_wvp;
-    int4        resource_indices; // x = uav output, y = scene_tlas
-};
-
 [shader("raygeneration")]
 void scene_raygen_shader()
 {
@@ -437,4 +436,48 @@ void shadow_closest_hit_shader(inout RayPayload payload, in BuiltInTriangleInter
 void scene_miss_shader(inout RayPayload payload)
 {
     payload.col = float4(0.0, 0.0, 0.0, 0.0);
+}
+
+ps_output ps_mesh_lit_rt_shadow(vs_output input) {
+    ps_output output;
+    output.colour = input.colour;
+
+    int i = 0;
+    float ks = 2.0;
+    float shininess = 32.0;
+    float roughness = 0.1;
+    float k = 0.3;
+
+    float3 v = normalize(input.world_pos.xyz - view_position.xyz);
+    float3 n = input.normal;
+
+    // point lights
+    uint point_lights_id = world_buffer_info.point_light.x;
+    uint point_lights_count = world_buffer_info.point_light.y;
+    for(i = 0; i < point_lights_count; ++i) {
+        point_light_data light = point_lights[point_lights_id][i];
+
+        float3 l = normalize(input.world_pos.xyz - light.pos);
+        float rl = length(light.pos - input.world_pos.xyz);
+
+        float diffuse = lambert(l, n);
+        float specular = cook_torrance(l, n, v, roughness, k);
+
+        float atteniuation = point_light_attenuation(
+            light.pos,
+            light.radius,
+            input.world_pos.xyz
+        );
+
+        float4 light_colour = atteniuation * light.colour * diffuse;
+        light_colour += atteniuation * light.colour * specular;
+
+        bool occluded = is_occluded(input.world_pos.xyz, -l, 0.001, rl);
+        
+        if(!occluded) {
+            output.colour += light_colour;
+        }
+    }
+
+    return output;
 }
diff --git a/shaders/material.jsn b/shaders/material.jsn
@@ -79,6 +79,18 @@
                 ray_tracing_constants
             ]
         }
+        mesh_lit_rt_shadow2: {
+            vs: "vs_mesh",
+            ps: "ps_mesh_lit_rt_shadow"
+            push_constants: [
+                "view_push_constants"
+                "draw_push_constants"
+                "world_buffer_info"
+            ]
+            depth_stencil_state: depth_test_less
+            raster_state: cull_back
+            topology: "TriangleList"
+        }
         mesh_pbr_ibl: {
             vs: "vs_mesh",
             ps: "ps_mesh_pbr_ibl"
@@ -136,16 +148,39 @@
                 depends_on: ["debug"]
             }
         }
+        mesh_lit_rt_shadow2: {
+            debug: {
+                view: "main_view"
+                pipelines: ["imdraw_3d"]
+                function: "render_debug"
+            }
+            update_tlas: {
+                pipelines: []
+                function: "update_tlas"
+                depends_on: ["debug"]
+            }
+            meshes: {
+                view: "main_view"
+                pipelines: ["mesh_lit_rt_shadow2"]
+                function: "render_meshes_bindless"
+                depends_on: ["update_tlas"]
+            }
+        }
         mesh_lit_rt_shadow: {
             debug: {
                 view: "main_view"
                 pipelines: ["imdraw_3d"]
                 function: "render_debug"
             }
+            update_tlas: {
+                pipelines: []
+                function: "update_tlas"
+                depends_on: ["debug"]
+            }
             meshes: {
                 pipelines: ["mesh_lit_rt_shadow"]
                 function: "render_meshes_raytraced"
-                depends_on: ["debug"]
+                depends_on: ["update_tlas"]
 				uses: [
 					["staging_output", "Write"]
 				]
diff --git a/src/gfx/d3d12.rs b/src/gfx/d3d12.rs
@@ -1853,6 +1853,7 @@ impl super::Device for Device {
                 std::ptr::addr_of!(options5) as *mut _, 
                 std::mem::size_of::<D3D12_FEATURE_DATA_D3D12_OPTIONS5>() as u32).is_ok() {
                 if options5.RaytracingTier != D3D12_RAYTRACING_TIER_NOT_SUPPORTED {
+                    println!("raytracing tier = {:?}", options5.RaytracingTier);
                     feature_flags |= super::DeviceFeatureFlags::RAYTRACING;
                 }
             }
diff --git a/src/pmfx.rs b/src/pmfx.rs
@@ -99,6 +99,8 @@ pub struct Mesh<D: gfx::Device> {
     pub ib: D::Buffer,
     /// Number of indices to draw from the index buffer
     pub num_indices: u32,
+    /// Number of vertices in the vertex buffer
+    pub num_vertices: u32,
     /// Bounding aabb min
     pub aabb_min: Vec3f,
     /// Bounding aabb mix
@@ -185,6 +187,8 @@ pub struct Pmfx<D: gfx::Device> {
     pub view_errors: Arc<Mutex<HashMap<String, String>>>,
     /// Tracks the currently active render graph name
     pub active_render_graph: String,
+    /// Quick access user data
+    pub push_constant_user_data: [u32; 4],
 }
 
 /// Contains frame statistics from the GPU for all pmfx jobs
@@ -716,7 +720,9 @@ pub struct WorldBufferInfo {
     /// cbv index of the camera
     pub camera: GpuBufferLookup,
     /// srv index of shadow matrices
-    pub shadow_matrix: GpuBufferLookup
+    pub shadow_matrix: GpuBufferLookup,
+    /// custom user data
+    pub user_data: [u32; 4]
 }
 
 pub fn cubemap_camera_face(face: usize, pos: Vec3f, near: f32, far: f32) -> CameraConstants {
@@ -1009,6 +1015,7 @@ impl<D> Pmfx<D> where D: gfx::Device {
             unit_quad_mesh: primitives::create_unit_quad_mesh(device),
             total_stats: TotalStats::new(),
             view_errors: Arc::new(Mutex::new(HashMap::new())),
+            push_constant_user_data: [0; 4]
         }
     }
 
@@ -1043,7 +1050,8 @@ impl<D> Pmfx<D> where D: gfx::Device {
             spot_light: self.world_buffers.spot_light.get_lookup(),
             directional_light: self.world_buffers.directional_light.get_lookup(),
             camera: self.world_buffers.camera.get_lookup(),
-            shadow_matrix: self.world_buffers.shadow_matrix.get_lookup()
+            shadow_matrix: self.world_buffers.shadow_matrix.get_lookup(),
+            user_data: self.push_constant_user_data
         }
     }
 
@@ -1596,13 +1604,18 @@ impl<D> Pmfx<D> where D: gfx::Device {
             threads
         }
         else {
-            let pipeline = self.pmfx.pipelines.get(&pass_pipeline).unwrap();
-            if let Some(num_threads) = pipeline["0"].numthreads {
-                num_threads
+            if let Some(pipeline) = self.pmfx.pipelines.get(&pass_pipeline) {
+                if let Some(num_threads) = pipeline["0"].numthreads {
+                    num_threads
+                }
+                else {
+                    (1, 1, 1)
+                }
             }
             else {
                 (1, 1, 1)
             }
+            //let pipeline = self.pmfx.pipelines.get(&pass_pipeline).unwrap();
         };
 
         // hashes
diff --git a/src/primitives.rs b/src/primitives.rs

Original file line number	Diff line number	Diff line change
`@@ -122,6 +122,9 @@`
`122`	`122`	`"-num_threads 1"`
`123`	`123`	`"-args"`
`124`	`124`	`"-Zpr"`
	`125`	`+ "-Zi"`
	`126`	`+ "-Qembed_debug"`
	`127`	`+ "-Od"`
`125`	`128`	`]`
`126`	`129`	`}`
`127`	`130`	`pmfx_dev: {`
Original file line number	Diff line number	Diff line change
`@@ -82,6 +82,7 @@ struct world_buffer_info_data {`
`82`	`82`	`uint2 directional_light;`
`83`	`83`	`uint2 camera;`
`84`	`84`	`uint2 shadow_matrix;`
	`85`	`+ uint4 user_data;`
`85`	`86`	`}`
`86`	`87`
`87`	`88`	`// info to lookup shadow srv and matrix`
Original file line number	Diff line number	Diff line change
`@@ -1853,6 +1853,7 @@ impl super::Device for Device {`
`1853`	`1853`	`std::ptr::addr_of!(options5) as *mut _,`
`1854`	`1854`	`std::mem::size_of::<D3D12_FEATURE_DATA_D3D12_OPTIONS5>() as u32).is_ok() {`
`1855`	`1855`	`if options5.RaytracingTier != D3D12_RAYTRACING_TIER_NOT_SUPPORTED {`
	`1856`	`+ println!("raytracing tier = {:?}", options5.RaytracingTier);`
`1856`	`1857`	`feature_flags \|= super::DeviceFeatureFlags::RAYTRACING;`
`1857`	`1858`	`}`
`1858`	`1859`	`}`