wip setting up shader tables for raytracing pipeline

Author: polymonster

src/gfx.rs

@@ -775,6 +775,13 @@ pub struct RaytracingPipelineInfo<'stack, D: Device> {
     pub pipeline_layout: PipelineLayout,
 }
 
+pub struct RaytacingShaderBindingTable<D: Device> {
+    pub ray_generation: D::ShaderTable,
+    pub miss: D::ShaderTable,
+    pub hit_group: D::ShaderTable,
+    pub callable: D::ShaderTable
+}
+
 /// Information to create a pipeline through `Device::create_texture`.
 #[derive(Copy, Clone)]
 pub struct TextureInfo {
@@ -946,6 +953,9 @@ pub trait ComputePipeline<D: Device>: Send + Sync  {}
 /// An opaque compute pipeline type..
 pub trait RaytracingPipeline<D: Device>: Send + Sync  {}
 
+/// An opaque shader table type..
+pub trait ShaderTable<D: Device>: Send + Sync  {}
+
 /// A pipeline trait for shared functionality between Compute and Render pipelines
 pub trait Pipeline {
     /// Returns the `PipelineSlotInfo` of which slot to bind a heap to based on the reequested `register` and `descriptor_type`
@@ -1083,6 +1093,7 @@ pub trait Device: 'static + Send + Sync + Sized + Any + Clone {
     type ComputePipeline: ComputePipeline<Self>;
     type RaytracingPipeline: RaytracingPipeline<Self>;
     type CommandSignature: CommandSignature<Self>;
+    type ShaderTable: ShaderTable<Self>;
     /// Create a new GPU `Device` from `Device Info`
     fn create(info: &DeviceInfo) -> Self;
     /// Create a new resource `Heap` from `HeapInfo`

src/gfx/d3d12.rs

@@ -1630,6 +1630,13 @@ impl Shader {
     }
 }
 
+pub struct ShaderTable {
+}
+
+impl super::ShaderTable<Device> for ShaderTable {
+
+}
+
 impl super::Device for Device {
     type SwapChain = SwapChain;
     type CmdBuf = CmdBuf;
@@ -1644,6 +1651,7 @@ impl super::Device for Device {
     type Heap = Heap;
     type QueryHeap = QueryHeap;
     type CommandSignature = CommandSignature;
+    type ShaderTable = ShaderTable;
     fn create(info: &super::DeviceInfo) -> Device {
         unsafe {
             // enable debug layer
@@ -2149,6 +2157,9 @@ impl super::Device for Device {
                     Flags: to_d3d12_buffer_usage_flags(info.usage),
                     ..Default::default()
                 },
+                D3D12_RESOURCE_STATE_COMMON,
+
+                /*
                 // initial state
                 if info.cpu_access.contains(super::CpuAccessFlags::WRITE) {
                     D3D12_RESOURCE_STATE_GENERIC_READ
@@ -2159,6 +2170,8 @@ impl super::Device for Device {
                 else {
                     to_d3d12_resource_state(info.initial_state)
                 },
+                */
+                
                 None,
                 &mut buf,
             )?;
@@ -3078,9 +3091,45 @@ impl super::Device for Device {
 
         unsafe {
             let device5 = self.device.cast::<ID3D12Device5>().expect("hotline_rs::gfx::d3d12: expected ID3D12Device5 availability to create_raytracing_pipeline");
-            let state_object = device5.CreateStateObject(
+            let state_object : ID3D12StateObject = device5.CreateStateObject(
                 &state_object_desc,
             )?;
+
+            // get shader identifiers
+            let props = state_object.cast::<ID3D12StateObjectProperties>().expect("hotline_rs::gfx::d3d12: expected ID3D12StateObjectProperties");
+            let ident = props.GetShaderIdentifier(windows_core::PCWSTR(wide_entry_points[0].as_ptr()));
+            println!("ident: {:?}", ident);
+            
+            // create a resource ray gen, miss and hitgroup (maybe arrays)
+
+            // create a table resource
+            let mut table_buffer: Option<ID3D12Resource> = None;
+            self.device.CreateCommittedResource(
+                &D3D12_HEAP_PROPERTIES {
+                    Type: D3D12_HEAP_TYPE_DEFAULT,
+                    ..Default::default()
+                },
+                D3D12_HEAP_FLAG_NONE,
+                &D3D12_RESOURCE_DESC {
+                    Dimension: D3D12_RESOURCE_DIMENSION_BUFFER,
+                    Alignment: 0, //D3D12_RAYTRACING_SHADER_RECORD_BYTE_ALIGNMENT as u64,
+                    Width: D3D12_SHADER_IDENTIFIER_SIZE_IN_BYTES as u64,
+                    Height: 1,
+                    DepthOrArraySize: 1,
+                    MipLevels: 1,
+                    Format: DXGI_FORMAT_UNKNOWN,
+                    SampleDesc: DXGI_SAMPLE_DESC {
+                        Count: 1,
+                        Quality: 0,
+                    },
+                    Layout: D3D12_TEXTURE_LAYOUT_ROW_MAJOR,
+                    Flags: D3D12_RESOURCE_FLAG_NONE,
+                },
+                D3D12_RESOURCE_STATE_COMMON,
+                None,
+                &mut table_buffer,
+            )?;
+
             Ok(RaytracingPipeline {
                 state_object: state_object
             })