[core] Add IDed RenderBundleEncoder methods on Global (#9778)

Signed-off-by: sagudev <16504129+sagudev@users.noreply.github.com>
This commit is contained in:
Sam authored and GitHub committed 2026-07-01 11:14:54 +02:00
1 parent afbab7b298
commit 74ae0435e6
3 files changed
+245 -3

No files matched your search

+195 -1
View File
@@ -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<id::RenderPipelineId>,
}
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<id::BindGroupId>,
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<id::BufferId>,
offset: wgt::BufferAddress,
size: Option<wgt::BufferSize>,
) -> 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<wgt::BufferSize>,
) -> 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 {
+43 -1
View File
@@ -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>,
) -> (
id::RenderBundleEncoderId,
Option<command::CreateRenderBundleError>,
) {
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<command::RenderBundleEncoder>,
bundle_encoder: &mut command::RenderBundleEncoder,
desc: &command::RenderBundleDescriptor,
id_in: Option<id::RenderBundleId>,
) -> (id::RenderBundleId, Option<command::RenderBundleError>) {
@@ -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>,
) -> (id::RenderBundleId, Option<command::RenderBundleError>) {
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:?}");
+7 -1
View File
@@ -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<Fallible<Tlas>>,
pub(crate) render_passes: Registry<Arc<Mutex<RenderPass>>>,
pub(crate) compute_passes: Registry<Arc<Mutex<ComputePass>>>,
pub(crate) render_bundle_encoders: Registry<Arc<Mutex<RenderBundleEncoder>>>,
}
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(),
}
}
}