#![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_device_fault";
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;
pub type DeviceFaultVendorBinaryHeaderVersionEXT = DeviceFaultVendorBinaryHeaderVersionKHR;
pub type DeviceFaultAddressTypeEXT = DeviceFaultAddressTypeKHR;
pub type DeviceFaultAddressInfoEXT = DeviceFaultAddressInfoKHR;
pub type DeviceFaultVendorInfoEXT = DeviceFaultVendorInfoKHR;
pub type DeviceFaultVendorBinaryHeaderVersionOneEXT =
DeviceFaultVendorBinaryHeaderVersionOneKHR;
#[repr(C)]
#[derive(Copy, Clone)]
#[must_use]
pub struct PhysicalDeviceFaultFeaturesEXT<'a> {
pub s_type: StructureType,
pub p_next: *mut c_void,
pub device_fault: Bool32,
pub device_fault_vendor_binary: Bool32,
pub _marker: PhantomData<&'a ()>,
}
#[cfg(feature = "debug")]
impl fmt::Debug for PhysicalDeviceFaultFeaturesEXT<'_> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("PhysicalDeviceFaultFeaturesEXT")
.field("s_type", &self.s_type)
.field("p_next", &self.p_next)
.field("device_fault", &self.device_fault)
.field(
"device_fault_vendor_binary",
&self.device_fault_vendor_binary,
)
.finish()
}
}
unsafe impl<'a> TaggedStructure<'a> for PhysicalDeviceFaultFeaturesEXT<'a> {
const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_FAULT_FEATURES_EXT;
}
unsafe impl Extends<PhysicalDeviceFeatures2<'_>> for PhysicalDeviceFaultFeaturesEXT<'_> {}
unsafe impl Extends<DeviceCreateInfo<'_>> for PhysicalDeviceFaultFeaturesEXT<'_> {}
impl Default for PhysicalDeviceFaultFeaturesEXT<'_> {
fn default() -> Self {
Self {
s_type: Self::STRUCTURE_TYPE,
p_next: ptr::null_mut(),
device_fault: Default::default(),
device_fault_vendor_binary: Default::default(),
_marker: PhantomData,
}
}
}
impl<'a> PhysicalDeviceFaultFeaturesEXT<'a> {
#[inline]
pub fn device_fault(mut self, device_fault: bool) -> Self {
self.device_fault = device_fault.into();
self
}
#[inline]
pub fn device_fault_vendor_binary(mut self, device_fault_vendor_binary: bool) -> Self {
self.device_fault_vendor_binary = device_fault_vendor_binary.into();
self
}
}
#[repr(C)]
#[derive(Copy, Clone)]
#[must_use]
pub struct DeviceFaultCountsEXT<'a> {
pub s_type: StructureType,
pub p_next: *mut c_void,
pub address_info_count: u32,
pub vendor_info_count: u32,
pub vendor_binary_size: DeviceSize,
pub _marker: PhantomData<&'a ()>,
}
#[cfg(feature = "debug")]
impl fmt::Debug for DeviceFaultCountsEXT<'_> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("DeviceFaultCountsEXT")
.field("s_type", &self.s_type)
.field("p_next", &self.p_next)
.field("address_info_count", &self.address_info_count)
.field("vendor_info_count", &self.vendor_info_count)
.field("vendor_binary_size", &self.vendor_binary_size)
.finish()
}
}
unsafe impl<'a> TaggedStructure<'a> for DeviceFaultCountsEXT<'a> {
const STRUCTURE_TYPE: StructureType = StructureType::DEVICE_FAULT_COUNTS_EXT;
}
impl Default for DeviceFaultCountsEXT<'_> {
fn default() -> Self {
Self {
s_type: Self::STRUCTURE_TYPE,
p_next: ptr::null_mut(),
address_info_count: Default::default(),
vendor_info_count: Default::default(),
vendor_binary_size: Default::default(),
_marker: PhantomData,
}
}
}
impl<'a> DeviceFaultCountsEXT<'a> {
#[inline]
pub fn address_info_count(mut self, address_info_count: u32) -> Self {
self.address_info_count = address_info_count;
self
}
#[inline]
pub fn vendor_info_count(mut self, vendor_info_count: u32) -> Self {
self.vendor_info_count = vendor_info_count;
self
}
#[inline]
pub fn vendor_binary_size(mut self, vendor_binary_size: DeviceSize) -> Self {
self.vendor_binary_size = vendor_binary_size;
self
}
}
#[repr(C)]
#[derive(Copy, Clone)]
#[must_use]
pub struct DeviceFaultInfoEXT<'a> {
pub s_type: StructureType,
pub p_next: *mut c_void,
pub description: ArrayCStr<{ MAX_DESCRIPTION_SIZE as usize }>,
pub p_address_infos: *mut DeviceFaultAddressInfoKHR,
pub p_vendor_infos: *mut DeviceFaultVendorInfoKHR,
pub p_vendor_binary_data: *mut c_void,
pub _marker: PhantomData<&'a ()>,
}
#[cfg(feature = "debug")]
impl fmt::Debug for DeviceFaultInfoEXT<'_> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("DeviceFaultInfoEXT")
.field("s_type", &self.s_type)
.field("p_next", &self.p_next)
.field("description", &self.description)
.field("p_address_infos", &self.p_address_infos)
.field("p_vendor_infos", &self.p_vendor_infos)
.field("p_vendor_binary_data", &self.p_vendor_binary_data)
.finish()
}
}
unsafe impl<'a> TaggedStructure<'a> for DeviceFaultInfoEXT<'a> {
const STRUCTURE_TYPE: StructureType = StructureType::DEVICE_FAULT_INFO_EXT;
}
impl Default for DeviceFaultInfoEXT<'_> {
fn default() -> Self {
Self {
s_type: Self::STRUCTURE_TYPE,
p_next: ptr::null_mut(),
description: Default::default(),
p_address_infos: ptr::null_mut(),
p_vendor_infos: ptr::null_mut(),
p_vendor_binary_data: ptr::null_mut(),
_marker: PhantomData,
}
}
}
impl<'a> DeviceFaultInfoEXT<'a> {
#[inline]
pub fn description(
mut self,
description: &CStr,
) -> core::result::Result<Self, CStrTooLargeForStaticArray> {
self.description.write_c_str(description)?;
Ok(self)
}
#[inline]
pub fn address_infos(mut self, address_infos: &'a mut DeviceFaultAddressInfoKHR) -> Self {
self.p_address_infos = address_infos;
self
}
#[inline]
pub fn vendor_infos(mut self, vendor_infos: &'a mut DeviceFaultVendorInfoKHR) -> Self {
self.p_vendor_infos = vendor_infos;
self
}
#[inline]
pub fn vendor_binary_data(mut self, vendor_binary_data: *mut c_void) -> Self {
self.p_vendor_binary_data = vendor_binary_data;
self
}
}
pub type PFN_vkGetDeviceFaultInfoEXT = unsafe extern "system" fn(
device: Device,
p_fault_counts: *mut DeviceFaultCountsEXT<'_>,
p_fault_info: *mut DeviceFaultInfoEXT<'_>,
) -> vk::Result;
}
#[cfg(feature = "ffi")]
pub(super) mod ffi {
#![allow(non_camel_case_types)]
use super::defs::*;
pub type VkPhysicalDeviceFaultFeaturesEXT = PhysicalDeviceFaultFeaturesEXT<'static>;
pub type VkDeviceFaultCountsEXT = DeviceFaultCountsEXT<'static>;
pub type VkDeviceFaultInfoEXT = DeviceFaultInfoEXT<'static>;
pub type VkDeviceFaultVendorBinaryHeaderVersionEXT = DeviceFaultVendorBinaryHeaderVersionEXT;
pub type VkDeviceFaultAddressTypeEXT = DeviceFaultAddressTypeEXT;
pub type VkDeviceFaultAddressInfoEXT = DeviceFaultAddressInfoEXT;
pub type VkDeviceFaultVendorInfoEXT = DeviceFaultVendorInfoEXT;
pub type VkDeviceFaultVendorBinaryHeaderVersionOneEXT =
DeviceFaultVendorBinaryHeaderVersionOneEXT;
impl PhysicalDeviceFaultFeaturesEXT<'_> {
#[inline]
pub unsafe fn drop_lifetime_for_ffi(&self) -> &VkPhysicalDeviceFaultFeaturesEXT {
unsafe { core::mem::transmute(self) }
}
}
impl DeviceFaultCountsEXT<'_> {
#[inline]
pub unsafe fn drop_lifetime_for_ffi(&self) -> &VkDeviceFaultCountsEXT {
unsafe { core::mem::transmute(self) }
}
}
impl DeviceFaultInfoEXT<'_> {
#[inline]
pub unsafe fn drop_lifetime_for_ffi(&self) -> &VkDeviceFaultInfoEXT {
unsafe { core::mem::transmute(self) }
}
}
}
pub struct DeviceFn {
get_device_fault_info: PFN_vkGetDeviceFaultInfoEXT,
}
impl LoadDeviceFn for DeviceFn {
unsafe fn load_with(
load: impl Fn(&CStr) -> Option<PFN_vkVoidFunction>,
) -> core::result::Result<Self, MissingEntryPointError> {
unsafe {
Ok(Self {
get_device_fault_info: transmute(
load(c"vkGetDeviceFaultInfoEXT").ok_or(MissingEntryPointError)?,
),
})
}
}
}
impl DeviceFn {
#[inline]
pub unsafe fn get_device_fault_info(
&self,
device: Device,
fault_counts: &mut DeviceFaultCountsEXT<'_>,
fault_info: Option<&mut DeviceFaultInfoEXT<'_>>,
) -> crate::Result<()> {
unsafe {
let result =
(self.get_device_fault_info)(device, fault_counts, fault_info.to_raw_mut_ptr());
match result {
VkResult::SUCCESS => Ok(()),
err => Err(err),
}
}
}
}