kazan 0.3.9+1.4.359

//! <https://registry.khronos.org/vulkan/specs/latest/man/html/VK_EXT_shader_module_identifier.html>
#![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_shader_module_identifier";

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 const MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT: u32 = 32;

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT.html>
    #[repr(C)]
    #[derive(Copy, Clone)]
    #[must_use]
    pub struct PhysicalDeviceShaderModuleIdentifierFeaturesEXT<'a> {
        pub s_type: StructureType,
        pub p_next: *mut c_void,
        pub shader_module_identifier: Bool32,
        pub _marker: PhantomData<&'a ()>,
    }

    #[cfg(feature = "debug")]
    impl fmt::Debug for PhysicalDeviceShaderModuleIdentifierFeaturesEXT<'_> {
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
            f.debug_struct("PhysicalDeviceShaderModuleIdentifierFeaturesEXT")
                .field("s_type", &self.s_type)
                .field("p_next", &self.p_next)
                .field("shader_module_identifier", &self.shader_module_identifier)
                .finish()
        }
    }

    unsafe impl<'a> TaggedStructure<'a> for PhysicalDeviceShaderModuleIdentifierFeaturesEXT<'a> {
        const STRUCTURE_TYPE: StructureType =
            StructureType::PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT;
    }

    unsafe impl Extends<PhysicalDeviceFeatures2<'_>>
        for PhysicalDeviceShaderModuleIdentifierFeaturesEXT<'_>
    {
    }
    unsafe impl Extends<DeviceCreateInfo<'_>> for PhysicalDeviceShaderModuleIdentifierFeaturesEXT<'_> {}

    impl Default for PhysicalDeviceShaderModuleIdentifierFeaturesEXT<'_> {
        fn default() -> Self {
            Self {
                s_type: Self::STRUCTURE_TYPE,
                p_next: ptr::null_mut(),
                shader_module_identifier: Default::default(),
                _marker: PhantomData,
            }
        }
    }

    impl<'a> PhysicalDeviceShaderModuleIdentifierFeaturesEXT<'a> {
        #[inline]
        pub fn shader_module_identifier(mut self, shader_module_identifier: bool) -> Self {
            self.shader_module_identifier = shader_module_identifier.into();
            self
        }
    }

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT.html>
    #[repr(C)]
    #[derive(Copy, Clone)]
    #[must_use]
    pub struct PhysicalDeviceShaderModuleIdentifierPropertiesEXT<'a> {
        pub s_type: StructureType,
        pub p_next: *mut c_void,
        pub shader_module_identifier_algorithm_uuid: [u8; UUID_SIZE as usize],
        pub _marker: PhantomData<&'a ()>,
    }

    #[cfg(feature = "debug")]
    impl fmt::Debug for PhysicalDeviceShaderModuleIdentifierPropertiesEXT<'_> {
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
            f.debug_struct("PhysicalDeviceShaderModuleIdentifierPropertiesEXT")
                .field("s_type", &self.s_type)
                .field("p_next", &self.p_next)
                .field(
                    "shader_module_identifier_algorithm_uuid",
                    &self.shader_module_identifier_algorithm_uuid,
                )
                .finish()
        }
    }

    unsafe impl<'a> TaggedStructure<'a> for PhysicalDeviceShaderModuleIdentifierPropertiesEXT<'a> {
        const STRUCTURE_TYPE: StructureType =
            StructureType::PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT;
    }

    unsafe impl Extends<PhysicalDeviceProperties2<'_>>
        for PhysicalDeviceShaderModuleIdentifierPropertiesEXT<'_>
    {
    }

    impl Default for PhysicalDeviceShaderModuleIdentifierPropertiesEXT<'_> {
        fn default() -> Self {
            Self {
                s_type: Self::STRUCTURE_TYPE,
                p_next: ptr::null_mut(),
                shader_module_identifier_algorithm_uuid: [Default::default(); _],
                _marker: PhantomData,
            }
        }
    }

    impl<'a> PhysicalDeviceShaderModuleIdentifierPropertiesEXT<'a> {
        #[inline]
        pub fn shader_module_identifier_algorithm_uuid(
            mut self,
            shader_module_identifier_algorithm_uuid: [u8; UUID_SIZE as usize],
        ) -> Self {
            self.shader_module_identifier_algorithm_uuid = shader_module_identifier_algorithm_uuid;
            self
        }
    }

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineShaderStageModuleIdentifierCreateInfoEXT.html>
    #[repr(C)]
    #[derive(Copy, Clone)]
    #[must_use]
    pub struct PipelineShaderStageModuleIdentifierCreateInfoEXT<'a> {
        pub s_type: StructureType,
        pub p_next: *const c_void,
        pub identifier_size: u32,
        pub p_identifier: *const u8,
        pub _marker: PhantomData<&'a ()>,
    }

    #[cfg(feature = "debug")]
    impl fmt::Debug for PipelineShaderStageModuleIdentifierCreateInfoEXT<'_> {
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
            f.debug_struct("PipelineShaderStageModuleIdentifierCreateInfoEXT")
                .field("s_type", &self.s_type)
                .field("p_next", &self.p_next)
                .field("identifier_size", &self.identifier_size)
                .field("p_identifier", &self.p_identifier)
                .finish()
        }
    }

    unsafe impl<'a> TaggedStructure<'a> for PipelineShaderStageModuleIdentifierCreateInfoEXT<'a> {
        const STRUCTURE_TYPE: StructureType =
            StructureType::PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT;
    }

    unsafe impl Extends<PipelineShaderStageCreateInfo<'_>>
        for PipelineShaderStageModuleIdentifierCreateInfoEXT<'_>
    {
    }

    impl Default for PipelineShaderStageModuleIdentifierCreateInfoEXT<'_> {
        fn default() -> Self {
            Self {
                s_type: Self::STRUCTURE_TYPE,
                p_next: ptr::null(),
                identifier_size: Default::default(),
                p_identifier: ptr::null(),
                _marker: PhantomData,
            }
        }
    }

    impl<'a> PipelineShaderStageModuleIdentifierCreateInfoEXT<'a> {
        #[inline]
        pub fn identifier(mut self, identifier: &'a [u8]) -> Self {
            self.identifier_size = identifier.len().try_into().unwrap();
            self.p_identifier = identifier.as_ptr() as _;
            self
        }
    }

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/VkShaderModuleIdentifierEXT.html>
    #[repr(C)]
    #[derive(Copy, Clone)]
    #[must_use]
    pub struct ShaderModuleIdentifierEXT<'a> {
        pub s_type: StructureType,
        pub p_next: *mut c_void,
        pub identifier_size: u32,
        pub identifier: [u8; MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT as usize],
        pub _marker: PhantomData<&'a ()>,
    }

    #[cfg(feature = "debug")]
    impl fmt::Debug for ShaderModuleIdentifierEXT<'_> {
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
            f.debug_struct("ShaderModuleIdentifierEXT")
                .field("s_type", &self.s_type)
                .field("p_next", &self.p_next)
                .field("identifier_size", &self.identifier_size)
                .field("identifier", &self.identifier)
                .finish()
        }
    }

    unsafe impl<'a> TaggedStructure<'a> for ShaderModuleIdentifierEXT<'a> {
        const STRUCTURE_TYPE: StructureType = StructureType::SHADER_MODULE_IDENTIFIER_EXT;
    }

    impl Default for ShaderModuleIdentifierEXT<'_> {
        fn default() -> Self {
            Self {
                s_type: Self::STRUCTURE_TYPE,
                p_next: ptr::null_mut(),
                identifier_size: Default::default(),
                identifier: [Default::default(); _],
                _marker: PhantomData,
            }
        }
    }

    impl<'a> ShaderModuleIdentifierEXT<'a> {
        #[inline]
        pub fn identifier(mut self, identifier: &[u8]) -> Self {
            self.identifier_size = identifier.len().try_into().unwrap();
            self.identifier[..identifier.len()].copy_from_slice(identifier);
            self
        }
    }

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetShaderModuleIdentifierEXT.html>
    pub type PFN_vkGetShaderModuleIdentifierEXT = unsafe extern "system" fn(
        device: Device,
        shader_module: ShaderModule,
        p_identifier: *mut ShaderModuleIdentifierEXT<'_>,
    );
    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetShaderModuleCreateInfoIdentifierEXT.html>
    pub type PFN_vkGetShaderModuleCreateInfoIdentifierEXT = unsafe extern "system" fn(
        device: Device,
        p_create_info: *const ShaderModuleCreateInfo<'_>,
        p_identifier: *mut ShaderModuleIdentifierEXT<'_>,
    );
}

#[cfg(feature = "ffi")]
pub(super) mod ffi {
    #![allow(non_camel_case_types)]
    use super::defs::*;

    pub type VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT =
        PhysicalDeviceShaderModuleIdentifierFeaturesEXT<'static>;
    pub type VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT =
        PhysicalDeviceShaderModuleIdentifierPropertiesEXT<'static>;
    pub type VkPipelineShaderStageModuleIdentifierCreateInfoEXT =
        PipelineShaderStageModuleIdentifierCreateInfoEXT<'static>;
    pub type VkShaderModuleIdentifierEXT = ShaderModuleIdentifierEXT<'static>;
    impl PhysicalDeviceShaderModuleIdentifierFeaturesEXT<'_> {
        #[inline]
        pub unsafe fn drop_lifetime_for_ffi(
            &self,
        ) -> &VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT {
            unsafe { core::mem::transmute(self) }
        }
    }
    impl PhysicalDeviceShaderModuleIdentifierPropertiesEXT<'_> {
        #[inline]
        pub unsafe fn drop_lifetime_for_ffi(
            &self,
        ) -> &VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT {
            unsafe { core::mem::transmute(self) }
        }
    }
    impl PipelineShaderStageModuleIdentifierCreateInfoEXT<'_> {
        #[inline]
        pub unsafe fn drop_lifetime_for_ffi(
            &self,
        ) -> &VkPipelineShaderStageModuleIdentifierCreateInfoEXT {
            unsafe { core::mem::transmute(self) }
        }
    }
    impl ShaderModuleIdentifierEXT<'_> {
        #[inline]
        pub unsafe fn drop_lifetime_for_ffi(&self) -> &VkShaderModuleIdentifierEXT {
            unsafe { core::mem::transmute(self) }
        }
    }
}

pub struct DeviceFn {
    get_shader_module_identifier: PFN_vkGetShaderModuleIdentifierEXT,
    get_shader_module_create_info_identifier: PFN_vkGetShaderModuleCreateInfoIdentifierEXT,
}

impl LoadDeviceFn for DeviceFn {
    unsafe fn load_with(
        load: impl Fn(&CStr) -> Option<PFN_vkVoidFunction>,
    ) -> core::result::Result<Self, MissingEntryPointError> {
        unsafe {
            Ok(Self {
                get_shader_module_identifier: transmute(
                    load(c"vkGetShaderModuleIdentifierEXT").ok_or(MissingEntryPointError)?,
                ),
                get_shader_module_create_info_identifier: transmute(
                    load(c"vkGetShaderModuleCreateInfoIdentifierEXT")
                        .ok_or(MissingEntryPointError)?,
                ),
            })
        }
    }
}

impl DeviceFn {
    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetShaderModuleIdentifierEXT.html>
    #[inline]
    pub unsafe fn get_shader_module_identifier(
        &self,
        device: Device,
        shader_module: ShaderModule,
        identifier: &mut ShaderModuleIdentifierEXT<'_>,
    ) {
        unsafe { (self.get_shader_module_identifier)(device, shader_module, identifier) }
    }

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetShaderModuleCreateInfoIdentifierEXT.html>
    #[inline]
    pub unsafe fn get_shader_module_create_info_identifier(
        &self,
        device: Device,
        create_info: &ShaderModuleCreateInfo<'_>,
        identifier: &mut ShaderModuleIdentifierEXT<'_>,
    ) {
        unsafe { (self.get_shader_module_create_info_identifier)(device, create_info, identifier) }
    }
}