diff --git a/wgpu-core/src/command/ray_tracing.rs b/wgpu-core/src/command/ray_tracing.rs index 9395c20fc..9d6dc09b8 100644 --- a/wgpu-core/src/command/ray_tracing.rs +++ b/wgpu-core/src/command/ray_tracing.rs @@ -81,12 +81,7 @@ impl Global { let device = &cmd_buf.device; - if !device - .features - .contains(Features::EXPERIMENTAL_RAY_TRACING_ACCELERATION_STRUCTURE) - { - return Err(BuildAccelerationStructureError::MissingFeature); - } + device.require_features(Features::EXPERIMENTAL_RAY_TRACING_ACCELERATION_STRUCTURE)?; let build_command_index = NonZeroU64::new( device @@ -199,18 +194,13 @@ impl Global { let mut tlas_buf_storage = Vec::new(); for entry in tlas_iter { - let instance_buffer = match hub.buffers.get(entry.instance_buffer_id).get() { - Ok(buffer) => buffer, - Err(_) => { - return Err(BuildAccelerationStructureError::InvalidBufferId); - } - }; + let instance_buffer = hub.buffers.get(entry.instance_buffer_id).get()?; let data = cmd_buf_data.trackers.buffers.set_single( &instance_buffer, BufferUses::BOTTOM_LEVEL_ACCELERATION_STRUCTURE_INPUT, ); tlas_buf_storage.push(TlasBufferStore { - buffer: instance_buffer.clone(), + buffer: instance_buffer, transition: data, entry: entry.clone(), }); @@ -221,14 +211,9 @@ impl Global { let instance_buffer = { let (instance_buffer, instance_pending) = (&mut tlas_buf.buffer, &mut tlas_buf.transition); - let instance_raw = instance_buffer.raw.get(&snatch_guard).ok_or( - BuildAccelerationStructureError::InvalidBuffer(instance_buffer.error_ident()), - )?; - if !instance_buffer.usage.contains(BufferUsages::TLAS_INPUT) { - return Err(BuildAccelerationStructureError::MissingTlasInputUsageFlag( - instance_buffer.error_ident(), - )); - } + let instance_raw = instance_buffer.try_raw(&snatch_guard)?; + instance_buffer.check_usage(BufferUsages::TLAS_INPUT)?; + if let Some(barrier) = instance_pending .take() .map(|pending| pending.into_hal(instance_buffer, &snatch_guard)) @@ -238,11 +223,7 @@ impl Global { instance_raw }; - let tlas = hub - .tlas_s - .get(entry.tlas_id) - .get() - .map_err(|_| BuildAccelerationStructureError::InvalidTlasId)?; + let tlas = hub.tlas_s.get(entry.tlas_id).get()?; cmd_buf_data.trackers.tlas_s.set_single(tlas.clone()); if let Some(queue) = device.get_queue() { queue.pending_writes.lock().insert_tlas(&tlas); @@ -266,7 +247,7 @@ impl Global { tlas, entries: hal::AccelerationStructureEntries::Instances( hal::AccelerationStructureInstances { - buffer: Some(instance_buffer.as_ref()), + buffer: Some(instance_buffer), offset: 0, count: entry.instance_count, }, @@ -311,9 +292,7 @@ impl Global { mode: hal::AccelerationStructureBuildMode::Build, flags: tlas.flags, source_acceleration_structure: None, - destination_acceleration_structure: tlas.raw(&snatch_guard).ok_or( - BuildAccelerationStructureError::InvalidTlas(tlas.error_ident()), - )?, + destination_acceleration_structure: tlas.try_raw(&snatch_guard)?, scratch_buffer: scratch_buffer.raw(), scratch_buffer_offset: *scratch_buffer_offset, }) @@ -381,12 +360,7 @@ impl Global { let device = &cmd_buf.device; - if !device - .features - .contains(Features::EXPERIMENTAL_RAY_TRACING_ACCELERATION_STRUCTURE) - { - return Err(BuildAccelerationStructureError::MissingFeature); - } + device.require_features(Features::EXPERIMENTAL_RAY_TRACING_ACCELERATION_STRUCTURE)?; let build_command_index = NonZeroU64::new( device @@ -521,17 +495,14 @@ impl Global { let mut tlas_lock_store = Vec::<(Option, Arc)>::new(); for package in tlas_iter { - let tlas = hub - .tlas_s - .get(package.tlas_id) - .get() - .map_err(|_| BuildAccelerationStructureError::InvalidTlasId)?; + let tlas = hub.tlas_s.get(package.tlas_id).get()?; if let Some(queue) = device.get_queue() { queue.pending_writes.lock().insert_tlas(&tlas); } + cmd_buf_data.trackers.tlas_s.set_single(tlas.clone()); - tlas_lock_store.push((Some(package), tlas.clone())) + tlas_lock_store.push((Some(package), tlas)) } let mut scratch_buffer_tlas_size = 0; @@ -558,12 +529,7 @@ impl Global { tlas.error_ident(), )); } - let blas = hub - .blas_s - .get(instance.blas_id) - .get() - .map_err(|_| BuildAccelerationStructureError::InvalidBlasIdForInstance)? - .clone(); + let blas = hub.blas_s.get(instance.blas_id).get()?; cmd_buf_data.trackers.blas_s.set_single(blas.clone()); @@ -581,7 +547,7 @@ impl Global { dependencies.push(blas.clone()); cmd_buf_data.blas_actions.push(BlasAction { - blas: blas.clone(), + blas, kind: crate::ray_tracing::BlasActionKind::Use, }); } @@ -659,13 +625,7 @@ impl Global { mode: hal::AccelerationStructureBuildMode::Build, flags: tlas.flags, source_acceleration_structure: None, - destination_acceleration_structure: tlas - .raw - .get(&snatch_guard) - .ok_or(BuildAccelerationStructureError::InvalidTlas( - tlas.error_ident(), - ))? - .as_ref(), + destination_acceleration_structure: tlas.try_raw(&snatch_guard)?, scratch_buffer: scratch_buffer.raw(), scratch_buffer_offset: *scratch_buffer_offset, }) @@ -857,9 +817,7 @@ impl CommandBufferMutable { action.tlas.error_ident(), )); } - if blas.raw.get(snatch_guard).is_none() { - return Err(ValidateTlasActionsError::InvalidBlas(blas.error_ident())); - } + blas.try_raw(snatch_guard)?; } } } @@ -879,11 +837,7 @@ fn iter_blas<'a>( ) -> Result<(), BuildAccelerationStructureError> { let mut temp_buffer = Vec::new(); for entry in blas_iter { - let blas = hub - .blas_s - .get(entry.blas_id) - .get() - .map_err(|_| BuildAccelerationStructureError::InvalidBlasId)?; + let blas = hub.blas_s.get(entry.blas_id).get()?; cmd_buf_data.trackers.blas_s.set_single(blas.clone()); if let Some(queue) = device.get_queue() { queue.pending_writes.lock().insert_blas(&blas); @@ -966,19 +920,13 @@ fn iter_blas<'a>( blas.error_ident(), )); } - let vertex_buffer = match hub.buffers.get(mesh.vertex_buffer).get() { - Ok(buffer) => buffer, - Err(_) => return Err(BuildAccelerationStructureError::InvalidBufferId), - }; + let vertex_buffer = hub.buffers.get(mesh.vertex_buffer).get()?; let vertex_pending = cmd_buf_data.trackers.buffers.set_single( &vertex_buffer, BufferUses::BOTTOM_LEVEL_ACCELERATION_STRUCTURE_INPUT, ); let index_data = if let Some(index_id) = mesh.index_buffer { - let index_buffer = match hub.buffers.get(index_id).get() { - Ok(buffer) => buffer, - Err(_) => return Err(BuildAccelerationStructureError::InvalidBufferId), - }; + let index_buffer = hub.buffers.get(index_id).get()?; if mesh.index_buffer_offset.is_none() || mesh.size.index_count.is_none() || mesh.size.index_count.is_none() @@ -991,15 +939,12 @@ fn iter_blas<'a>( &index_buffer, BufferUses::BOTTOM_LEVEL_ACCELERATION_STRUCTURE_INPUT, ); - Some((index_buffer.clone(), data)) + Some((index_buffer, data)) } else { None }; let transform_data = if let Some(transform_id) = mesh.transform_buffer { - let transform_buffer = match hub.buffers.get(transform_id).get() { - Ok(buffer) => buffer, - Err(_) => return Err(BuildAccelerationStructureError::InvalidBufferId), - }; + let transform_buffer = hub.buffers.get(transform_id).get()?; if mesh.transform_buffer_offset.is_none() { return Err(BuildAccelerationStructureError::MissingAssociatedData( transform_buffer.error_ident(), @@ -1014,7 +959,7 @@ fn iter_blas<'a>( None }; temp_buffer.push(TriangleBufferStore { - vertex_buffer: vertex_buffer.clone(), + vertex_buffer, vertex_transition: vertex_pending, index_buffer_transition: index_data, transform_buffer_transition: transform_data, @@ -1024,7 +969,7 @@ fn iter_blas<'a>( } if let Some(last) = temp_buffer.last_mut() { - last.ending_blas = Some(blas.clone()); + last.ending_blas = Some(blas); buf_storage.append(&mut temp_buffer); } } @@ -1050,14 +995,9 @@ fn iter_buffers<'a, 'b>( let mesh = &buf.geometry; let vertex_buffer = { let vertex_buffer = buf.vertex_buffer.as_ref(); - let vertex_raw = vertex_buffer.raw.get(snatch_guard).ok_or( - BuildAccelerationStructureError::InvalidBuffer(vertex_buffer.error_ident()), - )?; - if !vertex_buffer.usage.contains(BufferUsages::BLAS_INPUT) { - return Err(BuildAccelerationStructureError::MissingBlasInputUsageFlag( - vertex_buffer.error_ident(), - )); - } + let vertex_raw = vertex_buffer.try_raw(snatch_guard)?; + vertex_buffer.check_usage(BufferUsages::BLAS_INPUT)?; + if let Some(barrier) = buf .vertex_transition .take() @@ -1077,10 +1017,7 @@ fn iter_buffers<'a, 'b>( let vertex_buffer_offset = mesh.first_vertex as u64 * mesh.vertex_stride; cmd_buf_data.buffer_memory_init_actions.extend( vertex_buffer.initialization_status.read().create_action( - &hub.buffers - .get(mesh.vertex_buffer) - .get() - .map_err(|_| BuildAccelerationStructureError::InvalidBufferId)?, + &hub.buffers.get(mesh.vertex_buffer).get()?, vertex_buffer_offset ..(vertex_buffer_offset + mesh.size.vertex_count as u64 * mesh.vertex_stride), @@ -1092,14 +1029,9 @@ fn iter_buffers<'a, 'b>( let index_buffer = if let Some((ref mut index_buffer, ref mut index_pending)) = buf.index_buffer_transition { - let index_raw = index_buffer.raw.get(snatch_guard).ok_or( - BuildAccelerationStructureError::InvalidBuffer(index_buffer.error_ident()), - )?; - if !index_buffer.usage.contains(BufferUsages::BLAS_INPUT) { - return Err(BuildAccelerationStructureError::MissingBlasInputUsageFlag( - index_buffer.error_ident(), - )); - } + let index_raw = index_buffer.try_raw(snatch_guard)?; + index_buffer.check_usage(BufferUsages::BLAS_INPUT)?; + if let Some(barrier) = index_pending .take() .map(|pending| pending.into_hal(index_buffer, snatch_guard)) @@ -1155,14 +1087,9 @@ fn iter_buffers<'a, 'b>( transform_buffer.error_ident(), )); } - let transform_raw = transform_buffer.raw.get(snatch_guard).ok_or( - BuildAccelerationStructureError::InvalidBuffer(transform_buffer.error_ident()), - )?; - if !transform_buffer.usage.contains(BufferUsages::BLAS_INPUT) { - return Err(BuildAccelerationStructureError::MissingBlasInputUsageFlag( - transform_buffer.error_ident(), - )); - } + let transform_raw = transform_buffer.try_raw(snatch_guard)?; + transform_buffer.check_usage(BufferUsages::BLAS_INPUT)?; + if let Some(barrier) = transform_pending .take() .map(|pending| pending.into_hal(transform_buffer, snatch_guard)) @@ -1199,7 +1126,7 @@ fn iter_buffers<'a, 'b>( }; let triangles = hal::AccelerationStructureTriangles { - vertex_buffer: Some(vertex_buffer.as_ref()), + vertex_buffer: Some(vertex_buffer), vertex_format: mesh.size.vertex_format, first_vertex: mesh.first_vertex, vertex_count: mesh.size.vertex_count, @@ -1208,13 +1135,13 @@ fn iter_buffers<'a, 'b>( dyn hal::DynBuffer, > { format: mesh.size.index_format.unwrap(), - buffer: Some(index_buffer.as_ref()), + buffer: Some(index_buffer), offset: mesh.index_buffer_offset.unwrap() as u32, count: mesh.size.index_count.unwrap(), }), transform: transform_buffer.map(|transform_buffer| { hal::AccelerationStructureTriangleTransform { - buffer: transform_buffer.as_ref(), + buffer: transform_buffer, offset: mesh.transform_buffer_offset.unwrap() as u32, } }), @@ -1264,13 +1191,7 @@ fn map_blas<'a>( mode: hal::AccelerationStructureBuildMode::Build, flags: blas.flags, source_acceleration_structure: None, - destination_acceleration_structure: blas - .raw - .get(snatch_guard) - .ok_or(BuildAccelerationStructureError::InvalidBlas( - blas.error_ident(), - ))? - .as_ref(), + destination_acceleration_structure: blas.try_raw(snatch_guard)?, scratch_buffer, scratch_buffer_offset: *scratch_buffer_offset, }) diff --git a/wgpu-core/src/device/ray_tracing.rs b/wgpu-core/src/device/ray_tracing.rs index 12afc7e6a..4e53abdbf 100644 --- a/wgpu-core/src/device/ray_tracing.rs +++ b/wgpu-core/src/device/ray_tracing.rs @@ -1,6 +1,7 @@ use std::mem::ManuallyDrop; use std::sync::Arc; +use crate::api_log; #[cfg(feature = "trace")] use crate::device::trace; use crate::lock::{rank, Mutex}; @@ -24,6 +25,9 @@ impl Device { blas_desc: &resource::BlasDescriptor, sizes: wgt::BlasGeometrySizeDescriptors, ) -> Result, CreateBlasError> { + self.check_is_valid()?; + self.require_features(Features::EXPERIMENTAL_RAY_TRACING_ACCELERATION_STRUCTURE)?; + let size_info = match &sizes { wgt::BlasGeometrySizeDescriptors::Triangles { descriptors } => { let mut entries = @@ -109,6 +113,9 @@ impl Device { self: &Arc, desc: &resource::TlasDescriptor, ) -> Result, CreateTlasError> { + self.check_is_valid()?; + self.require_features(Features::EXPERIMENTAL_RAY_TRACING_ACCELERATION_STRUCTURE)?; + let size_info = unsafe { self.raw().get_acceleration_structure_build_sizes( &hal::GetAccelerationStructureBuildSizesDescriptor { @@ -174,23 +181,10 @@ impl Global { ) -> (BlasId, Option, Option) { profiling::scope!("Device::create_blas"); - let hub = &self.hub; - let fid = hub.blas_s.prepare(id_in); + let fid = self.hub.blas_s.prepare(id_in); - let device_guard = hub.devices.read(); let error = 'error: { - let device = device_guard.get(device_id); - match device.check_is_valid() { - Ok(_) => {} - Err(err) => break 'error CreateBlasError::Device(err), - }; - - if !device - .features - .contains(Features::EXPERIMENTAL_RAY_TRACING_ACCELERATION_STRUCTURE) - { - break 'error CreateBlasError::MissingFeature; - } + let device = self.hub.devices.get(device_id); #[cfg(feature = "trace")] if let Some(trace) = device.trace.lock().as_mut() { @@ -207,8 +201,8 @@ impl Global { }; let handle = blas.handle; - let id = fid.assign(Fallible::Valid(blas.clone())); - log::info!("Created blas {:?} with {:?}", id, desc); + let id = fid.assign(Fallible::Valid(blas)); + api_log!("Device::create_blas -> {id:?}"); return (id, Some(handle), None); }; @@ -225,23 +219,10 @@ impl Global { ) -> (TlasId, Option) { profiling::scope!("Device::create_tlas"); - let hub = &self.hub; - let fid = hub.tlas_s.prepare(id_in); + let fid = self.hub.tlas_s.prepare(id_in); - let device_guard = hub.devices.read(); let error = 'error: { - let device = device_guard.get(device_id); - match device.check_is_valid() { - Ok(_) => {} - Err(e) => break 'error CreateTlasError::Device(e), - } - - if !device - .features - .contains(Features::EXPERIMENTAL_RAY_TRACING_ACCELERATION_STRUCTURE) - { - break 'error CreateTlasError::MissingFeature; - } + let device = self.hub.devices.get(device_id); #[cfg(feature = "trace")] if let Some(trace) = device.trace.lock().as_mut() { @@ -257,7 +238,7 @@ impl Global { }; let id = fid.assign(Fallible::Valid(tlas)); - log::info!("Created tlas {:?} with {:?}", id, desc); + api_log!("Device::create_tlas -> {id:?}"); return (id, None); }; @@ -268,15 +249,12 @@ impl Global { pub fn blas_destroy(&self, blas_id: BlasId) -> Result<(), resource::DestroyError> { profiling::scope!("Blas::destroy"); - log::info!("Blas::destroy {blas_id:?}"); + api_log!("Blas::destroy {blas_id:?}"); - let hub = &self.hub; - - let blas = hub.blas_s.get(blas_id).get()?; - let _device = &blas.device; + let blas = self.hub.blas_s.get(blas_id).get()?; #[cfg(feature = "trace")] - if let Some(trace) = _device.trace.lock().as_mut() { + if let Some(trace) = blas.device.trace.lock().as_mut() { trace.add(trace::Action::FreeBlas(blas_id)); } @@ -285,22 +263,13 @@ impl Global { pub fn blas_drop(&self, blas_id: BlasId) { profiling::scope!("Blas::drop"); - log::debug!("blas {:?} is dropped", blas_id); + api_log!("Blas::drop {blas_id:?}"); - let hub = &self.hub; - - let _blas = match hub.blas_s.remove(blas_id).get() { - Ok(blas) => blas, - Err(_) => { - return; - } - }; + let _blas = self.hub.blas_s.remove(blas_id); #[cfg(feature = "trace")] - { - let mut lock = _blas.device.trace.lock(); - - if let Some(t) = lock.as_mut() { + if let Ok(blas) = _blas.get() { + if let Some(t) = blas.device.trace.lock().as_mut() { t.add(trace::Action::DestroyBlas(blas_id)); } } @@ -308,22 +277,12 @@ impl Global { pub fn tlas_destroy(&self, tlas_id: TlasId) -> Result<(), resource::DestroyError> { profiling::scope!("Tlas::destroy"); + api_log!("Tlas::destroy {tlas_id:?}"); - let hub = &self.hub; - - log::info!("Tlas {:?} is destroyed", tlas_id); - let tlas_guard = hub.tlas_s.write(); - let tlas = tlas_guard - .get(tlas_id) - .get() - .map_err(resource::DestroyError::InvalidResource)? - .clone(); - drop(tlas_guard); - - let _device = &mut tlas.device.clone(); + let tlas = self.hub.tlas_s.get(tlas_id).get()?; #[cfg(feature = "trace")] - if let Some(trace) = _device.trace.lock().as_mut() { + if let Some(trace) = tlas.device.trace.lock().as_mut() { trace.add(trace::Action::FreeTlas(tlas_id)); } @@ -332,22 +291,13 @@ impl Global { pub fn tlas_drop(&self, tlas_id: TlasId) { profiling::scope!("Tlas::drop"); - log::debug!("tlas {:?} is dropped", tlas_id); + api_log!("Tlas::drop {tlas_id:?}"); - let hub = &self.hub; - - let _tlas = match hub.tlas_s.remove(tlas_id).get() { - Ok(tlas) => tlas, - Err(_) => { - return; - } - }; + let _tlas = self.hub.tlas_s.remove(tlas_id); #[cfg(feature = "trace")] - { - let mut lock = _tlas.device.trace.lock(); - - if let Some(t) = lock.as_mut() { + if let Ok(tlas) = _tlas.get() { + if let Some(t) = tlas.device.trace.lock().as_mut() { t.add(trace::Action::DestroyTlas(tlas_id)); } } diff --git a/wgpu-core/src/device/resource.rs b/wgpu-core/src/device/resource.rs index 838e822d5..681367735 100644 --- a/wgpu-core/src/device/resource.rs +++ b/wgpu-core/src/device/resource.rs @@ -38,7 +38,7 @@ use wgt::{ math::align_to, DeviceLostReason, TextureFormat, TextureSampleType, TextureViewDimension, }; -use crate::resource::{AccelerationStructure, DestroyedResourceError, Tlas}; +use crate::resource::{AccelerationStructure, Tlas}; use std::{ borrow::Cow, mem::{self, ManuallyDrop}, @@ -2186,9 +2186,7 @@ impl Device { } } - Ok(tlas - .raw(snatch_guard) - .ok_or(DestroyedResourceError(tlas.error_ident()))?) + Ok(tlas.try_raw(snatch_guard)?) } // This function expects the provided bind group layout to be resolved diff --git a/wgpu-core/src/ray_tracing.rs b/wgpu-core/src/ray_tracing.rs index 9f4a11946..060044cd4 100644 --- a/wgpu-core/src/ray_tracing.rs +++ b/wgpu-core/src/ray_tracing.rs @@ -9,9 +9,9 @@ use crate::{ command::CommandEncoderError, - device::DeviceError, + device::{DeviceError, MissingFeatures}, id::{BlasId, BufferId, TlasId}, - resource::CreateBufferError, + resource::{DestroyedResourceError, InvalidResourceError, MissingBufferUsageError}, }; use std::num::NonZeroU64; use std::sync::Arc; @@ -25,15 +25,13 @@ pub enum CreateBlasError { #[error(transparent)] Device(#[from] DeviceError), #[error(transparent)] - CreateBufferError(#[from] CreateBufferError), + MissingFeatures(#[from] MissingFeatures), #[error( "Only one of 'index_count' and 'index_format' was provided (either provide both or none)" )] MissingIndexData, #[error("Provided format was not within allowed formats. Provided format: {0:?}. Allowed formats: {1:?}")] InvalidVertexFormat(VertexFormat, Vec), - #[error("Features::RAY_TRACING_ACCELERATION_STRUCTURE is not enabled")] - MissingFeature, } #[derive(Clone, Debug, Error)] @@ -41,9 +39,7 @@ pub enum CreateTlasError { #[error(transparent)] Device(#[from] DeviceError), #[error(transparent)] - CreateBufferError(#[from] CreateBufferError), - #[error("Features::RAY_TRACING_ACCELERATION_STRUCTURE is not enabled")] - MissingFeature, + MissingFeatures(#[from] MissingFeatures), } /// Error encountered while attempting to do a copy on a command encoder. @@ -55,14 +51,17 @@ pub enum BuildAccelerationStructureError { #[error(transparent)] Device(#[from] DeviceError), - #[error("BufferId is invalid or destroyed")] - InvalidBufferId, + #[error(transparent)] + InvalidResource(#[from] InvalidResourceError), - #[error("Buffer {0:?} is invalid or destroyed")] - InvalidBuffer(ResourceErrorIdent), + #[error(transparent)] + DestroyedResource(#[from] DestroyedResourceError), - #[error("Buffer {0:?} is missing `BLAS_INPUT` usage flag")] - MissingBlasInputUsageFlag(ResourceErrorIdent), + #[error(transparent)] + MissingBufferUsage(#[from] MissingBufferUsageError), + + #[error(transparent)] + MissingFeatures(#[from] MissingFeatures), #[error( "Buffer {0:?} size is insufficient for provided size information (size: {1}, required: {2}" @@ -111,12 +110,6 @@ pub enum BuildAccelerationStructureError { #[error("Blas {0:?} build sizes require index buffer but none was provided")] MissingIndexBuffer(ResourceErrorIdent), - #[error("BlasId is invalid")] - InvalidBlasId, - - #[error("Blas {0:?} is destroyed")] - InvalidBlas(ResourceErrorIdent), - #[error( "Tlas {0:?} an associated instances contains an invalid custom index (more than 24bits)" )] @@ -126,21 +119,6 @@ pub enum BuildAccelerationStructureError { "Tlas {0:?} has {1} active instances but only {2} are allowed as specified by the descriptor at creation" )] TlasInstanceCountExceeded(ResourceErrorIdent, u32, u32), - - #[error("BlasId is invalid or destroyed (for instance)")] - InvalidBlasIdForInstance, - - #[error("TlasId is invalid or destroyed")] - InvalidTlasId, - - #[error("Tlas {0:?} is invalid or destroyed")] - InvalidTlas(ResourceErrorIdent), - - #[error("Features::RAY_TRACING_ACCELERATION_STRUCTURE is not enabled")] - MissingFeature, - - #[error("Buffer {0:?} is missing `TLAS_INPUT` usage flag")] - MissingTlasInputUsageFlag(ResourceErrorIdent), } #[derive(Clone, Debug, Error)] @@ -151,15 +129,15 @@ pub enum ValidateBlasActionsError { #[derive(Clone, Debug, Error)] pub enum ValidateTlasActionsError { + #[error(transparent)] + DestroyedResource(#[from] DestroyedResourceError), + #[error("Tlas {0:?} is used before it is built")] UsedUnbuilt(ResourceErrorIdent), #[error("Blas {0:?} is used before it is built (in Tlas {1:?})")] UsedUnbuiltBlas(ResourceErrorIdent, ResourceErrorIdent), - #[error("BlasId is destroyed (in Tlas {0:?})")] - InvalidBlas(ResourceErrorIdent), - #[error("Blas {0:?} is newer than the containing Tlas {1:?}")] BlasNewerThenTlas(ResourceErrorIdent, ResourceErrorIdent), } diff --git a/wgpu-core/src/resource.rs b/wgpu-core/src/resource.rs index 0b13ad3bd..76c44ee47 100644 --- a/wgpu-core/src/resource.rs +++ b/wgpu-core/src/resource.rs @@ -1889,7 +1889,10 @@ pub type BlasDescriptor<'a> = wgt::CreateBlasDescriptor>; pub type TlasDescriptor<'a> = wgt::CreateTlasDescriptor>; pub(crate) trait AccelerationStructure: Trackable { - fn raw<'a>(&'a self, guard: &'a SnatchGuard) -> Option<&'a dyn hal::DynAccelerationStructure>; + fn try_raw<'a>( + &'a self, + guard: &'a SnatchGuard, + ) -> Result<&'a dyn hal::DynAccelerationStructure, DestroyedResourceError>; } #[derive(Debug)] @@ -1920,8 +1923,14 @@ impl Drop for Blas { } impl AccelerationStructure for Blas { - fn raw<'a>(&'a self, guard: &'a SnatchGuard) -> Option<&'a dyn hal::DynAccelerationStructure> { - Some(self.raw.get(guard)?.as_ref()) + fn try_raw<'a>( + &'a self, + guard: &'a SnatchGuard, + ) -> Result<&'a dyn hal::DynAccelerationStructure, DestroyedResourceError> { + self.raw + .get(guard) + .map(|raw| raw.as_ref()) + .ok_or_else(|| DestroyedResourceError(self.error_ident())) } } @@ -2003,8 +2012,14 @@ impl Drop for Tlas { } impl AccelerationStructure for Tlas { - fn raw<'a>(&'a self, guard: &'a SnatchGuard) -> Option<&'a dyn hal::DynAccelerationStructure> { - Some(self.raw.get(guard)?.as_ref()) + fn try_raw<'a>( + &'a self, + guard: &'a SnatchGuard, + ) -> Result<&'a dyn hal::DynAccelerationStructure, DestroyedResourceError> { + self.raw + .get(guard) + .map(|raw| raw.as_ref()) + .ok_or_else(|| DestroyedResourceError(self.error_ident())) } }