Ray tracing pipelines for wgpu

examples/features/src/ray_aabb_compute/mod.rs

@@ -288,6 +288,7 @@ impl crate::framework::Example for Example {
             )),
             0,
             0xff,
+            wgpu::IntersectionShaderIndex::QueryData(0),
         ));
 
         let mut encoder =

examples/features/src/ray_cube_compute/mod.rs

@@ -341,6 +341,7 @@ impl crate::framework::Example for Example {
                     )),
                     0,
                     0xff,
+                    wgpu::IntersectionShaderIndex::QueryData(0),
                 ));
             }
         }

examples/features/src/ray_cube_fragment/mod.rs

@@ -306,7 +306,13 @@ impl crate::framework::Example for Example {
                         .try_into()
                         .unwrap();
 
-                    *instance = Some(wgpu::TlasInstance::new(&self.blas, transform, 0, 0xff));
+                    *instance = Some(wgpu::TlasInstance::new(
+                        &self.blas,
+                        transform,
+                        0,
+                        0xff,
+                        wgpu::IntersectionShaderIndex::QueryData(0),
+                    ));
                 }
             }
         }

examples/features/src/ray_cube_normals/mod.rs

@@ -332,6 +332,7 @@ impl crate::framework::Example for Example {
                     )),
                     0,
                     0xff,
+                    wgpu::IntersectionShaderIndex::QueryData(0),
                 ));
             }
         }

examples/features/src/ray_scene/mod.rs

@@ -486,6 +486,7 @@ impl crate::framework::Example for Example {
                         transform,
                         blas_index as u32,
                         0xff,
+                        wgpu::IntersectionShaderIndex::QueryData(0),
                     ));
                 }
             }

examples/features/src/ray_shadows/mod.rs

@@ -223,6 +223,7 @@ impl crate::framework::Example for Example {
             [1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0],
             0,
             0xFF,
+            wgpu::IntersectionShaderIndex::QueryData(0),
         ));
 
         let mut encoder =

examples/features/src/ray_traced_triangle/mod.rs

@@ -165,6 +165,7 @@ impl crate::framework::Example for Example {
                 .unwrap(),
             0,
             0xff,
+            wgpu::IntersectionShaderIndex::QueryData(0),
         ));
 
         tlas[1] = Some(TlasInstance::new(
@@ -180,6 +181,7 @@ impl crate::framework::Example for Example {
                 .unwrap(),
             0,
             0xff,
+            wgpu::IntersectionShaderIndex::QueryData(0),
         ));
 
         tlas[2] = Some(TlasInstance::new(
@@ -195,6 +197,7 @@ impl crate::framework::Example for Example {
                 .unwrap(),
             0,
             0xff,
+            wgpu::IntersectionShaderIndex::QueryData(0),
         ));
 
         let uniforms = {

examples/standalone/custom_backend/src/custom.rs

@@ -191,6 +191,13 @@ impl DeviceInterface for CustomDevice {
         wgpu::custom::DispatchComputePipeline::custom(CustomComputePipeline(module.0.clone()))
     }
 
+    fn create_ray_tracing_pipeline(
+        &self,
+        _desc: &wgpu::RayTracingPipelineDescriptor<'_>,
+    ) -> wgpu::custom::DispatchRayTracingPipeline {
+        unimplemented!()
+    }
+
     unsafe fn create_pipeline_cache(
         &self,
         _desc: &wgpu::PipelineCacheDescriptor<'_>,

player/src/lib.rs

@@ -46,6 +46,10 @@ pub struct Player {
         wgc::id::PointerId<wgc::id::markers::ComputePipeline>,
         Arc<wgc::pipeline::ComputePipeline>,
     >,
+    ray_tracing_pipelines: HashMap<
+        wgc::id::PointerId<wgc::id::markers::RayTracingPipeline>,
+        Arc<wgc::pipeline::RayTracingPipeline>,
+    >,
     pipeline_caches: HashMap<
         wgc::id::PointerId<wgc::id::markers::PipelineCache>,
         Arc<wgc::pipeline::PipelineCache>,
@@ -75,6 +79,7 @@ impl Default for Player {
             render_bundles: HashMap::new(),
             render_pipelines: HashMap::new(),
             compute_pipelines: HashMap::new(),
+            ray_tracing_pipelines: HashMap::new(),
             pipeline_caches: HashMap::new(),
             query_sets: HashMap::new(),
             buffers: HashMap::new(),
@@ -230,6 +235,17 @@ impl Player {
                     .expect("invalid compute pipeline");
                 self.bind_group_layouts.insert(id, bgl);
             }
+            Action::GetRayTracingPipelineBindGroupLayout {
+                id,
+                pipeline,
+                index,
+            } => {
+                let pipeline = self.resolve_ray_tracing_pipeline_id(pipeline);
+                let bgl = pipeline
+                    .get_bind_group_layout(index)
+                    .expect("invalid ray tracing pipeline");
+                self.bind_group_layouts.insert(id, bgl);
+            }
             Action::DestroyBindGroupLayout(id) => {
                 self.bind_group_layouts
                     .remove(&id)
@@ -481,6 +497,18 @@ impl Player {
             Action::DestroyTlas(id) => {
                 self.tlas_s.remove(&id).expect("invalid tlas");
             }
+            Action::CreateRayTracingPipeline { id, desc } => {
+                let descriptor = self.resolve_ray_tracing_pipeline_descriptor(desc);
+                let rt_pipeline = device
+                    .create_ray_tracing_pipeline(descriptor)
+                    .expect("create_ray_tracing_pipeline error");
+                self.ray_tracing_pipelines.insert(id, rt_pipeline);
+            }
+            Action::DestroyRayTracingPipeline(id) => {
+                self.ray_tracing_pipelines
+                    .remove(&id)
+                    .expect("invalid ray tracing pipeline");
+            }
         }
     }
 
@@ -600,6 +628,16 @@ impl Player {
             .clone()
     }
 
+    fn resolve_ray_tracing_pipeline_id(
+        &self,
+        id: wgc::id::PointerId<wgc::id::markers::RayTracingPipeline>,
+    ) -> Arc<wgc::pipeline::RayTracingPipeline> {
+        self.ray_tracing_pipelines
+            .get(&id)
+            .expect("invalid ray tracing pipeline")
+            .clone()
+    }
+
     fn resolve_pipeline_cache_id(
         &self,
         id: wgc::id::PointerId<wgc::id::markers::PipelineCache>,
@@ -744,6 +782,61 @@ impl Player {
         }
     }
 
+    fn resolve_ray_tracing_pipeline_descriptor<'a>(
+        &self,
+        desc: wgc::device::trace::TraceRayTracingPipelineDescriptor<'a>,
+    ) -> wgc::pipeline::ResolvedRayTracingPipelineDescriptor<'a> {
+        let layout = desc.layout.map(|id| self.resolve_pipeline_layout_id(id));
+
+        wgc::pipeline::ResolvedRayTracingPipelineDescriptor {
+            label: desc.label,
+            layout,
+            cache: desc.cache.map(|id| self.resolve_pipeline_cache_id(id)),
+            ray_generation: wgc::pipeline::ResolvedProgrammableStageDescriptor {
+                module: self.resolve_shader_module_id(desc.ray_generation.module),
+                entry_point: desc.ray_generation.entry_point,
+                constants: desc.ray_generation.constants,
+                zero_initialize_workgroup_memory: desc
+                    .ray_generation
+                    .zero_initialize_workgroup_memory,
+            },
+            miss: wgc::pipeline::ResolvedProgrammableStageDescriptor {
+                module: self.resolve_shader_module_id(desc.miss.module),
+                entry_point: desc.miss.entry_point,
+                constants: desc.miss.constants,
+                zero_initialize_workgroup_memory: desc.miss.zero_initialize_workgroup_memory,
+            },
+            intersections: desc
+                .intersections
+                .into_iter()
+                .map(|intersections| match intersections {
+                    wgc::pipeline::RayTracingIntersectionDescriptor::Triangle {
+                        closest_hit,
+                        any_hit,
+                    } => wgc::pipeline::RayTracingIntersectionDescriptor::Triangle {
+                        closest_hit: wgc::pipeline::ResolvedProgrammableStageDescriptor {
+                            module: self.resolve_shader_module_id(closest_hit.module),
+                            entry_point: closest_hit.entry_point,
+                            constants: closest_hit.constants,
+                            zero_initialize_workgroup_memory: closest_hit
+                                .zero_initialize_workgroup_memory,
+                        },
+                        any_hit: any_hit.map(|any_hit| {
+                            wgc::pipeline::ResolvedProgrammableStageDescriptor {
+                                module: self.resolve_shader_module_id(any_hit.module),
+                                entry_point: any_hit.entry_point,
+                                constants: any_hit.constants,
+                                zero_initialize_workgroup_memory: any_hit
+                                    .zero_initialize_workgroup_memory,
+                            }
+                        }),
+                    },
+                })
+                .collect(),
+            max_recursion_depth: desc.max_recursion_depth,
+        }
+    }
+
     fn resolve_bind_group_descriptor<'a>(
         &self,
         desc: wgc::device::trace::TraceBindGroupDescriptor<'a>,
@@ -936,6 +1029,9 @@ impl Player {
                 occlusion_query_set: occlusion_query_set.map(|qs| self.resolve_query_set_id(qs)),
                 multiview_mask,
             },
+            Command::RunRayTracingPass { pass } => Command::RunRayTracingPass {
+                pass: self.resolve_ray_tracing_pass(pass),
+            },
             Command::BuildAccelerationStructures { blas, tlas } => {
                 Command::BuildAccelerationStructures {
                     blas: blas
@@ -1031,6 +1127,32 @@ impl Player {
         }
     }
 
+    fn resolve_ray_tracing_pass(
+        &self,
+        pass: BasePass<wgc::command::RayTracingCommand<PointerReferences>, Infallible>,
+    ) -> BasePass<wgc::command::RayTracingCommand<ArcReferences>, Infallible> {
+        let BasePass {
+            label,
+            error,
+            commands,
+            dynamic_offsets,
+            immediates_data,
+            string_data,
+        } = pass;
+
+        BasePass {
+            label,
+            error,
+            commands: commands
+                .into_iter()
+                .map(|cmd| self.resolve_ray_tracing_command(cmd))
+                .collect(),
+            dynamic_offsets,
+            immediates_data,
+            string_data,
+        }
+    }
+
     fn resolve_compute_command(
         &self,
         command: wgc::command::ComputeCommand<PointerReferences>,
@@ -1248,6 +1370,38 @@ impl Player {
         }
     }
 
+    fn resolve_ray_tracing_command(
+        &self,
+        command: wgc::command::RayTracingCommand<PointerReferences>,
+    ) -> wgc::command::RayTracingCommand<ArcReferences> {
+        use wgc::command::RayTracingCommand as C;
+        match command {
+            C::SetBindGroup {
+                index,
+                num_dynamic_offsets,
+                bind_group,
+            } => C::SetBindGroup {
+                index,
+                num_dynamic_offsets,
+                bind_group: bind_group.map(|bg| self.resolve_bind_group_id(bg)),
+            },
+            C::SetPipeline(id) => C::SetPipeline(self.resolve_ray_tracing_pipeline_id(id)),
+            C::SetImmediate {
+                offset,
+                size_bytes,
+                values_offset,
+            } => C::SetImmediate {
+                offset,
+                size_bytes,
+                values_offset,
+            },
+            C::TraceRays(groups) => C::TraceRays(groups),
+            C::PushDebugGroup { color, len } => C::PushDebugGroup { color, len },
+            C::PopDebugGroup => C::PopDebugGroup,
+            C::InsertDebugMarker { color, len } => C::InsertDebugMarker { color, len },
+        }
+    }
+
     fn resolve_pass_timestamp_writes(
         &self,
         writes: wgc::command::PassTimestampWrites<PointerId<wgc::id::markers::QuerySet>>,
@@ -1380,6 +1534,7 @@ impl Player {
             transform: instance.transform,
             custom_data: instance.custom_data,
             mask: instance.mask,
+            intersection_index: instance.intersection_index,
         }
     }
 

tests/tests/wgpu-gpu/binding_array/tlas.rs

@@ -131,12 +131,14 @@ async fn binding_array_tlas(ctx: TestingContext) {
         [1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0],
         0,
         0xff,
+        wgpu::IntersectionShaderIndex::QueryData(0),
     ));
     tlas_b[0] = Some(wgpu::TlasInstance::new(
         &blas,
         [1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0],
         0,
         0xff,
+        wgpu::IntersectionShaderIndex::QueryData(0),
     ));
 
     // Build BLAS and TLASes.

tests/tests/wgpu-gpu/ray_tracing/as_aabb.rs

@@ -86,6 +86,7 @@ fn aabb_blas_build_and_trace(ctx: TestingContext) {
         [1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0],
         0,
         0xFF,
+        wgpu::IntersectionShaderIndex::QueryData(0),
     ));
 
     let mut encoder = ctx