Struct DeviceObject

pub struct DeviceObject<Instance> { /* private fields */ }

Opaque handle to a device object

Implementations

impl<Instance> DeviceObject<Instance>

pub const fn wrap_handle(handle: VkDevice, parent: Instance) -> Self

impl<Instance: Instance + Clone> DeviceObject<&Instance>

pub fn clone_parent(self) -> DeviceObject<Instance>

Clones parent reference

impl<Instance: Instance> DeviceObject<Instance>

pub fn new<PhysicalDevice: PhysicalDevice + InstanceChildTransferrable<ConcreteInstance = Instance>>( physical_device: PhysicalDevice, info: &DeviceCreateInfo<'_>, ) -> Result<Self>

Create a new device instance

Failures

On failure, this command returns

• VK_ERROR_OUT_OF_HOST_MEMORY
• VK_ERROR_OUT_OF_DEVICE_MEMORY
• VK_ERROR_INITIALIZATION_FAILED
• VK_ERROR_EXTENSION_NOT_PRESENT
• VK_ERROR_FEATURE_NOT_PRESENT
• VK_ERROR_TOO_MANY_OBJECTS
• VK_ERROR_DEVICE_LOST

pub const unsafe fn manage(handle: VkDevice, parent: Instance) -> Self

Constructs from raw handle

Safety

the handle must be valid and not freed

pub fn unmanage(self) -> (VkDevice, Instance)

Purges the construct (Drop will not be called for this resource)

Trait Implementations

impl<Instance: Instance> Device for DeviceObject<Instance>

fn queue<'s>( &'s self, family_index: u32, queue_index: u32, ) -> QueueObject<&'s Self>

Get a queue handle from a device

fn new_fence_raw( &self, info: &FenceCreateInfo<'_>, allocation_callbacks: Option<&VkAllocationCallbacks>, ) -> Result<VkFence>

Create a new fence object

fn new_semaphore_raw( &self, info: &SemaphoreCreateInfo<'_>, allocation_callbacks: Option<&VkAllocationCallbacks>, ) -> Result<VkSemaphore>

Create a new queue semaphore object

fn new_event_raw( &self, info: &EventCreateInfo, allocation_callbacks: Option<&VkAllocationCallbacks>, ) -> Result<VkEvent>

Create a new event object

fn allocate_memory( &self, info: &MemoryAllocateInfo<'_>, allocation_callbacks: Option<&VkAllocationCallbacks>, ) -> Result<VkDeviceMemory>

Allocate device memory

fn new_buffer_raw( &self, info: &BufferCreateInfo<'_>, allocation_callbacks: Option<&VkAllocationCallbacks>, ) -> Result<VkBuffer>

Create a new buffer object

fn new_buffer_view_raw( &self, info: &BufferViewCreateInfo<'_>, allocation_callbacks: Option<&VkAllocationCallbacks>, ) -> Result<VkBufferView>

Create a new buffer view object

fn new_sampler_raw( &self, info: &SamplerCreateInfo, allocation_callbacks: Option<&VkAllocationCallbacks>, ) -> Result<VkSampler>

Create a new sampler object

fn new_image_raw( &self, info: &ImageCreateInfo<'_>, allocation_callbacks: Option<&VkAllocationCallbacks>, ) -> Result<VkImage>

Create a new image object

fn new_image_view_raw( &self, info: &ImageViewCreateInfo<'_>, allocation_callbacks: Option<&VkAllocationCallbacks>, ) -> Result<VkImageView>

Create a new image view from an existing image

fn new_render_pass( &self, info: &RenderPassCreateInfo<'_>, allocation_callbacks: Option<&VkAllocationCallbacks>, ) -> Result<VkRenderPass>

Create a new render pass object

fn new_framebuffer_raw( &self, info: &FramebufferCreateInfo<'_, '_>, allocation_callbacks: Option<&VkAllocationCallbacks>, ) -> Result<VkFramebuffer>

Create a new framebuffer object

fn new_shader_module_raw( &self, info: &ShaderModuleCreateInfo<'_>, allocation_callbacks: Option<&VkAllocationCallbacks>, ) -> Result<VkShaderModule>

Creates a new shader module object

fn new_pipeline_cache_raw( &self, info: &PipelineCacheCreateInfo<'_>, allocation_callbacks: Option<&VkAllocationCallbacks>, ) -> Result<VkPipelineCache>

Create a new pipeline cache

fn new_pipeline_layout_raw( &self, info: &PipelineLayoutCreateInfo<'_>, allocation_callbacks: Option<&VkAllocationCallbacks>, ) -> Result<VkPipelineLayout>

Create a new pipeline layout object

unsafe fn new_graphics_pipelines_raw( &self, infos: &[GraphicsPipelineCreateInfo<'_>], cache: Option<VkPipelineCache>, allocation_callbacks: Option<&VkAllocationCallbacks>, objects: &mut [VkPipeline], ) -> Result<()>

Create graphics pipelines

fn new_graphics_pipelines<'s>( &'s self, infos: &[GraphicsPipelineCreateInfo<'_>], cache: Option<&(impl VkHandle<Handle = VkPipelineCache> + ?Sized)>, ) -> Result<Vec<PipelineObject<&'s Self>>>

Create graphics pipelines

fn new_graphics_pipeline_array<'s, const N: usize>( &'s self, infos: &[GraphicsPipelineCreateInfo<'_>; N], cache: Option<&(impl VkHandle<Handle = VkPipelineCache> + ?Sized)>, ) -> Result<[PipelineObject<&'s Self>; N]>

Create graphics pipelines

unsafe fn new_compute_pipelines_raw( &self, infos: &[ComputePipelineCreateInfo<'_>], cache: Option<VkPipelineCache>, allocation_callbacks: Option<&VkAllocationCallbacks>, objects: &mut [VkPipeline], ) -> Result<()>

Create compute pipelines

fn new_compute_pipelines<'s>( &'s self, infos: &[ComputePipelineCreateInfo<'_>], cache: Option<&(impl VkHandle<Handle = VkPipelineCache> + ?Sized)>, ) -> Result<Vec<PipelineObject<&'s Self>>>

Create compute pipelines

fn new_compute_pipeline_array<'s, const N: usize>( &'s self, infos: &[ComputePipelineCreateInfo<'_>; N], cache: Option<&(impl VkHandle<Handle = VkPipelineCache> + ?Sized)>, ) -> Result<[PipelineObject<&'s Self>; N]>

Create compute pipelines

fn new_command_pool_raw( &self, info: &CommandPoolCreateInfo, allocation_callbacks: Option<&VkAllocationCallbacks>, ) -> Result<VkCommandPool>

Create a new command pool object

fn new_query_pool_raw( &self, info: &QueryPoolCreateInfo, allocation_callbacks: Option<&VkAllocationCallbacks>, ) -> Result<VkQueryPool>

Create a new query pool object

unsafe fn allocate_command_buffers<'s>( &'s self, info: &CommandBufferAllocateInfo<'_>, sink: &mut [MaybeUninit<CommandBufferObject<&'s Self>>], ) -> Result<()>

Allocate command buffers from an existing command pool

unsafe fn allocate_command_buffers_alloc<'s>( &'s self, info: &CommandBufferAllocateInfo<'_>, ) -> Result<Vec<CommandBufferObject<&'s Self>>>

Allocate command buffers from an existing command pool

unsafe fn allocate_command_buffer_array<'s, const N: usize>( &'s self, info: &CommandBufferFixedCountAllocateInfo<'_, N>, ) -> Result<[CommandBufferObject<&'s Self>; N]>

Allocate command buffers from an existing command pool

unsafe fn invalidate_memory_range( &self, ranges: &[MappedMemoryRange<'_>], ) -> Result<()>

Invalidate MappedMemoryRanges Invalidating the memory range allows that device writes to the memory ranges which have been made visible to the VK_ACCESS_HOST_WRITE_BIT and VK_ACCESS_HOST_READ_BIT are made visible to the host

unsafe fn flush_mapped_memory_ranges( &self, ranges: &[MappedMemoryRange<'_>], ) -> Result<()>

Flush MappedMemoryRanges Flushing the memory range allows that host writes to the memory ranges can be made available to device access

unsafe fn update_descriptor_sets_raw( &self, writes: &[VkWriteDescriptorSet], copies: &[VkCopyDescriptorSet], )

Update the contents of descriptor set objects

fn update_descriptor_sets( &self, writes: &[DescriptorSetWriteInfo<'_>], copies: &[DescriptorSetCopyInfo], )

Update the contents of descriptor set objects

unsafe fn wait(&self) -> Result<()>

Wait for a object to become idle

unsafe fn bind_buffer_raw( &self, buffer: VkBuffer, memory: VkDeviceMemory, offset: VkDeviceSize, ) -> Result<()>

Single binding for a buffer

unsafe fn bind_image_raw( &self, image: VkImage, memory: VkDeviceMemory, offset: VkDeviceSize, ) -> Result<()>

Single binding for an image

fn wait_multiple_fences( &self, objects: &[VkHandleRef<'_, VkFence>], wait_all: bool, timeout: Option<u64>, ) -> Result<bool>

Wait for one or more fences to become signaled, returns Ok(true) if operation is timed out

fn reset_multiple_fences( &self, objects: &[VkHandleRefMut<'_, VkFence>], ) -> Result<()>

Resets one or more fence objects

fn new_swapchain_raw( &self, info: &SwapchainCreateInfo<'_, '_, '_>, allocation_callbacks: Option<&VkAllocationCallbacks>, ) -> Result<VkSwapchainKHR>

Create a swapchain

impl<Instance: Instance> DeviceBindMemory2Extension for DeviceObject<Instance>

fn bind_buffer_memory2_khr_fn(&self) -> PFN_vkBindBufferMemory2KHR

fn bind_image_memory2_khr_fn(&self) -> PFN_vkBindImageMemory2KHR

unsafe fn bind_buffer_memory2_khr( &self, bounds: &[VkBindBufferMemoryInfoKHR], ) -> Result<()>

Multiple Binding for Buffers

unsafe fn bind_image_memory2_khr( &self, bounds: &[VkBindImageMemoryInfoKHR], ) -> Result<()>

Multiple Binding for Images

impl<Instance: Instance> DeviceGetMemoryRequirements2Extension for DeviceObject<Instance>

fn get_buffer_memory_requirements_2_khr_fn( &self, ) -> PFN_vkGetBufferMemoryRequirements2KHR

fn get_image_memory_requirements_2_khr_fn( &self, ) -> PFN_vkGetImageMemoryRequirements2KHR

fn get_image_sparse_memory_requirements_2_khr_fn( &self, ) -> PFN_vkGetImageSparseMemoryRequirements2KHR

unsafe fn get_buffer_memory_requirements2_khr( &self, info: &BufferMemoryRequirementsInfo2<'_, impl VkHandle<Handle = VkBuffer>>, sink: &mut MaybeUninit<VkMemoryRequirements2KHR>, )

Returns the memory requirements for specified Vulkan object.

unsafe fn get_image_memory_requirements2_khr( &self, info: &ImageMemoryRequirementsInfo2<'_, impl VkHandle<Handle = VkImage>>, sink: &mut MaybeUninit<VkMemoryRequirements2KHR>, )

Returns the memory requirements for specified Vulkan object.

unsafe fn get_image_sparse_memory_requirements2_count_khr( &self, info: &ImageSparseMemoryRequirementsInfo2<'_>, count_sink: &mut MaybeUninit<u32>, sink_head_ptr: *mut VkSparseImageMemoryRequirements2KHR, )

Query the memory requirements for a sparse image

impl<Instance: Instance> DeviceSynchronization2Extension for DeviceObject<Instance>

fn queue_submit2_khr_fn(&self) -> PFN_vkQueueSubmit2KHR

fn cmd_pipeline_barrier_2_khr_fn(&self) -> PFN_vkCmdPipelineBarrier2KHR

impl<Instance> Drop for DeviceObject<Instance>

fn drop(&mut self)

Executes the destructor for this type.

impl<Instance: Instance> InstanceChild for DeviceObject<Instance>

type ConcreteInstance = Instance

fn instance(&self) -> &Self::ConcreteInstance

impl<Instance> VkHandle for DeviceObject<Instance>

type Handle = VkDevice

fn native_ptr(&self) -> Self::Handle

Retrieve an underlying handle

fn as_transparent_ref(&self) -> VkHandleRef<'_, Self::Handle>

impl<Instance> VkHandleMut for DeviceObject<Instance>

fn native_ptr_mut(&mut self) -> Self::Handle

Retrieve an underlying mutable handle

fn as_transparent_ref_mut(&mut self) -> VkHandleRefMut<'_, Self::Handle>

impl<Instance> VkObject for DeviceObject<Instance>

const TYPE: VkObjectType = 3i32

impl<Instance: Send> Send for DeviceObject<Instance>

impl<Instance: Sync> Sync for DeviceObject<Instance>