maia 0.1.1

Safe low-level Vulkan bindings
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147

// Copyright 2022 Google LLC

// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.

use std::mem::MaybeUninit;

use crate::error::Result;
use crate::ffi::ArrayMut;
use crate::instance::Instance;
use crate::types::*;

/// A physical device. It is not freed separately from the instance and so can
/// be freely cloned.
///
/// Returned from [`Instance::enumerate_physical_devices`]
#[derive(Debug)]
pub struct PhysicalDevice {
    handle: Handle<VkPhysicalDevice>,
    instance: Arc<Instance>,
}

impl Instance {
    /// Returns the instance's physical devices.
    #[doc = crate::man_link!(vkEnumeratePhysicalDevices)]
    pub fn enumerate_physical_devices(
        self: &Arc<Self>,
    ) -> Result<Vec<PhysicalDevice>> {
        let mut len = 0;
        let mut result = Vec::new();
        unsafe {
            (self.fun.enumerate_physical_devices)(
                self.handle(),
                &mut len,
                None,
            )?;
            result.reserve(len as usize);
            (self.fun.enumerate_physical_devices)(
                self.handle(),
                &mut len,
                ArrayMut::from_slice(result.spare_capacity_mut()),
            )?;
            result.set_len(len as usize);
        }
        Ok(result
            .into_iter()
            .map(|handle| PhysicalDevice { handle, instance: self.clone() })
            .collect())
    }
}

impl PhysicalDevice {
    /// Borrows the inner Vulkan handle.
    pub fn handle(&self) -> Ref<VkPhysicalDevice> {
        self.handle.borrow()
    }
    /// Gets the instance.
    pub fn instance(&self) -> &Arc<Instance> {
        &self.instance
    }
}

impl Clone for PhysicalDevice {
    fn clone(&self) -> Self {
        Self {
            // Safety: phyiscal device has no externally synchronized functions
            // and is not freed
            handle: unsafe { self.handle.clone() },
            instance: self.instance.clone(),
        }
    }
}

impl PhysicalDevice {
    #[doc = crate::man_link!(vkGetPhysicalDeviceProperties)]
    pub fn properties(&self) -> PhysicalDeviceProperties {
        let mut result = MaybeUninit::uninit();
        unsafe {
            (self.instance.fun.get_physical_device_properties)(
                self.handle(),
                &mut result,
            );
            result.assume_init()
        }
    }

    #[doc = crate::man_link!(vkGetPhysicalDeviceQueueFamilyProperties)]
    pub fn queue_family_properties(&self) -> Vec<QueueFamilyProperties> {
        let mut len = 0;
        let mut result = Vec::new();
        unsafe {
            (self.instance.fun.get_physical_device_queue_family_properties)(
                self.handle(),
                &mut len,
                None,
            );
            result.reserve(len as usize);
            (self.instance.fun.get_physical_device_queue_family_properties)(
                self.handle(),
                &mut len,
                ArrayMut::from_slice(result.spare_capacity_mut()),
            );
            result.set_len(len as usize);
        }
        result
    }

    #[doc = crate::man_link!(vkGetPhysicalDeviceMemoryProperties)]
    pub fn memory_properties(&self) -> PhysicalDeviceMemoryProperties {
        let mut result = Default::default();
        unsafe {
            (self.instance.fun.get_physical_device_memory_properties)(
                self.handle(),
                &mut result,
            );
        }
        result
    }

    #[doc = crate::man_link!(vkEnumerateDeviceExtensionProperties)]
    pub fn device_extension_properties(
        &self,
    ) -> Result<Vec<ExtensionProperties>> {
        let mut len = 0;
        let mut result = Vec::new();
        unsafe {
            (self.instance.fun.enumerate_device_extension_properties)(
                self.handle(),
                None,
                &mut len,
                None,
            )?;
            result.reserve(len as usize);
            (self.instance.fun.enumerate_device_extension_properties)(
                self.handle(),
                None,
                &mut len,
                ArrayMut::from_slice(result.spare_capacity_mut()),
            )?;
            result.set_len(len as usize);
        }
        Ok(result)
    }
}