mod bind; mod bundle; mod clear; mod compute; mod draw; mod memory_init; mod query; mod render; mod transfer; use std::slice; pub(crate) use self::clear::clear_texture; pub use self::{ bundle::*, clear::ClearError, compute::*, draw::*, query::*, render::*, transfer::*, }; use self::memory_init::CommandBufferTextureMemoryActions; use crate::error::{ErrorFormatter, PrettyError}; use crate::init_tracker::BufferInitTrackerAction; use crate::track::{Tracker, UsageScope}; use crate::{ global::Global, hal_api::HalApi, hub::Token, id, identity::GlobalIdentityHandlerFactory, resource::{Buffer, Texture}, storage::Storage, Label, Stored, }; use hal::CommandEncoder as _; use thiserror::Error; #[cfg(feature = "trace")] use crate::device::trace::Command as TraceCommand; const PUSH_CONSTANT_CLEAR_ARRAY: &[u32] = &[0_u32; 64]; #[derive(Debug)] enum CommandEncoderStatus { Recording, Finished, Error, } struct CommandEncoder { raw: A::CommandEncoder, list: Vec, is_open: bool, label: Option, } //TODO: handle errors better impl CommandEncoder { /// Closes the live encoder fn close_and_swap(&mut self) { if self.is_open { self.is_open = false; let new = unsafe { self.raw.end_encoding().unwrap() }; self.list.insert(self.list.len() - 1, new); } } fn close(&mut self) { if self.is_open { self.is_open = false; let cmd_buf = unsafe { self.raw.end_encoding().unwrap() }; self.list.push(cmd_buf); } } fn discard(&mut self) { if self.is_open { self.is_open = false; unsafe { self.raw.discard_encoding() }; } } fn open(&mut self) -> &mut A::CommandEncoder { if !self.is_open { self.is_open = true; let label = self.label.as_deref(); unsafe { self.raw.begin_encoding(label).unwrap() }; } &mut self.raw } fn open_pass(&mut self, label: Option<&str>) { self.is_open = true; unsafe { self.raw.begin_encoding(label).unwrap() }; } } pub struct BakedCommands { pub(crate) encoder: A::CommandEncoder, pub(crate) list: Vec, pub(crate) trackers: Tracker, buffer_memory_init_actions: Vec, texture_memory_actions: CommandBufferTextureMemoryActions, } pub(crate) struct DestroyedBufferError(pub id::BufferId); pub(crate) struct DestroyedTextureError(pub id::TextureId); pub struct CommandBuffer { encoder: CommandEncoder, status: CommandEncoderStatus, pub(crate) device_id: Stored, pub(crate) trackers: Tracker, buffer_memory_init_actions: Vec, texture_memory_actions: CommandBufferTextureMemoryActions, limits: wgt::Limits, support_clear_texture: bool, #[cfg(feature = "trace")] pub(crate) commands: Option>, } impl CommandBuffer { pub(crate) fn new( encoder: A::CommandEncoder, device_id: Stored, limits: wgt::Limits, _downlevel: wgt::DownlevelCapabilities, features: wgt::Features, #[cfg(feature = "trace")] enable_tracing: bool, label: &Label, ) -> Self { CommandBuffer { encoder: CommandEncoder { raw: encoder, is_open: false, list: Vec::new(), label: crate::LabelHelpers::borrow_option(label).map(|s| s.to_string()), }, status: CommandEncoderStatus::Recording, device_id, trackers: Tracker::new(), buffer_memory_init_actions: Default::default(), texture_memory_actions: Default::default(), limits, support_clear_texture: features.contains(wgt::Features::CLEAR_TEXTURE), #[cfg(feature = "trace")] commands: if enable_tracing { Some(Vec::new()) } else { None }, } } pub(crate) fn insert_barriers_from_tracker( raw: &mut A::CommandEncoder, base: &mut Tracker, head: &Tracker, buffer_guard: &Storage, id::BufferId>, texture_guard: &Storage, id::TextureId>, ) { profiling::scope!("insert_barriers"); base.buffers.set_from_tracker(&head.buffers); base.textures .set_from_tracker(texture_guard, &head.textures); Self::drain_barriers(raw, base, buffer_guard, texture_guard); } pub(crate) fn insert_barriers_from_scope( raw: &mut A::CommandEncoder, base: &mut Tracker, head: &UsageScope, buffer_guard: &Storage, id::BufferId>, texture_guard: &Storage, id::TextureId>, ) { profiling::scope!("insert_barriers"); base.buffers.set_from_usage_scope(&head.buffers); base.textures .set_from_usage_scope(texture_guard, &head.textures); Self::drain_barriers(raw, base, buffer_guard, texture_guard); } pub(crate) fn drain_barriers( raw: &mut A::CommandEncoder, base: &mut Tracker, buffer_guard: &Storage, id::BufferId>, texture_guard: &Storage, id::TextureId>, ) { profiling::scope!("drain_barriers"); let buffer_barriers = base.buffers.drain().map(|pending| { let buf = unsafe { &buffer_guard.get_unchecked(pending.id) }; pending.into_hal(buf) }); let texture_barriers = base.textures.drain().map(|pending| { let tex = unsafe { texture_guard.get_unchecked(pending.id) }; pending.into_hal(tex) }); unsafe { raw.transition_buffers(buffer_barriers); raw.transition_textures(texture_barriers); } } } impl CommandBuffer { fn get_encoder_mut( storage: &mut Storage, id: id::CommandEncoderId, ) -> Result<&mut Self, CommandEncoderError> { match storage.get_mut(id) { Ok(cmd_buf) => match cmd_buf.status { CommandEncoderStatus::Recording => Ok(cmd_buf), CommandEncoderStatus::Finished => Err(CommandEncoderError::NotRecording), CommandEncoderStatus::Error => Err(CommandEncoderError::Invalid), }, Err(_) => Err(CommandEncoderError::Invalid), } } pub fn is_finished(&self) -> bool { match self.status { CommandEncoderStatus::Finished => true, _ => false, } } pub(crate) fn into_baked(self) -> BakedCommands { BakedCommands { encoder: self.encoder.raw, list: self.encoder.list, trackers: self.trackers, buffer_memory_init_actions: self.buffer_memory_init_actions, texture_memory_actions: self.texture_memory_actions, } } } impl crate::resource::Resource for CommandBuffer { const TYPE: &'static str = "CommandBuffer"; fn life_guard(&self) -> &crate::LifeGuard { unreachable!() } fn label(&self) -> &str { self.encoder.label.as_ref().map_or("", |s| s.as_str()) } } #[derive(Copy, Clone, Debug)] pub struct BasePassRef<'a, C> { pub label: Option<&'a str>, pub commands: &'a [C], pub dynamic_offsets: &'a [wgt::DynamicOffset], pub string_data: &'a [u8], pub push_constant_data: &'a [u32], } /// A stream of commands for a render pass or compute pass. /// /// This also contains side tables referred to by certain commands, /// like dynamic offsets for [`SetBindGroup`] or string data for /// [`InsertDebugMarker`]. /// /// Render passes use `BasePass`, whereas compute /// passes use `BasePass`. /// /// [`SetBindGroup`]: RenderCommand::SetBindGroup /// [`InsertDebugMarker`]: RenderCommand::InsertDebugMarker #[doc(hidden)] #[derive(Debug)] #[cfg_attr( any(feature = "serial-pass", feature = "trace"), derive(serde::Serialize) )] #[cfg_attr( any(feature = "serial-pass", feature = "replay"), derive(serde::Deserialize) )] pub struct BasePass { pub label: Option, /// The stream of commands. pub commands: Vec, /// Dynamic offsets consumed by [`SetBindGroup`] commands in `commands`. /// /// Each successive `SetBindGroup` consumes the next /// [`num_dynamic_offsets`] values from this list. pub dynamic_offsets: Vec, /// Strings used by debug instructions. /// /// Each successive [`PushDebugGroup`] or [`InsertDebugMarker`] /// instruction consumes the next `len` bytes from this vector. pub string_data: Vec, /// Data used by `SetPushConstant` instructions. /// /// See the documentation for [`RenderCommand::SetPushConstant`] /// and [`ComputeCommand::SetPushConstant`] for details. pub push_constant_data: Vec, } impl BasePass { fn new(label: &Label) -> Self { Self { label: label.as_ref().map(|cow| cow.to_string()), commands: Vec::new(), dynamic_offsets: Vec::new(), string_data: Vec::new(), push_constant_data: Vec::new(), } } #[cfg(feature = "trace")] fn from_ref(base: BasePassRef) -> Self { Self { label: base.label.map(str::to_string), commands: base.commands.to_vec(), dynamic_offsets: base.dynamic_offsets.to_vec(), string_data: base.string_data.to_vec(), push_constant_data: base.push_constant_data.to_vec(), } } pub fn as_ref(&self) -> BasePassRef { BasePassRef { label: self.label.as_deref(), commands: &self.commands, dynamic_offsets: &self.dynamic_offsets, string_data: &self.string_data, push_constant_data: &self.push_constant_data, } } } #[derive(Clone, Debug, Error)] #[non_exhaustive] pub enum CommandEncoderError { #[error("Command encoder is invalid")] Invalid, #[error("Command encoder must be active")] NotRecording, } impl Global { pub fn command_encoder_finish( &self, encoder_id: id::CommandEncoderId, _desc: &wgt::CommandBufferDescriptor