mirror of
https://github.com/storytold/wgpu.git
synced 2026-11-20 14:31:08 +01:00
[wgpu-core] ray tracing: use error handling helpers
This commit is contained in:
1 parent
214396a807
commit
fb9f91a668
5 files changed
+104
-242
No files matched your search
@@ -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,
|
||||
})
|
||||
|
||||
@@ -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));
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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),
|
||||
}
|
||||
|
||||
@@ -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()))
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
Reference in new issue
Block a user