diff --git a/wgpu-core/src/command/bundle.rs b/wgpu-core/src/command/bundle.rs index 3236e8ec1..e34b3fc6b 100644 --- a/wgpu-core/src/command/bundle.rs +++ b/wgpu-core/src/command/bundle.rs @@ -111,7 +111,7 @@ use crate::{ RenderPassContext, }, hub::Hub, - id, + id, impl_resource_type, impl_storage_item, init_tracker::{BufferInitTrackerAction, MemoryInitKind, TextureInitTrackerAction}, pipeline::{PipelineFlags, RenderPipeline}, resource::{ @@ -181,6 +181,9 @@ pub struct RenderBundleEncoder { current_pipeline: StateChange, } +impl_resource_type!(RenderBundleEncoder); +impl_storage_item!(RenderBundleEncoder); + /// Validate a render bundle descriptor. /// /// The underlying `device` is required to fully validate the descriptor. @@ -1834,6 +1837,22 @@ impl crate::global::Global { bundle.set_bind_group(index, bind_group_id, offsets) } + pub fn render_bundle_encoder_set_bind_group_with_id( + &self, + bundle_encoder: id::RenderBundleEncoderId, + index: u32, + bind_group_id: Option, + offsets: &[wgt::DynamicOffset], + ) -> Result<(), PassStateError> { + let bundle_encoder = self.hub.render_bundle_encoders.get(bundle_encoder); + + let mut bundle_encoder = bundle_encoder + .try_lock() + .expect("RenderBundleEncoders should not be accessed concurrently"); + + bundle_encoder.set_bind_group(index, bind_group_id, offsets) + } + pub fn render_bundle_encoder_set_pipeline( &self, bundle: &mut RenderBundleEncoder, @@ -1842,6 +1861,20 @@ impl crate::global::Global { bundle.set_pipeline(pipeline_id) } + pub fn render_bundle_encoder_set_pipeline_with_id( + &self, + bundle_encoder: id::RenderBundleEncoderId, + pipeline_id: id::RenderPipelineId, + ) -> Result<(), PassStateError> { + let bundle_encoder = self.hub.render_bundle_encoders.get(bundle_encoder); + + let mut bundle_encoder = bundle_encoder + .try_lock() + .expect("RenderBundleEncoders should not be accessed concurrently"); + + bundle_encoder.set_pipeline(pipeline_id) + } + pub fn render_bundle_encoder_set_vertex_buffer( &self, bundle: &mut RenderBundleEncoder, @@ -1853,6 +1886,23 @@ impl crate::global::Global { bundle.set_vertex_buffer(slot, buffer_id, offset, size) } + pub fn render_bundle_encoder_set_vertex_buffer_with_id( + &self, + bundle_encoder: id::RenderBundleEncoderId, + slot: u32, + buffer_id: Option, + offset: wgt::BufferAddress, + size: Option, + ) -> Result<(), PassStateError> { + let bundle_encoder = self.hub.render_bundle_encoders.get(bundle_encoder); + + let mut bundle_encoder = bundle_encoder + .try_lock() + .expect("RenderBundleEncoders should not be accessed concurrently"); + + bundle_encoder.set_vertex_buffer(slot, buffer_id, offset, size) + } + pub fn render_bundle_encoder_set_index_buffer( &self, encoder: &mut RenderBundleEncoder, @@ -1864,6 +1914,23 @@ impl crate::global::Global { encoder.set_index_buffer(buffer, index_format, offset, size) } + pub fn render_bundle_encoder_set_index_buffer_with_id( + &self, + bundle_encoder: id::RenderBundleEncoderId, + buffer: id::BufferId, + index_format: wgt::IndexFormat, + offset: wgt::BufferAddress, + size: Option, + ) -> Result<(), PassStateError> { + let bundle_encoder = self.hub.render_bundle_encoders.get(bundle_encoder); + + let mut bundle_encoder = bundle_encoder + .try_lock() + .expect("RenderBundleEncoders should not be accessed concurrently"); + + bundle_encoder.set_index_buffer(buffer, index_format, offset, size) + } + pub fn render_bundle_encoder_set_immediates( &self, pass: &mut RenderBundleEncoder, @@ -1873,6 +1940,21 @@ impl crate::global::Global { pass.set_immediates(offset, data) } + pub fn render_bundle_encoder_set_immediates_with_id( + &self, + bundle_encoder: id::RenderBundleEncoderId, + offset: u32, + data: &[u8], + ) -> Result<(), PassStateError> { + let bundle_encoder = self.hub.render_bundle_encoders.get(bundle_encoder); + + let mut bundle_encoder = bundle_encoder + .try_lock() + .expect("RenderBundleEncoders should not be accessed concurrently"); + + bundle_encoder.set_immediates(offset, data) + } + pub fn render_bundle_encoder_draw( &self, bundle: &mut RenderBundleEncoder, @@ -1884,6 +1966,23 @@ impl crate::global::Global { bundle.draw(vertex_count, instance_count, first_vertex, first_instance) } + pub fn render_bundle_encoder_draw_with_id( + &self, + bundle_encoder: id::RenderBundleEncoderId, + vertex_count: u32, + instance_count: u32, + first_vertex: u32, + first_instance: u32, + ) -> Result<(), PassStateError> { + let bundle_encoder = self.hub.render_bundle_encoders.get(bundle_encoder); + + let mut bundle_encoder = bundle_encoder + .try_lock() + .expect("RenderBundleEncoders should not be accessed concurrently"); + + bundle_encoder.draw(vertex_count, instance_count, first_vertex, first_instance) + } + pub fn render_bundle_encoder_draw_indexed( &self, bundle: &mut RenderBundleEncoder, @@ -1902,6 +2001,30 @@ impl crate::global::Global { ) } + pub fn render_bundle_encoder_draw_indexed_with_id( + &self, + bundle_encoder: id::RenderBundleEncoderId, + index_count: u32, + instance_count: u32, + first_index: u32, + base_vertex: i32, + first_instance: u32, + ) -> Result<(), PassStateError> { + let bundle_encoder = self.hub.render_bundle_encoders.get(bundle_encoder); + + let mut bundle_encoder = bundle_encoder + .try_lock() + .expect("RenderBundleEncoders should not be accessed concurrently"); + + bundle_encoder.draw_indexed( + index_count, + instance_count, + first_index, + base_vertex, + first_instance, + ) + } + pub fn render_bundle_encoder_draw_indirect( &self, bundle: &mut RenderBundleEncoder, @@ -1911,6 +2034,21 @@ impl crate::global::Global { bundle.draw_indirect(buffer_id, offset) } + pub fn render_bundle_encoder_draw_indirect_with_id( + &self, + bundle_encoder: id::RenderBundleEncoderId, + buffer_id: id::BufferId, + offset: wgt::BufferAddress, + ) -> Result<(), PassStateError> { + let bundle_encoder = self.hub.render_bundle_encoders.get(bundle_encoder); + + let mut bundle_encoder = bundle_encoder + .try_lock() + .expect("RenderBundleEncoders should not be accessed concurrently"); + + bundle_encoder.draw_indirect(buffer_id, offset) + } + pub fn render_bundle_encoder_draw_indexed_indirect( &self, bundle: &mut RenderBundleEncoder, @@ -1920,6 +2058,21 @@ impl crate::global::Global { bundle.draw_indexed_indirect(buffer_id, offset) } + pub fn render_bundle_encoder_draw_indexed_indirect_with_id( + &self, + bundle_encoder: id::RenderBundleEncoderId, + buffer_id: id::BufferId, + offset: wgt::BufferAddress, + ) -> Result<(), PassStateError> { + let bundle_encoder = self.hub.render_bundle_encoders.get(bundle_encoder); + + let mut bundle_encoder = bundle_encoder + .try_lock() + .expect("RenderBundleEncoders should not be accessed concurrently"); + + bundle_encoder.draw_indexed_indirect(buffer_id, offset) + } + pub fn render_bundle_encoder_push_debug_group( &self, bundle: &mut RenderBundleEncoder, @@ -1928,6 +2081,20 @@ impl crate::global::Global { bundle.push_debug_group(label) } + pub fn render_bundle_encoder_push_debug_group_with_id( + &self, + bundle_encoder: id::RenderBundleEncoderId, + label: &str, + ) -> Result<(), PassStateError> { + let bundle_encoder = self.hub.render_bundle_encoders.get(bundle_encoder); + + let mut bundle_encoder = bundle_encoder + .try_lock() + .expect("RenderBundleEncoders should not be accessed concurrently"); + + bundle_encoder.push_debug_group(label) + } + pub fn render_bundle_encoder_pop_debug_group( &self, bundle: &mut RenderBundleEncoder, @@ -1935,6 +2102,19 @@ impl crate::global::Global { bundle.pop_debug_group() } + pub fn render_bundle_encoder_pop_debug_group_with_id( + &self, + bundle_encoder: id::RenderBundleEncoderId, + ) -> Result<(), PassStateError> { + let bundle_encoder = self.hub.render_bundle_encoders.get(bundle_encoder); + + let mut bundle_encoder = bundle_encoder + .try_lock() + .expect("RenderBundleEncoders should not be accessed concurrently"); + + bundle_encoder.pop_debug_group() + } + pub fn render_bundle_encoder_insert_debug_marker( &self, bundle: &mut RenderBundleEncoder, @@ -1942,6 +2122,20 @@ impl crate::global::Global { ) -> Result<(), PassStateError> { bundle.insert_debug_marker(label) } + + pub fn render_bundle_encoder_insert_debug_marker_with_id( + &self, + bundle_encoder: id::RenderBundleEncoderId, + label: &str, + ) -> Result<(), PassStateError> { + let bundle_encoder = self.hub.render_bundle_encoders.get(bundle_encoder); + + let mut bundle_encoder = bundle_encoder + .try_lock() + .expect("RenderBundleEncoders should not be accessed concurrently"); + + bundle_encoder.insert_debug_marker(label) + } } pub mod bundle_ffi { diff --git a/wgpu-core/src/device/global.rs b/wgpu-core/src/device/global.rs index 3c6ee5bb3..844c4ddc0 100644 --- a/wgpu-core/src/device/global.rs +++ b/wgpu-core/src/device/global.rs @@ -1164,9 +1164,31 @@ impl Global { (Box::new(encoder), error) } + pub fn device_create_render_bundle_encoder_with_id( + &self, + device_id: DeviceId, + desc: &command::RenderBundleEncoderDescriptor, + id_in: Option, + ) -> ( + id::RenderBundleEncoderId, + Option, + ) { + let fid = self.hub.render_bundle_encoders.prepare(id_in); + + let (render_bundle_encoder, error) = + self.device_create_render_bundle_encoder(device_id, desc); + + // no lock rank here because only one thread should be using compute pass + // and it's only used by id variants of compute pass methods on global + // so no deadlock (or concurrent lock) should happen in practise + let id = fid.assign(Arc::new(parking_lot::Mutex::new(*render_bundle_encoder))); + + (id, error) + } + pub fn render_bundle_encoder_finish( &self, - bundle_encoder: &mut Box, + bundle_encoder: &mut command::RenderBundleEncoder, desc: &command::RenderBundleDescriptor, id_in: Option, ) -> (id::RenderBundleId, Option) { @@ -1211,6 +1233,26 @@ impl Global { (id, Some(error)) } + pub fn render_bundle_encoder_finish_with_id( + &self, + render_bundle_encoder_id: id::RenderBundleEncoderId, + desc: &command::RenderBundleDescriptor, + id_in: Option, + ) -> (id::RenderBundleId, Option) { + let bundle_encoder = self + .hub + .render_bundle_encoders + .get(render_bundle_encoder_id); + + let mut bundle_encoder = bundle_encoder + .try_lock() + .expect("RenderBundleEncoders should not be accessed concurrently"); + + let (id, error) = self.render_bundle_encoder_finish(&mut bundle_encoder, desc, id_in); + + (id, error) + } + pub fn render_bundle_drop(&self, render_bundle_id: id::RenderBundleId) { profiling::scope!("RenderBundle::drop"); api_log!("RenderBundle::drop {render_bundle_id:?}"); diff --git a/wgpu-core/src/hub.rs b/wgpu-core/src/hub.rs index 8641ded54..3b22e4a14 100644 --- a/wgpu-core/src/hub.rs +++ b/wgpu-core/src/hub.rs @@ -121,7 +121,9 @@ use core::fmt::Debug; use crate::{ binding_model::{BindGroup, BindGroupLayout, PipelineLayout}, - command::{CommandBuffer, CommandEncoder, ComputePass, RenderBundle, RenderPass}, + command::{ + CommandBuffer, CommandEncoder, ComputePass, RenderBundle, RenderBundleEncoder, RenderPass, + }, device::{queue::Queue, Device}, instance::Adapter, lock::rank, @@ -158,6 +160,7 @@ pub struct HubReport { pub samplers: RegistryReport, pub render_passes: RegistryReport, pub compute_passes: RegistryReport, + pub render_bundle_encoders: RegistryReport, } impl HubReport { @@ -212,6 +215,7 @@ pub struct Hub { pub(crate) tlas_s: Registry>, pub(crate) render_passes: Registry>>, pub(crate) compute_passes: Registry>>, + pub(crate) render_bundle_encoders: Registry>>, } impl Hub { @@ -248,6 +252,7 @@ impl Hub { tlas_s: Registry::with_rank(rank::HUB_TLAS), render_passes: Registry::new(), compute_passes: Registry::new(), + render_bundle_encoders: Registry::new(), } } @@ -274,6 +279,7 @@ impl Hub { samplers: self.samplers.generate_report(), render_passes: self.render_passes.generate_report(), compute_passes: self.compute_passes.generate_report(), + render_bundle_encoders: self.render_bundle_encoders.generate_report(), } } }