Enum wgpu_core::command::CommandEncoderStatus

pub(crate) enum CommandEncoderStatus {
    Recording(CommandBufferMutable),
    Locked(CommandBufferMutable),
    Finished(CommandBufferMutable),
    Error,
}

The current state of a CommandBuffer.

Variants

Recording(CommandBufferMutable)

Ready to record commands. An encoder’s initial state.

Command building methods like command_encoder_clear_buffer and compute_pass_end require the encoder to be in this state.

This corresponds to WebGPU’s “open” state. See https://www.w3.org/TR/webgpu/#encoder-state-open

Locked(CommandBufferMutable)

Locked by a render or compute pass.

This state is entered when a render/compute pass is created, and exited when the pass is ended.

As long as the command encoder is locked, any command building operation on it will fail and put the encoder into the Self::Error state. See https://www.w3.org/TR/webgpu/#encoder-state-locked

Finished(CommandBufferMutable)

Command recording is complete, and the buffer is ready for submission.

Global::command_encoder_finish transitions a CommandBuffer from the Recording state into this state.

Global::queue_submit drops command buffers unless they are in this state.

Error

An error occurred while recording a compute or render pass.

When a CommandEncoder is left in this state, we have also returned an error result from the function that encountered the problem. Future attempts to use the encoder (for example, calls to Self::record) will also return errors.

Implementations

impl CommandEncoderStatus

pub(crate) fn record( &mut self, ) -> Result<RecordingGuard<'_>, CommandEncoderError>

Checks that the encoder is in the Self::Recording state.

fn lock_encoder(&mut self) -> Result<(), CommandEncoderError>

Locks the encoder by putting it in the Self::Locked state.

Call Self::unlock_encoder to put the CommandBuffer back into the Self::Recording state.

fn unlock_encoder(&mut self) -> Result<RecordingGuard<'_>, CommandEncoderError>

Unlocks the CommandBuffer and puts it back into the Self::Recording state.

This function is the unlocking counterpart to Self::lock_encoder.

It is only valid to call this function if the encoder is in the Self::Locked state.

fn finish(&mut self, device: &Device) -> Result<(), CommandEncoderError>