Struct vulkano::command_buffer::AutoCommandBufferBuilder [−][src]
pub struct AutoCommandBufferBuilder<L, P = StandardCommandPoolBuilder> { /* fields omitted */ }
Expand description
Note that command buffers allocated from the default command pool (Arc<StandardCommandPool>
)
don’t implement the Send
and Sync
traits. If you use this pool, then the
AutoCommandBufferBuilder
will not implement Send
and Sync
either. Once a command buffer
is built, however, it does implement Send
and Sync
.
Implementations
pub fn primary(
device: Arc<Device>,
queue_family: QueueFamily<'_>,
usage: CommandBufferUsage
) -> Result<AutoCommandBufferBuilder<PrimaryAutoCommandBuffer, StandardCommandPoolBuilder>, OomError>
pub fn primary(
device: Arc<Device>,
queue_family: QueueFamily<'_>,
usage: CommandBufferUsage
) -> Result<AutoCommandBufferBuilder<PrimaryAutoCommandBuffer, StandardCommandPoolBuilder>, OomError>
Starts building a primary command buffer.
pub fn secondary_compute(
device: Arc<Device>,
queue_family: QueueFamily<'_>,
usage: CommandBufferUsage
) -> Result<AutoCommandBufferBuilder<SecondaryAutoCommandBuffer, StandardCommandPoolBuilder>, OomError>
pub fn secondary_compute(
device: Arc<Device>,
queue_family: QueueFamily<'_>,
usage: CommandBufferUsage
) -> Result<AutoCommandBufferBuilder<SecondaryAutoCommandBuffer, StandardCommandPoolBuilder>, OomError>
Starts building a secondary compute command buffer.
pub fn secondary_compute_inherit_queries(
device: Arc<Device>,
queue_family: QueueFamily<'_>,
usage: CommandBufferUsage,
occlusion_query: Option<QueryControlFlags>,
query_statistics_flags: QueryPipelineStatisticFlags
) -> Result<AutoCommandBufferBuilder<SecondaryAutoCommandBuffer, StandardCommandPoolBuilder>, BeginError>
pub fn secondary_compute_inherit_queries(
device: Arc<Device>,
queue_family: QueueFamily<'_>,
usage: CommandBufferUsage,
occlusion_query: Option<QueryControlFlags>,
query_statistics_flags: QueryPipelineStatisticFlags
) -> Result<AutoCommandBufferBuilder<SecondaryAutoCommandBuffer, StandardCommandPoolBuilder>, BeginError>
Same as secondary_compute
, but allows specifying how queries are being inherited.
pub fn secondary_graphics(
device: Arc<Device>,
queue_family: QueueFamily<'_>,
usage: CommandBufferUsage,
subpass: Subpass
) -> Result<AutoCommandBufferBuilder<SecondaryAutoCommandBuffer, StandardCommandPoolBuilder>, OomError>
pub fn secondary_graphics(
device: Arc<Device>,
queue_family: QueueFamily<'_>,
usage: CommandBufferUsage,
subpass: Subpass
) -> Result<AutoCommandBufferBuilder<SecondaryAutoCommandBuffer, StandardCommandPoolBuilder>, OomError>
Starts building a secondary graphics command buffer.
pub fn secondary_graphics_inherit_queries(
device: Arc<Device>,
queue_family: QueueFamily<'_>,
usage: CommandBufferUsage,
subpass: Subpass,
occlusion_query: Option<QueryControlFlags>,
query_statistics_flags: QueryPipelineStatisticFlags
) -> Result<AutoCommandBufferBuilder<SecondaryAutoCommandBuffer, StandardCommandPoolBuilder>, BeginError>
pub fn secondary_graphics_inherit_queries(
device: Arc<Device>,
queue_family: QueueFamily<'_>,
usage: CommandBufferUsage,
subpass: Subpass,
occlusion_query: Option<QueryControlFlags>,
query_statistics_flags: QueryPipelineStatisticFlags
) -> Result<AutoCommandBufferBuilder<SecondaryAutoCommandBuffer, StandardCommandPoolBuilder>, BeginError>
Same as secondary_graphics
, but allows specifying how queries are being inherited.
impl<P> AutoCommandBufferBuilder<PrimaryAutoCommandBuffer<P::Alloc>, P> where
P: CommandPoolBuilderAlloc,
impl<P> AutoCommandBufferBuilder<PrimaryAutoCommandBuffer<P::Alloc>, P> where
P: CommandPoolBuilderAlloc,
Builds the command buffer.
impl<P> AutoCommandBufferBuilder<SecondaryAutoCommandBuffer<P::Alloc>, P> where
P: CommandPoolBuilderAlloc,
impl<P> AutoCommandBufferBuilder<SecondaryAutoCommandBuffer<P::Alloc>, P> where
P: CommandPoolBuilderAlloc,
Builds the command buffer.
pub fn copy_image<S, D>(
&mut self,
source: S,
source_offset: [i32; 3],
source_base_array_layer: u32,
source_mip_level: u32,
destination: D,
destination_offset: [i32; 3],
destination_base_array_layer: u32,
destination_mip_level: u32,
extent: [u32; 3],
layer_count: u32
) -> Result<&mut Self, CopyImageError> where
S: ImageAccess + Send + Sync + 'static,
D: ImageAccess + Send + Sync + 'static,
pub fn copy_image<S, D>(
&mut self,
source: S,
source_offset: [i32; 3],
source_base_array_layer: u32,
source_mip_level: u32,
destination: D,
destination_offset: [i32; 3],
destination_base_array_layer: u32,
destination_mip_level: u32,
extent: [u32; 3],
layer_count: u32
) -> Result<&mut Self, CopyImageError> where
S: ImageAccess + Send + Sync + 'static,
D: ImageAccess + Send + Sync + 'static,
Adds a command that copies an image to another.
Copy operations have several restrictions:
- Copy operations are only allowed on queue families that support transfer, graphics, or compute operations.
- The number of samples in the source and destination images must be equal.
- The size of the uncompressed element format of the source image must be equal to the compressed element format of the destination.
- If you copy between depth, stencil or depth-stencil images, the format of both images must match exactly.
- For two-dimensional images, the Z coordinate must be 0 for the image offsets and 1 for the extent. Same for the Y coordinate for one-dimensional images.
- For non-array images, the base array layer must be 0 and the number of layers must be 1.
If layer_count
is greater than 1, the copy will happen between each individual layer as
if they were separate images.
Panic
- Panics if the source or the destination was not created with
device
.
pub fn blit_image<S, D>(
&mut self,
source: S,
source_top_left: [i32; 3],
source_bottom_right: [i32; 3],
source_base_array_layer: u32,
source_mip_level: u32,
destination: D,
destination_top_left: [i32; 3],
destination_bottom_right: [i32; 3],
destination_base_array_layer: u32,
destination_mip_level: u32,
layer_count: u32,
filter: Filter
) -> Result<&mut Self, BlitImageError> where
S: ImageAccess + Send + Sync + 'static,
D: ImageAccess + Send + Sync + 'static,
pub fn blit_image<S, D>(
&mut self,
source: S,
source_top_left: [i32; 3],
source_bottom_right: [i32; 3],
source_base_array_layer: u32,
source_mip_level: u32,
destination: D,
destination_top_left: [i32; 3],
destination_bottom_right: [i32; 3],
destination_base_array_layer: u32,
destination_mip_level: u32,
layer_count: u32,
filter: Filter
) -> Result<&mut Self, BlitImageError> where
S: ImageAccess + Send + Sync + 'static,
D: ImageAccess + Send + Sync + 'static,
Adds a command that blits an image to another.
A blit is similar to an image copy operation, except that the portion of the image that is transferred can be resized. You choose an area of the source and an area of the destination, and the implementation will resize the area of the source so that it matches the size of the area of the destination before writing it.
Blit operations have several restrictions:
- Blit operations are only allowed on queue families that support graphics operations.
- The format of the source and destination images must support blit operations, which depends on the Vulkan implementation. Vulkan guarantees that some specific formats must always be supported. See tables 52 to 61 of the specifications.
- Only single-sampled images are allowed.
- You can only blit between two images whose formats belong to the same type. The types are: floating-point, signed integers, unsigned integers, depth-stencil.
- If you blit between depth, stencil or depth-stencil images, the format of both images must match exactly.
- If you blit between depth, stencil or depth-stencil images, only the
Nearest
filter is allowed. - For two-dimensional images, the Z coordinate must be 0 for the top-left offset and 1 for the bottom-right offset. Same for the Y coordinate for one-dimensional images.
- For non-array images, the base array layer must be 0 and the number of layers must be 1.
If layer_count
is greater than 1, the blit will happen between each individual layer as
if they were separate images.
Panic
- Panics if the source or the destination was not created with
device
.
pub fn clear_color_image<I>(
&mut self,
image: I,
color: ClearValue
) -> Result<&mut Self, ClearColorImageError> where
I: ImageAccess + Send + Sync + 'static,
pub fn clear_color_image<I>(
&mut self,
image: I,
color: ClearValue
) -> Result<&mut Self, ClearColorImageError> where
I: ImageAccess + Send + Sync + 'static,
Adds a command that clears all the layers and mipmap levels of a color image with a specific value.
Panic
Panics if color
is not a color value.
pub fn clear_color_image_dimensions<I>(
&mut self,
image: I,
first_layer: u32,
num_layers: u32,
first_mipmap: u32,
num_mipmaps: u32,
color: ClearValue
) -> Result<&mut Self, ClearColorImageError> where
I: ImageAccess + Send + Sync + 'static,
pub fn clear_color_image_dimensions<I>(
&mut self,
image: I,
first_layer: u32,
num_layers: u32,
first_mipmap: u32,
num_mipmaps: u32,
color: ClearValue
) -> Result<&mut Self, ClearColorImageError> where
I: ImageAccess + Send + Sync + 'static,
Adds a command that clears a color image with a specific value.
Panic
- Panics if
color
is not a color value.
pub fn copy_buffer<S, D, T>(
&mut self,
source: S,
destination: D
) -> Result<&mut Self, CopyBufferError> where
S: TypedBufferAccess<Content = T> + Send + Sync + 'static,
D: TypedBufferAccess<Content = T> + Send + Sync + 'static,
T: ?Sized,
pub fn copy_buffer<S, D, T>(
&mut self,
source: S,
destination: D
) -> Result<&mut Self, CopyBufferError> where
S: TypedBufferAccess<Content = T> + Send + Sync + 'static,
D: TypedBufferAccess<Content = T> + Send + Sync + 'static,
T: ?Sized,
Adds a command that copies from a buffer to another.
This command will copy from the source to the destination. If their size is not equal, then the amount of data copied is equal to the smallest of the two.
pub fn copy_buffer_dimensions<S, D, T>(
&mut self,
source: S,
source_offset: usize,
destination: D,
destination_offset: usize,
count: usize
) -> Result<&mut Self, CopyBufferError> where
S: TypedBufferAccess<Content = [T]> + Send + Sync + 'static,
D: TypedBufferAccess<Content = [T]> + Send + Sync + 'static,
pub fn copy_buffer_dimensions<S, D, T>(
&mut self,
source: S,
source_offset: usize,
destination: D,
destination_offset: usize,
count: usize
) -> Result<&mut Self, CopyBufferError> where
S: TypedBufferAccess<Content = [T]> + Send + Sync + 'static,
D: TypedBufferAccess<Content = [T]> + Send + Sync + 'static,
Adds a command that copies a range from the source to the destination buffer. Panics if out of bounds.
pub fn copy_buffer_to_image<S, D, Px>(
&mut self,
source: S,
destination: D
) -> Result<&mut Self, CopyBufferImageError> where
S: TypedBufferAccess<Content = [Px]> + Send + Sync + 'static,
D: ImageAccess + Send + Sync + 'static,
Px: Pixel,
pub fn copy_buffer_to_image<S, D, Px>(
&mut self,
source: S,
destination: D
) -> Result<&mut Self, CopyBufferImageError> where
S: TypedBufferAccess<Content = [Px]> + Send + Sync + 'static,
D: ImageAccess + Send + Sync + 'static,
Px: Pixel,
Adds a command that copies from a buffer to an image.
pub fn copy_buffer_to_image_dimensions<S, D, Px>(
&mut self,
source: S,
destination: D,
offset: [u32; 3],
size: [u32; 3],
first_layer: u32,
num_layers: u32,
mipmap: u32
) -> Result<&mut Self, CopyBufferImageError> where
S: TypedBufferAccess<Content = [Px]> + Send + Sync + 'static,
D: ImageAccess + Send + Sync + 'static,
Px: Pixel,
pub fn copy_buffer_to_image_dimensions<S, D, Px>(
&mut self,
source: S,
destination: D,
offset: [u32; 3],
size: [u32; 3],
first_layer: u32,
num_layers: u32,
mipmap: u32
) -> Result<&mut Self, CopyBufferImageError> where
S: TypedBufferAccess<Content = [Px]> + Send + Sync + 'static,
D: ImageAccess + Send + Sync + 'static,
Px: Pixel,
Adds a command that copies from a buffer to an image.
pub fn copy_image_to_buffer<S, D, Px>(
&mut self,
source: S,
destination: D
) -> Result<&mut Self, CopyBufferImageError> where
S: ImageAccess + Send + Sync + 'static,
D: TypedBufferAccess<Content = [Px]> + Send + Sync + 'static,
Px: Pixel,
pub fn copy_image_to_buffer<S, D, Px>(
&mut self,
source: S,
destination: D
) -> Result<&mut Self, CopyBufferImageError> where
S: ImageAccess + Send + Sync + 'static,
D: TypedBufferAccess<Content = [Px]> + Send + Sync + 'static,
Px: Pixel,
Adds a command that copies from an image to a buffer.
pub fn copy_image_to_buffer_dimensions<S, D, Px>(
&mut self,
source: S,
destination: D,
offset: [u32; 3],
size: [u32; 3],
first_layer: u32,
num_layers: u32,
mipmap: u32
) -> Result<&mut Self, CopyBufferImageError> where
S: ImageAccess + Send + Sync + 'static,
D: TypedBufferAccess<Content = [Px]> + Send + Sync + 'static,
Px: Pixel,
pub fn copy_image_to_buffer_dimensions<S, D, Px>(
&mut self,
source: S,
destination: D,
offset: [u32; 3],
size: [u32; 3],
first_layer: u32,
num_layers: u32,
mipmap: u32
) -> Result<&mut Self, CopyBufferImageError> where
S: ImageAccess + Send + Sync + 'static,
D: TypedBufferAccess<Content = [Px]> + Send + Sync + 'static,
Px: Pixel,
Adds a command that copies from an image to a buffer.
pub fn debug_marker_begin(
&mut self,
name: &'static CStr,
color: [f32; 4]
) -> Result<&mut Self, DebugMarkerError>
pub fn debug_marker_begin(
&mut self,
name: &'static CStr,
color: [f32; 4]
) -> Result<&mut Self, DebugMarkerError>
Open a command buffer debug label region.
Note: you need to enable VK_EXT_debug_utils
extension when creating an instance.
Close a command buffer label region.
Note: you need to open a command buffer label region first with debug_marker_begin
.
Note: you need to enable VK_EXT_debug_utils
extension when creating an instance.
pub fn debug_marker_insert(
&mut self,
name: &'static CStr,
color: [f32; 4]
) -> Result<&mut Self, DebugMarkerError>
pub fn debug_marker_insert(
&mut self,
name: &'static CStr,
color: [f32; 4]
) -> Result<&mut Self, DebugMarkerError>
Insert a label into a command buffer.
Note: you need to enable VK_EXT_debug_utils
extension when creating an instance.
pub fn dispatch<Cp, S, Pc, Do, Doi>(
&mut self,
group_counts: [u32; 3],
pipeline: Cp,
sets: S,
constants: Pc,
dynamic_offsets: Do
) -> Result<&mut Self, DispatchError> where
Cp: ComputePipelineAbstract + Send + Sync + 'static + Clone,
S: DescriptorSetsCollection,
Do: IntoIterator<Item = u32, IntoIter = Doi>,
Doi: Iterator<Item = u32> + Send + Sync + 'static,
pub fn dispatch<Cp, S, Pc, Do, Doi>(
&mut self,
group_counts: [u32; 3],
pipeline: Cp,
sets: S,
constants: Pc,
dynamic_offsets: Do
) -> Result<&mut Self, DispatchError> where
Cp: ComputePipelineAbstract + Send + Sync + 'static + Clone,
S: DescriptorSetsCollection,
Do: IntoIterator<Item = u32, IntoIter = Doi>,
Doi: Iterator<Item = u32> + Send + Sync + 'static,
Perform a single compute operation using a compute pipeline.
pub fn dispatch_indirect<Inb, Cp, S, Pc, Do, Doi>(
&mut self,
indirect_buffer: Inb,
pipeline: Cp,
sets: S,
constants: Pc,
dynamic_offsets: Do
) -> Result<&mut Self, DispatchIndirectError> where
Inb: BufferAccess + TypedBufferAccess<Content = [DispatchIndirectCommand]> + Send + Sync + 'static,
Cp: ComputePipelineAbstract + Send + Sync + 'static + Clone,
S: DescriptorSetsCollection,
Do: IntoIterator<Item = u32, IntoIter = Doi>,
Doi: Iterator<Item = u32> + Send + Sync + 'static,
pub fn dispatch_indirect<Inb, Cp, S, Pc, Do, Doi>(
&mut self,
indirect_buffer: Inb,
pipeline: Cp,
sets: S,
constants: Pc,
dynamic_offsets: Do
) -> Result<&mut Self, DispatchIndirectError> where
Inb: BufferAccess + TypedBufferAccess<Content = [DispatchIndirectCommand]> + Send + Sync + 'static,
Cp: ComputePipelineAbstract + Send + Sync + 'static + Clone,
S: DescriptorSetsCollection,
Do: IntoIterator<Item = u32, IntoIter = Doi>,
Doi: Iterator<Item = u32> + Send + Sync + 'static,
Perform multiple compute operations using a compute pipeline. One dispatch is performed for
each vulkano::command_buffer::DispatchIndirectCommand
struct in indirect_buffer
.
pub fn draw<V, Gp, S, Pc, Do, Doi>(
&mut self,
pipeline: Gp,
dynamic: &DynamicState,
vertex_buffer: V,
sets: S,
constants: Pc,
dynamic_offsets: Do
) -> Result<&mut Self, DrawError> where
Gp: GraphicsPipelineAbstract + VertexSource<V> + Send + Sync + 'static + Clone,
S: DescriptorSetsCollection,
Do: IntoIterator<Item = u32, IntoIter = Doi>,
Doi: Iterator<Item = u32> + Send + Sync + 'static,
pub fn draw<V, Gp, S, Pc, Do, Doi>(
&mut self,
pipeline: Gp,
dynamic: &DynamicState,
vertex_buffer: V,
sets: S,
constants: Pc,
dynamic_offsets: Do
) -> Result<&mut Self, DrawError> where
Gp: GraphicsPipelineAbstract + VertexSource<V> + Send + Sync + 'static + Clone,
S: DescriptorSetsCollection,
Do: IntoIterator<Item = u32, IntoIter = Doi>,
Doi: Iterator<Item = u32> + Send + Sync + 'static,
Perform a single draw operation using a graphics pipeline.
vertex_buffer
is a set of vertex and/or instance buffers used to provide input.
All data in vertex_buffer
is used for the draw operation. To use only some data in the
buffer, wrap it in a vulkano::buffer::BufferSlice
.
pub fn draw_indirect<V, Gp, S, Pc, Inb, Do, Doi>(
&mut self,
pipeline: Gp,
dynamic: &DynamicState,
vertex_buffer: V,
indirect_buffer: Inb,
sets: S,
constants: Pc,
dynamic_offsets: Do
) -> Result<&mut Self, DrawIndirectError> where
Gp: GraphicsPipelineAbstract + VertexSource<V> + Send + Sync + 'static + Clone,
S: DescriptorSetsCollection,
Inb: BufferAccess + TypedBufferAccess<Content = [DrawIndirectCommand]> + Send + Sync + 'static,
Do: IntoIterator<Item = u32, IntoIter = Doi>,
Doi: Iterator<Item = u32> + Send + Sync + 'static,
pub fn draw_indirect<V, Gp, S, Pc, Inb, Do, Doi>(
&mut self,
pipeline: Gp,
dynamic: &DynamicState,
vertex_buffer: V,
indirect_buffer: Inb,
sets: S,
constants: Pc,
dynamic_offsets: Do
) -> Result<&mut Self, DrawIndirectError> where
Gp: GraphicsPipelineAbstract + VertexSource<V> + Send + Sync + 'static + Clone,
S: DescriptorSetsCollection,
Inb: BufferAccess + TypedBufferAccess<Content = [DrawIndirectCommand]> + Send + Sync + 'static,
Do: IntoIterator<Item = u32, IntoIter = Doi>,
Doi: Iterator<Item = u32> + Send + Sync + 'static,
Perform multiple draw operations using a graphics pipeline.
One draw is performed for each DrawIndirectCommand
struct in indirect_buffer
.
The maximum number of draw commands in the buffer is limited by the
max_draw_indirect_count
limit.
This limit is 1 unless the
multi_draw_indirect
feature has been
enabled.
vertex_buffer
is a set of vertex and/or instance buffers used to provide input. It is
used for every draw operation.
All data in vertex_buffer
is used for every draw operation. To use only some data in the
buffer, wrap it in a vulkano::buffer::BufferSlice
.
pub fn draw_indexed<V, Gp, S, Pc, Ib, I, Do, Doi>(
&mut self,
pipeline: Gp,
dynamic: &DynamicState,
vertex_buffer: V,
index_buffer: Ib,
sets: S,
constants: Pc,
dynamic_offsets: Do
) -> Result<&mut Self, DrawIndexedError> where
Gp: GraphicsPipelineAbstract + VertexSource<V> + Send + Sync + 'static + Clone,
S: DescriptorSetsCollection,
Ib: BufferAccess + TypedBufferAccess<Content = [I]> + Send + Sync + 'static,
I: Index + 'static,
Do: IntoIterator<Item = u32, IntoIter = Doi>,
Doi: Iterator<Item = u32> + Send + Sync + 'static,
pub fn draw_indexed<V, Gp, S, Pc, Ib, I, Do, Doi>(
&mut self,
pipeline: Gp,
dynamic: &DynamicState,
vertex_buffer: V,
index_buffer: Ib,
sets: S,
constants: Pc,
dynamic_offsets: Do
) -> Result<&mut Self, DrawIndexedError> where
Gp: GraphicsPipelineAbstract + VertexSource<V> + Send + Sync + 'static + Clone,
S: DescriptorSetsCollection,
Ib: BufferAccess + TypedBufferAccess<Content = [I]> + Send + Sync + 'static,
I: Index + 'static,
Do: IntoIterator<Item = u32, IntoIter = Doi>,
Doi: Iterator<Item = u32> + Send + Sync + 'static,
Perform a single draw operation using a graphics pipeline, using an index buffer.
vertex_buffer
is a set of vertex and/or instance buffers used to provide input.
index_buffer
is a buffer containing indices into the vertex buffer that should be
processed in order.
All data in vertex_buffer
and index_buffer
is used for the draw operation. To use
only some data in the buffer, wrap it in a vulkano::buffer::BufferSlice
.
pub fn draw_indexed_indirect<V, Gp, S, Pc, Ib, Inb, I, Do, Doi>(
&mut self,
pipeline: Gp,
dynamic: &DynamicState,
vertex_buffer: V,
index_buffer: Ib,
indirect_buffer: Inb,
sets: S,
constants: Pc,
dynamic_offsets: Do
) -> Result<&mut Self, DrawIndexedIndirectError> where
Gp: GraphicsPipelineAbstract + VertexSource<V> + Send + Sync + 'static + Clone,
S: DescriptorSetsCollection,
Ib: BufferAccess + TypedBufferAccess<Content = [I]> + Send + Sync + 'static,
Inb: BufferAccess + TypedBufferAccess<Content = [DrawIndexedIndirectCommand]> + Send + Sync + 'static,
I: Index + 'static,
Do: IntoIterator<Item = u32, IntoIter = Doi>,
Doi: Iterator<Item = u32> + Send + Sync + 'static,
pub fn draw_indexed_indirect<V, Gp, S, Pc, Ib, Inb, I, Do, Doi>(
&mut self,
pipeline: Gp,
dynamic: &DynamicState,
vertex_buffer: V,
index_buffer: Ib,
indirect_buffer: Inb,
sets: S,
constants: Pc,
dynamic_offsets: Do
) -> Result<&mut Self, DrawIndexedIndirectError> where
Gp: GraphicsPipelineAbstract + VertexSource<V> + Send + Sync + 'static + Clone,
S: DescriptorSetsCollection,
Ib: BufferAccess + TypedBufferAccess<Content = [I]> + Send + Sync + 'static,
Inb: BufferAccess + TypedBufferAccess<Content = [DrawIndexedIndirectCommand]> + Send + Sync + 'static,
I: Index + 'static,
Do: IntoIterator<Item = u32, IntoIter = Doi>,
Doi: Iterator<Item = u32> + Send + Sync + 'static,
Perform multiple draw operations using a graphics pipeline, using an index buffer.
One draw is performed for each DrawIndirectCommand
struct in indirect_buffer
.
The maximum number of draw commands in the buffer is limited by the
max_draw_indirect_count
limit.
This limit is 1 unless the
multi_draw_indirect
feature has been
enabled.
vertex_buffer
is a set of vertex and/or instance buffers used to provide input.
index_buffer
is a buffer containing indices into the vertex buffer that should be
processed in order.
All data in vertex_buffer
and index_buffer
is used for every draw operation. To use
only some data in the buffer, wrap it in a vulkano::buffer::BufferSlice
.
pub fn fill_buffer<B>(
&mut self,
buffer: B,
data: u32
) -> Result<&mut Self, FillBufferError> where
B: BufferAccess + Send + Sync + 'static,
pub fn fill_buffer<B>(
&mut self,
buffer: B,
data: u32
) -> Result<&mut Self, FillBufferError> where
B: BufferAccess + Send + Sync + 'static,
Adds a command that writes the content of a buffer.
This function is similar to the memset
function in C. The data
parameter is a number
that will be repeatedly written through the entire buffer.
Note: This function is technically safe because buffers can only contain integers or floating point numbers, which are always valid whatever their memory representation is. But unless your buffer actually contains only 32-bits integers, you are encouraged to use this function only for zeroing the content of a buffer by passing
0
for the data.
pub fn update_buffer<B, D, Dd>(
&mut self,
buffer: B,
data: Dd
) -> Result<&mut Self, UpdateBufferError> where
B: TypedBufferAccess<Content = D> + Send + Sync + 'static,
D: ?Sized,
Dd: SafeDeref<Target = D> + Send + Sync + 'static,
pub fn update_buffer<B, D, Dd>(
&mut self,
buffer: B,
data: Dd
) -> Result<&mut Self, UpdateBufferError> where
B: TypedBufferAccess<Content = D> + Send + Sync + 'static,
D: ?Sized,
Dd: SafeDeref<Target = D> + Send + Sync + 'static,
Adds a command that writes data to a buffer.
If data
is larger than the buffer, only the part of data
that fits is written. If the
buffer is larger than data
, only the start of the buffer is written.
pub unsafe fn begin_query(
&mut self,
query_pool: Arc<QueryPool>,
query: u32,
flags: QueryControlFlags
) -> Result<&mut Self, BeginQueryError>
pub unsafe fn begin_query(
&mut self,
query_pool: Arc<QueryPool>,
query: u32,
flags: QueryControlFlags
) -> Result<&mut Self, BeginQueryError>
Adds a command that begins a query.
The query will be active until end_query
is called for the same query.
Safety
The query must be unavailable, ensured by calling reset_query_pool
.
Adds a command that ends an active query.
pub unsafe fn write_timestamp(
&mut self,
query_pool: Arc<QueryPool>,
query: u32,
stage: PipelineStage
) -> Result<&mut Self, WriteTimestampError>
pub unsafe fn write_timestamp(
&mut self,
query_pool: Arc<QueryPool>,
query: u32,
stage: PipelineStage
) -> Result<&mut Self, WriteTimestampError>
Adds a command that writes a timestamp to a timestamp query.
Safety
The query must be unavailable, ensured by calling reset_query_pool
.
pub fn copy_query_pool_results<D, T>(
&mut self,
query_pool: Arc<QueryPool>,
queries: Range<u32>,
destination: D,
flags: QueryResultFlags
) -> Result<&mut Self, CopyQueryPoolResultsError> where
D: BufferAccess + TypedBufferAccess<Content = [T]> + Send + Sync + 'static,
T: QueryResultElement,
pub fn copy_query_pool_results<D, T>(
&mut self,
query_pool: Arc<QueryPool>,
queries: Range<u32>,
destination: D,
flags: QueryResultFlags
) -> Result<&mut Self, CopyQueryPoolResultsError> where
D: BufferAccess + TypedBufferAccess<Content = [T]> + Send + Sync + 'static,
T: QueryResultElement,
Adds a command that copies the results of a range of queries to a buffer on the GPU.
query_pool.ty().result_size()
elements
will be written for each query in the range, plus 1 extra element per query if
QueryResultFlags::with_availability
is enabled.
The provided buffer must be large enough to hold the data.
See also get_results
.
pub unsafe fn reset_query_pool(
&mut self,
query_pool: Arc<QueryPool>,
queries: Range<u32>
) -> Result<&mut Self, ResetQueryPoolError>
pub unsafe fn reset_query_pool(
&mut self,
query_pool: Arc<QueryPool>,
queries: Range<u32>
) -> Result<&mut Self, ResetQueryPoolError>
Adds a command to reset a range of queries on a query pool.
The affected queries will be marked as “unavailable” after this command runs, and will no longer return any results. They will be ready to have new results recorded for them.
Safety
The queries in the specified range must not be active in another command buffer.
impl<P> AutoCommandBufferBuilder<PrimaryAutoCommandBuffer<P::Alloc>, P> where
P: CommandPoolBuilderAlloc,
impl<P> AutoCommandBufferBuilder<PrimaryAutoCommandBuffer<P::Alloc>, P> where
P: CommandPoolBuilderAlloc,
Commands that can only be executed on primary command buffers
pub fn begin_render_pass<F, I>(
&mut self,
framebuffer: F,
contents: SubpassContents,
clear_values: I
) -> Result<&mut Self, BeginRenderPassError> where
F: FramebufferAbstract + Clone + Send + Sync + 'static,
I: IntoIterator<Item = ClearValue>,
pub fn begin_render_pass<F, I>(
&mut self,
framebuffer: F,
contents: SubpassContents,
clear_values: I
) -> Result<&mut Self, BeginRenderPassError> where
F: FramebufferAbstract + Clone + Send + Sync + 'static,
I: IntoIterator<Item = ClearValue>,
Adds a command that enters a render pass.
If contents
is SubpassContents::SecondaryCommandBuffers
, then you will only be able to
add secondary command buffers while you’re inside the first subpass of the render pass.
If it is SubpassContents::Inline
, you will only be able to add inline draw commands and
not secondary command buffers.
C must contain exactly one clear value for each attachment in the framebuffer.
You must call this before you can add draw commands.
Adds a command that ends the current render pass.
This must be called after you went through all the subpasses and before you can build the command buffer or add further commands.
pub fn execute_commands<C>(
&mut self,
command_buffer: C
) -> Result<&mut Self, ExecuteCommandsError> where
C: SecondaryCommandBuffer + Send + Sync + 'static,
pub fn execute_commands<C>(
&mut self,
command_buffer: C
) -> Result<&mut Self, ExecuteCommandsError> where
C: SecondaryCommandBuffer + Send + Sync + 'static,
Adds a command that executes a secondary command buffer.
If the flags
that command_buffer
was created with are more restrictive than those of
self
, then self
will be restricted to match. E.g. executing a secondary command buffer
with Flags::OneTimeSubmit
will set self
’s flags to Flags::OneTimeSubmit
also.
pub fn execute_commands_from_vec<C>(
&mut self,
command_buffers: Vec<C>
) -> Result<&mut Self, ExecuteCommandsError> where
C: SecondaryCommandBuffer + Send + Sync + 'static,
pub fn execute_commands_from_vec<C>(
&mut self,
command_buffers: Vec<C>
) -> Result<&mut Self, ExecuteCommandsError> where
C: SecondaryCommandBuffer + Send + Sync + 'static,
Adds a command that multiple secondary command buffers in a vector.
This requires that the secondary command buffers do not have resource conflicts; an error
will be returned if there are any. Use execute_commands
if you want to ensure that
resource conflicts are automatically resolved.
pub fn next_subpass(
&mut self,
contents: SubpassContents
) -> Result<&mut Self, AutoCommandBufferBuilderContextError>
pub fn next_subpass(
&mut self,
contents: SubpassContents
) -> Result<&mut Self, AutoCommandBufferBuilderContextError>
Adds a command that jumps to the next subpass of the current render pass.
Trait Implementations
Auto Trait Implementations
impl<L, P = StandardCommandPoolBuilder> !RefUnwindSafe for AutoCommandBufferBuilder<L, P>
impl<L, P = StandardCommandPoolBuilder> !Send for AutoCommandBufferBuilder<L, P>
impl<L, P = StandardCommandPoolBuilder> !Sync for AutoCommandBufferBuilder<L, P>
impl<L, P> Unpin for AutoCommandBufferBuilder<L, P> where
L: Unpin,
P: Unpin,
impl<L, P = StandardCommandPoolBuilder> !UnwindSafe for AutoCommandBufferBuilder<L, P>
Blanket Implementations
Mutably borrows from an owned value. Read more
Builds a pointer to this type from a raw pointer.
Returns true if the size is suitable to store a type like this.
Returns the size of an individual element.