erupt/generated/extensions/
khr_win32_surface.rs1#[doc(alias = "VK_KHR_WIN32_SURFACE_SPEC_VERSION")]
4pub const KHR_WIN32_SURFACE_SPEC_VERSION: u32 = 6;
5#[doc(alias = "VK_KHR_WIN32_SURFACE_EXTENSION_NAME")]
7pub const KHR_WIN32_SURFACE_EXTENSION_NAME: *const std::os::raw::c_char = crate::cstr!(
8 "VK_KHR_win32_surface"
9);
10pub const FN_CREATE_WIN32_SURFACE_KHR: *const std::os::raw::c_char = crate::cstr!(
12 "vkCreateWin32SurfaceKHR"
13);
14pub const FN_GET_PHYSICAL_DEVICE_WIN32_PRESENTATION_SUPPORT_KHR: *const std::os::raw::c_char = crate::cstr!(
16 "vkGetPhysicalDeviceWin32PresentationSupportKHR"
17);
18bitflags::bitflags! {
19 #[doc =
20 "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkWin32SurfaceCreateFlagsKHR.html) · Bitmask of [`Win32SurfaceCreateFlagBitsKHR`]"]
21 #[doc(alias = "VkWin32SurfaceCreateFlagsKHR")] #[derive(Default)]
22 #[repr(transparent)] pub struct Win32SurfaceCreateFlagsKHR : u32 {
23 #[cfg(empty_bitflag_workaround)] const EMPTY_BITFLAG_WORKAROUND = 0; }
24}
25#[doc(alias = "VkWin32SurfaceCreateFlagBitsKHR")]
27#[derive(Copy, Clone, PartialEq, Eq, Hash, Default, Ord, PartialOrd)]
28#[repr(transparent)]
29pub struct Win32SurfaceCreateFlagBitsKHR(pub u32);
30impl Win32SurfaceCreateFlagBitsKHR {
31 #[inline]
32 pub const fn bitmask(&self) -> Win32SurfaceCreateFlagsKHR {
34 Win32SurfaceCreateFlagsKHR::from_bits_truncate(self.0)
35 }
36}
37impl std::fmt::Debug for Win32SurfaceCreateFlagBitsKHR {
38 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
39 f.write_str(
40 match self {
41 _ => "(unknown variant)",
42 },
43 )
44 }
45}
46impl crate::vk1_0::StructureType {
48 pub const WIN32_SURFACE_CREATE_INFO_KHR: Self = Self(1000009000);
49}
50#[allow(non_camel_case_types)]
52pub type PFN_vkCreateWin32SurfaceKHR = unsafe extern "system" fn(
53 instance: crate::vk1_0::Instance,
54 p_create_info: *const crate::extensions::khr_win32_surface::Win32SurfaceCreateInfoKHR,
55 p_allocator: *const crate::vk1_0::AllocationCallbacks,
56 p_surface: *mut crate::extensions::khr_surface::SurfaceKHR,
57) -> crate::vk1_0::Result;
58#[allow(non_camel_case_types)]
60pub type PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR = unsafe extern "system" fn(
61 physical_device: crate::vk1_0::PhysicalDevice,
62 queue_family_index: u32,
63) -> crate::vk1_0::Bool32;
64#[doc(alias = "VkWin32SurfaceCreateInfoKHR")]
66#[derive(Copy, Clone)]
67#[repr(C)]
68pub struct Win32SurfaceCreateInfoKHR {
69 pub s_type: crate::vk1_0::StructureType,
70 pub p_next: *const std::ffi::c_void,
71 pub flags: crate::extensions::khr_win32_surface::Win32SurfaceCreateFlagsKHR,
72 pub hinstance: *mut std::ffi::c_void,
73 pub hwnd: *mut std::ffi::c_void,
74}
75impl Win32SurfaceCreateInfoKHR {
76 pub const STRUCTURE_TYPE: crate::vk1_0::StructureType = crate::vk1_0::StructureType::WIN32_SURFACE_CREATE_INFO_KHR;
77}
78impl Default for Win32SurfaceCreateInfoKHR {
79 fn default() -> Self {
80 Self {
81 s_type: Self::STRUCTURE_TYPE,
82 p_next: std::ptr::null(),
83 flags: Default::default(),
84 hinstance: std::ptr::null_mut(),
85 hwnd: std::ptr::null_mut(),
86 }
87 }
88}
89impl std::fmt::Debug for Win32SurfaceCreateInfoKHR {
90 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
91 f.debug_struct("Win32SurfaceCreateInfoKHR")
92 .field("s_type", &self.s_type)
93 .field("p_next", &self.p_next)
94 .field("flags", &self.flags)
95 .field("hinstance", &self.hinstance)
96 .field("hwnd", &self.hwnd)
97 .finish()
98 }
99}
100impl Win32SurfaceCreateInfoKHR {
101 #[inline]
102 pub fn into_builder<'a>(self) -> Win32SurfaceCreateInfoKHRBuilder<'a> {
103 Win32SurfaceCreateInfoKHRBuilder(self, std::marker::PhantomData)
104 }
105}
106#[derive(Copy, Clone)]
107#[repr(transparent)]
109pub struct Win32SurfaceCreateInfoKHRBuilder<'a>(
110 Win32SurfaceCreateInfoKHR,
111 std::marker::PhantomData<&'a ()>,
112);
113impl<'a> Win32SurfaceCreateInfoKHRBuilder<'a> {
114 #[inline]
115 pub fn new() -> Win32SurfaceCreateInfoKHRBuilder<'a> {
116 Win32SurfaceCreateInfoKHRBuilder(Default::default(), std::marker::PhantomData)
117 }
118 #[inline]
119 #[must_use]
120 pub fn flags(
121 mut self,
122 flags: crate::extensions::khr_win32_surface::Win32SurfaceCreateFlagsKHR,
123 ) -> Self {
124 self.0.flags = flags as _;
125 self
126 }
127 #[inline]
128 #[must_use]
129 pub fn hinstance(mut self, hinstance: *mut std::ffi::c_void) -> Self {
130 self.0.hinstance = hinstance;
131 self
132 }
133 #[inline]
134 #[must_use]
135 pub fn hwnd(mut self, hwnd: *mut std::ffi::c_void) -> Self {
136 self.0.hwnd = hwnd;
137 self
138 }
139 #[inline]
140 pub fn build_dangling(self) -> Win32SurfaceCreateInfoKHR {
143 self.0
144 }
145}
146impl<'a> std::default::Default for Win32SurfaceCreateInfoKHRBuilder<'a> {
147 fn default() -> Win32SurfaceCreateInfoKHRBuilder<'a> {
148 Self::new()
149 }
150}
151impl<'a> std::fmt::Debug for Win32SurfaceCreateInfoKHRBuilder<'a> {
152 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
153 std::fmt::Debug::fmt(&self.0, f)
154 }
155}
156impl<'a> std::ops::Deref for Win32SurfaceCreateInfoKHRBuilder<'a> {
157 type Target = Win32SurfaceCreateInfoKHR;
158 fn deref(&self) -> &Self::Target {
159 &self.0
160 }
161}
162impl<'a> std::ops::DerefMut for Win32SurfaceCreateInfoKHRBuilder<'a> {
163 fn deref_mut(&mut self) -> &mut Self::Target {
164 &mut self.0
165 }
166}
167impl crate::InstanceLoader {
169 #[inline]
170 #[track_caller]
171 #[doc(alias = "vkCreateWin32SurfaceKHR")]
173 pub unsafe fn create_win32_surface_khr(
174 &self,
175 create_info: &crate::extensions::khr_win32_surface::Win32SurfaceCreateInfoKHR,
176 allocator: Option<&crate::vk1_0::AllocationCallbacks>,
177 ) -> crate::utils::VulkanResult<crate::extensions::khr_surface::SurfaceKHR> {
178 let _function = self.create_win32_surface_khr.expect(crate::NOT_LOADED_MESSAGE);
179 let mut surface = Default::default();
180 let _return = _function(
181 self.handle,
182 create_info as _,
183 match allocator {
184 Some(v) => v,
185 None => std::ptr::null(),
186 },
187 &mut surface,
188 );
189 crate::utils::VulkanResult::new(_return, surface)
190 }
191 #[inline]
192 #[track_caller]
193 #[doc(alias = "vkGetPhysicalDeviceWin32PresentationSupportKHR")]
195 pub unsafe fn get_physical_device_win32_presentation_support_khr(
196 &self,
197 physical_device: crate::vk1_0::PhysicalDevice,
198 queue_family_index: u32,
199 ) -> bool {
200 let _function = self
201 .get_physical_device_win32_presentation_support_khr
202 .expect(crate::NOT_LOADED_MESSAGE);
203 let _return = _function(physical_device as _, queue_family_index as _);
204 _return != 0
205 }
206}