Enum gfx_backend_gl::Backend

pub enum Backend {}

Trait Implementations

impl Copy for Backend

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

impl Debug for Backend

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

Formats the value using the given formatter.

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

unsafe fn open(
    &self,
    families: &[(&QueueFamily, &[QueuePriority])],
    requested_features: 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: Format,
    _dimensions: u8,
    _tiling: Tiling,
    _usage: Usage,
    _view_caps: 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 Device<Backend> for Device

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

Allocates a memory segment of a specified type.

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

Create a new command pool for a given queue family.

unsafe fn destroy_command_pool(&self, pool: RawCommandPool)

Destroy a command pool.

unsafe fn create_render_pass<'a, IA, IS, ID>(
    &self,
    attachments: IA,
    subpasses: IS,
    _dependencies: ID
) -> Result<RenderPass, 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,
    layouts: IS,
    _: IR
) -> Result<PipelineLayout, OutOfMemory> where
    IS: IntoIterator,
    IS::Item: Borrow<Vec<DescriptorSetLayoutBinding>>,
    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_graphics_pipeline<'a>(
    &self,
    desc: &GraphicsPipelineDesc<'a, B>,
    _cache: Option<&()>
) -> Result<GraphicsPipeline, CreationError>

Create a graphics pipeline.

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

Create a compute pipeline.

unsafe fn create_framebuffer<I>(
    &self,
    pass: &RenderPass,
    attachments: I,
    _extent: Extent
) -> Result<GLuint, OutOfMemory> where
    I: IntoIterator,
    I::Item: Borrow<ImageView>, 

Create a new framebuffer object

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

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

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

Create a new sampler object

unsafe fn create_buffer(
    &self,
    size: u64,
    usage: 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,
    offset: u64,
    buffer: &mut Buffer
) -> Result<(), BindError>

Bind memory to a buffer.

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

Map a memory object into application address space

unsafe fn unmap_memory(&self, memory: &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, R>(
    &self,
    _: I
) -> Result<(), OutOfMemory> where
    I: IntoIterator,
    I::Item: Borrow<(&'a Memory, R)>,
    R: RangeArg<u64>, 

Flush mapped memory ranges

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

Invalidate ranges of non-coherent memory from the host caches

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

Create a new buffer view object

unsafe fn create_image(
    &self,
    kind: Kind,
    num_levels: Level,
    format: Format,
    _tiling: Tiling,
    usage: Usage,
    _view_caps: ViewCapabilities
) -> Result<Image, CreationError>

Create a new image object

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

Get memory requirements for the Image

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

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

Bind device memory to an image object

unsafe fn create_image_view(
    &self,
    image: &Image,
    _kind: ViewKind,
    _format: Format,
    swizzle: Swizzle,
    range: SubresourceRange
) -> Result<ImageView, 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,
    layout: I,
    _: J
) -> Result<Vec<DescriptorSetLayoutBinding>, OutOfMemory> where
    I: IntoIterator,
    I::Item: Borrow<DescriptorSetLayoutBinding>,
    J: IntoIterator,
    J::Item: Borrow<FatSampler>, 

Create a descriptor set layout.

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

Specifying the parameters of a descriptor set write operation

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

Structure specifying a copy descriptor set operation

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

Create a new semaphore object

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

Create a new fence object

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

unsafe fn wait_for_fence(
    &self,
    fence: &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 get_fence_status(&self, _: &Fence) -> Result<bool, DeviceLost>

true for signaled, false for not ready

unsafe fn free_memory(&self, _memory: Memory)

Free device memory

unsafe fn create_query_pool(
    &self,
    _ty: Type,
    _count: Id
) -> 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,
    _pool: &(),
    _queries: Range<Id>,
    _data: &mut [u8],
    _stride: Offset,
    _flags: 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 destroy_shader_module(&self, _: ShaderModule)

Destroy a shader module module

unsafe fn destroy_render_pass(&self, _: RenderPass)

Destroy a RenderPass.

unsafe fn destroy_pipeline_layout(&self, _: PipelineLayout)

Destroy a pipeline layout object

unsafe fn destroy_graphics_pipeline(&self, pipeline: GraphicsPipeline)

Destroy a graphics pipeline.

unsafe fn destroy_compute_pipeline(&self, pipeline: ComputePipeline)

Destroy a compute pipeline.

unsafe fn destroy_framebuffer(&self, frame_buffer: GLuint)

Destroy a framebuffer.

unsafe fn destroy_buffer(&self, buffer: Buffer)

Destroy a buffer.

unsafe fn destroy_buffer_view(&self, _: BufferView)

Destroy a buffer view object

unsafe fn destroy_image(&self, image: Image)

Destroy an image.

unsafe fn destroy_image_view(&self, _image_view: ImageView)

Destroy an image view object

unsafe fn destroy_sampler(&self, sampler: FatSampler)

Destroy a sampler object

unsafe fn destroy_descriptor_pool(&self, _: DescriptorPool)

Destroy a descriptor pool object

unsafe fn destroy_descriptor_set_layout(
    &self,
    _: Vec<DescriptorSetLayoutBinding>
)

Destroy a descriptor set layout object

unsafe fn destroy_fence(&self, fence: Fence)

Destroy a fence object

unsafe fn destroy_semaphore(&self, _: Semaphore)

Destroy a semaphore object

unsafe fn create_swapchain(
    &self,
    surface: &mut Surface,
    config: SwapchainConfig,
    _old_swapchain: Option<Swapchain>
) -> Result<(Swapchain, Vec<Image>), 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: 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_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_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 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,
    _timeout_ns: u64,
    _semaphore: Option<&Semaphore>,
    _fence: Option<&Fence>
) -> 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 Backend for Backend

type PhysicalDevice = PhysicalDevice

type Device = Device

type Surface = Surface

type Swapchain = Swapchain

type QueueFamily = QueueFamily

type CommandQueue = CommandQueue

type CommandBuffer = RawCommandBuffer

type Memory = Memory

type CommandPool = RawCommandPool

type ShaderModule = ShaderModule

type RenderPass = RenderPass

type Framebuffer = GLuint

type Buffer = Buffer

type BufferView = BufferView

type Image = Image

type ImageView = ImageView

type Sampler = FatSampler

type ComputePipeline = ComputePipeline

type GraphicsPipeline = GraphicsPipeline

type PipelineLayout = PipelineLayout

type PipelineCache = ()

type DescriptorSetLayout = Vec<DescriptorSetLayoutBinding>

type DescriptorPool = DescriptorPool

type DescriptorSet = DescriptorSet

type Fence = Fence

type Semaphore = Semaphore

type QueryPool = ()