[wgpu-core] ray tracing: use error handling helpers

This commit is contained in:
teoxoy authored and Teodor Tanasoaia committed 2025-01-13 20:52:55 +01:00
1 parent 214396a807
commit fb9f91a668
5 files changed
+104 -242

No files matched your search

+38 -117
View File
@@ -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<TlasPackage>, Arc<Tlas>)>::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,
})
+28 -78
View File
@@ -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<Arc<resource::Blas>, 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<Self>,
desc: &resource::TlasDescriptor,
) -> Result<Arc<resource::Tlas>, 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<u64>, Option<CreateBlasError>) {
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<CreateTlasError>) {
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));
}
}
+2 -4
View File
@@ -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
+16 -38
View File
@@ -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<VertexFormat>),
#[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),
}
+20 -5
View File
@@ -1889,7 +1889,10 @@ pub type BlasDescriptor<'a> = wgt::CreateBlasDescriptor<Label<'a>>;
pub type TlasDescriptor<'a> = wgt::CreateTlasDescriptor<Label<'a>>;
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()))
}
}