Struct wgpu_hal::vulkan::CommandEncoder

pub struct CommandEncoder {
    raw: CommandPool,
    device: Arc<DeviceShared>,
    active: CommandBuffer,
    bind_point: PipelineBindPoint,
    temp: Temp,
    free: Vec<CommandBuffer>,
    discarded: Vec<CommandBuffer>,
    rpass_debug_marker_active: bool,
    end_of_pass_timer_query: Option<(QueryPool, u32)>,
    counters: Arc<HalCounters>,
}

Fields

raw: CommandPool

device: Arc<DeviceShared>

active: CommandBuffer

The current command buffer, if self is in the “recording” state.

If non-null, the buffer is in the Vulkan “recording” state.

bind_point: PipelineBindPoint

What kind of pass we are currently within: compute or render.

temp: Temp

Allocation recycling pool for this encoder.

free: Vec<CommandBuffer>

A pool of available command buffers.

These are all in the Vulkan “initial” state.

discarded: Vec<CommandBuffer>

A pool of discarded command buffers.

These could be in any Vulkan state except “pending”.

rpass_debug_marker_active: bool

If this is true, the active renderpass enabled a debug span, and needs to be disabled on renderpass close.

end_of_pass_timer_query: Option<(QueryPool, u32)>

If set, the end of the next render/compute pass will write a timestamp at the given pool & location.

counters: Arc<HalCounters>

Implementations

impl CommandEncoder

fn write_pass_end_timestamp_if_requested(&mut self)

impl CommandEncoder

pub unsafe fn raw_handle(&self) -> CommandBuffer

Safety

• The command buffer handle must not be manually destroyed

Trait Implementations

impl CommandEncoder for CommandEncoder

type A = Api

unsafe fn begin_encoding(&mut self, label: Label<'_>) -> Result<(), DeviceError>

Begin encoding a new command buffer.

unsafe fn end_encoding(&mut self) -> Result<CommandBuffer, DeviceError>

Return a fresh CommandBuffer holding the recorded commands.

unsafe fn discard_encoding(&mut self)

Discard the command list under construction.

unsafe fn reset_all<I>(&mut self, cmd_bufs: I)

where I: Iterator<Item = CommandBuffer>,

Reclaim all resources belonging to this CommandEncoder.

unsafe fn transition_buffers<'a, T>(&mut self, barriers: T)

where T: Iterator<Item = BufferBarrier<'a, Buffer>>,

unsafe fn transition_textures<'a, T>(&mut self, barriers: T)

where T: Iterator<Item = TextureBarrier<'a, Texture>>,

unsafe fn clear_buffer(&mut self, buffer: &Buffer, range: MemoryRange)

unsafe fn copy_buffer_to_buffer<T>( &mut self, src: &Buffer, dst: &Buffer, regions: T, )

where T: Iterator<Item = BufferCopy>,

unsafe fn copy_texture_to_texture<T>( &mut self, src: &Texture, src_usage: TextureUses, dst: &Texture, regions: T, )

where T: Iterator<Item = TextureCopy>,

Copy from one texture to another. Works with a single array layer. Note: dst current usage has to be TextureUses::COPY_DST. Note: the copy extent is in physical size (rounded to the block size)

unsafe fn copy_buffer_to_texture<T>( &mut self, src: &Buffer, dst: &Texture, regions: T, )

where T: Iterator<Item = BufferTextureCopy>,

Copy from buffer to texture. Works with a single array layer. Note: dst current usage has to be TextureUses::COPY_DST. Note: the copy extent is in physical size (rounded to the block size)

unsafe fn copy_texture_to_buffer<T>( &mut self, src: &Texture, src_usage: TextureUses, dst: &Buffer, regions: T, )

where T: Iterator<Item = BufferTextureCopy>,

Copy from texture to buffer. Works with a single array layer. Note: the copy extent is in physical size (rounded to the block size)

unsafe fn begin_query(&mut self, set: &QuerySet, index: u32)

Safety:

unsafe fn end_query(&mut self, set: &QuerySet, index: u32)

Safety:

unsafe fn write_timestamp(&mut self, set: &QuerySet, index: u32)

unsafe fn reset_queries(&mut self, set: &QuerySet, range: Range<u32>)

unsafe fn copy_query_results( &mut self, set: &QuerySet, range: Range<u32>, buffer: &Buffer, offset: BufferAddress, stride: BufferSize, )

unsafe fn build_acceleration_structures<'a, T>( &mut self, descriptor_count: u32, descriptors: T, )

where Api: 'a, T: IntoIterator<Item = BuildAccelerationStructureDescriptor<'a, Buffer, AccelerationStructure>>,

To get the required sizes for the buffer allocations use get_acceleration_structure_build_sizes per descriptor All buffers must be synchronized externally All buffer regions, which are written to may only be passed once per function call, with the exception of updates in the same descriptor. Consequences of this limitation:

unsafe fn place_acceleration_structure_barrier( &mut self, barrier: AccelerationStructureBarrier, )

unsafe fn begin_render_pass( &mut self, desc: &RenderPassDescriptor<'_, QuerySet, TextureView>, )

Begin a new render pass, clearing all active bindings.

unsafe fn end_render_pass(&mut self)

End the current render pass.

unsafe fn set_bind_group( &mut self, layout: &PipelineLayout, index: u32, group: &BindGroup, dynamic_offsets: &[DynamicOffset], )

Sets the bind group at index to group.

unsafe fn set_push_constants( &mut self, layout: &PipelineLayout, stages: ShaderStages, offset_bytes: u32, data: &[u32], )

Sets a range in push constant data.

unsafe fn insert_debug_marker(&mut self, label: &str)

unsafe fn begin_debug_marker(&mut self, group_label: &str)

unsafe fn end_debug_marker(&mut self)

unsafe fn set_render_pipeline(&mut self, pipeline: &RenderPipeline)

unsafe fn set_index_buffer<'a>( &mut self, binding: BufferBinding<'a, Buffer>, format: IndexFormat, )

unsafe fn set_vertex_buffer<'a>( &mut self, index: u32, binding: BufferBinding<'a, Buffer>, )

unsafe fn set_viewport(&mut self, rect: &Rect<f32>, depth_range: Range<f32>)

unsafe fn set_scissor_rect(&mut self, rect: &Rect<u32>)

unsafe fn set_stencil_reference(&mut self, value: u32)

unsafe fn set_blend_constants(&mut self, color: &[f32; 4])

unsafe fn draw( &mut self, first_vertex: u32, vertex_count: u32, first_instance: u32, instance_count: u32, )

unsafe fn draw_indexed( &mut self, first_index: u32, index_count: u32, base_vertex: i32, first_instance: u32, instance_count: u32, )

unsafe fn draw_indirect( &mut self, buffer: &Buffer, offset: BufferAddress, draw_count: u32, )

unsafe fn draw_indexed_indirect( &mut self, buffer: &Buffer, offset: BufferAddress, draw_count: u32, )

unsafe fn draw_indirect_count( &mut self, buffer: &Buffer, offset: BufferAddress, count_buffer: &Buffer, count_offset: BufferAddress, max_count: u32, )

unsafe fn draw_indexed_indirect_count( &mut self, buffer: &Buffer, offset: BufferAddress, count_buffer: &Buffer, count_offset: BufferAddress, max_count: u32, )

unsafe fn begin_compute_pass( &mut self, desc: &ComputePassDescriptor<'_, QuerySet>, )

Begin a new compute pass, clearing all active bindings.

unsafe fn end_compute_pass(&mut self)

End the current compute pass.

unsafe fn set_compute_pipeline(&mut self, pipeline: &ComputePipeline)

unsafe fn dispatch(&mut self, count: [u32; 3])

unsafe fn dispatch_indirect(&mut self, buffer: &Buffer, offset: BufferAddress)

impl Debug for CommandEncoder

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Drop for CommandEncoder

fn drop(&mut self)

Executes the destructor for this type.

impl DynResource for CommandEncoder

fn as_any(&self) -> &dyn Any

fn as_any_mut(&mut self) -> &mut dyn Any