Enum gfx_backend_empty::Backend

pub enum Backend {}

Dummy backend.

Trait Implementations

impl PartialEq<Backend> for Backend

fn eq(&self, other: &Backend) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl Copy for Backend

impl Eq for Backend

impl Clone for Backend

fn clone(&self) -> Backend

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Hash for Backend

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given [Hasher].

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given [Hasher].

impl Debug for Backend

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

Formats the value using the given formatter.

impl PhysicalDevice<Backend> for PhysicalDevice

unsafe fn open(
    &self,
    _: &[(&QueueFamily, &[QueuePriority])],
    _: Features
) -> Result<Gpu<Backend>, DeviceCreationError>

Create a new logical device with the requested features. If requested_features is empty (e.g. through Features::empty()) then only the core features are supported.

fn format_properties(&self, _: Option<Format>) -> Properties

Fetch details for a particular format.

fn image_format_properties(
    &self,
    _: Format,
    _dim: u8,
    _: Tiling,
    _: Usage,
    _: ViewCapabilities
) -> Option<FormatProperties>

Fetch details for a particular image format.

fn memory_properties(&self) -> MemoryProperties

Fetch details for the memory regions provided by the device.

fn features(&self) -> Features

Returns the features of this Device. This usually depends on the graphics API being used.

fn limits(&self) -> Limits

Returns the resource limits of this Device.

fn is_valid_cache(&self, _cache: &[u8]) -> bool

Check cache compatibility with the Device.

impl Backend for Backend

type PhysicalDevice = PhysicalDevice

type Device = Device

type Surface = Surface

type Swapchain = Swapchain

type QueueFamily = QueueFamily

type CommandQueue = RawCommandQueue

type CommandBuffer = RawCommandBuffer

type Memory = ()

type CommandPool = RawCommandPool

type ShaderModule = ()

type RenderPass = ()

type Framebuffer = ()

type Buffer = ()

type BufferView = ()

type Image = ()

type ImageView = ()

type Sampler = ()

type ComputePipeline = ()

type GraphicsPipeline = ()

type PipelineCache = ()

type PipelineLayout = ()

type DescriptorSetLayout = ()

type DescriptorPool = DescriptorPool

type DescriptorSet = ()

type Fence = ()

type Semaphore = ()

type QueryPool = ()

impl Device<Backend> for Device

unsafe fn create_command_pool(
    &self,
    _: QueueFamilyId,
    _: CommandPoolCreateFlags
) -> Result<RawCommandPool, OutOfMemory>

Create a new command pool for a given queue family.

unsafe fn destroy_command_pool(&self, _: RawCommandPool)

Destroy a command pool.

unsafe fn allocate_memory(
    &self,
    _: MemoryTypeId,
    _: u64
) -> Result<(), AllocationError>

Allocates a memory segment of a specified type.

unsafe fn create_render_pass<'a, IA, IS, ID>(
    &self,
    _: IA,
    _: IS,
    _: ID
) -> Result<(), OutOfMemory> where
    IA: IntoIterator,
    IA::Item: Borrow<Attachment>,
    IS: IntoIterator,
    IS::Item: Borrow<SubpassDesc<'a>>,
    ID: IntoIterator,
    ID::Item: Borrow<SubpassDependency>, 

Create a render pass with the given attachments and subpasses.

unsafe fn create_pipeline_layout<IS, IR>(
    &self,
    _: IS,
    _: IR
) -> Result<(), OutOfMemory> where
    IS: IntoIterator,
    IS::Item: Borrow<()>,
    IR: IntoIterator,
    IR::Item: Borrow<(ShaderStageFlags, Range<u32>)>, 

Create a new pipeline layout object.

unsafe fn create_pipeline_cache(
    &self,
    _data: Option<&[u8]>
) -> Result<(), OutOfMemory>

Create a pipeline cache object.

unsafe fn get_pipeline_cache_data(
    &self,
    _cache: &()
) -> Result<Vec<u8>, OutOfMemory>

Retrieve data from pipeline cache object.

unsafe fn destroy_pipeline_cache(&self, _: ())

Destroy a pipeline cache object.

unsafe fn merge_pipeline_caches<I>(
    &self,
    _: &(),
    _: I
) -> Result<(), OutOfMemory> where
    I: IntoIterator,
    I::Item: Borrow<()>, 

Merge a number of source pipeline caches into the target one.

unsafe fn create_framebuffer<I>(
    &self,
    _: &(),
    _: I,
    _: Extent
) -> Result<(), OutOfMemory> where
    I: IntoIterator,
    I::Item: Borrow<()>, 

Create a new framebuffer object

unsafe fn create_shader_module(&self, _: &[u8]) -> Result<(), ShaderError>

Create a new shader module object through the SPIR-V binary data.

unsafe fn create_sampler(&self, _: SamplerInfo) -> Result<(), AllocationError>

Create a new sampler object

unsafe fn create_buffer(&self, _: u64, _: Usage) -> Result<(), CreationError>

Create a new buffer (unbound).

unsafe fn get_buffer_requirements(&self, _: &()) -> Requirements

Get memory requirements for the buffer

unsafe fn bind_buffer_memory(
    &self,
    _: &(),
    _: u64,
    _: &mut ()
) -> Result<(), BindError>

Bind memory to a buffer.

unsafe fn create_buffer_view<R: RangeArg<u64>>(
    &self,
    _: &(),
    _: Option<Format>,
    _: R
) -> Result<(), ViewCreationError>

Create a new buffer view object

unsafe fn create_image(
    &self,
    _: Kind,
    _: Level,
    _: Format,
    _: Tiling,
    _: Usage,
    _: ViewCapabilities
) -> Result<(), CreationError>

Create a new image object

unsafe fn get_image_requirements(&self, _: &()) -> Requirements

Get memory requirements for the Image

unsafe fn get_image_subresource_footprint(
    &self,
    _: &(),
    _: Subresource
) -> SubresourceFootprint

unsafe fn bind_image_memory(
    &self,
    _: &(),
    _: u64,
    _: &mut ()
) -> Result<(), BindError>

Bind device memory to an image object

unsafe fn create_image_view(
    &self,
    _: &(),
    _: ViewKind,
    _: Format,
    _: Swizzle,
    _: SubresourceRange
) -> Result<(), ViewError>

Create an image view from an existing image

unsafe fn create_descriptor_pool<I>(
    &self,
    _: usize,
    _: I,
    _: DescriptorPoolCreateFlags
) -> Result<DescriptorPool, OutOfMemory> where
    I: IntoIterator,
    I::Item: Borrow<DescriptorRangeDesc>, 

Create a descriptor pool.

unsafe fn create_descriptor_set_layout<I, J>(
    &self,
    _: I,
    _: J
) -> Result<(), OutOfMemory> where
    I: IntoIterator,
    I::Item: Borrow<DescriptorSetLayoutBinding>,
    J: IntoIterator,
    J::Item: Borrow<()>, 

Create a descriptor set layout.

unsafe fn write_descriptor_sets<'a, I, J>(&self, _: I) where
    I: IntoIterator<Item = DescriptorSetWrite<'a, Backend, J>>,
    J: IntoIterator,
    J::Item: Borrow<Descriptor<'a, Backend>>, 

Specifying the parameters of a descriptor set write operation

unsafe fn copy_descriptor_sets<'a, I>(&self, _: I) where
    I: IntoIterator,
    I::Item: Borrow<DescriptorSetCopy<'a, Backend>>, 

Structure specifying a copy descriptor set operation

fn create_semaphore(&self) -> Result<(), OutOfMemory>

Create a new semaphore object

fn create_fence(&self, _: bool) -> Result<(), OutOfMemory>

Create a new fence object

unsafe fn get_fence_status(&self, _: &()) -> Result<bool, DeviceLost>

true for signaled, false for not ready

unsafe fn create_query_pool(&self, _: Type, _: u32) -> Result<(), CreationError>

Create a new query pool object

unsafe fn destroy_query_pool(&self, _: ())

Destroy a query pool object

unsafe fn get_query_pool_results(
    &self,
    _: &(),
    _: Range<Id>,
    _: &mut [u8],
    _: Offset,
    _: ResultFlags
) -> Result<bool, OomOrDeviceLost>

Get query pool results into the specified CPU memory. Returns Ok(false) if the results are not ready yet and neither of WAIT or PARTIAL flags are set.

unsafe fn map_memory<R: RangeArg<u64>>(
    &self,
    _: &(),
    _: R
) -> Result<*mut u8, Error>

Map a memory object into application address space

unsafe fn unmap_memory(&self, _: &())

Unmap a memory object once host access to it is no longer needed by the application

unsafe fn flush_mapped_memory_ranges<'a, I, R>(
    &self,
    _: I
) -> Result<(), OutOfMemory> where
    I: IntoIterator,
    I::Item: Borrow<(&'a (), R)>,
    R: RangeArg<u64>, 

Flush mapped memory ranges

unsafe fn invalidate_mapped_memory_ranges<'a, I, R>(
    &self,
    _: I
) -> Result<(), OutOfMemory> where
    I: IntoIterator,
    I::Item: Borrow<(&'a (), R)>,
    R: RangeArg<u64>, 

Invalidate ranges of non-coherent memory from the host caches

unsafe fn free_memory(&self, _: ())

Free device memory

unsafe fn destroy_shader_module(&self, _: ())

Destroy a shader module module

unsafe fn destroy_render_pass(&self, _: ())

Destroy a RenderPass.

unsafe fn destroy_pipeline_layout(&self, _: ())

Destroy a pipeline layout object

unsafe fn destroy_graphics_pipeline(&self, _: ())

Destroy a graphics pipeline.

unsafe fn destroy_compute_pipeline(&self, _: ())

Destroy a compute pipeline.

unsafe fn destroy_framebuffer(&self, _: ())

Destroy a framebuffer.

unsafe fn destroy_buffer(&self, _: ())

Destroy a buffer.

unsafe fn destroy_buffer_view(&self, _: ())

Destroy a buffer view object

unsafe fn destroy_image(&self, _: ())

Destroy an image.

unsafe fn destroy_image_view(&self, _: ())

Destroy an image view object

unsafe fn destroy_sampler(&self, _: ())

Destroy a sampler object

unsafe fn destroy_descriptor_pool(&self, _: DescriptorPool)

Destroy a descriptor pool object

unsafe fn destroy_descriptor_set_layout(&self, _: ())

Destroy a descriptor set layout object

unsafe fn destroy_fence(&self, _: ())

Destroy a fence object

unsafe fn destroy_semaphore(&self, _: ())

Destroy a semaphore object

unsafe fn create_swapchain(
    &self,
    _: &mut Surface,
    _: SwapchainConfig,
    _: Option<Swapchain>
) -> Result<(Swapchain, Vec<()>), CreationError>

Create a new swapchain from a surface and a queue family, optionally providing the old swapchain to aid in resource reuse and rendering continuity.

unsafe fn destroy_swapchain(&self, _: Swapchain)

fn wait_idle(&self) -> Result<(), HostExecutionError>

Wait for all queues associated with this device to idle.

unsafe fn create_command_pool_typed<C>(
    &self,
    group: &QueueGroup<B, C>,
    flags: CommandPoolCreateFlags
) -> Result<CommandPool<B, C>, OutOfMemory>

Create a strongly typed command pool wrapper.

unsafe fn create_graphics_pipeline(
    &self,
    desc: &GraphicsPipelineDesc<'a, B>,
    cache: Option<&<B as Backend>::PipelineCache>
) -> Result<<B as Backend>::GraphicsPipeline, CreationError>

Create a graphics pipeline.

unsafe fn create_graphics_pipelines<'a, I>(
    &self,
    descs: I,
    cache: Option<&<B as Backend>::PipelineCache>
) -> Vec<Result<<B as Backend>::GraphicsPipeline, CreationError>> where
    I: IntoIterator,
    <I as IntoIterator>::Item: Borrow<GraphicsPipelineDesc<'a, B>>, 

Create graphics pipelines.

unsafe fn create_compute_pipeline(
    &self,
    desc: &ComputePipelineDesc<'a, B>,
    cache: Option<&<B as Backend>::PipelineCache>
) -> Result<<B as Backend>::ComputePipeline, CreationError>

Create a compute pipeline.

unsafe fn create_compute_pipelines<'a, I>(
    &self,
    descs: I,
    cache: Option<&<B as Backend>::PipelineCache>
) -> Vec<Result<<B as Backend>::ComputePipeline, CreationError>> where
    I: IntoIterator,
    <I as IntoIterator>::Item: Borrow<ComputePipelineDesc<'a, B>>, 

Create compute pipelines.

unsafe fn acquire_mapping_reader<T>(
    &self,
    memory: &'a <B as Backend>::Memory,
    range: Range<u64>
) -> Result<Reader<'a, B, T>, Error> where
    T: Copy, 

Acquire a mapping Reader.

unsafe fn release_mapping_reader<T>(&self, reader: Reader<'a, B, T>)

Release a mapping Reader.

unsafe fn acquire_mapping_writer<T>(
    &self,
    memory: &'a <B as Backend>::Memory,
    range: Range<u64>
) -> Result<Writer<'a, B, T>, Error> where
    T: Copy, 

Acquire a mapping Writer.

unsafe fn release_mapping_writer<T>(
    &self,
    writer: Writer<'a, B, T>
) -> Result<(), OutOfMemory>

Release a mapping Writer.

unsafe fn reset_fence(
    &self,
    fence: &<B as Backend>::Fence
) -> Result<(), OutOfMemory>

unsafe fn reset_fences<I>(&self, fences: I) -> Result<(), OutOfMemory> where
    I: IntoIterator,
    <I as IntoIterator>::Item: Borrow<<B as Backend>::Fence>, 

unsafe fn wait_for_fence(
    &self,
    fence: &<B as Backend>::Fence,
    timeout_ns: u64
) -> Result<bool, OomOrDeviceLost>

Blocks until the given fence is signaled. Returns true if the fence was signaled before the timeout.

unsafe fn wait_for_fences<I>(
    &self,
    fences: I,
    wait: WaitFor,
    timeout_ns: u64
) -> Result<bool, OomOrDeviceLost> where
    I: IntoIterator,
    <I as IntoIterator>::Item: Borrow<<B as Backend>::Fence>, 

Blocks until all or one of the given fences are signaled. Returns true if fences were signaled before the timeout.

impl Surface<Backend> for Surface

fn kind(&self) -> Kind

Retrieve the surface image kind.

fn compatibility(
    &self,
    _: &PhysicalDevice
) -> (SurfaceCapabilities, Option<Vec<Format>>, Vec<PresentMode>)

Query surface capabilities, formats, and present modes for this physical device.

fn supports_queue_family(&self, _: &QueueFamily) -> bool

Check if the queue family supports presentation to this surface.

impl Swapchain<Backend> for Swapchain

unsafe fn acquire_image(
    &mut self,
    _: u64,
    _: Option<&()>,
    _: Option<&()>
) -> Result<(SwapImageIndex, Option<Suboptimal>), AcquireError>

Acquire a new swapchain image for rendering. This needs to be called before presenting.

unsafe fn present<'a, C, S, Iw>(
    &'a self,
    present_queue: &mut CommandQueue<B, C>,
    image_index: u32,
    wait_semaphores: Iw
) -> Result<Option<Suboptimal>, PresentError> where
    C: Capability,
    Iw: IntoIterator<Item = &'a S>,
    S: 'a + Borrow<<B as Backend>::Semaphore>,
    Self: 'a + Borrow<<B as Backend>::Swapchain>, 

Present one acquired image.

unsafe fn present_nosemaphores<'a, C>(
    &'a self,
    present_queue: &mut CommandQueue<B, C>,
    image_index: u32
) -> Result<Option<Suboptimal>, PresentError> where
    C: Capability,
    Self: 'a + Borrow<<B as Backend>::Swapchain>, 

Present one acquired image without any semaphore synchronization.

impl DescriptorPool<Backend> for DescriptorPool

unsafe fn free_sets<I>(&mut self, _descriptor_sets: I) where
    I: IntoIterator<Item = ()>, 

Free the given descriptor sets provided as an iterator.

unsafe fn reset(&mut self)

Resets a descriptor pool, releasing all resources from all the descriptor sets allocated from it and freeing the descriptor sets. Invalidates all descriptor sets allocated from the pool; trying to use one after the pool has been reset is undefined behavior.

unsafe fn allocate_set(
    &mut self,
    layout: &<B as Backend>::DescriptorSetLayout
) -> Result<<B as Backend>::DescriptorSet, AllocationError>

Allocate a descriptor set from the pool.

unsafe fn allocate_sets<I>(
    &mut self,
    layouts: I,
    sets: &mut Vec<<B as Backend>::DescriptorSet>
) -> Result<(), AllocationError> where
    I: IntoIterator,
    <I as IntoIterator>::Item: Borrow<<B as Backend>::DescriptorSetLayout>, 

Allocate one or multiple descriptor sets from the pool.

impl RawCommandQueue<Backend> for RawCommandQueue

unsafe fn submit<'a, T, Ic, S, Iw, Is>(
    &mut self,
    _: Submission<Ic, Iw, Is>,
    _: Option<&()>
) where
    T: 'a + Borrow<RawCommandBuffer>,
    Ic: IntoIterator<Item = &'a T>,
    S: 'a + Borrow<()>,
    Iw: IntoIterator<Item = (&'a S, PipelineStage)>,
    Is: IntoIterator<Item = &'a S>, 

Submit command buffers to queue for execution. fence must be in unsignalled state, and will be signalled after all command buffers in the submission have finished execution.

unsafe fn present<'a, W, Is, S, Iw>(
    &mut self,
    _: Is,
    _: Iw
) -> Result<Option<Suboptimal>, PresentError> where
    W: 'a + Borrow<Swapchain>,
    Is: IntoIterator<Item = (&'a W, SwapImageIndex)>,
    S: 'a + Borrow<()>,
    Iw: IntoIterator<Item = &'a S>, 

Presents the result of the queue to the given swapchains, after waiting on all the semaphores given in wait_semaphores. A given swapchain must not appear in this list more than once.

fn wait_idle(&self) -> Result<(), HostExecutionError>

Wait for the queue to idle.

impl RawCommandBuffer<Backend> for RawCommandBuffer

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: IntoIterator,
    T::Item: Borrow<Barrier<'a, Backend>>, 

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

unsafe fn fill_buffer<R>(&mut self, _: &(), _: R, _: u32) where
    R: RangeArg<Offset>, 

Fill a buffer with the given u32 value.

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

Copy data from the given slice into a buffer.

unsafe fn clear_image<T>(
    &mut self,
    _: &(),
    _: Layout,
    _: ClearColorRaw,
    _: ClearDepthStencilRaw,
    _: T
) where
    T: IntoIterator,
    T::Item: Borrow<SubresourceRange>, 

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

unsafe fn clear_attachments<T, U>(&mut self, _: T, _: U) where
    T: IntoIterator,
    T::Item: Borrow<AttachmentClear>,
    U: IntoIterator,
    U::Item: Borrow<ClearRect>, 

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,
    _: &(),
    _: Layout,
    _: &(),
    _: Layout,
    _: T
) where
    T: IntoIterator,
    T::Item: Borrow<ImageResolve>, 

"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,
    _: &(),
    _: Layout,
    _: &(),
    _: Layout,
    _: Filter,
    _: T
) where
    T: IntoIterator,
    T::Item: Borrow<ImageBlit>, 

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

unsafe fn bind_index_buffer(&mut self, _: IndexBufferView<Backend>)

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

unsafe fn bind_vertex_buffers<I, T>(&mut self, _: u32, _: I) where
    I: IntoIterator<Item = (T, Offset)>,
    T: Borrow<()>, 

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) where
    T: IntoIterator,
    T::Item: Borrow<Viewport>, 

Set the viewport parameters for the rasterizer.

unsafe fn set_scissors<T>(&mut self, _: u32, _: T) where
    T: IntoIterator,
    T::Item: Borrow<Rect>, 

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<T>(
    &mut self,
    _: &(),
    _: &(),
    _: Rect,
    _: T,
    _: SubpassContents
) where
    T: IntoIterator,
    T::Item: Borrow<ClearValueRaw>, 

Begins recording commands for a render pass on the given framebuffer. render_area is the section of the framebuffer to render, clear_values is an iterator of ClearValueRaw's to use to use for clear_* commands, one for each attachment of the render pass that has a clear operation. first_subpass specifies, for the first subpass, whether the rendering commands are provided inline or whether the render pass is composed of subpasses.

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<I, J>(
    &mut self,
    _: &(),
    _: usize,
    _: I,
    _: J
) where
    I: IntoIterator,
    I::Item: Borrow<()>,
    J: IntoIterator,
    J::Item: Borrow<DescriptorSetOffset>, 

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<I, J>(
    &mut self,
    _: &(),
    _: usize,
    _: I,
    _: J
) where
    I: IntoIterator,
    I::Item: Borrow<()>,
    J: IntoIterator,
    J::Item: Borrow<DescriptorSetOffset>, 

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 x``y``z local workgroups will be created.

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

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

unsafe fn copy_buffer<T>(&mut self, _: &(), _: &(), _: T) where
    T: IntoIterator,
    T::Item: Borrow<BufferCopy>, 

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

unsafe fn copy_image<T>(&mut self, _: &(), _: Layout, _: &(), _: Layout, _: T) where
    T: IntoIterator,
    T::Item: Borrow<ImageCopy>, 

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, _: &(), _: &(), _: Layout, _: T) where
    T: IntoIterator,
    T::Item: Borrow<BufferImageCopy>, 

Copies regions from the source buffer to the destination image.

unsafe fn copy_image_to_buffer<T>(&mut self, _: &(), _: Layout, _: &(), _: T) where
    T: IntoIterator,
    T::Item: Borrow<BufferImageCopy>, 

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, _: &(), _: Offset, _: DrawCount, _: u32)

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,
    _: &(),
    _: Offset,
    _: DrawCount,
    _: u32
)

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

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>,
    _: &(),
    _: Offset,
    _: Offset,
    _: 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, I>(&mut self, _: I) where
    T: 'a + Borrow<RawCommandBuffer>,
    I: IntoIterator<Item = &'a T>, 

Execute the given secondary command buffers.

impl RawCommandPool<Backend> for RawCommandPool

unsafe fn reset(&mut self)

Reset the command pool and the corresponding command buffers.

unsafe fn free<I>(&mut self, _: I) where
    I: IntoIterator<Item = RawCommandBuffer>, 

Free command buffers which are allocated from this pool.

fn allocate_one(&mut self, level: Level) -> <B as Backend>::CommandBuffer

Allocate a single command buffers from the pool.

fn allocate_vec(
    &mut self,
    num: usize,
    level: Level
) -> Vec<<B as Backend>::CommandBuffer>

Allocate new command buffers from the pool.