#[doc = "<s>Vulkan Manual Page</s> · Constant"]
#[doc(alias = "VK_NV_DEVICE_GENERATED_COMMANDS_SPEC_VERSION")]
pub const NV_DEVICE_GENERATED_COMMANDS_SPEC_VERSION: u32 = 3;
#[doc = "<s>Vulkan Manual Page</s> · Constant"]
#[doc(alias = "VK_NV_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME")]
pub const NV_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME: *const std::os::raw::c_char =
    crate::cstr!("VK_NV_device_generated_commands");
#[doc = "<s>Vulkan Manual Page</s> · Constant"]
pub const FN_CMD_EXECUTE_GENERATED_COMMANDS_NV: *const std::os::raw::c_char =
    crate::cstr!("vkCmdExecuteGeneratedCommandsNV");
#[doc = "<s>Vulkan Manual Page</s> · Constant"]
pub const FN_CMD_PREPROCESS_GENERATED_COMMANDS_NV: *const std::os::raw::c_char =
    crate::cstr!("vkCmdPreprocessGeneratedCommandsNV");
#[doc = "<s>Vulkan Manual Page</s> · Constant"]
pub const FN_CMD_BIND_PIPELINE_SHADER_GROUP_NV: *const std::os::raw::c_char =
    crate::cstr!("vkCmdBindPipelineShaderGroupNV");
#[doc = "<s>Vulkan Manual Page</s> · Constant"]
pub const FN_GET_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_NV: *const std::os::raw::c_char =
    crate::cstr!("vkGetGeneratedCommandsMemoryRequirementsNV");
#[doc = "<s>Vulkan Manual Page</s> · Constant"]
pub const FN_CREATE_INDIRECT_COMMANDS_LAYOUT_NV: *const std::os::raw::c_char =
    crate::cstr!("vkCreateIndirectCommandsLayoutNV");
#[doc = "<s>Vulkan Manual Page</s> · Constant"]
pub const FN_DESTROY_INDIRECT_COMMANDS_LAYOUT_NV: *const std::os::raw::c_char =
    crate::cstr!("vkDestroyIndirectCommandsLayoutNV");
crate :: non_dispatchable_handle ! (IndirectCommandsLayoutNV , INDIRECT_COMMANDS_LAYOUT_NV , "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkIndirectCommandsLayoutNV.html) · Non-dispatchable Handle" , "VkIndirectCommandsLayoutNV") ;
bitflags::bitflags! { # [doc = "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkIndirectCommandsLayoutUsageFlagsNV.html) · Bitmask of [`IndirectCommandsLayoutUsageFlagBitsNV`]"] # [doc (alias = "VkIndirectCommandsLayoutUsageFlagsNV")] # [derive (Default)] # [repr (transparent)] pub struct IndirectCommandsLayoutUsageFlagsNV : u32 { # [cfg (empty_bitflag_workaround)] const EMPTY_BITFLAG_WORKAROUND = 0 ; const EXPLICIT_PREPROCESS_NV = IndirectCommandsLayoutUsageFlagBitsNV :: EXPLICIT_PREPROCESS_NV . 0 ; const INDEXED_SEQUENCES_NV = IndirectCommandsLayoutUsageFlagBitsNV :: INDEXED_SEQUENCES_NV . 0 ; const UNORDERED_SEQUENCES_NV = IndirectCommandsLayoutUsageFlagBitsNV :: UNORDERED_SEQUENCES_NV . 0 ; } }
#[doc = "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkIndirectCommandsLayoutUsageFlagBitsNV.html) · Bits enum of [`IndirectCommandsLayoutUsageFlagsNV`]"]
#[doc(alias = "VkIndirectCommandsLayoutUsageFlagBitsNV")]
#[derive(Copy, Clone, PartialEq, Eq, Hash, Default, Ord, PartialOrd)]
#[repr(transparent)]
pub struct IndirectCommandsLayoutUsageFlagBitsNV(pub u32);
impl IndirectCommandsLayoutUsageFlagBitsNV {
    #[inline]
    #[doc = "Converts this enum variant to the corresponding bitmask"]
    pub const fn bitmask(&self) -> IndirectCommandsLayoutUsageFlagsNV {
        IndirectCommandsLayoutUsageFlagsNV::from_bits_truncate(self.0)
    }
}
impl std::fmt::Debug for IndirectCommandsLayoutUsageFlagBitsNV {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        f.write_str(match self {
            &Self::EXPLICIT_PREPROCESS_NV => "EXPLICIT_PREPROCESS_NV",
            &Self::INDEXED_SEQUENCES_NV => "INDEXED_SEQUENCES_NV",
            &Self::UNORDERED_SEQUENCES_NV => "UNORDERED_SEQUENCES_NV",
            _ => "(unknown variant)",
        })
    }
}
#[doc = "Provided by [`crate::extensions::nv_device_generated_commands`]"]
impl IndirectCommandsLayoutUsageFlagBitsNV {
    pub const EXPLICIT_PREPROCESS_NV: Self = Self(1);
    pub const INDEXED_SEQUENCES_NV: Self = Self(2);
    pub const UNORDERED_SEQUENCES_NV: Self = Self(4);
}
#[doc = "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkIndirectCommandsTokenTypeNV.html) · Enum"]
#[doc(alias = "VkIndirectCommandsTokenTypeNV")]
#[derive(Copy, Clone, PartialEq, Eq, Hash, Default, Ord, PartialOrd)]
#[repr(transparent)]
pub struct IndirectCommandsTokenTypeNV(pub i32);
impl std::fmt::Debug for IndirectCommandsTokenTypeNV {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        f.write_str(match self {
            &Self::SHADER_GROUP_NV => "SHADER_GROUP_NV",
            &Self::STATE_FLAGS_NV => "STATE_FLAGS_NV",
            &Self::INDEX_BUFFER_NV => "INDEX_BUFFER_NV",
            &Self::VERTEX_BUFFER_NV => "VERTEX_BUFFER_NV",
            &Self::PUSH_CONSTANT_NV => "PUSH_CONSTANT_NV",
            &Self::DRAW_INDEXED_NV => "DRAW_INDEXED_NV",
            &Self::DRAW_NV => "DRAW_NV",
            &Self::DRAW_TASKS_NV => "DRAW_TASKS_NV",
            _ => "(unknown variant)",
        })
    }
}
#[doc = "Provided by [`crate::extensions::nv_device_generated_commands`]"]
impl IndirectCommandsTokenTypeNV {
    pub const SHADER_GROUP_NV: Self = Self(0);
    pub const STATE_FLAGS_NV: Self = Self(1);
    pub const INDEX_BUFFER_NV: Self = Self(2);
    pub const VERTEX_BUFFER_NV: Self = Self(3);
    pub const PUSH_CONSTANT_NV: Self = Self(4);
    pub const DRAW_INDEXED_NV: Self = Self(5);
    pub const DRAW_NV: Self = Self(6);
    pub const DRAW_TASKS_NV: Self = Self(7);
}
bitflags::bitflags! { # [doc = "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkIndirectStateFlagsNV.html) · Bitmask of [`IndirectStateFlagBitsNV`]"] # [doc (alias = "VkIndirectStateFlagsNV")] # [derive (Default)] # [repr (transparent)] pub struct IndirectStateFlagsNV : u32 { # [cfg (empty_bitflag_workaround)] const EMPTY_BITFLAG_WORKAROUND = 0 ; const FLAG_FRONTFACE_NV = IndirectStateFlagBitsNV :: FLAG_FRONTFACE_NV . 0 ; } }
#[doc = "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkIndirectStateFlagBitsNV.html) · Bits enum of [`IndirectStateFlagsNV`]"]
#[doc(alias = "VkIndirectStateFlagBitsNV")]
#[derive(Copy, Clone, PartialEq, Eq, Hash, Default, Ord, PartialOrd)]
#[repr(transparent)]
pub struct IndirectStateFlagBitsNV(pub u32);
impl IndirectStateFlagBitsNV {
    #[inline]
    #[doc = "Converts this enum variant to the corresponding bitmask"]
    pub const fn bitmask(&self) -> IndirectStateFlagsNV {
        IndirectStateFlagsNV::from_bits_truncate(self.0)
    }
}
impl std::fmt::Debug for IndirectStateFlagBitsNV {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        f.write_str(match self {
            &Self::FLAG_FRONTFACE_NV => "FLAG_FRONTFACE_NV",
            _ => "(unknown variant)",
        })
    }
}
#[doc = "Provided by [`crate::extensions::nv_device_generated_commands`]"]
impl IndirectStateFlagBitsNV {
    pub const FLAG_FRONTFACE_NV: Self = Self(1);
}
#[doc = "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdExecuteGeneratedCommandsNV.html) · Function"]
#[allow(non_camel_case_types)]
pub type PFN_vkCmdExecuteGeneratedCommandsNV = unsafe extern "system" fn (command_buffer : crate :: vk1_0 :: CommandBuffer , is_preprocessed : crate :: vk1_0 :: Bool32 , p_generated_commands_info : * const crate :: extensions :: nv_device_generated_commands :: GeneratedCommandsInfoNV) -> () ;
#[doc = "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdPreprocessGeneratedCommandsNV.html) · Function"]
#[allow(non_camel_case_types)]
pub type PFN_vkCmdPreprocessGeneratedCommandsNV = unsafe extern "system" fn (command_buffer : crate :: vk1_0 :: CommandBuffer , p_generated_commands_info : * const crate :: extensions :: nv_device_generated_commands :: GeneratedCommandsInfoNV) -> () ;
#[doc = "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdBindPipelineShaderGroupNV.html) · Function"]
#[allow(non_camel_case_types)]
pub type PFN_vkCmdBindPipelineShaderGroupNV = unsafe extern "system" fn(
    command_buffer: crate::vk1_0::CommandBuffer,
    pipeline_bind_point: crate::vk1_0::PipelineBindPoint,
    pipeline: crate::vk1_0::Pipeline,
    group_index: u32,
) -> ();
#[doc = "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetGeneratedCommandsMemoryRequirementsNV.html) · Function"]
#[allow(non_camel_case_types)]
pub type PFN_vkGetGeneratedCommandsMemoryRequirementsNV = unsafe extern "system" fn (device : crate :: vk1_0 :: Device , p_info : * const crate :: extensions :: nv_device_generated_commands :: GeneratedCommandsMemoryRequirementsInfoNV , p_memory_requirements : * mut crate :: vk1_1 :: MemoryRequirements2) -> () ;
#[doc = "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateIndirectCommandsLayoutNV.html) · Function"]
#[allow(non_camel_case_types)]
pub type PFN_vkCreateIndirectCommandsLayoutNV = unsafe extern "system" fn (device : crate :: vk1_0 :: Device , p_create_info : * const crate :: extensions :: nv_device_generated_commands :: IndirectCommandsLayoutCreateInfoNV , p_allocator : * const crate :: vk1_0 :: AllocationCallbacks , p_indirect_commands_layout : * mut crate :: extensions :: nv_device_generated_commands :: IndirectCommandsLayoutNV) -> crate :: vk1_0 :: Result ;
#[doc = "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDestroyIndirectCommandsLayoutNV.html) · Function"]
#[allow(non_camel_case_types)]
pub type PFN_vkDestroyIndirectCommandsLayoutNV = unsafe extern "system" fn (device : crate :: vk1_0 :: Device , indirect_commands_layout : crate :: extensions :: nv_device_generated_commands :: IndirectCommandsLayoutNV , p_allocator : * const crate :: vk1_0 :: AllocationCallbacks) -> () ;
#[doc = "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV.html) · Structure"]
#[doc(alias = "VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV")]
#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhysicalDeviceDeviceGeneratedCommandsFeaturesNV {
    pub s_type: crate::vk1_0::StructureType,
    pub p_next: *mut std::ffi::c_void,
    pub device_generated_commands: crate::vk1_0::Bool32,
}
impl Default for PhysicalDeviceDeviceGeneratedCommandsFeaturesNV {
    fn default() -> Self {
        Self {
            s_type:
                crate::vk1_0::StructureType::PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV,
            p_next: std::ptr::null_mut(),
            device_generated_commands: Default::default(),
        }
    }
}
impl std::fmt::Debug for PhysicalDeviceDeviceGeneratedCommandsFeaturesNV {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        f.debug_struct("PhysicalDeviceDeviceGeneratedCommandsFeaturesNV")
            .field("s_type", &self.s_type)
            .field("p_next", &self.p_next)
            .field(
                "device_generated_commands",
                &(self.device_generated_commands != 0),
            )
            .finish()
    }
}
impl PhysicalDeviceDeviceGeneratedCommandsFeaturesNV {
    #[inline]
    pub fn into_builder<'a>(self) -> PhysicalDeviceDeviceGeneratedCommandsFeaturesNVBuilder<'a> {
        PhysicalDeviceDeviceGeneratedCommandsFeaturesNVBuilder(self, std::marker::PhantomData)
    }
}
#[derive(Copy, Clone)]
#[doc = "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV.html) · Builder of [`PhysicalDeviceDeviceGeneratedCommandsFeaturesNV`]"]
#[repr(transparent)]
pub struct PhysicalDeviceDeviceGeneratedCommandsFeaturesNVBuilder<'a>(
    PhysicalDeviceDeviceGeneratedCommandsFeaturesNV,
    std::marker::PhantomData<&'a ()>,
);
impl<'a> PhysicalDeviceDeviceGeneratedCommandsFeaturesNVBuilder<'a> {
    #[inline]
    pub fn new() -> PhysicalDeviceDeviceGeneratedCommandsFeaturesNVBuilder<'a> {
        PhysicalDeviceDeviceGeneratedCommandsFeaturesNVBuilder(
            Default::default(),
            std::marker::PhantomData,
        )
    }
    #[inline]
    pub fn device_generated_commands(mut self, device_generated_commands: bool) -> Self {
        self.0.device_generated_commands = device_generated_commands as _;
        self
    }
    #[inline]
    #[doc = "Discards all lifetime information. Use the `Deref` and `DerefMut` implementations if possible."]
    pub fn build(self) -> PhysicalDeviceDeviceGeneratedCommandsFeaturesNV {
        self.0
    }
}
impl<'a> std::default::Default for PhysicalDeviceDeviceGeneratedCommandsFeaturesNVBuilder<'a> {
    fn default() -> PhysicalDeviceDeviceGeneratedCommandsFeaturesNVBuilder<'a> {
        Self::new()
    }
}
impl<'a> std::fmt::Debug for PhysicalDeviceDeviceGeneratedCommandsFeaturesNVBuilder<'a> {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        std::fmt::Debug::fmt(&self.0, f)
    }
}
impl<'a> std::ops::Deref for PhysicalDeviceDeviceGeneratedCommandsFeaturesNVBuilder<'a> {
    type Target = PhysicalDeviceDeviceGeneratedCommandsFeaturesNV;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
impl<'a> std::ops::DerefMut for PhysicalDeviceDeviceGeneratedCommandsFeaturesNVBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.0
    }
}
#[doc = "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV.html) · Structure"]
#[doc(alias = "VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV")]
#[derive(Copy, Clone)]
#[repr(C)]
pub struct PhysicalDeviceDeviceGeneratedCommandsPropertiesNV {
    pub s_type: crate::vk1_0::StructureType,
    pub p_next: *mut std::ffi::c_void,
    pub max_graphics_shader_group_count: u32,
    pub max_indirect_sequence_count: u32,
    pub max_indirect_commands_token_count: u32,
    pub max_indirect_commands_stream_count: u32,
    pub max_indirect_commands_token_offset: u32,
    pub max_indirect_commands_stream_stride: u32,
    pub min_sequences_count_buffer_offset_alignment: u32,
    pub min_sequences_index_buffer_offset_alignment: u32,
    pub min_indirect_commands_buffer_offset_alignment: u32,
}
impl Default for PhysicalDeviceDeviceGeneratedCommandsPropertiesNV {
    fn default() -> Self {
        Self {
            s_type:
                crate::vk1_0::StructureType::PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV,
            p_next: std::ptr::null_mut(),
            max_graphics_shader_group_count: Default::default(),
            max_indirect_sequence_count: Default::default(),
            max_indirect_commands_token_count: Default::default(),
            max_indirect_commands_stream_count: Default::default(),
            max_indirect_commands_token_offset: Default::default(),
            max_indirect_commands_stream_stride: Default::default(),
            min_sequences_count_buffer_offset_alignment: Default::default(),
            min_sequences_index_buffer_offset_alignment: Default::default(),
            min_indirect_commands_buffer_offset_alignment: Default::default(),
        }
    }
}
impl std::fmt::Debug for PhysicalDeviceDeviceGeneratedCommandsPropertiesNV {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        f.debug_struct("PhysicalDeviceDeviceGeneratedCommandsPropertiesNV")
            .field("s_type", &self.s_type)
            .field("p_next", &self.p_next)
            .field(
                "max_graphics_shader_group_count",
                &self.max_graphics_shader_group_count,
            )
            .field(
                "max_indirect_sequence_count",
                &self.max_indirect_sequence_count,
            )
            .field(
                "max_indirect_commands_token_count",
                &self.max_indirect_commands_token_count,
            )
            .field(
                "max_indirect_commands_stream_count",
                &self.max_indirect_commands_stream_count,
            )
            .field(
                "max_indirect_commands_token_offset",
                &self.max_indirect_commands_token_offset,
            )
            .field(
                "max_indirect_commands_stream_stride",
                &self.max_indirect_commands_stream_stride,
            )
            .field(
                "min_sequences_count_buffer_offset_alignment",
                &self.min_sequences_count_buffer_offset_alignment,
            )
            .field(
                "min_sequences_index_buffer_offset_alignment",
                &self.min_sequences_index_buffer_offset_alignment,
            )
            .field(
                "min_indirect_commands_buffer_offset_alignment",
                &self.min_indirect_commands_buffer_offset_alignment,
            )
            .finish()
    }
}
impl PhysicalDeviceDeviceGeneratedCommandsPropertiesNV {
    #[inline]
    pub fn into_builder<'a>(self) -> PhysicalDeviceDeviceGeneratedCommandsPropertiesNVBuilder<'a> {
        PhysicalDeviceDeviceGeneratedCommandsPropertiesNVBuilder(self, std::marker::PhantomData)
    }
}
#[derive(Copy, Clone)]
#[doc = "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV.html) · Builder of [`PhysicalDeviceDeviceGeneratedCommandsPropertiesNV`]"]
#[repr(transparent)]
pub struct PhysicalDeviceDeviceGeneratedCommandsPropertiesNVBuilder<'a>(
    PhysicalDeviceDeviceGeneratedCommandsPropertiesNV,
    std::marker::PhantomData<&'a ()>,
);
impl<'a> PhysicalDeviceDeviceGeneratedCommandsPropertiesNVBuilder<'a> {
    #[inline]
    pub fn new() -> PhysicalDeviceDeviceGeneratedCommandsPropertiesNVBuilder<'a> {
        PhysicalDeviceDeviceGeneratedCommandsPropertiesNVBuilder(
            Default::default(),
            std::marker::PhantomData,
        )
    }
    #[inline]
    pub fn max_graphics_shader_group_count(mut self, max_graphics_shader_group_count: u32) -> Self {
        self.0.max_graphics_shader_group_count = max_graphics_shader_group_count as _;
        self
    }
    #[inline]
    pub fn max_indirect_sequence_count(mut self, max_indirect_sequence_count: u32) -> Self {
        self.0.max_indirect_sequence_count = max_indirect_sequence_count as _;
        self
    }
    #[inline]
    pub fn max_indirect_commands_token_count(
        mut self,
        max_indirect_commands_token_count: u32,
    ) -> Self {
        self.0.max_indirect_commands_token_count = max_indirect_commands_token_count as _;
        self
    }
    #[inline]
    pub fn max_indirect_commands_stream_count(
        mut self,
        max_indirect_commands_stream_count: u32,
    ) -> Self {
        self.0.max_indirect_commands_stream_count = max_indirect_commands_stream_count as _;
        self
    }
    #[inline]
    pub fn max_indirect_commands_token_offset(
        mut self,
        max_indirect_commands_token_offset: u32,
    ) -> Self {
        self.0.max_indirect_commands_token_offset = max_indirect_commands_token_offset as _;
        self
    }
    #[inline]
    pub fn max_indirect_commands_stream_stride(
        mut self,
        max_indirect_commands_stream_stride: u32,
    ) -> Self {
        self.0.max_indirect_commands_stream_stride = max_indirect_commands_stream_stride as _;
        self
    }
    #[inline]
    pub fn min_sequences_count_buffer_offset_alignment(
        mut self,
        min_sequences_count_buffer_offset_alignment: u32,
    ) -> Self {
        self.0.min_sequences_count_buffer_offset_alignment =
            min_sequences_count_buffer_offset_alignment as _;
        self
    }
    #[inline]
    pub fn min_sequences_index_buffer_offset_alignment(
        mut self,
        min_sequences_index_buffer_offset_alignment: u32,
    ) -> Self {
        self.0.min_sequences_index_buffer_offset_alignment =
            min_sequences_index_buffer_offset_alignment as _;
        self
    }
    #[inline]
    pub fn min_indirect_commands_buffer_offset_alignment(
        mut self,
        min_indirect_commands_buffer_offset_alignment: u32,
    ) -> Self {
        self.0.min_indirect_commands_buffer_offset_alignment =
            min_indirect_commands_buffer_offset_alignment as _;
        self
    }
    #[inline]
    #[doc = "Discards all lifetime information. Use the `Deref` and `DerefMut` implementations if possible."]
    pub fn build(self) -> PhysicalDeviceDeviceGeneratedCommandsPropertiesNV {
        self.0
    }
}
impl<'a> std::default::Default for PhysicalDeviceDeviceGeneratedCommandsPropertiesNVBuilder<'a> {
    fn default() -> PhysicalDeviceDeviceGeneratedCommandsPropertiesNVBuilder<'a> {
        Self::new()
    }
}
impl<'a> std::fmt::Debug for PhysicalDeviceDeviceGeneratedCommandsPropertiesNVBuilder<'a> {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        std::fmt::Debug::fmt(&self.0, f)
    }
}
impl<'a> std::ops::Deref for PhysicalDeviceDeviceGeneratedCommandsPropertiesNVBuilder<'a> {
    type Target = PhysicalDeviceDeviceGeneratedCommandsPropertiesNV;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
impl<'a> std::ops::DerefMut for PhysicalDeviceDeviceGeneratedCommandsPropertiesNVBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.0
    }
}
#[doc = "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkGraphicsShaderGroupCreateInfoNV.html) · Structure"]
#[doc(alias = "VkGraphicsShaderGroupCreateInfoNV")]
#[derive(Copy, Clone)]
#[repr(C)]
pub struct GraphicsShaderGroupCreateInfoNV {
    pub s_type: crate::vk1_0::StructureType,
    pub p_next: *const std::ffi::c_void,
    pub stage_count: u32,
    pub p_stages: *const crate::vk1_0::PipelineShaderStageCreateInfo,
    pub p_vertex_input_state: *const crate::vk1_0::PipelineVertexInputStateCreateInfo,
    pub p_tessellation_state: *const crate::vk1_0::PipelineTessellationStateCreateInfo,
}
impl Default for GraphicsShaderGroupCreateInfoNV {
    fn default() -> Self {
        Self {
            s_type: crate::vk1_0::StructureType::GRAPHICS_SHADER_GROUP_CREATE_INFO_NV,
            p_next: std::ptr::null(),
            stage_count: Default::default(),
            p_stages: std::ptr::null(),
            p_vertex_input_state: std::ptr::null(),
            p_tessellation_state: std::ptr::null(),
        }
    }
}
impl std::fmt::Debug for GraphicsShaderGroupCreateInfoNV {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        f.debug_struct("GraphicsShaderGroupCreateInfoNV")
            .field("s_type", &self.s_type)
            .field("p_next", &self.p_next)
            .field("stage_count", &self.stage_count)
            .field("p_stages", &self.p_stages)
            .field("p_vertex_input_state", &self.p_vertex_input_state)
            .field("p_tessellation_state", &self.p_tessellation_state)
            .finish()
    }
}
impl GraphicsShaderGroupCreateInfoNV {
    #[inline]
    pub fn into_builder<'a>(self) -> GraphicsShaderGroupCreateInfoNVBuilder<'a> {
        GraphicsShaderGroupCreateInfoNVBuilder(self, std::marker::PhantomData)
    }
}
#[derive(Copy, Clone)]
#[doc = "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkGraphicsShaderGroupCreateInfoNV.html) · Builder of [`GraphicsShaderGroupCreateInfoNV`]"]
#[repr(transparent)]
pub struct GraphicsShaderGroupCreateInfoNVBuilder<'a>(
    GraphicsShaderGroupCreateInfoNV,
    std::marker::PhantomData<&'a ()>,
);
impl<'a> GraphicsShaderGroupCreateInfoNVBuilder<'a> {
    #[inline]
    pub fn new() -> GraphicsShaderGroupCreateInfoNVBuilder<'a> {
        GraphicsShaderGroupCreateInfoNVBuilder(Default::default(), std::marker::PhantomData)
    }
    #[inline]
    pub fn stages(
        mut self,
        stages: &'a [crate::vk1_0::PipelineShaderStageCreateInfoBuilder],
    ) -> Self {
        self.0.p_stages = stages.as_ptr() as _;
        self.0.stage_count = stages.len() as _;
        self
    }
    #[inline]
    pub fn vertex_input_state(
        mut self,
        vertex_input_state: &'a crate::vk1_0::PipelineVertexInputStateCreateInfo,
    ) -> Self {
        self.0.p_vertex_input_state = vertex_input_state as _;
        self
    }
    #[inline]
    pub fn tessellation_state(
        mut self,
        tessellation_state: &'a crate::vk1_0::PipelineTessellationStateCreateInfo,
    ) -> Self {
        self.0.p_tessellation_state = tessellation_state as _;
        self
    }
    #[inline]
    #[doc = "Discards all lifetime information. Use the `Deref` and `DerefMut` implementations if possible."]
    pub fn build(self) -> GraphicsShaderGroupCreateInfoNV {
        self.0
    }
}
impl<'a> std::default::Default for GraphicsShaderGroupCreateInfoNVBuilder<'a> {
    fn default() -> GraphicsShaderGroupCreateInfoNVBuilder<'a> {
        Self::new()
    }
}
impl<'a> std::fmt::Debug for GraphicsShaderGroupCreateInfoNVBuilder<'a> {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        std::fmt::Debug::fmt(&self.0, f)
    }
}
impl<'a> std::ops::Deref for GraphicsShaderGroupCreateInfoNVBuilder<'a> {
    type Target = GraphicsShaderGroupCreateInfoNV;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
impl<'a> std::ops::DerefMut for GraphicsShaderGroupCreateInfoNVBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.0
    }
}
#[doc = "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkGraphicsPipelineShaderGroupsCreateInfoNV.html) · Structure"]
#[doc(alias = "VkGraphicsPipelineShaderGroupsCreateInfoNV")]
#[derive(Copy, Clone)]
#[repr(C)]
pub struct GraphicsPipelineShaderGroupsCreateInfoNV {
    pub s_type: crate::vk1_0::StructureType,
    pub p_next: *const std::ffi::c_void,
    pub group_count: u32,
    pub p_groups:
        *const crate::extensions::nv_device_generated_commands::GraphicsShaderGroupCreateInfoNV,
    pub pipeline_count: u32,
    pub p_pipelines: *const crate::vk1_0::Pipeline,
}
impl Default for GraphicsPipelineShaderGroupsCreateInfoNV {
    fn default() -> Self {
        Self {
            s_type: crate::vk1_0::StructureType::GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV,
            p_next: std::ptr::null(),
            group_count: Default::default(),
            p_groups: std::ptr::null(),
            pipeline_count: Default::default(),
            p_pipelines: std::ptr::null(),
        }
    }
}
impl std::fmt::Debug for GraphicsPipelineShaderGroupsCreateInfoNV {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        f.debug_struct("GraphicsPipelineShaderGroupsCreateInfoNV")
            .field("s_type", &self.s_type)
            .field("p_next", &self.p_next)
            .field("group_count", &self.group_count)
            .field("p_groups", &self.p_groups)
            .field("pipeline_count", &self.pipeline_count)
            .field("p_pipelines", &self.p_pipelines)
            .finish()
    }
}
impl GraphicsPipelineShaderGroupsCreateInfoNV {
    #[inline]
    pub fn into_builder<'a>(self) -> GraphicsPipelineShaderGroupsCreateInfoNVBuilder<'a> {
        GraphicsPipelineShaderGroupsCreateInfoNVBuilder(self, std::marker::PhantomData)
    }
}
#[derive(Copy, Clone)]
#[doc = "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkGraphicsPipelineShaderGroupsCreateInfoNV.html) · Builder of [`GraphicsPipelineShaderGroupsCreateInfoNV`]"]
#[repr(transparent)]
pub struct GraphicsPipelineShaderGroupsCreateInfoNVBuilder<'a>(
    GraphicsPipelineShaderGroupsCreateInfoNV,
    std::marker::PhantomData<&'a ()>,
);
impl<'a> GraphicsPipelineShaderGroupsCreateInfoNVBuilder<'a> {
    #[inline]
    pub fn new() -> GraphicsPipelineShaderGroupsCreateInfoNVBuilder<'a> {
        GraphicsPipelineShaderGroupsCreateInfoNVBuilder(
            Default::default(),
            std::marker::PhantomData,
        )
    }
    #[inline]
    pub fn groups(
        mut self,
        groups : & 'a [crate :: extensions :: nv_device_generated_commands :: GraphicsShaderGroupCreateInfoNVBuilder],
    ) -> Self {
        self.0.p_groups = groups.as_ptr() as _;
        self.0.group_count = groups.len() as _;
        self
    }
    #[inline]
    pub fn pipelines(mut self, pipelines: &'a [crate::vk1_0::Pipeline]) -> Self {
        self.0.p_pipelines = pipelines.as_ptr() as _;
        self.0.pipeline_count = pipelines.len() as _;
        self
    }
    #[inline]
    #[doc = "Discards all lifetime information. Use the `Deref` and `DerefMut` implementations if possible."]
    pub fn build(self) -> GraphicsPipelineShaderGroupsCreateInfoNV {
        self.0
    }
}
impl<'a> std::default::Default for GraphicsPipelineShaderGroupsCreateInfoNVBuilder<'a> {
    fn default() -> GraphicsPipelineShaderGroupsCreateInfoNVBuilder<'a> {
        Self::new()
    }
}
impl<'a> std::fmt::Debug for GraphicsPipelineShaderGroupsCreateInfoNVBuilder<'a> {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        std::fmt::Debug::fmt(&self.0, f)
    }
}
impl<'a> std::ops::Deref for GraphicsPipelineShaderGroupsCreateInfoNVBuilder<'a> {
    type Target = GraphicsPipelineShaderGroupsCreateInfoNV;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
impl<'a> std::ops::DerefMut for GraphicsPipelineShaderGroupsCreateInfoNVBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.0
    }
}
#[doc = "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkBindShaderGroupIndirectCommandNV.html) · Structure"]
#[doc(alias = "VkBindShaderGroupIndirectCommandNV")]
#[derive(Copy, Clone)]
#[repr(C)]
pub struct BindShaderGroupIndirectCommandNV {
    pub group_index: u32,
}
impl Default for BindShaderGroupIndirectCommandNV {
    fn default() -> Self {
        Self {
            group_index: Default::default(),
        }
    }
}
impl std::fmt::Debug for BindShaderGroupIndirectCommandNV {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        f.debug_struct("BindShaderGroupIndirectCommandNV")
            .field("group_index", &self.group_index)
            .finish()
    }
}
impl BindShaderGroupIndirectCommandNV {
    #[inline]
    pub fn into_builder<'a>(self) -> BindShaderGroupIndirectCommandNVBuilder<'a> {
        BindShaderGroupIndirectCommandNVBuilder(self, std::marker::PhantomData)
    }
}
#[derive(Copy, Clone)]
#[doc = "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkBindShaderGroupIndirectCommandNV.html) · Builder of [`BindShaderGroupIndirectCommandNV`]"]
#[repr(transparent)]
pub struct BindShaderGroupIndirectCommandNVBuilder<'a>(
    BindShaderGroupIndirectCommandNV,
    std::marker::PhantomData<&'a ()>,
);
impl<'a> BindShaderGroupIndirectCommandNVBuilder<'a> {
    #[inline]
    pub fn new() -> BindShaderGroupIndirectCommandNVBuilder<'a> {
        BindShaderGroupIndirectCommandNVBuilder(Default::default(), std::marker::PhantomData)
    }
    #[inline]
    pub fn group_index(mut self, group_index: u32) -> Self {
        self.0.group_index = group_index as _;
        self
    }
    #[inline]
    #[doc = "Discards all lifetime information. Use the `Deref` and `DerefMut` implementations if possible."]
    pub fn build(self) -> BindShaderGroupIndirectCommandNV {
        self.0
    }
}
impl<'a> std::default::Default for BindShaderGroupIndirectCommandNVBuilder<'a> {
    fn default() -> BindShaderGroupIndirectCommandNVBuilder<'a> {
        Self::new()
    }
}
impl<'a> std::fmt::Debug for BindShaderGroupIndirectCommandNVBuilder<'a> {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        std::fmt::Debug::fmt(&self.0, f)
    }
}
impl<'a> std::ops::Deref for BindShaderGroupIndirectCommandNVBuilder<'a> {
    type Target = BindShaderGroupIndirectCommandNV;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
impl<'a> std::ops::DerefMut for BindShaderGroupIndirectCommandNVBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.0
    }
}
#[doc = "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkBindIndexBufferIndirectCommandNV.html) · Structure"]
#[doc(alias = "VkBindIndexBufferIndirectCommandNV")]
#[derive(Copy, Clone)]
#[repr(C)]
pub struct BindIndexBufferIndirectCommandNV {
    pub buffer_address: crate::vk1_0::DeviceAddress,
    pub size: u32,
    pub index_type: crate::vk1_0::IndexType,
}
impl Default for BindIndexBufferIndirectCommandNV {
    fn default() -> Self {
        Self {
            buffer_address: Default::default(),
            size: Default::default(),
            index_type: Default::default(),
        }
    }
}
impl std::fmt::Debug for BindIndexBufferIndirectCommandNV {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        f.debug_struct("BindIndexBufferIndirectCommandNV")
            .field("buffer_address", &self.buffer_address)
            .field("size", &self.size)
            .field("index_type", &self.index_type)
            .finish()
    }
}
impl BindIndexBufferIndirectCommandNV {
    #[inline]
    pub fn into_builder<'a>(self) -> BindIndexBufferIndirectCommandNVBuilder<'a> {
        BindIndexBufferIndirectCommandNVBuilder(self, std::marker::PhantomData)
    }
}
#[derive(Copy, Clone)]
#[doc = "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkBindIndexBufferIndirectCommandNV.html) · Builder of [`BindIndexBufferIndirectCommandNV`]"]
#[repr(transparent)]
pub struct BindIndexBufferIndirectCommandNVBuilder<'a>(
    BindIndexBufferIndirectCommandNV,
    std::marker::PhantomData<&'a ()>,
);
impl<'a> BindIndexBufferIndirectCommandNVBuilder<'a> {
    #[inline]
    pub fn new() -> BindIndexBufferIndirectCommandNVBuilder<'a> {
        BindIndexBufferIndirectCommandNVBuilder(Default::default(), std::marker::PhantomData)
    }
    #[inline]
    pub fn buffer_address(mut self, buffer_address: crate::vk1_0::DeviceAddress) -> Self {
        self.0.buffer_address = buffer_address as _;
        self
    }
    #[inline]
    pub fn size(mut self, size: u32) -> Self {
        self.0.size = size as _;
        self
    }
    #[inline]
    pub fn index_type(mut self, index_type: crate::vk1_0::IndexType) -> Self {
        self.0.index_type = index_type as _;
        self
    }
    #[inline]
    #[doc = "Discards all lifetime information. Use the `Deref` and `DerefMut` implementations if possible."]
    pub fn build(self) -> BindIndexBufferIndirectCommandNV {
        self.0
    }
}
impl<'a> std::default::Default for BindIndexBufferIndirectCommandNVBuilder<'a> {
    fn default() -> BindIndexBufferIndirectCommandNVBuilder<'a> {
        Self::new()
    }
}
impl<'a> std::fmt::Debug for BindIndexBufferIndirectCommandNVBuilder<'a> {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        std::fmt::Debug::fmt(&self.0, f)
    }
}
impl<'a> std::ops::Deref for BindIndexBufferIndirectCommandNVBuilder<'a> {
    type Target = BindIndexBufferIndirectCommandNV;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
impl<'a> std::ops::DerefMut for BindIndexBufferIndirectCommandNVBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.0
    }
}
#[doc = "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkBindVertexBufferIndirectCommandNV.html) · Structure"]
#[doc(alias = "VkBindVertexBufferIndirectCommandNV")]
#[derive(Copy, Clone)]
#[repr(C)]
pub struct BindVertexBufferIndirectCommandNV {
    pub buffer_address: crate::vk1_0::DeviceAddress,
    pub size: u32,
    pub stride: u32,
}
impl Default for BindVertexBufferIndirectCommandNV {
    fn default() -> Self {
        Self {
            buffer_address: Default::default(),
            size: Default::default(),
            stride: Default::default(),
        }
    }
}
impl std::fmt::Debug for BindVertexBufferIndirectCommandNV {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        f.debug_struct("BindVertexBufferIndirectCommandNV")
            .field("buffer_address", &self.buffer_address)
            .field("size", &self.size)
            .field("stride", &self.stride)
            .finish()
    }
}
impl BindVertexBufferIndirectCommandNV {
    #[inline]
    pub fn into_builder<'a>(self) -> BindVertexBufferIndirectCommandNVBuilder<'a> {
        BindVertexBufferIndirectCommandNVBuilder(self, std::marker::PhantomData)
    }
}
#[derive(Copy, Clone)]
#[doc = "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkBindVertexBufferIndirectCommandNV.html) · Builder of [`BindVertexBufferIndirectCommandNV`]"]
#[repr(transparent)]
pub struct BindVertexBufferIndirectCommandNVBuilder<'a>(
    BindVertexBufferIndirectCommandNV,
    std::marker::PhantomData<&'a ()>,
);
impl<'a> BindVertexBufferIndirectCommandNVBuilder<'a> {
    #[inline]
    pub fn new() -> BindVertexBufferIndirectCommandNVBuilder<'a> {
        BindVertexBufferIndirectCommandNVBuilder(Default::default(), std::marker::PhantomData)
    }
    #[inline]
    pub fn buffer_address(mut self, buffer_address: crate::vk1_0::DeviceAddress) -> Self {
        self.0.buffer_address = buffer_address as _;
        self
    }
    #[inline]
    pub fn size(mut self, size: u32) -> Self {
        self.0.size = size as _;
        self
    }
    #[inline]
    pub fn stride(mut self, stride: u32) -> Self {
        self.0.stride = stride as _;
        self
    }
    #[inline]
    #[doc = "Discards all lifetime information. Use the `Deref` and `DerefMut` implementations if possible."]
    pub fn build(self) -> BindVertexBufferIndirectCommandNV {
        self.0
    }
}
impl<'a> std::default::Default for BindVertexBufferIndirectCommandNVBuilder<'a> {
    fn default() -> BindVertexBufferIndirectCommandNVBuilder<'a> {
        Self::new()
    }
}
impl<'a> std::fmt::Debug for BindVertexBufferIndirectCommandNVBuilder<'a> {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        std::fmt::Debug::fmt(&self.0, f)
    }
}
impl<'a> std::ops::Deref for BindVertexBufferIndirectCommandNVBuilder<'a> {
    type Target = BindVertexBufferIndirectCommandNV;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
impl<'a> std::ops::DerefMut for BindVertexBufferIndirectCommandNVBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.0
    }
}
#[doc = "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSetStateFlagsIndirectCommandNV.html) · Structure"]
#[doc(alias = "VkSetStateFlagsIndirectCommandNV")]
#[derive(Copy, Clone)]
#[repr(C)]
pub struct SetStateFlagsIndirectCommandNV {
    pub data: u32,
}
impl Default for SetStateFlagsIndirectCommandNV {
    fn default() -> Self {
        Self {
            data: Default::default(),
        }
    }
}
impl std::fmt::Debug for SetStateFlagsIndirectCommandNV {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        f.debug_struct("SetStateFlagsIndirectCommandNV")
            .field("data", &self.data)
            .finish()
    }
}
impl SetStateFlagsIndirectCommandNV {
    #[inline]
    pub fn into_builder<'a>(self) -> SetStateFlagsIndirectCommandNVBuilder<'a> {
        SetStateFlagsIndirectCommandNVBuilder(self, std::marker::PhantomData)
    }
}
#[derive(Copy, Clone)]
#[doc = "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSetStateFlagsIndirectCommandNV.html) · Builder of [`SetStateFlagsIndirectCommandNV`]"]
#[repr(transparent)]
pub struct SetStateFlagsIndirectCommandNVBuilder<'a>(
    SetStateFlagsIndirectCommandNV,
    std::marker::PhantomData<&'a ()>,
);
impl<'a> SetStateFlagsIndirectCommandNVBuilder<'a> {
    #[inline]
    pub fn new() -> SetStateFlagsIndirectCommandNVBuilder<'a> {
        SetStateFlagsIndirectCommandNVBuilder(Default::default(), std::marker::PhantomData)
    }
    #[inline]
    pub fn data(mut self, data: u32) -> Self {
        self.0.data = data as _;
        self
    }
    #[inline]
    #[doc = "Discards all lifetime information. Use the `Deref` and `DerefMut` implementations if possible."]
    pub fn build(self) -> SetStateFlagsIndirectCommandNV {
        self.0
    }
}
impl<'a> std::default::Default for SetStateFlagsIndirectCommandNVBuilder<'a> {
    fn default() -> SetStateFlagsIndirectCommandNVBuilder<'a> {
        Self::new()
    }
}
impl<'a> std::fmt::Debug for SetStateFlagsIndirectCommandNVBuilder<'a> {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        std::fmt::Debug::fmt(&self.0, f)
    }
}
impl<'a> std::ops::Deref for SetStateFlagsIndirectCommandNVBuilder<'a> {
    type Target = SetStateFlagsIndirectCommandNV;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
impl<'a> std::ops::DerefMut for SetStateFlagsIndirectCommandNVBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.0
    }
}
#[doc = "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkIndirectCommandsStreamNV.html) · Structure"]
#[doc(alias = "VkIndirectCommandsStreamNV")]
#[derive(Copy, Clone)]
#[repr(C)]
pub struct IndirectCommandsStreamNV {
    pub buffer: crate::vk1_0::Buffer,
    pub offset: crate::vk1_0::DeviceSize,
}
impl Default for IndirectCommandsStreamNV {
    fn default() -> Self {
        Self {
            buffer: Default::default(),
            offset: Default::default(),
        }
    }
}
impl std::fmt::Debug for IndirectCommandsStreamNV {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        f.debug_struct("IndirectCommandsStreamNV")
            .field("buffer", &self.buffer)
            .field("offset", &self.offset)
            .finish()
    }
}
impl IndirectCommandsStreamNV {
    #[inline]
    pub fn into_builder<'a>(self) -> IndirectCommandsStreamNVBuilder<'a> {
        IndirectCommandsStreamNVBuilder(self, std::marker::PhantomData)
    }
}
#[derive(Copy, Clone)]
#[doc = "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkIndirectCommandsStreamNV.html) · Builder of [`IndirectCommandsStreamNV`]"]
#[repr(transparent)]
pub struct IndirectCommandsStreamNVBuilder<'a>(
    IndirectCommandsStreamNV,
    std::marker::PhantomData<&'a ()>,
);
impl<'a> IndirectCommandsStreamNVBuilder<'a> {
    #[inline]
    pub fn new() -> IndirectCommandsStreamNVBuilder<'a> {
        IndirectCommandsStreamNVBuilder(Default::default(), std::marker::PhantomData)
    }
    #[inline]
    pub fn buffer(mut self, buffer: crate::vk1_0::Buffer) -> Self {
        self.0.buffer = buffer as _;
        self
    }
    #[inline]
    pub fn offset(mut self, offset: crate::vk1_0::DeviceSize) -> Self {
        self.0.offset = offset as _;
        self
    }
    #[inline]
    #[doc = "Discards all lifetime information. Use the `Deref` and `DerefMut` implementations if possible."]
    pub fn build(self) -> IndirectCommandsStreamNV {
        self.0
    }
}
impl<'a> std::default::Default for IndirectCommandsStreamNVBuilder<'a> {
    fn default() -> IndirectCommandsStreamNVBuilder<'a> {
        Self::new()
    }
}
impl<'a> std::fmt::Debug for IndirectCommandsStreamNVBuilder<'a> {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        std::fmt::Debug::fmt(&self.0, f)
    }
}
impl<'a> std::ops::Deref for IndirectCommandsStreamNVBuilder<'a> {
    type Target = IndirectCommandsStreamNV;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
impl<'a> std::ops::DerefMut for IndirectCommandsStreamNVBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.0
    }
}
#[doc = "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkIndirectCommandsLayoutTokenNV.html) · Structure"]
#[doc(alias = "VkIndirectCommandsLayoutTokenNV")]
#[derive(Copy, Clone)]
#[repr(C)]
pub struct IndirectCommandsLayoutTokenNV {
    pub s_type: crate::vk1_0::StructureType,
    pub p_next: *const std::ffi::c_void,
    pub token_type: crate::extensions::nv_device_generated_commands::IndirectCommandsTokenTypeNV,
    pub stream: u32,
    pub offset: u32,
    pub vertex_binding_unit: u32,
    pub vertex_dynamic_stride: crate::vk1_0::Bool32,
    pub pushconstant_pipeline_layout: crate::vk1_0::PipelineLayout,
    pub pushconstant_shader_stage_flags: crate::vk1_0::ShaderStageFlags,
    pub pushconstant_offset: u32,
    pub pushconstant_size: u32,
    pub indirect_state_flags: crate::extensions::nv_device_generated_commands::IndirectStateFlagsNV,
    pub index_type_count: u32,
    pub p_index_types: *const crate::vk1_0::IndexType,
    pub p_index_type_values: *const u32,
}
impl Default for IndirectCommandsLayoutTokenNV {
    fn default() -> Self {
        Self {
            s_type: crate::vk1_0::StructureType::INDIRECT_COMMANDS_LAYOUT_TOKEN_NV,
            p_next: std::ptr::null(),
            token_type: Default::default(),
            stream: Default::default(),
            offset: Default::default(),
            vertex_binding_unit: Default::default(),
            vertex_dynamic_stride: Default::default(),
            pushconstant_pipeline_layout: Default::default(),
            pushconstant_shader_stage_flags: Default::default(),
            pushconstant_offset: Default::default(),
            pushconstant_size: Default::default(),
            indirect_state_flags: Default::default(),
            index_type_count: Default::default(),
            p_index_types: std::ptr::null(),
            p_index_type_values: std::ptr::null(),
        }
    }
}
impl std::fmt::Debug for IndirectCommandsLayoutTokenNV {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        f.debug_struct("IndirectCommandsLayoutTokenNV")
            .field("s_type", &self.s_type)
            .field("p_next", &self.p_next)
            .field("token_type", &self.token_type)
            .field("stream", &self.stream)
            .field("offset", &self.offset)
            .field("vertex_binding_unit", &self.vertex_binding_unit)
            .field("vertex_dynamic_stride", &(self.vertex_dynamic_stride != 0))
            .field(
                "pushconstant_pipeline_layout",
                &self.pushconstant_pipeline_layout,
            )
            .field(
                "pushconstant_shader_stage_flags",
                &self.pushconstant_shader_stage_flags,
            )
            .field("pushconstant_offset", &self.pushconstant_offset)
            .field("pushconstant_size", &self.pushconstant_size)
            .field("indirect_state_flags", &self.indirect_state_flags)
            .field("index_type_count", &self.index_type_count)
            .field("p_index_types", &self.p_index_types)
            .field("p_index_type_values", &self.p_index_type_values)
            .finish()
    }
}
impl IndirectCommandsLayoutTokenNV {
    #[inline]
    pub fn into_builder<'a>(self) -> IndirectCommandsLayoutTokenNVBuilder<'a> {
        IndirectCommandsLayoutTokenNVBuilder(self, std::marker::PhantomData)
    }
}
#[derive(Copy, Clone)]
#[doc = "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkIndirectCommandsLayoutTokenNV.html) · Builder of [`IndirectCommandsLayoutTokenNV`]"]
#[repr(transparent)]
pub struct IndirectCommandsLayoutTokenNVBuilder<'a>(
    IndirectCommandsLayoutTokenNV,
    std::marker::PhantomData<&'a ()>,
);
impl<'a> IndirectCommandsLayoutTokenNVBuilder<'a> {
    #[inline]
    pub fn new() -> IndirectCommandsLayoutTokenNVBuilder<'a> {
        IndirectCommandsLayoutTokenNVBuilder(Default::default(), std::marker::PhantomData)
    }
    #[inline]
    pub fn token_type(
        mut self,
        token_type: crate::extensions::nv_device_generated_commands::IndirectCommandsTokenTypeNV,
    ) -> Self {
        self.0.token_type = token_type as _;
        self
    }
    #[inline]
    pub fn stream(mut self, stream: u32) -> Self {
        self.0.stream = stream as _;
        self
    }
    #[inline]
    pub fn offset(mut self, offset: u32) -> Self {
        self.0.offset = offset as _;
        self
    }
    #[inline]
    pub fn vertex_binding_unit(mut self, vertex_binding_unit: u32) -> Self {
        self.0.vertex_binding_unit = vertex_binding_unit as _;
        self
    }
    #[inline]
    pub fn vertex_dynamic_stride(mut self, vertex_dynamic_stride: bool) -> Self {
        self.0.vertex_dynamic_stride = vertex_dynamic_stride as _;
        self
    }
    #[inline]
    pub fn pushconstant_pipeline_layout(
        mut self,
        pushconstant_pipeline_layout: crate::vk1_0::PipelineLayout,
    ) -> Self {
        self.0.pushconstant_pipeline_layout = pushconstant_pipeline_layout as _;
        self
    }
    #[inline]
    pub fn pushconstant_shader_stage_flags(
        mut self,
        pushconstant_shader_stage_flags: crate::vk1_0::ShaderStageFlags,
    ) -> Self {
        self.0.pushconstant_shader_stage_flags = pushconstant_shader_stage_flags as _;
        self
    }
    #[inline]
    pub fn pushconstant_offset(mut self, pushconstant_offset: u32) -> Self {
        self.0.pushconstant_offset = pushconstant_offset as _;
        self
    }
    #[inline]
    pub fn pushconstant_size(mut self, pushconstant_size: u32) -> Self {
        self.0.pushconstant_size = pushconstant_size as _;
        self
    }
    #[inline]
    pub fn indirect_state_flags(
        mut self,
        indirect_state_flags: crate::extensions::nv_device_generated_commands::IndirectStateFlagsNV,
    ) -> Self {
        self.0.indirect_state_flags = indirect_state_flags as _;
        self
    }
    #[inline]
    pub fn index_types(mut self, index_types: &'a [crate::vk1_0::IndexType]) -> Self {
        self.0.p_index_types = index_types.as_ptr() as _;
        self.0.index_type_count = index_types.len() as _;
        self
    }
    #[inline]
    pub fn index_type_values(mut self, index_type_values: &'a [u32]) -> Self {
        self.0.p_index_type_values = index_type_values.as_ptr() as _;
        self.0.index_type_count = index_type_values.len() as _;
        self
    }
    #[inline]
    #[doc = "Discards all lifetime information. Use the `Deref` and `DerefMut` implementations if possible."]
    pub fn build(self) -> IndirectCommandsLayoutTokenNV {
        self.0
    }
}
impl<'a> std::default::Default for IndirectCommandsLayoutTokenNVBuilder<'a> {
    fn default() -> IndirectCommandsLayoutTokenNVBuilder<'a> {
        Self::new()
    }
}
impl<'a> std::fmt::Debug for IndirectCommandsLayoutTokenNVBuilder<'a> {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        std::fmt::Debug::fmt(&self.0, f)
    }
}
impl<'a> std::ops::Deref for IndirectCommandsLayoutTokenNVBuilder<'a> {
    type Target = IndirectCommandsLayoutTokenNV;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
impl<'a> std::ops::DerefMut for IndirectCommandsLayoutTokenNVBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.0
    }
}
#[doc = "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkIndirectCommandsLayoutCreateInfoNV.html) · Structure"]
#[doc(alias = "VkIndirectCommandsLayoutCreateInfoNV")]
#[derive(Copy, Clone)]
#[repr(C)]
pub struct IndirectCommandsLayoutCreateInfoNV {
    pub s_type: crate::vk1_0::StructureType,
    pub p_next: *const std::ffi::c_void,
    pub flags: crate::extensions::nv_device_generated_commands::IndirectCommandsLayoutUsageFlagsNV,
    pub pipeline_bind_point: crate::vk1_0::PipelineBindPoint,
    pub token_count: u32,
    pub p_tokens:
        *const crate::extensions::nv_device_generated_commands::IndirectCommandsLayoutTokenNV,
    pub stream_count: u32,
    pub p_stream_strides: *const u32,
}
impl Default for IndirectCommandsLayoutCreateInfoNV {
    fn default() -> Self {
        Self {
            s_type: crate::vk1_0::StructureType::INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NV,
            p_next: std::ptr::null(),
            flags: Default::default(),
            pipeline_bind_point: Default::default(),
            token_count: Default::default(),
            p_tokens: std::ptr::null(),
            stream_count: Default::default(),
            p_stream_strides: std::ptr::null(),
        }
    }
}
impl std::fmt::Debug for IndirectCommandsLayoutCreateInfoNV {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        f.debug_struct("IndirectCommandsLayoutCreateInfoNV")
            .field("s_type", &self.s_type)
            .field("p_next", &self.p_next)
            .field("flags", &self.flags)
            .field("pipeline_bind_point", &self.pipeline_bind_point)
            .field("token_count", &self.token_count)
            .field("p_tokens", &self.p_tokens)
            .field("stream_count", &self.stream_count)
            .field("p_stream_strides", &self.p_stream_strides)
            .finish()
    }
}
impl IndirectCommandsLayoutCreateInfoNV {
    #[inline]
    pub fn into_builder<'a>(self) -> IndirectCommandsLayoutCreateInfoNVBuilder<'a> {
        IndirectCommandsLayoutCreateInfoNVBuilder(self, std::marker::PhantomData)
    }
}
#[derive(Copy, Clone)]
#[doc = "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkIndirectCommandsLayoutCreateInfoNV.html) · Builder of [`IndirectCommandsLayoutCreateInfoNV`]"]
#[repr(transparent)]
pub struct IndirectCommandsLayoutCreateInfoNVBuilder<'a>(
    IndirectCommandsLayoutCreateInfoNV,
    std::marker::PhantomData<&'a ()>,
);
impl<'a> IndirectCommandsLayoutCreateInfoNVBuilder<'a> {
    #[inline]
    pub fn new() -> IndirectCommandsLayoutCreateInfoNVBuilder<'a> {
        IndirectCommandsLayoutCreateInfoNVBuilder(Default::default(), std::marker::PhantomData)
    }
    #[inline]
    pub fn flags(
        mut self,
        flags: crate::extensions::nv_device_generated_commands::IndirectCommandsLayoutUsageFlagsNV,
    ) -> Self {
        self.0.flags = flags as _;
        self
    }
    #[inline]
    pub fn pipeline_bind_point(
        mut self,
        pipeline_bind_point: crate::vk1_0::PipelineBindPoint,
    ) -> Self {
        self.0.pipeline_bind_point = pipeline_bind_point as _;
        self
    }
    #[inline]
    pub fn tokens(
        mut self,
        tokens : & 'a [crate :: extensions :: nv_device_generated_commands :: IndirectCommandsLayoutTokenNVBuilder],
    ) -> Self {
        self.0.p_tokens = tokens.as_ptr() as _;
        self.0.token_count = tokens.len() as _;
        self
    }
    #[inline]
    pub fn stream_strides(mut self, stream_strides: &'a [u32]) -> Self {
        self.0.p_stream_strides = stream_strides.as_ptr() as _;
        self.0.stream_count = stream_strides.len() as _;
        self
    }
    #[inline]
    #[doc = "Discards all lifetime information. Use the `Deref` and `DerefMut` implementations if possible."]
    pub fn build(self) -> IndirectCommandsLayoutCreateInfoNV {
        self.0
    }
}
impl<'a> std::default::Default for IndirectCommandsLayoutCreateInfoNVBuilder<'a> {
    fn default() -> IndirectCommandsLayoutCreateInfoNVBuilder<'a> {
        Self::new()
    }
}
impl<'a> std::fmt::Debug for IndirectCommandsLayoutCreateInfoNVBuilder<'a> {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        std::fmt::Debug::fmt(&self.0, f)
    }
}
impl<'a> std::ops::Deref for IndirectCommandsLayoutCreateInfoNVBuilder<'a> {
    type Target = IndirectCommandsLayoutCreateInfoNV;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
impl<'a> std::ops::DerefMut for IndirectCommandsLayoutCreateInfoNVBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.0
    }
}
#[doc = "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkGeneratedCommandsInfoNV.html) · Structure"]
#[doc(alias = "VkGeneratedCommandsInfoNV")]
#[derive(Copy, Clone)]
#[repr(C)]
pub struct GeneratedCommandsInfoNV {
    pub s_type: crate::vk1_0::StructureType,
    pub p_next: *const std::ffi::c_void,
    pub pipeline_bind_point: crate::vk1_0::PipelineBindPoint,
    pub pipeline: crate::vk1_0::Pipeline,
    pub indirect_commands_layout:
        crate::extensions::nv_device_generated_commands::IndirectCommandsLayoutNV,
    pub stream_count: u32,
    pub p_streams: *const crate::extensions::nv_device_generated_commands::IndirectCommandsStreamNV,
    pub sequences_count: u32,
    pub preprocess_buffer: crate::vk1_0::Buffer,
    pub preprocess_offset: crate::vk1_0::DeviceSize,
    pub preprocess_size: crate::vk1_0::DeviceSize,
    pub sequences_count_buffer: crate::vk1_0::Buffer,
    pub sequences_count_offset: crate::vk1_0::DeviceSize,
    pub sequences_index_buffer: crate::vk1_0::Buffer,
    pub sequences_index_offset: crate::vk1_0::DeviceSize,
}
impl Default for GeneratedCommandsInfoNV {
    fn default() -> Self {
        Self {
            s_type: crate::vk1_0::StructureType::GENERATED_COMMANDS_INFO_NV,
            p_next: std::ptr::null(),
            pipeline_bind_point: Default::default(),
            pipeline: Default::default(),
            indirect_commands_layout: Default::default(),
            stream_count: Default::default(),
            p_streams: std::ptr::null(),
            sequences_count: Default::default(),
            preprocess_buffer: Default::default(),
            preprocess_offset: Default::default(),
            preprocess_size: Default::default(),
            sequences_count_buffer: Default::default(),
            sequences_count_offset: Default::default(),
            sequences_index_buffer: Default::default(),
            sequences_index_offset: Default::default(),
        }
    }
}
impl std::fmt::Debug for GeneratedCommandsInfoNV {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        f.debug_struct("GeneratedCommandsInfoNV")
            .field("s_type", &self.s_type)
            .field("p_next", &self.p_next)
            .field("pipeline_bind_point", &self.pipeline_bind_point)
            .field("pipeline", &self.pipeline)
            .field("indirect_commands_layout", &self.indirect_commands_layout)
            .field("stream_count", &self.stream_count)
            .field("p_streams", &self.p_streams)
            .field("sequences_count", &self.sequences_count)
            .field("preprocess_buffer", &self.preprocess_buffer)
            .field("preprocess_offset", &self.preprocess_offset)
            .field("preprocess_size", &self.preprocess_size)
            .field("sequences_count_buffer", &self.sequences_count_buffer)
            .field("sequences_count_offset", &self.sequences_count_offset)
            .field("sequences_index_buffer", &self.sequences_index_buffer)
            .field("sequences_index_offset", &self.sequences_index_offset)
            .finish()
    }
}
impl GeneratedCommandsInfoNV {
    #[inline]
    pub fn into_builder<'a>(self) -> GeneratedCommandsInfoNVBuilder<'a> {
        GeneratedCommandsInfoNVBuilder(self, std::marker::PhantomData)
    }
}
#[derive(Copy, Clone)]
#[doc = "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkGeneratedCommandsInfoNV.html) · Builder of [`GeneratedCommandsInfoNV`]"]
#[repr(transparent)]
pub struct GeneratedCommandsInfoNVBuilder<'a>(
    GeneratedCommandsInfoNV,
    std::marker::PhantomData<&'a ()>,
);
impl<'a> GeneratedCommandsInfoNVBuilder<'a> {
    #[inline]
    pub fn new() -> GeneratedCommandsInfoNVBuilder<'a> {
        GeneratedCommandsInfoNVBuilder(Default::default(), std::marker::PhantomData)
    }
    #[inline]
    pub fn pipeline_bind_point(
        mut self,
        pipeline_bind_point: crate::vk1_0::PipelineBindPoint,
    ) -> Self {
        self.0.pipeline_bind_point = pipeline_bind_point as _;
        self
    }
    #[inline]
    pub fn pipeline(mut self, pipeline: crate::vk1_0::Pipeline) -> Self {
        self.0.pipeline = pipeline as _;
        self
    }
    #[inline]
    pub fn indirect_commands_layout(
        mut self,
        indirect_commands_layout : crate :: extensions :: nv_device_generated_commands :: IndirectCommandsLayoutNV,
    ) -> Self {
        self.0.indirect_commands_layout = indirect_commands_layout as _;
        self
    }
    #[inline]
    pub fn streams(
        mut self,
        streams : & 'a [crate :: extensions :: nv_device_generated_commands :: IndirectCommandsStreamNVBuilder],
    ) -> Self {
        self.0.p_streams = streams.as_ptr() as _;
        self.0.stream_count = streams.len() as _;
        self
    }
    #[inline]
    pub fn sequences_count(mut self, sequences_count: u32) -> Self {
        self.0.sequences_count = sequences_count as _;
        self
    }
    #[inline]
    pub fn preprocess_buffer(mut self, preprocess_buffer: crate::vk1_0::Buffer) -> Self {
        self.0.preprocess_buffer = preprocess_buffer as _;
        self
    }
    #[inline]
    pub fn preprocess_offset(mut self, preprocess_offset: crate::vk1_0::DeviceSize) -> Self {
        self.0.preprocess_offset = preprocess_offset as _;
        self
    }
    #[inline]
    pub fn preprocess_size(mut self, preprocess_size: crate::vk1_0::DeviceSize) -> Self {
        self.0.preprocess_size = preprocess_size as _;
        self
    }
    #[inline]
    pub fn sequences_count_buffer(mut self, sequences_count_buffer: crate::vk1_0::Buffer) -> Self {
        self.0.sequences_count_buffer = sequences_count_buffer as _;
        self
    }
    #[inline]
    pub fn sequences_count_offset(
        mut self,
        sequences_count_offset: crate::vk1_0::DeviceSize,
    ) -> Self {
        self.0.sequences_count_offset = sequences_count_offset as _;
        self
    }
    #[inline]
    pub fn sequences_index_buffer(mut self, sequences_index_buffer: crate::vk1_0::Buffer) -> Self {
        self.0.sequences_index_buffer = sequences_index_buffer as _;
        self
    }
    #[inline]
    pub fn sequences_index_offset(
        mut self,
        sequences_index_offset: crate::vk1_0::DeviceSize,
    ) -> Self {
        self.0.sequences_index_offset = sequences_index_offset as _;
        self
    }
    #[inline]
    #[doc = "Discards all lifetime information. Use the `Deref` and `DerefMut` implementations if possible."]
    pub fn build(self) -> GeneratedCommandsInfoNV {
        self.0
    }
}
impl<'a> std::default::Default for GeneratedCommandsInfoNVBuilder<'a> {
    fn default() -> GeneratedCommandsInfoNVBuilder<'a> {
        Self::new()
    }
}
impl<'a> std::fmt::Debug for GeneratedCommandsInfoNVBuilder<'a> {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        std::fmt::Debug::fmt(&self.0, f)
    }
}
impl<'a> std::ops::Deref for GeneratedCommandsInfoNVBuilder<'a> {
    type Target = GeneratedCommandsInfoNV;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
impl<'a> std::ops::DerefMut for GeneratedCommandsInfoNVBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.0
    }
}
#[doc = "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkGeneratedCommandsMemoryRequirementsInfoNV.html) · Structure"]
#[doc(alias = "VkGeneratedCommandsMemoryRequirementsInfoNV")]
#[derive(Copy, Clone)]
#[repr(C)]
pub struct GeneratedCommandsMemoryRequirementsInfoNV {
    pub s_type: crate::vk1_0::StructureType,
    pub p_next: *const std::ffi::c_void,
    pub pipeline_bind_point: crate::vk1_0::PipelineBindPoint,
    pub pipeline: crate::vk1_0::Pipeline,
    pub indirect_commands_layout:
        crate::extensions::nv_device_generated_commands::IndirectCommandsLayoutNV,
    pub max_sequences_count: u32,
}
impl Default for GeneratedCommandsMemoryRequirementsInfoNV {
    fn default() -> Self {
        Self {
            s_type: crate::vk1_0::StructureType::GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_NV,
            p_next: std::ptr::null(),
            pipeline_bind_point: Default::default(),
            pipeline: Default::default(),
            indirect_commands_layout: Default::default(),
            max_sequences_count: Default::default(),
        }
    }
}
impl std::fmt::Debug for GeneratedCommandsMemoryRequirementsInfoNV {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        f.debug_struct("GeneratedCommandsMemoryRequirementsInfoNV")
            .field("s_type", &self.s_type)
            .field("p_next", &self.p_next)
            .field("pipeline_bind_point", &self.pipeline_bind_point)
            .field("pipeline", &self.pipeline)
            .field("indirect_commands_layout", &self.indirect_commands_layout)
            .field("max_sequences_count", &self.max_sequences_count)
            .finish()
    }
}
impl GeneratedCommandsMemoryRequirementsInfoNV {
    #[inline]
    pub fn into_builder<'a>(self) -> GeneratedCommandsMemoryRequirementsInfoNVBuilder<'a> {
        GeneratedCommandsMemoryRequirementsInfoNVBuilder(self, std::marker::PhantomData)
    }
}
#[derive(Copy, Clone)]
#[doc = "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkGeneratedCommandsMemoryRequirementsInfoNV.html) · Builder of [`GeneratedCommandsMemoryRequirementsInfoNV`]"]
#[repr(transparent)]
pub struct GeneratedCommandsMemoryRequirementsInfoNVBuilder<'a>(
    GeneratedCommandsMemoryRequirementsInfoNV,
    std::marker::PhantomData<&'a ()>,
);
impl<'a> GeneratedCommandsMemoryRequirementsInfoNVBuilder<'a> {
    #[inline]
    pub fn new() -> GeneratedCommandsMemoryRequirementsInfoNVBuilder<'a> {
        GeneratedCommandsMemoryRequirementsInfoNVBuilder(
            Default::default(),
            std::marker::PhantomData,
        )
    }
    #[inline]
    pub fn pipeline_bind_point(
        mut self,
        pipeline_bind_point: crate::vk1_0::PipelineBindPoint,
    ) -> Self {
        self.0.pipeline_bind_point = pipeline_bind_point as _;
        self
    }
    #[inline]
    pub fn pipeline(mut self, pipeline: crate::vk1_0::Pipeline) -> Self {
        self.0.pipeline = pipeline as _;
        self
    }
    #[inline]
    pub fn indirect_commands_layout(
        mut self,
        indirect_commands_layout : crate :: extensions :: nv_device_generated_commands :: IndirectCommandsLayoutNV,
    ) -> Self {
        self.0.indirect_commands_layout = indirect_commands_layout as _;
        self
    }
    #[inline]
    pub fn max_sequences_count(mut self, max_sequences_count: u32) -> Self {
        self.0.max_sequences_count = max_sequences_count as _;
        self
    }
    #[inline]
    #[doc = "Discards all lifetime information. Use the `Deref` and `DerefMut` implementations if possible."]
    pub fn build(self) -> GeneratedCommandsMemoryRequirementsInfoNV {
        self.0
    }
}
impl<'a> std::default::Default for GeneratedCommandsMemoryRequirementsInfoNVBuilder<'a> {
    fn default() -> GeneratedCommandsMemoryRequirementsInfoNVBuilder<'a> {
        Self::new()
    }
}
impl<'a> std::fmt::Debug for GeneratedCommandsMemoryRequirementsInfoNVBuilder<'a> {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        std::fmt::Debug::fmt(&self.0, f)
    }
}
impl<'a> std::ops::Deref for GeneratedCommandsMemoryRequirementsInfoNVBuilder<'a> {
    type Target = GeneratedCommandsMemoryRequirementsInfoNV;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
impl<'a> std::ops::DerefMut for GeneratedCommandsMemoryRequirementsInfoNVBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.0
    }
}
#[doc = "Provided by [`crate::extensions::nv_device_generated_commands`]"]
impl crate::DeviceLoader {
    #[inline]
    #[doc = "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdExecuteGeneratedCommandsNV.html) · Function"]
    #[doc(alias = "vkCmdExecuteGeneratedCommandsNV")]
    pub unsafe fn cmd_execute_generated_commands_nv(
        &self,
        command_buffer: crate::vk1_0::CommandBuffer,
        is_preprocessed: bool,
        generated_commands_info : & crate :: extensions :: nv_device_generated_commands :: GeneratedCommandsInfoNV,
    ) -> () {
        let _function = self
            .cmd_execute_generated_commands_nv
            .expect("`cmd_execute_generated_commands_nv` is not loaded");
        let _return = _function(
            command_buffer as _,
            is_preprocessed as _,
            generated_commands_info as _,
        );
        ()
    }
    #[inline]
    #[doc = "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdPreprocessGeneratedCommandsNV.html) · Function"]
    #[doc(alias = "vkCmdPreprocessGeneratedCommandsNV")]
    pub unsafe fn cmd_preprocess_generated_commands_nv(
        &self,
        command_buffer: crate::vk1_0::CommandBuffer,
        generated_commands_info : & crate :: extensions :: nv_device_generated_commands :: GeneratedCommandsInfoNV,
    ) -> () {
        let _function = self
            .cmd_preprocess_generated_commands_nv
            .expect("`cmd_preprocess_generated_commands_nv` is not loaded");
        let _return = _function(command_buffer as _, generated_commands_info as _);
        ()
    }
    #[inline]
    #[doc = "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdBindPipelineShaderGroupNV.html) · Function"]
    #[doc(alias = "vkCmdBindPipelineShaderGroupNV")]
    pub unsafe fn cmd_bind_pipeline_shader_group_nv(
        &self,
        command_buffer: crate::vk1_0::CommandBuffer,
        pipeline_bind_point: crate::vk1_0::PipelineBindPoint,
        pipeline: crate::vk1_0::Pipeline,
        group_index: u32,
    ) -> () {
        let _function = self
            .cmd_bind_pipeline_shader_group_nv
            .expect("`cmd_bind_pipeline_shader_group_nv` is not loaded");
        let _return = _function(
            command_buffer as _,
            pipeline_bind_point as _,
            pipeline as _,
            group_index as _,
        );
        ()
    }
    #[inline]
    #[doc = "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetGeneratedCommandsMemoryRequirementsNV.html) · Function"]
    #[doc(alias = "vkGetGeneratedCommandsMemoryRequirementsNV")]
    pub unsafe fn get_generated_commands_memory_requirements_nv(
        &self,
        info : & crate :: extensions :: nv_device_generated_commands :: GeneratedCommandsMemoryRequirementsInfoNV,
        memory_requirements: Option<crate::vk1_1::MemoryRequirements2>,
    ) -> crate::vk1_1::MemoryRequirements2 {
        let _function = self
            .get_generated_commands_memory_requirements_nv
            .expect("`get_generated_commands_memory_requirements_nv` is not loaded");
        let mut memory_requirements = match memory_requirements {
            Some(v) => v,
            None => Default::default(),
        };
        let _return = _function(self.handle, info as _, &mut memory_requirements);
        memory_requirements
    }
    #[inline]
    #[doc = "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateIndirectCommandsLayoutNV.html) · Function"]
    #[doc(alias = "vkCreateIndirectCommandsLayoutNV")]
    pub unsafe fn create_indirect_commands_layout_nv(
        &self,
        create_info : & crate :: extensions :: nv_device_generated_commands :: IndirectCommandsLayoutCreateInfoNV,
        allocator: Option<&crate::vk1_0::AllocationCallbacks>,
        indirect_commands_layout: Option<
            crate::extensions::nv_device_generated_commands::IndirectCommandsLayoutNV,
        >,
    ) -> crate::utils::VulkanResult<
        crate::extensions::nv_device_generated_commands::IndirectCommandsLayoutNV,
    > {
        let _function = self
            .create_indirect_commands_layout_nv
            .expect("`create_indirect_commands_layout_nv` is not loaded");
        let mut indirect_commands_layout = match indirect_commands_layout {
            Some(v) => v,
            None => Default::default(),
        };
        let _return = _function(
            self.handle,
            create_info as _,
            match allocator {
                Some(v) => v,
                None => std::ptr::null(),
            },
            &mut indirect_commands_layout,
        );
        crate::utils::VulkanResult::new(_return, indirect_commands_layout)
    }
    #[inline]
    #[doc = "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDestroyIndirectCommandsLayoutNV.html) · Function"]
    #[doc(alias = "vkDestroyIndirectCommandsLayoutNV")]
    pub unsafe fn destroy_indirect_commands_layout_nv(
        &self,
        indirect_commands_layout: Option<
            crate::extensions::nv_device_generated_commands::IndirectCommandsLayoutNV,
        >,
        allocator: Option<&crate::vk1_0::AllocationCallbacks>,
    ) -> () {
        let _function = self
            .destroy_indirect_commands_layout_nv
            .expect("`destroy_indirect_commands_layout_nv` is not loaded");
        let _return = _function(
            self.handle,
            match indirect_commands_layout {
                Some(v) => v,
                None => Default::default(),
            },
            match allocator {
                Some(v) => v,
                None => std::ptr::null(),
            },
        );
        ()
    }
}
