Ray tracing compaction

CHANGELOG.md

@@ -149,6 +149,7 @@ By @ErichDonGubler in [#6456](https://github.com/gfx-rs/wgpu/pull/6456), [#6148]
 - Return submission index in `map_async` and `on_submitted_work_done` to track down completion of async callbacks. By @eliemichel in [#6360](https://github.com/gfx-rs/wgpu/pull/6360).
 - Move raytracing alignments into HAL instead of in core. By @Vecvec in [#6563](https://github.com/gfx-rs/wgpu/pull/6563).
 - Allow for statically linking DXC rather than including separate `.dll` files. By @DouglasDwyer in [#6574](https://github.com/gfx-rs/wgpu/pull/6574).
+- Allow BLASes to be compacted. By @Vecvec in [#6609](https://github.com/gfx-rs/wgpu/pull/6609)
 
 ### Changes
 

examples/src/ray_cube_compute/mod.rs

@@ -4,7 +4,7 @@ use bytemuck::{Pod, Zeroable};
 use glam::{Affine3A, Mat4, Quat, Vec3};
 use wgpu::util::DeviceExt;
 
-use wgpu::StoreOp;
+use wgpu::{CommandEncoderDescriptor, StoreOp};
 
 // from cube
 #[repr(C)]
@@ -141,6 +141,7 @@ impl crate::framework::Example for Example {
             | wgpu::Features::VERTEX_WRITABLE_STORAGE
             | wgpu::Features::EXPERIMENTAL_RAY_QUERY
             | wgpu::Features::EXPERIMENTAL_RAY_TRACING_ACCELERATION_STRUCTURE
+            | wgpu::Features::TEXTURE_ADAPTER_SPECIFIC_FORMAT_FEATURES
     }
 
     fn required_downlevel_capabilities() -> wgpu::DownlevelCapabilities {
@@ -242,7 +243,8 @@ impl crate::framework::Example for Example {
         let blas = device.create_blas(
             &wgpu::CreateBlasDescriptor {
                 label: None,
-                flags: wgpu::AccelerationStructureFlags::PREFER_FAST_TRACE,
+                flags: wgpu::AccelerationStructureFlags::PREFER_FAST_TRACE
+                    | wgpu::AccelerationStructureFlags::ALLOW_COMPACTION,
                 update_mode: wgpu::AccelerationStructureUpdateMode::Build,
             },
             wgpu::BlasGeometrySizeDescriptors::Triangles {
@@ -343,6 +345,30 @@ impl crate::framework::Example for Example {
 
         let dist = 3.0;
 
+        let mut encoder = device.create_command_encoder(&CommandEncoderDescriptor { label: None });
+
+        encoder.build_acceleration_structures(
+            iter::once(&wgpu::BlasBuildEntry {
+                blas: &blas,
+                geometry: wgpu::BlasGeometries::TriangleGeometries(vec![
+                    wgpu::BlasTriangleGeometry {
+                        size: &blas_geo_size_desc,
+                        vertex_buffer: &vertex_buf,
+                        first_vertex: 0,
+                        vertex_stride: mem::size_of::<Vertex>() as u64,
+                        index_buffer: Some(&index_buf),
+                        index_buffer_offset: Some(0),
+                        transform_buffer: None,
+                        transform_buffer_offset: None,
+                    },
+                ]),
+            }),
+            iter::empty(),
+        );
+        queue.submit(Some(encoder.finish()));
+        let mut encoder = device.create_command_encoder(&CommandEncoderDescriptor { label: None });
+        let blas = encoder.compact_blas(&blas);
+        queue.submit(Some(encoder.finish()));
         for x in 0..side_count {
             for y in 0..side_count {
                 tlas_package[(x + y * side_count) as usize] = Some(wgpu::TlasInstance::new(
@@ -364,24 +390,7 @@ impl crate::framework::Example for Example {
         let mut encoder =
             device.create_command_encoder(&wgpu::CommandEncoderDescriptor { label: None });
 
-        encoder.build_acceleration_structures(
-            iter::once(&wgpu::BlasBuildEntry {
-                blas: &blas,
-                geometry: wgpu::BlasGeometries::TriangleGeometries(vec![
-                    wgpu::BlasTriangleGeometry {
-                        size: &blas_geo_size_desc,
-                        vertex_buffer: &vertex_buf,
-                        first_vertex: 0,
-                        vertex_stride: mem::size_of::<Vertex>() as u64,
-                        index_buffer: Some(&index_buf),
-                        index_buffer_offset: Some(0),
-                        transform_buffer: None,
-                        transform_buffer_offset: None,
-                    },
-                ]),
-            }),
-            iter::once(&tlas_package),
-        );
+        encoder.build_acceleration_structures(iter::empty(), iter::once(&tlas_package));
 
         queue.submit(Some(encoder.finish()));
 

player/src/lib.rs

@@ -207,6 +207,12 @@ impl GlobalPlay for wgc::global::Global {
                     )
                     .unwrap();
                 }
+                trace::Command::CompactBlas {
+                    blas,
+                    compacted_blas,
+                } => {
+                    self.command_encoder_compact_blas(encoder, blas, Some(compacted_blas));
+                }
             }
         }
         let (cmd_buf, error) =

tests/tests/ray_tracing/as_build.rs

@@ -17,7 +17,7 @@ struct AsBuildContext {
 }
 
 impl AsBuildContext {
-    fn new(ctx: &TestingContext) -> Self {
+    fn new(ctx: &TestingContext, additional_blas_flags: AccelerationStructureFlags) -> Self {
         let vertices = ctx.device.create_buffer_init(&BufferInitDescriptor {
             label: None,
             contents: &[0; mem::size_of::<[[f32; 3]; 3]>()],
@@ -35,7 +35,7 @@ impl AsBuildContext {
         let blas = ctx.device.create_blas(
             &CreateBlasDescriptor {
                 label: Some("BLAS"),
-                flags: AccelerationStructureFlags::PREFER_FAST_TRACE,
+                flags: AccelerationStructureFlags::PREFER_FAST_TRACE | additional_blas_flags,
                 update_mode: AccelerationStructureUpdateMode::Build,
             },
             BlasGeometrySizeDescriptors::Triangles {
@@ -95,7 +95,7 @@ static UNBUILT_BLAS: GpuTestConfiguration = GpuTestConfiguration::new()
     .run_sync(unbuilt_blas);
 
 fn unbuilt_blas(ctx: TestingContext) {
-    let as_ctx = AsBuildContext::new(&ctx);
+    let as_ctx = AsBuildContext::new(&ctx, AccelerationStructureFlags::empty());
 
     // Build the TLAS package with an unbuilt BLAS.
     let mut encoder = ctx
@@ -125,7 +125,7 @@ static OUT_OF_ORDER_AS_BUILD: GpuTestConfiguration = GpuTestConfiguration::new()
     .run_sync(out_of_order_as_build);
 
 fn out_of_order_as_build(ctx: TestingContext) {
-    let as_ctx = AsBuildContext::new(&ctx);
+    let as_ctx = AsBuildContext::new(&ctx, AccelerationStructureFlags::empty());
 
     //
     // Encode the TLAS build before the BLAS build, but submit them in the right order.
@@ -156,7 +156,7 @@ fn out_of_order_as_build(ctx: TestingContext) {
     // Create a clean `AsBuildContext`
     //
 
-    let as_ctx = AsBuildContext::new(&ctx);
+    let as_ctx = AsBuildContext::new(&ctx, AccelerationStructureFlags::empty());
 
     //
     // Encode the BLAS build before the TLAS build, but submit them in the wrong order.
@@ -207,7 +207,7 @@ fn out_of_order_as_build_use(ctx: TestingContext) {
     // Create a clean `AsBuildContext`
     //
 
-    let as_ctx = AsBuildContext::new(&ctx);
+    let as_ctx = AsBuildContext::new(&ctx, AccelerationStructureFlags::empty());
 
     //
     // Build in the right order, then rebuild the BLAS so the TLAS is invalid, then use the TLAS.
@@ -328,3 +328,197 @@ fn empty_build(ctx: TestingContext) {
     ctx.queue
         .submit([encoder_safe.finish(), encoder_unsafe.finish()]);
 }
+
+#[gpu_test]
+static COMPACT_BLAS: GpuTestConfiguration = GpuTestConfiguration::new()
+    .parameters(
+        TestParameters::default()
+            .test_features_limits()
+            .features(wgpu::Features::EXPERIMENTAL_RAY_TRACING_ACCELERATION_STRUCTURE),
+    )
+    .run_sync(compact_blas);
+
+fn compact_blas(ctx: TestingContext) {
+    //
+    // Create a clean `AsBuildContext`
+    //
+
+    let as_ctx = AsBuildContext::new(&ctx, AccelerationStructureFlags::ALLOW_COMPACTION);
+
+    let mut encoder_blas = ctx
+        .device
+        .create_command_encoder(&CommandEncoderDescriptor {
+            label: Some("BLAS 1"),
+        });
+
+    encoder_blas.build_acceleration_structures([&as_ctx.blas_build_entry()], []);
+
+    ctx.queue.submit([encoder_blas.finish()]);
+    let mut encoder_compact = ctx
+        .device
+        .create_command_encoder(&CommandEncoderDescriptor {
+            label: Some("Compact 1"),
+        });
+
+    let _ = encoder_compact.compact_blas(&as_ctx.blas);
+
+    ctx.queue.submit([encoder_compact.finish()]);
+    //
+    // Create a clean `AsBuildContext`
+    //
+
+    let as_ctx = AsBuildContext::new(&ctx, AccelerationStructureFlags::ALLOW_COMPACTION);
+
+    let mut encoder_blas = ctx
+        .device
+        .create_command_encoder(&CommandEncoderDescriptor {
+            label: Some("BLAS 2"),
+        });
+
+    encoder_blas.build_acceleration_structures([&as_ctx.blas_build_entry()], []);
+
+    ctx.queue.submit([encoder_blas.finish()]);
+    let mut encoder_compact = ctx
+        .device
+        .create_command_encoder(&CommandEncoderDescriptor {
+            label: Some("Compact 2"),
+        });
+
+    let _ = encoder_compact.compact_blas(&as_ctx.blas);
+
+    let mut encoder_blas = ctx
+        .device
+        .create_command_encoder(&CommandEncoderDescriptor {
+            label: Some("BLAS 3"),
+        });
+
+    encoder_blas.build_acceleration_structures([&as_ctx.blas_build_entry()], []);
+
+    ctx.queue
+        .submit([encoder_compact.finish(), encoder_blas.finish()]);
+}
+
+#[gpu_test]
+static INVALID_COMPACT_BLAS: GpuTestConfiguration = GpuTestConfiguration::new()
+    .parameters(
+        TestParameters::default()
+            .test_features_limits()
+            .features(wgpu::Features::EXPERIMENTAL_RAY_TRACING_ACCELERATION_STRUCTURE),
+    )
+    .run_sync(invalid_compact_blas);
+
+fn invalid_compact_blas(ctx: TestingContext) {
+    //
+    // Create a clean `AsBuildContext`
+    //
+
+    let as_ctx = AsBuildContext::new(&ctx, AccelerationStructureFlags::empty());
+
+    let mut encoder_blas = ctx
+        .device
+        .create_command_encoder(&CommandEncoderDescriptor {
+            label: Some("BLAS 1"),
+        });
+
+    encoder_blas.build_acceleration_structures([&as_ctx.blas_build_entry()], []);
+
+    ctx.queue.submit([encoder_blas.finish()]);
+    let mut encoder_compact = ctx
+        .device
+        .create_command_encoder(&CommandEncoderDescriptor {
+            label: Some("Compact 1"),
+        });
+
+    fail(
+        &ctx.device,
+        || {
+            let _ = encoder_compact.compact_blas(&as_ctx.blas);
+        },
+        None,
+    );
+
+    //
+    // Create a clean `AsBuildContext`
+    //
+
+    let as_ctx = AsBuildContext::new(&ctx, AccelerationStructureFlags::ALLOW_COMPACTION);
+
+    let mut encoder_compact = ctx
+        .device
+        .create_command_encoder(&CommandEncoderDescriptor {
+            label: Some("Compact 2"),
+        });
+
+    fail(
+        &ctx.device,
+        || {
+            let _ = encoder_compact.compact_blas(&as_ctx.blas);
+        },
+        None,
+    );
+
+    //
+    // Create a clean `AsBuildContext`
+    //
+
+    let as_ctx = AsBuildContext::new(&ctx, AccelerationStructureFlags::ALLOW_COMPACTION);
+
+    let mut encoder_blas = ctx
+        .device
+        .create_command_encoder(&CommandEncoderDescriptor {
+            label: Some("BLAS 2"),
+        });
+
+    encoder_blas.build_acceleration_structures([&as_ctx.blas_build_entry()], []);
+
+    ctx.queue.submit([encoder_blas.finish()]);
+    let mut encoder_compact = ctx
+        .device
+        .create_command_encoder(&CommandEncoderDescriptor {
+            label: Some("Compact 3"),
+        });
+
+    let _ = encoder_compact.compact_blas(&as_ctx.blas);
+
+    let mut encoder_blas = ctx
+        .device
+        .create_command_encoder(&CommandEncoderDescriptor {
+            label: Some("BLAS 3"),
+        });
+
+    encoder_blas.build_acceleration_structures([&as_ctx.blas_build_entry()], []);
+
+    fail(
+        &ctx.device,
+        || {
+            ctx.queue
+                .submit([encoder_blas.finish(), encoder_compact.finish()]);
+        },
+        None,
+    );
+
+    let mut encoder_compact = ctx
+        .device
+        .create_command_encoder(&CommandEncoderDescriptor {
+            label: Some("Compact 4"),
+        });
+
+    let blas = encoder_compact.compact_blas(&as_ctx.blas);
+
+    let mut encoder_blas = ctx
+        .device
+        .create_command_encoder(&CommandEncoderDescriptor {
+            label: Some("BLAS 4"),
+        });
+
+    let mut entry = as_ctx.blas_build_entry();
+    entry.blas = &blas;
+
+    fail(
+        &ctx.device,
+        || {
+            encoder_blas.build_acceleration_structures([&entry], []);
+        },
+        None,
+    );
+}