1mod allocator;
12mod bind;
13mod bundle;
14mod clear;
15mod compute;
16mod compute_command;
17mod draw;
18mod encoder;
19mod encoder_command;
20pub mod ffi;
21mod memory_init;
22mod pass;
23mod query;
24mod ray_tracing;
25mod render;
26mod render_command;
27mod timestamp_writes;
28mod transfer;
29mod transition_resources;
30
31use alloc::{borrow::ToOwned as _, boxed::Box, string::String, sync::Arc, vec::Vec};
32use core::convert::Infallible;
33use core::mem::{self, ManuallyDrop};
34use core::{ops, panic};
35
36#[cfg(feature = "serde")]
37pub(crate) use self::encoder_command::serde_object_reference_struct;
38#[cfg(any(feature = "trace", feature = "replay"))]
39#[doc(hidden)]
40pub use self::encoder_command::PointerReferences;
41pub use self::{
45 bundle::{
46 bundle_ffi, CreateRenderBundleError, ExecutionError, RenderBundle, RenderBundleDescriptor,
47 RenderBundleEncoder, RenderBundleEncoderDescriptor, RenderBundleError,
48 RenderBundleErrorInner,
49 },
50 clear::ClearError,
51 compute::{
52 ComputeBasePass, ComputePass, ComputePassDescriptor, ComputePassError,
53 ComputePassErrorInner, DispatchError,
54 },
55 compute_command::ArcComputeCommand,
56 draw::{DrawError, Rect, RenderCommandError},
57 encoder_command::{ArcCommand, ArcReferences, Command, IdReferences, ReferenceType},
58 query::{QueryError, QueryUseError, ResolveError, SimplifiedQueryType},
59 render::{
60 ArcRenderPassColorAttachment, AttachmentError, AttachmentErrorLocation,
61 ColorAttachmentError, ColorAttachments, LoadOp, PassChannel, RenderBasePass, RenderPass,
62 RenderPassColorAttachment, RenderPassDepthStencilAttachment, RenderPassDescriptor,
63 RenderPassError, RenderPassErrorInner, ResolvedPassChannel,
64 ResolvedRenderPassDepthStencilAttachment, StoreOp,
65 },
66 render_command::ArcRenderCommand,
67 transfer::{CopySide, TransferError},
68 transition_resources::TransitionResourcesError,
69};
70pub(crate) use self::{
71 clear::clear_texture,
72 encoder::EncodingState,
73 memory_init::CommandBufferTextureMemoryActions,
74 render::{get_dst_stride_of_indirect_args, get_src_stride_of_indirect_args, VertexState},
75 transfer::{
76 extract_texture_selector, validate_linear_texture_data, validate_texture_buffer_copy,
77 validate_texture_copy_dst_format, validate_texture_copy_range,
78 },
79};
80
81pub(crate) use allocator::CommandAllocator;
82
83pub use self::{compute_command::ComputeCommand, render_command::RenderCommand};
85
86pub(crate) use timestamp_writes::ArcPassTimestampWrites;
87pub use timestamp_writes::PassTimestampWrites;
88
89use crate::binding_model::BindingError;
90use crate::device::queue::TempResource;
91use crate::device::{Device, DeviceError, MissingFeatures};
92use crate::id::Id;
93use crate::lock::{rank, Mutex};
94use crate::snatch::SnatchGuard;
95
96use crate::init_tracker::BufferInitTrackerAction;
97use crate::ray_tracing::{AsAction, BuildAccelerationStructureError};
98use crate::resource::{
99 DestroyedResourceError, Fallible, InvalidOrDestroyedResourceError, InvalidResourceError,
100 Labeled, ParentDevice as _, QuerySet,
101};
102use crate::track::{DeviceTracker, ResourceUsageCompatibilityError, Tracker, UsageScope};
103use crate::{api_log, global::Global, id, resource_log, Label};
104use crate::{hal_label, LabelHelpers};
105
106use wgt::error::{ErrorType, WebGpuError};
107
108use thiserror::Error;
109
110pub type TexelCopyBufferInfo = ffi::TexelCopyBufferInfo;
112pub type TexelCopyTextureInfo = ffi::TexelCopyTextureInfo;
114pub type CopyExternalImageDestInfo = ffi::CopyExternalImageDestInfo;
116
117const IMMEDIATES_CLEAR_ARRAY: &[u32] = &[0_u32; 64];
118
119pub(crate) struct EncoderErrorState {
120 error: CommandEncoderError,
121
122 #[cfg(feature = "trace")]
123 trace_commands: Option<Vec<Command<PointerReferences>>>,
124}
125
126fn make_error_state<E: Into<CommandEncoderError>>(error: E) -> CommandEncoderStatus {
136 CommandEncoderStatus::Error(EncoderErrorState {
137 error: error.into(),
138
139 #[cfg(feature = "trace")]
140 trace_commands: None,
141 })
142}
143
144pub(crate) enum CommandEncoderStatus {
150 Recording(CommandBufferMutable),
162
163 Locked(CommandBufferMutable),
172
173 Consumed,
174
175 Finished(CommandBufferMutable),
186
187 Error(EncoderErrorState),
192
193 Transitioning,
196}
197
198impl CommandEncoderStatus {
199 #[doc(hidden)]
200 fn replay(&mut self, commands: Vec<Command<ArcReferences>>) {
201 let Self::Recording(cmd_buf_data) = self else {
202 panic!("encoder should be in the recording state");
203 };
204 cmd_buf_data.commands.extend(commands);
205 }
206
207 fn push_with<F: FnOnce() -> Result<ArcCommand, E>, E: Clone + Into<CommandEncoderError>>(
223 &mut self,
224 f: F,
225 ) -> Result<(), EncoderStateError> {
226 match self {
227 Self::Recording(cmd_buf_data) => {
228 cmd_buf_data.encoder.api.set(EncodingApi::Wgpu);
229 match f() {
230 Ok(cmd) => cmd_buf_data.commands.push(cmd),
231 Err(err) => {
232 self.invalidate(err);
233 }
234 }
235 Ok(())
236 }
237 Self::Locked(_) => {
238 self.invalidate(EncoderStateError::Locked);
241 Ok(())
242 }
243 Self::Finished(_) => Err(self.invalidate(EncoderStateError::Ended)),
246 Self::Consumed => Err(EncoderStateError::Ended),
247 Self::Error(_) => Ok(()),
250 Self::Transitioning => unreachable!(),
251 }
252 }
253
254 fn with_buffer<
268 F: FnOnce(&mut CommandBufferMutable) -> Result<(), E>,
269 E: Clone + Into<CommandEncoderError>,
270 >(
271 &mut self,
272 api: EncodingApi,
273 f: F,
274 ) -> Result<(), EncoderStateError> {
275 match self {
276 Self::Recording(inner) => {
277 inner.encoder.api.set(api);
278 RecordingGuard { inner: self }.record(f);
279 Ok(())
280 }
281 Self::Locked(_) => {
282 self.invalidate(EncoderStateError::Locked);
285 Ok(())
286 }
287 Self::Finished(_) => Err(self.invalidate(EncoderStateError::Ended)),
290 Self::Consumed => Err(EncoderStateError::Ended),
291 Self::Error(_) => Ok(()),
294 Self::Transitioning => unreachable!(),
295 }
296 }
297
298 pub(crate) fn record_as_hal_mut<T, F: FnOnce(Option<&mut CommandBufferMutable>) -> T>(
306 &mut self,
307 f: F,
308 ) -> T {
309 match self {
310 Self::Recording(inner) => {
311 inner.encoder.api.set(EncodingApi::Raw);
312 RecordingGuard { inner: self }.record_as_hal_mut(f)
313 }
314 Self::Locked(_) => {
315 self.invalidate(EncoderStateError::Locked);
316 f(None)
317 }
318 Self::Finished(_) => {
319 self.invalidate(EncoderStateError::Ended);
320 f(None)
321 }
322 Self::Consumed => f(None),
323 Self::Error(_) => f(None),
324 Self::Transitioning => unreachable!(),
325 }
326 }
327
328 fn lock_encoder(&mut self) -> Result<(), EncoderStateError> {
334 match mem::replace(self, Self::Transitioning) {
335 Self::Recording(inner) => {
336 *self = Self::Locked(inner);
337 Ok(())
338 }
339 st @ Self::Finished(_) => {
340 *self = st;
344 Err(EncoderStateError::Ended)
345 }
346 Self::Locked(_) => Err(self.invalidate(EncoderStateError::Locked)),
347 st @ Self::Consumed => {
348 *self = st;
349 Err(EncoderStateError::Ended)
350 }
351 st @ Self::Error(_) => {
352 *self = st;
353 Err(EncoderStateError::Invalid)
354 }
355 Self::Transitioning => unreachable!(),
356 }
357 }
358
359 fn unlock_encoder(&mut self) -> Result<(), EncoderStateError> {
369 match mem::replace(self, Self::Transitioning) {
370 Self::Locked(inner) => {
371 *self = Self::Recording(inner);
372 Ok(())
373 }
374 st @ Self::Finished(_) => {
375 *self = st;
376 Err(EncoderStateError::Ended)
377 }
378 Self::Recording(_) => {
379 *self = make_error_state(EncoderStateError::Unlocked);
380 Err(EncoderStateError::Unlocked)
381 }
382 st @ Self::Consumed => {
383 *self = st;
384 Err(EncoderStateError::Ended)
385 }
386 st @ Self::Error(_) => {
387 *self = st;
390 Ok(())
391 }
392 Self::Transitioning => unreachable!(),
393 }
394 }
395
396 fn finish(&mut self) -> Self {
397 match mem::replace(self, Self::Consumed) {
400 Self::Recording(inner) => {
401 if inner.encoder.api != EncodingApi::Raw {
404 assert!(!inner.encoder.is_open);
405 }
406 Self::Finished(inner)
407 }
408 Self::Consumed | Self::Finished(_) => make_error_state(EncoderStateError::Ended),
409 Self::Locked(_) => make_error_state(EncoderStateError::Locked),
410 st @ Self::Error(_) => st,
411 Self::Transitioning => unreachable!(),
412 }
413 }
414
415 fn invalidate<E: Clone + Into<CommandEncoderError>>(&mut self, err: E) -> E {
423 #[cfg(feature = "trace")]
424 let trace_commands = match self {
425 Self::Recording(cmd_buf_data) => Some(
426 mem::take(&mut cmd_buf_data.commands)
427 .into_iter()
428 .map(crate::device::trace::IntoTrace::into_trace)
429 .collect(),
430 ),
431 _ => None,
432 };
433
434 let enc_err = err.clone().into();
435 api_log!("Invalidating command encoder: {enc_err:?}");
436 *self = Self::Error(EncoderErrorState {
437 error: enc_err,
438 #[cfg(feature = "trace")]
439 trace_commands,
440 });
441 err
442 }
443}
444
445pub(crate) struct RecordingGuard<'a> {
458 inner: &'a mut CommandEncoderStatus,
459}
460
461impl<'a> RecordingGuard<'a> {
462 pub(crate) fn mark_successful(self) {
463 mem::forget(self)
464 }
465
466 fn record<
467 F: FnOnce(&mut CommandBufferMutable) -> Result<(), E>,
468 E: Clone + Into<CommandEncoderError>,
469 >(
470 mut self,
471 f: F,
472 ) {
473 match f(&mut self) {
474 Ok(()) => self.mark_successful(),
475 Err(err) => {
476 self.inner.invalidate(err);
477 }
478 }
479 }
480
481 pub(crate) fn record_as_hal_mut<T, F: FnOnce(Option<&mut CommandBufferMutable>) -> T>(
484 mut self,
485 f: F,
486 ) -> T {
487 let res = f(Some(&mut self));
488 self.mark_successful();
489 res
490 }
491}
492
493impl<'a> Drop for RecordingGuard<'a> {
494 fn drop(&mut self) {
495 if matches!(*self.inner, CommandEncoderStatus::Error(_)) {
496 return;
498 }
499 self.inner.invalidate(EncoderStateError::Invalid);
500 }
501}
502
503impl<'a> ops::Deref for RecordingGuard<'a> {
504 type Target = CommandBufferMutable;
505
506 fn deref(&self) -> &Self::Target {
507 match &*self.inner {
508 CommandEncoderStatus::Recording(command_buffer_mutable) => command_buffer_mutable,
509 _ => unreachable!(),
510 }
511 }
512}
513
514impl<'a> ops::DerefMut for RecordingGuard<'a> {
515 fn deref_mut(&mut self) -> &mut Self::Target {
516 match self.inner {
517 CommandEncoderStatus::Recording(command_buffer_mutable) => command_buffer_mutable,
518 _ => unreachable!(),
519 }
520 }
521}
522
523pub(crate) struct CommandEncoder {
524 pub(crate) device: Arc<Device>,
525
526 pub(crate) label: String,
527
528 pub(crate) data: Mutex<CommandEncoderStatus>,
530}
531
532crate::impl_resource_type!(CommandEncoder);
533crate::impl_labeled!(CommandEncoder);
534crate::impl_parent_device!(CommandEncoder);
535crate::impl_storage_item!(CommandEncoder);
536
537#[cfg(send_sync)]
538const _: () = {
539 unsafe impl Send for CommandEncoder {}
541 unsafe impl Sync for CommandEncoder {}
543
544 fn _command_encoder_fields_are_send_sync(obj: &CommandEncoder) {
545 fn _check_bound<T: Send + Sync>(_: &T) {}
546 let CommandEncoder {
547 device,
548 label,
549 data,
550 } = obj;
551 _check_bound(device);
552 _check_bound(label);
553 _check_bound(data);
554 }
555};
556
557impl Drop for CommandEncoder {
558 fn drop(&mut self) {
559 resource_log!("Drop {}", self.error_ident());
560 }
561}
562
563#[derive(Copy, Clone, Debug, Eq, PartialEq)]
567pub enum EncodingApi {
568 Wgpu,
570
571 Raw,
573
574 Undecided,
576
577 InternalUse,
579}
580
581impl EncodingApi {
582 pub(crate) fn set(&mut self, api: EncodingApi) {
583 match *self {
584 EncodingApi::Undecided => {
585 *self = api;
586 }
587 self_api if self_api != api => {
588 panic!("Mixing the wgpu encoding API with the raw encoding API is not permitted");
589 }
590 _ => {}
591 }
592 }
593}
594
595pub(crate) struct InnerCommandEncoder {
611 pub(crate) raw: ManuallyDrop<Box<dyn hal::DynCommandEncoder>>,
619
620 pub(crate) list: Vec<Box<dyn hal::DynCommandBuffer>>,
632
633 pub(crate) device: Arc<Device>,
634
635 pub(crate) is_open: bool,
642
643 pub(crate) api: EncodingApi,
649
650 pub(crate) label: String,
651}
652
653impl InnerCommandEncoder {
654 fn close_and_swap(&mut self) -> Result<(), DeviceError> {
686 self.close_and_insert_at(self.list.len() - 1)
687 }
688
689 pub(crate) fn close_and_push_front(&mut self) -> Result<(), DeviceError> {
706 self.close_and_insert_at(0)
707 }
708
709 pub(crate) fn close_and_insert_at(&mut self, index: usize) -> Result<(), DeviceError> {
726 assert!(self.is_open);
727 self.is_open = false;
728
729 let cmd_buf =
730 unsafe { self.raw.end_encoding() }.map_err(|e| self.device.handle_hal_error(e))?;
731 self.list.insert(index, cmd_buf);
732
733 Ok(())
734 }
735
736 pub(crate) fn close(&mut self) -> Result<(), DeviceError> {
747 assert!(self.is_open);
748 self.is_open = false;
749
750 let cmd_buf =
751 unsafe { self.raw.end_encoding() }.map_err(|e| self.device.handle_hal_error(e))?;
752 self.list.push(cmd_buf);
753
754 Ok(())
755 }
756
757 fn close_if_open(&mut self) -> Result<(), DeviceError> {
768 if self.is_open {
769 self.is_open = false;
770 let cmd_buf =
771 unsafe { self.raw.end_encoding() }.map_err(|e| self.device.handle_hal_error(e))?;
772 self.list.push(cmd_buf);
773 }
774
775 Ok(())
776 }
777
778 fn open_if_closed(&mut self) -> Result<&mut dyn hal::DynCommandEncoder, DeviceError> {
784 if !self.is_open {
785 let hal_label = hal_label(Some(self.label.as_str()), self.device.instance_flags);
786 unsafe { self.raw.begin_encoding(hal_label) }
787 .map_err(|e| self.device.handle_hal_error(e))?;
788 self.is_open = true;
789 }
790
791 Ok(self.raw.as_mut())
792 }
793
794 pub(crate) fn open(&mut self) -> Result<&mut dyn hal::DynCommandEncoder, DeviceError> {
798 if !self.is_open {
799 let hal_label = hal_label(Some(self.label.as_str()), self.device.instance_flags);
800 unsafe { self.raw.begin_encoding(hal_label) }
801 .map_err(|e| self.device.handle_hal_error(e))?;
802 self.is_open = true;
803 }
804
805 Ok(self.raw.as_mut())
806 }
807
808 pub(crate) fn open_pass(
817 &mut self,
818 label: Option<&str>,
819 ) -> Result<&mut dyn hal::DynCommandEncoder, DeviceError> {
820 assert!(!self.is_open);
821
822 let hal_label = hal_label(label, self.device.instance_flags);
823 unsafe { self.raw.begin_encoding(hal_label) }
824 .map_err(|e| self.device.handle_hal_error(e))?;
825 self.is_open = true;
826
827 Ok(self.raw.as_mut())
828 }
829}
830
831impl Drop for InnerCommandEncoder {
832 fn drop(&mut self) {
833 if self.is_open {
834 unsafe { self.raw.discard_encoding() };
835 }
836 unsafe {
837 self.raw.reset_all(mem::take(&mut self.list));
838 }
839 let raw = unsafe { ManuallyDrop::take(&mut self.raw) };
841 self.device.command_allocator.release_encoder(raw);
842 }
843}
844
845pub(crate) struct BakedCommands {
848 pub(crate) encoder: InnerCommandEncoder,
849 pub(crate) trackers: Tracker,
850 pub(crate) temp_resources: Vec<TempResource>,
851 pub(crate) indirect_draw_validation_resources: crate::indirect_validation::DrawResources,
852 buffer_memory_init_actions: Vec<BufferInitTrackerAction>,
853 texture_memory_actions: CommandBufferTextureMemoryActions,
854 pub(crate) query_set_writes: query::QuerySetWrites,
855 pub(crate) deferred_query_set_resolves: Vec<query::DeferredQuerySetResolve>,
856}
857
858pub struct CommandBufferMutable {
860 pub(crate) encoder: InnerCommandEncoder,
865
866 pub(crate) trackers: Tracker,
868
869 buffer_memory_init_actions: Vec<BufferInitTrackerAction>,
876 texture_memory_actions: CommandBufferTextureMemoryActions,
877
878 as_actions: Vec<AsAction>,
879 temp_resources: Vec<TempResource>,
880
881 indirect_draw_validation_resources: crate::indirect_validation::DrawResources,
882
883 pub(crate) commands: Vec<Command<ArcReferences>>,
884
885 #[cfg(feature = "trace")]
888 pub(crate) trace_commands: Option<Vec<Command<PointerReferences>>>,
889
890 pub(crate) query_set_writes: query::QuerySetWrites,
892 pub(crate) deferred_query_set_resolves: Vec<query::DeferredQuerySetResolve>,
894}
895
896impl CommandBufferMutable {
897 pub(crate) fn into_baked_commands(self) -> BakedCommands {
898 BakedCommands {
899 encoder: self.encoder,
900 trackers: self.trackers,
901 temp_resources: self.temp_resources,
902 indirect_draw_validation_resources: self.indirect_draw_validation_resources,
903 buffer_memory_init_actions: self.buffer_memory_init_actions,
904 texture_memory_actions: self.texture_memory_actions,
905 query_set_writes: self.query_set_writes,
906 deferred_query_set_resolves: self.deferred_query_set_resolves,
907 }
908 }
909}
910
911pub struct CommandBuffer {
917 pub(crate) device: Arc<Device>,
918 label: String,
920
921 pub(crate) data: Mutex<CommandEncoderStatus>,
923}
924
925#[cfg(send_sync)]
926const _: () = {
927 unsafe impl Send for CommandBuffer {}
929 unsafe impl Sync for CommandBuffer {}
931
932 fn _command_buffer_fields_are_send_sync(obj: &CommandBuffer) {
933 fn _check_bound<T: Send + Sync>(_: &T) {}
934 let CommandBuffer {
935 device,
936 label,
937 data,
938 } = obj;
939 _check_bound(device);
940 _check_bound(label);
941 _check_bound(data);
942 }
943};
944
945impl Drop for CommandBuffer {
946 fn drop(&mut self) {
947 resource_log!("Drop {}", self.error_ident());
948 }
949}
950
951impl CommandEncoder {
952 pub(crate) fn new(
953 encoder: Box<dyn hal::DynCommandEncoder>,
954 device: &Arc<Device>,
955 label: &Label,
956 ) -> Self {
957 CommandEncoder {
958 device: device.clone(),
959 label: label.to_string(),
960 data: Mutex::new(
961 rank::COMMAND_BUFFER_DATA,
962 CommandEncoderStatus::Recording(CommandBufferMutable {
963 encoder: InnerCommandEncoder {
964 raw: ManuallyDrop::new(encoder),
965 list: Vec::new(),
966 device: device.clone(),
967 is_open: false,
968 api: EncodingApi::Undecided,
969 label: label.to_string(),
970 },
971 trackers: Tracker::new(
972 device.ordered_buffer_usages,
973 device.ordered_texture_usages,
974 ),
975 buffer_memory_init_actions: Default::default(),
976 texture_memory_actions: Default::default(),
977 as_actions: Default::default(),
978 temp_resources: Default::default(),
979 indirect_draw_validation_resources:
980 crate::indirect_validation::DrawResources::new(device.clone()),
981 commands: Vec::new(),
982 query_set_writes: Default::default(),
983 deferred_query_set_resolves: Default::default(),
984 #[cfg(feature = "trace")]
985 trace_commands: if device.trace.lock().is_some() {
986 Some(Vec::new())
987 } else {
988 None
989 },
990 }),
991 ),
992 }
993 }
994
995 pub(crate) fn new_invalid(
996 device: &Arc<Device>,
997 label: &Label,
998 err: CommandEncoderError,
999 ) -> Self {
1000 CommandEncoder {
1001 device: device.clone(),
1002 label: label.to_string(),
1003 data: Mutex::new(rank::COMMAND_BUFFER_DATA, make_error_state(err)),
1004 }
1005 }
1006
1007 pub(crate) fn validate_pass_timestamp_writes<E>(
1008 device: &Device,
1009 timestamp_writes: &PassTimestampWrites<Fallible<QuerySet>>,
1010 ) -> Result<ArcPassTimestampWrites, E>
1011 where
1012 E: From<TimestampWritesError>
1013 + From<QueryUseError>
1014 + From<DeviceError>
1015 + From<MissingFeatures>
1016 + From<InvalidResourceError>,
1017 {
1018 let &PassTimestampWrites {
1019 ref query_set,
1020 beginning_of_pass_write_index,
1021 end_of_pass_write_index,
1022 } = timestamp_writes;
1023
1024 device.require_features(wgt::Features::TIMESTAMP_QUERY)?;
1025
1026 let query_set = query_set.clone().get()?;
1027
1028 query_set.same_device(device)?;
1029
1030 for idx in [beginning_of_pass_write_index, end_of_pass_write_index]
1031 .into_iter()
1032 .flatten()
1033 {
1034 query_set.validate_query(SimplifiedQueryType::Timestamp, idx, None)?;
1035 }
1036
1037 if let Some((begin, end)) = beginning_of_pass_write_index.zip(end_of_pass_write_index) {
1038 if begin == end {
1039 return Err(TimestampWritesError::IndicesEqual { idx: begin }.into());
1040 }
1041 }
1042
1043 if beginning_of_pass_write_index
1044 .or(end_of_pass_write_index)
1045 .is_none()
1046 {
1047 return Err(TimestampWritesError::IndicesMissing.into());
1048 }
1049
1050 Ok(ArcPassTimestampWrites {
1051 query_set,
1052 beginning_of_pass_write_index,
1053 end_of_pass_write_index,
1054 })
1055 }
1056
1057 pub(crate) fn insert_barriers_from_tracker(
1058 raw: &mut dyn hal::DynCommandEncoder,
1059 base: &mut Tracker,
1060 head: &Tracker,
1061 snatch_guard: &SnatchGuard,
1062 ) {
1063 profiling::scope!("insert_barriers");
1064
1065 base.buffers.set_from_tracker(&head.buffers);
1066 base.textures.set_from_tracker(&head.textures);
1067
1068 Self::drain_barriers(raw, base, snatch_guard);
1069 }
1070
1071 pub(crate) fn insert_barriers_from_scope(
1072 raw: &mut dyn hal::DynCommandEncoder,
1073 base: &mut Tracker,
1074 head: &UsageScope,
1075 snatch_guard: &SnatchGuard,
1076 ) {
1077 profiling::scope!("insert_barriers");
1078
1079 base.buffers.set_from_usage_scope(&head.buffers);
1080 base.textures.set_from_usage_scope(&head.textures);
1081
1082 Self::drain_barriers(raw, base, snatch_guard);
1083 }
1084
1085 pub(crate) fn drain_barriers(
1086 raw: &mut dyn hal::DynCommandEncoder,
1087 base: &mut Tracker,
1088 snatch_guard: &SnatchGuard,
1089 ) {
1090 profiling::scope!("drain_barriers");
1091
1092 let buffer_barriers = base
1093 .buffers
1094 .drain_transitions(snatch_guard)
1095 .collect::<Vec<_>>();
1096 let (transitions, textures) = base.textures.drain_transitions(snatch_guard);
1097 let texture_barriers = transitions
1098 .into_iter()
1099 .enumerate()
1100 .map(|(i, p)| p.into_hal(textures[i].unwrap().raw()))
1101 .collect::<Vec<_>>();
1102
1103 unsafe {
1104 raw.transition_buffers(&buffer_barriers);
1105 raw.transition_textures(&texture_barriers);
1106 }
1107 }
1108
1109 pub(crate) fn insert_barriers_from_device_tracker(
1110 raw: &mut dyn hal::DynCommandEncoder,
1111 base: &mut DeviceTracker,
1112 head: &Tracker,
1113 snatch_guard: &SnatchGuard,
1114 ) {
1115 profiling::scope!("insert_barriers_from_device_tracker");
1116
1117 let buffer_barriers = base
1118 .buffers
1119 .set_from_tracker_and_drain_transitions(&head.buffers, snatch_guard)
1120 .collect::<Vec<_>>();
1121
1122 let texture_barriers = base
1123 .textures
1124 .set_from_tracker_and_drain_transitions(&head.textures, snatch_guard)
1125 .collect::<Vec<_>>();
1126
1127 unsafe {
1128 raw.transition_buffers(&buffer_barriers);
1129 raw.transition_textures(&texture_barriers);
1130 }
1131 }
1132
1133 fn encode_commands(
1134 device: &Arc<Device>,
1135 cmd_buf_data: &mut CommandBufferMutable,
1136 ) -> Result<(), CommandEncoderError> {
1137 device.check_is_valid()?;
1138 let snatch_guard = device.snatchable_lock.read();
1139 let mut debug_scope_depth = 0;
1140
1141 if cmd_buf_data.encoder.api == EncodingApi::Raw {
1142 assert!(cmd_buf_data.commands.is_empty());
1145 }
1146
1147 let commands = mem::take(&mut cmd_buf_data.commands);
1148
1149 #[cfg(feature = "trace")]
1150 if device.trace.lock().is_some() {
1151 cmd_buf_data.trace_commands = Some(
1152 commands
1153 .iter()
1154 .map(crate::device::trace::IntoTrace::to_trace)
1155 .collect(),
1156 );
1157 }
1158
1159 for command in commands {
1160 if matches!(
1161 command,
1162 ArcCommand::RunRenderPass { .. }
1163 | ArcCommand::RunComputePass { .. }
1164 | ArcCommand::ResolveQuerySet { .. }
1165 ) {
1166 let mut state = EncodingState {
1172 device,
1173 raw_encoder: &mut cmd_buf_data.encoder,
1174 tracker: &mut cmd_buf_data.trackers,
1175 buffer_memory_init_actions: &mut cmd_buf_data.buffer_memory_init_actions,
1176 texture_memory_actions: &mut cmd_buf_data.texture_memory_actions,
1177 as_actions: &mut cmd_buf_data.as_actions,
1178 temp_resources: &mut cmd_buf_data.temp_resources,
1179 indirect_draw_validation_resources: &mut cmd_buf_data
1180 .indirect_draw_validation_resources,
1181 snatch_guard: &snatch_guard,
1182 debug_scope_depth: &mut debug_scope_depth,
1183 query_set_writes: &mut cmd_buf_data.query_set_writes,
1184 deferred_query_set_resolves: &mut cmd_buf_data.deferred_query_set_resolves,
1185 };
1186
1187 match command {
1188 ArcCommand::RunRenderPass {
1189 pass,
1190 color_attachments,
1191 depth_stencil_attachment,
1192 timestamp_writes,
1193 occlusion_query_set,
1194 multiview_mask,
1195 } => {
1196 api_log!(
1197 "Begin encoding render pass with '{}' label",
1198 pass.label.as_deref().unwrap_or("")
1199 );
1200 let res = render::encode_render_pass(
1201 &mut state,
1202 pass,
1203 color_attachments,
1204 depth_stencil_attachment,
1205 timestamp_writes,
1206 occlusion_query_set,
1207 multiview_mask,
1208 );
1209 match res.as_ref() {
1210 Err(err) => {
1211 api_log!("Finished encoding render pass ({err:?})")
1212 }
1213 Ok(_) => {
1214 api_log!("Finished encoding render pass (success)")
1215 }
1216 }
1217 res?;
1218 }
1219 ArcCommand::RunComputePass {
1220 pass,
1221 timestamp_writes,
1222 } => {
1223 api_log!(
1224 "Begin encoding compute pass with '{}' label",
1225 pass.label.as_deref().unwrap_or("")
1226 );
1227 let res = compute::encode_compute_pass(&mut state, pass, timestamp_writes);
1228 match res.as_ref() {
1229 Err(err) => {
1230 api_log!("Finished encoding compute pass ({err:?})")
1231 }
1232 Ok(_) => {
1233 api_log!("Finished encoding compute pass (success)")
1234 }
1235 }
1236 res?;
1237 }
1238 ArcCommand::ResolveQuerySet {
1239 query_set,
1240 start_query,
1241 query_count,
1242 destination,
1243 destination_offset,
1244 } => {
1245 query::resolve_query_set(
1246 &mut state,
1247 query_set,
1248 start_query,
1249 query_count,
1250 destination,
1251 destination_offset,
1252 )?;
1253 }
1254 _ => unreachable!(),
1255 }
1256 } else {
1257 let raw_encoder = cmd_buf_data.encoder.open_if_closed()?;
1263 let mut state = EncodingState {
1264 device,
1265 raw_encoder,
1266 tracker: &mut cmd_buf_data.trackers,
1267 buffer_memory_init_actions: &mut cmd_buf_data.buffer_memory_init_actions,
1268 texture_memory_actions: &mut cmd_buf_data.texture_memory_actions,
1269 as_actions: &mut cmd_buf_data.as_actions,
1270 temp_resources: &mut cmd_buf_data.temp_resources,
1271 indirect_draw_validation_resources: &mut cmd_buf_data
1272 .indirect_draw_validation_resources,
1273 snatch_guard: &snatch_guard,
1274 debug_scope_depth: &mut debug_scope_depth,
1275 query_set_writes: &mut cmd_buf_data.query_set_writes,
1276 deferred_query_set_resolves: &mut cmd_buf_data.deferred_query_set_resolves,
1277 };
1278 match command {
1279 ArcCommand::CopyBufferToBuffer {
1280 src,
1281 src_offset,
1282 dst,
1283 dst_offset,
1284 size,
1285 } => {
1286 transfer::copy_buffer_to_buffer(
1287 &mut state, &src, src_offset, &dst, dst_offset, size,
1288 )?;
1289 }
1290 ArcCommand::CopyBufferToTexture { src, dst, size } => {
1291 transfer::copy_buffer_to_texture(&mut state, &src, &dst, &size)?;
1292 }
1293 ArcCommand::CopyTextureToBuffer { src, dst, size } => {
1294 transfer::copy_texture_to_buffer(&mut state, &src, &dst, &size)?;
1295 }
1296 ArcCommand::CopyTextureToTexture { src, dst, size } => {
1297 transfer::copy_texture_to_texture(&mut state, &src, &dst, &size)?;
1298 }
1299 ArcCommand::ClearBuffer { dst, offset, size } => {
1300 clear::clear_buffer(&mut state, dst, offset, size)?;
1301 }
1302 ArcCommand::ClearTexture {
1303 dst,
1304 subresource_range,
1305 } => {
1306 clear::clear_texture_cmd(&mut state, dst, &subresource_range)?;
1307 }
1308 ArcCommand::WriteTimestamp {
1309 query_set,
1310 query_index,
1311 } => {
1312 query::write_timestamp(&mut state, query_set, query_index)?;
1313 }
1314 ArcCommand::PushDebugGroup(label) => {
1315 push_debug_group(&mut state, &label)?;
1316 }
1317 ArcCommand::PopDebugGroup => {
1318 pop_debug_group(&mut state)?;
1319 }
1320 ArcCommand::InsertDebugMarker(label) => {
1321 insert_debug_marker(&mut state, &label)?;
1322 }
1323 ArcCommand::BuildAccelerationStructures { blas, tlas } => {
1324 ray_tracing::build_acceleration_structures(&mut state, blas, tlas)?;
1325 }
1326 ArcCommand::TransitionResources {
1327 buffer_transitions,
1328 texture_transitions,
1329 } => {
1330 transition_resources::transition_resources(
1331 &mut state,
1332 buffer_transitions,
1333 texture_transitions,
1334 )?;
1335 }
1336 ArcCommand::RunComputePass { .. }
1337 | ArcCommand::RunRenderPass { .. }
1338 | ArcCommand::ResolveQuerySet { .. } => {
1339 unreachable!()
1340 }
1341 }
1342 }
1343 }
1344
1345 if debug_scope_depth > 0 {
1346 Err(CommandEncoderError::DebugGroupError(
1347 DebugGroupError::MissingPop,
1348 ))?;
1349 }
1350
1351 cmd_buf_data.encoder.close_if_open()?;
1353
1354 Ok(())
1358 }
1359
1360 fn finish(
1361 self: &Arc<Self>,
1362 desc: &wgt::CommandBufferDescriptor<Label>,
1363 ) -> (Arc<CommandBuffer>, Option<CommandEncoderError>) {
1364 let status = self.data.lock().finish();
1365
1366 let res = match status {
1367 CommandEncoderStatus::Finished(mut cmd_buf_data) => {
1368 match Self::encode_commands(&self.device, &mut cmd_buf_data) {
1369 Ok(()) => Ok(cmd_buf_data),
1370 Err(error) => Err(EncoderErrorState {
1371 error,
1372 #[cfg(feature = "trace")]
1373 trace_commands: mem::take(&mut cmd_buf_data.trace_commands),
1374 }),
1375 }
1376 }
1377 CommandEncoderStatus::Error(error_state) => Err(error_state),
1378 _ => unreachable!(),
1379 };
1380
1381 let (data, error) = match res {
1382 Err(EncoderErrorState {
1383 error,
1384 #[cfg(feature = "trace")]
1385 trace_commands,
1386 }) => {
1387 #[cfg(feature = "trace")]
1391 if let Some(trace) = self.device.trace.lock().as_mut() {
1392 use alloc::string::ToString;
1393
1394 trace.add(crate::device::trace::Action::FailedCommands {
1395 commands: trace_commands,
1396 failed_at_submit: None,
1397 error: error.to_string(),
1398 });
1399 }
1400
1401 if error.is_destroyed_error() {
1402 (make_error_state(error), None)
1405 } else {
1406 (make_error_state(error.clone()), Some(error))
1407 }
1408 }
1409
1410 Ok(data) => (CommandEncoderStatus::Finished(data), None),
1411 };
1412
1413 let cmd_buf = Arc::new(CommandBuffer {
1414 device: self.device.clone(),
1415 label: desc.label.to_string(),
1416 data: Mutex::new(rank::COMMAND_BUFFER_DATA, data),
1417 });
1418
1419 (cmd_buf, error)
1420 }
1421}
1422
1423impl CommandBuffer {
1424 #[doc(hidden)]
1430 pub fn from_trace(device: &Arc<Device>, commands: Vec<Command<ArcReferences>>) -> Arc<Self> {
1431 let encoder = device.create_command_encoder(&None).unwrap();
1432 let mut cmd_enc_status = encoder.data.lock();
1433 cmd_enc_status.replay(commands);
1434 drop(cmd_enc_status);
1435
1436 let (cmd_buf, error) = encoder.finish(&wgt::CommandBufferDescriptor { label: None });
1437 if let Some(err) = error {
1438 panic!("CommandEncoder::finish failed: {err}");
1439 }
1440
1441 cmd_buf
1442 }
1443
1444 pub fn take_finished(&self) -> Result<CommandBufferMutable, CommandEncoderError> {
1445 use CommandEncoderStatus as St;
1446 match mem::replace(
1447 &mut *self.data.lock(),
1448 make_error_state(EncoderStateError::Submitted),
1449 ) {
1450 St::Finished(command_buffer_mutable) => Ok(command_buffer_mutable),
1451 St::Error(EncoderErrorState {
1452 #[cfg(feature = "trace")]
1453 trace_commands: _,
1454 error,
1455 }) => Err(error),
1456 St::Recording(_) | St::Locked(_) | St::Consumed | St::Transitioning => unreachable!(),
1457 }
1458 }
1459}
1460
1461crate::impl_resource_type!(CommandBuffer);
1462crate::impl_labeled!(CommandBuffer);
1463crate::impl_parent_device!(CommandBuffer);
1464crate::impl_storage_item!(CommandBuffer);
1465
1466#[doc(hidden)]
1478#[derive(Debug, Clone)]
1479#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
1480pub struct BasePass<C, E> {
1481 pub label: Option<String>,
1482
1483 #[cfg_attr(feature = "serde", serde(skip, default = "Option::default"))]
1491 pub error: Option<E>,
1492
1493 pub commands: Vec<C>,
1499
1500 pub dynamic_offsets: Vec<wgt::DynamicOffset>,
1505
1506 pub string_data: Vec<u8>,
1511
1512 pub immediates_data: Vec<u32>,
1517}
1518
1519impl<C: Clone, E: Clone> BasePass<C, E> {
1520 fn new(label: &Label) -> Self {
1521 Self {
1522 label: label.as_deref().map(str::to_owned),
1523 error: None,
1524 commands: Vec::new(),
1525 dynamic_offsets: Vec::new(),
1526 string_data: Vec::new(),
1527 immediates_data: Vec::new(),
1528 }
1529 }
1530
1531 fn new_invalid(label: &Label, err: E) -> Self {
1532 Self {
1533 label: label.as_deref().map(str::to_owned),
1534 error: Some(err),
1535 commands: Vec::new(),
1536 dynamic_offsets: Vec::new(),
1537 string_data: Vec::new(),
1538 immediates_data: Vec::new(),
1539 }
1540 }
1541
1542 fn take(&mut self) -> Result<BasePass<C, Infallible>, E> {
1549 match self.error.as_ref() {
1550 Some(err) => Err(err.clone()),
1551 None => Ok(BasePass {
1552 label: self.label.clone(),
1553 error: None,
1554 commands: mem::take(&mut self.commands),
1555 dynamic_offsets: mem::take(&mut self.dynamic_offsets),
1556 string_data: mem::take(&mut self.string_data),
1557 immediates_data: mem::take(&mut self.immediates_data),
1558 }),
1559 }
1560 }
1561}
1562
1563macro_rules! pass_base {
1586 ($pass:expr, $scope:expr $(,)?) => {
1587 match (&$pass.parent, &$pass.base.error) {
1588 (&None, _) => return Err(EncoderStateError::Ended).map_pass_err($scope),
1590 (&Some(_), &Some(_)) => return Ok(()),
1592 (&Some(_), &None) => &mut $pass.base,
1594 }
1595 };
1596}
1597pub(crate) use pass_base;
1598
1599macro_rules! pass_try {
1611 ($base:expr, $scope:expr, $res:expr $(,)?) => {
1612 match $res.map_pass_err($scope) {
1613 Ok(val) => val,
1614 Err(err) => {
1615 $base.error.get_or_insert(err);
1616 return Ok(());
1617 }
1618 }
1619 };
1620}
1621pub(crate) use pass_try;
1622
1623#[derive(Clone, Debug, Error)]
1628#[non_exhaustive]
1629pub enum EncoderStateError {
1630 #[error("Encoder is invalid")]
1635 Invalid,
1636
1637 #[error("Encoding must not have ended")]
1640 Ended,
1641
1642 #[error("Encoder is locked by a previously created render/compute pass. Before recording any new commands, the pass must be ended.")]
1648 Locked,
1649
1650 #[error(
1653 "Encoder is not currently locked. A pass can only be ended while the encoder is locked."
1654 )]
1655 Unlocked,
1656
1657 #[error("This command buffer has already been submitted.")]
1662 Submitted,
1663}
1664
1665impl WebGpuError for EncoderStateError {
1666 fn webgpu_error_type(&self) -> ErrorType {
1667 match self {
1668 EncoderStateError::Invalid
1669 | EncoderStateError::Ended
1670 | EncoderStateError::Locked
1671 | EncoderStateError::Unlocked
1672 | EncoderStateError::Submitted => ErrorType::Validation,
1673 }
1674 }
1675}
1676
1677#[derive(Clone, Debug, Error)]
1678#[non_exhaustive]
1679pub enum CommandEncoderError {
1680 #[error(transparent)]
1681 State(#[from] EncoderStateError),
1682 #[error(transparent)]
1683 Device(#[from] DeviceError),
1684 #[error(transparent)]
1685 InvalidResource(#[from] InvalidResourceError),
1686 #[error(transparent)]
1687 DestroyedResource(#[from] DestroyedResourceError),
1688 #[error(transparent)]
1689 ResourceUsage(#[from] ResourceUsageCompatibilityError),
1690 #[error(transparent)]
1691 DebugGroupError(#[from] DebugGroupError),
1692 #[error(transparent)]
1693 MissingFeatures(#[from] MissingFeatures),
1694 #[error(transparent)]
1695 Transfer(#[from] TransferError),
1696 #[error(transparent)]
1697 Clear(#[from] ClearError),
1698 #[error(transparent)]
1699 Query(#[from] QueryError),
1700 #[error(transparent)]
1701 BuildAccelerationStructure(#[from] BuildAccelerationStructureError),
1702 #[error(transparent)]
1703 TransitionResources(#[from] TransitionResourcesError),
1704 #[error(transparent)]
1705 ComputePass(#[from] ComputePassError),
1706 #[error(transparent)]
1707 RenderPass(#[from] RenderPassError),
1708}
1709
1710impl From<InvalidOrDestroyedResourceError> for CommandEncoderError {
1711 fn from(err: InvalidOrDestroyedResourceError) -> Self {
1712 match err {
1713 InvalidOrDestroyedResourceError::InvalidResource(e) => Self::InvalidResource(e),
1714 InvalidOrDestroyedResourceError::DestroyedResource(e) => Self::DestroyedResource(e),
1715 }
1716 }
1717}
1718
1719impl CommandEncoderError {
1720 fn is_destroyed_error(&self) -> bool {
1721 matches!(
1722 self,
1723 Self::DestroyedResource(_)
1724 | Self::Clear(ClearError::DestroyedResource(_))
1725 | Self::Query(QueryError::DestroyedResource(_))
1726 | Self::ComputePass(ComputePassError {
1727 inner: ComputePassErrorInner::DestroyedResource(_),
1728 ..
1729 })
1730 | Self::RenderPass(RenderPassError {
1731 inner: RenderPassErrorInner::DestroyedResource(_),
1732 ..
1733 })
1734 | Self::RenderPass(RenderPassError {
1735 inner: RenderPassErrorInner::RenderCommand(
1736 RenderCommandError::DestroyedResource(_)
1737 ),
1738 ..
1739 })
1740 | Self::RenderPass(RenderPassError {
1741 inner: RenderPassErrorInner::RenderCommand(RenderCommandError::BindingError(
1742 BindingError::DestroyedResource(_)
1743 )),
1744 ..
1745 })
1746 )
1747 }
1748}
1749
1750impl WebGpuError for CommandEncoderError {
1751 fn webgpu_error_type(&self) -> ErrorType {
1752 match self {
1753 Self::Device(e) => e.webgpu_error_type(),
1754 Self::InvalidResource(e) => e.webgpu_error_type(),
1755 Self::DebugGroupError(e) => e.webgpu_error_type(),
1756 Self::MissingFeatures(e) => e.webgpu_error_type(),
1757 Self::State(e) => e.webgpu_error_type(),
1758 Self::DestroyedResource(e) => e.webgpu_error_type(),
1759 Self::Transfer(e) => e.webgpu_error_type(),
1760 Self::Clear(e) => e.webgpu_error_type(),
1761 Self::Query(e) => e.webgpu_error_type(),
1762 Self::BuildAccelerationStructure(e) => e.webgpu_error_type(),
1763 Self::TransitionResources(e) => e.webgpu_error_type(),
1764 Self::ResourceUsage(e) => e.webgpu_error_type(),
1765 Self::ComputePass(e) => e.webgpu_error_type(),
1766 Self::RenderPass(e) => e.webgpu_error_type(),
1767 }
1768 }
1769}
1770
1771#[derive(Clone, Debug, Error)]
1772#[non_exhaustive]
1773pub enum DebugGroupError {
1774 #[error("Cannot pop debug group, because number of pushed debug groups is zero")]
1775 InvalidPop,
1776 #[error("A debug group was not popped before the encoder was finished")]
1777 MissingPop,
1778}
1779
1780impl WebGpuError for DebugGroupError {
1781 fn webgpu_error_type(&self) -> ErrorType {
1782 match self {
1783 Self::InvalidPop | Self::MissingPop => ErrorType::Validation,
1784 }
1785 }
1786}
1787
1788#[derive(Clone, Debug, Error)]
1789#[non_exhaustive]
1790pub enum TimestampWritesError {
1791 #[error(
1792 "begin and end indices of pass timestamp writes are both set to {idx}, which is not allowed"
1793 )]
1794 IndicesEqual { idx: u32 },
1795 #[error("no begin or end indices were specified for pass timestamp writes, expected at least one to be set")]
1796 IndicesMissing,
1797}
1798
1799impl WebGpuError for TimestampWritesError {
1800 fn webgpu_error_type(&self) -> ErrorType {
1801 match self {
1802 Self::IndicesEqual { .. } | Self::IndicesMissing => ErrorType::Validation,
1803 }
1804 }
1805}
1806
1807impl Global {
1808 fn resolve_buffer_id(
1809 &self,
1810 buffer_id: Id<id::markers::Buffer>,
1811 ) -> Result<Arc<crate::resource::Buffer>, InvalidResourceError> {
1812 self.hub.buffers.get(buffer_id).get()
1813 }
1814
1815 fn resolve_texture_id(
1816 &self,
1817 texture_id: Id<id::markers::Texture>,
1818 ) -> Arc<crate::resource::Texture> {
1819 self.hub.textures.get(texture_id)
1820 }
1821
1822 fn resolve_query_set(
1823 &self,
1824 query_set_id: Id<id::markers::QuerySet>,
1825 ) -> Result<Arc<QuerySet>, InvalidResourceError> {
1826 self.hub.query_sets.get(query_set_id).get()
1827 }
1828
1829 pub fn command_encoder_finish(
1837 &self,
1838 encoder_id: id::CommandEncoderId,
1839 desc: &wgt::CommandBufferDescriptor<Label>,
1840 id_in: Option<id::CommandBufferId>,
1841 ) -> (id::CommandBufferId, Option<(String, CommandEncoderError)>) {
1842 profiling::scope!("CommandEncoder::finish");
1843
1844 let hub = &self.hub;
1845 let cmd_enc = hub.command_encoders.get(encoder_id);
1846
1847 let (cmd_buf, opt_error) = cmd_enc.finish(desc);
1848 let cmd_buf_id = hub.command_buffers.prepare(id_in).assign(cmd_buf);
1849
1850 (
1851 cmd_buf_id,
1852 opt_error.map(|error| (cmd_enc.label.clone(), error)),
1853 )
1854 }
1855
1856 pub fn command_encoder_push_debug_group(
1857 &self,
1858 encoder_id: id::CommandEncoderId,
1859 label: &str,
1860 ) -> Result<(), EncoderStateError> {
1861 profiling::scope!("CommandEncoder::push_debug_group");
1862 api_log!("CommandEncoder::push_debug_group {label}");
1863
1864 let hub = &self.hub;
1865
1866 let cmd_enc = hub.command_encoders.get(encoder_id);
1867 let mut cmd_buf_data = cmd_enc.data.lock();
1868
1869 cmd_buf_data.push_with(|| -> Result<_, CommandEncoderError> {
1870 Ok(ArcCommand::PushDebugGroup(label.to_owned()))
1871 })
1872 }
1873
1874 pub fn command_encoder_insert_debug_marker(
1875 &self,
1876 encoder_id: id::CommandEncoderId,
1877 label: &str,
1878 ) -> Result<(), EncoderStateError> {
1879 profiling::scope!("CommandEncoder::insert_debug_marker");
1880 api_log!("CommandEncoder::insert_debug_marker {label}");
1881
1882 let hub = &self.hub;
1883
1884 let cmd_enc = hub.command_encoders.get(encoder_id);
1885 let mut cmd_buf_data = cmd_enc.data.lock();
1886
1887 cmd_buf_data.push_with(|| -> Result<_, CommandEncoderError> {
1888 Ok(ArcCommand::InsertDebugMarker(label.to_owned()))
1889 })
1890 }
1891
1892 pub fn command_encoder_pop_debug_group(
1893 &self,
1894 encoder_id: id::CommandEncoderId,
1895 ) -> Result<(), EncoderStateError> {
1896 profiling::scope!("CommandEncoder::pop_debug_marker");
1897 api_log!("CommandEncoder::pop_debug_group");
1898
1899 let hub = &self.hub;
1900
1901 let cmd_enc = hub.command_encoders.get(encoder_id);
1902 let mut cmd_buf_data = cmd_enc.data.lock();
1903
1904 cmd_buf_data
1905 .push_with(|| -> Result<_, CommandEncoderError> { Ok(ArcCommand::PopDebugGroup) })
1906 }
1907}
1908
1909pub(crate) fn push_debug_group(
1910 state: &mut EncodingState,
1911 label: &str,
1912) -> Result<(), CommandEncoderError> {
1913 *state.debug_scope_depth += 1;
1914
1915 if !state
1916 .device
1917 .instance_flags
1918 .contains(wgt::InstanceFlags::DISCARD_HAL_LABELS)
1919 {
1920 unsafe { state.raw_encoder.begin_debug_marker(label) };
1921 }
1922
1923 Ok(())
1924}
1925
1926pub(crate) fn insert_debug_marker(
1927 state: &mut EncodingState,
1928 label: &str,
1929) -> Result<(), CommandEncoderError> {
1930 if !state
1931 .device
1932 .instance_flags
1933 .contains(wgt::InstanceFlags::DISCARD_HAL_LABELS)
1934 {
1935 unsafe { state.raw_encoder.insert_debug_marker(label) };
1936 }
1937
1938 Ok(())
1939}
1940
1941pub(crate) fn pop_debug_group(state: &mut EncodingState) -> Result<(), CommandEncoderError> {
1942 if *state.debug_scope_depth == 0 {
1943 return Err(DebugGroupError::InvalidPop.into());
1944 }
1945 *state.debug_scope_depth -= 1;
1946
1947 if !state
1948 .device
1949 .instance_flags
1950 .contains(wgt::InstanceFlags::DISCARD_HAL_LABELS)
1951 {
1952 unsafe { state.raw_encoder.end_debug_marker() };
1953 }
1954
1955 Ok(())
1956}
1957
1958fn immediates_clear<PushFn>(offset: u32, size_bytes: u32, mut push_fn: PushFn)
1959where
1960 PushFn: FnMut(u32, &[u32]),
1961{
1962 let mut count_words = 0_u32;
1963 let size_words = size_bytes / wgt::IMMEDIATE_DATA_ALIGNMENT;
1964 while count_words < size_words {
1965 let count_bytes = count_words * wgt::IMMEDIATE_DATA_ALIGNMENT;
1966 let size_to_write_words =
1967 (size_words - count_words).min(IMMEDIATES_CLEAR_ARRAY.len() as u32);
1968
1969 push_fn(
1970 offset + count_bytes,
1971 &IMMEDIATES_CLEAR_ARRAY[0..size_to_write_words as usize],
1972 );
1973
1974 count_words += size_to_write_words;
1975 }
1976}
1977
1978#[derive(Debug, Copy, Clone)]
1979struct StateChange<T> {
1980 last_state: Option<T>,
1981}
1982
1983impl<T: Copy + PartialEq> StateChange<T> {
1984 fn new() -> Self {
1985 Self { last_state: None }
1986 }
1987 fn set_and_check_redundant(&mut self, new_state: T) -> bool {
1988 let already_set = self.last_state == Some(new_state);
1989 self.last_state = Some(new_state);
1990 already_set
1991 }
1992 fn reset(&mut self) {
1993 self.last_state = None;
1994 }
1995}
1996
1997impl<T: Copy + PartialEq> Default for StateChange<T> {
1998 fn default() -> Self {
1999 Self::new()
2000 }
2001}
2002
2003#[derive(Debug)]
2004struct BindGroupStateChange {
2005 last_states: [StateChange<Option<id::BindGroupId>>; hal::MAX_BIND_GROUPS],
2006}
2007
2008impl BindGroupStateChange {
2009 fn new() -> Self {
2010 Self {
2011 last_states: [StateChange::new(); hal::MAX_BIND_GROUPS],
2012 }
2013 }
2014
2015 fn set_and_check_redundant(
2016 &mut self,
2017 bind_group_id: Option<id::BindGroupId>,
2018 index: u32,
2019 dynamic_offsets: &mut Vec<u32>,
2020 offsets: &[wgt::DynamicOffset],
2021 ) -> bool {
2022 if offsets.is_empty() {
2024 if let Some(current_bind_group) = self.last_states.get_mut(index as usize) {
2027 if current_bind_group.set_and_check_redundant(bind_group_id) {
2029 return true;
2030 }
2031 }
2032 } else {
2033 if let Some(current_bind_group) = self.last_states.get_mut(index as usize) {
2037 current_bind_group.reset();
2038 }
2039 dynamic_offsets.extend_from_slice(offsets);
2040 }
2041 false
2042 }
2043 fn reset(&mut self) {
2044 self.last_states = [StateChange::new(); hal::MAX_BIND_GROUPS];
2045 }
2046}
2047
2048impl Default for BindGroupStateChange {
2049 fn default() -> Self {
2050 Self::new()
2051 }
2052}
2053
2054trait MapPassErr<T> {
2056 fn map_pass_err(self, scope: PassErrorScope) -> T;
2057}
2058
2059impl<T, E, F> MapPassErr<Result<T, F>> for Result<T, E>
2060where
2061 E: MapPassErr<F>,
2062{
2063 fn map_pass_err(self, scope: PassErrorScope) -> Result<T, F> {
2064 self.map_err(|err| err.map_pass_err(scope))
2065 }
2066}
2067
2068impl MapPassErr<PassStateError> for EncoderStateError {
2069 fn map_pass_err(self, scope: PassErrorScope) -> PassStateError {
2070 PassStateError { scope, inner: self }
2071 }
2072}
2073
2074#[derive(Clone, Copy, Debug)]
2075pub enum DrawKind {
2076 Draw,
2077 DrawIndirect,
2078 MultiDrawIndirect,
2079 MultiDrawIndirectCount,
2080}
2081
2082#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
2084#[derive(Clone, Copy, Debug, PartialEq, Eq)]
2085pub enum DrawCommandFamily {
2086 Draw,
2087 DrawIndexed,
2088 DrawMeshTasks,
2089}
2090
2091#[derive(Clone, Copy, Debug, Error)]
2101pub enum PassErrorScope {
2102 #[error("In a bundle parameter")]
2105 Bundle,
2106 #[error("In a pass parameter")]
2107 Pass,
2108 #[error("In a set_bind_group command")]
2109 SetBindGroup,
2110 #[error("In a set_pipeline command")]
2111 SetPipelineRender,
2112 #[error("In a set_pipeline command")]
2113 SetPipelineCompute,
2114 #[error("In a set_immediates command")]
2115 SetImmediate,
2116 #[error("In a set_vertex_buffer command")]
2117 SetVertexBuffer,
2118 #[error("In a set_index_buffer command")]
2119 SetIndexBuffer,
2120 #[error("In a set_blend_constant command")]
2121 SetBlendConstant,
2122 #[error("In a set_stencil_reference command")]
2123 SetStencilReference,
2124 #[error("In a set_viewport command")]
2125 SetViewport,
2126 #[error("In a set_scissor_rect command")]
2127 SetScissorRect,
2128 #[error("In a draw command, kind: {kind:?}")]
2129 Draw {
2130 kind: DrawKind,
2131 family: DrawCommandFamily,
2132 },
2133 #[error("In a write_timestamp command")]
2134 WriteTimestamp,
2135 #[error("In a begin_occlusion_query command")]
2136 BeginOcclusionQuery,
2137 #[error("In a end_occlusion_query command")]
2138 EndOcclusionQuery,
2139 #[error("In a begin_pipeline_statistics_query command")]
2140 BeginPipelineStatisticsQuery,
2141 #[error("In a end_pipeline_statistics_query command")]
2142 EndPipelineStatisticsQuery,
2143 #[error("In a transition_resources command")]
2144 TransitionResources,
2145 #[error("In a execute_bundle command")]
2146 ExecuteBundle,
2147 #[error("In a dispatch command, indirect:{indirect}")]
2148 Dispatch { indirect: bool },
2149 #[error("In a push_debug_group command")]
2150 PushDebugGroup,
2151 #[error("In a pop_debug_group command")]
2152 PopDebugGroup,
2153 #[error("In a insert_debug_marker command")]
2154 InsertDebugMarker,
2155}
2156
2157#[derive(Clone, Debug, Error)]
2159#[error("{scope}")]
2160pub struct PassStateError {
2161 pub scope: PassErrorScope,
2162 #[source]
2163 pub(super) inner: EncoderStateError,
2164}
2165
2166impl WebGpuError for PassStateError {
2167 fn webgpu_error_type(&self) -> ErrorType {
2168 let Self { scope: _, inner } = self;
2169 inner.webgpu_error_type()
2170 }
2171}