diff --git a/deno_webgpu/command_encoder.rs b/deno_webgpu/command_encoder.rs index 23454938b..7bd464f17 100644 --- a/deno_webgpu/command_encoder.rs +++ b/deno_webgpu/command_encoder.rs @@ -132,13 +132,10 @@ impl GPUCommandEncoder { multiview_mask: NonZero::new(descriptor.multiview_mask), }; - let (render_pass, err) = + let render_pass = self.wgpu_command_encoder.begin_render_pass(wgpu_descriptor); - self.error_handler.push_error(err); - Ok(GPURenderPassEncoder { - error_handler: self.error_handler.clone(), render_pass: RefCell::new(render_pass), label: descriptor.label, }) diff --git a/deno_webgpu/device.rs b/deno_webgpu/device.rs index 4b61fc9eb..968fa9b62 100644 --- a/deno_webgpu/device.rs +++ b/deno_webgpu/device.rs @@ -649,7 +649,6 @@ impl GPUDevice { self.error_handler.push_error(err); GPURenderBundleEncoder { - error_handler: self.error_handler.clone(), encoder: RefCell::new(encoder), label: descriptor.label, } diff --git a/deno_webgpu/render_bundle.rs b/deno_webgpu/render_bundle.rs index babde177b..493d90594 100644 --- a/deno_webgpu/render_bundle.rs +++ b/deno_webgpu/render_bundle.rs @@ -23,8 +23,6 @@ use crate::get_data_slice; use crate::texture::GPUTextureFormat; pub struct GPURenderBundleEncoder { - pub error_handler: super::error::ErrorHandler, - pub encoder: RefCell>, pub label: String, } @@ -62,10 +60,7 @@ impl GPURenderBundleEncoder { let wgpu_descriptor = wgpu_core::command::RenderBundleDescriptor { label: crate::transform_label(descriptor.label.clone()), }; - let (wgpu_render_bundle, err) = - self.encoder.borrow_mut().finish(&wgpu_descriptor); - - self.error_handler.push_error(err); + let wgpu_render_bundle = self.encoder.borrow_mut().finish(&wgpu_descriptor); GPURenderBundle { wgpu_render_bundle, @@ -81,9 +76,7 @@ impl GPURenderBundleEncoder { let mut encoder = self.encoder.borrow_mut(); let encoder = encoder.as_mut(); - let err = encoder.push_debug_group(&group_label).err(); - - self.error_handler.push_error(err); + encoder.push_debug_group(&group_label); Ok(()) } @@ -94,9 +87,7 @@ impl GPURenderBundleEncoder { let mut encoder = self.encoder.borrow_mut(); let encoder = encoder.as_mut(); - let err = encoder.pop_debug_group().err(); - - self.error_handler.push_error(err); + encoder.pop_debug_group(); Ok(()) } @@ -109,9 +100,8 @@ impl GPURenderBundleEncoder { let mut encoder = self.encoder.borrow_mut(); let encoder = encoder.as_mut(); - let err = encoder.insert_debug_marker(&marker_label).err(); + encoder.insert_debug_marker(&marker_label); - self.error_handler.push_error(err); Ok(()) } @@ -162,17 +152,13 @@ impl GPURenderBundleEncoder { let offsets = &data[start..(start + len)]; - let err = encoder - .set_bind_group( - index, - bind_group - .into_option() - .map(|bind_group| bind_group.wgpu_bind_group.clone()), - offsets, - ) - .err(); - - self.error_handler.push_error(err); + encoder.set_bind_group( + index, + bind_group + .into_option() + .map(|bind_group| bind_group.wgpu_bind_group.clone()), + offsets, + ); } else { let offsets = >>::convert( scope, @@ -186,17 +172,13 @@ impl GPURenderBundleEncoder { )? .unwrap_or_default(); - let err = encoder - .set_bind_group( - index, - bind_group - .into_option() - .map(|bind_group| bind_group.wgpu_bind_group.clone()), - &offsets, - ) - .err(); - - self.error_handler.push_error(err); + encoder.set_bind_group( + index, + bind_group + .into_option() + .map(|bind_group| bind_group.wgpu_bind_group.clone()), + &offsets, + ); } Ok(()) @@ -210,11 +192,8 @@ impl GPURenderBundleEncoder { let mut encoder = self.encoder.borrow_mut(); let encoder = encoder.as_mut(); - let err = encoder - .set_pipeline(pipeline.wgpu_render_pipeline.clone()) - .err(); + encoder.set_pipeline(pipeline.wgpu_render_pipeline.clone()); - self.error_handler.push_error(err); Ok(()) } @@ -230,16 +209,12 @@ impl GPURenderBundleEncoder { let mut encoder = self.encoder.borrow_mut(); let encoder = encoder.as_mut(); - let err = encoder - .set_index_buffer( - buffer.wgpu_buffer.clone(), - index_format.into(), - offset, - size.and_then(NonZeroU64::new), - ) - .err(); - - self.error_handler.push_error(err); + encoder.set_index_buffer( + buffer.wgpu_buffer.clone(), + index_format.into(), + offset, + size.and_then(NonZeroU64::new), + ); Ok(()) } @@ -256,17 +231,15 @@ impl GPURenderBundleEncoder { let mut encoder = self.encoder.borrow_mut(); let encoder = encoder.as_mut(); - let err = encoder - .set_vertex_buffer( - slot, - buffer - .into_option() - .map(|buffer| buffer.wgpu_buffer.clone()), - offset, - size.and_then(NonZeroU64::new), - ) - .err(); - self.error_handler.push_error(err); + encoder.set_vertex_buffer( + slot, + buffer + .into_option() + .map(|buffer| buffer.wgpu_buffer.clone()), + offset, + size.and_then(NonZeroU64::new), + ); + Ok(()) } @@ -282,10 +255,8 @@ impl GPURenderBundleEncoder { let mut encoder = self.encoder.borrow_mut(); let encoder = encoder.as_mut(); - let err = encoder - .draw(vertex_count, instance_count, first_vertex, first_instance) - .err(); - self.error_handler.push_error(err); + encoder.draw(vertex_count, instance_count, first_vertex, first_instance); + Ok(()) } @@ -302,16 +273,14 @@ impl GPURenderBundleEncoder { let mut encoder = self.encoder.borrow_mut(); let encoder = encoder.as_mut(); - let err = encoder - .draw_indexed( - index_count, - instance_count, - first_index, - base_vertex, - first_instance, - ) - .err(); - self.error_handler.push_error(err); + encoder.draw_indexed( + index_count, + instance_count, + first_index, + base_vertex, + first_instance, + ); + Ok(()) } @@ -325,10 +294,8 @@ impl GPURenderBundleEncoder { let mut encoder = self.encoder.borrow_mut(); let encoder = encoder.as_mut(); - let err = encoder - .draw_indirect(indirect_buffer.wgpu_buffer.clone(), indirect_offset) - .err(); - self.error_handler.push_error(err); + encoder.draw_indirect(indirect_buffer.wgpu_buffer.clone(), indirect_offset); + Ok(()) } @@ -342,13 +309,11 @@ impl GPURenderBundleEncoder { let mut encoder = self.encoder.borrow_mut(); let encoder = encoder.as_mut(); - let err = encoder - .draw_indexed_indirect( - indirect_buffer.wgpu_buffer.clone(), - indirect_offset, - ) - .err(); - self.error_handler.push_error(err); + encoder.draw_indexed_indirect( + indirect_buffer.wgpu_buffer.clone(), + indirect_offset, + ); + Ok(()) } @@ -367,8 +332,8 @@ impl GPURenderBundleEncoder { let mut encoder = self.encoder.borrow_mut(); let encoder = encoder.as_mut(); - let err = encoder.set_immediates(offset, data).err(); - self.error_handler.push_error(err); + encoder.set_immediates(offset, data); + Ok(()) } } diff --git a/deno_webgpu/render_pass.rs b/deno_webgpu/render_pass.rs index 80c3b93d2..741c411b4 100644 --- a/deno_webgpu/render_pass.rs +++ b/deno_webgpu/render_pass.rs @@ -29,8 +29,6 @@ use crate::texture::GPUTextureView; use crate::webidl::GPUColor; pub struct GPURenderPassEncoder { - pub error_handler: super::error::ErrorHandler, - pub render_pass: RefCell, pub label: String, } @@ -71,12 +69,10 @@ impl GPURenderPassEncoder { #[webidl] min_depth: f32, #[webidl] max_depth: f32, ) { - let err = self + self .render_pass .borrow_mut() - .set_viewport(x, y, width, height, min_depth, max_depth) - .err(); - self.error_handler.push_error(err); + .set_viewport(x, y, width, height, min_depth, max_depth); } #[required(4)] @@ -88,23 +84,19 @@ impl GPURenderPassEncoder { #[webidl(options(enforce_range = true))] width: u32, #[webidl(options(enforce_range = true))] height: u32, ) { - let err = self + self .render_pass .borrow_mut() - .set_scissor_rect(x, y, width, height) - .err(); - self.error_handler.push_error(err); + .set_scissor_rect(x, y, width, height); } #[required(1)] #[undefined] fn set_blend_constant(&self, #[webidl] color: GPUColor) { - let err = self + self .render_pass .borrow_mut() - .set_blend_constant(color.into()) - .err(); - self.error_handler.push_error(err); + .set_blend_constant(color.into()); } #[required(1)] @@ -113,12 +105,10 @@ impl GPURenderPassEncoder { &self, #[webidl(options(enforce_range = true))] reference: u32, ) { - let err = self + self .render_pass .borrow_mut() - .set_stencil_reference(reference) - .err(); - self.error_handler.push_error(err); + .set_stencil_reference(reference); } #[required(1)] @@ -127,75 +117,55 @@ impl GPURenderPassEncoder { &self, #[webidl(options(enforce_range = true))] query_index: u32, ) { - let err = self + self .render_pass .borrow_mut() - .begin_occlusion_query(query_index) - .err(); - self.error_handler.push_error(err); + .begin_occlusion_query(query_index); } #[fast] #[undefined] fn end_occlusion_query(&self) { - let err = self.render_pass.borrow_mut().end_occlusion_query().err(); - self.error_handler.push_error(err); + self.render_pass.borrow_mut().end_occlusion_query(); } #[required(1)] #[undefined] fn execute_bundles(&self, #[webidl] bundles: Vec>) { - let err = self - .render_pass - .borrow_mut() - .execute_bundles( - &bundles - .into_iter() - .map(|bundle| bundle.wgpu_render_bundle.clone()) - .collect::>(), - ) - .err(); - self.error_handler.push_error(err); + self.render_pass.borrow_mut().execute_bundles( + &bundles + .into_iter() + .map(|bundle| bundle.wgpu_render_bundle.clone()) + .collect::>(), + ); } #[fast] #[undefined] fn end(&self) { - let err = self.render_pass.borrow_mut().end().err(); - self.error_handler.push_error(err); + self.render_pass.borrow_mut().end(); } #[undefined] fn push_debug_group(&self, #[webidl] group_label: String) { - let err = self - .render_pass - .borrow_mut() - .push_debug_group( - &group_label, - 0, // wgpu#975 - ) - .err(); - self.error_handler.push_error(err); + self.render_pass.borrow_mut().push_debug_group( + &group_label, + 0, // wgpu#975 + ); } #[fast] #[undefined] fn pop_debug_group(&self) { - let err = self.render_pass.borrow_mut().pop_debug_group().err(); - self.error_handler.push_error(err); + self.render_pass.borrow_mut().pop_debug_group(); } #[undefined] fn insert_debug_marker(&self, #[webidl] marker_label: String) { - let err = self - .render_pass - .borrow_mut() - .insert_debug_marker( - &marker_label, - 0, // wgpu#975 - ) - .err(); - self.error_handler.push_error(err); + self.render_pass.borrow_mut().insert_debug_marker( + &marker_label, + 0, // wgpu#975 + ); } #[undefined] @@ -211,8 +181,7 @@ impl GPURenderPassEncoder { const PREFIX: &str = "Failed to execute 'setBindGroup' on 'GPUComputePassEncoder'"; - let err = if let Ok(uint_32) = dynamic_offsets.try_cast::() - { + if let Ok(uint_32) = dynamic_offsets.try_cast::() { let start = u64::convert( scope, dynamic_offsets_data_start, @@ -244,17 +213,13 @@ impl GPURenderPassEncoder { let offsets = &data[start..(start + len)]; - self - .render_pass - .borrow_mut() - .set_bind_group( - index, - bind_group - .into_option() - .map(|bind_group| bind_group.wgpu_bind_group.clone()), - offsets, - ) - .err() + self.render_pass.borrow_mut().set_bind_group( + index, + bind_group + .into_option() + .map(|bind_group| bind_group.wgpu_bind_group.clone()), + offsets, + ) } else { let offsets = >>::convert( scope, @@ -268,21 +233,15 @@ impl GPURenderPassEncoder { )? .unwrap_or_default(); - self - .render_pass - .borrow_mut() - .set_bind_group( - index, - bind_group - .into_option() - .map(|bind_group| bind_group.wgpu_bind_group.clone()), - &offsets, - ) - .err() + self.render_pass.borrow_mut().set_bind_group( + index, + bind_group + .into_option() + .map(|bind_group| bind_group.wgpu_bind_group.clone()), + &offsets, + ) }; - self.error_handler.push_error(err); - Ok(()) } @@ -291,12 +250,10 @@ impl GPURenderPassEncoder { &self, #[webidl] pipeline: Ptr, ) { - let err = self + self .render_pass .borrow_mut() - .set_pipeline(pipeline.wgpu_render_pipeline.clone()) - .err(); - self.error_handler.push_error(err); + .set_pipeline(pipeline.wgpu_render_pipeline.clone()); } #[required(2)] @@ -308,17 +265,12 @@ impl GPURenderPassEncoder { #[webidl(default = 0, options(enforce_range = true))] offset: u64, #[webidl(options(enforce_range = true))] size: Option, ) { - let err = self - .render_pass - .borrow_mut() - .set_index_buffer( - buffer.wgpu_buffer.clone(), - index_format.into(), - offset, - size.and_then(NonZeroU64::new), - ) - .err(); - self.error_handler.push_error(err); + self.render_pass.borrow_mut().set_index_buffer( + buffer.wgpu_buffer.clone(), + index_format.into(), + offset, + size.and_then(NonZeroU64::new), + ); } #[required(2)] @@ -330,19 +282,14 @@ impl GPURenderPassEncoder { #[webidl(default = 0, options(enforce_range = true))] offset: u64, #[webidl(options(enforce_range = true))] size: Option, ) { - let err = self - .render_pass - .borrow_mut() - .set_vertex_buffer( - slot, - buffer - .into_option() - .map(|buffer| buffer.wgpu_buffer.clone()), - offset, - size.and_then(NonZeroU64::new), - ) - .err(); - self.error_handler.push_error(err); + self.render_pass.borrow_mut().set_vertex_buffer( + slot, + buffer + .into_option() + .map(|buffer| buffer.wgpu_buffer.clone()), + offset, + size.and_then(NonZeroU64::new), + ); } #[required(1)] @@ -354,12 +301,12 @@ impl GPURenderPassEncoder { #[webidl(default = 0, options(enforce_range = true))] first_vertex: u32, #[webidl(default = 0, options(enforce_range = true))] first_instance: u32, ) { - let err = self - .render_pass - .borrow_mut() - .draw(vertex_count, instance_count, first_vertex, first_instance) - .err(); - self.error_handler.push_error(err); + self.render_pass.borrow_mut().draw( + vertex_count, + instance_count, + first_vertex, + first_instance, + ); } #[required(1)] @@ -372,18 +319,13 @@ impl GPURenderPassEncoder { #[webidl(default = 0, options(enforce_range = true))] base_vertex: i32, #[webidl(default = 0, options(enforce_range = true))] first_instance: u32, ) { - let err = self - .render_pass - .borrow_mut() - .draw_indexed( - index_count, - instance_count, - first_index, - base_vertex, - first_instance, - ) - .err(); - self.error_handler.push_error(err); + self.render_pass.borrow_mut().draw_indexed( + index_count, + instance_count, + first_index, + base_vertex, + first_instance, + ); } #[required(2)] @@ -393,12 +335,10 @@ impl GPURenderPassEncoder { #[webidl] indirect_buffer: Ptr, #[webidl(options(enforce_range = true))] indirect_offset: u64, ) { - let err = self + self .render_pass .borrow_mut() - .draw_indirect(indirect_buffer.wgpu_buffer.clone(), indirect_offset) - .err(); - self.error_handler.push_error(err); + .draw_indirect(indirect_buffer.wgpu_buffer.clone(), indirect_offset); } #[required(2)] @@ -408,15 +348,10 @@ impl GPURenderPassEncoder { #[webidl] indirect_buffer: Ptr, #[webidl(options(enforce_range = true))] indirect_offset: u64, ) { - let err = self - .render_pass - .borrow_mut() - .draw_indexed_indirect( - indirect_buffer.wgpu_buffer.clone(), - indirect_offset, - ) - .err(); - self.error_handler.push_error(err); + self.render_pass.borrow_mut().draw_indexed_indirect( + indirect_buffer.wgpu_buffer.clone(), + indirect_offset, + ); } #[required(2)] @@ -431,12 +366,7 @@ impl GPURenderPassEncoder { ) -> Result<(), JsErrorBox> { let data = get_data_slice(scope, data_arg, data_offset, data_size)?; - let err = self - .render_pass - .borrow_mut() - .set_immediates(offset, data) - .err(); - self.error_handler.push_error(err); + self.render_pass.borrow_mut().set_immediates(offset, data); Ok(()) } } diff --git a/wgpu-core-remote/src/global/bundle.rs b/wgpu-core-remote/src/global/bundle.rs index 0a8543fb9..70adfb97f 100644 --- a/wgpu-core-remote/src/global/bundle.rs +++ b/wgpu-core-remote/src/global/bundle.rs @@ -1,6 +1,5 @@ use crate::hub::Hub; use crate::id; -use wgpu_core::command::PassStateError; impl crate::global::Global { pub fn render_bundle_encoder_set_bind_group( @@ -9,7 +8,7 @@ impl crate::global::Global { index: u32, bind_group_id: Option, offsets: &[wgt::DynamicOffset], - ) -> Result<(), PassStateError> { + ) { let mut hub = self.hub.borrow_mut(); let Hub { render_bundle_encoders, @@ -25,7 +24,7 @@ impl crate::global::Global { &self, bundle_encoder: id::RenderBundleEncoderId, pipeline_id: id::RenderPipelineId, - ) -> Result<(), PassStateError> { + ) { let mut hub = self.hub.borrow_mut(); let Hub { render_bundle_encoders, @@ -44,7 +43,7 @@ impl crate::global::Global { buffer_id: Option, offset: wgt::BufferAddress, size: Option, - ) -> Result<(), PassStateError> { + ) { let mut hub = self.hub.borrow_mut(); let Hub { render_bundle_encoders, @@ -63,7 +62,7 @@ impl crate::global::Global { index_format: wgt::IndexFormat, offset: wgt::BufferAddress, size: Option, - ) -> Result<(), PassStateError> { + ) { let mut hub = self.hub.borrow_mut(); let Hub { render_bundle_encoders, @@ -80,7 +79,7 @@ impl crate::global::Global { bundle_encoder: id::RenderBundleEncoderId, offset: u32, data: &[u8], - ) -> Result<(), PassStateError> { + ) { let mut hub = self.hub.borrow_mut(); let bundle_encoder = hub.render_bundle_encoders.get_mut(bundle_encoder); @@ -94,7 +93,7 @@ impl crate::global::Global { instance_count: u32, first_vertex: u32, first_instance: u32, - ) -> Result<(), PassStateError> { + ) { let mut hub = self.hub.borrow_mut(); let bundle_encoder = hub.render_bundle_encoders.get_mut(bundle_encoder); @@ -109,7 +108,7 @@ impl crate::global::Global { first_index: u32, base_vertex: i32, first_instance: u32, - ) -> Result<(), PassStateError> { + ) { let mut hub = self.hub.borrow_mut(); let bundle_encoder = hub.render_bundle_encoders.get_mut(bundle_encoder); @@ -127,7 +126,7 @@ impl crate::global::Global { bundle_encoder: id::RenderBundleEncoderId, buffer_id: id::BufferId, offset: wgt::BufferAddress, - ) -> Result<(), PassStateError> { + ) { let mut hub = self.hub.borrow_mut(); let Hub { render_bundle_encoders, @@ -144,7 +143,7 @@ impl crate::global::Global { bundle_encoder: id::RenderBundleEncoderId, buffer_id: id::BufferId, offset: wgt::BufferAddress, - ) -> Result<(), PassStateError> { + ) { let mut hub = self.hub.borrow_mut(); let Hub { render_bundle_encoders, @@ -160,17 +159,14 @@ impl crate::global::Global { &self, bundle_encoder: id::RenderBundleEncoderId, label: &str, - ) -> Result<(), PassStateError> { + ) { let mut hub = self.hub.borrow_mut(); let bundle_encoder = hub.render_bundle_encoders.get_mut(bundle_encoder); bundle_encoder.push_debug_group(label) } - pub fn render_bundle_encoder_pop_debug_group( - &self, - bundle_encoder: id::RenderBundleEncoderId, - ) -> Result<(), PassStateError> { + pub fn render_bundle_encoder_pop_debug_group(&self, bundle_encoder: id::RenderBundleEncoderId) { let mut hub = self.hub.borrow_mut(); let bundle_encoder = hub.render_bundle_encoders.get_mut(bundle_encoder); @@ -181,7 +177,7 @@ impl crate::global::Global { &self, bundle_encoder: id::RenderBundleEncoderId, label: &str, - ) -> Result<(), PassStateError> { + ) { let mut hub = self.hub.borrow_mut(); let bundle_encoder = hub.render_bundle_encoders.get_mut(bundle_encoder); diff --git a/wgpu-core-remote/src/global/device.rs b/wgpu-core-remote/src/global/device.rs index 035bf522a..61ee3a145 100644 --- a/wgpu-core-remote/src/global/device.rs +++ b/wgpu-core-remote/src/global/device.rs @@ -721,7 +721,7 @@ impl Global { render_bundle_encoder_id: id::RenderBundleEncoderId, desc: &command::RenderBundleDescriptor, id_in: id::RenderBundleId, - ) -> (id::RenderBundleId, Option) { + ) { let mut hub = self.hub.borrow_mut(); let Hub { render_bundle_encoders, @@ -730,11 +730,9 @@ impl Global { } = &mut *hub; let bundle_encoder = render_bundle_encoders.get_mut(render_bundle_encoder_id); - let (render_bundle, error) = bundle_encoder.finish(desc); + let render_bundle = bundle_encoder.finish(desc); - let id = render_bundles.assign(id_in, render_bundle); - - (id, error) + render_bundles.assign(id_in, render_bundle); } pub fn render_bundle_encoder_drop(&self, render_bundle_encoder_id: id::RenderBundleEncoderId) { diff --git a/wgpu-core-remote/src/global/render_pass.rs b/wgpu-core-remote/src/global/render_pass.rs index 33e2ddbd0..dc8045ec5 100644 --- a/wgpu-core-remote/src/global/render_pass.rs +++ b/wgpu-core-remote/src/global/render_pass.rs @@ -2,8 +2,8 @@ use alloc::borrow::Cow; use core::num::NonZeroU32; use wgpu_core::command::{ - CommandEncoderError, EncoderStateError, PassStateError, PassTimestampWrites, - RenderPassColorAttachment, RenderPassDepthStencilAttachment, ResolvedRenderPassDescriptor, + PassTimestampWrites, RenderPassColorAttachment, RenderPassDepthStencilAttachment, + ResolvedRenderPassDescriptor, }; use wgpu_core::Label; use wgt::{BufferAddress, BufferSize, Color, DynamicOffset, IndexFormat}; @@ -45,7 +45,7 @@ impl Global { encoder_id: id::CommandEncoderId, desc: &RenderPassDescriptor<'_>, id_in: id::RenderPassEncoderId, - ) -> (id::RenderPassEncoderId, Option) { + ) { let mut hub = self.hub.borrow_mut(); let Hub { command_encoders, @@ -98,13 +98,12 @@ impl Global { multiview_mask: desc.multiview_mask, }; - let (render_pass, error) = cmd_enc.begin_render_pass(desc); + let render_pass = cmd_enc.begin_render_pass(desc); - let id = render_passes.assign(id_in, render_pass); - (id, error) + render_passes.assign(id_in, render_pass); } - pub fn render_pass_end(&self, pass: id::RenderPassEncoderId) -> Result<(), EncoderStateError> { + pub fn render_pass_end(&self, pass: id::RenderPassEncoderId) { let mut hub = self.hub.borrow_mut(); let pass = hub.render_passes.get_mut(pass); pass.end() @@ -131,7 +130,7 @@ impl Global { index: u32, bind_group_id: Option, offsets: &[DynamicOffset], - ) -> Result<(), PassStateError> { + ) { let mut hub = self.hub.borrow_mut(); let Hub { render_passes, @@ -146,7 +145,7 @@ impl Global { &self, pass: id::RenderPassEncoderId, pipeline_id: id::RenderPipelineId, - ) -> Result<(), PassStateError> { + ) { let mut hub = self.hub.borrow_mut(); let Hub { render_passes, @@ -165,7 +164,7 @@ impl Global { index_format: IndexFormat, offset: BufferAddress, size: Option, - ) -> Result<(), PassStateError> { + ) { let mut hub = self.hub.borrow_mut(); let Hub { render_passes, @@ -183,7 +182,7 @@ impl Global { buffer_id: Option, offset: BufferAddress, size: Option, - ) -> Result<(), PassStateError> { + ) { let mut hub = self.hub.borrow_mut(); let Hub { render_passes, @@ -194,21 +193,13 @@ impl Global { pass.set_vertex_buffer(slot, buffer_id.map(|id| buffers.get(id)), offset, size) } - pub fn render_pass_set_blend_constant( - &self, - pass: id::RenderPassEncoderId, - color: Color, - ) -> Result<(), PassStateError> { + pub fn render_pass_set_blend_constant(&self, pass: id::RenderPassEncoderId, color: Color) { let mut hub = self.hub.borrow_mut(); let pass = hub.render_passes.get_mut(pass); pass.set_blend_constant(color) } - pub fn render_pass_set_stencil_reference( - &self, - pass: id::RenderPassEncoderId, - value: u32, - ) -> Result<(), PassStateError> { + pub fn render_pass_set_stencil_reference(&self, pass: id::RenderPassEncoderId, value: u32) { let mut hub = self.hub.borrow_mut(); let pass = hub.render_passes.get_mut(pass); pass.set_stencil_reference(value) @@ -223,7 +214,7 @@ impl Global { h: f32, depth_min: f32, depth_max: f32, - ) -> Result<(), PassStateError> { + ) { let mut hub = self.hub.borrow_mut(); let pass = hub.render_passes.get_mut(pass); pass.set_viewport(x, y, w, h, depth_min, depth_max) @@ -236,7 +227,7 @@ impl Global { y: u32, w: u32, h: u32, - ) -> Result<(), PassStateError> { + ) { let mut hub = self.hub.borrow_mut(); let pass = hub.render_passes.get_mut(pass); pass.set_scissor_rect(x, y, w, h) @@ -247,7 +238,7 @@ impl Global { pass: id::RenderPassEncoderId, offset: u32, data: &[u8], - ) -> Result<(), PassStateError> { + ) { let mut hub = self.hub.borrow_mut(); let pass = hub.render_passes.get_mut(pass); pass.set_immediates(offset, data) @@ -260,7 +251,7 @@ impl Global { instance_count: u32, first_vertex: u32, first_instance: u32, - ) -> Result<(), PassStateError> { + ) { let mut hub = self.hub.borrow_mut(); let pass = hub.render_passes.get_mut(pass); pass.draw(vertex_count, instance_count, first_vertex, first_instance) @@ -274,7 +265,7 @@ impl Global { first_index: u32, base_vertex: i32, first_instance: u32, - ) -> Result<(), PassStateError> { + ) { let mut hub = self.hub.borrow_mut(); let pass = hub.render_passes.get_mut(pass); pass.draw_indexed( @@ -291,7 +282,7 @@ impl Global { pass: id::RenderPassEncoderId, buffer_id: id::BufferId, offset: BufferAddress, - ) -> Result<(), PassStateError> { + ) { let mut hub = self.hub.borrow_mut(); let Hub { render_passes, @@ -307,7 +298,7 @@ impl Global { pass: id::RenderPassEncoderId, buffer_id: id::BufferId, offset: BufferAddress, - ) -> Result<(), PassStateError> { + ) { let mut hub = self.hub.borrow_mut(); let Hub { render_passes, @@ -323,16 +314,13 @@ impl Global { pass: id::RenderPassEncoderId, label: &str, color: u32, - ) -> Result<(), PassStateError> { + ) { let mut hub = self.hub.borrow_mut(); let pass = hub.render_passes.get_mut(pass); pass.push_debug_group(label, color) } - pub fn render_pass_pop_debug_group( - &self, - pass: id::RenderPassEncoderId, - ) -> Result<(), PassStateError> { + pub fn render_pass_pop_debug_group(&self, pass: id::RenderPassEncoderId) { let mut hub = self.hub.borrow_mut(); let pass = hub.render_passes.get_mut(pass); pass.pop_debug_group() @@ -343,7 +331,7 @@ impl Global { pass: id::RenderPassEncoderId, label: &str, color: u32, - ) -> Result<(), PassStateError> { + ) { let mut hub = self.hub.borrow_mut(); let pass = hub.render_passes.get_mut(pass); pass.insert_debug_marker(label, color) @@ -354,7 +342,7 @@ impl Global { pass: id::RenderPassEncoderId, query_set_id: id::QuerySetId, query_index: u32, - ) -> Result<(), PassStateError> { + ) { let mut hub = self.hub.borrow_mut(); let Hub { render_passes, @@ -369,16 +357,13 @@ impl Global { &self, pass: id::RenderPassEncoderId, query_index: u32, - ) -> Result<(), PassStateError> { + ) { let mut hub = self.hub.borrow_mut(); let pass = hub.render_passes.get_mut(pass); pass.begin_occlusion_query(query_index) } - pub fn render_pass_end_occlusion_query( - &self, - pass: id::RenderPassEncoderId, - ) -> Result<(), PassStateError> { + pub fn render_pass_end_occlusion_query(&self, pass: id::RenderPassEncoderId) { let mut hub = self.hub.borrow_mut(); let pass = hub.render_passes.get_mut(pass); pass.end_occlusion_query() @@ -389,7 +374,7 @@ impl Global { pass: id::RenderPassEncoderId, query_set_id: id::QuerySetId, query_index: u32, - ) -> Result<(), PassStateError> { + ) { let mut hub = self.hub.borrow_mut(); let Hub { render_passes, @@ -400,10 +385,7 @@ impl Global { pass.begin_pipeline_statistics_query(query_sets.get(query_set_id), query_index) } - pub fn render_pass_end_pipeline_statistics_query( - &self, - pass: id::RenderPassEncoderId, - ) -> Result<(), PassStateError> { + pub fn render_pass_end_pipeline_statistics_query(&self, pass: id::RenderPassEncoderId) { let mut hub = self.hub.borrow_mut(); let pass = hub.render_passes.get_mut(pass); pass.end_pipeline_statistics_query() @@ -413,7 +395,7 @@ impl Global { &self, pass: id::RenderPassEncoderId, render_bundle_ids: &[id::RenderBundleId], - ) -> Result<(), PassStateError> { + ) { let mut hub = self.hub.borrow_mut(); let Hub { render_passes, diff --git a/wgpu-core/src/command/bundle.rs b/wgpu-core/src/command/bundle.rs index e706978a1..1be4da443 100644 --- a/wgpu-core/src/command/bundle.rs +++ b/wgpu-core/src/command/bundle.rs @@ -303,10 +303,7 @@ impl RenderBundleEncoder { /// and accumulate buffer and texture initialization actions. /// /// [`ExecuteBundle`]: RenderCommand::ExecuteBundle - pub fn finish( - &mut self, - desc: &RenderBundleDescriptor, - ) -> (Arc, Option) { + pub fn finish(&mut self, desc: &RenderBundleDescriptor) -> Arc { profiling::scope!("RenderBundleEncoder::finish"); #[cfg(feature = "trace")] let trace_desc = crate::device::trace::new_render_bundle_encoder_descriptor( @@ -316,13 +313,11 @@ impl RenderBundleEncoder { self.is_stencil_read_only, ); - let (render_bundle, error) = match self.finish_inner(desc) { - Ok(render_bundle) => (render_bundle, None), - Err(e) => ( - RenderBundle::invalid(Arc::clone(&self.device), desc), - Some(e), - ), - }; + let render_bundle = self.finish_inner(desc).unwrap_or_else(|error| { + self.device + .handle_error(error, self.label(), "RenderBundleEncoder::finish"); + RenderBundle::invalid(Arc::clone(&self.device), desc) + }); #[cfg(feature = "trace")] if let Some(ref mut trace) = *self.device.trace.lock() { @@ -339,7 +334,7 @@ impl RenderBundleEncoder { Arc::as_ptr(&render_bundle) ); - (render_bundle, error) + render_bundle } /// Convert this encoder's commands into a [`RenderBundle`]. @@ -576,7 +571,7 @@ impl RenderBundleEncoder { Ok(render_bundle) } - pub fn set_index_buffer( + fn set_index_buffer_inner( &mut self, buffer: Arc, index_format: wgt::IndexFormat, @@ -593,7 +588,20 @@ impl RenderBundleEncoder { Ok(()) } - pub fn set_bind_group( + pub fn set_index_buffer( + &mut self, + buffer: Arc, + index_format: wgt::IndexFormat, + offset: wgt::BufferAddress, + size: Option, + ) { + if let Err(err) = self.set_index_buffer_inner(buffer, index_format, offset, size) { + self.device + .handle_error(err, self.label(), "RenderBundleEncoder::set_index_buffer"); + } + } + + fn set_bind_group_inner( &mut self, index: u32, bind_group: Option>, @@ -619,7 +627,19 @@ impl RenderBundleEncoder { Ok(()) } - pub fn set_pipeline(&mut self, pipeline: Arc) -> Result<(), PassStateError> { + pub fn set_bind_group( + &mut self, + index: u32, + bind_group: Option>, + offsets: &[wgt::DynamicOffset], + ) { + if let Err(err) = self.set_bind_group_inner(index, bind_group, offsets) { + self.device + .handle_error(err, self.label(), "RenderBundleEncoder::set_bind_group"); + } + } + + fn set_pipeline_inner(&mut self, pipeline: Arc) -> Result<(), PassStateError> { pass_base!(self, PassErrorScope::SetPipelineRender); if self.current_pipeline.set_and_check_redundant(&pipeline) { return Ok(()); @@ -631,7 +651,14 @@ impl RenderBundleEncoder { Ok(()) } - pub fn set_vertex_buffer( + pub fn set_pipeline(&mut self, pipeline: Arc) { + if let Err(err) = self.set_pipeline_inner(pipeline) { + self.device + .handle_error(err, self.label(), "RenderBundleEncoder::set_pipeline"); + } + } + + fn set_vertex_buffer_inner( &mut self, slot: u32, buffer: Option>, @@ -648,7 +675,20 @@ impl RenderBundleEncoder { Ok(()) } - pub fn set_immediates(&mut self, offset: u32, data: &[u8]) -> Result<(), PassStateError> { + pub fn set_vertex_buffer( + &mut self, + slot: u32, + buffer: Option>, + offset: wgt::BufferAddress, + size: Option, + ) { + if let Err(err) = self.set_vertex_buffer_inner(slot, buffer, offset, size) { + self.device + .handle_error(err, self.label(), "RenderBundleEncoder::set_vertex_buffer"); + } + } + + fn set_immediates_inner(&mut self, offset: u32, data: &[u8]) -> Result<(), PassStateError> { pass_base!(self, PassErrorScope::SetImmediate); // This should have been validated in content timeline @@ -664,7 +704,14 @@ impl RenderBundleEncoder { Ok(()) } - pub fn draw( + pub fn set_immediates(&mut self, offset: u32, data: &[u8]) { + if let Err(err) = self.set_immediates_inner(offset, data) { + self.device + .handle_error(err, self.label(), "RenderBundleEncoder::set_immediates"); + } + } + + fn draw_inner( &mut self, vertex_count: u32, instance_count: u32, @@ -687,7 +734,22 @@ impl RenderBundleEncoder { Ok(()) } - pub fn draw_indexed( + pub fn draw( + &mut self, + vertex_count: u32, + instance_count: u32, + first_vertex: u32, + first_instance: u32, + ) { + if let Err(err) = + self.draw_inner(vertex_count, instance_count, first_vertex, first_instance) + { + self.device + .handle_error(err, self.label(), "RenderBundleEncoder::draw"); + } + } + + fn draw_indexed_inner( &mut self, index_count: u32, instance_count: u32, @@ -712,7 +774,27 @@ impl RenderBundleEncoder { Ok(()) } - pub fn draw_indirect( + pub fn draw_indexed( + &mut self, + index_count: u32, + instance_count: u32, + first_index: u32, + base_vertex: i32, + first_instance: u32, + ) { + if let Err(err) = self.draw_indexed_inner( + index_count, + instance_count, + first_index, + base_vertex, + first_instance, + ) { + self.device + .handle_error(err, self.label(), "RenderBundleEncoder::draw_indexed"); + } + } + + fn draw_indirect_inner( &mut self, buffer: Arc, offset: wgt::BufferAddress, @@ -735,7 +817,14 @@ impl RenderBundleEncoder { Ok(()) } - pub fn draw_indexed_indirect( + pub fn draw_indirect(&mut self, buffer: Arc, offset: wgt::BufferAddress) { + if let Err(err) = self.draw_indirect_inner(buffer, offset) { + self.device + .handle_error(err, self.label(), "RenderBundleEncoder::draw_indirect"); + } + } + + fn draw_indexed_indirect_inner( &mut self, buffer: Arc, offset: wgt::BufferAddress, @@ -758,23 +847,57 @@ impl RenderBundleEncoder { Ok(()) } - pub fn push_debug_group(&mut self, _label: &str) -> Result<(), PassStateError> { + pub fn draw_indexed_indirect(&mut self, buffer: Arc, offset: wgt::BufferAddress) { + if let Err(err) = self.draw_indexed_indirect_inner(buffer, offset) { + self.device.handle_error( + err, + self.label(), + "RenderBundleEncoder::draw_indexed_indirect", + ); + } + } + + fn push_debug_group_inner(&mut self, _label: &str) -> Result<(), PassStateError> { pass_base!(self, PassErrorScope::PushDebugGroup); //TODO Ok(()) } - pub fn pop_debug_group(&mut self) -> Result<(), PassStateError> { + pub fn push_debug_group(&mut self, label: &str) { + if let Err(err) = self.push_debug_group_inner(label) { + self.device + .handle_error(err, self.label(), "RenderBundleEncoder::push_debug_group"); + } + } + + fn pop_debug_group_inner(&mut self) -> Result<(), PassStateError> { pass_base!(self, PassErrorScope::PopDebugGroup); //TODO Ok(()) } - pub fn insert_debug_marker(&mut self, _label: &str) -> Result<(), PassStateError> { + pub fn pop_debug_group(&mut self) { + if let Err(err) = self.pop_debug_group_inner() { + self.device + .handle_error(err, self.label(), "RenderBundleEncoder::pop_debug_group"); + } + } + + fn insert_debug_marker_inner(&mut self, _label: &str) -> Result<(), PassStateError> { pass_base!(self, PassErrorScope::InsertDebugMarker); //TODO Ok(()) } + + pub fn insert_debug_marker(&mut self, label: &str) { + if let Err(err) = self.insert_debug_marker_inner(label) { + self.device.handle_error( + err, + self.label(), + "RenderBundleEncoder::insert_debug_marker", + ); + } + } } fn set_bind_group( diff --git a/wgpu-core/src/command/render.rs b/wgpu-core/src/command/render.rs index 4267b91d3..5e92bcbbf 100644 --- a/wgpu-core/src/command/render.rs +++ b/wgpu-core/src/command/render.rs @@ -1812,7 +1812,7 @@ fn check_transient_attachment_ops(load_op: LoadOp, store_op: StoreOp) -> b } impl CommandEncoder { - pub fn begin_render_pass( + fn begin_render_pass_inner( self: &Arc, desc: ResolvedRenderPassDescriptor<'_>, ) -> (RenderPass, Option) { @@ -2129,10 +2129,22 @@ impl CommandEncoder { } } } + + pub fn begin_render_pass( + self: &Arc, + desc: ResolvedRenderPassDescriptor<'_>, + ) -> RenderPass { + let (pass, err) = self.begin_render_pass_inner(desc); + if let Some(err) = err { + self.device + .handle_error(err, pass.label(), "CommandEncoder::begin_render_pass"); + } + pass + } } impl RenderPass { - pub fn end(&mut self) -> Result<(), EncoderStateError> { + fn end_inner(&mut self) -> Result<(), EncoderStateError> { profiling::scope!( "CommandEncoder::run_render_pass {}", self.base.label.as_deref().unwrap_or("") @@ -2171,6 +2183,13 @@ impl RenderPass { }) }) } + + pub fn end(&mut self) { + if let Err(err) = self.end_inner() { + self.device + .handle_error(err, self.label(), "RenderPass::end"); + } + } } pub(super) fn encode_render_pass( @@ -3535,7 +3554,7 @@ fn execute_bundle( // that the `pass_try!` and `pass_base!` macros may return early from the // function that invokes them, like the `?` operator. impl RenderPass { - pub fn set_bind_group( + fn set_bind_group_inner( &mut self, index: u32, bind_group: Option>, @@ -3573,7 +3592,19 @@ impl RenderPass { Ok(()) } - pub fn set_pipeline(&mut self, pipeline: Arc) -> Result<(), PassStateError> { + pub fn set_bind_group( + &mut self, + index: u32, + bind_group: Option>, + offsets: &[DynamicOffset], + ) { + if let Err(err) = self.set_bind_group_inner(index, bind_group, offsets) { + self.device + .handle_error(err, self.label(), "RenderPass::set_bind_group"); + } + } + + fn set_pipeline_inner(&mut self, pipeline: Arc) -> Result<(), PassStateError> { let scope = PassErrorScope::SetPipelineRender; let redundant = self.current_pipeline.set_and_check_redundant(&pipeline); @@ -3593,7 +3624,14 @@ impl RenderPass { Ok(()) } - pub fn set_index_buffer( + pub fn set_pipeline(&mut self, pipeline: Arc) { + if let Err(err) = self.set_pipeline_inner(pipeline) { + self.device + .handle_error(err, self.label(), "RenderPass::set_pipeline"); + } + } + + fn set_index_buffer_inner( &mut self, buffer: Arc, index_format: IndexFormat, @@ -3615,7 +3653,20 @@ impl RenderPass { Ok(()) } - pub fn set_vertex_buffer( + pub fn set_index_buffer( + &mut self, + buffer: Arc, + index_format: IndexFormat, + offset: BufferAddress, + size: Option, + ) { + if let Err(err) = self.set_index_buffer_inner(buffer, index_format, offset, size) { + self.device + .handle_error(err, self.label(), "RenderPass::set_index_buffer"); + } + } + + fn set_vertex_buffer_inner( &mut self, slot: u32, buffer: Option>, @@ -3642,7 +3693,20 @@ impl RenderPass { Ok(()) } - pub fn set_blend_constant(&mut self, color: Color) -> Result<(), PassStateError> { + pub fn set_vertex_buffer( + &mut self, + slot: u32, + buffer: Option>, + offset: BufferAddress, + size: Option, + ) { + if let Err(err) = self.set_vertex_buffer_inner(slot, buffer, offset, size) { + self.device + .handle_error(err, self.label(), "RenderPass::set_vertex_buffer"); + } + } + + fn set_blend_constant_inner(&mut self, color: Color) -> Result<(), PassStateError> { let scope = PassErrorScope::SetBlendConstant; let base = pass_base!(self, scope); @@ -3652,7 +3716,14 @@ impl RenderPass { Ok(()) } - pub fn set_stencil_reference(&mut self, value: u32) -> Result<(), PassStateError> { + pub fn set_blend_constant(&mut self, color: Color) { + if let Err(err) = self.set_blend_constant_inner(color) { + self.device + .handle_error(err, self.label(), "RenderPass::set_blend_constant"); + } + } + + fn set_stencil_reference_inner(&mut self, value: u32) -> Result<(), PassStateError> { let scope = PassErrorScope::SetStencilReference; let base = pass_base!(self, scope); let value = convert_stencil_value( @@ -3667,7 +3738,14 @@ impl RenderPass { Ok(()) } - pub fn set_viewport( + pub fn set_stencil_reference(&mut self, value: u32) { + if let Err(err) = self.set_stencil_reference_inner(value) { + self.device + .handle_error(err, self.label(), "RenderPass::set_stencil_reference"); + } + } + + fn set_viewport_inner( &mut self, x: f32, y: f32, @@ -3688,7 +3766,14 @@ impl RenderPass { Ok(()) } - pub fn set_scissor_rect( + pub fn set_viewport(&mut self, x: f32, y: f32, w: f32, h: f32, depth_min: f32, depth_max: f32) { + if let Err(err) = self.set_viewport_inner(x, y, w, h, depth_min, depth_max) { + self.device + .handle_error(err, self.label(), "RenderPass::set_viewport"); + } + } + + fn set_scissor_rect_inner( &mut self, x: u32, y: u32, @@ -3704,7 +3789,14 @@ impl RenderPass { Ok(()) } - pub fn set_immediates(&mut self, offset: u32, data: &[u8]) -> Result<(), PassStateError> { + pub fn set_scissor_rect(&mut self, x: u32, y: u32, w: u32, h: u32) { + if let Err(err) = self.set_scissor_rect_inner(x, y, w, h) { + self.device + .handle_error(err, self.label(), "RenderPass::set_scissor_rect"); + } + } + + fn set_immediates_inner(&mut self, offset: u32, data: &[u8]) -> Result<(), PassStateError> { let scope = PassErrorScope::SetImmediate; let base = pass_base!(self, scope); @@ -3725,7 +3817,14 @@ impl RenderPass { Ok(()) } - pub fn draw( + pub fn set_immediates(&mut self, offset: u32, data: &[u8]) { + if let Err(err) = self.set_immediates_inner(offset, data) { + self.device + .handle_error(err, self.label(), "RenderPass::set_immediates"); + } + } + + fn draw_inner( &mut self, vertex_count: u32, instance_count: u32, @@ -3748,7 +3847,22 @@ impl RenderPass { Ok(()) } - pub fn draw_indexed( + pub fn draw( + &mut self, + vertex_count: u32, + instance_count: u32, + first_vertex: u32, + first_instance: u32, + ) { + if let Err(err) = + self.draw_inner(vertex_count, instance_count, first_vertex, first_instance) + { + self.device + .handle_error(err, self.label(), "RenderPass::draw"); + } + } + + fn draw_indexed_inner( &mut self, index_count: u32, instance_count: u32, @@ -3773,7 +3887,27 @@ impl RenderPass { Ok(()) } - pub fn draw_mesh_tasks( + pub fn draw_indexed( + &mut self, + index_count: u32, + instance_count: u32, + first_index: u32, + base_vertex: i32, + first_instance: u32, + ) { + if let Err(err) = self.draw_indexed_inner( + index_count, + instance_count, + first_index, + base_vertex, + first_instance, + ) { + self.device + .handle_error(err, self.label(), "RenderPass::draw_indexed"); + } + } + + fn draw_mesh_tasks_inner( &mut self, group_count_x: u32, group_count_y: u32, @@ -3793,7 +3927,14 @@ impl RenderPass { Ok(()) } - pub fn draw_indirect( + pub fn draw_mesh_tasks(&mut self, group_count_x: u32, group_count_y: u32, group_count_z: u32) { + if let Err(err) = self.draw_mesh_tasks_inner(group_count_x, group_count_y, group_count_z) { + self.device + .handle_error(err, self.label(), "RenderPass::draw_mesh_tasks"); + } + } + + fn draw_indirect_inner( &mut self, buffer: Arc, offset: BufferAddress, @@ -3819,7 +3960,14 @@ impl RenderPass { Ok(()) } - pub fn draw_indexed_indirect( + pub fn draw_indirect(&mut self, buffer: Arc, offset: BufferAddress) { + if let Err(err) = self.draw_indirect_inner(buffer, offset) { + self.device + .handle_error(err, self.label(), "RenderPass::draw_indirect"); + } + } + + fn draw_indexed_indirect_inner( &mut self, buffer: Arc, offset: BufferAddress, @@ -3845,7 +3993,14 @@ impl RenderPass { Ok(()) } - pub fn draw_mesh_tasks_indirect( + pub fn draw_indexed_indirect(&mut self, buffer: Arc, offset: BufferAddress) { + if let Err(err) = self.draw_indexed_indirect_inner(buffer, offset) { + self.device + .handle_error(err, self.label(), "RenderPass::draw_indexed_indirect"); + } + } + + fn draw_mesh_tasks_indirect_inner( &mut self, buffer: Arc, offset: BufferAddress, @@ -3871,7 +4026,14 @@ impl RenderPass { Ok(()) } - pub fn multi_draw_indirect( + pub fn draw_mesh_tasks_indirect(&mut self, buffer: Arc, offset: BufferAddress) { + if let Err(err) = self.draw_mesh_tasks_indirect_inner(buffer, offset) { + self.device + .handle_error(err, self.label(), "RenderPass::draw_mesh_tasks_indirect"); + } + } + + fn multi_draw_indirect_inner( &mut self, buffer: Arc, offset: BufferAddress, @@ -3898,34 +4060,53 @@ impl RenderPass { Ok(()) } + pub fn multi_draw_indirect(&mut self, buffer: Arc, offset: BufferAddress, count: u32) { + if let Err(err) = self.multi_draw_indirect_inner(buffer, offset, count) { + self.device + .handle_error(err, self.label(), "RenderPass::multi_draw_indirect"); + } + } + + fn multi_draw_indexed_indirect_inner( + &mut self, + buffer: Arc, + offset: BufferAddress, + count: u32, + ) -> Result<(), PassStateError> { + let scope = PassErrorScope::Draw { + kind: DrawKind::MultiDrawIndirect, + family: DrawCommandFamily::DrawIndexed, + }; + let base = pass_base!(self, scope); + + pass_try!(base, scope, buffer.check_is_valid()); + + base.commands.push(ArcRenderCommand::DrawIndirect { + buffer, + offset, + count, + family: DrawCommandFamily::DrawIndexed, + + vertex_or_index_limit: None, + instance_limit: None, + }); + + Ok(()) + } + pub fn multi_draw_indexed_indirect( &mut self, buffer: Arc, offset: BufferAddress, count: u32, - ) -> Result<(), PassStateError> { - let scope = PassErrorScope::Draw { - kind: DrawKind::MultiDrawIndirect, - family: DrawCommandFamily::DrawIndexed, - }; - let base = pass_base!(self, scope); - - pass_try!(base, scope, buffer.check_is_valid()); - - base.commands.push(ArcRenderCommand::DrawIndirect { - buffer, - offset, - count, - family: DrawCommandFamily::DrawIndexed, - - vertex_or_index_limit: None, - instance_limit: None, - }); - - Ok(()) + ) { + if let Err(err) = self.multi_draw_indexed_indirect_inner(buffer, offset, count) { + self.device + .handle_error(err, self.label(), "RenderPass::multi_draw_indexed_indirect"); + } } - pub fn multi_draw_mesh_tasks_indirect( + fn multi_draw_mesh_tasks_indirect_inner( &mut self, buffer: Arc, offset: BufferAddress, @@ -3952,7 +4133,22 @@ impl RenderPass { Ok(()) } - pub fn multi_draw_indirect_count( + pub fn multi_draw_mesh_tasks_indirect( + &mut self, + buffer: Arc, + offset: BufferAddress, + count: u32, + ) { + if let Err(err) = self.multi_draw_mesh_tasks_indirect_inner(buffer, offset, count) { + self.device.handle_error( + err, + self.label(), + "RenderPass::multi_draw_mesh_tasks_indirect", + ); + } + } + + fn multi_draw_indirect_count_inner( &mut self, buffer: Arc, offset: BufferAddress, @@ -3981,7 +4177,27 @@ impl RenderPass { Ok(()) } - pub fn multi_draw_indexed_indirect_count( + pub fn multi_draw_indirect_count( + &mut self, + buffer: Arc, + offset: BufferAddress, + count_buffer: Arc, + count_buffer_offset: BufferAddress, + max_count: u32, + ) { + if let Err(err) = self.multi_draw_indirect_count_inner( + buffer, + offset, + count_buffer, + count_buffer_offset, + max_count, + ) { + self.device + .handle_error(err, self.label(), "RenderPass::multi_draw_indirect_count"); + } + } + + fn multi_draw_indexed_indirect_count_inner( &mut self, buffer: Arc, offset: BufferAddress, @@ -4011,7 +4227,30 @@ impl RenderPass { Ok(()) } - pub fn multi_draw_mesh_tasks_indirect_count( + pub fn multi_draw_indexed_indirect_count( + &mut self, + buffer: Arc, + offset: BufferAddress, + count_buffer: Arc, + count_buffer_offset: BufferAddress, + max_count: u32, + ) { + if let Err(err) = self.multi_draw_indexed_indirect_count_inner( + buffer, + offset, + count_buffer, + count_buffer_offset, + max_count, + ) { + self.device.handle_error( + err, + self.label(), + "RenderPass::multi_draw_indexed_indirect_count", + ); + } + } + + fn multi_draw_mesh_tasks_indirect_count_inner( &mut self, buffer: Arc, offset: BufferAddress, @@ -4041,7 +4280,30 @@ impl RenderPass { Ok(()) } - pub fn push_debug_group(&mut self, label: &str, color: u32) -> Result<(), PassStateError> { + pub fn multi_draw_mesh_tasks_indirect_count( + &mut self, + buffer: Arc, + offset: BufferAddress, + count_buffer: Arc, + count_buffer_offset: BufferAddress, + max_count: u32, + ) { + if let Err(err) = self.multi_draw_mesh_tasks_indirect_count_inner( + buffer, + offset, + count_buffer, + count_buffer_offset, + max_count, + ) { + self.device.handle_error( + err, + self.label(), + "RenderPass::multi_draw_mesh_tasks_indirect_count", + ); + } + } + + fn push_debug_group_inner(&mut self, label: &str, color: u32) -> Result<(), PassStateError> { let base = pass_base!(self, PassErrorScope::PushDebugGroup); let bytes = label.as_bytes(); @@ -4055,7 +4317,14 @@ impl RenderPass { Ok(()) } - pub fn pop_debug_group(&mut self) -> Result<(), PassStateError> { + pub fn push_debug_group(&mut self, label: &str, color: u32) { + if let Err(err) = self.push_debug_group_inner(label, color) { + self.device + .handle_error(err, self.label(), "RenderPass::push_debug_group"); + } + } + + fn pop_debug_group_inner(&mut self) -> Result<(), PassStateError> { let base = pass_base!(self, PassErrorScope::PopDebugGroup); base.commands.push(ArcRenderCommand::PopDebugGroup); @@ -4063,7 +4332,14 @@ impl RenderPass { Ok(()) } - pub fn insert_debug_marker(&mut self, label: &str, color: u32) -> Result<(), PassStateError> { + pub fn pop_debug_group(&mut self) { + if let Err(err) = self.pop_debug_group_inner() { + self.device + .handle_error(err, self.label(), "RenderPass::pop_debug_group"); + } + } + + fn insert_debug_marker_inner(&mut self, label: &str, color: u32) -> Result<(), PassStateError> { let base = pass_base!(self, PassErrorScope::InsertDebugMarker); let bytes = label.as_bytes(); @@ -4077,7 +4353,14 @@ impl RenderPass { Ok(()) } - pub fn write_timestamp( + pub fn insert_debug_marker(&mut self, label: &str, color: u32) { + if let Err(err) = self.insert_debug_marker_inner(label, color) { + self.device + .handle_error(err, self.label(), "RenderPass::insert_debug_marker"); + } + } + + fn write_timestamp_inner( &mut self, query_set: Arc, query_index: u32, @@ -4094,7 +4377,14 @@ impl RenderPass { Ok(()) } - pub fn begin_occlusion_query(&mut self, query_index: u32) -> Result<(), PassStateError> { + pub fn write_timestamp(&mut self, query_set: Arc, query_index: u32) { + if let Err(err) = self.write_timestamp_inner(query_set, query_index) { + self.device + .handle_error(err, self.label(), "RenderPass::write_timestamp"); + } + } + + fn begin_occlusion_query_inner(&mut self, query_index: u32) -> Result<(), PassStateError> { let scope = PassErrorScope::BeginOcclusionQuery; let base = pass_base!(self, scope); @@ -4104,7 +4394,14 @@ impl RenderPass { Ok(()) } - pub fn end_occlusion_query(&mut self) -> Result<(), PassStateError> { + pub fn begin_occlusion_query(&mut self, query_index: u32) { + if let Err(err) = self.begin_occlusion_query_inner(query_index) { + self.device + .handle_error(err, self.label(), "RenderPass::begin_occlusion_query"); + } + } + + fn end_occlusion_query_inner(&mut self) -> Result<(), PassStateError> { let scope = PassErrorScope::EndOcclusionQuery; let base = pass_base!(self, scope); @@ -4113,7 +4410,14 @@ impl RenderPass { Ok(()) } - pub fn begin_pipeline_statistics_query( + pub fn end_occlusion_query(&mut self) { + if let Err(err) = self.end_occlusion_query_inner() { + self.device + .handle_error(err, self.label(), "RenderPass::end_occlusion_query"); + } + } + + fn begin_pipeline_statistics_query_inner( &mut self, query_set: Arc, query_index: u32, @@ -4131,7 +4435,17 @@ impl RenderPass { Ok(()) } - pub fn end_pipeline_statistics_query(&mut self) -> Result<(), PassStateError> { + pub fn begin_pipeline_statistics_query(&mut self, query_set: Arc, query_index: u32) { + if let Err(err) = self.begin_pipeline_statistics_query_inner(query_set, query_index) { + self.device.handle_error( + err, + self.label(), + "RenderPass::begin_pipeline_statistics_query", + ); + } + } + + fn end_pipeline_statistics_query_inner(&mut self) -> Result<(), PassStateError> { let scope = PassErrorScope::EndPipelineStatisticsQuery; let base = pass_base!(self, scope); @@ -4141,7 +4455,17 @@ impl RenderPass { Ok(()) } - pub fn execute_bundles( + pub fn end_pipeline_statistics_query(&mut self) { + if let Err(err) = self.end_pipeline_statistics_query_inner() { + self.device.handle_error( + err, + self.label(), + "RenderPass::end_pipeline_statistics_query", + ); + } + } + + fn execute_bundles_inner( &mut self, render_bundles: &[Arc], ) -> Result<(), PassStateError> { @@ -4159,6 +4483,13 @@ impl RenderPass { Ok(()) } + + pub fn execute_bundles(&mut self, render_bundles: &[Arc]) { + if let Err(err) = self.execute_bundles_inner(render_bundles) { + self.device + .handle_error(err, self.label(), "RenderPass::execute_bundles"); + } + } } pub(crate) const fn get_src_stride_of_indirect_args(family: DrawCommandFamily) -> u64 { diff --git a/wgpu/src/backend/wgpu_core.rs b/wgpu/src/backend/wgpu_core.rs index d1d0bafff..605e26abc 100644 --- a/wgpu/src/backend/wgpu_core.rs +++ b/wgpu/src/backend/wgpu_core.rs @@ -2186,7 +2186,7 @@ impl dispatch::CommandEncoderInterface for CoreCommandEncoder { end_of_pass_write_index: tw.end_of_pass_write_index, }); - let (pass, err) = self.wgpu_command_encoder.begin_render_pass( + let pass = self.wgpu_command_encoder.begin_render_pass( wgc::command::ResolvedRenderPassDescriptor { label: desc.label.map(Borrowed), timestamp_writes, @@ -2199,14 +2199,6 @@ impl dispatch::CommandEncoderInterface for CoreCommandEncoder { }, ); - if let Some(cause) = err { - self.wgpu_command_encoder.device().handle_error( - cause, - desc.label, - "CommandEncoder::begin_render_pass", - ); - } - CoreRenderPass { pass, id: crate::cmp::Identifier::create(), @@ -2563,14 +2555,8 @@ impl dispatch::RenderPassInterface for CoreRenderPass { fn set_pipeline(&mut self, pipeline: &dispatch::DispatchRenderPipeline) { let pipeline = pipeline.as_core(); - if let Err(cause) = self - .pass - .set_pipeline(pipeline.wgpu_render_pipeline.clone()) - { - self.pass - .device() - .handle_error(cause, self.pass.label(), "RenderPass::set_pipeline"); - } + self.pass + .set_pipeline(pipeline.wgpu_render_pipeline.clone()); } fn set_bind_group( @@ -2581,11 +2567,7 @@ impl dispatch::RenderPassInterface for CoreRenderPass { ) { let bg = bind_group.map(|bg| bg.as_core().wgpu_bind_group.clone()); - if let Err(cause) = self.pass.set_bind_group(index, bg, offsets) { - self.pass - .device() - .handle_error(cause, self.pass.label(), "RenderPass::set_bind_group"); - } + self.pass.set_bind_group(index, bg, offsets); } fn set_index_buffer( @@ -2597,16 +2579,8 @@ impl dispatch::RenderPassInterface for CoreRenderPass { ) { let buffer = buffer.as_core(); - if let Err(cause) = - self.pass - .set_index_buffer(buffer.wgpu_buffer.clone(), index_format, offset, size) - { - self.pass.device().handle_error( - cause, - self.pass.label(), - "RenderPass::set_index_buffer", - ); - } + self.pass + .set_index_buffer(buffer.wgpu_buffer.clone(), index_format, offset, size) } fn set_vertex_buffer( @@ -2618,41 +2592,19 @@ impl dispatch::RenderPassInterface for CoreRenderPass { ) { let buffer = buffer.map(|buffer| buffer.as_core().wgpu_buffer.clone()); - if let Err(cause) = self.pass.set_vertex_buffer(slot, buffer, offset, size) { - self.pass.device().handle_error( - cause, - self.pass.label(), - "RenderPass::set_vertex_buffer", - ); - } + self.pass.set_vertex_buffer(slot, buffer, offset, size); } fn set_immediates(&mut self, offset: u32, data: &[u8]) { - if let Err(cause) = self.pass.set_immediates(offset, data) { - self.pass - .device() - .handle_error(cause, self.pass.label(), "RenderPass::set_immediates"); - } + self.pass.set_immediates(offset, data); } fn set_blend_constant(&mut self, color: crate::Color) { - if let Err(cause) = self.pass.set_blend_constant(color) { - self.pass.device().handle_error( - cause, - self.pass.label(), - "RenderPass::set_blend_constant", - ); - } + self.pass.set_blend_constant(color); } fn set_scissor_rect(&mut self, x: u32, y: u32, width: u32, height: u32) { - if let Err(cause) = self.pass.set_scissor_rect(x, y, width, height) { - self.pass.device().handle_error( - cause, - self.pass.label(), - "RenderPass::set_scissor_rect", - ); - } + self.pass.set_scissor_rect(x, y, width, height); } fn set_viewport( @@ -2664,64 +2616,36 @@ impl dispatch::RenderPassInterface for CoreRenderPass { min_depth: f32, max_depth: f32, ) { - if let Err(cause) = self - .pass - .set_viewport(x, y, width, height, min_depth, max_depth) - { - self.pass - .device() - .handle_error(cause, self.pass.label(), "RenderPass::set_viewport"); - } + self.pass + .set_viewport(x, y, width, height, min_depth, max_depth); } fn set_stencil_reference(&mut self, reference: u32) { - if let Err(cause) = self.pass.set_stencil_reference(reference) { - self.pass.device().handle_error( - cause, - self.pass.label(), - "RenderPass::set_stencil_reference", - ); - } + self.pass.set_stencil_reference(reference); } fn draw(&mut self, vertices: Range, instances: Range) { - if let Err(cause) = self.pass.draw( + self.pass.draw( vertices.end - vertices.start, instances.end - instances.start, vertices.start, instances.start, - ) { - self.pass - .device() - .handle_error(cause, self.pass.label(), "RenderPass::draw"); - } + ); } fn draw_indexed(&mut self, indices: Range, base_vertex: i32, instances: Range) { - if let Err(cause) = self.pass.draw_indexed( + self.pass.draw_indexed( indices.end - indices.start, instances.end - instances.start, indices.start, base_vertex, instances.start, - ) { - self.pass - .device() - .handle_error(cause, self.pass.label(), "RenderPass::draw_indexed"); - } + ); } fn draw_mesh_tasks(&mut self, group_count_x: u32, group_count_y: u32, group_count_z: u32) { - if let Err(cause) = self - .pass - .draw_mesh_tasks(group_count_x, group_count_y, group_count_z) - { - self.pass.device().handle_error( - cause, - self.pass.label(), - "RenderPass::draw_mesh_tasks", - ); - } + self.pass + .draw_mesh_tasks(group_count_x, group_count_y, group_count_z); } fn draw_indirect( @@ -2731,14 +2655,8 @@ impl dispatch::RenderPassInterface for CoreRenderPass { ) { let indirect_buffer = indirect_buffer.as_core(); - if let Err(cause) = self - .pass - .draw_indirect(indirect_buffer.wgpu_buffer.clone(), indirect_offset) - { - self.pass - .device() - .handle_error(cause, self.pass.label(), "RenderPass::draw_indirect"); - } + self.pass + .draw_indirect(indirect_buffer.wgpu_buffer.clone(), indirect_offset); } fn draw_indexed_indirect( @@ -2748,16 +2666,8 @@ impl dispatch::RenderPassInterface for CoreRenderPass { ) { let indirect_buffer = indirect_buffer.as_core(); - if let Err(cause) = self - .pass - .draw_indexed_indirect(indirect_buffer.wgpu_buffer.clone(), indirect_offset) - { - self.pass.device().handle_error( - cause, - self.pass.label(), - "RenderPass::draw_indexed_indirect", - ); - } + self.pass + .draw_indexed_indirect(indirect_buffer.wgpu_buffer.clone(), indirect_offset); } fn draw_mesh_tasks_indirect( @@ -2767,16 +2677,8 @@ impl dispatch::RenderPassInterface for CoreRenderPass { ) { let indirect_buffer = indirect_buffer.as_core(); - if let Err(cause) = self - .pass - .draw_mesh_tasks_indirect(indirect_buffer.wgpu_buffer.clone(), indirect_offset) - { - self.pass.device().handle_error( - cause, - self.pass.label(), - "RenderPass::draw_mesh_tasks_indirect", - ); - } + self.pass + .draw_mesh_tasks_indirect(indirect_buffer.wgpu_buffer.clone(), indirect_offset); } fn multi_draw_indirect( @@ -2787,17 +2689,8 @@ impl dispatch::RenderPassInterface for CoreRenderPass { ) { let indirect_buffer = indirect_buffer.as_core(); - if let Err(cause) = self.pass.multi_draw_indirect( - indirect_buffer.wgpu_buffer.clone(), - indirect_offset, - count, - ) { - self.pass.device().handle_error( - cause, - self.pass.label(), - "RenderPass::multi_draw_indirect", - ); - } + self.pass + .multi_draw_indirect(indirect_buffer.wgpu_buffer.clone(), indirect_offset, count); } fn multi_draw_indexed_indirect( @@ -2808,17 +2701,11 @@ impl dispatch::RenderPassInterface for CoreRenderPass { ) { let indirect_buffer = indirect_buffer.as_core(); - if let Err(cause) = self.pass.multi_draw_indexed_indirect( + self.pass.multi_draw_indexed_indirect( indirect_buffer.wgpu_buffer.clone(), indirect_offset, count, - ) { - self.pass.device().handle_error( - cause, - self.pass.label(), - "RenderPass::multi_draw_indexed_indirect", - ); - } + ); } fn multi_draw_mesh_tasks_indirect( @@ -2829,17 +2716,11 @@ impl dispatch::RenderPassInterface for CoreRenderPass { ) { let indirect_buffer = indirect_buffer.as_core(); - if let Err(cause) = self.pass.multi_draw_mesh_tasks_indirect( + self.pass.multi_draw_mesh_tasks_indirect( indirect_buffer.wgpu_buffer.clone(), indirect_offset, count, - ) { - self.pass.device().handle_error( - cause, - self.pass.label(), - "RenderPass::multi_draw_mesh_tasks_indirect", - ); - } + ); } fn multi_draw_indirect_count( @@ -2853,19 +2734,13 @@ impl dispatch::RenderPassInterface for CoreRenderPass { let indirect_buffer = indirect_buffer.as_core(); let count_buffer = count_buffer.as_core(); - if let Err(cause) = self.pass.multi_draw_indirect_count( + self.pass.multi_draw_indirect_count( indirect_buffer.wgpu_buffer.clone(), indirect_offset, count_buffer.wgpu_buffer.clone(), count_buffer_offset, max_count, - ) { - self.pass.device().handle_error( - cause, - self.pass.label(), - "RenderPass::multi_draw_indirect_count", - ); - } + ); } fn multi_draw_indexed_indirect_count( @@ -2879,19 +2754,13 @@ impl dispatch::RenderPassInterface for CoreRenderPass { let indirect_buffer = indirect_buffer.as_core(); let count_buffer = count_buffer.as_core(); - if let Err(cause) = self.pass.multi_draw_indexed_indirect_count( + self.pass.multi_draw_indexed_indirect_count( indirect_buffer.wgpu_buffer.clone(), indirect_offset, count_buffer.wgpu_buffer.clone(), count_buffer_offset, max_count, - ) { - self.pass.device().handle_error( - cause, - self.pass.label(), - "RenderPass::multi_draw_indexed_indirect_count", - ); - } + ); } fn multi_draw_mesh_tasks_indirect_count( @@ -2905,84 +2774,40 @@ impl dispatch::RenderPassInterface for CoreRenderPass { let indirect_buffer = indirect_buffer.as_core(); let count_buffer = count_buffer.as_core(); - if let Err(cause) = self.pass.multi_draw_mesh_tasks_indirect_count( + self.pass.multi_draw_mesh_tasks_indirect_count( indirect_buffer.wgpu_buffer.clone(), indirect_offset, count_buffer.wgpu_buffer.clone(), count_buffer_offset, max_count, - ) { - self.pass.device().handle_error( - cause, - self.pass.label(), - "RenderPass::multi_draw_mesh_tasks_indirect_count", - ); - } + ); } fn insert_debug_marker(&mut self, label: &str) { - if let Err(cause) = self.pass.insert_debug_marker(label, 0) { - self.pass.device().handle_error( - cause, - self.pass.label(), - "RenderPass::insert_debug_marker", - ); - } + self.pass.insert_debug_marker(label, 0); } fn push_debug_group(&mut self, group_label: &str) { - if let Err(cause) = self.pass.push_debug_group(group_label, 0) { - self.pass.device().handle_error( - cause, - self.pass.label(), - "RenderPass::push_debug_group", - ); - } + self.pass.push_debug_group(group_label, 0); } fn pop_debug_group(&mut self) { - if let Err(cause) = self.pass.pop_debug_group() { - self.pass.device().handle_error( - cause, - self.pass.label(), - "RenderPass::pop_debug_group", - ); - } + self.pass.pop_debug_group(); } fn write_timestamp(&mut self, query_set: &dispatch::DispatchQuerySet, query_index: u32) { let query_set = query_set.as_core(); - if let Err(cause) = self - .pass - .write_timestamp(query_set.wgpu_query_set.clone(), query_index) - { - self.pass.device().handle_error( - cause, - self.pass.label(), - "RenderPass::write_timestamp", - ); - } + self.pass + .write_timestamp(query_set.wgpu_query_set.clone(), query_index); } fn begin_occlusion_query(&mut self, query_index: u32) { - if let Err(cause) = self.pass.begin_occlusion_query(query_index) { - self.pass.device().handle_error( - cause, - self.pass.label(), - "RenderPass::begin_occlusion_query", - ); - } + self.pass.begin_occlusion_query(query_index); } fn end_occlusion_query(&mut self) { - if let Err(cause) = self.pass.end_occlusion_query() { - self.pass.device().handle_error( - cause, - self.pass.label(), - "RenderPass::end_occlusion_query", - ); - } + self.pass.end_occlusion_query(); } fn begin_pipeline_statistics_query( @@ -2992,26 +2817,12 @@ impl dispatch::RenderPassInterface for CoreRenderPass { ) { let query_set = query_set.as_core(); - if let Err(cause) = self - .pass - .begin_pipeline_statistics_query(query_set.wgpu_query_set.clone(), query_index) - { - self.pass.device().handle_error( - cause, - self.pass.label(), - "RenderPass::begin_pipeline_statistics_query", - ); - } + self.pass + .begin_pipeline_statistics_query(query_set.wgpu_query_set.clone(), query_index); } fn end_pipeline_statistics_query(&mut self) { - if let Err(cause) = self.pass.end_pipeline_statistics_query() { - self.pass.device().handle_error( - cause, - self.pass.label(), - "RenderPass::end_pipeline_statistics_query", - ); - } + self.pass.end_pipeline_statistics_query(); } fn execute_bundles( @@ -3021,23 +2832,13 @@ impl dispatch::RenderPassInterface for CoreRenderPass { let temp_render_bundles = render_bundles .map(|rb| rb.as_core().wgpu_render_bundle.clone()) .collect::>(); - if let Err(cause) = self.pass.execute_bundles(&temp_render_bundles) { - self.pass.device().handle_error( - cause, - self.pass.label(), - "RenderPass::execute_bundles", - ); - } + self.pass.execute_bundles(&temp_render_bundles); } } impl Drop for CoreRenderPass { fn drop(&mut self) { - if let Err(cause) = self.pass.end() { - self.pass - .device() - .handle_error(cause, self.pass.label(), "RenderPass::end"); - } + self.pass.end() } } @@ -3047,7 +2848,6 @@ impl dispatch::RenderBundleEncoderInterface for CoreRenderBundleEncoder { self.encoder .set_pipeline(pipeline.wgpu_render_pipeline.clone()) - .expect("RenderBundleEncoder should not have ended") } fn set_bind_group( @@ -3058,9 +2858,7 @@ impl dispatch::RenderBundleEncoderInterface for CoreRenderBundleEncoder { ) { let bg = bind_group.map(|bg| bg.as_core().wgpu_bind_group.clone()); - self.encoder - .set_bind_group(index, bg, offsets) - .expect("RenderBundleEncoder should not have ended"); + self.encoder.set_bind_group(index, bg, offsets); } fn set_index_buffer( @@ -3073,8 +2871,7 @@ impl dispatch::RenderBundleEncoderInterface for CoreRenderBundleEncoder { let buffer = buffer.as_core(); self.encoder - .set_index_buffer(buffer.wgpu_buffer.clone(), index_format, offset, size) - .expect("RenderBundleEncoder should not have ended"); + .set_index_buffer(buffer.wgpu_buffer.clone(), index_format, offset, size); } fn set_vertex_buffer( @@ -3086,9 +2883,7 @@ impl dispatch::RenderBundleEncoderInterface for CoreRenderBundleEncoder { ) { let buffer = buffer.map(|buffer| buffer.as_core().wgpu_buffer.clone()); - self.encoder - .set_vertex_buffer(slot, buffer, offset, size) - .expect("RenderBundleEncoder should not have ended"); + self.encoder.set_vertex_buffer(slot, buffer, offset, size); } fn set_immediates(&mut self, offset: u32, data: &[u8]) { @@ -3104,32 +2899,26 @@ impl dispatch::RenderBundleEncoderInterface for CoreRenderBundleEncoder { return; } - self.encoder - .set_immediates(offset, data) - .expect("RenderBundleEncoder should not have ended"); + self.encoder.set_immediates(offset, data); } fn draw(&mut self, vertices: Range, instances: Range) { - self.encoder - .draw( - vertices.end - vertices.start, - instances.end - instances.start, - vertices.start, - instances.start, - ) - .expect("RenderBundleEncoder should not have ended"); + self.encoder.draw( + vertices.end - vertices.start, + instances.end - instances.start, + vertices.start, + instances.start, + ); } fn draw_indexed(&mut self, indices: Range, base_vertex: i32, instances: Range) { - self.encoder - .draw_indexed( - indices.end - indices.start, - instances.end - instances.start, - indices.start, - base_vertex, - instances.start, - ) - .expect("RenderBundleEncoder should not have ended"); + self.encoder.draw_indexed( + indices.end - indices.start, + instances.end - instances.start, + indices.start, + base_vertex, + instances.start, + ); } fn draw_indirect( @@ -3140,8 +2929,7 @@ impl dispatch::RenderBundleEncoderInterface for CoreRenderBundleEncoder { let indirect_buffer = indirect_buffer.as_core(); self.encoder - .draw_indirect(indirect_buffer.wgpu_buffer.clone(), indirect_offset) - .expect("RenderBundleEncoder should not have ended"); + .draw_indirect(indirect_buffer.wgpu_buffer.clone(), indirect_offset); } fn draw_indexed_indirect( @@ -3152,23 +2940,14 @@ impl dispatch::RenderBundleEncoderInterface for CoreRenderBundleEncoder { let indirect_buffer = indirect_buffer.as_core(); self.encoder - .draw_indexed_indirect(indirect_buffer.wgpu_buffer.clone(), indirect_offset) - .expect("RenderBundleEncoder should not have ended"); + .draw_indexed_indirect(indirect_buffer.wgpu_buffer.clone(), indirect_offset); } fn finish(mut self, desc: &crate::RenderBundleDescriptor<'_>) -> dispatch::DispatchRenderBundle where Self: Sized, { - let label = self.encoder.label().map(alloc::string::ToString::to_string); - let (wgpu_render_bundle, error) = self.encoder.finish(&desc.map_label(|l| l.map(Borrowed))); - if let Some(err) = error { - self.encoder.device().handle_error( - err, - label.as_deref(), - "RenderBundleEncoder::finish", - ); - } + let wgpu_render_bundle = self.encoder.finish(&desc.map_label(|l| l.map(Borrowed))); CoreRenderBundle { wgpu_render_bundle }.into() }