Struct gfx_backend_empty::CommandBuffer

pub struct CommandBuffer;

Dummy command buffer, which ignores all the calls.

Trait Implementations

impl CommandBuffer<Backend> for CommandBuffer

unsafe fn begin(
    &mut self,
    _: CommandBufferFlags,
    _: CommandBufferInheritanceInfo<'_, Backend>
)

Begins recording commands to a command buffer.

unsafe fn finish(&mut self)

Finish recording commands to a command buffer.

unsafe fn reset(&mut self, _: bool)

Empties the command buffer, optionally releasing all resources from the commands that have been submitted.

unsafe fn pipeline_barrier<'a, T>(
    &mut self,
    _: Range<PipelineStage>,
    _: Dependencies,
    _: T
) where
    T: Iterator<Item = Barrier<'a, Backend>>, 

Inserts a synchronization dependency between pipeline stages in the command buffer.

unsafe fn fill_buffer(&mut self, _: &Buffer, _: SubRange, _: u32)

Fill a buffer with the given u32 value.

unsafe fn update_buffer(&mut self, _: &Buffer, _: Offset, _: &[u8])

Copy data from the given slice into a buffer.

unsafe fn clear_image<T>(&mut self, _: &Image, _: Layout, _: ClearValue, _: T)

Clears an image to the given color/depth/stencil.

unsafe fn clear_attachments<T, U>(&mut self, _: T, _: U)

Takes an iterator of attachments and an iterator of rect’s, and clears the given rect’s for each attachment.

unsafe fn resolve_image<T>(
    &mut self,
    _: &Image,
    _: Layout,
    _: &Image,
    _: Layout,
    _: T
)

“Resolves” a multisampled image, converting it into a non-multisampled image. Takes an iterator of regions to apply the resolution to.

unsafe fn blit_image<T>(
    &mut self,
    _: &Image,
    _: Layout,
    _: &Image,
    _: Layout,
    _: Filter,
    _: T
)

Copies regions from the source to destination image, applying scaling, filtering and potentially format conversion.

unsafe fn bind_index_buffer(&mut self, _: &Buffer, _: SubRange, _: IndexType)

Bind the index buffer view, making it the “current” one that draw commands will operate on.

unsafe fn bind_vertex_buffers<'a, T>(&mut self, _: u32, _: T) where
    T: Iterator<Item = (&'a Buffer, SubRange)>, 

Bind the vertex buffer set, making it the “current” one that draw commands will operate on.

unsafe fn set_viewports<T>(&mut self, _: u32, _: T)

Set the viewport parameters for the rasterizer.

unsafe fn set_scissors<T>(&mut self, _: u32, _: T)

Set the scissor rectangles for the rasterizer.

unsafe fn set_stencil_reference(&mut self, _: Face, _: StencilValue)

Sets the stencil reference value for comparison operations and store operations. Will be used on the LHS of stencil compare ops and as store value when the store op is Reference.

unsafe fn set_stencil_read_mask(&mut self, _: Face, _: StencilValue)

Sets the stencil read mask.

unsafe fn set_stencil_write_mask(&mut self, _: Face, _: StencilValue)

Sets the stencil write mask.

unsafe fn set_blend_constants(&mut self, _: ColorValue)

Set the blend constant values dynamically.

unsafe fn set_depth_bounds(&mut self, _: Range<f32>)

Set the depth bounds test values dynamically.

unsafe fn set_line_width(&mut self, _: f32)

Set the line width dynamically.

unsafe fn set_depth_bias(&mut self, _: DepthBias)

Set the depth bias dynamically.

unsafe fn begin_render_pass<'a, T>(
    &mut self,
    _: &(),
    _: &(),
    _: Rect,
    _: T,
    _: SubpassContents
) where
    T: Iterator<Item = RenderAttachmentInfo<'a, Backend>>, 

Begins recording commands for a render pass on the given framebuffer.

unsafe fn next_subpass(&mut self, _: SubpassContents)

Steps to the next subpass in the current render pass.

unsafe fn end_render_pass(&mut self)

Finishes recording commands for the current a render pass.

unsafe fn bind_graphics_pipeline(&mut self, _: &())

Bind a graphics pipeline.

unsafe fn bind_graphics_descriptor_sets<'a, I, J>(
    &mut self,
    _: &(),
    _: usize,
    _: I,
    _: J
) where
    I: Iterator<Item = &'a DescriptorSet>, 

Takes an iterator of graphics DescriptorSet’s, and binds them to the command buffer. first_set is the index that the first descriptor is mapped to in the command buffer.

unsafe fn bind_compute_pipeline(&mut self, _: &())

Bind a compute pipeline.

unsafe fn bind_compute_descriptor_sets<'a, I, J>(
    &mut self,
    _: &(),
    _: usize,
    _: I,
    _: J
) where
    I: Iterator<Item = &'a DescriptorSet>, 

Takes an iterator of compute DescriptorSet’s, and binds them to the command buffer, first_set is the index that the first descriptor is mapped to in the command buffer.

unsafe fn dispatch(&mut self, _: WorkGroupCount)

Execute a workgroup in the compute pipeline. x, y and z are the number of local workgroups to dispatch along each “axis”; a total of xyz local workgroups will be created.

unsafe fn dispatch_indirect(&mut self, _: &Buffer, _: Offset)

Works similarly to dispatch() but reads parameters from the given buffer during execution.

unsafe fn copy_buffer<T>(&mut self, _: &Buffer, _: &Buffer, _: T)

Adds a command to copy regions from the source to destination buffer.

unsafe fn copy_image<T>(
    &mut self,
    _: &Image,
    _: Layout,
    _: &Image,
    _: Layout,
    _: T
)

Copies regions from the source to the destination images, which have the given layouts. No format conversion is done; the source and destination Layout’s must have the same sized image formats (such as Rgba8Unorm and R32, both of which are 32 bits).

unsafe fn copy_buffer_to_image<T>(
    &mut self,
    _: &Buffer,
    _: &Image,
    _: Layout,
    _: T
)

Copies regions from the source buffer to the destination image.

unsafe fn copy_image_to_buffer<T>(
    &mut self,
    _: &Image,
    _: Layout,
    _: &Buffer,
    _: T
)

Copies regions from the source image to the destination buffer.

unsafe fn draw(&mut self, _: Range<VertexCount>, _: Range<InstanceCount>)

Performs a non-indexed drawing operation, fetching vertex attributes from the currently bound vertex buffers. It performs instanced drawing, drawing instances.len() times with an instanceIndex starting with the start of the range.

unsafe fn draw_indexed(
    &mut self,
    _: Range<IndexCount>,
    _: VertexOffset,
    _: Range<InstanceCount>
)

Performs indexed drawing, drawing the range of indices given by the current index buffer and any bound vertex buffers. base_vertex specifies the vertex offset corresponding to index 0. That is, the offset into the vertex buffer is (current_index + base_vertex)

unsafe fn draw_indirect(
    &mut self,
    _: &Buffer,
    _: Offset,
    _: DrawCount,
    _: Stride
)

Functions identically to draw(), except the parameters are read from the given buffer, starting at offset and increasing stride bytes with each successive draw. Performs draw_count draws total. draw_count may be zero.

unsafe fn draw_indexed_indirect(
    &mut self,
    _: &Buffer,
    _: Offset,
    _: DrawCount,
    _: Stride
)

Like draw_indirect(), this does indexed drawing a la draw_indexed() but reads the draw parameters out of the given buffer.

unsafe fn draw_indirect_count(
    &mut self,
    _: &Buffer,
    _: Offset,
    _: &Buffer,
    _: Offset,
    _: u32,
    _: Stride
)

Functions identically to draw_indirect(), except the amount of draw calls are specified by the u32 in count_buffer at count_buffer_offset. There is a limit of max_draw_count invocations.

unsafe fn draw_indexed_indirect_count(
    &mut self,
    _: &Buffer,
    _: Offset,
    _: &Buffer,
    _: Offset,
    _: u32,
    _: Stride
)

Functions identically to draw_indexed_indirect(), except the amount of draw calls are specified by the u32 in count_buffer at count_buffer_offset. There is a limit of max_draw_count invocations.

unsafe fn draw_mesh_tasks(&mut self, _: TaskCount, _: TaskCount)

Dispatches task_count of threads. Similar to compute dispatch.

unsafe fn draw_mesh_tasks_indirect(
    &mut self,
    _: &Buffer,
    _: Offset,
    _: DrawCount,
    _: Stride
)

Indirect version of draw_mesh_tasks. Analogous to draw_indirect, but for mesh shaders.

unsafe fn draw_mesh_tasks_indirect_count(
    &mut self,
    _: &Buffer,
    _: Offset,
    _: &Buffer,
    _: Offset,
    _: u32,
    _: Stride
)

Like draw_mesh_tasks_indirect except that the draw count is read by the device from a buffer during execution. The command will read an unsigned 32-bit integer from count_buffer located at count_buffer_offset and use this as the draw count.

unsafe fn set_event(&mut self, _: &(), _: PipelineStage)

Signals an event once all specified stages of the shader pipeline have completed.

unsafe fn reset_event(&mut self, _: &(), _: PipelineStage)

Resets an event once all specified stages of the shader pipeline have completed.

unsafe fn wait_events<'a, I, J>(&mut self, _: I, _: Range<PipelineStage>, _: J) where
    J: Iterator<Item = Barrier<'a, Backend>>, 

Waits at some shader stage(s) until all events have been signalled.

unsafe fn begin_query(&mut self, _: Query<'_, Backend>, _: ControlFlags)

Begins a query operation. Queries count operations or record timestamps resulting from commands that occur between the beginning and end of the query, and save the results to the query pool.

unsafe fn end_query(&mut self, _: Query<'_, Backend>)

End a query.

unsafe fn reset_query_pool(&mut self, _: &(), _: Range<Id>)

Reset/clear the values in the given range of the query pool.

unsafe fn copy_query_pool_results(
    &mut self,
    _: &(),
    _: Range<Id>,
    _: &Buffer,
    _: Offset,
    _: Stride,
    _: ResultFlags
)

Copy query results into a buffer.

unsafe fn write_timestamp(&mut self, _: PipelineStage, _: Query<'_, Backend>)

Requests a timestamp to be written.

unsafe fn push_graphics_constants(
    &mut self,
    _: &(),
    _: ShaderStageFlags,
    _: u32,
    _: &[u32]
)

Modify constant data in a graphics pipeline. Push constants are intended to modify data in a pipeline more quickly than a updating the values inside a descriptor set.

unsafe fn push_compute_constants(&mut self, _: &(), _: u32, _: &[u32])

Modify constant data in a compute pipeline. Push constants are intended to modify data in a pipeline more quickly than a updating the values inside a descriptor set.

unsafe fn execute_commands<'a, T>(&mut self, _: T) where
    T: Iterator<Item = &'a CommandBuffer>, 

Execute the given secondary command buffers.

unsafe fn insert_debug_marker(&mut self, _: &str, _: u32)

Debug mark the current spot in the command buffer.

unsafe fn begin_debug_marker(&mut self, _: &str, _: u32)

Start a debug marker at the current place in the command buffer.

unsafe fn end_debug_marker(&mut self)

End the last started debug marker scope.

pub unsafe fn begin_primary(&mut self, flags: CommandBufferFlags)

Begins recording a primary command buffer (that has no inheritance information).

impl Debug for CommandBuffer

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

Formats the value using the given formatter.