firefox-main/third_party/rust/wgpu-core/src/command/render_command.rs

Source code

Revision control

Copy as Markdown

Other Tools

use wgt::{BufferAddress, BufferSize, Color};
use super::{DrawCommandFamily, Rect};
#[cfg(feature = "serde")]
use crate::command::serde_object_reference_struct;
use crate::command::{ArcReferences, ReferenceType};
#[cfg(feature = "serde")]
use macro_rules_attribute::apply;
/// cbindgen:ignore
#[doc(hidden)]
#[derive(Clone, Debug)]
#[cfg_attr(feature = "serde", apply(serde_object_reference_struct))]
pub enum RenderCommand<R: ReferenceType> {
SetBindGroup {
index: u32,
num_dynamic_offsets: usize,
bind_group: Option<R::BindGroup>,
},
SetPipeline(R::RenderPipeline),
SetIndexBuffer {
buffer: R::Buffer,
index_format: wgt::IndexFormat,
offset: BufferAddress,
size: Option<BufferSize>,
},
SetVertexBuffer {
slot: u32,
buffer: R::Buffer,
offset: BufferAddress,
size: Option<BufferSize>,
},
SetBlendConstant(Color),
SetStencilReference(u32),
SetViewport {
rect: Rect<f32>,
//TODO: use half-float to reduce the size?
depth_min: f32,
depth_max: f32,
},
SetScissor(Rect<u32>),
/// Set a range of immediates to values stored in [`BasePass::immediates_data`].
///
/// See [`wgpu::RenderPass::set_immediates`] for a detailed explanation
/// of the restrictions these commands must satisfy.
SetImmediate {
/// The byte offset within the immediate data storage to write to. This
/// must be a multiple of four.
offset: u32,
/// The number of bytes to write. This must be a multiple of four.
size_bytes: u32,
/// Index in [`BasePass::immediates_data`] of the start of the data
/// to be written.
///
/// Note: this is not a byte offset like `offset`. Rather, it is the
/// index of the first `u32` element in `immediates_data` to read.
///
/// `None` means zeros should be written to the destination range, and
/// there is no corresponding data in `immediates_data`. This is used
/// by render bundles, which explicitly clear out any state that
/// post-bundle code might see.
values_offset: Option<u32>,
},
Draw {
vertex_count: u32,
instance_count: u32,
first_vertex: u32,
first_instance: u32,
},
DrawIndexed {
index_count: u32,
instance_count: u32,
first_index: u32,
base_vertex: i32,
first_instance: u32,
},
DrawMeshTasks {
group_count_x: u32,
group_count_y: u32,
group_count_z: u32,
},
DrawIndirect {
buffer: R::Buffer,
offset: BufferAddress,
count: u32,
family: DrawCommandFamily,
/// This limit is only populated for commands in a finished [`RenderBundle`].
vertex_or_index_limit: Option<u64>,
/// This limit is only populated for commands in a finished [`RenderBundle`].
instance_limit: Option<u64>,
},
MultiDrawIndirectCount {
buffer: R::Buffer,
offset: BufferAddress,
count_buffer: R::Buffer,
count_buffer_offset: BufferAddress,
max_count: u32,
family: DrawCommandFamily,
},
PushDebugGroup {
color: u32,
len: usize,
},
PopDebugGroup,
InsertDebugMarker {
color: u32,
len: usize,
},
WriteTimestamp {
query_set: R::QuerySet,
query_index: u32,
},
BeginOcclusionQuery {
query_index: u32,
},
EndOcclusionQuery,
BeginPipelineStatisticsQuery {
query_set: R::QuerySet,
query_index: u32,
},
EndPipelineStatisticsQuery,
ExecuteBundle(R::RenderBundle),
}
/// Equivalent to `RenderCommand` with the Ids resolved into resource Arcs.
///
/// In a render pass, commands are stored in this format between when they are
/// added to the pass, and when the pass is `end()`ed and the commands are
/// replayed to the HAL encoder. Validation occurs when the pass is ended, which
/// means that parameters stored in an `ArcRenderCommand` for a pass operation
/// have generally not been validated.
///
/// In a render bundle, commands are stored in this format between when the bundle
/// is `finish()`ed and when the bundle is executed. Validation occurs when the
/// bundle is finished, which means that parameters stored in an `ArcRenderCommand`
/// for a render bundle operation must have been validated.
///
/// cbindgen:ignore
pub type ArcRenderCommand = RenderCommand<ArcReferences>;