mirror of
https://github.com/storytold/wgpu.git
synced 2026-11-22 23:41:01 +01:00
Merge #1018
1018: Add context for errors originating from commads in a Pass r=kvark a=Kimundi
**Description**
This adds some error context information for some errors that can happen in a `{Render,Compute}Pass` to make error messages more clear.
Combined with https://github.com/gfx-rs/wgpu-rs/pull/613, errors in passes will look like this:
```
wgpu error: Validation error
Caused by:
In a RenderPass
In a draw command
index 3600 extends beyond limit 38
```
Co-authored-by: Marvin Löbel <loebel.marvin@gmail.com>
This commit is contained in:
4 files changed
+385
-140
No files matched your search
@@ -38,7 +38,10 @@
|
||||
#![allow(clippy::reversed_empty_ranges)]
|
||||
|
||||
use crate::{
|
||||
command::{BasePass, DrawError, RenderCommand, RenderCommandError, StateChange},
|
||||
command::{
|
||||
BasePass, DrawError, MapPassErr, PassErrorScope, RenderCommand, RenderCommandError,
|
||||
StateChange,
|
||||
},
|
||||
conv,
|
||||
device::{
|
||||
AttachmentData, DeviceError, RenderPassContext, MAX_VERTEX_BUFFERS, SHADER_STAGE_COUNT,
|
||||
@@ -656,17 +659,47 @@ impl State {
|
||||
|
||||
/// Error encountered when finishing recording a render bundle.
|
||||
#[derive(Clone, Debug, Error)]
|
||||
pub enum RenderBundleError {
|
||||
pub(super) enum RenderBundleErrorInner {
|
||||
#[error(transparent)]
|
||||
Device(#[from] DeviceError),
|
||||
#[error(transparent)]
|
||||
RenderCommand(#[from] RenderCommandError),
|
||||
RenderCommand(RenderCommandError),
|
||||
#[error(transparent)]
|
||||
ResourceUsageConflict(#[from] UsageConflict),
|
||||
#[error(transparent)]
|
||||
Draw(#[from] DrawError),
|
||||
}
|
||||
|
||||
impl<T> From<T> for RenderBundleErrorInner
|
||||
where
|
||||
T: Into<RenderCommandError>,
|
||||
{
|
||||
fn from(t: T) -> Self {
|
||||
Self::RenderCommand(t.into())
|
||||
}
|
||||
}
|
||||
|
||||
/// Error encountered when finishing recording a render bundle.
|
||||
#[derive(Clone, Debug, Error)]
|
||||
#[error("{scope}")]
|
||||
pub struct RenderBundleError {
|
||||
scope: PassErrorScope,
|
||||
#[source]
|
||||
inner: RenderBundleErrorInner,
|
||||
}
|
||||
|
||||
impl<T, E> MapPassErr<T, RenderBundleError> for Result<T, E>
|
||||
where
|
||||
E: Into<RenderBundleErrorInner>,
|
||||
{
|
||||
fn map_pass_err(self, scope: PassErrorScope) -> Result<T, RenderBundleError> {
|
||||
self.map_err(|inner| RenderBundleError {
|
||||
scope,
|
||||
inner: inner.into(),
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
impl<G: GlobalIdentityHandlerFactory> Global<G> {
|
||||
pub fn render_bundle_encoder_finish<B: GfxBackend>(
|
||||
&self,
|
||||
@@ -675,13 +708,16 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
|
||||
id_in: Input<G, id::RenderBundleId>,
|
||||
) -> Result<id::RenderBundleId, RenderBundleError> {
|
||||
span!(_guard, INFO, "RenderBundleEncoder::finish");
|
||||
let scope = PassErrorScope::Bundle;
|
||||
|
||||
let hub = B::hub(self);
|
||||
let mut token = Token::root();
|
||||
let (device_guard, mut token) = hub.devices.read(&mut token);
|
||||
|
||||
let device = device_guard
|
||||
.get(bundle_encoder.parent_id)
|
||||
.map_err(|_| DeviceError::Invalid)?;
|
||||
.map_err(|_| DeviceError::Invalid)
|
||||
.map_pass_err(scope)?;
|
||||
let render_bundle = {
|
||||
let (pipeline_layout_guard, mut token) = hub.pipeline_layouts.read(&mut token);
|
||||
let (bind_group_guard, mut token) = hub.bind_groups.read(&mut token);
|
||||
@@ -712,12 +748,15 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
|
||||
num_dynamic_offsets,
|
||||
bind_group_id,
|
||||
} => {
|
||||
let scope = PassErrorScope::SetBindGroup;
|
||||
|
||||
let max_bind_groups = device.limits.max_bind_groups;
|
||||
if (index as u32) >= max_bind_groups {
|
||||
Err(RenderCommandError::BindGroupIndexOutOfRange {
|
||||
return Err(RenderCommandError::BindGroupIndexOutOfRange {
|
||||
index,
|
||||
max: max_bind_groups,
|
||||
})?
|
||||
})
|
||||
.map_pass_err(scope);
|
||||
}
|
||||
|
||||
let offsets = &base.dynamic_offsets[..num_dynamic_offsets as usize];
|
||||
@@ -729,25 +768,32 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
|
||||
.map(|offset| *offset as wgt::BufferAddress)
|
||||
.find(|offset| offset % wgt::BIND_BUFFER_ALIGNMENT != 0)
|
||||
{
|
||||
Err(RenderCommandError::UnalignedBufferOffset(offset))?
|
||||
return Err(RenderCommandError::UnalignedBufferOffset(offset))
|
||||
.map_pass_err(scope);
|
||||
}
|
||||
|
||||
let bind_group = state
|
||||
.trackers
|
||||
.bind_groups
|
||||
.use_extend(&*bind_group_guard, bind_group_id, (), ())
|
||||
.map_err(|_| RenderCommandError::InvalidBindGroup(bind_group_id))?;
|
||||
.map_err(|_| RenderCommandError::InvalidBindGroup(bind_group_id))
|
||||
.map_pass_err(scope)?;
|
||||
if bind_group.dynamic_binding_info.len() != offsets.len() {
|
||||
Err(RenderCommandError::InvalidDynamicOffsetCount {
|
||||
return Err(RenderCommandError::InvalidDynamicOffsetCount {
|
||||
actual: offsets.len(),
|
||||
expected: bind_group.dynamic_binding_info.len(),
|
||||
})?
|
||||
})
|
||||
.map_pass_err(scope);
|
||||
}
|
||||
|
||||
state.set_bind_group(index, bind_group_id, bind_group.layout_id, offsets);
|
||||
state.trackers.merge_extend(&bind_group.used)?;
|
||||
state
|
||||
.trackers
|
||||
.merge_extend(&bind_group.used)
|
||||
.map_pass_err(scope)?;
|
||||
}
|
||||
RenderCommand::SetPipeline(pipeline_id) => {
|
||||
let scope = PassErrorScope::SetPipeline;
|
||||
if state.pipeline.set_and_check_redundant(pipeline_id) {
|
||||
continue;
|
||||
}
|
||||
@@ -761,7 +807,8 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
|
||||
bundle_encoder
|
||||
.context
|
||||
.check_compatible(&pipeline.pass_context)
|
||||
.map_err(RenderCommandError::IncompatiblePipeline)?;
|
||||
.map_err(RenderCommandError::IncompatiblePipeline)
|
||||
.map_pass_err(scope)?;
|
||||
|
||||
//TODO: check read-only depth
|
||||
|
||||
@@ -784,13 +831,14 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
|
||||
offset,
|
||||
size,
|
||||
} => {
|
||||
let scope = PassErrorScope::SetIndexBuffer;
|
||||
let buffer = state
|
||||
.trackers
|
||||
.buffers
|
||||
.use_extend(&*buffer_guard, buffer_id, (), BufferUse::INDEX)
|
||||
.unwrap();
|
||||
check_buffer_usage(buffer.usage, wgt::BufferUsage::INDEX)
|
||||
.map_err(RenderCommandError::from)?;
|
||||
.map_pass_err(scope)?;
|
||||
|
||||
let end = match size {
|
||||
Some(s) => offset + s.get(),
|
||||
@@ -804,13 +852,14 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
|
||||
offset,
|
||||
size,
|
||||
} => {
|
||||
let scope = PassErrorScope::SetVertexBuffer;
|
||||
let buffer = state
|
||||
.trackers
|
||||
.buffers
|
||||
.use_extend(&*buffer_guard, buffer_id, (), BufferUse::VERTEX)
|
||||
.unwrap();
|
||||
check_buffer_usage(buffer.usage, wgt::BufferUsage::VERTEX)
|
||||
.map_err(RenderCommandError::from)?;
|
||||
.map_pass_err(scope)?;
|
||||
|
||||
let end = match size {
|
||||
Some(s) => offset + s.get(),
|
||||
@@ -824,15 +873,17 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
|
||||
size_bytes,
|
||||
values_offset: _,
|
||||
} => {
|
||||
let scope = PassErrorScope::SetPushConstant;
|
||||
let end_offset = offset + size_bytes;
|
||||
|
||||
let pipeline_layout_id =
|
||||
pipeline_layout_id.ok_or(DrawError::MissingPipeline)?;
|
||||
let pipeline_layout_id = pipeline_layout_id
|
||||
.ok_or(DrawError::MissingPipeline)
|
||||
.map_pass_err(scope)?;
|
||||
let pipeline_layout = &pipeline_layout_guard[pipeline_layout_id];
|
||||
|
||||
pipeline_layout
|
||||
.validate_push_constant_ranges(stages, offset, end_offset)
|
||||
.map_err(RenderCommandError::from)?;
|
||||
.map_pass_err(scope)?;
|
||||
|
||||
commands.push(command);
|
||||
}
|
||||
@@ -842,20 +893,23 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
|
||||
first_vertex,
|
||||
first_instance,
|
||||
} => {
|
||||
let scope = PassErrorScope::Draw;
|
||||
let (vertex_limit, instance_limit) = state.vertex_limits();
|
||||
let last_vertex = first_vertex + vertex_count;
|
||||
if last_vertex > vertex_limit {
|
||||
Err(DrawError::VertexBeyondLimit {
|
||||
return Err(DrawError::VertexBeyondLimit {
|
||||
last_vertex,
|
||||
vertex_limit,
|
||||
})?
|
||||
})
|
||||
.map_pass_err(scope);
|
||||
}
|
||||
let last_instance = first_instance + instance_count;
|
||||
if last_instance > instance_limit {
|
||||
Err(DrawError::InstanceBeyondLimit {
|
||||
return Err(DrawError::InstanceBeyondLimit {
|
||||
last_instance,
|
||||
instance_limit,
|
||||
})?
|
||||
})
|
||||
.map_pass_err(scope);
|
||||
}
|
||||
commands.extend(state.flush_vertices());
|
||||
commands.extend(state.flush_binds());
|
||||
@@ -868,22 +922,25 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
|
||||
base_vertex: _,
|
||||
first_instance,
|
||||
} => {
|
||||
let scope = PassErrorScope::DrawIndexed;
|
||||
//TODO: validate that base_vertex + max_index() is within the provided range
|
||||
let (_, instance_limit) = state.vertex_limits();
|
||||
let index_limit = state.index.limit();
|
||||
let last_index = first_index + index_count;
|
||||
if last_index > index_limit {
|
||||
Err(DrawError::IndexBeyondLimit {
|
||||
return Err(DrawError::IndexBeyondLimit {
|
||||
last_index,
|
||||
index_limit,
|
||||
})?
|
||||
})
|
||||
.map_pass_err(scope);
|
||||
}
|
||||
let last_instance = first_instance + instance_count;
|
||||
if last_instance > instance_limit {
|
||||
Err(DrawError::InstanceBeyondLimit {
|
||||
return Err(DrawError::InstanceBeyondLimit {
|
||||
last_instance,
|
||||
instance_limit,
|
||||
})?
|
||||
})
|
||||
.map_pass_err(scope);
|
||||
}
|
||||
commands.extend(state.index.flush());
|
||||
commands.extend(state.flush_vertices());
|
||||
@@ -896,13 +953,14 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
|
||||
count: None,
|
||||
indexed: false,
|
||||
} => {
|
||||
let scope = PassErrorScope::DrawIndirect;
|
||||
let buffer = state
|
||||
.trackers
|
||||
.buffers
|
||||
.use_extend(&*buffer_guard, buffer_id, (), BufferUse::INDIRECT)
|
||||
.unwrap();
|
||||
check_buffer_usage(buffer.usage, wgt::BufferUsage::INDIRECT)
|
||||
.map_err(RenderCommandError::from)?;
|
||||
.map_pass_err(scope)?;
|
||||
|
||||
commands.extend(state.flush_vertices());
|
||||
commands.extend(state.flush_binds());
|
||||
@@ -914,13 +972,15 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
|
||||
count: None,
|
||||
indexed: true,
|
||||
} => {
|
||||
let scope = PassErrorScope::DrawIndexedIndirect;
|
||||
let buffer = state
|
||||
.trackers
|
||||
.buffers
|
||||
.use_extend(&*buffer_guard, buffer_id, (), BufferUse::INDIRECT)
|
||||
.map_err(|err| RenderCommandError::Buffer(buffer_id, err))?;
|
||||
.map_err(|err| RenderCommandError::Buffer(buffer_id, err))
|
||||
.map_pass_err(scope)?;
|
||||
check_buffer_usage(buffer.usage, wgt::BufferUsage::INDIRECT)
|
||||
.map_err(RenderCommandError::from)?;
|
||||
.map_pass_err(scope)?;
|
||||
|
||||
commands.extend(state.index.flush());
|
||||
commands.extend(state.flush_vertices());
|
||||
|
||||
@@ -6,7 +6,8 @@ use crate::{
|
||||
binding_model::{BindError, BindGroup, PushConstantUploadError},
|
||||
command::{
|
||||
bind::{Binder, LayoutChange},
|
||||
BasePass, BasePassRef, CommandBuffer, CommandEncoderError, StateChange,
|
||||
BasePass, BasePassRef, CommandBuffer, CommandEncoderError, MapPassErr, PassErrorScope,
|
||||
StateChange,
|
||||
},
|
||||
hub::{GfxBackend, Global, GlobalIdentityHandlerFactory, Storage, Token},
|
||||
id,
|
||||
@@ -116,8 +117,9 @@ pub enum DispatchError {
|
||||
},
|
||||
}
|
||||
|
||||
/// Error encountered when performing a compute pass.
|
||||
#[derive(Clone, Debug, Error)]
|
||||
pub enum ComputePassError {
|
||||
pub(super) enum ComputePassErrorInner {
|
||||
#[error(transparent)]
|
||||
Encoder(#[from] CommandEncoderError),
|
||||
#[error("bind group {0:?} is invalid")]
|
||||
@@ -142,6 +144,27 @@ pub enum ComputePassError {
|
||||
PushConstants(#[from] PushConstantUploadError),
|
||||
}
|
||||
|
||||
/// Error encountered when performing a compute pass.
|
||||
#[derive(Clone, Debug, Error)]
|
||||
#[error("{scope}")]
|
||||
pub struct ComputePassError {
|
||||
scope: PassErrorScope,
|
||||
#[source]
|
||||
inner: ComputePassErrorInner,
|
||||
}
|
||||
|
||||
impl<T, E> MapPassErr<T, ComputePassError> for Result<T, E>
|
||||
where
|
||||
E: Into<ComputePassErrorInner>,
|
||||
{
|
||||
fn map_pass_err(self, scope: PassErrorScope) -> Result<T, ComputePassError> {
|
||||
self.map_err(|inner| ComputePassError {
|
||||
scope,
|
||||
inner: inner.into(),
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
struct State {
|
||||
binder: Binder,
|
||||
@@ -211,11 +234,14 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
|
||||
mut base: BasePassRef<ComputeCommand>,
|
||||
) -> Result<(), ComputePassError> {
|
||||
span!(_guard, INFO, "CommandEncoder::run_compute_pass");
|
||||
let scope = PassErrorScope::Pass;
|
||||
|
||||
let hub = B::hub(self);
|
||||
let mut token = Token::root();
|
||||
|
||||
let (mut cmd_buf_guard, mut token) = hub.command_buffers.write(&mut token);
|
||||
let cmd_buf = CommandBuffer::get_encoder(&mut *cmd_buf_guard, encoder_id)?;
|
||||
let cmd_buf =
|
||||
CommandBuffer::get_encoder(&mut *cmd_buf_guard, encoder_id).map_pass_err(scope)?;
|
||||
let raw = cmd_buf.raw.last_mut().unwrap();
|
||||
|
||||
#[cfg(feature = "trace")]
|
||||
@@ -247,12 +273,15 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
|
||||
num_dynamic_offsets,
|
||||
bind_group_id,
|
||||
} => {
|
||||
let scope = PassErrorScope::SetBindGroup;
|
||||
|
||||
let max_bind_groups = cmd_buf.limits.max_bind_groups;
|
||||
if (index as u32) >= max_bind_groups {
|
||||
return Err(ComputePassError::BindGroupIndexOutOfRange {
|
||||
return Err(ComputePassErrorInner::BindGroupIndexOutOfRange {
|
||||
index,
|
||||
max: max_bind_groups,
|
||||
});
|
||||
})
|
||||
.map_pass_err(scope);
|
||||
}
|
||||
|
||||
temp_offsets.clear();
|
||||
@@ -264,8 +293,11 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
|
||||
.trackers
|
||||
.bind_groups
|
||||
.use_extend(&*bind_group_guard, bind_group_id, (), ())
|
||||
.map_err(|_| ComputePassError::InvalidBindGroup(bind_group_id))?;
|
||||
bind_group.validate_dynamic_bindings(&temp_offsets)?;
|
||||
.map_err(|_| ComputePassErrorInner::InvalidBindGroup(bind_group_id))
|
||||
.map_pass_err(scope)?;
|
||||
bind_group
|
||||
.validate_dynamic_bindings(&temp_offsets)
|
||||
.map_pass_err(scope)?;
|
||||
|
||||
if let Some((pipeline_layout_id, follow_ups)) = state.binder.provide_entry(
|
||||
index as usize,
|
||||
@@ -292,6 +324,8 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
|
||||
}
|
||||
}
|
||||
ComputeCommand::SetPipeline(pipeline_id) => {
|
||||
let scope = PassErrorScope::SetPipeline;
|
||||
|
||||
if state.pipeline.set_and_check_redundant(pipeline_id) {
|
||||
continue;
|
||||
}
|
||||
@@ -300,7 +334,8 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
|
||||
.trackers
|
||||
.compute_pipes
|
||||
.use_extend(&*pipeline_guard, pipeline_id, (), ())
|
||||
.map_err(|_| ComputePassError::InvalidPipeline(pipeline_id))?;
|
||||
.map_err(|_| ComputePassErrorInner::InvalidPipeline(pipeline_id))
|
||||
.map_pass_err(scope)?;
|
||||
|
||||
unsafe {
|
||||
raw.bind_compute_pipeline(&pipeline.raw);
|
||||
@@ -369,6 +404,8 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
|
||||
size_bytes,
|
||||
values_offset,
|
||||
} => {
|
||||
let scope = PassErrorScope::SetPushConstant;
|
||||
|
||||
let end_offset_bytes = offset + size_bytes;
|
||||
let values_end_offset =
|
||||
(values_offset + size_bytes / wgt::PUSH_CONSTANT_ALIGNMENT) as usize;
|
||||
@@ -379,7 +416,10 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
|
||||
.binder
|
||||
.pipeline_layout_id
|
||||
//TODO: don't error here, lazily update the push constants
|
||||
.ok_or(ComputePassError::Dispatch(DispatchError::MissingPipeline))?;
|
||||
.ok_or(ComputePassErrorInner::Dispatch(
|
||||
DispatchError::MissingPipeline,
|
||||
))
|
||||
.map_pass_err(scope)?;
|
||||
let pipeline_layout = &pipeline_layout_guard[pipeline_layout_id];
|
||||
|
||||
pipeline_layout
|
||||
@@ -388,44 +428,55 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
|
||||
offset,
|
||||
end_offset_bytes,
|
||||
)
|
||||
.map_err(ComputePassError::from)?;
|
||||
.map_pass_err(scope)?;
|
||||
|
||||
unsafe { raw.push_compute_constants(&pipeline_layout.raw, offset, data_slice) }
|
||||
}
|
||||
ComputeCommand::Dispatch(groups) => {
|
||||
state.is_ready()?;
|
||||
state.flush_states(
|
||||
raw,
|
||||
&mut cmd_buf.trackers,
|
||||
&*bind_group_guard,
|
||||
&*buffer_guard,
|
||||
&*texture_guard,
|
||||
)?;
|
||||
let scope = PassErrorScope::Dispatch;
|
||||
|
||||
state.is_ready().map_pass_err(scope)?;
|
||||
state
|
||||
.flush_states(
|
||||
raw,
|
||||
&mut cmd_buf.trackers,
|
||||
&*bind_group_guard,
|
||||
&*buffer_guard,
|
||||
&*texture_guard,
|
||||
)
|
||||
.map_pass_err(scope)?;
|
||||
unsafe {
|
||||
raw.dispatch(groups);
|
||||
}
|
||||
}
|
||||
ComputeCommand::DispatchIndirect { buffer_id, offset } => {
|
||||
state.is_ready()?;
|
||||
let scope = PassErrorScope::DispatchIndirect;
|
||||
|
||||
state.is_ready().map_pass_err(scope)?;
|
||||
|
||||
let indirect_buffer = state
|
||||
.trackers
|
||||
.buffers
|
||||
.use_extend(&*buffer_guard, buffer_id, (), BufferUse::INDIRECT)
|
||||
.map_err(|_| ComputePassError::InvalidIndirectBuffer(buffer_id))?;
|
||||
check_buffer_usage(indirect_buffer.usage, BufferUsage::INDIRECT)?;
|
||||
.map_err(|_| ComputePassErrorInner::InvalidIndirectBuffer(buffer_id))
|
||||
.map_pass_err(scope)?;
|
||||
check_buffer_usage(indirect_buffer.usage, BufferUsage::INDIRECT)
|
||||
.map_pass_err(scope)?;
|
||||
let &(ref buf_raw, _) = indirect_buffer
|
||||
.raw
|
||||
.as_ref()
|
||||
.ok_or(ComputePassError::InvalidIndirectBuffer(buffer_id))?;
|
||||
.ok_or(ComputePassErrorInner::InvalidIndirectBuffer(buffer_id))
|
||||
.map_pass_err(scope)?;
|
||||
|
||||
state.flush_states(
|
||||
raw,
|
||||
&mut cmd_buf.trackers,
|
||||
&*bind_group_guard,
|
||||
&*buffer_guard,
|
||||
&*texture_guard,
|
||||
)?;
|
||||
state
|
||||
.flush_states(
|
||||
raw,
|
||||
&mut cmd_buf.trackers,
|
||||
&*bind_group_guard,
|
||||
&*buffer_guard,
|
||||
&*texture_guard,
|
||||
)
|
||||
.map_pass_err(scope)?;
|
||||
unsafe {
|
||||
raw.dispatch_indirect(buf_raw, offset);
|
||||
}
|
||||
@@ -440,8 +491,11 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
|
||||
base.string_data = &base.string_data[len..];
|
||||
}
|
||||
ComputeCommand::PopDebugGroup => {
|
||||
let scope = PassErrorScope::PopDebugGroup;
|
||||
|
||||
if state.debug_scope_depth == 0 {
|
||||
return Err(ComputePassError::InvalidPopDebugGroup);
|
||||
return Err(ComputePassErrorInner::InvalidPopDebugGroup)
|
||||
.map_pass_err(scope);
|
||||
}
|
||||
state.debug_scope_depth -= 1;
|
||||
unsafe {
|
||||
|
||||
@@ -292,3 +292,45 @@ impl<T: Copy + PartialEq> StateChange<T> {
|
||||
self.last_state = None;
|
||||
}
|
||||
}
|
||||
|
||||
trait MapPassErr<T, O> {
|
||||
fn map_pass_err(self, scope: PassErrorScope) -> Result<T, O>;
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, Error)]
|
||||
enum PassErrorScope {
|
||||
#[error("In a bundle parameter")]
|
||||
Bundle,
|
||||
#[error("In a pass parameter")]
|
||||
Pass,
|
||||
#[error("In a set_bind_group command")]
|
||||
SetBindGroup,
|
||||
#[error("In a set_pipeline command")]
|
||||
SetPipeline,
|
||||
#[error("In a set_push_constant command")]
|
||||
SetPushConstant,
|
||||
#[error("In a set_vertex_buffer command")]
|
||||
SetVertexBuffer,
|
||||
#[error("In a set_index_buffer command")]
|
||||
SetIndexBuffer,
|
||||
#[error("In a set_viewport command")]
|
||||
SetViewport,
|
||||
#[error("In a set_scissor_rect command")]
|
||||
SetScissorRect,
|
||||
#[error("In a draw command")]
|
||||
Draw,
|
||||
#[error("In a draw_indexed command")]
|
||||
DrawIndexed,
|
||||
#[error("In a draw_indirect command")]
|
||||
DrawIndirect,
|
||||
#[error("In a draw_indexed_indirect command")]
|
||||
DrawIndexedIndirect,
|
||||
#[error("In a execute_bundle command")]
|
||||
ExecuteBundle,
|
||||
#[error("In a dispatch command")]
|
||||
Dispatch,
|
||||
#[error("In a dispatch_indirect command")]
|
||||
DispatchIndirect,
|
||||
#[error("In a pop_debug_group command")]
|
||||
PopDebugGroup,
|
||||
}
|
||||
+171
-82
@@ -7,7 +7,7 @@ use crate::{
|
||||
command::{
|
||||
bind::{Binder, LayoutChange},
|
||||
BasePass, BasePassRef, CommandBuffer, CommandEncoderError, DrawError, ExecutionError,
|
||||
RenderCommand, RenderCommandError, StateChange,
|
||||
MapPassErr, PassErrorScope, RenderCommand, RenderCommandError, StateChange,
|
||||
},
|
||||
conv,
|
||||
device::{
|
||||
@@ -116,18 +116,18 @@ pub struct DepthStencilAttachmentDescriptor {
|
||||
}
|
||||
|
||||
impl DepthStencilAttachmentDescriptor {
|
||||
fn is_read_only(&self, aspects: hal::format::Aspects) -> Result<bool, RenderPassError> {
|
||||
fn is_read_only(&self, aspects: hal::format::Aspects) -> Result<bool, RenderPassErrorInner> {
|
||||
if aspects.contains(hal::format::Aspects::DEPTH) && !self.depth.read_only {
|
||||
return Ok(false);
|
||||
}
|
||||
if (self.depth.load_op, self.depth.store_op) != (LoadOp::Load, StoreOp::Store) {
|
||||
return Err(RenderPassError::InvalidDepthOps);
|
||||
return Err(RenderPassErrorInner::InvalidDepthOps);
|
||||
}
|
||||
if aspects.contains(hal::format::Aspects::STENCIL) && !self.stencil.read_only {
|
||||
return Ok(false);
|
||||
}
|
||||
if (self.stencil.load_op, self.stencil.store_op) != (LoadOp::Load, StoreOp::Store) {
|
||||
return Err(RenderPassError::InvalidStencilOps);
|
||||
return Err(RenderPassErrorInner::InvalidStencilOps);
|
||||
}
|
||||
Ok(true)
|
||||
}
|
||||
@@ -318,7 +318,7 @@ impl State {
|
||||
|
||||
/// Error encountered when performing a render pass.
|
||||
#[derive(Clone, Debug, Error)]
|
||||
pub enum RenderPassError {
|
||||
pub(super) enum RenderPassErrorInner {
|
||||
#[error(transparent)]
|
||||
Encoder(#[from] CommandEncoderError),
|
||||
#[error("attachment texture view {0:?} is invalid")]
|
||||
@@ -380,24 +380,45 @@ pub enum RenderPassError {
|
||||
Bind(#[from] BindError),
|
||||
}
|
||||
|
||||
impl From<MissingBufferUsageError> for RenderPassError {
|
||||
impl From<MissingBufferUsageError> for RenderPassErrorInner {
|
||||
fn from(error: MissingBufferUsageError) -> Self {
|
||||
Self::RenderCommand(error.into())
|
||||
}
|
||||
}
|
||||
|
||||
impl From<MissingTextureUsageError> for RenderPassError {
|
||||
impl From<MissingTextureUsageError> for RenderPassErrorInner {
|
||||
fn from(error: MissingTextureUsageError) -> Self {
|
||||
Self::RenderCommand(error.into())
|
||||
}
|
||||
}
|
||||
|
||||
/// Error encountered when performing a render pass.
|
||||
#[derive(Clone, Debug, Error)]
|
||||
#[error("{scope}")]
|
||||
pub struct RenderPassError {
|
||||
scope: PassErrorScope,
|
||||
#[source]
|
||||
inner: RenderPassErrorInner,
|
||||
}
|
||||
|
||||
impl<T, E> MapPassErr<T, RenderPassError> for Result<T, E>
|
||||
where
|
||||
E: Into<RenderPassErrorInner>,
|
||||
{
|
||||
fn map_pass_err(self, scope: PassErrorScope) -> Result<T, RenderPassError> {
|
||||
self.map_err(|inner| RenderPassError {
|
||||
scope,
|
||||
inner: inner.into(),
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
fn check_device_features(
|
||||
actual: wgt::Features,
|
||||
expected: wgt::Features,
|
||||
) -> Result<(), RenderPassError> {
|
||||
) -> Result<(), RenderPassErrorInner> {
|
||||
if !actual.contains(expected) {
|
||||
Err(RenderPassError::MissingDeviceFeatures(expected))
|
||||
Err(RenderPassErrorInner::MissingDeviceFeatures(expected))
|
||||
} else {
|
||||
Ok(())
|
||||
}
|
||||
@@ -428,6 +449,7 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
|
||||
depth_stencil_attachment: Option<&DepthStencilAttachmentDescriptor>,
|
||||
) -> Result<(), RenderPassError> {
|
||||
span!(_guard, INFO, "CommandEncoder::run_render_pass");
|
||||
let scope = PassErrorScope::Pass;
|
||||
|
||||
let hub = B::hub(self);
|
||||
let mut token = Token::root();
|
||||
@@ -436,7 +458,8 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
|
||||
let (mut cmb_guard, mut token) = hub.command_buffers.write(&mut token);
|
||||
|
||||
let mut trackers = TrackerSet::new(B::VARIANT);
|
||||
let cmd_buf = CommandBuffer::get_encoder(&mut *cmb_guard, encoder_id)?;
|
||||
let cmd_buf =
|
||||
CommandBuffer::get_encoder(&mut *cmb_guard, encoder_id).map_pass_err(scope)?;
|
||||
let device = &device_guard[cmd_buf.device_id.value];
|
||||
let mut raw = device.cmd_allocator.extend(cmd_buf);
|
||||
|
||||
@@ -492,7 +515,7 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
|
||||
let mut add_view = |view: &TextureView<B>| {
|
||||
if let Some(ex) = extent {
|
||||
if ex != view.extent {
|
||||
return Err(RenderPassError::ExtentStateMismatch {
|
||||
return Err(RenderPassErrorInner::ExtentStateMismatch {
|
||||
state_extent: ex,
|
||||
view_extent: view.extent,
|
||||
});
|
||||
@@ -503,7 +526,7 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
|
||||
if sample_count == 0 {
|
||||
sample_count = view.samples;
|
||||
} else if sample_count != view.samples {
|
||||
return Err(RenderPassError::SampleCountMismatch {
|
||||
return Err(RenderPassErrorInner::SampleCountMismatch {
|
||||
actual: view.samples,
|
||||
expected: sample_count,
|
||||
});
|
||||
@@ -521,14 +544,16 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
|
||||
let view = trackers
|
||||
.views
|
||||
.use_extend(&*view_guard, at.attachment, (), ())
|
||||
.map_err(|_| RenderPassError::InvalidAttachment(at.attachment))?;
|
||||
add_view(view)?;
|
||||
.map_err(|_| RenderPassErrorInner::InvalidAttachment(at.attachment))
|
||||
.map_pass_err(scope)?;
|
||||
add_view(view).map_pass_err(scope)?;
|
||||
depth_stencil_aspects = view.aspects;
|
||||
|
||||
let source_id = match view.inner {
|
||||
TextureViewInner::Native { ref source_id, .. } => source_id,
|
||||
TextureViewInner::SwapChain { .. } => {
|
||||
return Err(RenderPassError::SwapChainImageAsDepthStencil)
|
||||
return Err(RenderPassErrorInner::SwapChainImageAsDepthStencil)
|
||||
.map_pass_err(scope)
|
||||
}
|
||||
};
|
||||
|
||||
@@ -536,7 +561,7 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
|
||||
let previous_use = base_trackers
|
||||
.textures
|
||||
.query(source_id.value, view.selector.clone());
|
||||
let new_use = if at.is_read_only(view.aspects)? {
|
||||
let new_use = if at.is_read_only(view.aspects).map_pass_err(scope)? {
|
||||
is_ds_read_only = true;
|
||||
TextureUse::ATTACHMENT_READ
|
||||
} else {
|
||||
@@ -577,8 +602,9 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
|
||||
let view = trackers
|
||||
.views
|
||||
.use_extend(&*view_guard, at.attachment, (), ())
|
||||
.map_err(|_| RenderPassError::InvalidAttachment(at.attachment))?;
|
||||
add_view(view)?;
|
||||
.map_err(|_| RenderPassErrorInner::InvalidAttachment(at.attachment))
|
||||
.map_pass_err(scope)?;
|
||||
add_view(view).map_pass_err(scope)?;
|
||||
|
||||
valid_attachment &= *attachment_width.get_or_insert(view.extent.width)
|
||||
== view.extent.width
|
||||
@@ -611,7 +637,8 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
|
||||
TextureViewInner::SwapChain { ref source_id, .. } => {
|
||||
if let Some((ref sc_id, _)) = cmd_buf.used_swap_chain {
|
||||
if source_id.value != sc_id.value {
|
||||
return Err(RenderPassError::SwapChainMismatch);
|
||||
return Err(RenderPassErrorInner::SwapChainMismatch)
|
||||
.map_pass_err(scope);
|
||||
}
|
||||
} else {
|
||||
assert!(used_swap_chain.is_none());
|
||||
@@ -641,25 +668,29 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
|
||||
}
|
||||
|
||||
if !valid_attachment {
|
||||
Err(RenderPassError::MismatchAttachments)?
|
||||
return Err(RenderPassErrorInner::MismatchAttachments).map_pass_err(scope);
|
||||
}
|
||||
|
||||
for resolve_target in color_attachments.iter().flat_map(|at| at.resolve_target) {
|
||||
let view = trackers
|
||||
.views
|
||||
.use_extend(&*view_guard, resolve_target, (), ())
|
||||
.map_err(|_| RenderPassError::InvalidAttachment(resolve_target))?;
|
||||
.map_err(|_| RenderPassErrorInner::InvalidAttachment(resolve_target))
|
||||
.map_pass_err(scope)?;
|
||||
if extent != Some(view.extent) {
|
||||
return Err(RenderPassError::ExtentStateMismatch {
|
||||
return Err(RenderPassErrorInner::ExtentStateMismatch {
|
||||
state_extent: extent.unwrap_or_default(),
|
||||
view_extent: view.extent,
|
||||
});
|
||||
})
|
||||
.map_pass_err(scope);
|
||||
}
|
||||
if view.samples != 1 {
|
||||
return Err(RenderPassError::InvalidResolveTargetSampleCount);
|
||||
return Err(RenderPassErrorInner::InvalidResolveTargetSampleCount)
|
||||
.map_pass_err(scope);
|
||||
}
|
||||
if sample_count == 1 {
|
||||
return Err(RenderPassError::InvalidResolveSourceSampleCount);
|
||||
return Err(RenderPassErrorInner::InvalidResolveSourceSampleCount)
|
||||
.map_pass_err(scope);
|
||||
}
|
||||
|
||||
let layouts = match view.inner {
|
||||
@@ -688,7 +719,8 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
|
||||
TextureViewInner::SwapChain { ref source_id, .. } => {
|
||||
if let Some((ref sc_id, _)) = cmd_buf.used_swap_chain {
|
||||
if source_id.value != sc_id.value {
|
||||
return Err(RenderPassError::SwapChainMismatch);
|
||||
return Err(RenderPassErrorInner::SwapChainMismatch)
|
||||
.map_pass_err(scope);
|
||||
}
|
||||
} else {
|
||||
assert!(used_swap_chain.is_none());
|
||||
@@ -722,7 +754,8 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
|
||||
};
|
||||
|
||||
if sample_count & sample_count_limit == 0 {
|
||||
return Err(RenderPassError::InvalidSampleCount(sample_count));
|
||||
return Err(RenderPassErrorInner::InvalidSampleCount(sample_count))
|
||||
.map_pass_err(scope);
|
||||
}
|
||||
|
||||
let mut render_pass_cache = device.render_passes.lock();
|
||||
@@ -833,7 +866,8 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
|
||||
device
|
||||
.raw
|
||||
.create_framebuffer(&render_pass, attachments, extent.unwrap())
|
||||
.or(Err(RenderPassError::OutOfMemory))?
|
||||
.or(Err(RenderPassErrorInner::OutOfMemory))
|
||||
.map_pass_err(scope)?
|
||||
};
|
||||
cmd_buf.used_swap_chain = Some((sc_id, framebuffer));
|
||||
&mut cmd_buf.used_swap_chain.as_mut().unwrap().1
|
||||
@@ -863,7 +897,8 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
|
||||
attachments,
|
||||
extent.unwrap(),
|
||||
)
|
||||
.or(Err(RenderPassError::OutOfMemory))?
|
||||
.or(Err(RenderPassErrorInner::OutOfMemory))
|
||||
.map_pass_err(scope)?
|
||||
}
|
||||
};
|
||||
e.insert(fb)
|
||||
@@ -968,13 +1003,14 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
|
||||
num_dynamic_offsets,
|
||||
bind_group_id,
|
||||
} => {
|
||||
let scope = PassErrorScope::SetBindGroup;
|
||||
let max_bind_groups = device.limits.max_bind_groups;
|
||||
if (index as u32) >= max_bind_groups {
|
||||
return Err(RenderCommandError::BindGroupIndexOutOfRange {
|
||||
index,
|
||||
max: max_bind_groups,
|
||||
}
|
||||
.into());
|
||||
})
|
||||
.map_pass_err(scope);
|
||||
}
|
||||
|
||||
temp_offsets.clear();
|
||||
@@ -988,9 +1024,11 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
|
||||
.unwrap();
|
||||
bind_group
|
||||
.validate_dynamic_bindings(&temp_offsets)
|
||||
.map_err(RenderPassError::from)?;
|
||||
.map_pass_err(scope)?;
|
||||
|
||||
trackers.merge_extend(&bind_group.used)?;
|
||||
trackers
|
||||
.merge_extend(&bind_group.used)
|
||||
.map_pass_err(scope)?;
|
||||
|
||||
if let Some((pipeline_layout_id, follow_ups)) = state.binder.provide_entry(
|
||||
index as usize,
|
||||
@@ -1017,6 +1055,7 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
|
||||
};
|
||||
}
|
||||
RenderCommand::SetPipeline(pipeline_id) => {
|
||||
let scope = PassErrorScope::SetPipeline;
|
||||
if state.pipeline.set_and_check_redundant(pipeline_id) {
|
||||
continue;
|
||||
}
|
||||
@@ -1024,18 +1063,21 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
|
||||
let pipeline = trackers
|
||||
.render_pipes
|
||||
.use_extend(&*pipeline_guard, pipeline_id, (), ())
|
||||
.map_err(|_| RenderCommandError::InvalidPipeline(pipeline_id))?;
|
||||
.map_err(|_| RenderCommandError::InvalidPipeline(pipeline_id))
|
||||
.map_pass_err(scope)?;
|
||||
|
||||
context
|
||||
.check_compatible(&pipeline.pass_context)
|
||||
.map_err(RenderCommandError::IncompatiblePipeline)?;
|
||||
.map_err(RenderCommandError::IncompatiblePipeline)
|
||||
.map_pass_err(scope)?;
|
||||
|
||||
state.pipeline_flags = pipeline.flags;
|
||||
|
||||
if pipeline.flags.contains(PipelineFlags::WRITES_DEPTH_STENCIL)
|
||||
&& is_ds_read_only
|
||||
{
|
||||
return Err(RenderCommandError::IncompatibleReadOnlyDepthStencil.into());
|
||||
return Err(RenderCommandError::IncompatibleReadOnlyDepthStencil)
|
||||
.map_pass_err(scope);
|
||||
}
|
||||
|
||||
state
|
||||
@@ -1155,15 +1197,18 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
|
||||
offset,
|
||||
size,
|
||||
} => {
|
||||
let scope = PassErrorScope::SetIndexBuffer;
|
||||
let buffer = trackers
|
||||
.buffers
|
||||
.use_extend(&*buffer_guard, buffer_id, (), BufferUse::INDEX)
|
||||
.map_err(|e| RenderCommandError::Buffer(buffer_id, e))?;
|
||||
check_buffer_usage(buffer.usage, BufferUsage::INDEX)?;
|
||||
.map_err(|e| RenderCommandError::Buffer(buffer_id, e))
|
||||
.map_pass_err(scope)?;
|
||||
check_buffer_usage(buffer.usage, BufferUsage::INDEX).map_pass_err(scope)?;
|
||||
let &(ref buf_raw, _) = buffer
|
||||
.raw
|
||||
.as_ref()
|
||||
.ok_or(RenderCommandError::DestroyedBuffer(buffer_id))?;
|
||||
.ok_or(RenderCommandError::DestroyedBuffer(buffer_id))
|
||||
.map_pass_err(scope)?;
|
||||
|
||||
let end = match size {
|
||||
Some(s) => offset + s.get(),
|
||||
@@ -1191,15 +1236,18 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
|
||||
offset,
|
||||
size,
|
||||
} => {
|
||||
let scope = PassErrorScope::SetVertexBuffer;
|
||||
let buffer = trackers
|
||||
.buffers
|
||||
.use_extend(&*buffer_guard, buffer_id, (), BufferUse::VERTEX)
|
||||
.map_err(|e| RenderCommandError::Buffer(buffer_id, e))?;
|
||||
check_buffer_usage(buffer.usage, BufferUsage::VERTEX)?;
|
||||
.map_err(|e| RenderCommandError::Buffer(buffer_id, e))
|
||||
.map_pass_err(scope)?;
|
||||
check_buffer_usage(buffer.usage, BufferUsage::VERTEX).map_pass_err(scope)?;
|
||||
let &(ref buf_raw, _) = buffer
|
||||
.raw
|
||||
.as_ref()
|
||||
.ok_or(RenderCommandError::DestroyedBuffer(buffer_id))?;
|
||||
.ok_or(RenderCommandError::DestroyedBuffer(buffer_id))
|
||||
.map_pass_err(scope)?;
|
||||
|
||||
let empty_slots = (1 + slot as usize).saturating_sub(state.vertex.inputs.len());
|
||||
state
|
||||
@@ -1242,6 +1290,7 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
|
||||
depth_min,
|
||||
depth_max,
|
||||
} => {
|
||||
let scope = PassErrorScope::SetViewport;
|
||||
use std::{convert::TryFrom, i16};
|
||||
if rect.w <= 0.0
|
||||
|| rect.h <= 0.0
|
||||
@@ -1250,7 +1299,7 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
|
||||
|| depth_max < 0.0
|
||||
|| depth_max > 1.0
|
||||
{
|
||||
Err(RenderCommandError::InvalidViewport)?
|
||||
return Err(RenderCommandError::InvalidViewport).map_pass_err(scope);
|
||||
}
|
||||
let r = hal::pso::Rect {
|
||||
x: i16::try_from(rect.x.round() as i64).unwrap_or(0),
|
||||
@@ -1274,8 +1323,10 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
|
||||
size_bytes,
|
||||
values_offset,
|
||||
} => {
|
||||
let values_offset =
|
||||
values_offset.ok_or(RenderPassError::InvalidValuesOffset)?;
|
||||
let scope = PassErrorScope::SetPushConstant;
|
||||
let values_offset = values_offset
|
||||
.ok_or(RenderPassErrorInner::InvalidValuesOffset)
|
||||
.map_pass_err(scope)?;
|
||||
|
||||
let end_offset_bytes = offset + size_bytes;
|
||||
let values_end_offset =
|
||||
@@ -1286,12 +1337,14 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
|
||||
let pipeline_layout_id = state
|
||||
.binder
|
||||
.pipeline_layout_id
|
||||
.ok_or(DrawError::MissingPipeline)?;
|
||||
.ok_or(DrawError::MissingPipeline)
|
||||
.map_pass_err(scope)?;
|
||||
let pipeline_layout = &pipeline_layout_guard[pipeline_layout_id];
|
||||
|
||||
pipeline_layout
|
||||
.validate_push_constant_ranges(stages, offset, end_offset_bytes)
|
||||
.map_err(RenderCommandError::from)?;
|
||||
.map_err(RenderCommandError::from)
|
||||
.map_pass_err(scope)?;
|
||||
|
||||
unsafe {
|
||||
raw.push_graphics_constants(
|
||||
@@ -1303,13 +1356,14 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
|
||||
}
|
||||
}
|
||||
RenderCommand::SetScissor(ref rect) => {
|
||||
let scope = PassErrorScope::SetScissorRect;
|
||||
use std::{convert::TryFrom, i16};
|
||||
if rect.w == 0
|
||||
|| rect.h == 0
|
||||
|| rect.x + rect.w > attachment_width.unwrap()
|
||||
|| rect.y + rect.h > attachment_height.unwrap()
|
||||
{
|
||||
Err(RenderCommandError::InvalidScissorRect)?
|
||||
return Err(RenderCommandError::InvalidScissorRect).map_pass_err(scope);
|
||||
}
|
||||
let r = hal::pso::Rect {
|
||||
x: i16::try_from(rect.x).unwrap_or(0),
|
||||
@@ -1327,22 +1381,25 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
|
||||
first_vertex,
|
||||
first_instance,
|
||||
} => {
|
||||
state.is_ready()?;
|
||||
let scope = PassErrorScope::Draw;
|
||||
state.is_ready().map_pass_err(scope)?;
|
||||
let last_vertex = first_vertex + vertex_count;
|
||||
let vertex_limit = state.vertex.vertex_limit;
|
||||
if last_vertex > vertex_limit {
|
||||
Err(DrawError::VertexBeyondLimit {
|
||||
return Err(DrawError::VertexBeyondLimit {
|
||||
last_vertex,
|
||||
vertex_limit,
|
||||
})?
|
||||
})
|
||||
.map_pass_err(scope);
|
||||
}
|
||||
let last_instance = first_instance + instance_count;
|
||||
let instance_limit = state.vertex.instance_limit;
|
||||
if last_instance > instance_limit {
|
||||
Err(DrawError::InstanceBeyondLimit {
|
||||
return Err(DrawError::InstanceBeyondLimit {
|
||||
last_instance,
|
||||
instance_limit,
|
||||
})?
|
||||
})
|
||||
.map_pass_err(scope);
|
||||
}
|
||||
|
||||
unsafe {
|
||||
@@ -1359,24 +1416,27 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
|
||||
base_vertex,
|
||||
first_instance,
|
||||
} => {
|
||||
state.is_ready()?;
|
||||
let scope = PassErrorScope::DrawIndexed;
|
||||
state.is_ready().map_pass_err(scope)?;
|
||||
|
||||
//TODO: validate that base_vertex + max_index() is within the provided range
|
||||
let last_index = first_index + index_count;
|
||||
let index_limit = state.index.limit;
|
||||
if last_index > index_limit {
|
||||
Err(DrawError::IndexBeyondLimit {
|
||||
return Err(DrawError::IndexBeyondLimit {
|
||||
last_index,
|
||||
index_limit,
|
||||
})?
|
||||
})
|
||||
.map_pass_err(scope);
|
||||
}
|
||||
let last_instance = first_instance + instance_count;
|
||||
let instance_limit = state.vertex.instance_limit;
|
||||
if last_instance > instance_limit {
|
||||
Err(DrawError::InstanceBeyondLimit {
|
||||
return Err(DrawError::InstanceBeyondLimit {
|
||||
last_instance,
|
||||
instance_limit,
|
||||
})?
|
||||
})
|
||||
.map_pass_err(scope);
|
||||
}
|
||||
|
||||
unsafe {
|
||||
@@ -1393,7 +1453,12 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
|
||||
count,
|
||||
indexed,
|
||||
} => {
|
||||
state.is_ready()?;
|
||||
let scope = if indexed {
|
||||
PassErrorScope::DrawIndexedIndirect
|
||||
} else {
|
||||
PassErrorScope::DrawIndirect
|
||||
};
|
||||
state.is_ready().map_pass_err(scope)?;
|
||||
|
||||
let stride = match indexed {
|
||||
false => 16,
|
||||
@@ -1401,31 +1466,36 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
|
||||
};
|
||||
|
||||
if count.is_some() {
|
||||
check_device_features(device.features, wgt::Features::MULTI_DRAW_INDIRECT)?;
|
||||
check_device_features(device.features, wgt::Features::MULTI_DRAW_INDIRECT)
|
||||
.map_pass_err(scope)?;
|
||||
}
|
||||
|
||||
let indirect_buffer = trackers
|
||||
.buffers
|
||||
.use_extend(&*buffer_guard, buffer_id, (), BufferUse::INDIRECT)
|
||||
.map_err(|e| RenderCommandError::Buffer(buffer_id, e))?;
|
||||
check_buffer_usage(indirect_buffer.usage, BufferUsage::INDIRECT)?;
|
||||
.map_err(|e| RenderCommandError::Buffer(buffer_id, e))
|
||||
.map_pass_err(scope)?;
|
||||
check_buffer_usage(indirect_buffer.usage, BufferUsage::INDIRECT)
|
||||
.map_pass_err(scope)?;
|
||||
let &(ref indirect_raw, _) = indirect_buffer
|
||||
.raw
|
||||
.as_ref()
|
||||
.ok_or(RenderCommandError::DestroyedBuffer(buffer_id))?;
|
||||
.ok_or(RenderCommandError::DestroyedBuffer(buffer_id))
|
||||
.map_pass_err(scope)?;
|
||||
|
||||
let actual_count = count.map_or(1, |c| c.get());
|
||||
|
||||
let begin_offset = offset;
|
||||
let end_offset = offset + stride * actual_count as u64;
|
||||
if end_offset > indirect_buffer.size {
|
||||
return Err(RenderPassError::IndirectBufferOverrun {
|
||||
return Err(RenderPassErrorInner::IndirectBufferOverrun {
|
||||
offset,
|
||||
count,
|
||||
begin_offset,
|
||||
end_offset,
|
||||
buffer_size: indirect_buffer.size,
|
||||
});
|
||||
})
|
||||
.map_pass_err(scope);
|
||||
}
|
||||
|
||||
match indexed {
|
||||
@@ -1450,7 +1520,12 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
|
||||
max_count,
|
||||
indexed,
|
||||
} => {
|
||||
state.is_ready()?;
|
||||
let scope = if indexed {
|
||||
PassErrorScope::DrawIndexedIndirect
|
||||
} else {
|
||||
PassErrorScope::DrawIndirect
|
||||
};
|
||||
state.is_ready().map_pass_err(scope)?;
|
||||
|
||||
let stride = match indexed {
|
||||
false => 16,
|
||||
@@ -1460,48 +1535,57 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
|
||||
check_device_features(
|
||||
device.features,
|
||||
wgt::Features::MULTI_DRAW_INDIRECT_COUNT,
|
||||
)?;
|
||||
)
|
||||
.map_pass_err(scope)?;
|
||||
|
||||
let indirect_buffer = trackers
|
||||
.buffers
|
||||
.use_extend(&*buffer_guard, buffer_id, (), BufferUse::INDIRECT)
|
||||
.map_err(|e| RenderCommandError::Buffer(buffer_id, e))?;
|
||||
check_buffer_usage(indirect_buffer.usage, BufferUsage::INDIRECT)?;
|
||||
.map_err(|e| RenderCommandError::Buffer(buffer_id, e))
|
||||
.map_pass_err(scope)?;
|
||||
check_buffer_usage(indirect_buffer.usage, BufferUsage::INDIRECT)
|
||||
.map_pass_err(scope)?;
|
||||
let &(ref indirect_raw, _) = indirect_buffer
|
||||
.raw
|
||||
.as_ref()
|
||||
.ok_or(RenderCommandError::DestroyedBuffer(buffer_id))?;
|
||||
.ok_or(RenderCommandError::DestroyedBuffer(buffer_id))
|
||||
.map_pass_err(scope)?;
|
||||
|
||||
let count_buffer = trackers
|
||||
.buffers
|
||||
.use_extend(&*buffer_guard, count_buffer_id, (), BufferUse::INDIRECT)
|
||||
.map_err(|e| RenderCommandError::Buffer(count_buffer_id, e))?;
|
||||
check_buffer_usage(count_buffer.usage, BufferUsage::INDIRECT)?;
|
||||
.map_err(|e| RenderCommandError::Buffer(count_buffer_id, e))
|
||||
.map_pass_err(scope)?;
|
||||
check_buffer_usage(count_buffer.usage, BufferUsage::INDIRECT)
|
||||
.map_pass_err(scope)?;
|
||||
let &(ref count_raw, _) = count_buffer
|
||||
.raw
|
||||
.as_ref()
|
||||
.ok_or(RenderCommandError::DestroyedBuffer(count_buffer_id))?;
|
||||
.ok_or(RenderCommandError::DestroyedBuffer(count_buffer_id))
|
||||
.map_pass_err(scope)?;
|
||||
|
||||
let begin_offset = offset;
|
||||
let end_offset = offset + stride * max_count as u64;
|
||||
if end_offset > indirect_buffer.size {
|
||||
return Err(RenderPassError::IndirectBufferOverrun {
|
||||
return Err(RenderPassErrorInner::IndirectBufferOverrun {
|
||||
offset,
|
||||
count: None,
|
||||
begin_offset,
|
||||
end_offset,
|
||||
buffer_size: indirect_buffer.size,
|
||||
});
|
||||
})
|
||||
.map_pass_err(scope);
|
||||
}
|
||||
|
||||
let begin_count_offset = count_buffer_offset;
|
||||
let end_count_offset = count_buffer_offset + 4;
|
||||
if end_count_offset > count_buffer.size {
|
||||
return Err(RenderPassError::IndirectCountBufferOverrun {
|
||||
return Err(RenderPassErrorInner::IndirectCountBufferOverrun {
|
||||
begin_count_offset,
|
||||
end_count_offset,
|
||||
count_buffer_size: count_buffer.size,
|
||||
});
|
||||
})
|
||||
.map_pass_err(scope);
|
||||
}
|
||||
|
||||
match indexed {
|
||||
@@ -1536,8 +1620,9 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
|
||||
base.string_data = &base.string_data[len..];
|
||||
}
|
||||
RenderCommand::PopDebugGroup => {
|
||||
let scope = PassErrorScope::PopDebugGroup;
|
||||
if state.debug_scope_depth == 0 {
|
||||
return Err(RenderPassError::InvalidPopDebugGroup);
|
||||
return Err(RenderPassErrorInner::InvalidPopDebugGroup).map_pass_err(scope);
|
||||
}
|
||||
state.debug_scope_depth -= 1;
|
||||
unsafe {
|
||||
@@ -1552,6 +1637,7 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
|
||||
base.string_data = &base.string_data[len..];
|
||||
}
|
||||
RenderCommand::ExecuteBundle(bundle_id) => {
|
||||
let scope = PassErrorScope::ExecuteBundle;
|
||||
let bundle = trackers
|
||||
.bundles
|
||||
.use_extend(&*bundle_guard, bundle_id, (), ())
|
||||
@@ -1559,7 +1645,8 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
|
||||
|
||||
context
|
||||
.check_compatible(&bundle.context)
|
||||
.map_err(RenderPassError::IncompatibleRenderBundle)?;
|
||||
.map_err(RenderPassErrorInner::IncompatibleRenderBundle)
|
||||
.map_pass_err(scope)?;
|
||||
|
||||
unsafe {
|
||||
bundle.execute(
|
||||
@@ -1574,9 +1661,10 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
|
||||
ExecutionError::DestroyedBuffer(id) => {
|
||||
RenderCommandError::DestroyedBuffer(id)
|
||||
}
|
||||
})?;
|
||||
})
|
||||
.map_pass_err(scope)?;
|
||||
|
||||
trackers.merge_extend(&bundle.used)?;
|
||||
trackers.merge_extend(&bundle.used).map_pass_err(scope)?;
|
||||
state.reset_bundle();
|
||||
}
|
||||
}
|
||||
@@ -1589,7 +1677,8 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
|
||||
|
||||
for ra in render_attachments {
|
||||
let texture = &texture_guard[ra.texture_id.value];
|
||||
check_texture_usage(texture.usage, TextureUsage::RENDER_ATTACHMENT)?;
|
||||
check_texture_usage(texture.usage, TextureUsage::RENDER_ATTACHMENT)
|
||||
.map_pass_err(scope)?;
|
||||
|
||||
// the tracker set of the pass is always in "extend" mode
|
||||
trackers
|
||||
|
||||
Reference in new issue
Block a user