Struct DeviceShared

struct DeviceShared {

    raw: Device,
    family_index: u32,
    queue_index: u32,
    raw_queue: Queue,
    instance: Arc<InstanceShared>,
    physical_device: PhysicalDevice,
    enabled_extensions: Vec<&'static CStr>,
    extension_fns: DeviceExtensionFunctions,
    vendor_id: u32,
    pipeline_cache_validation_key: [u8; 16],
    timestamp_period: f32,
    private_caps: PrivateCapabilities,
    workarounds: Workarounds,
    features: Features,
    render_passes: Mutex<FastHashMap<RenderPassKey, RenderPass>>,
    sampler_cache: Mutex<SamplerCache>,
    memory_allocations_counter: InternalCounter,
    texture_identity_factory: ResourceIdentityFactory<Image>,
    texture_view_identity_factory: ResourceIdentityFactory<ImageView>,
    drop_guard: Option<DropGuard>,
}

Fields

raw: Device

family_index: u32

queue_index: u32

raw_queue: Queue

instance: Arc<InstanceShared>

physical_device: PhysicalDevice

enabled_extensions: Vec<&'static CStr>

extension_fns: DeviceExtensionFunctions

vendor_id: u32

pipeline_cache_validation_key: [u8; 16]

timestamp_period: f32

private_caps: PrivateCapabilities

workarounds: Workarounds

features: Features

render_passes: Mutex<FastHashMap<RenderPassKey, RenderPass>>

sampler_cache: Mutex<SamplerCache>

memory_allocations_counter: InternalCounter

texture_identity_factory: ResourceIdentityFactory<Image>

Because we have cached framebuffers which are not deleted from until the device is destroyed, if the implementation of vulkan re-uses handles we need some way to differentiate between the old handle and the new handle. This factory allows us to have a dedicated identity value for each texture.

texture_view_identity_factory: ResourceIdentityFactory<ImageView>

As above, for texture views.

drop_guard: Option<DropGuard>

Implementations

impl DeviceShared

pub(super) unsafe fn set_object_name(&self, object: impl Handle, name: &str)

Set the name of object to name.

If name contains an interior null byte, then the name set will be truncated to that byte.

Safety

This method inherits the safety contract from vkSetDebugUtilsObjectName. In particular:

• object must be a valid handle for one of the following:
  • An instance-level object from the same instance as this device.
  • A physical-device-level object that descends from the same physical device as this device.
  • A device-level object that descends from this device.
• object must be externally synchronized—only the calling thread should access it during this call.

pub fn make_render_pass( &self, key: RenderPassKey, ) -> Result<RenderPass, DeviceError>

fn make_memory_ranges<'a, I: 'a + Iterator<Item = MemoryRange>>( &self, buffer: &'a Buffer, ranges: I, ) -> Option<impl 'a + Iterator<Item = MappedMemoryRange<'a>>>

impl DeviceShared

pub(super) fn new_binary_semaphore( &self, name: &str, ) -> Result<Semaphore, DeviceError>

pub(super) fn wait_for_fence( &self, fence: &Fence, wait_value: FenceValue, timeout_ns: u64, ) -> Result<bool, DeviceError>

Trait Implementations

impl DescriptorDevice<DescriptorSetLayout, DescriptorPool, DescriptorSet> for DeviceShared

unsafe fn create_descriptor_pool( &self, descriptor_count: &DescriptorTotalCount, max_sets: u32, flags: DescriptorPoolCreateFlags, ) -> Result<DescriptorPool, CreatePoolError>

Creates a new descriptor pool.

unsafe fn destroy_descriptor_pool(&self, pool: DescriptorPool)

Destroys descriptor pool.

unsafe fn alloc_descriptor_sets<'a>( &self, pool: &mut DescriptorPool, layouts: impl ExactSizeIterator<Item = &'a DescriptorSetLayout>, sets: &mut impl Extend<DescriptorSet>, ) -> Result<(), DeviceAllocationError>

Allocates descriptor sets.

unsafe fn dealloc_descriptor_sets<'a>( &self, pool: &mut DescriptorPool, sets: impl Iterator<Item = DescriptorSet>, )

Deallocates descriptor sets.

impl Drop for DeviceShared

fn drop(&mut self)

Executes the destructor for this type.

impl MemoryDevice<DeviceMemory> for DeviceShared

unsafe fn allocate_memory( &self, size: u64, memory_type: u32, flags: AllocationFlags, ) -> Result<DeviceMemory, OutOfMemory>

Allocates new memory object from device. This function may be expensive and even limit maximum number of memory objects allocated. Which is the reason for sub-allocation this crate provides.

unsafe fn deallocate_memory(&self, memory: DeviceMemory)

Deallocate memory object.

unsafe fn map_memory( &self, memory: &mut DeviceMemory, offset: u64, size: u64, ) -> Result<NonNull<u8>, DeviceMapError>

Map region of device memory to host memory space.

unsafe fn unmap_memory(&self, memory: &mut DeviceMemory)

Unmap previously mapped memory region.

unsafe fn invalidate_memory_ranges( &self, _ranges: &[MappedMemoryRange<'_, DeviceMemory>], ) -> Result<(), OutOfMemory>

Invalidates ranges of memory mapped regions.

unsafe fn flush_memory_ranges( &self, _ranges: &[MappedMemoryRange<'_, DeviceMemory>], ) -> Result<(), OutOfMemory>

Flushes ranges of memory mapped regions.