Handle RenderPass errors inside wgpu-core

Signed-off-by: sagudev <16504129+sagudev@users.noreply.github.com>
This commit is contained in:
sagudev authored and Teodor Tanasoaia committed 2026-08-19 15:23:27 +02:00
1 parent 00fca71151
commit c64625f092
10 files changed
+773 -673

No files matched your search

+1 -4
View File
@@ -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,
})
-1
View File
@@ -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,
}
+53 -88
View File
@@ -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<Box<wgpu_core::command::RenderBundleEncoder>>,
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 = <Option<Vec<u32>>>::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(())
}
}
+78 -148
View File
@@ -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<wgpu_core::command::RenderPass>,
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<Ptr<GPURenderBundle>>) {
let err = self
.render_pass
.borrow_mut()
.execute_bundles(
&bundles
.into_iter()
.map(|bundle| bundle.wgpu_render_bundle.clone())
.collect::<Vec<_>>(),
)
.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::<Vec<_>>(),
);
}
#[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::<v8::Uint32Array>()
{
if let Ok(uint_32) = dynamic_offsets.try_cast::<v8::Uint32Array>() {
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 = <Option<Vec<u32>>>::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<crate::render_pipeline::GPURenderPipeline>,
) {
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<u64>,
) {
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<u64>,
) {
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<GPUBuffer>,
#[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<GPUBuffer>,
#[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(())
}
}
+12 -16
View File
@@ -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<id::BindGroupId>,
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<id::BufferId>,
offset: wgt::BufferAddress,
size: Option<wgt::BufferSize>,
) -> 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<wgt::BufferSize>,
) -> 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);
+3 -5
View File
@@ -721,7 +721,7 @@ impl Global {
render_bundle_encoder_id: id::RenderBundleEncoderId,
desc: &command::RenderBundleDescriptor,
id_in: id::RenderBundleId,
) -> (id::RenderBundleId, Option<command::RenderBundleError>) {
) {
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) {
+28 -46
View File
@@ -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<CommandEncoderError>) {
) {
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<id::BindGroupId>,
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<BufferSize>,
) -> Result<(), PassStateError> {
) {
let mut hub = self.hub.borrow_mut();
let Hub {
render_passes,
@@ -183,7 +182,7 @@ impl Global {
buffer_id: Option<id::BufferId>,
offset: BufferAddress,
size: Option<BufferSize>,
) -> 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,
+147 -24
View File
@@ -303,10 +303,7 @@ impl RenderBundleEncoder {
/// and accumulate buffer and texture initialization actions.
///
/// [`ExecuteBundle`]: RenderCommand::ExecuteBundle
pub fn finish(
&mut self,
desc: &RenderBundleDescriptor,
) -> (Arc<RenderBundle>, Option<RenderBundleError>) {
pub fn finish(&mut self, desc: &RenderBundleDescriptor) -> Arc<RenderBundle> {
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<Buffer>,
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<Buffer>,
index_format: wgt::IndexFormat,
offset: wgt::BufferAddress,
size: Option<wgt::BufferSize>,
) {
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<Arc<BindGroup>>,
@@ -619,7 +627,19 @@ impl RenderBundleEncoder {
Ok(())
}
pub fn set_pipeline(&mut self, pipeline: Arc<RenderPipeline>) -> Result<(), PassStateError> {
pub fn set_bind_group(
&mut self,
index: u32,
bind_group: Option<Arc<BindGroup>>,
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<RenderPipeline>) -> 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<RenderPipeline>) {
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<Arc<Buffer>>,
@@ -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<Arc<Buffer>>,
offset: wgt::BufferAddress,
size: Option<wgt::BufferSize>,
) {
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<Buffer>,
offset: wgt::BufferAddress,
@@ -735,7 +817,14 @@ impl RenderBundleEncoder {
Ok(())
}
pub fn draw_indexed_indirect(
pub fn draw_indirect(&mut self, buffer: Arc<Buffer>, 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<Buffer>,
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<Buffer>, 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(
+382 -51
View File
@@ -1812,7 +1812,7 @@ fn check_transient_attachment_ops<V>(load_op: LoadOp<V>, store_op: StoreOp) -> b
}
impl CommandEncoder {
pub fn begin_render_pass(
fn begin_render_pass_inner(
self: &Arc<Self>,
desc: ResolvedRenderPassDescriptor<'_>,
) -> (RenderPass, Option<CommandEncoderError>) {
@@ -2129,10 +2129,22 @@ impl CommandEncoder {
}
}
}
pub fn begin_render_pass(
self: &Arc<Self>,
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<Arc<BindGroup>>,
@@ -3573,7 +3592,19 @@ impl RenderPass {
Ok(())
}
pub fn set_pipeline(&mut self, pipeline: Arc<RenderPipeline>) -> Result<(), PassStateError> {
pub fn set_bind_group(
&mut self,
index: u32,
bind_group: Option<Arc<BindGroup>>,
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<RenderPipeline>) -> 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<RenderPipeline>) {
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<Buffer>,
index_format: IndexFormat,
@@ -3615,7 +3653,20 @@ impl RenderPass {
Ok(())
}
pub fn set_vertex_buffer(
pub fn set_index_buffer(
&mut self,
buffer: Arc<Buffer>,
index_format: IndexFormat,
offset: BufferAddress,
size: Option<BufferSize>,
) {
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<Arc<Buffer>>,
@@ -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<Arc<Buffer>>,
offset: BufferAddress,
size: Option<BufferSize>,
) {
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<Buffer>,
offset: BufferAddress,
@@ -3819,7 +3960,14 @@ impl RenderPass {
Ok(())
}
pub fn draw_indexed_indirect(
pub fn draw_indirect(&mut self, buffer: Arc<Buffer>, 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<Buffer>,
offset: BufferAddress,
@@ -3845,7 +3993,14 @@ impl RenderPass {
Ok(())
}
pub fn draw_mesh_tasks_indirect(
pub fn draw_indexed_indirect(&mut self, buffer: Arc<Buffer>, 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<Buffer>,
offset: BufferAddress,
@@ -3871,7 +4026,14 @@ impl RenderPass {
Ok(())
}
pub fn multi_draw_indirect(
pub fn draw_mesh_tasks_indirect(&mut self, buffer: Arc<Buffer>, 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<Buffer>,
offset: BufferAddress,
@@ -3898,34 +4060,53 @@ impl RenderPass {
Ok(())
}
pub fn multi_draw_indirect(&mut self, buffer: Arc<Buffer>, 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<Buffer>,
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<Buffer>,
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<Buffer>,
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<Buffer>,
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<Buffer>,
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<Buffer>,
offset: BufferAddress,
count_buffer: Arc<Buffer>,
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<Buffer>,
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<Buffer>,
offset: BufferAddress,
count_buffer: Arc<Buffer>,
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<Buffer>,
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<Buffer>,
offset: BufferAddress,
count_buffer: Arc<Buffer>,
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<QuerySet>,
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<QuerySet>, 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<QuerySet>,
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<QuerySet>, 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<RenderBundle>],
) -> Result<(), PassStateError> {
@@ -4159,6 +4483,13 @@ impl RenderPass {
Ok(())
}
pub fn execute_bundles(&mut self, render_bundles: &[Arc<RenderBundle>]) {
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 {
+69 -290
View File
@@ -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<u32>, instances: Range<u32>) {
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<u32>, base_vertex: i32, instances: Range<u32>) {
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::<SmallVec<[_; 4]>>();
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<u32>, instances: Range<u32>) {
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<u32>, base_vertex: i32, instances: Range<u32>) {
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()
}