#![allow(unused_imports)]
use crate::{vk::Result as VkResult, vk::*, *};
use core::ffi::{CStr, c_char, c_int, c_void};
use core::mem::transmute;
use core::ptr;
pub const EXTENSION_NAME: &CStr = c"VK_KHR_xcb_surface";
pub(super) mod defs {
#![allow(non_camel_case_types, unused_imports)]
use crate::{vk::*, *};
use core::ffi::{CStr, c_char, c_int, c_void};
use core::fmt;
use core::marker::PhantomData;
use core::ptr;
#[repr(C)]
#[derive(Copy, Clone)]
#[must_use]
pub struct XcbSurfaceCreateInfoKHR<'a> {
pub s_type: StructureType,
pub p_next: *const c_void,
pub flags: XcbSurfaceCreateFlagsKHR,
pub connection: *mut xcb_connection_t,
pub window: xcb_window_t,
pub _marker: PhantomData<&'a ()>,
}
#[cfg(feature = "debug")]
impl fmt::Debug for XcbSurfaceCreateInfoKHR<'_> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("XcbSurfaceCreateInfoKHR")
.field("s_type", &self.s_type)
.field("p_next", &self.p_next)
.field("flags", &self.flags)
.field("connection", &self.connection)
.field("window", &self.window)
.finish()
}
}
unsafe impl<'a> TaggedStructure<'a> for XcbSurfaceCreateInfoKHR<'a> {
const STRUCTURE_TYPE: StructureType = StructureType::XCB_SURFACE_CREATE_INFO_KHR;
}
impl Default for XcbSurfaceCreateInfoKHR<'_> {
fn default() -> Self {
Self {
s_type: Self::STRUCTURE_TYPE,
p_next: ptr::null(),
flags: Default::default(),
connection: ptr::null_mut(),
window: Default::default(),
_marker: PhantomData,
}
}
}
impl<'a> XcbSurfaceCreateInfoKHR<'a> {
#[inline]
pub fn flags(mut self, flags: XcbSurfaceCreateFlagsKHR) -> Self {
self.flags = flags;
self
}
#[inline]
pub fn connection(mut self, connection: *mut xcb_connection_t) -> Self {
self.connection = connection;
self
}
#[inline]
pub fn window(mut self, window: xcb_window_t) -> Self {
self.window = window;
self
}
}
#[repr(transparent)]
#[derive(Copy, Clone, PartialEq, Eq, Hash)]
pub struct XcbSurfaceCreateFlagsKHR(Flags);
vk_bitflags_wrapped!(XcbSurfaceCreateFlagsKHR, Flags);
impl fmt::Debug for XcbSurfaceCreateFlagsKHR {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
debug_flags(f, &[], self.0)
}
}
pub type PFN_vkCreateXcbSurfaceKHR = unsafe extern "system" fn(
instance: Instance,
p_create_info: *const XcbSurfaceCreateInfoKHR<'_>,
p_allocator: *const AllocationCallbacks<'_>,
p_surface: *mut SurfaceKHR,
) -> vk::Result;
pub type PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR = unsafe extern "system" fn(
physical_device: PhysicalDevice,
queue_family_index: u32,
connection: *mut xcb_connection_t,
visual_id: xcb_visualid_t,
)
-> Bool32;
}
#[cfg(feature = "ffi")]
pub(super) mod ffi {
#![allow(non_camel_case_types)]
use super::defs::*;
pub type VkXcbSurfaceCreateInfoKHR = XcbSurfaceCreateInfoKHR<'static>;
pub type VkXcbSurfaceCreateFlagsKHR = XcbSurfaceCreateFlagsKHR;
impl XcbSurfaceCreateInfoKHR<'_> {
#[inline]
pub unsafe fn drop_lifetime_for_ffi(&self) -> &VkXcbSurfaceCreateInfoKHR {
unsafe { core::mem::transmute(self) }
}
}
}
pub struct InstanceFn {
create_xcb_surface: PFN_vkCreateXcbSurfaceKHR,
get_physical_device_xcb_presentation_support: PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR,
}
impl LoadInstanceFn for InstanceFn {
unsafe fn load_with(
load: impl Fn(&CStr) -> Option<PFN_vkVoidFunction>,
) -> core::result::Result<Self, MissingEntryPointError> {
unsafe {
Ok(Self {
create_xcb_surface: transmute(
load(c"vkCreateXcbSurfaceKHR").ok_or(MissingEntryPointError)?,
),
get_physical_device_xcb_presentation_support: transmute(
load(c"vkGetPhysicalDeviceXcbPresentationSupportKHR")
.ok_or(MissingEntryPointError)?,
),
})
}
}
}
impl InstanceFn {
#[inline]
pub unsafe fn create_xcb_surface(
&self,
instance: Instance,
create_info: &XcbSurfaceCreateInfoKHR<'_>,
allocator: Option<&AllocationCallbacks<'_>>,
) -> crate::Result<SurfaceKHR> {
unsafe {
let mut surface = core::mem::MaybeUninit::uninit();
let result = (self.create_xcb_surface)(
instance,
create_info,
allocator.to_raw_ptr(),
surface.as_mut_ptr(),
);
match result {
VkResult::SUCCESS => Ok(surface.assume_init()),
err => Err(err),
}
}
}
#[inline]
pub unsafe fn get_physical_device_xcb_presentation_support(
&self,
physical_device: PhysicalDevice,
queue_family_index: u32,
connection: *mut xcb_connection_t,
visual_id: xcb_visualid_t,
) -> bool {
unsafe {
(self.get_physical_device_xcb_presentation_support)(
physical_device,
queue_family_index,
connection,
visual_id,
) != 0
}
}
}