Support getting hit vertex positions.

CHANGELOG.md

@@ -128,6 +128,8 @@ By @cwfitzgerald in [#7030](https://github.com/gfx-rs/wgpu/pull/7030).
 - Add `util::StagingBelt::allocate()` so the staging belt can be used to write textures. By @kpreid in [#6900](https://github.com/gfx-rs/wgpu/pull/6900).
 - Added `CommandEncoder::transition_resources()` for native API interop, and allowing users to slightly optimize barriers. By @JMS55 in [#6678](https://github.com/gfx-rs/wgpu/pull/6678).
 
+- Support getting vertices of the hit triangle when raytracing. By @Vecvec in [#7141](https://github.com/gfx-rs/wgpu/pull/7141) .
+
 #### Naga
 
 - Support @must_use attribute on function declarations. By @turbocrime in [#6801](https://github.com/gfx-rs/wgpu/pull/6801).
@@ -2180,6 +2182,20 @@ By @cwfitzgerald in [#3671](https://github.com/gfx-rs/wgpu/pull/3671).
 - Added basic ray-tracing api for acceleration structures, and ray-queries @daniel-keitel (started by @expenses) in [#3507](https://github.com/gfx-rs/wgpu/pull/3507)
 
 
+### Added/New Features
+
+#### General
+- Added feature flags for ray-tracing (currently only hal): `RAY_QUERY` and `RAY_TRACING` @daniel-keitel (started by @expenses) in [#3507](https://github.com/gfx-rs/wgpu/pull/3507)
+
+#### Vulkan
+
+- Implemented basic ray-tracing api for acceleration structures, and ray-queries @daniel-keitel (started by @expenses) in [#3507](https://github.com/gfx-rs/wgpu/pull/3507)
+
+#### Hal 
+
+- Added basic ray-tracing api for acceleration structures, and ray-queries @daniel-keitel (started by @expenses) in [#3507](https://github.com/gfx-rs/wgpu/pull/3507)
+
+
 ### Changes
 
 #### General

Cargo.toml

@@ -159,7 +159,7 @@ gpu-descriptor = "0.3"
 # DX12 dependencies
 gpu-allocator = { version = "0.27", default-features = false }
 range-alloc = "0.1"
-mach-dxcompiler-rs = { version = "0.1.4", default-features = false }
+mach-dxcompiler-rs = { version = "0.1.4", default-features = false } # remember to increase max_shader_model if applicable
 windows-core = { version = "0.58", default-features = false }
 
 # Gles dependencies

etc/specs/ray_tracing.md

@@ -50,6 +50,8 @@ Naming is mostly taken from vulkan.
 ```wgsl
 // - Initializes the `ray_query` to check where (if anywhere) the ray defined by `ray_desc` hits in `acceleration_structure
 rayQueryInitialize(rq: ptr<function, ray_query>, acceleration_structure: acceleration_structure, ray_desc: RayDesc)
+// Overload.
+rayQueryInitialize(rq: ptr<function, ray_query<vertex_return>>, acceleration_structure: acceleration_structure<vertex_return>, ray_desc: RayDesc)
 
 // - Traces the ray in the initialized ray_query (partially) through the scene.
 // - Returns true if a triangle that was hit by the ray was in a `Blas` that is not marked as opaque.
@@ -63,6 +65,8 @@ rayQueryInitialize(rq: ptr<function, ray_query>, acceleration_structure: acceler
 // - Calling this function multiple times will cause the ray traversal to continue if it was interrupted by a `Candidate`
 //   intersection.
 rayQueryProceed(rq: ptr<function, ray_query>) -> bool
+// Overload.
+rayQueryProceed(rq: ptr<function, ray_query<vertex_return>>) -> bool
 
 // - Generates a hit from procedural geometry at a particular distance.
 rayQueryGenerateIntersection(hit_t: f32)
@@ -75,9 +79,19 @@ rayQueryTerminate()
 
 // - Returns intersection details about a hit considered `Committed`.
 rayQueryGetCommittedIntersection(rq: ptr<function, ray_query>) -> RayIntersection
+// Overload.
+rayQueryGetCommittedIntersection(rq: ptr<function, ray_query<vertex_return>>) -> RayIntersection
 
 // - Returns intersection details about a hit considered `Candidate`.
 rayQueryGetCandidateIntersection(rq: ptr<function, ray_query>) -> RayIntersection
+// Overload.
+rayQueryGetCandidateIntersection(rq: ptr<function, ray_query<vertex_return>>) -> RayIntersection
+
+// - Returns the vertices of the hit triangle considered `Committed`.
+getCommittedHitVertexPositions(rq: ptr<function, ray_query<vertex_return>>) -> array<vec3<f32>, 3>
+
+// - Returns the vertices of the hit triangle considered `Candidate`.
+getCandidateHitVertexPositions(rq: ptr<function, ray_query<vertex_return>>) -> array<vec3<f32>, 3>
 ```
 
 > [!CAUTION]
@@ -89,6 +103,11 @@ rayQueryGetCandidateIntersection(rq: ptr<function, ray_query>) -> RayIntersectio
 >   `Candidate`.
 > - Calling `rayQueryGetCandidateIntersection` when `rayQueryProceed`'s latest return on this ray query is considered
 >   `Committed`.
+> - Calling `getCommittedHitVertexPositions` when `rayQueryProceed`'s latest return on this ray query is considered
+>   `Candidate`.
+> - Calling `getCandidateHitVertexPositions` when `rayQueryProceed`'s latest return on this ray query is considered
+>   `Committed`.
+> - Calling `get*HitVertexPositions` when the last `rayQueryProceed` did not hit a triangle
 > - Calling `rayQueryProceed` when `rayQueryInitialize` has not previously been called on this ray query
 > - Calling `rayQueryGenerateIntersection` on a query with last intersection kind not being
 >   `RAY_QUERY_INTERSECTION_AABB`,

examples/features/src/lib.rs

@@ -17,6 +17,7 @@ pub mod msaa_line;
 pub mod multiple_render_targets;
 pub mod ray_cube_compute;
 pub mod ray_cube_fragment;
+pub mod ray_cube_normals;
 pub mod ray_scene;
 pub mod ray_shadows;
 pub mod ray_traced_triangle;
@@ -31,6 +32,9 @@ pub mod texture_arrays;
 pub mod timestamp_queries;
 pub mod uniform_values;
 pub mod water;
+pub mod ray_cube_compute;
+pub mod ray_cube_fragment;
+pub mod ray_scene;
 
 #[cfg(test)]
 wgpu_test::gpu_test_main!();

examples/features/src/main.rs

@@ -170,6 +170,12 @@ const EXAMPLES: &[ExampleDesc] = &[
         webgl: false,
         webgpu: false,
     },
+    ExampleDesc {
+        name: "ray_cube_normals",
+        function: wgpu_examples::ray_cube_normals::main,
+        webgl: false,  // No Ray-tracing extensions
+        webgpu: false, // No Ray-tracing extensions (yet)
+    },
 ];
 
 fn get_example_name() -> Option<String> {

examples/features/src/ray_cube_normals/README.md

@@ -0,0 +1,14 @@
+# ray-cube
+
+This example renders a ray traced cube with hardware acceleration.
+A separate compute shader is used to perform the ray queries. 
+
+## To Run
+
+```
+cargo run --bin wgpu-examples ray_cube_normals
+```
+
+## Screenshots
+
+![Cube example](screenshot.png)

examples/features/src/ray_cube_normals/blit.wgsl

@@ -0,0 +1,52 @@
+struct VertexOutput {
+    @builtin(position) position: vec4<f32>,
+    @location(0) tex_coords: vec2<f32>,
+};
+
+// meant to be called with 3 vertex indices: 0, 1, 2
+// draws one large triangle over the clip space like this:
+// (the asterisks represent the clip space bounds)
+//-1,1           1,1
+// ---------------------------------
+// |              *              .
+// |              *           .
+// |              *        .
+// |              *      .
+// |              *    . 
+// |              * .
+// |***************
+// |            . 1,-1 
+// |          .
+// |       .
+// |     .
+// |   .
+// |.
+@vertex
+fn vs_main(@builtin(vertex_index) vertex_index: u32) -> VertexOutput {
+    var result: VertexOutput;
+    let x = i32(vertex_index) / 2;
+    let y = i32(vertex_index) & 1;
+    let tc = vec2<f32>(
+        f32(x) * 2.0,
+        f32(y) * 2.0
+    );
+    result.position = vec4<f32>(
+        tc.x * 2.0 - 1.0,
+        1.0 - tc.y * 2.0,
+        0.0, 1.0
+    );
+    result.tex_coords = tc;
+    return result;
+}
+
+@group(0)
+@binding(0)
+var r_color: texture_2d<f32>;
+@group(0)
+@binding(1)
+var r_sampler: sampler;
+
+@fragment
+fn fs_main(vertex: VertexOutput) -> @location(0) vec4<f32> {
+    return textureSample(r_color, r_sampler, vertex.tex_coords);
+}