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
use std::{mem, ptr};
use sys::platform::*;
use crate::*;
pub enum Vulkan {}
impl Graphics for Vulkan {
type Requirements = Requirements;
type Format = VkFormat;
type SessionCreateInfo = SessionCreateInfo;
type SwapchainImage = VkImage;
fn raise_format(x: i64) -> Self::Format {
x as _
}
fn lower_format(x: Self::Format) -> i64 {
x as _
}
fn requirements(instance: &Instance, system: SystemId) -> Result<Requirements> {
let mut out;
unsafe {
out = sys::GraphicsRequirementsVulkanKHR {
ty: sys::GraphicsRequirementsVulkanKHR::TYPE,
next: ptr::null_mut(),
..mem::uninitialized()
};
cvt((instance.vulkan().get_vulkan_graphics_requirements)(
instance.as_raw(),
system,
&mut out,
))?;
}
Ok(Requirements {
min_api_version_supported: Version::from_raw(out.min_api_version_supported),
max_api_version_supported: Version::from_raw(out.max_api_version_supported),
})
}
unsafe fn create_session(
instance: &Instance,
system: SystemId,
info: &Self::SessionCreateInfo,
) -> Result<sys::Session> {
let binding = sys::GraphicsBindingVulkanKHR {
ty: sys::GraphicsBindingVulkanKHR::TYPE,
next: ptr::null(),
instance: info.instance,
physical_device: info.physical_device,
device: info.device,
queue_family_index: info.queue_family_index,
queue_index: info.queue_index,
};
let info = sys::SessionCreateInfo {
ty: sys::SessionCreateInfo::TYPE,
next: &binding as *const _ as *const _,
create_flags: Default::default(),
system_id: system,
};
let mut out = sys::Session::NULL;
cvt((instance.fp().create_session)(
instance.as_raw(),
&info,
&mut out,
))?;
Ok(out)
}
fn enumerate_swapchain_images(swapchain: &Swapchain<Self>) -> Result<Vec<Self::SwapchainImage>> {
let images = get_arr_init(
sys::SwapchainImageVulkanKHR {
ty: sys::SwapchainImageVulkanKHR::TYPE,
next: ptr::null_mut(),
image: 0,
},
|capacity, count, buf| unsafe {
(swapchain.instance().fp().enumerate_swapchain_images)(
swapchain.as_raw(),
capacity,
count,
buf as *mut _,
)
},
)?;
Ok(images.into_iter().map(|x| x.image as _).collect())
}
}
#[derive(Copy, Clone)]
pub struct Requirements {
pub min_api_version_supported: Version,
pub max_api_version_supported: Version,
}
#[derive(Copy, Clone)]
pub struct SessionCreateInfo {
pub instance: VkInstance,
pub physical_device: VkPhysicalDevice,
pub device: VkDevice,
pub queue_family_index: u32,
pub queue_index: u32,
}