kazan 0.3.9+1.4.359

//! <https://registry.khronos.org/vulkan/specs/latest/man/html/VK_NV_ray_tracing_motion_blur.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_NV_ray_tracing_motion_blur";

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;

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

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

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

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

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

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

        #[inline]
        pub fn ray_tracing_motion_blur_pipeline_trace_rays_indirect(
            mut self,
            ray_tracing_motion_blur_pipeline_trace_rays_indirect: bool,
        ) -> Self {
            self.ray_tracing_motion_blur_pipeline_trace_rays_indirect =
                ray_tracing_motion_blur_pipeline_trace_rays_indirect.into();
            self
        }
    }

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

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

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

    unsafe impl Extends<AccelerationStructureGeometryTrianglesDataKHR<'_>>
        for AccelerationStructureGeometryMotionTrianglesDataNV<'_>
    {
    }

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

    impl<'a> AccelerationStructureGeometryMotionTrianglesDataNV<'a> {
        #[inline]
        pub fn vertex_data(mut self, vertex_data: DeviceOrHostAddressConstKHR<'a>) -> Self {
            self.vertex_data = vertex_data;
            self
        }
    }

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

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

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

    unsafe impl Extends<AccelerationStructureCreateInfoKHR<'_>>
        for AccelerationStructureMotionInfoNV<'_>
    {
    }

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

    impl<'a> AccelerationStructureMotionInfoNV<'a> {
        #[inline]
        pub fn max_instances(mut self, max_instances: u32) -> Self {
            self.max_instances = max_instances;
            self
        }

        #[inline]
        pub fn flags(mut self, flags: AccelerationStructureMotionInfoFlagsNV) -> Self {
            self.flags = flags;
            self
        }
    }

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/VkSRTDataNV.html>
    #[repr(C)]
    #[cfg_attr(feature = "debug", derive(Debug))]
    #[derive(Copy, Clone, Default)]
    #[must_use]
    pub struct SRTDataNV {
        pub sx: f32,
        pub a: f32,
        pub b: f32,
        pub pvx: f32,
        pub sy: f32,
        pub c: f32,
        pub pvy: f32,
        pub sz: f32,
        pub pvz: f32,
        pub qx: f32,
        pub qy: f32,
        pub qz: f32,
        pub qw: f32,
        pub tx: f32,
        pub ty: f32,
        pub tz: f32,
    }

    impl SRTDataNV {
        #[inline]
        pub fn sx(mut self, sx: f32) -> Self {
            self.sx = sx;
            self
        }

        #[inline]
        pub fn a(mut self, a: f32) -> Self {
            self.a = a;
            self
        }

        #[inline]
        pub fn b(mut self, b: f32) -> Self {
            self.b = b;
            self
        }

        #[inline]
        pub fn pvx(mut self, pvx: f32) -> Self {
            self.pvx = pvx;
            self
        }

        #[inline]
        pub fn sy(mut self, sy: f32) -> Self {
            self.sy = sy;
            self
        }

        #[inline]
        pub fn c(mut self, c: f32) -> Self {
            self.c = c;
            self
        }

        #[inline]
        pub fn pvy(mut self, pvy: f32) -> Self {
            self.pvy = pvy;
            self
        }

        #[inline]
        pub fn sz(mut self, sz: f32) -> Self {
            self.sz = sz;
            self
        }

        #[inline]
        pub fn pvz(mut self, pvz: f32) -> Self {
            self.pvz = pvz;
            self
        }

        #[inline]
        pub fn qx(mut self, qx: f32) -> Self {
            self.qx = qx;
            self
        }

        #[inline]
        pub fn qy(mut self, qy: f32) -> Self {
            self.qy = qy;
            self
        }

        #[inline]
        pub fn qz(mut self, qz: f32) -> Self {
            self.qz = qz;
            self
        }

        #[inline]
        pub fn qw(mut self, qw: f32) -> Self {
            self.qw = qw;
            self
        }

        #[inline]
        pub fn tx(mut self, tx: f32) -> Self {
            self.tx = tx;
            self
        }

        #[inline]
        pub fn ty(mut self, ty: f32) -> Self {
            self.ty = ty;
            self
        }

        #[inline]
        pub fn tz(mut self, tz: f32) -> Self {
            self.tz = tz;
            self
        }
    }

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureSRTMotionInstanceNV.html>
    #[repr(C)]
    #[cfg_attr(feature = "debug", derive(Debug))]
    #[derive(Copy, Clone, Default)]
    #[must_use]
    pub struct AccelerationStructureSRTMotionInstanceNV {
        pub transform_t0: SRTDataNV,
        pub transform_t1: SRTDataNV,
        pub _bitfield_0: u32,
        pub _bitfield_1: u32,
        pub acceleration_structure_reference: u64,
    }

    impl AccelerationStructureSRTMotionInstanceNV {
        #[inline]
        pub fn transform_t0(mut self, transform_t0: SRTDataNV) -> Self {
            self.transform_t0 = transform_t0;
            self
        }

        #[inline]
        pub fn transform_t1(mut self, transform_t1: SRTDataNV) -> Self {
            self.transform_t1 = transform_t1;
            self
        }

        #[inline]
        pub fn instance_custom_index(mut self, instance_custom_index: u32) -> Self {
            set_bitfield::<0, 24>(&mut self._bitfield_0, instance_custom_index);
            self
        }

        #[inline]
        pub fn mask(mut self, mask: u32) -> Self {
            set_bitfield::<24, 8>(&mut self._bitfield_0, mask);
            self
        }

        #[inline]
        pub fn instance_shader_binding_table_record_offset(
            mut self,
            instance_shader_binding_table_record_offset: u32,
        ) -> Self {
            set_bitfield::<0, 24>(
                &mut self._bitfield_1,
                instance_shader_binding_table_record_offset,
            );
            self
        }

        #[inline]
        pub fn flags(mut self, flags: GeometryInstanceFlagsKHR) -> Self {
            set_bitfield::<24, 8>(&mut self._bitfield_1, flags.as_raw());
            self
        }

        #[inline]
        pub fn acceleration_structure_reference(
            mut self,
            acceleration_structure_reference: u64,
        ) -> Self {
            self.acceleration_structure_reference = acceleration_structure_reference;
            self
        }
    }

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureMatrixMotionInstanceNV.html>
    #[repr(C)]
    #[cfg_attr(feature = "debug", derive(Debug))]
    #[derive(Copy, Clone)]
    #[must_use]
    pub struct AccelerationStructureMatrixMotionInstanceNV {
        pub transform_t0: TransformMatrixKHR,
        pub transform_t1: TransformMatrixKHR,
        pub _bitfield_0: u32,
        pub _bitfield_1: u32,
        pub acceleration_structure_reference: u64,
    }

    impl Default for AccelerationStructureMatrixMotionInstanceNV {
        fn default() -> Self {
            Self {
                transform_t0: Default::default(),
                transform_t1: Default::default(),
                _bitfield_0: Default::default(),
                _bitfield_1: Default::default(),
                acceleration_structure_reference: Default::default(),
            }
        }
    }

    impl AccelerationStructureMatrixMotionInstanceNV {
        #[inline]
        pub fn transform_t0(mut self, transform_t0: TransformMatrixKHR) -> Self {
            self.transform_t0 = transform_t0;
            self
        }

        #[inline]
        pub fn transform_t1(mut self, transform_t1: TransformMatrixKHR) -> Self {
            self.transform_t1 = transform_t1;
            self
        }

        #[inline]
        pub fn instance_custom_index(mut self, instance_custom_index: u32) -> Self {
            set_bitfield::<0, 24>(&mut self._bitfield_0, instance_custom_index);
            self
        }

        #[inline]
        pub fn mask(mut self, mask: u32) -> Self {
            set_bitfield::<24, 8>(&mut self._bitfield_0, mask);
            self
        }

        #[inline]
        pub fn instance_shader_binding_table_record_offset(
            mut self,
            instance_shader_binding_table_record_offset: u32,
        ) -> Self {
            set_bitfield::<0, 24>(
                &mut self._bitfield_1,
                instance_shader_binding_table_record_offset,
            );
            self
        }

        #[inline]
        pub fn flags(mut self, flags: GeometryInstanceFlagsKHR) -> Self {
            set_bitfield::<24, 8>(&mut self._bitfield_1, flags.as_raw());
            self
        }

        #[inline]
        pub fn acceleration_structure_reference(
            mut self,
            acceleration_structure_reference: u64,
        ) -> Self {
            self.acceleration_structure_reference = acceleration_structure_reference;
            self
        }
    }

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureMotionInstanceNV.html>
    #[repr(C)]
    #[cfg_attr(feature = "debug", derive(Debug))]
    #[derive(Copy, Clone)]
    #[must_use]
    pub struct AccelerationStructureMotionInstanceNV {
        pub ty: AccelerationStructureMotionInstanceTypeNV,
        pub flags: AccelerationStructureMotionInstanceFlagsNV,
        pub data: AccelerationStructureMotionInstanceDataNV,
    }

    impl Default for AccelerationStructureMotionInstanceNV {
        fn default() -> Self {
            Self {
                ty: Default::default(),
                flags: Default::default(),
                data: Default::default(),
            }
        }
    }

    impl AccelerationStructureMotionInstanceNV {
        #[inline]
        pub fn ty(mut self, ty: AccelerationStructureMotionInstanceTypeNV) -> Self {
            self.ty = ty;
            self
        }

        #[inline]
        pub fn flags(mut self, flags: AccelerationStructureMotionInstanceFlagsNV) -> Self {
            self.flags = flags;
            self
        }

        #[inline]
        pub fn data(mut self, data: AccelerationStructureMotionInstanceDataNV) -> Self {
            self.data = data;
            self
        }
    }

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureMotionInstanceDataNV.html>
    #[repr(C)]
    #[derive(Copy, Clone)]
    pub union AccelerationStructureMotionInstanceDataNV {
        pub static_instance: AccelerationStructureInstanceKHR,
        pub matrix_motion_instance: AccelerationStructureMatrixMotionInstanceNV,
        pub srt_motion_instance: AccelerationStructureSRTMotionInstanceNV,
    }

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

    impl Default for AccelerationStructureMotionInstanceDataNV {
        fn default() -> Self {
            unsafe { core::mem::zeroed() }
        }
    }

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureMotionInstanceTypeNV.html>
    #[repr(transparent)]
    #[derive(Copy, Clone, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub struct AccelerationStructureMotionInstanceTypeNV(i32);

    impl AccelerationStructureMotionInstanceTypeNV {
        #[inline]
        pub const fn from_raw(x: i32) -> Self {
            Self(x)
        }
        #[inline]
        pub const fn as_raw(self) -> i32 {
            self.0
        }

        pub const STATIC_NV: Self = Self(0);
        pub const MATRIX_MOTION_NV: Self = Self(1);
        pub const SRT_MOTION_NV: Self = Self(2);
    }

    impl fmt::Debug for AccelerationStructureMotionInstanceTypeNV {
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
            let name = match *self {
                Self::STATIC_NV => Some("STATIC_NV"),
                Self::MATRIX_MOTION_NV => Some("MATRIX_MOTION_NV"),
                Self::SRT_MOTION_NV => Some("SRT_MOTION_NV"),
                _ => None,
            };
            if let Some(name) = name {
                f.write_str(name)
            } else {
                self.0.fmt(f)
            }
        }
    }

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureMotionInfoFlagsNV.html>
    #[repr(transparent)]
    #[derive(Copy, Clone, PartialEq, Eq, Hash)]
    pub struct AccelerationStructureMotionInfoFlagsNV(Flags);
    vk_bitflags_wrapped!(AccelerationStructureMotionInfoFlagsNV, Flags);

    impl fmt::Debug for AccelerationStructureMotionInfoFlagsNV {
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
            debug_flags(f, &[], self.0)
        }
    }

    /// <https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureMotionInstanceFlagsNV.html>
    #[repr(transparent)]
    #[derive(Copy, Clone, PartialEq, Eq, Hash)]
    pub struct AccelerationStructureMotionInstanceFlagsNV(Flags);
    vk_bitflags_wrapped!(AccelerationStructureMotionInstanceFlagsNV, Flags);

    impl fmt::Debug for AccelerationStructureMotionInstanceFlagsNV {
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
            debug_flags(f, &[], self.0)
        }
    }
}

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

    pub type VkPhysicalDeviceRayTracingMotionBlurFeaturesNV =
        PhysicalDeviceRayTracingMotionBlurFeaturesNV<'static>;
    pub type VkAccelerationStructureGeometryMotionTrianglesDataNV =
        AccelerationStructureGeometryMotionTrianglesDataNV<'static>;
    pub type VkAccelerationStructureMotionInfoNV = AccelerationStructureMotionInfoNV<'static>;
    pub type VkSRTDataNV = SRTDataNV;
    pub type VkAccelerationStructureSRTMotionInstanceNV = AccelerationStructureSRTMotionInstanceNV;
    pub type VkAccelerationStructureMatrixMotionInstanceNV =
        AccelerationStructureMatrixMotionInstanceNV;
    pub type VkAccelerationStructureMotionInstanceNV = AccelerationStructureMotionInstanceNV;
    pub type VkAccelerationStructureMotionInstanceDataNV =
        AccelerationStructureMotionInstanceDataNV;
    pub type VkAccelerationStructureMotionInstanceTypeNV =
        AccelerationStructureMotionInstanceTypeNV;
    pub type VkAccelerationStructureMotionInfoFlagsNV = AccelerationStructureMotionInfoFlagsNV;
    pub type VkAccelerationStructureMotionInstanceFlagsNV =
        AccelerationStructureMotionInstanceFlagsNV;
    impl PhysicalDeviceRayTracingMotionBlurFeaturesNV<'_> {
        #[inline]
        pub unsafe fn drop_lifetime_for_ffi(
            &self,
        ) -> &VkPhysicalDeviceRayTracingMotionBlurFeaturesNV {
            unsafe { core::mem::transmute(self) }
        }
    }
    impl AccelerationStructureGeometryMotionTrianglesDataNV<'_> {
        #[inline]
        pub unsafe fn drop_lifetime_for_ffi(
            &self,
        ) -> &VkAccelerationStructureGeometryMotionTrianglesDataNV {
            unsafe { core::mem::transmute(self) }
        }
    }
    impl AccelerationStructureMotionInfoNV<'_> {
        #[inline]
        pub unsafe fn drop_lifetime_for_ffi(&self) -> &VkAccelerationStructureMotionInfoNV {
            unsafe { core::mem::transmute(self) }
        }
    }
}