Struct wgpu_core::command::bundle::State

struct State<A: HalApi> {
    trackers: RenderBundleScope<A>,
    pipeline: Option<PipelineState>,
    bind: ArrayVec<Option<BindState>, { hal::MAX_BIND_GROUPS }>,
    vertex: ArrayVec<Option<VertexState>, { hal::MAX_VERTEX_BUFFERS }>,
    index: Option<IndexState>,
    flat_dynamic_offsets: Vec<DynamicOffset>,
}

State for analyzing and cleaning up bundle command streams.

To minimize state updates, RenderBundleEncoder::finish actually just applies commands like SetBindGroup and SetIndexBuffer to the simulated state stored here, and then calls the flush_foo methods before draw calls to produce the update commands we actually need.

Fields

trackers: RenderBundleScope<A>

Resources used by this bundle. This will become RenderBundle::used.

pipeline: Option<PipelineState>

The currently set pipeline, if any.

bind: ArrayVec<Option<BindState>, { hal::MAX_BIND_GROUPS }>

The bind group set at each index, if any.

vertex: ArrayVec<Option<VertexState>, { hal::MAX_VERTEX_BUFFERS }>

The state of each vertex buffer slot.

index: Option<IndexState>

The current index buffer, if one has been set. We flush this state before indexed draw commands.

flat_dynamic_offsets: Vec<DynamicOffset>

Dynamic offset values used by the cleaned-up command sequence.

This becomes the final RenderBundle’s [BasePass]’s dynamic_offsets list.

Implementations

impl<A: HalApi> State<A>

fn vertex_limits(&self, pipeline: &PipelineState) -> VertexLimitState

fn pipeline_id(&self) -> Option<RenderPipelineId>

Return the id of the current pipeline, if any.

fn pipeline( &self, scope: PassErrorScope ) -> Result<&PipelineState, RenderBundleError>

Return the current pipeline state. Return an error if none is set.

fn invalidate_bind_group_from(&mut self, index: usize)

Mark all non-empty bind group table entries from index onwards as dirty.

fn set_bind_group( &mut self, slot: u32, bind_group_id: BindGroupId, layout_id: Valid<BindGroupLayoutId>, dynamic_offsets: Range<usize> )

fn invalidate_bind_groups( &mut self, new: &PipelineState, layout: &PipelineLayout<A> )

Determine which bind group slots need to be re-set after a pipeline change.

Given that we are switching from the current pipeline state to new, whose layout is layout, mark all the bind group slots that we need to emit new SetBindGroup commands for as dirty.

According to wgpu_hal’s rules:

• If the layout of any bind group slot changes, then that slot and all following slots must have their bind groups re-established.

• Changing the push constant ranges at all requires re-establishing all bind groups.

fn set_index_buffer( &mut self, buffer: BufferId, format: IndexFormat, range: Range<BufferAddress> )

Set the bundle’s current index buffer and its associated parameters.

fn flush_index(&mut self) -> Option<RenderCommand>

Generate a SetIndexBuffer command to prepare for an indexed draw command, if needed.

fn flush_vertices(&mut self) -> impl Iterator<Item = RenderCommand> + '_

fn flush_binds( &mut self, used_bind_groups: usize, dynamic_offsets: &[DynamicOffset] ) -> impl Iterator<Item = RenderCommand> + '_

Generate SetBindGroup commands for any bind groups that need to be updated.