1     type VkPhysicalDevice
2         def get_capabilities surface =
3             let mut capabilities = SurfaceCapabilitiesKhr@zero
4             vk/get_physical_device_surface_capabilities_khr self surface
5                                                             capabilities@mut_ptr
6             |> assert_success
7     
8             capabilities
9     
10        def is_supported queue_family_index
11                         surface =
12            let mut is_supported = 0
13            vk/get_physical_device_surface_support_khr self queue_family_index
14                                                       surface
15                                                       is_supported@mut_ptr
16            |> assert_success
17    
18            is_supported <> 0
19    
20        def get_present_modes surface =
21            let mut count = 0
22            vk/get_physical_device_surface_present_modes_khr self surface
23                                                             count@mut_ptr
24                                                             null
25            |> assert_success
26    
27            let present_modes = Array<PresentModeKhr> count
28            vk/get_physical_device_surface_present_modes_khr self surface
29                                                             count@mut_ptr
30                                                             present_modes.as_mut_ptr
31            |> assert_success
32    
33            List.from present_modes
34    
35        def get_max_usable_sample_count =
36            let mut properties = PhysicalDeviceProperties@zero
37            vk/get_physical_device_properties self properties@mut_ptr
38    
39            let flags = properties.limits.framebuffer_color_sample_counts
40                        & properties.limits.framebuffer_depth_sample_counts
41            when
42                flags.contains SampleCountFlags/ -> SampleCountFlags/
43                flags.contains SampleCountFlags/ -> SampleCountFlags/
44                flags.contains SampleCountFlags/ -> SampleCountFlags/
45                flags.contains SampleCountFlags/ -> SampleCountFlags/
46                flags.contains SampleCountFlags/ -> SampleCountFlags/
47                flags.contains SampleCountFlags/ -> SampleCountFlags/
48                else -> SampleCountFlags/
49    
50        let find_supported_format (formats : Slice<VkFormat>
51                                   tiling : ImageTiling
52                                   features : FormatFeatureFlags) : VkFormat =
53            for format in formats do
54                let mut properties = FormatProperties@zero
55                vk/get_physical_device_format_properties self format properties@mut_ptr
56    
57                if tiling == ImageTiling/Linear
58                   && properties.linear_tiling_features.contains features
59                   || tiling == ImageTiling/Optimal
60                      && properties.optimal_tiling_features.contains features
61                then
62                    return format
63    
64            fail "cannot find supported format"
65    
66        def find_depth_format =
67            let formats = [VkFormat/D32_SFLOAT
68                           VkFormat/D32_SFLOAT_S8_UINT
69                           VkFormat/D24_UNORM_S8_UINT]
70    
71            find_supported_format formats ImageTiling/Optimal
72                                  FormatFeatureFlags/DepthStencilAttachment
73    
74        def get_properties =
75            let mut physical_device_properties = PhysicalDeviceProperties@zero
76            vk/get_physical_device_properties self physical_device_properties@mut_ptr
77    
78            physical_device_properties
79    
80        def get_graphics_queue_family_index : u32 =
81            let mut count = 0
82            vk/get_physical_device_queue_family_properties self count@mut_ptr null
83    
84            let properties = Array<QueueFamilyProperties> count
85            vk/get_physical_device_queue_family_properties self count@mut_ptr
86                                                           properties.as_mut_ptr
87            let queue_index =
88                properties.find_index { _.queue_flags.contains QueueFlags/Graphics }
89    
90            properties.discard
91            queue_index
92    
93        def get_memory_type_index (type_filter : u32
94                                   property_flags : MemoryPropertyFlags) : u32 =
95            let mut memory_properties = PhysicalDeviceMemoryProperties@zero
96            vk/get_physical_device_memory_properties self memory_properties@mut_ptr
97    
98            for i = 0 until memory_properties.memory_type_count do
99                if type_filter & 1 << i <> 0
100                  && memory_properties.memory_types[i].property_flags
101                     & property_flags == property_flags
102               then
103                   return i
104   
105           fail "cannot find memory type index"
106