#![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_get_display_properties2";
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 DisplayProperties2KHR<'a> {
pub s_type: StructureType,
pub p_next: *mut c_void,
pub display_properties: DisplayPropertiesKHR<'a>,
pub _marker: PhantomData<&'a ()>,
}
#[cfg(feature = "debug")]
impl fmt::Debug for DisplayProperties2KHR<'_> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("DisplayProperties2KHR")
.field("s_type", &self.s_type)
.field("p_next", &self.p_next)
.field("display_properties", &self.display_properties)
.finish()
}
}
unsafe impl<'a> TaggedStructure<'a> for DisplayProperties2KHR<'a> {
const STRUCTURE_TYPE: StructureType = StructureType::DISPLAY_PROPERTIES_2_KHR;
}
impl Default for DisplayProperties2KHR<'_> {
fn default() -> Self {
Self {
s_type: Self::STRUCTURE_TYPE,
p_next: ptr::null_mut(),
display_properties: Default::default(),
_marker: PhantomData,
}
}
}
impl<'a> DisplayProperties2KHR<'a> {
#[inline]
pub fn display_properties(mut self, display_properties: DisplayPropertiesKHR<'a>) -> Self {
self.display_properties = display_properties;
self
}
}
#[repr(C)]
#[derive(Copy, Clone)]
#[must_use]
pub struct DisplayPlaneProperties2KHR<'a> {
pub s_type: StructureType,
pub p_next: *mut c_void,
pub display_plane_properties: DisplayPlanePropertiesKHR,
pub _marker: PhantomData<&'a ()>,
}
#[cfg(feature = "debug")]
impl fmt::Debug for DisplayPlaneProperties2KHR<'_> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("DisplayPlaneProperties2KHR")
.field("s_type", &self.s_type)
.field("p_next", &self.p_next)
.field("display_plane_properties", &self.display_plane_properties)
.finish()
}
}
unsafe impl<'a> TaggedStructure<'a> for DisplayPlaneProperties2KHR<'a> {
const STRUCTURE_TYPE: StructureType = StructureType::DISPLAY_PLANE_PROPERTIES_2_KHR;
}
impl Default for DisplayPlaneProperties2KHR<'_> {
fn default() -> Self {
Self {
s_type: Self::STRUCTURE_TYPE,
p_next: ptr::null_mut(),
display_plane_properties: Default::default(),
_marker: PhantomData,
}
}
}
impl<'a> DisplayPlaneProperties2KHR<'a> {
#[inline]
pub fn display_plane_properties(
mut self,
display_plane_properties: DisplayPlanePropertiesKHR,
) -> Self {
self.display_plane_properties = display_plane_properties;
self
}
}
#[repr(C)]
#[derive(Copy, Clone)]
#[must_use]
pub struct DisplayModeProperties2KHR<'a> {
pub s_type: StructureType,
pub p_next: *mut c_void,
pub display_mode_properties: DisplayModePropertiesKHR,
pub _marker: PhantomData<&'a ()>,
}
#[cfg(feature = "debug")]
impl fmt::Debug for DisplayModeProperties2KHR<'_> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("DisplayModeProperties2KHR")
.field("s_type", &self.s_type)
.field("p_next", &self.p_next)
.field("display_mode_properties", &self.display_mode_properties)
.finish()
}
}
unsafe impl<'a> TaggedStructure<'a> for DisplayModeProperties2KHR<'a> {
const STRUCTURE_TYPE: StructureType = StructureType::DISPLAY_MODE_PROPERTIES_2_KHR;
}
impl Default for DisplayModeProperties2KHR<'_> {
fn default() -> Self {
Self {
s_type: Self::STRUCTURE_TYPE,
p_next: ptr::null_mut(),
display_mode_properties: Default::default(),
_marker: PhantomData,
}
}
}
impl<'a> DisplayModeProperties2KHR<'a> {
#[inline]
pub fn display_mode_properties(
mut self,
display_mode_properties: DisplayModePropertiesKHR,
) -> Self {
self.display_mode_properties = display_mode_properties;
self
}
}
#[repr(C)]
#[derive(Copy, Clone)]
#[must_use]
pub struct DisplayPlaneInfo2KHR<'a> {
pub s_type: StructureType,
pub p_next: *const c_void,
pub mode: DisplayModeKHR,
pub plane_index: u32,
pub _marker: PhantomData<&'a ()>,
}
#[cfg(feature = "debug")]
impl fmt::Debug for DisplayPlaneInfo2KHR<'_> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("DisplayPlaneInfo2KHR")
.field("s_type", &self.s_type)
.field("p_next", &self.p_next)
.field("mode", &self.mode)
.field("plane_index", &self.plane_index)
.finish()
}
}
unsafe impl<'a> TaggedStructure<'a> for DisplayPlaneInfo2KHR<'a> {
const STRUCTURE_TYPE: StructureType = StructureType::DISPLAY_PLANE_INFO_2_KHR;
}
impl Default for DisplayPlaneInfo2KHR<'_> {
fn default() -> Self {
Self {
s_type: Self::STRUCTURE_TYPE,
p_next: ptr::null(),
mode: Default::default(),
plane_index: Default::default(),
_marker: PhantomData,
}
}
}
impl<'a> DisplayPlaneInfo2KHR<'a> {
#[inline]
pub fn mode(mut self, mode: DisplayModeKHR) -> Self {
self.mode = mode;
self
}
#[inline]
pub fn plane_index(mut self, plane_index: u32) -> Self {
self.plane_index = plane_index;
self
}
}
#[repr(C)]
#[derive(Copy, Clone)]
#[must_use]
pub struct DisplayPlaneCapabilities2KHR<'a> {
pub s_type: StructureType,
pub p_next: *mut c_void,
pub capabilities: DisplayPlaneCapabilitiesKHR,
pub _marker: PhantomData<&'a ()>,
}
#[cfg(feature = "debug")]
impl fmt::Debug for DisplayPlaneCapabilities2KHR<'_> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("DisplayPlaneCapabilities2KHR")
.field("s_type", &self.s_type)
.field("p_next", &self.p_next)
.field("capabilities", &self.capabilities)
.finish()
}
}
unsafe impl<'a> TaggedStructure<'a> for DisplayPlaneCapabilities2KHR<'a> {
const STRUCTURE_TYPE: StructureType = StructureType::DISPLAY_PLANE_CAPABILITIES_2_KHR;
}
impl Default for DisplayPlaneCapabilities2KHR<'_> {
fn default() -> Self {
Self {
s_type: Self::STRUCTURE_TYPE,
p_next: ptr::null_mut(),
capabilities: Default::default(),
_marker: PhantomData,
}
}
}
impl<'a> DisplayPlaneCapabilities2KHR<'a> {
#[inline]
pub fn capabilities(mut self, capabilities: DisplayPlaneCapabilitiesKHR) -> Self {
self.capabilities = capabilities;
self
}
}
pub type PFN_vkGetPhysicalDeviceDisplayProperties2KHR = unsafe extern "system" fn(
physical_device: PhysicalDevice,
p_property_count: *mut u32,
p_properties: *mut DisplayProperties2KHR<'_>,
)
-> vk::Result;
pub type PFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR =
unsafe extern "system" fn(
physical_device: PhysicalDevice,
p_property_count: *mut u32,
p_properties: *mut DisplayPlaneProperties2KHR<'_>,
) -> vk::Result;
pub type PFN_vkGetDisplayModeProperties2KHR = unsafe extern "system" fn(
physical_device: PhysicalDevice,
display: DisplayKHR,
p_property_count: *mut u32,
p_properties: *mut DisplayModeProperties2KHR<'_>,
) -> vk::Result;
pub type PFN_vkGetDisplayPlaneCapabilities2KHR = unsafe extern "system" fn(
physical_device: PhysicalDevice,
p_display_plane_info: *const DisplayPlaneInfo2KHR<'_>,
p_capabilities: *mut DisplayPlaneCapabilities2KHR<'_>,
) -> vk::Result;
}
#[cfg(feature = "ffi")]
pub(super) mod ffi {
#![allow(non_camel_case_types)]
use super::defs::*;
pub type VkDisplayProperties2KHR = DisplayProperties2KHR<'static>;
pub type VkDisplayPlaneProperties2KHR = DisplayPlaneProperties2KHR<'static>;
pub type VkDisplayModeProperties2KHR = DisplayModeProperties2KHR<'static>;
pub type VkDisplayPlaneInfo2KHR = DisplayPlaneInfo2KHR<'static>;
pub type VkDisplayPlaneCapabilities2KHR = DisplayPlaneCapabilities2KHR<'static>;
impl DisplayProperties2KHR<'_> {
#[inline]
pub unsafe fn drop_lifetime_for_ffi(&self) -> &VkDisplayProperties2KHR {
unsafe { core::mem::transmute(self) }
}
}
impl DisplayPlaneProperties2KHR<'_> {
#[inline]
pub unsafe fn drop_lifetime_for_ffi(&self) -> &VkDisplayPlaneProperties2KHR {
unsafe { core::mem::transmute(self) }
}
}
impl DisplayModeProperties2KHR<'_> {
#[inline]
pub unsafe fn drop_lifetime_for_ffi(&self) -> &VkDisplayModeProperties2KHR {
unsafe { core::mem::transmute(self) }
}
}
impl DisplayPlaneInfo2KHR<'_> {
#[inline]
pub unsafe fn drop_lifetime_for_ffi(&self) -> &VkDisplayPlaneInfo2KHR {
unsafe { core::mem::transmute(self) }
}
}
impl DisplayPlaneCapabilities2KHR<'_> {
#[inline]
pub unsafe fn drop_lifetime_for_ffi(&self) -> &VkDisplayPlaneCapabilities2KHR {
unsafe { core::mem::transmute(self) }
}
}
}
pub struct InstanceFn {
get_physical_device_display_properties2: PFN_vkGetPhysicalDeviceDisplayProperties2KHR,
get_physical_device_display_plane_properties2:
PFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR,
get_display_mode_properties2: PFN_vkGetDisplayModeProperties2KHR,
get_display_plane_capabilities2: PFN_vkGetDisplayPlaneCapabilities2KHR,
}
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_display_properties2: transmute(
load(c"vkGetPhysicalDeviceDisplayProperties2KHR")
.ok_or(MissingEntryPointError)?,
),
get_physical_device_display_plane_properties2: transmute(
load(c"vkGetPhysicalDeviceDisplayPlaneProperties2KHR")
.ok_or(MissingEntryPointError)?,
),
get_display_mode_properties2: transmute(
load(c"vkGetDisplayModeProperties2KHR").ok_or(MissingEntryPointError)?,
),
get_display_plane_capabilities2: transmute(
load(c"vkGetDisplayPlaneCapabilities2KHR").ok_or(MissingEntryPointError)?,
),
})
}
}
}
impl InstanceFn {
#[inline]
pub unsafe fn get_physical_device_display_properties2<'a>(
&self,
physical_device: PhysicalDevice,
mut properties: impl EnumerateInto<DisplayProperties2KHR<'a>>,
) -> crate::Result<()> {
unsafe {
let call = |property_count, properties| {
let result = (self.get_physical_device_display_properties2)(
physical_device,
property_count,
properties 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 properties_buf = properties.reserve(capacity);
len = properties_buf.len().try_into().unwrap();
let result = call(&mut len, properties_buf.as_mut_ptr() as *mut _)?;
properties.set_len(len.try_into().unwrap());
Ok(result)
}
}
#[inline]
pub unsafe fn get_physical_device_display_plane_properties2<'a>(
&self,
physical_device: PhysicalDevice,
mut properties: impl EnumerateInto<DisplayPlaneProperties2KHR<'a>>,
) -> crate::Result<()> {
unsafe {
let call = |property_count, properties| {
let result = (self.get_physical_device_display_plane_properties2)(
physical_device,
property_count,
properties 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 properties_buf = properties.reserve(capacity);
len = properties_buf.len().try_into().unwrap();
let result = call(&mut len, properties_buf.as_mut_ptr() as *mut _)?;
properties.set_len(len.try_into().unwrap());
Ok(result)
}
}
#[inline]
pub unsafe fn get_display_mode_properties2<'a>(
&self,
physical_device: PhysicalDevice,
display: DisplayKHR,
mut properties: impl EnumerateInto<DisplayModeProperties2KHR<'a>>,
) -> crate::Result<()> {
unsafe {
let call = |property_count, properties| {
let result = (self.get_display_mode_properties2)(
physical_device,
display,
property_count,
properties 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 properties_buf = properties.reserve(capacity);
len = properties_buf.len().try_into().unwrap();
let result = call(&mut len, properties_buf.as_mut_ptr() as *mut _)?;
properties.set_len(len.try_into().unwrap());
Ok(result)
}
}
#[inline]
pub unsafe fn get_display_plane_capabilities2(
&self,
physical_device: PhysicalDevice,
display_plane_info: &DisplayPlaneInfo2KHR<'_>,
capabilities: &mut DisplayPlaneCapabilities2KHR<'_>,
) -> crate::Result<()> {
unsafe {
let result = (self.get_display_plane_capabilities2)(
physical_device,
display_plane_info,
capabilities,
);
match result {
VkResult::SUCCESS => Ok(()),
err => Err(err),
}
}
}
}