erupt/generated/extensions/
khr_xcb_surface.rs1#[doc(alias = "VK_KHR_XCB_SURFACE_SPEC_VERSION")]
4pub const KHR_XCB_SURFACE_SPEC_VERSION: u32 = 6;
5#[doc(alias = "VK_KHR_XCB_SURFACE_EXTENSION_NAME")]
7pub const KHR_XCB_SURFACE_EXTENSION_NAME: *const std::os::raw::c_char = crate::cstr!(
8 "VK_KHR_xcb_surface"
9);
10pub const FN_CREATE_XCB_SURFACE_KHR: *const std::os::raw::c_char = crate::cstr!(
12 "vkCreateXcbSurfaceKHR"
13);
14pub const FN_GET_PHYSICAL_DEVICE_XCB_PRESENTATION_SUPPORT_KHR: *const std::os::raw::c_char = crate::cstr!(
16 "vkGetPhysicalDeviceXcbPresentationSupportKHR"
17);
18bitflags::bitflags! {
19 #[doc =
20 "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkXcbSurfaceCreateFlagsKHR.html) · Bitmask of [`XcbSurfaceCreateFlagBitsKHR`]"]
21 #[doc(alias = "VkXcbSurfaceCreateFlagsKHR")] #[derive(Default)] #[repr(transparent)]
22 pub struct XcbSurfaceCreateFlagsKHR : u32 { #[cfg(empty_bitflag_workaround)] const
23 EMPTY_BITFLAG_WORKAROUND = 0; }
24}
25#[doc(alias = "VkXcbSurfaceCreateFlagBitsKHR")]
27#[derive(Copy, Clone, PartialEq, Eq, Hash, Default, Ord, PartialOrd)]
28#[repr(transparent)]
29pub struct XcbSurfaceCreateFlagBitsKHR(pub u32);
30impl XcbSurfaceCreateFlagBitsKHR {
31 #[inline]
32 pub const fn bitmask(&self) -> XcbSurfaceCreateFlagsKHR {
34 XcbSurfaceCreateFlagsKHR::from_bits_truncate(self.0)
35 }
36}
37impl std::fmt::Debug for XcbSurfaceCreateFlagBitsKHR {
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 XCB_SURFACE_CREATE_INFO_KHR: Self = Self(1000005000);
49}
50#[allow(non_camel_case_types)]
52pub type PFN_vkCreateXcbSurfaceKHR = unsafe extern "system" fn(
53 instance: crate::vk1_0::Instance,
54 p_create_info: *const crate::extensions::khr_xcb_surface::XcbSurfaceCreateInfoKHR,
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_vkGetPhysicalDeviceXcbPresentationSupportKHR = unsafe extern "system" fn(
61 physical_device: crate::vk1_0::PhysicalDevice,
62 queue_family_index: u32,
63 connection: *mut std::ffi::c_void,
64 visual_id: u32,
65) -> crate::vk1_0::Bool32;
66#[doc(alias = "VkXcbSurfaceCreateInfoKHR")]
68#[derive(Copy, Clone)]
69#[repr(C)]
70pub struct XcbSurfaceCreateInfoKHR {
71 pub s_type: crate::vk1_0::StructureType,
72 pub p_next: *const std::ffi::c_void,
73 pub flags: crate::extensions::khr_xcb_surface::XcbSurfaceCreateFlagsKHR,
74 pub connection: *mut std::ffi::c_void,
75 pub window: u32,
76}
77impl XcbSurfaceCreateInfoKHR {
78 pub const STRUCTURE_TYPE: crate::vk1_0::StructureType = crate::vk1_0::StructureType::XCB_SURFACE_CREATE_INFO_KHR;
79}
80impl Default for XcbSurfaceCreateInfoKHR {
81 fn default() -> Self {
82 Self {
83 s_type: Self::STRUCTURE_TYPE,
84 p_next: std::ptr::null(),
85 flags: Default::default(),
86 connection: std::ptr::null_mut(),
87 window: Default::default(),
88 }
89 }
90}
91impl std::fmt::Debug for XcbSurfaceCreateInfoKHR {
92 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
93 f.debug_struct("XcbSurfaceCreateInfoKHR")
94 .field("s_type", &self.s_type)
95 .field("p_next", &self.p_next)
96 .field("flags", &self.flags)
97 .field("connection", &self.connection)
98 .field("window", &self.window)
99 .finish()
100 }
101}
102impl XcbSurfaceCreateInfoKHR {
103 #[inline]
104 pub fn into_builder<'a>(self) -> XcbSurfaceCreateInfoKHRBuilder<'a> {
105 XcbSurfaceCreateInfoKHRBuilder(self, std::marker::PhantomData)
106 }
107}
108#[derive(Copy, Clone)]
109#[repr(transparent)]
111pub struct XcbSurfaceCreateInfoKHRBuilder<'a>(
112 XcbSurfaceCreateInfoKHR,
113 std::marker::PhantomData<&'a ()>,
114);
115impl<'a> XcbSurfaceCreateInfoKHRBuilder<'a> {
116 #[inline]
117 pub fn new() -> XcbSurfaceCreateInfoKHRBuilder<'a> {
118 XcbSurfaceCreateInfoKHRBuilder(Default::default(), std::marker::PhantomData)
119 }
120 #[inline]
121 #[must_use]
122 pub fn flags(
123 mut self,
124 flags: crate::extensions::khr_xcb_surface::XcbSurfaceCreateFlagsKHR,
125 ) -> Self {
126 self.0.flags = flags as _;
127 self
128 }
129 #[inline]
130 #[must_use]
131 pub fn connection(mut self, connection: *mut std::ffi::c_void) -> Self {
132 self.0.connection = connection;
133 self
134 }
135 #[inline]
136 #[must_use]
137 pub fn window(mut self, window: u32) -> Self {
138 self.0.window = window as _;
139 self
140 }
141 #[inline]
142 pub fn build_dangling(self) -> XcbSurfaceCreateInfoKHR {
145 self.0
146 }
147}
148impl<'a> std::default::Default for XcbSurfaceCreateInfoKHRBuilder<'a> {
149 fn default() -> XcbSurfaceCreateInfoKHRBuilder<'a> {
150 Self::new()
151 }
152}
153impl<'a> std::fmt::Debug for XcbSurfaceCreateInfoKHRBuilder<'a> {
154 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
155 std::fmt::Debug::fmt(&self.0, f)
156 }
157}
158impl<'a> std::ops::Deref for XcbSurfaceCreateInfoKHRBuilder<'a> {
159 type Target = XcbSurfaceCreateInfoKHR;
160 fn deref(&self) -> &Self::Target {
161 &self.0
162 }
163}
164impl<'a> std::ops::DerefMut for XcbSurfaceCreateInfoKHRBuilder<'a> {
165 fn deref_mut(&mut self) -> &mut Self::Target {
166 &mut self.0
167 }
168}
169impl crate::InstanceLoader {
171 #[inline]
172 #[track_caller]
173 #[doc(alias = "vkCreateXcbSurfaceKHR")]
175 pub unsafe fn create_xcb_surface_khr(
176 &self,
177 create_info: &crate::extensions::khr_xcb_surface::XcbSurfaceCreateInfoKHR,
178 allocator: Option<&crate::vk1_0::AllocationCallbacks>,
179 ) -> crate::utils::VulkanResult<crate::extensions::khr_surface::SurfaceKHR> {
180 let _function = self.create_xcb_surface_khr.expect(crate::NOT_LOADED_MESSAGE);
181 let mut surface = Default::default();
182 let _return = _function(
183 self.handle,
184 create_info as _,
185 match allocator {
186 Some(v) => v,
187 None => std::ptr::null(),
188 },
189 &mut surface,
190 );
191 crate::utils::VulkanResult::new(_return, surface)
192 }
193 #[inline]
194 #[track_caller]
195 #[doc(alias = "vkGetPhysicalDeviceXcbPresentationSupportKHR")]
197 pub unsafe fn get_physical_device_xcb_presentation_support_khr(
198 &self,
199 physical_device: crate::vk1_0::PhysicalDevice,
200 queue_family_index: u32,
201 connection: *mut std::ffi::c_void,
202 visual_id: u32,
203 ) -> bool {
204 let _function = self
205 .get_physical_device_xcb_presentation_support_khr
206 .expect(crate::NOT_LOADED_MESSAGE);
207 let _return = _function(
208 physical_device as _,
209 queue_family_index as _,
210 connection,
211 visual_id as _,
212 );
213 _return != 0
214 }
215}