Enum gfx_backend_empty::Backend

pub enum Backend {}

Dummy backend.

Trait Implementations

impl Backend for Backend

type Instance = Instance

The corresponding instance type for this backend.

type PhysicalDevice = PhysicalDevice

The corresponding physical device type for this backend.

type Device = Device

The corresponding logical device type for this backend.

type Surface = Surface

The corresponding surface type for this backend.

type QueueFamily = QueueFamily

The corresponding queue family type for this backend.

type CommandQueue = CommandQueue

The corresponding command queue type for this backend.

type CommandBuffer = CommandBuffer

The corresponding command buffer type for this backend.

type Memory = Memory

The corresponding memory type for this backend.

type CommandPool = CommandPool

The corresponding command pool type for this backend.

type ShaderModule = ()

The corresponding shader module type for this backend.

type RenderPass = ()

The corresponding render pass type for this backend.

type Framebuffer = ()

The corresponding framebuffer type for this backend.

type Buffer = Buffer

The corresponding buffer type for this backend.

type BufferView = ()

The corresponding buffer view type for this backend.

type Image = Image

The corresponding image type for this backend.

type ImageView = ()

The corresponding image view type for this backend.

type Sampler = ()

The corresponding sampler type for this backend.

type ComputePipeline = ()

The corresponding compute pipeline type for this backend.

type GraphicsPipeline = ()

The corresponding graphics pipeline type for this backend.

type PipelineCache = ()

The corresponding pipeline cache type for this backend.

type PipelineLayout = ()

The corresponding pipeline layout type for this backend.

type DescriptorSetLayout = DescriptorSetLayout

The corresponding descriptor set layout type for this backend.

type DescriptorPool = DescriptorPool

The corresponding descriptor pool type for this backend.

type DescriptorSet = DescriptorSet

The corresponding descriptor set type for this backend.

type Fence = ()

The corresponding fence type for this backend.

type Semaphore = ()

The corresponding semaphore type for this backend.

type Event = ()

The corresponding event type for this backend.

type QueryPool = ()

The corresponding query pool type for this backend.

impl Clone for Backend

fn clone(&self) -> Backend

Returns a copy of the value.

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

Performs copy-assignment from source.

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 CommandPool<Backend> for CommandPool

unsafe fn allocate_one(&mut self, level: Level) -> CommandBuffer

Allocate a single command buffer from the pool.

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

Reset the command pool and the corresponding command buffers.

unsafe fn free<I>(&mut self, _: I)

Free command buffers allocated from this pool.

pub unsafe fn allocate<E>(&mut self, num: usize, level: Level, list: &mut E) where
    E: Extend<<B as Backend>::CommandBuffer>, 

Allocate new command buffers from the pool.

impl CommandQueue<Backend> for CommandQueue

unsafe fn submit<'a, Ic, Iw, Is>(
    &mut self,
    _: Ic,
    _: Iw,
    _: Is,
    _: Option<&mut ()>
) where
    Ic: Iterator<Item = &'a CommandBuffer>, 

Submit command buffers to queue for execution.

unsafe fn present(
    &mut self,
    _surface: &mut Surface,
    _image: SwapchainImage,
    _wait_semaphore: Option<&mut ()>
) -> Result<Option<Suboptimal>, PresentError>

Present a swapchain image directly to a surface, after waiting on wait_semaphore.

fn wait_idle(&mut self) -> Result<(), OutOfMemory>

Wait for the queue to be idle.

impl Copy for Backend

impl Debug for Backend

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

Formats the value using the given formatter.

impl Device<Backend> for Device

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

Create a new command pool for a given queue family.

unsafe fn destroy_command_pool(&self, _: CommandPool)

Destroy a command pool.

unsafe fn allocate_memory(
    &self,
    memory_type: MemoryTypeId,
    size: u64
) -> Result<Memory, 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
    Is: Iterator<Item = SubpassDesc<'a>>, 

Create a render pass with the given attachments and subpasses.

unsafe fn create_pipeline_layout<'a, Is, Ic>(
    &self,
    _: Is,
    _: Ic
) -> Result<(), OutOfMemory> where
    Is: Iterator<Item = &'a DescriptorSetLayout>, 

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 create_graphics_pipeline<'a>(
    &self,
    _: &GraphicsPipelineDesc<'a, Backend>,
    _: Option<&()>
) -> Result<(), CreationError>

Create a graphics pipeline.

unsafe fn create_compute_pipeline<'a>(
    &self,
    _: &ComputePipelineDesc<'a, Backend>,
    _: Option<&()>
) -> Result<(), CreationError>

Create a compute pipeline.

unsafe fn merge_pipeline_caches<'a, I>(
    &self,
    _: &mut (),
    _: I
) -> Result<(), OutOfMemory> where
    I: Iterator<Item = &'a ()>, 

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

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

Create a new framebuffer object.

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

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

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

Create a new sampler object

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

Create a new buffer (unbound).

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

Get memory requirements for the buffer

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

Bind memory to a buffer.

unsafe fn create_buffer_view(
    &self,
    _: &Buffer,
    _: Option<Format>,
    _: SubRange
) -> Result<(), ViewCreationError>

Create a new buffer view object

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

Create a new image object

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

Get memory requirements for the Image

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

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

Bind device memory to an image object

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

Create an image view from an existing image

unsafe fn create_descriptor_pool<I>(
    &self,
    _: usize,
    _: I,
    _: DescriptorPoolCreateFlags
) -> Result<DescriptorPool, OutOfMemory>

Create a descriptor pool.

unsafe fn create_descriptor_set_layout<'a, I, J>(
    &self,
    _bindings: I,
    _samplers: J
) -> Result<DescriptorSetLayout, OutOfMemory> where
    J: Iterator<Item = &'a ()>, 

Create a descriptor set layout.

unsafe fn write_descriptor_set<'a, I>(
    &self,
    _: DescriptorSetWrite<'a, Backend, I>
) where
    I: Iterator<Item = Descriptor<'a, Backend>>, 

Specifying the parameters of a descriptor set write operation.

unsafe fn copy_descriptor_set<'a>(&self, _: 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

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

Create an event object.

unsafe fn get_event_status(&self, _: &()) -> Result<bool, WaitError>

Query the status of an event.

unsafe fn set_event(&self, _: &mut ()) -> Result<(), OutOfMemory>

Sets an event.

unsafe fn reset_event(&self, _: &mut ()) -> Result<(), OutOfMemory>

Resets an event.

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],
    _: Stride,
    _: ResultFlags
) -> Result<bool, WaitError>

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(
    &self,
    memory: &mut Memory,
    segment: Segment
) -> Result<*mut u8, MapError>

Map a memory object into application address space

unsafe fn unmap_memory(&self, _memory: &mut Memory)

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

unsafe fn flush_mapped_memory_ranges<'a, I>(
    &self,
    _: I
) -> Result<(), OutOfMemory> where
    I: Iterator<Item = (&'a Memory, Segment)>, 

Flush mapped memory ranges

unsafe fn invalidate_mapped_memory_ranges<'a, I>(
    &self,
    _: I
) -> Result<(), OutOfMemory> where
    I: Iterator<Item = (&'a Memory, Segment)>, 

Invalidate ranges of non-coherent memory from the host caches

unsafe fn free_memory(&self, _memory: Memory)

Free device memory

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

Destroy a shader module module

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

Destroys a render pass created by this device.

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, _: Buffer)

Destroy a buffer.

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

Destroy a buffer view object

unsafe fn destroy_image(&self, _: Image)

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, _: DescriptorSetLayout)

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 destroy_event(&self, _: ())

Destroy an event object.

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

Wait for all queues associated with this device to idle.

unsafe fn set_image_name(&self, _: &mut Image, _: &str)

Associate a name with an image, for easier debugging in external tools or with validation layers that can print a friendly name when referring to objects in error messages

unsafe fn set_buffer_name(&self, _: &mut Buffer, _: &str)

Associate a name with a buffer, for easier debugging in external tools or with validation layers that can print a friendly name when referring to objects in error messages

unsafe fn set_command_buffer_name(&self, _: &mut CommandBuffer, _: &str)

Associate a name with a command buffer, for easier debugging in external tools or with validation layers that can print a friendly name when referring to objects in error messages

unsafe fn set_semaphore_name(&self, _: &mut (), _: &str)

Associate a name with a semaphore, for easier debugging in external tools or with validation layers that can print a friendly name when referring to objects in error messages

unsafe fn set_fence_name(&self, _: &mut (), _: &str)

Associate a name with a fence, for easier debugging in external tools or with validation layers that can print a friendly name when referring to objects in error messages

unsafe fn set_framebuffer_name(&self, _: &mut (), _: &str)

Associate a name with a framebuffer, for easier debugging in external tools or with validation layers that can print a friendly name when referring to objects in error messages

unsafe fn set_render_pass_name(&self, _: &mut (), _: &str)

Associate a name with a render pass, for easier debugging in external tools or with validation layers that can print a friendly name when referring to objects in error messages

unsafe fn set_descriptor_set_name(&self, set: &mut DescriptorSet, name: &str)

Associate a name with a descriptor set, for easier debugging in external tools or with validation layers that can print a friendly name when referring to objects in error messages

unsafe fn set_descriptor_set_layout_name(
    &self,
    layout: &mut DescriptorSetLayout,
    name: &str
)

Associate a name with a descriptor set layout, for easier debugging in external tools or with validation layers that can print a friendly name when referring to objects in error messages

unsafe fn set_pipeline_layout_name(
    &self,
    _pipeline_layout: &mut (),
    _name: &str
)

Associate a name with a pipeline layout, for easier debugging in external tools or with validation layers that can print a friendly name when referring to objects in error messages

unsafe fn reset_fence(&self, _: &mut ()) -> Result<(), OutOfMemory>

Resets a given fence to its original, unsignaled state.

unsafe fn wait_for_fence(&self, _: &(), _: u64) -> Result<bool, WaitError>

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

pub unsafe fn create_shader_module_from_naga(
    &self,
    module: Module
) -> Result<<B as Backend>::ShaderModule, (ShaderError, Module)>

Create a new shader module from the naga module.

pub unsafe fn wait_for_fences<'a, I>(
    &self,
    fences: I,
    wait: WaitFor,
    timeout_ns: u64
) -> Result<bool, WaitError> where
    I: Iterator<Item = &'a <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 Eq for Backend

impl Hash for Backend

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

Feeds this value into the given Hasher.

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

Feeds a slice of this type into the given Hasher.

impl Instance<Backend> for Instance

fn create(name: &str, version: u32) -> Result<Self, UnsupportedBackend>

Create a new instance.

fn enumerate_adapters(&self) -> Vec<Adapter<Backend>>

Return all available graphics adapters.

unsafe fn create_surface(
    &self,
    raw_window_handle: &impl HasRawWindowHandle
) -> Result<Surface, InitError>

Create a new surface.

unsafe fn destroy_surface(&self, _surface: Surface)

Destroy a surface, freeing the resources associated with it and releasing it from this graphics API.

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]pub fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PhysicalDevice<Backend> for PhysicalDevice

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

Create a new logical device with the requested features. If requested_features is 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 PhysicalDevice. This usually depends on the graphics API being used, as well as the actual platform underneath.

fn capabilities(&self) -> Capabilities

Returns the capabilities of this PhysicalDevice. Similarly to Features, they

fn limits(&self) -> Limits

Returns the resource limits of this PhysicalDevice.

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

Check cache compatibility with the PhysicalDevice.

impl PresentationSurface<Backend> for Surface

type SwapchainImage = SwapchainImage

An opaque type wrapping the swapchain image.

unsafe fn configure_swapchain(
    &mut self,
    _: &Device,
    _: SwapchainConfig
) -> Result<(), SwapchainError>

Set up the swapchain associated with the surface to have the given format.

unsafe fn unconfigure_swapchain(&mut self, _: &Device)

Remove the associated swapchain from this surface.

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

Acquire a new swapchain image for rendering.

impl StructuralEq for Backend

impl StructuralPartialEq for Backend

impl Surface<Backend> for Surface

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

Check if the queue family supports presentation to this surface.

fn capabilities(&self, _: &PhysicalDevice) -> SurfaceCapabilities

Query surface capabilities for this physical device.

fn supported_formats(&self, _: &PhysicalDevice) -> Option<Vec<Format>>

Query surface formats for this physical device.