#![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_EXT_full_screen_exclusive";
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 SurfaceFullScreenExclusiveInfoEXT<'a> {
pub s_type: StructureType,
pub p_next: *mut c_void,
pub full_screen_exclusive: FullScreenExclusiveEXT,
pub _marker: PhantomData<&'a ()>,
}
#[cfg(feature = "debug")]
impl fmt::Debug for SurfaceFullScreenExclusiveInfoEXT<'_> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("SurfaceFullScreenExclusiveInfoEXT")
.field("s_type", &self.s_type)
.field("p_next", &self.p_next)
.field("full_screen_exclusive", &self.full_screen_exclusive)
.finish()
}
}
unsafe impl<'a> TaggedStructure<'a> for SurfaceFullScreenExclusiveInfoEXT<'a> {
const STRUCTURE_TYPE: StructureType = StructureType::SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT;
}
unsafe impl Extends<PhysicalDeviceSurfaceInfo2KHR<'_>> for SurfaceFullScreenExclusiveInfoEXT<'_> {}
unsafe impl Extends<SwapchainCreateInfoKHR<'_>> for SurfaceFullScreenExclusiveInfoEXT<'_> {}
impl Default for SurfaceFullScreenExclusiveInfoEXT<'_> {
fn default() -> Self {
Self {
s_type: Self::STRUCTURE_TYPE,
p_next: ptr::null_mut(),
full_screen_exclusive: Default::default(),
_marker: PhantomData,
}
}
}
impl<'a> SurfaceFullScreenExclusiveInfoEXT<'a> {
#[inline]
pub fn full_screen_exclusive(
mut self,
full_screen_exclusive: FullScreenExclusiveEXT,
) -> Self {
self.full_screen_exclusive = full_screen_exclusive;
self
}
}
#[repr(C)]
#[derive(Copy, Clone)]
#[must_use]
pub struct SurfaceFullScreenExclusiveWin32InfoEXT<'a> {
pub s_type: StructureType,
pub p_next: *const c_void,
pub hmonitor: HMONITOR,
pub _marker: PhantomData<&'a ()>,
}
#[cfg(feature = "debug")]
impl fmt::Debug for SurfaceFullScreenExclusiveWin32InfoEXT<'_> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("SurfaceFullScreenExclusiveWin32InfoEXT")
.field("s_type", &self.s_type)
.field("p_next", &self.p_next)
.field("hmonitor", &self.hmonitor)
.finish()
}
}
unsafe impl<'a> TaggedStructure<'a> for SurfaceFullScreenExclusiveWin32InfoEXT<'a> {
const STRUCTURE_TYPE: StructureType =
StructureType::SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT;
}
unsafe impl Extends<PhysicalDeviceSurfaceInfo2KHR<'_>>
for SurfaceFullScreenExclusiveWin32InfoEXT<'_>
{
}
unsafe impl Extends<SwapchainCreateInfoKHR<'_>> for SurfaceFullScreenExclusiveWin32InfoEXT<'_> {}
impl Default for SurfaceFullScreenExclusiveWin32InfoEXT<'_> {
fn default() -> Self {
Self {
s_type: Self::STRUCTURE_TYPE,
p_next: ptr::null(),
hmonitor: Default::default(),
_marker: PhantomData,
}
}
}
impl<'a> SurfaceFullScreenExclusiveWin32InfoEXT<'a> {
#[inline]
pub fn hmonitor(mut self, hmonitor: HMONITOR) -> Self {
self.hmonitor = hmonitor;
self
}
}
#[repr(C)]
#[derive(Copy, Clone)]
#[must_use]
pub struct SurfaceCapabilitiesFullScreenExclusiveEXT<'a> {
pub s_type: StructureType,
pub p_next: *mut c_void,
pub full_screen_exclusive_supported: Bool32,
pub _marker: PhantomData<&'a ()>,
}
#[cfg(feature = "debug")]
impl fmt::Debug for SurfaceCapabilitiesFullScreenExclusiveEXT<'_> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("SurfaceCapabilitiesFullScreenExclusiveEXT")
.field("s_type", &self.s_type)
.field("p_next", &self.p_next)
.field(
"full_screen_exclusive_supported",
&self.full_screen_exclusive_supported,
)
.finish()
}
}
unsafe impl<'a> TaggedStructure<'a> for SurfaceCapabilitiesFullScreenExclusiveEXT<'a> {
const STRUCTURE_TYPE: StructureType =
StructureType::SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT;
}
unsafe impl Extends<SurfaceCapabilities2KHR<'_>> for SurfaceCapabilitiesFullScreenExclusiveEXT<'_> {}
impl Default for SurfaceCapabilitiesFullScreenExclusiveEXT<'_> {
fn default() -> Self {
Self {
s_type: Self::STRUCTURE_TYPE,
p_next: ptr::null_mut(),
full_screen_exclusive_supported: Default::default(),
_marker: PhantomData,
}
}
}
impl<'a> SurfaceCapabilitiesFullScreenExclusiveEXT<'a> {
#[inline]
pub fn full_screen_exclusive_supported(
mut self,
full_screen_exclusive_supported: bool,
) -> Self {
self.full_screen_exclusive_supported = full_screen_exclusive_supported.into();
self
}
}
#[repr(transparent)]
#[derive(Copy, Clone, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct FullScreenExclusiveEXT(i32);
impl FullScreenExclusiveEXT {
#[inline]
pub const fn from_raw(x: i32) -> Self {
Self(x)
}
#[inline]
pub const fn as_raw(self) -> i32 {
self.0
}
pub const DEFAULT_EXT: Self = Self(0);
pub const ALLOWED_EXT: Self = Self(1);
pub const DISALLOWED_EXT: Self = Self(2);
pub const APPLICATION_CONTROLLED_EXT: Self = Self(3);
}
impl fmt::Debug for FullScreenExclusiveEXT {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let name = match *self {
Self::DEFAULT_EXT => Some("DEFAULT_EXT"),
Self::ALLOWED_EXT => Some("ALLOWED_EXT"),
Self::DISALLOWED_EXT => Some("DISALLOWED_EXT"),
Self::APPLICATION_CONTROLLED_EXT => Some("APPLICATION_CONTROLLED_EXT"),
_ => None,
};
if let Some(name) = name {
f.write_str(name)
} else {
self.0.fmt(f)
}
}
}
pub type PFN_vkGetPhysicalDeviceSurfacePresentModes2EXT =
unsafe extern "system" fn(
physical_device: PhysicalDevice,
p_surface_info: *const PhysicalDeviceSurfaceInfo2KHR<'_>,
p_present_mode_count: *mut u32,
p_present_modes: *mut PresentModeKHR,
) -> vk::Result;
pub type PFN_vkGetDeviceGroupSurfacePresentModes2EXT = unsafe extern "system" fn(
device: Device,
p_surface_info: *const PhysicalDeviceSurfaceInfo2KHR<'_>,
p_modes: *mut DeviceGroupPresentModeFlagsKHR,
)
-> vk::Result;
pub type PFN_vkAcquireFullScreenExclusiveModeEXT =
unsafe extern "system" fn(device: Device, swapchain: SwapchainKHR) -> vk::Result;
pub type PFN_vkReleaseFullScreenExclusiveModeEXT =
unsafe extern "system" fn(device: Device, swapchain: SwapchainKHR) -> vk::Result;
}
#[cfg(feature = "ffi")]
pub(super) mod ffi {
#![allow(non_camel_case_types)]
use super::defs::*;
pub type VkSurfaceFullScreenExclusiveInfoEXT = SurfaceFullScreenExclusiveInfoEXT<'static>;
pub type VkSurfaceFullScreenExclusiveWin32InfoEXT =
SurfaceFullScreenExclusiveWin32InfoEXT<'static>;
pub type VkSurfaceCapabilitiesFullScreenExclusiveEXT =
SurfaceCapabilitiesFullScreenExclusiveEXT<'static>;
pub type VkFullScreenExclusiveEXT = FullScreenExclusiveEXT;
impl SurfaceFullScreenExclusiveInfoEXT<'_> {
#[inline]
pub unsafe fn drop_lifetime_for_ffi(&self) -> &VkSurfaceFullScreenExclusiveInfoEXT {
unsafe { core::mem::transmute(self) }
}
}
impl SurfaceFullScreenExclusiveWin32InfoEXT<'_> {
#[inline]
pub unsafe fn drop_lifetime_for_ffi(&self) -> &VkSurfaceFullScreenExclusiveWin32InfoEXT {
unsafe { core::mem::transmute(self) }
}
}
impl SurfaceCapabilitiesFullScreenExclusiveEXT<'_> {
#[inline]
pub unsafe fn drop_lifetime_for_ffi(&self) -> &VkSurfaceCapabilitiesFullScreenExclusiveEXT {
unsafe { core::mem::transmute(self) }
}
}
}
pub struct InstanceFn {
get_physical_device_surface_present_modes2: PFN_vkGetPhysicalDeviceSurfacePresentModes2EXT,
}
impl LoadInstanceFn for InstanceFn {
unsafe fn load_with(
load: impl Fn(&CStr) -> Option<PFN_vkVoidFunction>,
) -> core::result::Result<Self, MissingEntryPointError> {
unsafe {
Ok(Self {
get_physical_device_surface_present_modes2: transmute(
load(c"vkGetPhysicalDeviceSurfacePresentModes2EXT")
.ok_or(MissingEntryPointError)?,
),
})
}
}
}
impl InstanceFn {
#[inline]
pub unsafe fn get_physical_device_surface_present_modes2<'a>(
&self,
physical_device: PhysicalDevice,
surface_info: &PhysicalDeviceSurfaceInfo2KHR<'a>,
mut present_modes: impl EnumerateInto<PresentModeKHR>,
) -> crate::Result<()> {
unsafe {
let call = |present_mode_count, present_modes| {
let result = (self.get_physical_device_surface_present_modes2)(
physical_device,
surface_info,
present_mode_count,
present_modes as _,
);
match result {
VkResult::SUCCESS => Ok(()),
VkResult::INCOMPLETE => Ok(()),
err => Err(err),
}
};
let mut len = 0;
call(&mut len, std::ptr::null_mut())?;
let capacity = len.try_into().expect("failed to convert `N` to usize");
let present_modes_buf = present_modes.reserve(capacity);
len = present_modes_buf.len().try_into().unwrap();
let result = call(&mut len, present_modes_buf.as_mut_ptr() as *mut _)?;
present_modes.set_len(len.try_into().unwrap());
Ok(result)
}
}
}
pub struct DeviceFn {
acquire_full_screen_exclusive_mode: PFN_vkAcquireFullScreenExclusiveModeEXT,
release_full_screen_exclusive_mode: PFN_vkReleaseFullScreenExclusiveModeEXT,
get_device_group_surface_present_modes2: Option<PFN_vkGetDeviceGroupSurfacePresentModes2EXT>,
}
impl LoadDeviceFn for DeviceFn {
unsafe fn load_with(
load: impl Fn(&CStr) -> Option<PFN_vkVoidFunction>,
) -> core::result::Result<Self, MissingEntryPointError> {
unsafe {
Ok(Self {
acquire_full_screen_exclusive_mode: transmute(
load(c"vkAcquireFullScreenExclusiveModeEXT").ok_or(MissingEntryPointError)?,
),
release_full_screen_exclusive_mode: transmute(
load(c"vkReleaseFullScreenExclusiveModeEXT").ok_or(MissingEntryPointError)?,
),
get_device_group_surface_present_modes2: transmute(load(
c"vkGetDeviceGroupSurfacePresentModes2EXT",
)),
})
}
}
}
impl DeviceFn {
#[inline]
pub unsafe fn acquire_full_screen_exclusive_mode(
&self,
device: Device,
swapchain: SwapchainKHR,
) -> crate::Result<()> {
unsafe {
let result = (self.acquire_full_screen_exclusive_mode)(device, swapchain);
match result {
VkResult::SUCCESS => Ok(()),
err => Err(err),
}
}
}
#[inline]
pub unsafe fn release_full_screen_exclusive_mode(
&self,
device: Device,
swapchain: SwapchainKHR,
) -> crate::Result<()> {
unsafe {
let result = (self.release_full_screen_exclusive_mode)(device, swapchain);
match result {
VkResult::SUCCESS => Ok(()),
err => Err(err),
}
}
}
#[inline]
pub unsafe fn get_device_group_surface_present_modes2(
&self,
device: Device,
surface_info: &PhysicalDeviceSurfaceInfo2KHR<'_>,
) -> crate::Result<DeviceGroupPresentModeFlagsKHR> {
unsafe {
let mut modes = core::mem::MaybeUninit::uninit();
let result = (self.get_device_group_surface_present_modes2.unwrap())(
device,
surface_info,
modes.as_mut_ptr(),
);
match result {
VkResult::SUCCESS => Ok(modes.assume_init()),
err => Err(err),
}
}
}
}