use crate::vk::aliases::*;
use crate::vk::bitflags::*;
use crate::vk::constants::*;
use crate::vk::enums::*;
use crate::vk::platform_types::*;
use crate::vk::{ptr_chain_iter, Handle};
use std::fmt;
use std::os::raw::*;
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSampleMask.html>"]
pub type SampleMask = u32;
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkBool32.html>"]
pub type Bool32 = u32;
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkFlags.html>"]
pub type Flags = u32;
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDeviceSize.html>"]
pub type DeviceSize = u64;
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDeviceAddress.html>"]
pub type DeviceAddress = u64;
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkQueryPoolCreateFlags.html>"]
pub struct QueryPoolCreateFlags(pub(crate) Flags);
vk_bitflags_wrapped!(QueryPoolCreateFlags, 0b0, Flags);
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineLayoutCreateFlags.html>"]
pub struct PipelineLayoutCreateFlags(pub(crate) Flags);
vk_bitflags_wrapped!(PipelineLayoutCreateFlags, 0b0, Flags);
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineDepthStencilStateCreateFlags.html>"]
pub struct PipelineDepthStencilStateCreateFlags(pub(crate) Flags);
vk_bitflags_wrapped!(PipelineDepthStencilStateCreateFlags, 0b0, Flags);
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineDynamicStateCreateFlags.html>"]
pub struct PipelineDynamicStateCreateFlags(pub(crate) Flags);
vk_bitflags_wrapped!(PipelineDynamicStateCreateFlags, 0b0, Flags);
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineColorBlendStateCreateFlags.html>"]
pub struct PipelineColorBlendStateCreateFlags(pub(crate) Flags);
vk_bitflags_wrapped!(PipelineColorBlendStateCreateFlags, 0b0, Flags);
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineMultisampleStateCreateFlags.html>"]
pub struct PipelineMultisampleStateCreateFlags(pub(crate) Flags);
vk_bitflags_wrapped!(PipelineMultisampleStateCreateFlags, 0b0, Flags);
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineRasterizationStateCreateFlags.html>"]
pub struct PipelineRasterizationStateCreateFlags(pub(crate) Flags);
vk_bitflags_wrapped!(PipelineRasterizationStateCreateFlags, 0b0, Flags);
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineViewportStateCreateFlags.html>"]
pub struct PipelineViewportStateCreateFlags(pub(crate) Flags);
vk_bitflags_wrapped!(PipelineViewportStateCreateFlags, 0b0, Flags);
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineTessellationStateCreateFlags.html>"]
pub struct PipelineTessellationStateCreateFlags(pub(crate) Flags);
vk_bitflags_wrapped!(PipelineTessellationStateCreateFlags, 0b0, Flags);
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineInputAssemblyStateCreateFlags.html>"]
pub struct PipelineInputAssemblyStateCreateFlags(pub(crate) Flags);
vk_bitflags_wrapped!(PipelineInputAssemblyStateCreateFlags, 0b0, Flags);
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineVertexInputStateCreateFlags.html>"]
pub struct PipelineVertexInputStateCreateFlags(pub(crate) Flags);
vk_bitflags_wrapped!(PipelineVertexInputStateCreateFlags, 0b0, Flags);
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkBufferViewCreateFlags.html>"]
pub struct BufferViewCreateFlags(pub(crate) Flags);
vk_bitflags_wrapped!(BufferViewCreateFlags, 0b0, Flags);
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkInstanceCreateFlags.html>"]
pub struct InstanceCreateFlags(pub(crate) Flags);
vk_bitflags_wrapped!(InstanceCreateFlags, 0b0, Flags);
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDeviceCreateFlags.html>"]
pub struct DeviceCreateFlags(pub(crate) Flags);
vk_bitflags_wrapped!(DeviceCreateFlags, 0b0, Flags);
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkEventCreateFlags.html>"]
pub struct EventCreateFlags(pub(crate) Flags);
vk_bitflags_wrapped!(EventCreateFlags, 0b0, Flags);
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkMemoryMapFlags.html>"]
pub struct MemoryMapFlags(pub(crate) Flags);
vk_bitflags_wrapped!(MemoryMapFlags, 0b0, Flags);
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDescriptorPoolResetFlags.html>"]
pub struct DescriptorPoolResetFlags(pub(crate) Flags);
vk_bitflags_wrapped!(DescriptorPoolResetFlags, 0b0, Flags);
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDescriptorUpdateTemplateCreateFlags.html>"]
pub struct DescriptorUpdateTemplateCreateFlags(pub(crate) Flags);
vk_bitflags_wrapped!(DescriptorUpdateTemplateCreateFlags, 0b0, Flags);
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDisplayModeCreateFlagsKHR.html>"]
pub struct DisplayModeCreateFlagsKHR(pub(crate) Flags);
vk_bitflags_wrapped!(DisplayModeCreateFlagsKHR, 0b0, Flags);
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDisplaySurfaceCreateFlagsKHR.html>"]
pub struct DisplaySurfaceCreateFlagsKHR(pub(crate) Flags);
vk_bitflags_wrapped!(DisplaySurfaceCreateFlagsKHR, 0b0, Flags);
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAndroidSurfaceCreateFlagsKHR.html>"]
pub struct AndroidSurfaceCreateFlagsKHR(pub(crate) Flags);
vk_bitflags_wrapped!(AndroidSurfaceCreateFlagsKHR, 0b0, Flags);
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkViSurfaceCreateFlagsNN.html>"]
pub struct ViSurfaceCreateFlagsNN(pub(crate) Flags);
vk_bitflags_wrapped!(ViSurfaceCreateFlagsNN, 0b0, Flags);
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkWaylandSurfaceCreateFlagsKHR.html>"]
pub struct WaylandSurfaceCreateFlagsKHR(pub(crate) Flags);
vk_bitflags_wrapped!(WaylandSurfaceCreateFlagsKHR, 0b0, Flags);
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkWin32SurfaceCreateFlagsKHR.html>"]
pub struct Win32SurfaceCreateFlagsKHR(pub(crate) Flags);
vk_bitflags_wrapped!(Win32SurfaceCreateFlagsKHR, 0b0, Flags);
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkXlibSurfaceCreateFlagsKHR.html>"]
pub struct XlibSurfaceCreateFlagsKHR(pub(crate) Flags);
vk_bitflags_wrapped!(XlibSurfaceCreateFlagsKHR, 0b0, Flags);
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkXcbSurfaceCreateFlagsKHR.html>"]
pub struct XcbSurfaceCreateFlagsKHR(pub(crate) Flags);
vk_bitflags_wrapped!(XcbSurfaceCreateFlagsKHR, 0b0, Flags);
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkIOSSurfaceCreateFlagsMVK.html>"]
pub struct IOSSurfaceCreateFlagsMVK(pub(crate) Flags);
vk_bitflags_wrapped!(IOSSurfaceCreateFlagsMVK, 0b0, Flags);
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkMacOSSurfaceCreateFlagsMVK.html>"]
pub struct MacOSSurfaceCreateFlagsMVK(pub(crate) Flags);
vk_bitflags_wrapped!(MacOSSurfaceCreateFlagsMVK, 0b0, Flags);
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkMetalSurfaceCreateFlagsEXT.html>"]
pub struct MetalSurfaceCreateFlagsEXT(pub(crate) Flags);
vk_bitflags_wrapped!(MetalSurfaceCreateFlagsEXT, 0b0, Flags);
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImagePipeSurfaceCreateFlagsFUCHSIA.html>"]
pub struct ImagePipeSurfaceCreateFlagsFUCHSIA(pub(crate) Flags);
vk_bitflags_wrapped!(ImagePipeSurfaceCreateFlagsFUCHSIA, 0b0, Flags);
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkStreamDescriptorSurfaceCreateFlagsGGP.html>"]
pub struct StreamDescriptorSurfaceCreateFlagsGGP(pub(crate) Flags);
vk_bitflags_wrapped!(StreamDescriptorSurfaceCreateFlagsGGP, 0b0, Flags);
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkHeadlessSurfaceCreateFlagsEXT.html>"]
pub struct HeadlessSurfaceCreateFlagsEXT(pub(crate) Flags);
vk_bitflags_wrapped!(HeadlessSurfaceCreateFlagsEXT, 0b0, Flags);
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCommandPoolTrimFlags.html>"]
pub struct CommandPoolTrimFlags(pub(crate) Flags);
vk_bitflags_wrapped!(CommandPoolTrimFlags, 0b0, Flags);
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineViewportSwizzleStateCreateFlagsNV.html>"]
pub struct PipelineViewportSwizzleStateCreateFlagsNV(pub(crate) Flags);
vk_bitflags_wrapped!(PipelineViewportSwizzleStateCreateFlagsNV, 0b0, Flags);
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineDiscardRectangleStateCreateFlagsEXT.html>"]
pub struct PipelineDiscardRectangleStateCreateFlagsEXT(pub(crate) Flags);
vk_bitflags_wrapped!(PipelineDiscardRectangleStateCreateFlagsEXT, 0b0, Flags);
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineCoverageToColorStateCreateFlagsNV.html>"]
pub struct PipelineCoverageToColorStateCreateFlagsNV(pub(crate) Flags);
vk_bitflags_wrapped!(PipelineCoverageToColorStateCreateFlagsNV, 0b0, Flags);
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineCoverageModulationStateCreateFlagsNV.html>"]
pub struct PipelineCoverageModulationStateCreateFlagsNV(pub(crate) Flags);
vk_bitflags_wrapped!(PipelineCoverageModulationStateCreateFlagsNV, 0b0, Flags);
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineCoverageReductionStateCreateFlagsNV.html>"]
pub struct PipelineCoverageReductionStateCreateFlagsNV(pub(crate) Flags);
vk_bitflags_wrapped!(PipelineCoverageReductionStateCreateFlagsNV, 0b0, Flags);
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkValidationCacheCreateFlagsEXT.html>"]
pub struct ValidationCacheCreateFlagsEXT(pub(crate) Flags);
vk_bitflags_wrapped!(ValidationCacheCreateFlagsEXT, 0b0, Flags);
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDebugUtilsMessengerCreateFlagsEXT.html>"]
pub struct DebugUtilsMessengerCreateFlagsEXT(pub(crate) Flags);
vk_bitflags_wrapped!(DebugUtilsMessengerCreateFlagsEXT, 0b0, Flags);
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDebugUtilsMessengerCallbackDataFlagsEXT.html>"]
pub struct DebugUtilsMessengerCallbackDataFlagsEXT(pub(crate) Flags);
vk_bitflags_wrapped!(DebugUtilsMessengerCallbackDataFlagsEXT, 0b0, Flags);
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineRasterizationConservativeStateCreateFlagsEXT.html>"]
pub struct PipelineRasterizationConservativeStateCreateFlagsEXT(pub(crate) Flags);
vk_bitflags_wrapped!(
    PipelineRasterizationConservativeStateCreateFlagsEXT,
    0b0,
    Flags
);
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineRasterizationStateStreamCreateFlagsEXT.html>"]
pub struct PipelineRasterizationStateStreamCreateFlagsEXT(pub(crate) Flags);
vk_bitflags_wrapped!(PipelineRasterizationStateStreamCreateFlagsEXT, 0b0, Flags);
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineRasterizationDepthClipStateCreateFlagsEXT.html>"]
pub struct PipelineRasterizationDepthClipStateCreateFlagsEXT(pub(crate) Flags);
vk_bitflags_wrapped!(
    PipelineRasterizationDepthClipStateCreateFlagsEXT,
    0b0,
    Flags
);
define_handle!(
    Instance,
    INSTANCE,
    doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkInstance.html>"
);
define_handle ! ( PhysicalDevice , PHYSICAL_DEVICE , doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDevice.html>" ) ;
define_handle!(
    Device,
    DEVICE,
    doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDevice.html>"
);
define_handle!(
    Queue,
    QUEUE,
    doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkQueue.html>"
);
define_handle ! ( CommandBuffer , COMMAND_BUFFER , doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCommandBuffer.html>" ) ;
handle_nondispatchable ! ( DeviceMemory , DEVICE_MEMORY , doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDeviceMemory.html>" ) ;
handle_nondispatchable ! ( CommandPool , COMMAND_POOL , doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCommandPool.html>" ) ;
handle_nondispatchable!(
    Buffer,
    BUFFER,
    doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkBuffer.html>"
);
handle_nondispatchable!(
    BufferView,
    BUFFER_VIEW,
    doc =
        "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkBufferView.html>"
);
handle_nondispatchable!(
    Image,
    IMAGE,
    doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImage.html>"
);
handle_nondispatchable!(
    ImageView,
    IMAGE_VIEW,
    doc =
        "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImageView.html>"
);
handle_nondispatchable ! ( ShaderModule , SHADER_MODULE , doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkShaderModule.html>" ) ;
handle_nondispatchable!(
    Pipeline,
    PIPELINE,
    doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipeline.html>"
);
handle_nondispatchable ! ( PipelineLayout , PIPELINE_LAYOUT , doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineLayout.html>" ) ;
handle_nondispatchable!(
    Sampler,
    SAMPLER,
    doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSampler.html>"
);
handle_nondispatchable ! ( DescriptorSet , DESCRIPTOR_SET , doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDescriptorSet.html>" ) ;
handle_nondispatchable ! ( DescriptorSetLayout , DESCRIPTOR_SET_LAYOUT , doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDescriptorSetLayout.html>" ) ;
handle_nondispatchable ! ( DescriptorPool , DESCRIPTOR_POOL , doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDescriptorPool.html>" ) ;
handle_nondispatchable!(
    Fence,
    FENCE,
    doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkFence.html>"
);
handle_nondispatchable!(
    Semaphore,
    SEMAPHORE,
    doc =
        "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSemaphore.html>"
);
handle_nondispatchable!(
    Event,
    EVENT,
    doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkEvent.html>"
);
handle_nondispatchable!(
    QueryPool,
    QUERY_POOL,
    doc =
        "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkQueryPool.html>"
);
handle_nondispatchable ! ( Framebuffer , FRAMEBUFFER , doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkFramebuffer.html>" ) ;
handle_nondispatchable!(
    RenderPass,
    RENDER_PASS,
    doc =
        "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkRenderPass.html>"
);
handle_nondispatchable ! ( PipelineCache , PIPELINE_CACHE , doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineCache.html>" ) ;
handle_nondispatchable ! ( IndirectCommandsLayoutNV , INDIRECT_COMMANDS_LAYOUT_NV , doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkIndirectCommandsLayoutNV.html>" ) ;
handle_nondispatchable ! ( DescriptorUpdateTemplate , DESCRIPTOR_UPDATE_TEMPLATE , doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDescriptorUpdateTemplate.html>" ) ;
handle_nondispatchable ! ( SamplerYcbcrConversion , SAMPLER_YCBCR_CONVERSION , doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSamplerYcbcrConversion.html>" ) ;
handle_nondispatchable ! ( ValidationCacheEXT , VALIDATION_CACHE_EXT , doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkValidationCacheEXT.html>" ) ;
handle_nondispatchable ! ( AccelerationStructureKHR , ACCELERATION_STRUCTURE_KHR , doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAccelerationStructureKHR.html>" ) ;
handle_nondispatchable ! ( PerformanceConfigurationINTEL , PERFORMANCE_CONFIGURATION_INTEL , doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPerformanceConfigurationINTEL.html>" ) ;
handle_nondispatchable ! ( DeferredOperationKHR , DEFERRED_OPERATION_KHR , doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDeferredOperationKHR.html>" ) ;
handle_nondispatchable!(
    DisplayKHR,
    DISPLAY_KHR,
    doc =
        "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDisplayKHR.html>"
);
handle_nondispatchable ! ( DisplayModeKHR , DISPLAY_MODE_KHR , doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDisplayModeKHR.html>" ) ;
handle_nondispatchable!(
    SurfaceKHR,
    SURFACE_KHR,
    doc =
        "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSurfaceKHR.html>"
);
handle_nondispatchable ! ( SwapchainKHR , SWAPCHAIN_KHR , doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSwapchainKHR.html>" ) ;
handle_nondispatchable ! ( DebugReportCallbackEXT , DEBUG_REPORT_CALLBACK_EXT , doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDebugReportCallbackEXT.html>" ) ;
handle_nondispatchable ! ( DebugUtilsMessengerEXT , DEBUG_UTILS_MESSENGER_EXT , doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDebugUtilsMessengerEXT.html>" ) ;
#[allow(non_camel_case_types)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/PFN_vkInternalAllocationNotification.html>"]
pub type PFN_vkInternalAllocationNotification = Option<
    unsafe extern "system" fn(
        p_user_data: *mut c_void,
        size: usize,
        allocation_type: InternalAllocationType,
        allocation_scope: SystemAllocationScope,
    ) -> c_void,
>;
#[allow(non_camel_case_types)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/PFN_vkInternalFreeNotification.html>"]
pub type PFN_vkInternalFreeNotification = Option<
    unsafe extern "system" fn(
        p_user_data: *mut c_void,
        size: usize,
        allocation_type: InternalAllocationType,
        allocation_scope: SystemAllocationScope,
    ) -> c_void,
>;
#[allow(non_camel_case_types)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/PFN_vkReallocationFunction.html>"]
pub type PFN_vkReallocationFunction = Option<
    unsafe extern "system" fn(
        p_user_data: *mut c_void,
        p_original: *mut c_void,
        size: usize,
        alignment: usize,
        allocation_scope: SystemAllocationScope,
    ) -> *mut c_void,
>;
#[allow(non_camel_case_types)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/PFN_vkAllocationFunction.html>"]
pub type PFN_vkAllocationFunction = Option<
    unsafe extern "system" fn(
        p_user_data: *mut c_void,
        size: usize,
        alignment: usize,
        allocation_scope: SystemAllocationScope,
    ) -> *mut c_void,
>;
#[allow(non_camel_case_types)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/PFN_vkFreeFunction.html>"]
pub type PFN_vkFreeFunction =
    Option<unsafe extern "system" fn(p_user_data: *mut c_void, p_memory: *mut c_void) -> c_void>;
#[allow(non_camel_case_types)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/PFN_vkVoidFunction.html>"]
pub type PFN_vkVoidFunction = Option<unsafe extern "system" fn() -> c_void>;
#[allow(non_camel_case_types)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/PFN_vkDebugReportCallbackEXT.html>"]
pub type PFN_vkDebugReportCallbackEXT = Option<
    unsafe extern "system" fn(
        flags: DebugReportFlagsEXT,
        object_type: DebugReportObjectTypeEXT,
        object: u64,
        location: usize,
        message_code: i32,
        p_layer_prefix: *const c_char,
        p_message: *const c_char,
        p_user_data: *mut c_void,
    ) -> Bool32,
>;
#[allow(non_camel_case_types)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/PFN_vkDebugUtilsMessengerCallbackEXT.html>"]
pub type PFN_vkDebugUtilsMessengerCallbackEXT = Option<
    unsafe extern "system" fn(
        message_severity: DebugUtilsMessageSeverityFlagsEXT,
        message_types: DebugUtilsMessageTypeFlagsEXT,
        p_callback_data: *const DebugUtilsMessengerCallbackDataEXT,
        p_user_data: *mut c_void,
    ) -> Bool32,
>;
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkBaseOutStructure.html>"]
pub struct BaseOutStructure {
    pub s_type: StructureType,
    pub p_next: *mut BaseOutStructure,
}
impl ::std::default::Default for BaseOutStructure {
    fn default() -> BaseOutStructure {
        BaseOutStructure {
            s_type: unsafe { ::std::mem::zeroed() },
            p_next: ::std::ptr::null_mut(),
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkBaseInStructure.html>"]
pub struct BaseInStructure {
    pub s_type: StructureType,
    pub p_next: *const BaseInStructure,
}
impl ::std::default::Default for BaseInStructure {
    fn default() -> BaseInStructure {
        BaseInStructure {
            s_type: unsafe { ::std::mem::zeroed() },
            p_next: ::std::ptr::null(),
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, PartialEq, Eq, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkOffset2D.html>"]
pub struct Offset2D {
    pub x: i32,
    pub y: i32,
}
impl Offset2D {
    pub fn builder<'a>() -> Offset2DBuilder<'a> {
        Offset2DBuilder {
            inner: Offset2D::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct Offset2DBuilder<'a> {
    inner: Offset2D,
    marker: ::std::marker::PhantomData<&'a ()>,
}
impl<'a> ::std::ops::Deref for Offset2DBuilder<'a> {
    type Target = Offset2D;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for Offset2DBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> Offset2DBuilder<'a> {
    pub fn x(mut self, x: i32) -> Offset2DBuilder<'a> {
        self.inner.x = x;
        self
    }
    pub fn y(mut self, y: i32) -> Offset2DBuilder<'a> {
        self.inner.y = y;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> Offset2D {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, PartialEq, Eq, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkOffset3D.html>"]
pub struct Offset3D {
    pub x: i32,
    pub y: i32,
    pub z: i32,
}
impl Offset3D {
    pub fn builder<'a>() -> Offset3DBuilder<'a> {
        Offset3DBuilder {
            inner: Offset3D::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct Offset3DBuilder<'a> {
    inner: Offset3D,
    marker: ::std::marker::PhantomData<&'a ()>,
}
impl<'a> ::std::ops::Deref for Offset3DBuilder<'a> {
    type Target = Offset3D;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for Offset3DBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> Offset3DBuilder<'a> {
    pub fn x(mut self, x: i32) -> Offset3DBuilder<'a> {
        self.inner.x = x;
        self
    }
    pub fn y(mut self, y: i32) -> Offset3DBuilder<'a> {
        self.inner.y = y;
        self
    }
    pub fn z(mut self, z: i32) -> Offset3DBuilder<'a> {
        self.inner.z = z;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> Offset3D {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, PartialEq, Eq, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkExtent2D.html>"]
pub struct Extent2D {
    pub width: u32,
    pub height: u32,
}
impl Extent2D {
    pub fn builder<'a>() -> Extent2DBuilder<'a> {
        Extent2DBuilder {
            inner: Extent2D::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct Extent2DBuilder<'a> {
    inner: Extent2D,
    marker: ::std::marker::PhantomData<&'a ()>,
}
impl<'a> ::std::ops::Deref for Extent2DBuilder<'a> {
    type Target = Extent2D;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for Extent2DBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> Extent2DBuilder<'a> {
    pub fn width(mut self, width: u32) -> Extent2DBuilder<'a> {
        self.inner.width = width;
        self
    }
    pub fn height(mut self, height: u32) -> Extent2DBuilder<'a> {
        self.inner.height = height;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> Extent2D {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, PartialEq, Eq, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkExtent3D.html>"]
pub struct Extent3D {
    pub width: u32,
    pub height: u32,
    pub depth: u32,
}
impl Extent3D {
    pub fn builder<'a>() -> Extent3DBuilder<'a> {
        Extent3DBuilder {
            inner: Extent3D::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct Extent3DBuilder<'a> {
    inner: Extent3D,
    marker: ::std::marker::PhantomData<&'a ()>,
}
impl<'a> ::std::ops::Deref for Extent3DBuilder<'a> {
    type Target = Extent3D;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for Extent3DBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> Extent3DBuilder<'a> {
    pub fn width(mut self, width: u32) -> Extent3DBuilder<'a> {
        self.inner.width = width;
        self
    }
    pub fn height(mut self, height: u32) -> Extent3DBuilder<'a> {
        self.inner.height = height;
        self
    }
    pub fn depth(mut self, depth: u32) -> Extent3DBuilder<'a> {
        self.inner.depth = depth;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> Extent3D {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Default, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkViewport.html>"]
pub struct Viewport {
    pub x: f32,
    pub y: f32,
    pub width: f32,
    pub height: f32,
    pub min_depth: f32,
    pub max_depth: f32,
}
impl Viewport {
    pub fn builder<'a>() -> ViewportBuilder<'a> {
        ViewportBuilder {
            inner: Viewport::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct ViewportBuilder<'a> {
    inner: Viewport,
    marker: ::std::marker::PhantomData<&'a ()>,
}
impl<'a> ::std::ops::Deref for ViewportBuilder<'a> {
    type Target = Viewport;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for ViewportBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> ViewportBuilder<'a> {
    pub fn x(mut self, x: f32) -> ViewportBuilder<'a> {
        self.inner.x = x;
        self
    }
    pub fn y(mut self, y: f32) -> ViewportBuilder<'a> {
        self.inner.y = y;
        self
    }
    pub fn width(mut self, width: f32) -> ViewportBuilder<'a> {
        self.inner.width = width;
        self
    }
    pub fn height(mut self, height: f32) -> ViewportBuilder<'a> {
        self.inner.height = height;
        self
    }
    pub fn min_depth(mut self, min_depth: f32) -> ViewportBuilder<'a> {
        self.inner.min_depth = min_depth;
        self
    }
    pub fn max_depth(mut self, max_depth: f32) -> ViewportBuilder<'a> {
        self.inner.max_depth = max_depth;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> Viewport {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, PartialEq, Eq, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkRect2D.html>"]
pub struct Rect2D {
    pub offset: Offset2D,
    pub extent: Extent2D,
}
impl Rect2D {
    pub fn builder<'a>() -> Rect2DBuilder<'a> {
        Rect2DBuilder {
            inner: Rect2D::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct Rect2DBuilder<'a> {
    inner: Rect2D,
    marker: ::std::marker::PhantomData<&'a ()>,
}
impl<'a> ::std::ops::Deref for Rect2DBuilder<'a> {
    type Target = Rect2D;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for Rect2DBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> Rect2DBuilder<'a> {
    pub fn offset(mut self, offset: Offset2D) -> Rect2DBuilder<'a> {
        self.inner.offset = offset;
        self
    }
    pub fn extent(mut self, extent: Extent2D) -> Rect2DBuilder<'a> {
        self.inner.extent = extent;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> Rect2D {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, PartialEq, Eq, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkClearRect.html>"]
pub struct ClearRect {
    pub rect: Rect2D,
    pub base_array_layer: u32,
    pub layer_count: u32,
}
impl ClearRect {
    pub fn builder<'a>() -> ClearRectBuilder<'a> {
        ClearRectBuilder {
            inner: ClearRect::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct ClearRectBuilder<'a> {
    inner: ClearRect,
    marker: ::std::marker::PhantomData<&'a ()>,
}
impl<'a> ::std::ops::Deref for ClearRectBuilder<'a> {
    type Target = ClearRect;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for ClearRectBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> ClearRectBuilder<'a> {
    pub fn rect(mut self, rect: Rect2D) -> ClearRectBuilder<'a> {
        self.inner.rect = rect;
        self
    }
    pub fn base_array_layer(mut self, base_array_layer: u32) -> ClearRectBuilder<'a> {
        self.inner.base_array_layer = base_array_layer;
        self
    }
    pub fn layer_count(mut self, layer_count: u32) -> ClearRectBuilder<'a> {
        self.inner.layer_count = layer_count;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> ClearRect {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Default, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkComponentMapping.html>"]
pub struct ComponentMapping {
    pub r: ComponentSwizzle,
    pub g: ComponentSwizzle,
    pub b: ComponentSwizzle,
    pub a: ComponentSwizzle,
}
impl ComponentMapping {
    pub fn builder<'a>() -> ComponentMappingBuilder<'a> {
        ComponentMappingBuilder {
            inner: ComponentMapping::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct ComponentMappingBuilder<'a> {
    inner: ComponentMapping,
    marker: ::std::marker::PhantomData<&'a ()>,
}
impl<'a> ::std::ops::Deref for ComponentMappingBuilder<'a> {
    type Target = ComponentMapping;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for ComponentMappingBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> ComponentMappingBuilder<'a> {
    pub fn r(mut self, r: ComponentSwizzle) -> ComponentMappingBuilder<'a> {
        self.inner.r = r;
        self
    }
    pub fn g(mut self, g: ComponentSwizzle) -> ComponentMappingBuilder<'a> {
        self.inner.g = g;
        self
    }
    pub fn b(mut self, b: ComponentSwizzle) -> ComponentMappingBuilder<'a> {
        self.inner.b = b;
        self
    }
    pub fn a(mut self, a: ComponentSwizzle) -> ComponentMappingBuilder<'a> {
        self.inner.a = a;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> ComponentMapping {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceProperties.html>"]
pub struct PhysicalDeviceProperties {
    pub api_version: u32,
    pub driver_version: u32,
    pub vendor_id: u32,
    pub device_id: u32,
    pub device_type: PhysicalDeviceType,
    pub device_name: [c_char; MAX_PHYSICAL_DEVICE_NAME_SIZE],
    pub pipeline_cache_uuid: [u8; UUID_SIZE],
    pub limits: PhysicalDeviceLimits,
    pub sparse_properties: PhysicalDeviceSparseProperties,
}
impl fmt::Debug for PhysicalDeviceProperties {
    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
        fmt.debug_struct("PhysicalDeviceProperties")
            .field("api_version", &self.api_version)
            .field("driver_version", &self.driver_version)
            .field("vendor_id", &self.vendor_id)
            .field("device_id", &self.device_id)
            .field("device_type", &self.device_type)
            .field("device_name", &unsafe {
                ::std::ffi::CStr::from_ptr(self.device_name.as_ptr() as *const c_char)
            })
            .field("pipeline_cache_uuid", &self.pipeline_cache_uuid)
            .field("limits", &self.limits)
            .field("sparse_properties", &self.sparse_properties)
            .finish()
    }
}
impl ::std::default::Default for PhysicalDeviceProperties {
    fn default() -> PhysicalDeviceProperties {
        PhysicalDeviceProperties {
            api_version: u32::default(),
            driver_version: u32::default(),
            vendor_id: u32::default(),
            device_id: u32::default(),
            device_type: PhysicalDeviceType::default(),
            device_name: unsafe { ::std::mem::zeroed() },
            pipeline_cache_uuid: unsafe { ::std::mem::zeroed() },
            limits: PhysicalDeviceLimits::default(),
            sparse_properties: PhysicalDeviceSparseProperties::default(),
        }
    }
}
impl PhysicalDeviceProperties {
    pub fn builder<'a>() -> PhysicalDevicePropertiesBuilder<'a> {
        PhysicalDevicePropertiesBuilder {
            inner: PhysicalDeviceProperties::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDevicePropertiesBuilder<'a> {
    inner: PhysicalDeviceProperties,
    marker: ::std::marker::PhantomData<&'a ()>,
}
impl<'a> ::std::ops::Deref for PhysicalDevicePropertiesBuilder<'a> {
    type Target = PhysicalDeviceProperties;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PhysicalDevicePropertiesBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDevicePropertiesBuilder<'a> {
    pub fn api_version(mut self, api_version: u32) -> PhysicalDevicePropertiesBuilder<'a> {
        self.inner.api_version = api_version;
        self
    }
    pub fn driver_version(mut self, driver_version: u32) -> PhysicalDevicePropertiesBuilder<'a> {
        self.inner.driver_version = driver_version;
        self
    }
    pub fn vendor_id(mut self, vendor_id: u32) -> PhysicalDevicePropertiesBuilder<'a> {
        self.inner.vendor_id = vendor_id;
        self
    }
    pub fn device_id(mut self, device_id: u32) -> PhysicalDevicePropertiesBuilder<'a> {
        self.inner.device_id = device_id;
        self
    }
    pub fn device_type(
        mut self,
        device_type: PhysicalDeviceType,
    ) -> PhysicalDevicePropertiesBuilder<'a> {
        self.inner.device_type = device_type;
        self
    }
    pub fn device_name(
        mut self,
        device_name: [c_char; MAX_PHYSICAL_DEVICE_NAME_SIZE],
    ) -> PhysicalDevicePropertiesBuilder<'a> {
        self.inner.device_name = device_name;
        self
    }
    pub fn pipeline_cache_uuid(
        mut self,
        pipeline_cache_uuid: [u8; UUID_SIZE],
    ) -> PhysicalDevicePropertiesBuilder<'a> {
        self.inner.pipeline_cache_uuid = pipeline_cache_uuid;
        self
    }
    pub fn limits(mut self, limits: PhysicalDeviceLimits) -> PhysicalDevicePropertiesBuilder<'a> {
        self.inner.limits = limits;
        self
    }
    pub fn sparse_properties(
        mut self,
        sparse_properties: PhysicalDeviceSparseProperties,
    ) -> PhysicalDevicePropertiesBuilder<'a> {
        self.inner.sparse_properties = sparse_properties;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDeviceProperties {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkExtensionProperties.html>"]
pub struct ExtensionProperties {
    pub extension_name: [c_char; MAX_EXTENSION_NAME_SIZE],
    pub spec_version: u32,
}
impl fmt::Debug for ExtensionProperties {
    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
        fmt.debug_struct("ExtensionProperties")
            .field("extension_name", &unsafe {
                ::std::ffi::CStr::from_ptr(self.extension_name.as_ptr() as *const c_char)
            })
            .field("spec_version", &self.spec_version)
            .finish()
    }
}
impl ::std::default::Default for ExtensionProperties {
    fn default() -> ExtensionProperties {
        ExtensionProperties {
            extension_name: unsafe { ::std::mem::zeroed() },
            spec_version: u32::default(),
        }
    }
}
impl ExtensionProperties {
    pub fn builder<'a>() -> ExtensionPropertiesBuilder<'a> {
        ExtensionPropertiesBuilder {
            inner: ExtensionProperties::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct ExtensionPropertiesBuilder<'a> {
    inner: ExtensionProperties,
    marker: ::std::marker::PhantomData<&'a ()>,
}
impl<'a> ::std::ops::Deref for ExtensionPropertiesBuilder<'a> {
    type Target = ExtensionProperties;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for ExtensionPropertiesBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> ExtensionPropertiesBuilder<'a> {
    pub fn extension_name(
        mut self,
        extension_name: [c_char; MAX_EXTENSION_NAME_SIZE],
    ) -> ExtensionPropertiesBuilder<'a> {
        self.inner.extension_name = extension_name;
        self
    }
    pub fn spec_version(mut self, spec_version: u32) -> ExtensionPropertiesBuilder<'a> {
        self.inner.spec_version = spec_version;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> ExtensionProperties {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkLayerProperties.html>"]
pub struct LayerProperties {
    pub layer_name: [c_char; MAX_EXTENSION_NAME_SIZE],
    pub spec_version: u32,
    pub implementation_version: u32,
    pub description: [c_char; MAX_DESCRIPTION_SIZE],
}
impl fmt::Debug for LayerProperties {
    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
        fmt.debug_struct("LayerProperties")
            .field("layer_name", &unsafe {
                ::std::ffi::CStr::from_ptr(self.layer_name.as_ptr() as *const c_char)
            })
            .field("spec_version", &self.spec_version)
            .field("implementation_version", &self.implementation_version)
            .field("description", &unsafe {
                ::std::ffi::CStr::from_ptr(self.description.as_ptr() as *const c_char)
            })
            .finish()
    }
}
impl ::std::default::Default for LayerProperties {
    fn default() -> LayerProperties {
        LayerProperties {
            layer_name: unsafe { ::std::mem::zeroed() },
            spec_version: u32::default(),
            implementation_version: u32::default(),
            description: unsafe { ::std::mem::zeroed() },
        }
    }
}
impl LayerProperties {
    pub fn builder<'a>() -> LayerPropertiesBuilder<'a> {
        LayerPropertiesBuilder {
            inner: LayerProperties::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct LayerPropertiesBuilder<'a> {
    inner: LayerProperties,
    marker: ::std::marker::PhantomData<&'a ()>,
}
impl<'a> ::std::ops::Deref for LayerPropertiesBuilder<'a> {
    type Target = LayerProperties;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for LayerPropertiesBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> LayerPropertiesBuilder<'a> {
    pub fn layer_name(
        mut self,
        layer_name: [c_char; MAX_EXTENSION_NAME_SIZE],
    ) -> LayerPropertiesBuilder<'a> {
        self.inner.layer_name = layer_name;
        self
    }
    pub fn spec_version(mut self, spec_version: u32) -> LayerPropertiesBuilder<'a> {
        self.inner.spec_version = spec_version;
        self
    }
    pub fn implementation_version(
        mut self,
        implementation_version: u32,
    ) -> LayerPropertiesBuilder<'a> {
        self.inner.implementation_version = implementation_version;
        self
    }
    pub fn description(
        mut self,
        description: [c_char; MAX_DESCRIPTION_SIZE],
    ) -> LayerPropertiesBuilder<'a> {
        self.inner.description = description;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> LayerProperties {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkApplicationInfo.html>"]
pub struct ApplicationInfo {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub p_application_name: *const c_char,
    pub application_version: u32,
    pub p_engine_name: *const c_char,
    pub engine_version: u32,
    pub api_version: u32,
}
impl ::std::default::Default for ApplicationInfo {
    fn default() -> ApplicationInfo {
        ApplicationInfo {
            s_type: StructureType::APPLICATION_INFO,
            p_next: ::std::ptr::null(),
            p_application_name: ::std::ptr::null(),
            application_version: u32::default(),
            p_engine_name: ::std::ptr::null(),
            engine_version: u32::default(),
            api_version: u32::default(),
        }
    }
}
impl ApplicationInfo {
    pub fn builder<'a>() -> ApplicationInfoBuilder<'a> {
        ApplicationInfoBuilder {
            inner: ApplicationInfo::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct ApplicationInfoBuilder<'a> {
    inner: ApplicationInfo,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsApplicationInfo {}
impl<'a> ::std::ops::Deref for ApplicationInfoBuilder<'a> {
    type Target = ApplicationInfo;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for ApplicationInfoBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> ApplicationInfoBuilder<'a> {
    pub fn application_name(
        mut self,
        application_name: &'a ::std::ffi::CStr,
    ) -> ApplicationInfoBuilder<'a> {
        self.inner.p_application_name = application_name.as_ptr();
        self
    }
    pub fn application_version(mut self, application_version: u32) -> ApplicationInfoBuilder<'a> {
        self.inner.application_version = application_version;
        self
    }
    pub fn engine_name(mut self, engine_name: &'a ::std::ffi::CStr) -> ApplicationInfoBuilder<'a> {
        self.inner.p_engine_name = engine_name.as_ptr();
        self
    }
    pub fn engine_version(mut self, engine_version: u32) -> ApplicationInfoBuilder<'a> {
        self.inner.engine_version = engine_version;
        self
    }
    pub fn api_version(mut self, api_version: u32) -> ApplicationInfoBuilder<'a> {
        self.inner.api_version = api_version;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsApplicationInfo>(
        mut self,
        next: &'a mut T,
    ) -> ApplicationInfoBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> ApplicationInfo {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAllocationCallbacks.html>"]
pub struct AllocationCallbacks {
    pub p_user_data: *mut c_void,
    pub pfn_allocation: PFN_vkAllocationFunction,
    pub pfn_reallocation: PFN_vkReallocationFunction,
    pub pfn_free: PFN_vkFreeFunction,
    pub pfn_internal_allocation: PFN_vkInternalAllocationNotification,
    pub pfn_internal_free: PFN_vkInternalFreeNotification,
}
impl fmt::Debug for AllocationCallbacks {
    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
        fmt.debug_struct("AllocationCallbacks")
            .field("p_user_data", &self.p_user_data)
            .field(
                "pfn_allocation",
                &(self.pfn_allocation.map(|x| x as *const ())),
            )
            .field(
                "pfn_reallocation",
                &(self.pfn_reallocation.map(|x| x as *const ())),
            )
            .field("pfn_free", &(self.pfn_free.map(|x| x as *const ())))
            .field(
                "pfn_internal_allocation",
                &(self.pfn_internal_allocation.map(|x| x as *const ())),
            )
            .field(
                "pfn_internal_free",
                &(self.pfn_internal_free.map(|x| x as *const ())),
            )
            .finish()
    }
}
impl ::std::default::Default for AllocationCallbacks {
    fn default() -> AllocationCallbacks {
        AllocationCallbacks {
            p_user_data: ::std::ptr::null_mut(),
            pfn_allocation: PFN_vkAllocationFunction::default(),
            pfn_reallocation: PFN_vkReallocationFunction::default(),
            pfn_free: PFN_vkFreeFunction::default(),
            pfn_internal_allocation: PFN_vkInternalAllocationNotification::default(),
            pfn_internal_free: PFN_vkInternalFreeNotification::default(),
        }
    }
}
impl AllocationCallbacks {
    pub fn builder<'a>() -> AllocationCallbacksBuilder<'a> {
        AllocationCallbacksBuilder {
            inner: AllocationCallbacks::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct AllocationCallbacksBuilder<'a> {
    inner: AllocationCallbacks,
    marker: ::std::marker::PhantomData<&'a ()>,
}
impl<'a> ::std::ops::Deref for AllocationCallbacksBuilder<'a> {
    type Target = AllocationCallbacks;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for AllocationCallbacksBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> AllocationCallbacksBuilder<'a> {
    pub fn user_data(mut self, user_data: *mut c_void) -> AllocationCallbacksBuilder<'a> {
        self.inner.p_user_data = user_data;
        self
    }
    pub fn pfn_allocation(
        mut self,
        pfn_allocation: PFN_vkAllocationFunction,
    ) -> AllocationCallbacksBuilder<'a> {
        self.inner.pfn_allocation = pfn_allocation;
        self
    }
    pub fn pfn_reallocation(
        mut self,
        pfn_reallocation: PFN_vkReallocationFunction,
    ) -> AllocationCallbacksBuilder<'a> {
        self.inner.pfn_reallocation = pfn_reallocation;
        self
    }
    pub fn pfn_free(mut self, pfn_free: PFN_vkFreeFunction) -> AllocationCallbacksBuilder<'a> {
        self.inner.pfn_free = pfn_free;
        self
    }
    pub fn pfn_internal_allocation(
        mut self,
        pfn_internal_allocation: PFN_vkInternalAllocationNotification,
    ) -> AllocationCallbacksBuilder<'a> {
        self.inner.pfn_internal_allocation = pfn_internal_allocation;
        self
    }
    pub fn pfn_internal_free(
        mut self,
        pfn_internal_free: PFN_vkInternalFreeNotification,
    ) -> AllocationCallbacksBuilder<'a> {
        self.inner.pfn_internal_free = pfn_internal_free;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> AllocationCallbacks {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDeviceQueueCreateInfo.html>"]
pub struct DeviceQueueCreateInfo {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub flags: DeviceQueueCreateFlags,
    pub queue_family_index: u32,
    pub queue_count: u32,
    pub p_queue_priorities: *const f32,
}
impl ::std::default::Default for DeviceQueueCreateInfo {
    fn default() -> DeviceQueueCreateInfo {
        DeviceQueueCreateInfo {
            s_type: StructureType::DEVICE_QUEUE_CREATE_INFO,
            p_next: ::std::ptr::null(),
            flags: DeviceQueueCreateFlags::default(),
            queue_family_index: u32::default(),
            queue_count: u32::default(),
            p_queue_priorities: ::std::ptr::null(),
        }
    }
}
impl DeviceQueueCreateInfo {
    pub fn builder<'a>() -> DeviceQueueCreateInfoBuilder<'a> {
        DeviceQueueCreateInfoBuilder {
            inner: DeviceQueueCreateInfo::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct DeviceQueueCreateInfoBuilder<'a> {
    inner: DeviceQueueCreateInfo,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsDeviceQueueCreateInfo {}
impl<'a> ::std::ops::Deref for DeviceQueueCreateInfoBuilder<'a> {
    type Target = DeviceQueueCreateInfo;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for DeviceQueueCreateInfoBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> DeviceQueueCreateInfoBuilder<'a> {
    pub fn flags(mut self, flags: DeviceQueueCreateFlags) -> DeviceQueueCreateInfoBuilder<'a> {
        self.inner.flags = flags;
        self
    }
    pub fn queue_family_index(
        mut self,
        queue_family_index: u32,
    ) -> DeviceQueueCreateInfoBuilder<'a> {
        self.inner.queue_family_index = queue_family_index;
        self
    }
    pub fn queue_priorities(
        mut self,
        queue_priorities: &'a [f32],
    ) -> DeviceQueueCreateInfoBuilder<'a> {
        self.inner.queue_count = queue_priorities.len() as _;
        self.inner.p_queue_priorities = queue_priorities.as_ptr();
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsDeviceQueueCreateInfo>(
        mut self,
        next: &'a mut T,
    ) -> DeviceQueueCreateInfoBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> DeviceQueueCreateInfo {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDeviceCreateInfo.html>"]
pub struct DeviceCreateInfo {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub flags: DeviceCreateFlags,
    pub queue_create_info_count: u32,
    pub p_queue_create_infos: *const DeviceQueueCreateInfo,
    pub enabled_layer_count: u32,
    pub pp_enabled_layer_names: *const *const c_char,
    pub enabled_extension_count: u32,
    pub pp_enabled_extension_names: *const *const c_char,
    pub p_enabled_features: *const PhysicalDeviceFeatures,
}
impl ::std::default::Default for DeviceCreateInfo {
    fn default() -> DeviceCreateInfo {
        DeviceCreateInfo {
            s_type: StructureType::DEVICE_CREATE_INFO,
            p_next: ::std::ptr::null(),
            flags: DeviceCreateFlags::default(),
            queue_create_info_count: u32::default(),
            p_queue_create_infos: ::std::ptr::null(),
            enabled_layer_count: u32::default(),
            pp_enabled_layer_names: ::std::ptr::null(),
            enabled_extension_count: u32::default(),
            pp_enabled_extension_names: ::std::ptr::null(),
            p_enabled_features: ::std::ptr::null(),
        }
    }
}
impl DeviceCreateInfo {
    pub fn builder<'a>() -> DeviceCreateInfoBuilder<'a> {
        DeviceCreateInfoBuilder {
            inner: DeviceCreateInfo::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct DeviceCreateInfoBuilder<'a> {
    inner: DeviceCreateInfo,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsDeviceCreateInfo {}
impl<'a> ::std::ops::Deref for DeviceCreateInfoBuilder<'a> {
    type Target = DeviceCreateInfo;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for DeviceCreateInfoBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> DeviceCreateInfoBuilder<'a> {
    pub fn flags(mut self, flags: DeviceCreateFlags) -> DeviceCreateInfoBuilder<'a> {
        self.inner.flags = flags;
        self
    }
    pub fn queue_create_infos(
        mut self,
        queue_create_infos: &'a [DeviceQueueCreateInfo],
    ) -> DeviceCreateInfoBuilder<'a> {
        self.inner.queue_create_info_count = queue_create_infos.len() as _;
        self.inner.p_queue_create_infos = queue_create_infos.as_ptr();
        self
    }
    pub fn enabled_layer_names(
        mut self,
        enabled_layer_names: &'a [*const c_char],
    ) -> DeviceCreateInfoBuilder<'a> {
        self.inner.pp_enabled_layer_names = enabled_layer_names.as_ptr();
        self.inner.enabled_layer_count = enabled_layer_names.len() as _;
        self
    }
    pub fn enabled_extension_names(
        mut self,
        enabled_extension_names: &'a [*const c_char],
    ) -> DeviceCreateInfoBuilder<'a> {
        self.inner.pp_enabled_extension_names = enabled_extension_names.as_ptr();
        self.inner.enabled_extension_count = enabled_extension_names.len() as _;
        self
    }
    pub fn enabled_features(
        mut self,
        enabled_features: &'a PhysicalDeviceFeatures,
    ) -> DeviceCreateInfoBuilder<'a> {
        self.inner.p_enabled_features = enabled_features;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsDeviceCreateInfo>(
        mut self,
        next: &'a mut T,
    ) -> DeviceCreateInfoBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> DeviceCreateInfo {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkInstanceCreateInfo.html>"]
pub struct InstanceCreateInfo {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub flags: InstanceCreateFlags,
    pub p_application_info: *const ApplicationInfo,
    pub enabled_layer_count: u32,
    pub pp_enabled_layer_names: *const *const c_char,
    pub enabled_extension_count: u32,
    pub pp_enabled_extension_names: *const *const c_char,
}
impl ::std::default::Default for InstanceCreateInfo {
    fn default() -> InstanceCreateInfo {
        InstanceCreateInfo {
            s_type: StructureType::INSTANCE_CREATE_INFO,
            p_next: ::std::ptr::null(),
            flags: InstanceCreateFlags::default(),
            p_application_info: ::std::ptr::null(),
            enabled_layer_count: u32::default(),
            pp_enabled_layer_names: ::std::ptr::null(),
            enabled_extension_count: u32::default(),
            pp_enabled_extension_names: ::std::ptr::null(),
        }
    }
}
impl InstanceCreateInfo {
    pub fn builder<'a>() -> InstanceCreateInfoBuilder<'a> {
        InstanceCreateInfoBuilder {
            inner: InstanceCreateInfo::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct InstanceCreateInfoBuilder<'a> {
    inner: InstanceCreateInfo,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsInstanceCreateInfo {}
impl<'a> ::std::ops::Deref for InstanceCreateInfoBuilder<'a> {
    type Target = InstanceCreateInfo;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for InstanceCreateInfoBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> InstanceCreateInfoBuilder<'a> {
    pub fn flags(mut self, flags: InstanceCreateFlags) -> InstanceCreateInfoBuilder<'a> {
        self.inner.flags = flags;
        self
    }
    pub fn application_info(
        mut self,
        application_info: &'a ApplicationInfo,
    ) -> InstanceCreateInfoBuilder<'a> {
        self.inner.p_application_info = application_info;
        self
    }
    pub fn enabled_layer_names(
        mut self,
        enabled_layer_names: &'a [*const c_char],
    ) -> InstanceCreateInfoBuilder<'a> {
        self.inner.pp_enabled_layer_names = enabled_layer_names.as_ptr();
        self.inner.enabled_layer_count = enabled_layer_names.len() as _;
        self
    }
    pub fn enabled_extension_names(
        mut self,
        enabled_extension_names: &'a [*const c_char],
    ) -> InstanceCreateInfoBuilder<'a> {
        self.inner.pp_enabled_extension_names = enabled_extension_names.as_ptr();
        self.inner.enabled_extension_count = enabled_extension_names.len() as _;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsInstanceCreateInfo>(
        mut self,
        next: &'a mut T,
    ) -> InstanceCreateInfoBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> InstanceCreateInfo {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Default, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkQueueFamilyProperties.html>"]
pub struct QueueFamilyProperties {
    pub queue_flags: QueueFlags,
    pub queue_count: u32,
    pub timestamp_valid_bits: u32,
    pub min_image_transfer_granularity: Extent3D,
}
impl QueueFamilyProperties {
    pub fn builder<'a>() -> QueueFamilyPropertiesBuilder<'a> {
        QueueFamilyPropertiesBuilder {
            inner: QueueFamilyProperties::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct QueueFamilyPropertiesBuilder<'a> {
    inner: QueueFamilyProperties,
    marker: ::std::marker::PhantomData<&'a ()>,
}
impl<'a> ::std::ops::Deref for QueueFamilyPropertiesBuilder<'a> {
    type Target = QueueFamilyProperties;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for QueueFamilyPropertiesBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> QueueFamilyPropertiesBuilder<'a> {
    pub fn queue_flags(mut self, queue_flags: QueueFlags) -> QueueFamilyPropertiesBuilder<'a> {
        self.inner.queue_flags = queue_flags;
        self
    }
    pub fn queue_count(mut self, queue_count: u32) -> QueueFamilyPropertiesBuilder<'a> {
        self.inner.queue_count = queue_count;
        self
    }
    pub fn timestamp_valid_bits(
        mut self,
        timestamp_valid_bits: u32,
    ) -> QueueFamilyPropertiesBuilder<'a> {
        self.inner.timestamp_valid_bits = timestamp_valid_bits;
        self
    }
    pub fn min_image_transfer_granularity(
        mut self,
        min_image_transfer_granularity: Extent3D,
    ) -> QueueFamilyPropertiesBuilder<'a> {
        self.inner.min_image_transfer_granularity = min_image_transfer_granularity;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> QueueFamilyProperties {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceMemoryProperties.html>"]
pub struct PhysicalDeviceMemoryProperties {
    pub memory_type_count: u32,
    pub memory_types: [MemoryType; MAX_MEMORY_TYPES],
    pub memory_heap_count: u32,
    pub memory_heaps: [MemoryHeap; MAX_MEMORY_HEAPS],
}
impl ::std::default::Default for PhysicalDeviceMemoryProperties {
    fn default() -> PhysicalDeviceMemoryProperties {
        PhysicalDeviceMemoryProperties {
            memory_type_count: u32::default(),
            memory_types: unsafe { ::std::mem::zeroed() },
            memory_heap_count: u32::default(),
            memory_heaps: unsafe { ::std::mem::zeroed() },
        }
    }
}
impl PhysicalDeviceMemoryProperties {
    pub fn builder<'a>() -> PhysicalDeviceMemoryPropertiesBuilder<'a> {
        PhysicalDeviceMemoryPropertiesBuilder {
            inner: PhysicalDeviceMemoryProperties::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDeviceMemoryPropertiesBuilder<'a> {
    inner: PhysicalDeviceMemoryProperties,
    marker: ::std::marker::PhantomData<&'a ()>,
}
impl<'a> ::std::ops::Deref for PhysicalDeviceMemoryPropertiesBuilder<'a> {
    type Target = PhysicalDeviceMemoryProperties;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PhysicalDeviceMemoryPropertiesBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDeviceMemoryPropertiesBuilder<'a> {
    pub fn memory_type_count(
        mut self,
        memory_type_count: u32,
    ) -> PhysicalDeviceMemoryPropertiesBuilder<'a> {
        self.inner.memory_type_count = memory_type_count;
        self
    }
    pub fn memory_types(
        mut self,
        memory_types: [MemoryType; MAX_MEMORY_TYPES],
    ) -> PhysicalDeviceMemoryPropertiesBuilder<'a> {
        self.inner.memory_types = memory_types;
        self
    }
    pub fn memory_heap_count(
        mut self,
        memory_heap_count: u32,
    ) -> PhysicalDeviceMemoryPropertiesBuilder<'a> {
        self.inner.memory_heap_count = memory_heap_count;
        self
    }
    pub fn memory_heaps(
        mut self,
        memory_heaps: [MemoryHeap; MAX_MEMORY_HEAPS],
    ) -> PhysicalDeviceMemoryPropertiesBuilder<'a> {
        self.inner.memory_heaps = memory_heaps;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDeviceMemoryProperties {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkMemoryAllocateInfo.html>"]
pub struct MemoryAllocateInfo {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub allocation_size: DeviceSize,
    pub memory_type_index: u32,
}
impl ::std::default::Default for MemoryAllocateInfo {
    fn default() -> MemoryAllocateInfo {
        MemoryAllocateInfo {
            s_type: StructureType::MEMORY_ALLOCATE_INFO,
            p_next: ::std::ptr::null(),
            allocation_size: DeviceSize::default(),
            memory_type_index: u32::default(),
        }
    }
}
impl MemoryAllocateInfo {
    pub fn builder<'a>() -> MemoryAllocateInfoBuilder<'a> {
        MemoryAllocateInfoBuilder {
            inner: MemoryAllocateInfo::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct MemoryAllocateInfoBuilder<'a> {
    inner: MemoryAllocateInfo,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsMemoryAllocateInfo {}
impl<'a> ::std::ops::Deref for MemoryAllocateInfoBuilder<'a> {
    type Target = MemoryAllocateInfo;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for MemoryAllocateInfoBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> MemoryAllocateInfoBuilder<'a> {
    pub fn allocation_size(mut self, allocation_size: DeviceSize) -> MemoryAllocateInfoBuilder<'a> {
        self.inner.allocation_size = allocation_size;
        self
    }
    pub fn memory_type_index(mut self, memory_type_index: u32) -> MemoryAllocateInfoBuilder<'a> {
        self.inner.memory_type_index = memory_type_index;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsMemoryAllocateInfo>(
        mut self,
        next: &'a mut T,
    ) -> MemoryAllocateInfoBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> MemoryAllocateInfo {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Default, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkMemoryRequirements.html>"]
pub struct MemoryRequirements {
    pub size: DeviceSize,
    pub alignment: DeviceSize,
    pub memory_type_bits: u32,
}
impl MemoryRequirements {
    pub fn builder<'a>() -> MemoryRequirementsBuilder<'a> {
        MemoryRequirementsBuilder {
            inner: MemoryRequirements::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct MemoryRequirementsBuilder<'a> {
    inner: MemoryRequirements,
    marker: ::std::marker::PhantomData<&'a ()>,
}
impl<'a> ::std::ops::Deref for MemoryRequirementsBuilder<'a> {
    type Target = MemoryRequirements;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for MemoryRequirementsBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> MemoryRequirementsBuilder<'a> {
    pub fn size(mut self, size: DeviceSize) -> MemoryRequirementsBuilder<'a> {
        self.inner.size = size;
        self
    }
    pub fn alignment(mut self, alignment: DeviceSize) -> MemoryRequirementsBuilder<'a> {
        self.inner.alignment = alignment;
        self
    }
    pub fn memory_type_bits(mut self, memory_type_bits: u32) -> MemoryRequirementsBuilder<'a> {
        self.inner.memory_type_bits = memory_type_bits;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> MemoryRequirements {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Default, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSparseImageFormatProperties.html>"]
pub struct SparseImageFormatProperties {
    pub aspect_mask: ImageAspectFlags,
    pub image_granularity: Extent3D,
    pub flags: SparseImageFormatFlags,
}
impl SparseImageFormatProperties {
    pub fn builder<'a>() -> SparseImageFormatPropertiesBuilder<'a> {
        SparseImageFormatPropertiesBuilder {
            inner: SparseImageFormatProperties::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct SparseImageFormatPropertiesBuilder<'a> {
    inner: SparseImageFormatProperties,
    marker: ::std::marker::PhantomData<&'a ()>,
}
impl<'a> ::std::ops::Deref for SparseImageFormatPropertiesBuilder<'a> {
    type Target = SparseImageFormatProperties;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for SparseImageFormatPropertiesBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> SparseImageFormatPropertiesBuilder<'a> {
    pub fn aspect_mask(
        mut self,
        aspect_mask: ImageAspectFlags,
    ) -> SparseImageFormatPropertiesBuilder<'a> {
        self.inner.aspect_mask = aspect_mask;
        self
    }
    pub fn image_granularity(
        mut self,
        image_granularity: Extent3D,
    ) -> SparseImageFormatPropertiesBuilder<'a> {
        self.inner.image_granularity = image_granularity;
        self
    }
    pub fn flags(
        mut self,
        flags: SparseImageFormatFlags,
    ) -> SparseImageFormatPropertiesBuilder<'a> {
        self.inner.flags = flags;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> SparseImageFormatProperties {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Default, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSparseImageMemoryRequirements.html>"]
pub struct SparseImageMemoryRequirements {
    pub format_properties: SparseImageFormatProperties,
    pub image_mip_tail_first_lod: u32,
    pub image_mip_tail_size: DeviceSize,
    pub image_mip_tail_offset: DeviceSize,
    pub image_mip_tail_stride: DeviceSize,
}
impl SparseImageMemoryRequirements {
    pub fn builder<'a>() -> SparseImageMemoryRequirementsBuilder<'a> {
        SparseImageMemoryRequirementsBuilder {
            inner: SparseImageMemoryRequirements::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct SparseImageMemoryRequirementsBuilder<'a> {
    inner: SparseImageMemoryRequirements,
    marker: ::std::marker::PhantomData<&'a ()>,
}
impl<'a> ::std::ops::Deref for SparseImageMemoryRequirementsBuilder<'a> {
    type Target = SparseImageMemoryRequirements;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for SparseImageMemoryRequirementsBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> SparseImageMemoryRequirementsBuilder<'a> {
    pub fn format_properties(
        mut self,
        format_properties: SparseImageFormatProperties,
    ) -> SparseImageMemoryRequirementsBuilder<'a> {
        self.inner.format_properties = format_properties;
        self
    }
    pub fn image_mip_tail_first_lod(
        mut self,
        image_mip_tail_first_lod: u32,
    ) -> SparseImageMemoryRequirementsBuilder<'a> {
        self.inner.image_mip_tail_first_lod = image_mip_tail_first_lod;
        self
    }
    pub fn image_mip_tail_size(
        mut self,
        image_mip_tail_size: DeviceSize,
    ) -> SparseImageMemoryRequirementsBuilder<'a> {
        self.inner.image_mip_tail_size = image_mip_tail_size;
        self
    }
    pub fn image_mip_tail_offset(
        mut self,
        image_mip_tail_offset: DeviceSize,
    ) -> SparseImageMemoryRequirementsBuilder<'a> {
        self.inner.image_mip_tail_offset = image_mip_tail_offset;
        self
    }
    pub fn image_mip_tail_stride(
        mut self,
        image_mip_tail_stride: DeviceSize,
    ) -> SparseImageMemoryRequirementsBuilder<'a> {
        self.inner.image_mip_tail_stride = image_mip_tail_stride;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> SparseImageMemoryRequirements {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Default, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkMemoryType.html>"]
pub struct MemoryType {
    pub property_flags: MemoryPropertyFlags,
    pub heap_index: u32,
}
impl MemoryType {
    pub fn builder<'a>() -> MemoryTypeBuilder<'a> {
        MemoryTypeBuilder {
            inner: MemoryType::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct MemoryTypeBuilder<'a> {
    inner: MemoryType,
    marker: ::std::marker::PhantomData<&'a ()>,
}
impl<'a> ::std::ops::Deref for MemoryTypeBuilder<'a> {
    type Target = MemoryType;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for MemoryTypeBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> MemoryTypeBuilder<'a> {
    pub fn property_flags(mut self, property_flags: MemoryPropertyFlags) -> MemoryTypeBuilder<'a> {
        self.inner.property_flags = property_flags;
        self
    }
    pub fn heap_index(mut self, heap_index: u32) -> MemoryTypeBuilder<'a> {
        self.inner.heap_index = heap_index;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> MemoryType {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Default, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkMemoryHeap.html>"]
pub struct MemoryHeap {
    pub size: DeviceSize,
    pub flags: MemoryHeapFlags,
}
impl MemoryHeap {
    pub fn builder<'a>() -> MemoryHeapBuilder<'a> {
        MemoryHeapBuilder {
            inner: MemoryHeap::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct MemoryHeapBuilder<'a> {
    inner: MemoryHeap,
    marker: ::std::marker::PhantomData<&'a ()>,
}
impl<'a> ::std::ops::Deref for MemoryHeapBuilder<'a> {
    type Target = MemoryHeap;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for MemoryHeapBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> MemoryHeapBuilder<'a> {
    pub fn size(mut self, size: DeviceSize) -> MemoryHeapBuilder<'a> {
        self.inner.size = size;
        self
    }
    pub fn flags(mut self, flags: MemoryHeapFlags) -> MemoryHeapBuilder<'a> {
        self.inner.flags = flags;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> MemoryHeap {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkMappedMemoryRange.html>"]
pub struct MappedMemoryRange {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub memory: DeviceMemory,
    pub offset: DeviceSize,
    pub size: DeviceSize,
}
impl ::std::default::Default for MappedMemoryRange {
    fn default() -> MappedMemoryRange {
        MappedMemoryRange {
            s_type: StructureType::MAPPED_MEMORY_RANGE,
            p_next: ::std::ptr::null(),
            memory: DeviceMemory::default(),
            offset: DeviceSize::default(),
            size: DeviceSize::default(),
        }
    }
}
impl MappedMemoryRange {
    pub fn builder<'a>() -> MappedMemoryRangeBuilder<'a> {
        MappedMemoryRangeBuilder {
            inner: MappedMemoryRange::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct MappedMemoryRangeBuilder<'a> {
    inner: MappedMemoryRange,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsMappedMemoryRange {}
impl<'a> ::std::ops::Deref for MappedMemoryRangeBuilder<'a> {
    type Target = MappedMemoryRange;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for MappedMemoryRangeBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> MappedMemoryRangeBuilder<'a> {
    pub fn memory(mut self, memory: DeviceMemory) -> MappedMemoryRangeBuilder<'a> {
        self.inner.memory = memory;
        self
    }
    pub fn offset(mut self, offset: DeviceSize) -> MappedMemoryRangeBuilder<'a> {
        self.inner.offset = offset;
        self
    }
    pub fn size(mut self, size: DeviceSize) -> MappedMemoryRangeBuilder<'a> {
        self.inner.size = size;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsMappedMemoryRange>(
        mut self,
        next: &'a mut T,
    ) -> MappedMemoryRangeBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> MappedMemoryRange {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Default, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkFormatProperties.html>"]
pub struct FormatProperties {
    pub linear_tiling_features: FormatFeatureFlags,
    pub optimal_tiling_features: FormatFeatureFlags,
    pub buffer_features: FormatFeatureFlags,
}
impl FormatProperties {
    pub fn builder<'a>() -> FormatPropertiesBuilder<'a> {
        FormatPropertiesBuilder {
            inner: FormatProperties::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct FormatPropertiesBuilder<'a> {
    inner: FormatProperties,
    marker: ::std::marker::PhantomData<&'a ()>,
}
impl<'a> ::std::ops::Deref for FormatPropertiesBuilder<'a> {
    type Target = FormatProperties;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for FormatPropertiesBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> FormatPropertiesBuilder<'a> {
    pub fn linear_tiling_features(
        mut self,
        linear_tiling_features: FormatFeatureFlags,
    ) -> FormatPropertiesBuilder<'a> {
        self.inner.linear_tiling_features = linear_tiling_features;
        self
    }
    pub fn optimal_tiling_features(
        mut self,
        optimal_tiling_features: FormatFeatureFlags,
    ) -> FormatPropertiesBuilder<'a> {
        self.inner.optimal_tiling_features = optimal_tiling_features;
        self
    }
    pub fn buffer_features(
        mut self,
        buffer_features: FormatFeatureFlags,
    ) -> FormatPropertiesBuilder<'a> {
        self.inner.buffer_features = buffer_features;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> FormatProperties {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Default, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImageFormatProperties.html>"]
pub struct ImageFormatProperties {
    pub max_extent: Extent3D,
    pub max_mip_levels: u32,
    pub max_array_layers: u32,
    pub sample_counts: SampleCountFlags,
    pub max_resource_size: DeviceSize,
}
impl ImageFormatProperties {
    pub fn builder<'a>() -> ImageFormatPropertiesBuilder<'a> {
        ImageFormatPropertiesBuilder {
            inner: ImageFormatProperties::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct ImageFormatPropertiesBuilder<'a> {
    inner: ImageFormatProperties,
    marker: ::std::marker::PhantomData<&'a ()>,
}
impl<'a> ::std::ops::Deref for ImageFormatPropertiesBuilder<'a> {
    type Target = ImageFormatProperties;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for ImageFormatPropertiesBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> ImageFormatPropertiesBuilder<'a> {
    pub fn max_extent(mut self, max_extent: Extent3D) -> ImageFormatPropertiesBuilder<'a> {
        self.inner.max_extent = max_extent;
        self
    }
    pub fn max_mip_levels(mut self, max_mip_levels: u32) -> ImageFormatPropertiesBuilder<'a> {
        self.inner.max_mip_levels = max_mip_levels;
        self
    }
    pub fn max_array_layers(mut self, max_array_layers: u32) -> ImageFormatPropertiesBuilder<'a> {
        self.inner.max_array_layers = max_array_layers;
        self
    }
    pub fn sample_counts(
        mut self,
        sample_counts: SampleCountFlags,
    ) -> ImageFormatPropertiesBuilder<'a> {
        self.inner.sample_counts = sample_counts;
        self
    }
    pub fn max_resource_size(
        mut self,
        max_resource_size: DeviceSize,
    ) -> ImageFormatPropertiesBuilder<'a> {
        self.inner.max_resource_size = max_resource_size;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> ImageFormatProperties {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Default, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDescriptorBufferInfo.html>"]
pub struct DescriptorBufferInfo {
    pub buffer: Buffer,
    pub offset: DeviceSize,
    pub range: DeviceSize,
}
impl DescriptorBufferInfo {
    pub fn builder<'a>() -> DescriptorBufferInfoBuilder<'a> {
        DescriptorBufferInfoBuilder {
            inner: DescriptorBufferInfo::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct DescriptorBufferInfoBuilder<'a> {
    inner: DescriptorBufferInfo,
    marker: ::std::marker::PhantomData<&'a ()>,
}
impl<'a> ::std::ops::Deref for DescriptorBufferInfoBuilder<'a> {
    type Target = DescriptorBufferInfo;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for DescriptorBufferInfoBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> DescriptorBufferInfoBuilder<'a> {
    pub fn buffer(mut self, buffer: Buffer) -> DescriptorBufferInfoBuilder<'a> {
        self.inner.buffer = buffer;
        self
    }
    pub fn offset(mut self, offset: DeviceSize) -> DescriptorBufferInfoBuilder<'a> {
        self.inner.offset = offset;
        self
    }
    pub fn range(mut self, range: DeviceSize) -> DescriptorBufferInfoBuilder<'a> {
        self.inner.range = range;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> DescriptorBufferInfo {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Default, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDescriptorImageInfo.html>"]
pub struct DescriptorImageInfo {
    pub sampler: Sampler,
    pub image_view: ImageView,
    pub image_layout: ImageLayout,
}
impl DescriptorImageInfo {
    pub fn builder<'a>() -> DescriptorImageInfoBuilder<'a> {
        DescriptorImageInfoBuilder {
            inner: DescriptorImageInfo::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct DescriptorImageInfoBuilder<'a> {
    inner: DescriptorImageInfo,
    marker: ::std::marker::PhantomData<&'a ()>,
}
impl<'a> ::std::ops::Deref for DescriptorImageInfoBuilder<'a> {
    type Target = DescriptorImageInfo;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for DescriptorImageInfoBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> DescriptorImageInfoBuilder<'a> {
    pub fn sampler(mut self, sampler: Sampler) -> DescriptorImageInfoBuilder<'a> {
        self.inner.sampler = sampler;
        self
    }
    pub fn image_view(mut self, image_view: ImageView) -> DescriptorImageInfoBuilder<'a> {
        self.inner.image_view = image_view;
        self
    }
    pub fn image_layout(mut self, image_layout: ImageLayout) -> DescriptorImageInfoBuilder<'a> {
        self.inner.image_layout = image_layout;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> DescriptorImageInfo {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkWriteDescriptorSet.html>"]
pub struct WriteDescriptorSet {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub dst_set: DescriptorSet,
    pub dst_binding: u32,
    pub dst_array_element: u32,
    pub descriptor_count: u32,
    pub descriptor_type: DescriptorType,
    pub p_image_info: *const DescriptorImageInfo,
    pub p_buffer_info: *const DescriptorBufferInfo,
    pub p_texel_buffer_view: *const BufferView,
}
impl ::std::default::Default for WriteDescriptorSet {
    fn default() -> WriteDescriptorSet {
        WriteDescriptorSet {
            s_type: StructureType::WRITE_DESCRIPTOR_SET,
            p_next: ::std::ptr::null(),
            dst_set: DescriptorSet::default(),
            dst_binding: u32::default(),
            dst_array_element: u32::default(),
            descriptor_count: u32::default(),
            descriptor_type: DescriptorType::default(),
            p_image_info: ::std::ptr::null(),
            p_buffer_info: ::std::ptr::null(),
            p_texel_buffer_view: ::std::ptr::null(),
        }
    }
}
impl WriteDescriptorSet {
    pub fn builder<'a>() -> WriteDescriptorSetBuilder<'a> {
        WriteDescriptorSetBuilder {
            inner: WriteDescriptorSet::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct WriteDescriptorSetBuilder<'a> {
    inner: WriteDescriptorSet,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsWriteDescriptorSet {}
impl<'a> ::std::ops::Deref for WriteDescriptorSetBuilder<'a> {
    type Target = WriteDescriptorSet;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for WriteDescriptorSetBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> WriteDescriptorSetBuilder<'a> {
    pub fn dst_set(mut self, dst_set: DescriptorSet) -> WriteDescriptorSetBuilder<'a> {
        self.inner.dst_set = dst_set;
        self
    }
    pub fn dst_binding(mut self, dst_binding: u32) -> WriteDescriptorSetBuilder<'a> {
        self.inner.dst_binding = dst_binding;
        self
    }
    pub fn dst_array_element(mut self, dst_array_element: u32) -> WriteDescriptorSetBuilder<'a> {
        self.inner.dst_array_element = dst_array_element;
        self
    }
    pub fn descriptor_type(
        mut self,
        descriptor_type: DescriptorType,
    ) -> WriteDescriptorSetBuilder<'a> {
        self.inner.descriptor_type = descriptor_type;
        self
    }
    pub fn image_info(
        mut self,
        image_info: &'a [DescriptorImageInfo],
    ) -> WriteDescriptorSetBuilder<'a> {
        self.inner.descriptor_count = image_info.len() as _;
        self.inner.p_image_info = image_info.as_ptr();
        self
    }
    pub fn buffer_info(
        mut self,
        buffer_info: &'a [DescriptorBufferInfo],
    ) -> WriteDescriptorSetBuilder<'a> {
        self.inner.descriptor_count = buffer_info.len() as _;
        self.inner.p_buffer_info = buffer_info.as_ptr();
        self
    }
    pub fn texel_buffer_view(
        mut self,
        texel_buffer_view: &'a [BufferView],
    ) -> WriteDescriptorSetBuilder<'a> {
        self.inner.descriptor_count = texel_buffer_view.len() as _;
        self.inner.p_texel_buffer_view = texel_buffer_view.as_ptr();
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsWriteDescriptorSet>(
        mut self,
        next: &'a mut T,
    ) -> WriteDescriptorSetBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> WriteDescriptorSet {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCopyDescriptorSet.html>"]
pub struct CopyDescriptorSet {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub src_set: DescriptorSet,
    pub src_binding: u32,
    pub src_array_element: u32,
    pub dst_set: DescriptorSet,
    pub dst_binding: u32,
    pub dst_array_element: u32,
    pub descriptor_count: u32,
}
impl ::std::default::Default for CopyDescriptorSet {
    fn default() -> CopyDescriptorSet {
        CopyDescriptorSet {
            s_type: StructureType::COPY_DESCRIPTOR_SET,
            p_next: ::std::ptr::null(),
            src_set: DescriptorSet::default(),
            src_binding: u32::default(),
            src_array_element: u32::default(),
            dst_set: DescriptorSet::default(),
            dst_binding: u32::default(),
            dst_array_element: u32::default(),
            descriptor_count: u32::default(),
        }
    }
}
impl CopyDescriptorSet {
    pub fn builder<'a>() -> CopyDescriptorSetBuilder<'a> {
        CopyDescriptorSetBuilder {
            inner: CopyDescriptorSet::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct CopyDescriptorSetBuilder<'a> {
    inner: CopyDescriptorSet,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsCopyDescriptorSet {}
impl<'a> ::std::ops::Deref for CopyDescriptorSetBuilder<'a> {
    type Target = CopyDescriptorSet;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for CopyDescriptorSetBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> CopyDescriptorSetBuilder<'a> {
    pub fn src_set(mut self, src_set: DescriptorSet) -> CopyDescriptorSetBuilder<'a> {
        self.inner.src_set = src_set;
        self
    }
    pub fn src_binding(mut self, src_binding: u32) -> CopyDescriptorSetBuilder<'a> {
        self.inner.src_binding = src_binding;
        self
    }
    pub fn src_array_element(mut self, src_array_element: u32) -> CopyDescriptorSetBuilder<'a> {
        self.inner.src_array_element = src_array_element;
        self
    }
    pub fn dst_set(mut self, dst_set: DescriptorSet) -> CopyDescriptorSetBuilder<'a> {
        self.inner.dst_set = dst_set;
        self
    }
    pub fn dst_binding(mut self, dst_binding: u32) -> CopyDescriptorSetBuilder<'a> {
        self.inner.dst_binding = dst_binding;
        self
    }
    pub fn dst_array_element(mut self, dst_array_element: u32) -> CopyDescriptorSetBuilder<'a> {
        self.inner.dst_array_element = dst_array_element;
        self
    }
    pub fn descriptor_count(mut self, descriptor_count: u32) -> CopyDescriptorSetBuilder<'a> {
        self.inner.descriptor_count = descriptor_count;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsCopyDescriptorSet>(
        mut self,
        next: &'a mut T,
    ) -> CopyDescriptorSetBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> CopyDescriptorSet {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkBufferCreateInfo.html>"]
pub struct BufferCreateInfo {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub flags: BufferCreateFlags,
    pub size: DeviceSize,
    pub usage: BufferUsageFlags,
    pub sharing_mode: SharingMode,
    pub queue_family_index_count: u32,
    pub p_queue_family_indices: *const u32,
}
impl ::std::default::Default for BufferCreateInfo {
    fn default() -> BufferCreateInfo {
        BufferCreateInfo {
            s_type: StructureType::BUFFER_CREATE_INFO,
            p_next: ::std::ptr::null(),
            flags: BufferCreateFlags::default(),
            size: DeviceSize::default(),
            usage: BufferUsageFlags::default(),
            sharing_mode: SharingMode::default(),
            queue_family_index_count: u32::default(),
            p_queue_family_indices: ::std::ptr::null(),
        }
    }
}
impl BufferCreateInfo {
    pub fn builder<'a>() -> BufferCreateInfoBuilder<'a> {
        BufferCreateInfoBuilder {
            inner: BufferCreateInfo::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct BufferCreateInfoBuilder<'a> {
    inner: BufferCreateInfo,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsBufferCreateInfo {}
impl<'a> ::std::ops::Deref for BufferCreateInfoBuilder<'a> {
    type Target = BufferCreateInfo;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for BufferCreateInfoBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> BufferCreateInfoBuilder<'a> {
    pub fn flags(mut self, flags: BufferCreateFlags) -> BufferCreateInfoBuilder<'a> {
        self.inner.flags = flags;
        self
    }
    pub fn size(mut self, size: DeviceSize) -> BufferCreateInfoBuilder<'a> {
        self.inner.size = size;
        self
    }
    pub fn usage(mut self, usage: BufferUsageFlags) -> BufferCreateInfoBuilder<'a> {
        self.inner.usage = usage;
        self
    }
    pub fn sharing_mode(mut self, sharing_mode: SharingMode) -> BufferCreateInfoBuilder<'a> {
        self.inner.sharing_mode = sharing_mode;
        self
    }
    pub fn queue_family_indices(
        mut self,
        queue_family_indices: &'a [u32],
    ) -> BufferCreateInfoBuilder<'a> {
        self.inner.queue_family_index_count = queue_family_indices.len() as _;
        self.inner.p_queue_family_indices = queue_family_indices.as_ptr();
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsBufferCreateInfo>(
        mut self,
        next: &'a mut T,
    ) -> BufferCreateInfoBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> BufferCreateInfo {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkBufferViewCreateInfo.html>"]
pub struct BufferViewCreateInfo {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub flags: BufferViewCreateFlags,
    pub buffer: Buffer,
    pub format: Format,
    pub offset: DeviceSize,
    pub range: DeviceSize,
}
impl ::std::default::Default for BufferViewCreateInfo {
    fn default() -> BufferViewCreateInfo {
        BufferViewCreateInfo {
            s_type: StructureType::BUFFER_VIEW_CREATE_INFO,
            p_next: ::std::ptr::null(),
            flags: BufferViewCreateFlags::default(),
            buffer: Buffer::default(),
            format: Format::default(),
            offset: DeviceSize::default(),
            range: DeviceSize::default(),
        }
    }
}
impl BufferViewCreateInfo {
    pub fn builder<'a>() -> BufferViewCreateInfoBuilder<'a> {
        BufferViewCreateInfoBuilder {
            inner: BufferViewCreateInfo::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct BufferViewCreateInfoBuilder<'a> {
    inner: BufferViewCreateInfo,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsBufferViewCreateInfo {}
impl<'a> ::std::ops::Deref for BufferViewCreateInfoBuilder<'a> {
    type Target = BufferViewCreateInfo;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for BufferViewCreateInfoBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> BufferViewCreateInfoBuilder<'a> {
    pub fn flags(mut self, flags: BufferViewCreateFlags) -> BufferViewCreateInfoBuilder<'a> {
        self.inner.flags = flags;
        self
    }
    pub fn buffer(mut self, buffer: Buffer) -> BufferViewCreateInfoBuilder<'a> {
        self.inner.buffer = buffer;
        self
    }
    pub fn format(mut self, format: Format) -> BufferViewCreateInfoBuilder<'a> {
        self.inner.format = format;
        self
    }
    pub fn offset(mut self, offset: DeviceSize) -> BufferViewCreateInfoBuilder<'a> {
        self.inner.offset = offset;
        self
    }
    pub fn range(mut self, range: DeviceSize) -> BufferViewCreateInfoBuilder<'a> {
        self.inner.range = range;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsBufferViewCreateInfo>(
        mut self,
        next: &'a mut T,
    ) -> BufferViewCreateInfoBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> BufferViewCreateInfo {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Default, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImageSubresource.html>"]
pub struct ImageSubresource {
    pub aspect_mask: ImageAspectFlags,
    pub mip_level: u32,
    pub array_layer: u32,
}
impl ImageSubresource {
    pub fn builder<'a>() -> ImageSubresourceBuilder<'a> {
        ImageSubresourceBuilder {
            inner: ImageSubresource::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct ImageSubresourceBuilder<'a> {
    inner: ImageSubresource,
    marker: ::std::marker::PhantomData<&'a ()>,
}
impl<'a> ::std::ops::Deref for ImageSubresourceBuilder<'a> {
    type Target = ImageSubresource;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for ImageSubresourceBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> ImageSubresourceBuilder<'a> {
    pub fn aspect_mask(mut self, aspect_mask: ImageAspectFlags) -> ImageSubresourceBuilder<'a> {
        self.inner.aspect_mask = aspect_mask;
        self
    }
    pub fn mip_level(mut self, mip_level: u32) -> ImageSubresourceBuilder<'a> {
        self.inner.mip_level = mip_level;
        self
    }
    pub fn array_layer(mut self, array_layer: u32) -> ImageSubresourceBuilder<'a> {
        self.inner.array_layer = array_layer;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> ImageSubresource {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Default, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImageSubresourceLayers.html>"]
pub struct ImageSubresourceLayers {
    pub aspect_mask: ImageAspectFlags,
    pub mip_level: u32,
    pub base_array_layer: u32,
    pub layer_count: u32,
}
impl ImageSubresourceLayers {
    pub fn builder<'a>() -> ImageSubresourceLayersBuilder<'a> {
        ImageSubresourceLayersBuilder {
            inner: ImageSubresourceLayers::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct ImageSubresourceLayersBuilder<'a> {
    inner: ImageSubresourceLayers,
    marker: ::std::marker::PhantomData<&'a ()>,
}
impl<'a> ::std::ops::Deref for ImageSubresourceLayersBuilder<'a> {
    type Target = ImageSubresourceLayers;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for ImageSubresourceLayersBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> ImageSubresourceLayersBuilder<'a> {
    pub fn aspect_mask(
        mut self,
        aspect_mask: ImageAspectFlags,
    ) -> ImageSubresourceLayersBuilder<'a> {
        self.inner.aspect_mask = aspect_mask;
        self
    }
    pub fn mip_level(mut self, mip_level: u32) -> ImageSubresourceLayersBuilder<'a> {
        self.inner.mip_level = mip_level;
        self
    }
    pub fn base_array_layer(mut self, base_array_layer: u32) -> ImageSubresourceLayersBuilder<'a> {
        self.inner.base_array_layer = base_array_layer;
        self
    }
    pub fn layer_count(mut self, layer_count: u32) -> ImageSubresourceLayersBuilder<'a> {
        self.inner.layer_count = layer_count;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> ImageSubresourceLayers {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Default, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImageSubresourceRange.html>"]
pub struct ImageSubresourceRange {
    pub aspect_mask: ImageAspectFlags,
    pub base_mip_level: u32,
    pub level_count: u32,
    pub base_array_layer: u32,
    pub layer_count: u32,
}
impl ImageSubresourceRange {
    pub fn builder<'a>() -> ImageSubresourceRangeBuilder<'a> {
        ImageSubresourceRangeBuilder {
            inner: ImageSubresourceRange::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct ImageSubresourceRangeBuilder<'a> {
    inner: ImageSubresourceRange,
    marker: ::std::marker::PhantomData<&'a ()>,
}
impl<'a> ::std::ops::Deref for ImageSubresourceRangeBuilder<'a> {
    type Target = ImageSubresourceRange;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for ImageSubresourceRangeBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> ImageSubresourceRangeBuilder<'a> {
    pub fn aspect_mask(
        mut self,
        aspect_mask: ImageAspectFlags,
    ) -> ImageSubresourceRangeBuilder<'a> {
        self.inner.aspect_mask = aspect_mask;
        self
    }
    pub fn base_mip_level(mut self, base_mip_level: u32) -> ImageSubresourceRangeBuilder<'a> {
        self.inner.base_mip_level = base_mip_level;
        self
    }
    pub fn level_count(mut self, level_count: u32) -> ImageSubresourceRangeBuilder<'a> {
        self.inner.level_count = level_count;
        self
    }
    pub fn base_array_layer(mut self, base_array_layer: u32) -> ImageSubresourceRangeBuilder<'a> {
        self.inner.base_array_layer = base_array_layer;
        self
    }
    pub fn layer_count(mut self, layer_count: u32) -> ImageSubresourceRangeBuilder<'a> {
        self.inner.layer_count = layer_count;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> ImageSubresourceRange {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkMemoryBarrier.html>"]
pub struct MemoryBarrier {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub src_access_mask: AccessFlags,
    pub dst_access_mask: AccessFlags,
}
impl ::std::default::Default for MemoryBarrier {
    fn default() -> MemoryBarrier {
        MemoryBarrier {
            s_type: StructureType::MEMORY_BARRIER,
            p_next: ::std::ptr::null(),
            src_access_mask: AccessFlags::default(),
            dst_access_mask: AccessFlags::default(),
        }
    }
}
impl MemoryBarrier {
    pub fn builder<'a>() -> MemoryBarrierBuilder<'a> {
        MemoryBarrierBuilder {
            inner: MemoryBarrier::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct MemoryBarrierBuilder<'a> {
    inner: MemoryBarrier,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsMemoryBarrier {}
impl<'a> ::std::ops::Deref for MemoryBarrierBuilder<'a> {
    type Target = MemoryBarrier;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for MemoryBarrierBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> MemoryBarrierBuilder<'a> {
    pub fn src_access_mask(mut self, src_access_mask: AccessFlags) -> MemoryBarrierBuilder<'a> {
        self.inner.src_access_mask = src_access_mask;
        self
    }
    pub fn dst_access_mask(mut self, dst_access_mask: AccessFlags) -> MemoryBarrierBuilder<'a> {
        self.inner.dst_access_mask = dst_access_mask;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsMemoryBarrier>(
        mut self,
        next: &'a mut T,
    ) -> MemoryBarrierBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> MemoryBarrier {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkBufferMemoryBarrier.html>"]
pub struct BufferMemoryBarrier {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub src_access_mask: AccessFlags,
    pub dst_access_mask: AccessFlags,
    pub src_queue_family_index: u32,
    pub dst_queue_family_index: u32,
    pub buffer: Buffer,
    pub offset: DeviceSize,
    pub size: DeviceSize,
}
impl ::std::default::Default for BufferMemoryBarrier {
    fn default() -> BufferMemoryBarrier {
        BufferMemoryBarrier {
            s_type: StructureType::BUFFER_MEMORY_BARRIER,
            p_next: ::std::ptr::null(),
            src_access_mask: AccessFlags::default(),
            dst_access_mask: AccessFlags::default(),
            src_queue_family_index: u32::default(),
            dst_queue_family_index: u32::default(),
            buffer: Buffer::default(),
            offset: DeviceSize::default(),
            size: DeviceSize::default(),
        }
    }
}
impl BufferMemoryBarrier {
    pub fn builder<'a>() -> BufferMemoryBarrierBuilder<'a> {
        BufferMemoryBarrierBuilder {
            inner: BufferMemoryBarrier::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct BufferMemoryBarrierBuilder<'a> {
    inner: BufferMemoryBarrier,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsBufferMemoryBarrier {}
impl<'a> ::std::ops::Deref for BufferMemoryBarrierBuilder<'a> {
    type Target = BufferMemoryBarrier;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for BufferMemoryBarrierBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> BufferMemoryBarrierBuilder<'a> {
    pub fn src_access_mask(
        mut self,
        src_access_mask: AccessFlags,
    ) -> BufferMemoryBarrierBuilder<'a> {
        self.inner.src_access_mask = src_access_mask;
        self
    }
    pub fn dst_access_mask(
        mut self,
        dst_access_mask: AccessFlags,
    ) -> BufferMemoryBarrierBuilder<'a> {
        self.inner.dst_access_mask = dst_access_mask;
        self
    }
    pub fn src_queue_family_index(
        mut self,
        src_queue_family_index: u32,
    ) -> BufferMemoryBarrierBuilder<'a> {
        self.inner.src_queue_family_index = src_queue_family_index;
        self
    }
    pub fn dst_queue_family_index(
        mut self,
        dst_queue_family_index: u32,
    ) -> BufferMemoryBarrierBuilder<'a> {
        self.inner.dst_queue_family_index = dst_queue_family_index;
        self
    }
    pub fn buffer(mut self, buffer: Buffer) -> BufferMemoryBarrierBuilder<'a> {
        self.inner.buffer = buffer;
        self
    }
    pub fn offset(mut self, offset: DeviceSize) -> BufferMemoryBarrierBuilder<'a> {
        self.inner.offset = offset;
        self
    }
    pub fn size(mut self, size: DeviceSize) -> BufferMemoryBarrierBuilder<'a> {
        self.inner.size = size;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsBufferMemoryBarrier>(
        mut self,
        next: &'a mut T,
    ) -> BufferMemoryBarrierBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> BufferMemoryBarrier {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImageMemoryBarrier.html>"]
pub struct ImageMemoryBarrier {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub src_access_mask: AccessFlags,
    pub dst_access_mask: AccessFlags,
    pub old_layout: ImageLayout,
    pub new_layout: ImageLayout,
    pub src_queue_family_index: u32,
    pub dst_queue_family_index: u32,
    pub image: Image,
    pub subresource_range: ImageSubresourceRange,
}
impl ::std::default::Default for ImageMemoryBarrier {
    fn default() -> ImageMemoryBarrier {
        ImageMemoryBarrier {
            s_type: StructureType::IMAGE_MEMORY_BARRIER,
            p_next: ::std::ptr::null(),
            src_access_mask: AccessFlags::default(),
            dst_access_mask: AccessFlags::default(),
            old_layout: ImageLayout::default(),
            new_layout: ImageLayout::default(),
            src_queue_family_index: u32::default(),
            dst_queue_family_index: u32::default(),
            image: Image::default(),
            subresource_range: ImageSubresourceRange::default(),
        }
    }
}
impl ImageMemoryBarrier {
    pub fn builder<'a>() -> ImageMemoryBarrierBuilder<'a> {
        ImageMemoryBarrierBuilder {
            inner: ImageMemoryBarrier::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct ImageMemoryBarrierBuilder<'a> {
    inner: ImageMemoryBarrier,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsImageMemoryBarrier {}
impl<'a> ::std::ops::Deref for ImageMemoryBarrierBuilder<'a> {
    type Target = ImageMemoryBarrier;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for ImageMemoryBarrierBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> ImageMemoryBarrierBuilder<'a> {
    pub fn src_access_mask(
        mut self,
        src_access_mask: AccessFlags,
    ) -> ImageMemoryBarrierBuilder<'a> {
        self.inner.src_access_mask = src_access_mask;
        self
    }
    pub fn dst_access_mask(
        mut self,
        dst_access_mask: AccessFlags,
    ) -> ImageMemoryBarrierBuilder<'a> {
        self.inner.dst_access_mask = dst_access_mask;
        self
    }
    pub fn old_layout(mut self, old_layout: ImageLayout) -> ImageMemoryBarrierBuilder<'a> {
        self.inner.old_layout = old_layout;
        self
    }
    pub fn new_layout(mut self, new_layout: ImageLayout) -> ImageMemoryBarrierBuilder<'a> {
        self.inner.new_layout = new_layout;
        self
    }
    pub fn src_queue_family_index(
        mut self,
        src_queue_family_index: u32,
    ) -> ImageMemoryBarrierBuilder<'a> {
        self.inner.src_queue_family_index = src_queue_family_index;
        self
    }
    pub fn dst_queue_family_index(
        mut self,
        dst_queue_family_index: u32,
    ) -> ImageMemoryBarrierBuilder<'a> {
        self.inner.dst_queue_family_index = dst_queue_family_index;
        self
    }
    pub fn image(mut self, image: Image) -> ImageMemoryBarrierBuilder<'a> {
        self.inner.image = image;
        self
    }
    pub fn subresource_range(
        mut self,
        subresource_range: ImageSubresourceRange,
    ) -> ImageMemoryBarrierBuilder<'a> {
        self.inner.subresource_range = subresource_range;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsImageMemoryBarrier>(
        mut self,
        next: &'a mut T,
    ) -> ImageMemoryBarrierBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> ImageMemoryBarrier {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImageCreateInfo.html>"]
pub struct ImageCreateInfo {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub flags: ImageCreateFlags,
    pub image_type: ImageType,
    pub format: Format,
    pub extent: Extent3D,
    pub mip_levels: u32,
    pub array_layers: u32,
    pub samples: SampleCountFlags,
    pub tiling: ImageTiling,
    pub usage: ImageUsageFlags,
    pub sharing_mode: SharingMode,
    pub queue_family_index_count: u32,
    pub p_queue_family_indices: *const u32,
    pub initial_layout: ImageLayout,
}
impl ::std::default::Default for ImageCreateInfo {
    fn default() -> ImageCreateInfo {
        ImageCreateInfo {
            s_type: StructureType::IMAGE_CREATE_INFO,
            p_next: ::std::ptr::null(),
            flags: ImageCreateFlags::default(),
            image_type: ImageType::default(),
            format: Format::default(),
            extent: Extent3D::default(),
            mip_levels: u32::default(),
            array_layers: u32::default(),
            samples: SampleCountFlags::default(),
            tiling: ImageTiling::default(),
            usage: ImageUsageFlags::default(),
            sharing_mode: SharingMode::default(),
            queue_family_index_count: u32::default(),
            p_queue_family_indices: ::std::ptr::null(),
            initial_layout: ImageLayout::default(),
        }
    }
}
impl ImageCreateInfo {
    pub fn builder<'a>() -> ImageCreateInfoBuilder<'a> {
        ImageCreateInfoBuilder {
            inner: ImageCreateInfo::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct ImageCreateInfoBuilder<'a> {
    inner: ImageCreateInfo,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsImageCreateInfo {}
impl<'a> ::std::ops::Deref for ImageCreateInfoBuilder<'a> {
    type Target = ImageCreateInfo;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for ImageCreateInfoBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> ImageCreateInfoBuilder<'a> {
    pub fn flags(mut self, flags: ImageCreateFlags) -> ImageCreateInfoBuilder<'a> {
        self.inner.flags = flags;
        self
    }
    pub fn image_type(mut self, image_type: ImageType) -> ImageCreateInfoBuilder<'a> {
        self.inner.image_type = image_type;
        self
    }
    pub fn format(mut self, format: Format) -> ImageCreateInfoBuilder<'a> {
        self.inner.format = format;
        self
    }
    pub fn extent(mut self, extent: Extent3D) -> ImageCreateInfoBuilder<'a> {
        self.inner.extent = extent;
        self
    }
    pub fn mip_levels(mut self, mip_levels: u32) -> ImageCreateInfoBuilder<'a> {
        self.inner.mip_levels = mip_levels;
        self
    }
    pub fn array_layers(mut self, array_layers: u32) -> ImageCreateInfoBuilder<'a> {
        self.inner.array_layers = array_layers;
        self
    }
    pub fn samples(mut self, samples: SampleCountFlags) -> ImageCreateInfoBuilder<'a> {
        self.inner.samples = samples;
        self
    }
    pub fn tiling(mut self, tiling: ImageTiling) -> ImageCreateInfoBuilder<'a> {
        self.inner.tiling = tiling;
        self
    }
    pub fn usage(mut self, usage: ImageUsageFlags) -> ImageCreateInfoBuilder<'a> {
        self.inner.usage = usage;
        self
    }
    pub fn sharing_mode(mut self, sharing_mode: SharingMode) -> ImageCreateInfoBuilder<'a> {
        self.inner.sharing_mode = sharing_mode;
        self
    }
    pub fn queue_family_indices(
        mut self,
        queue_family_indices: &'a [u32],
    ) -> ImageCreateInfoBuilder<'a> {
        self.inner.queue_family_index_count = queue_family_indices.len() as _;
        self.inner.p_queue_family_indices = queue_family_indices.as_ptr();
        self
    }
    pub fn initial_layout(mut self, initial_layout: ImageLayout) -> ImageCreateInfoBuilder<'a> {
        self.inner.initial_layout = initial_layout;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsImageCreateInfo>(
        mut self,
        next: &'a mut T,
    ) -> ImageCreateInfoBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> ImageCreateInfo {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Default, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSubresourceLayout.html>"]
pub struct SubresourceLayout {
    pub offset: DeviceSize,
    pub size: DeviceSize,
    pub row_pitch: DeviceSize,
    pub array_pitch: DeviceSize,
    pub depth_pitch: DeviceSize,
}
impl SubresourceLayout {
    pub fn builder<'a>() -> SubresourceLayoutBuilder<'a> {
        SubresourceLayoutBuilder {
            inner: SubresourceLayout::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct SubresourceLayoutBuilder<'a> {
    inner: SubresourceLayout,
    marker: ::std::marker::PhantomData<&'a ()>,
}
impl<'a> ::std::ops::Deref for SubresourceLayoutBuilder<'a> {
    type Target = SubresourceLayout;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for SubresourceLayoutBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> SubresourceLayoutBuilder<'a> {
    pub fn offset(mut self, offset: DeviceSize) -> SubresourceLayoutBuilder<'a> {
        self.inner.offset = offset;
        self
    }
    pub fn size(mut self, size: DeviceSize) -> SubresourceLayoutBuilder<'a> {
        self.inner.size = size;
        self
    }
    pub fn row_pitch(mut self, row_pitch: DeviceSize) -> SubresourceLayoutBuilder<'a> {
        self.inner.row_pitch = row_pitch;
        self
    }
    pub fn array_pitch(mut self, array_pitch: DeviceSize) -> SubresourceLayoutBuilder<'a> {
        self.inner.array_pitch = array_pitch;
        self
    }
    pub fn depth_pitch(mut self, depth_pitch: DeviceSize) -> SubresourceLayoutBuilder<'a> {
        self.inner.depth_pitch = depth_pitch;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> SubresourceLayout {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImageViewCreateInfo.html>"]
pub struct ImageViewCreateInfo {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub flags: ImageViewCreateFlags,
    pub image: Image,
    pub view_type: ImageViewType,
    pub format: Format,
    pub components: ComponentMapping,
    pub subresource_range: ImageSubresourceRange,
}
impl ::std::default::Default for ImageViewCreateInfo {
    fn default() -> ImageViewCreateInfo {
        ImageViewCreateInfo {
            s_type: StructureType::IMAGE_VIEW_CREATE_INFO,
            p_next: ::std::ptr::null(),
            flags: ImageViewCreateFlags::default(),
            image: Image::default(),
            view_type: ImageViewType::default(),
            format: Format::default(),
            components: ComponentMapping::default(),
            subresource_range: ImageSubresourceRange::default(),
        }
    }
}
impl ImageViewCreateInfo {
    pub fn builder<'a>() -> ImageViewCreateInfoBuilder<'a> {
        ImageViewCreateInfoBuilder {
            inner: ImageViewCreateInfo::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct ImageViewCreateInfoBuilder<'a> {
    inner: ImageViewCreateInfo,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsImageViewCreateInfo {}
impl<'a> ::std::ops::Deref for ImageViewCreateInfoBuilder<'a> {
    type Target = ImageViewCreateInfo;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for ImageViewCreateInfoBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> ImageViewCreateInfoBuilder<'a> {
    pub fn flags(mut self, flags: ImageViewCreateFlags) -> ImageViewCreateInfoBuilder<'a> {
        self.inner.flags = flags;
        self
    }
    pub fn image(mut self, image: Image) -> ImageViewCreateInfoBuilder<'a> {
        self.inner.image = image;
        self
    }
    pub fn view_type(mut self, view_type: ImageViewType) -> ImageViewCreateInfoBuilder<'a> {
        self.inner.view_type = view_type;
        self
    }
    pub fn format(mut self, format: Format) -> ImageViewCreateInfoBuilder<'a> {
        self.inner.format = format;
        self
    }
    pub fn components(mut self, components: ComponentMapping) -> ImageViewCreateInfoBuilder<'a> {
        self.inner.components = components;
        self
    }
    pub fn subresource_range(
        mut self,
        subresource_range: ImageSubresourceRange,
    ) -> ImageViewCreateInfoBuilder<'a> {
        self.inner.subresource_range = subresource_range;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsImageViewCreateInfo>(
        mut self,
        next: &'a mut T,
    ) -> ImageViewCreateInfoBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> ImageViewCreateInfo {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Default, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkBufferCopy.html>"]
pub struct BufferCopy {
    pub src_offset: DeviceSize,
    pub dst_offset: DeviceSize,
    pub size: DeviceSize,
}
impl BufferCopy {
    pub fn builder<'a>() -> BufferCopyBuilder<'a> {
        BufferCopyBuilder {
            inner: BufferCopy::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct BufferCopyBuilder<'a> {
    inner: BufferCopy,
    marker: ::std::marker::PhantomData<&'a ()>,
}
impl<'a> ::std::ops::Deref for BufferCopyBuilder<'a> {
    type Target = BufferCopy;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for BufferCopyBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> BufferCopyBuilder<'a> {
    pub fn src_offset(mut self, src_offset: DeviceSize) -> BufferCopyBuilder<'a> {
        self.inner.src_offset = src_offset;
        self
    }
    pub fn dst_offset(mut self, dst_offset: DeviceSize) -> BufferCopyBuilder<'a> {
        self.inner.dst_offset = dst_offset;
        self
    }
    pub fn size(mut self, size: DeviceSize) -> BufferCopyBuilder<'a> {
        self.inner.size = size;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> BufferCopy {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Default, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSparseMemoryBind.html>"]
pub struct SparseMemoryBind {
    pub resource_offset: DeviceSize,
    pub size: DeviceSize,
    pub memory: DeviceMemory,
    pub memory_offset: DeviceSize,
    pub flags: SparseMemoryBindFlags,
}
impl SparseMemoryBind {
    pub fn builder<'a>() -> SparseMemoryBindBuilder<'a> {
        SparseMemoryBindBuilder {
            inner: SparseMemoryBind::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct SparseMemoryBindBuilder<'a> {
    inner: SparseMemoryBind,
    marker: ::std::marker::PhantomData<&'a ()>,
}
impl<'a> ::std::ops::Deref for SparseMemoryBindBuilder<'a> {
    type Target = SparseMemoryBind;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for SparseMemoryBindBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> SparseMemoryBindBuilder<'a> {
    pub fn resource_offset(mut self, resource_offset: DeviceSize) -> SparseMemoryBindBuilder<'a> {
        self.inner.resource_offset = resource_offset;
        self
    }
    pub fn size(mut self, size: DeviceSize) -> SparseMemoryBindBuilder<'a> {
        self.inner.size = size;
        self
    }
    pub fn memory(mut self, memory: DeviceMemory) -> SparseMemoryBindBuilder<'a> {
        self.inner.memory = memory;
        self
    }
    pub fn memory_offset(mut self, memory_offset: DeviceSize) -> SparseMemoryBindBuilder<'a> {
        self.inner.memory_offset = memory_offset;
        self
    }
    pub fn flags(mut self, flags: SparseMemoryBindFlags) -> SparseMemoryBindBuilder<'a> {
        self.inner.flags = flags;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> SparseMemoryBind {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Default, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSparseImageMemoryBind.html>"]
pub struct SparseImageMemoryBind {
    pub subresource: ImageSubresource,
    pub offset: Offset3D,
    pub extent: Extent3D,
    pub memory: DeviceMemory,
    pub memory_offset: DeviceSize,
    pub flags: SparseMemoryBindFlags,
}
impl SparseImageMemoryBind {
    pub fn builder<'a>() -> SparseImageMemoryBindBuilder<'a> {
        SparseImageMemoryBindBuilder {
            inner: SparseImageMemoryBind::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct SparseImageMemoryBindBuilder<'a> {
    inner: SparseImageMemoryBind,
    marker: ::std::marker::PhantomData<&'a ()>,
}
impl<'a> ::std::ops::Deref for SparseImageMemoryBindBuilder<'a> {
    type Target = SparseImageMemoryBind;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for SparseImageMemoryBindBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> SparseImageMemoryBindBuilder<'a> {
    pub fn subresource(
        mut self,
        subresource: ImageSubresource,
    ) -> SparseImageMemoryBindBuilder<'a> {
        self.inner.subresource = subresource;
        self
    }
    pub fn offset(mut self, offset: Offset3D) -> SparseImageMemoryBindBuilder<'a> {
        self.inner.offset = offset;
        self
    }
    pub fn extent(mut self, extent: Extent3D) -> SparseImageMemoryBindBuilder<'a> {
        self.inner.extent = extent;
        self
    }
    pub fn memory(mut self, memory: DeviceMemory) -> SparseImageMemoryBindBuilder<'a> {
        self.inner.memory = memory;
        self
    }
    pub fn memory_offset(mut self, memory_offset: DeviceSize) -> SparseImageMemoryBindBuilder<'a> {
        self.inner.memory_offset = memory_offset;
        self
    }
    pub fn flags(mut self, flags: SparseMemoryBindFlags) -> SparseImageMemoryBindBuilder<'a> {
        self.inner.flags = flags;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> SparseImageMemoryBind {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSparseBufferMemoryBindInfo.html>"]
pub struct SparseBufferMemoryBindInfo {
    pub buffer: Buffer,
    pub bind_count: u32,
    pub p_binds: *const SparseMemoryBind,
}
impl ::std::default::Default for SparseBufferMemoryBindInfo {
    fn default() -> SparseBufferMemoryBindInfo {
        SparseBufferMemoryBindInfo {
            buffer: Buffer::default(),
            bind_count: u32::default(),
            p_binds: ::std::ptr::null(),
        }
    }
}
impl SparseBufferMemoryBindInfo {
    pub fn builder<'a>() -> SparseBufferMemoryBindInfoBuilder<'a> {
        SparseBufferMemoryBindInfoBuilder {
            inner: SparseBufferMemoryBindInfo::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct SparseBufferMemoryBindInfoBuilder<'a> {
    inner: SparseBufferMemoryBindInfo,
    marker: ::std::marker::PhantomData<&'a ()>,
}
impl<'a> ::std::ops::Deref for SparseBufferMemoryBindInfoBuilder<'a> {
    type Target = SparseBufferMemoryBindInfo;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for SparseBufferMemoryBindInfoBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> SparseBufferMemoryBindInfoBuilder<'a> {
    pub fn buffer(mut self, buffer: Buffer) -> SparseBufferMemoryBindInfoBuilder<'a> {
        self.inner.buffer = buffer;
        self
    }
    pub fn binds(mut self, binds: &'a [SparseMemoryBind]) -> SparseBufferMemoryBindInfoBuilder<'a> {
        self.inner.bind_count = binds.len() as _;
        self.inner.p_binds = binds.as_ptr();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> SparseBufferMemoryBindInfo {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSparseImageOpaqueMemoryBindInfo.html>"]
pub struct SparseImageOpaqueMemoryBindInfo {
    pub image: Image,
    pub bind_count: u32,
    pub p_binds: *const SparseMemoryBind,
}
impl ::std::default::Default for SparseImageOpaqueMemoryBindInfo {
    fn default() -> SparseImageOpaqueMemoryBindInfo {
        SparseImageOpaqueMemoryBindInfo {
            image: Image::default(),
            bind_count: u32::default(),
            p_binds: ::std::ptr::null(),
        }
    }
}
impl SparseImageOpaqueMemoryBindInfo {
    pub fn builder<'a>() -> SparseImageOpaqueMemoryBindInfoBuilder<'a> {
        SparseImageOpaqueMemoryBindInfoBuilder {
            inner: SparseImageOpaqueMemoryBindInfo::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct SparseImageOpaqueMemoryBindInfoBuilder<'a> {
    inner: SparseImageOpaqueMemoryBindInfo,
    marker: ::std::marker::PhantomData<&'a ()>,
}
impl<'a> ::std::ops::Deref for SparseImageOpaqueMemoryBindInfoBuilder<'a> {
    type Target = SparseImageOpaqueMemoryBindInfo;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for SparseImageOpaqueMemoryBindInfoBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> SparseImageOpaqueMemoryBindInfoBuilder<'a> {
    pub fn image(mut self, image: Image) -> SparseImageOpaqueMemoryBindInfoBuilder<'a> {
        self.inner.image = image;
        self
    }
    pub fn binds(
        mut self,
        binds: &'a [SparseMemoryBind],
    ) -> SparseImageOpaqueMemoryBindInfoBuilder<'a> {
        self.inner.bind_count = binds.len() as _;
        self.inner.p_binds = binds.as_ptr();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> SparseImageOpaqueMemoryBindInfo {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSparseImageMemoryBindInfo.html>"]
pub struct SparseImageMemoryBindInfo {
    pub image: Image,
    pub bind_count: u32,
    pub p_binds: *const SparseImageMemoryBind,
}
impl ::std::default::Default for SparseImageMemoryBindInfo {
    fn default() -> SparseImageMemoryBindInfo {
        SparseImageMemoryBindInfo {
            image: Image::default(),
            bind_count: u32::default(),
            p_binds: ::std::ptr::null(),
        }
    }
}
impl SparseImageMemoryBindInfo {
    pub fn builder<'a>() -> SparseImageMemoryBindInfoBuilder<'a> {
        SparseImageMemoryBindInfoBuilder {
            inner: SparseImageMemoryBindInfo::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct SparseImageMemoryBindInfoBuilder<'a> {
    inner: SparseImageMemoryBindInfo,
    marker: ::std::marker::PhantomData<&'a ()>,
}
impl<'a> ::std::ops::Deref for SparseImageMemoryBindInfoBuilder<'a> {
    type Target = SparseImageMemoryBindInfo;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for SparseImageMemoryBindInfoBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> SparseImageMemoryBindInfoBuilder<'a> {
    pub fn image(mut self, image: Image) -> SparseImageMemoryBindInfoBuilder<'a> {
        self.inner.image = image;
        self
    }
    pub fn binds(
        mut self,
        binds: &'a [SparseImageMemoryBind],
    ) -> SparseImageMemoryBindInfoBuilder<'a> {
        self.inner.bind_count = binds.len() as _;
        self.inner.p_binds = binds.as_ptr();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> SparseImageMemoryBindInfo {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkBindSparseInfo.html>"]
pub struct BindSparseInfo {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub wait_semaphore_count: u32,
    pub p_wait_semaphores: *const Semaphore,
    pub buffer_bind_count: u32,
    pub p_buffer_binds: *const SparseBufferMemoryBindInfo,
    pub image_opaque_bind_count: u32,
    pub p_image_opaque_binds: *const SparseImageOpaqueMemoryBindInfo,
    pub image_bind_count: u32,
    pub p_image_binds: *const SparseImageMemoryBindInfo,
    pub signal_semaphore_count: u32,
    pub p_signal_semaphores: *const Semaphore,
}
impl ::std::default::Default for BindSparseInfo {
    fn default() -> BindSparseInfo {
        BindSparseInfo {
            s_type: StructureType::BIND_SPARSE_INFO,
            p_next: ::std::ptr::null(),
            wait_semaphore_count: u32::default(),
            p_wait_semaphores: ::std::ptr::null(),
            buffer_bind_count: u32::default(),
            p_buffer_binds: ::std::ptr::null(),
            image_opaque_bind_count: u32::default(),
            p_image_opaque_binds: ::std::ptr::null(),
            image_bind_count: u32::default(),
            p_image_binds: ::std::ptr::null(),
            signal_semaphore_count: u32::default(),
            p_signal_semaphores: ::std::ptr::null(),
        }
    }
}
impl BindSparseInfo {
    pub fn builder<'a>() -> BindSparseInfoBuilder<'a> {
        BindSparseInfoBuilder {
            inner: BindSparseInfo::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct BindSparseInfoBuilder<'a> {
    inner: BindSparseInfo,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsBindSparseInfo {}
impl<'a> ::std::ops::Deref for BindSparseInfoBuilder<'a> {
    type Target = BindSparseInfo;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for BindSparseInfoBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> BindSparseInfoBuilder<'a> {
    pub fn wait_semaphores(
        mut self,
        wait_semaphores: &'a [Semaphore],
    ) -> BindSparseInfoBuilder<'a> {
        self.inner.wait_semaphore_count = wait_semaphores.len() as _;
        self.inner.p_wait_semaphores = wait_semaphores.as_ptr();
        self
    }
    pub fn buffer_binds(
        mut self,
        buffer_binds: &'a [SparseBufferMemoryBindInfo],
    ) -> BindSparseInfoBuilder<'a> {
        self.inner.buffer_bind_count = buffer_binds.len() as _;
        self.inner.p_buffer_binds = buffer_binds.as_ptr();
        self
    }
    pub fn image_opaque_binds(
        mut self,
        image_opaque_binds: &'a [SparseImageOpaqueMemoryBindInfo],
    ) -> BindSparseInfoBuilder<'a> {
        self.inner.image_opaque_bind_count = image_opaque_binds.len() as _;
        self.inner.p_image_opaque_binds = image_opaque_binds.as_ptr();
        self
    }
    pub fn image_binds(
        mut self,
        image_binds: &'a [SparseImageMemoryBindInfo],
    ) -> BindSparseInfoBuilder<'a> {
        self.inner.image_bind_count = image_binds.len() as _;
        self.inner.p_image_binds = image_binds.as_ptr();
        self
    }
    pub fn signal_semaphores(
        mut self,
        signal_semaphores: &'a [Semaphore],
    ) -> BindSparseInfoBuilder<'a> {
        self.inner.signal_semaphore_count = signal_semaphores.len() as _;
        self.inner.p_signal_semaphores = signal_semaphores.as_ptr();
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsBindSparseInfo>(
        mut self,
        next: &'a mut T,
    ) -> BindSparseInfoBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> BindSparseInfo {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Default, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImageCopy.html>"]
pub struct ImageCopy {
    pub src_subresource: ImageSubresourceLayers,
    pub src_offset: Offset3D,
    pub dst_subresource: ImageSubresourceLayers,
    pub dst_offset: Offset3D,
    pub extent: Extent3D,
}
impl ImageCopy {
    pub fn builder<'a>() -> ImageCopyBuilder<'a> {
        ImageCopyBuilder {
            inner: ImageCopy::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct ImageCopyBuilder<'a> {
    inner: ImageCopy,
    marker: ::std::marker::PhantomData<&'a ()>,
}
impl<'a> ::std::ops::Deref for ImageCopyBuilder<'a> {
    type Target = ImageCopy;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for ImageCopyBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> ImageCopyBuilder<'a> {
    pub fn src_subresource(
        mut self,
        src_subresource: ImageSubresourceLayers,
    ) -> ImageCopyBuilder<'a> {
        self.inner.src_subresource = src_subresource;
        self
    }
    pub fn src_offset(mut self, src_offset: Offset3D) -> ImageCopyBuilder<'a> {
        self.inner.src_offset = src_offset;
        self
    }
    pub fn dst_subresource(
        mut self,
        dst_subresource: ImageSubresourceLayers,
    ) -> ImageCopyBuilder<'a> {
        self.inner.dst_subresource = dst_subresource;
        self
    }
    pub fn dst_offset(mut self, dst_offset: Offset3D) -> ImageCopyBuilder<'a> {
        self.inner.dst_offset = dst_offset;
        self
    }
    pub fn extent(mut self, extent: Extent3D) -> ImageCopyBuilder<'a> {
        self.inner.extent = extent;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> ImageCopy {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImageBlit.html>"]
pub struct ImageBlit {
    pub src_subresource: ImageSubresourceLayers,
    pub src_offsets: [Offset3D; 2],
    pub dst_subresource: ImageSubresourceLayers,
    pub dst_offsets: [Offset3D; 2],
}
impl ::std::default::Default for ImageBlit {
    fn default() -> ImageBlit {
        ImageBlit {
            src_subresource: ImageSubresourceLayers::default(),
            src_offsets: unsafe { ::std::mem::zeroed() },
            dst_subresource: ImageSubresourceLayers::default(),
            dst_offsets: unsafe { ::std::mem::zeroed() },
        }
    }
}
impl ImageBlit {
    pub fn builder<'a>() -> ImageBlitBuilder<'a> {
        ImageBlitBuilder {
            inner: ImageBlit::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct ImageBlitBuilder<'a> {
    inner: ImageBlit,
    marker: ::std::marker::PhantomData<&'a ()>,
}
impl<'a> ::std::ops::Deref for ImageBlitBuilder<'a> {
    type Target = ImageBlit;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for ImageBlitBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> ImageBlitBuilder<'a> {
    pub fn src_subresource(
        mut self,
        src_subresource: ImageSubresourceLayers,
    ) -> ImageBlitBuilder<'a> {
        self.inner.src_subresource = src_subresource;
        self
    }
    pub fn src_offsets(mut self, src_offsets: [Offset3D; 2]) -> ImageBlitBuilder<'a> {
        self.inner.src_offsets = src_offsets;
        self
    }
    pub fn dst_subresource(
        mut self,
        dst_subresource: ImageSubresourceLayers,
    ) -> ImageBlitBuilder<'a> {
        self.inner.dst_subresource = dst_subresource;
        self
    }
    pub fn dst_offsets(mut self, dst_offsets: [Offset3D; 2]) -> ImageBlitBuilder<'a> {
        self.inner.dst_offsets = dst_offsets;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> ImageBlit {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Default, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkBufferImageCopy.html>"]
pub struct BufferImageCopy {
    pub buffer_offset: DeviceSize,
    pub buffer_row_length: u32,
    pub buffer_image_height: u32,
    pub image_subresource: ImageSubresourceLayers,
    pub image_offset: Offset3D,
    pub image_extent: Extent3D,
}
impl BufferImageCopy {
    pub fn builder<'a>() -> BufferImageCopyBuilder<'a> {
        BufferImageCopyBuilder {
            inner: BufferImageCopy::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct BufferImageCopyBuilder<'a> {
    inner: BufferImageCopy,
    marker: ::std::marker::PhantomData<&'a ()>,
}
impl<'a> ::std::ops::Deref for BufferImageCopyBuilder<'a> {
    type Target = BufferImageCopy;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for BufferImageCopyBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> BufferImageCopyBuilder<'a> {
    pub fn buffer_offset(mut self, buffer_offset: DeviceSize) -> BufferImageCopyBuilder<'a> {
        self.inner.buffer_offset = buffer_offset;
        self
    }
    pub fn buffer_row_length(mut self, buffer_row_length: u32) -> BufferImageCopyBuilder<'a> {
        self.inner.buffer_row_length = buffer_row_length;
        self
    }
    pub fn buffer_image_height(mut self, buffer_image_height: u32) -> BufferImageCopyBuilder<'a> {
        self.inner.buffer_image_height = buffer_image_height;
        self
    }
    pub fn image_subresource(
        mut self,
        image_subresource: ImageSubresourceLayers,
    ) -> BufferImageCopyBuilder<'a> {
        self.inner.image_subresource = image_subresource;
        self
    }
    pub fn image_offset(mut self, image_offset: Offset3D) -> BufferImageCopyBuilder<'a> {
        self.inner.image_offset = image_offset;
        self
    }
    pub fn image_extent(mut self, image_extent: Extent3D) -> BufferImageCopyBuilder<'a> {
        self.inner.image_extent = image_extent;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> BufferImageCopy {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Default, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImageResolve.html>"]
pub struct ImageResolve {
    pub src_subresource: ImageSubresourceLayers,
    pub src_offset: Offset3D,
    pub dst_subresource: ImageSubresourceLayers,
    pub dst_offset: Offset3D,
    pub extent: Extent3D,
}
impl ImageResolve {
    pub fn builder<'a>() -> ImageResolveBuilder<'a> {
        ImageResolveBuilder {
            inner: ImageResolve::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct ImageResolveBuilder<'a> {
    inner: ImageResolve,
    marker: ::std::marker::PhantomData<&'a ()>,
}
impl<'a> ::std::ops::Deref for ImageResolveBuilder<'a> {
    type Target = ImageResolve;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for ImageResolveBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> ImageResolveBuilder<'a> {
    pub fn src_subresource(
        mut self,
        src_subresource: ImageSubresourceLayers,
    ) -> ImageResolveBuilder<'a> {
        self.inner.src_subresource = src_subresource;
        self
    }
    pub fn src_offset(mut self, src_offset: Offset3D) -> ImageResolveBuilder<'a> {
        self.inner.src_offset = src_offset;
        self
    }
    pub fn dst_subresource(
        mut self,
        dst_subresource: ImageSubresourceLayers,
    ) -> ImageResolveBuilder<'a> {
        self.inner.dst_subresource = dst_subresource;
        self
    }
    pub fn dst_offset(mut self, dst_offset: Offset3D) -> ImageResolveBuilder<'a> {
        self.inner.dst_offset = dst_offset;
        self
    }
    pub fn extent(mut self, extent: Extent3D) -> ImageResolveBuilder<'a> {
        self.inner.extent = extent;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> ImageResolve {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkShaderModuleCreateInfo.html>"]
pub struct ShaderModuleCreateInfo {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub flags: ShaderModuleCreateFlags,
    pub code_size: usize,
    pub p_code: *const u32,
}
impl ::std::default::Default for ShaderModuleCreateInfo {
    fn default() -> ShaderModuleCreateInfo {
        ShaderModuleCreateInfo {
            s_type: StructureType::SHADER_MODULE_CREATE_INFO,
            p_next: ::std::ptr::null(),
            flags: ShaderModuleCreateFlags::default(),
            code_size: usize::default(),
            p_code: ::std::ptr::null(),
        }
    }
}
impl ShaderModuleCreateInfo {
    pub fn builder<'a>() -> ShaderModuleCreateInfoBuilder<'a> {
        ShaderModuleCreateInfoBuilder {
            inner: ShaderModuleCreateInfo::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct ShaderModuleCreateInfoBuilder<'a> {
    inner: ShaderModuleCreateInfo,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsShaderModuleCreateInfo {}
impl<'a> ::std::ops::Deref for ShaderModuleCreateInfoBuilder<'a> {
    type Target = ShaderModuleCreateInfo;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for ShaderModuleCreateInfoBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> ShaderModuleCreateInfoBuilder<'a> {
    pub fn flags(mut self, flags: ShaderModuleCreateFlags) -> ShaderModuleCreateInfoBuilder<'a> {
        self.inner.flags = flags;
        self
    }
    pub fn code(mut self, code: &'a [u32]) -> ShaderModuleCreateInfoBuilder<'a> {
        self.inner.code_size = code.len() * 4;
        self.inner.p_code = code.as_ptr() as *const u32;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsShaderModuleCreateInfo>(
        mut self,
        next: &'a mut T,
    ) -> ShaderModuleCreateInfoBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> ShaderModuleCreateInfo {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDescriptorSetLayoutBinding.html>"]
pub struct DescriptorSetLayoutBinding {
    pub binding: u32,
    pub descriptor_type: DescriptorType,
    pub descriptor_count: u32,
    pub stage_flags: ShaderStageFlags,
    pub p_immutable_samplers: *const Sampler,
}
impl ::std::default::Default for DescriptorSetLayoutBinding {
    fn default() -> DescriptorSetLayoutBinding {
        DescriptorSetLayoutBinding {
            binding: u32::default(),
            descriptor_type: DescriptorType::default(),
            descriptor_count: u32::default(),
            stage_flags: ShaderStageFlags::default(),
            p_immutable_samplers: ::std::ptr::null(),
        }
    }
}
impl DescriptorSetLayoutBinding {
    pub fn builder<'a>() -> DescriptorSetLayoutBindingBuilder<'a> {
        DescriptorSetLayoutBindingBuilder {
            inner: DescriptorSetLayoutBinding::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct DescriptorSetLayoutBindingBuilder<'a> {
    inner: DescriptorSetLayoutBinding,
    marker: ::std::marker::PhantomData<&'a ()>,
}
impl<'a> ::std::ops::Deref for DescriptorSetLayoutBindingBuilder<'a> {
    type Target = DescriptorSetLayoutBinding;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for DescriptorSetLayoutBindingBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> DescriptorSetLayoutBindingBuilder<'a> {
    pub fn binding(mut self, binding: u32) -> DescriptorSetLayoutBindingBuilder<'a> {
        self.inner.binding = binding;
        self
    }
    pub fn descriptor_type(
        mut self,
        descriptor_type: DescriptorType,
    ) -> DescriptorSetLayoutBindingBuilder<'a> {
        self.inner.descriptor_type = descriptor_type;
        self
    }
    pub fn descriptor_count(
        mut self,
        descriptor_count: u32,
    ) -> DescriptorSetLayoutBindingBuilder<'a> {
        self.inner.descriptor_count = descriptor_count;
        self
    }
    pub fn stage_flags(
        mut self,
        stage_flags: ShaderStageFlags,
    ) -> DescriptorSetLayoutBindingBuilder<'a> {
        self.inner.stage_flags = stage_flags;
        self
    }
    pub fn immutable_samplers(
        mut self,
        immutable_samplers: &'a [Sampler],
    ) -> DescriptorSetLayoutBindingBuilder<'a> {
        self.inner.descriptor_count = immutable_samplers.len() as _;
        self.inner.p_immutable_samplers = immutable_samplers.as_ptr();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> DescriptorSetLayoutBinding {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDescriptorSetLayoutCreateInfo.html>"]
pub struct DescriptorSetLayoutCreateInfo {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub flags: DescriptorSetLayoutCreateFlags,
    pub binding_count: u32,
    pub p_bindings: *const DescriptorSetLayoutBinding,
}
impl ::std::default::Default for DescriptorSetLayoutCreateInfo {
    fn default() -> DescriptorSetLayoutCreateInfo {
        DescriptorSetLayoutCreateInfo {
            s_type: StructureType::DESCRIPTOR_SET_LAYOUT_CREATE_INFO,
            p_next: ::std::ptr::null(),
            flags: DescriptorSetLayoutCreateFlags::default(),
            binding_count: u32::default(),
            p_bindings: ::std::ptr::null(),
        }
    }
}
impl DescriptorSetLayoutCreateInfo {
    pub fn builder<'a>() -> DescriptorSetLayoutCreateInfoBuilder<'a> {
        DescriptorSetLayoutCreateInfoBuilder {
            inner: DescriptorSetLayoutCreateInfo::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct DescriptorSetLayoutCreateInfoBuilder<'a> {
    inner: DescriptorSetLayoutCreateInfo,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsDescriptorSetLayoutCreateInfo {}
impl<'a> ::std::ops::Deref for DescriptorSetLayoutCreateInfoBuilder<'a> {
    type Target = DescriptorSetLayoutCreateInfo;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for DescriptorSetLayoutCreateInfoBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> DescriptorSetLayoutCreateInfoBuilder<'a> {
    pub fn flags(
        mut self,
        flags: DescriptorSetLayoutCreateFlags,
    ) -> DescriptorSetLayoutCreateInfoBuilder<'a> {
        self.inner.flags = flags;
        self
    }
    pub fn bindings(
        mut self,
        bindings: &'a [DescriptorSetLayoutBinding],
    ) -> DescriptorSetLayoutCreateInfoBuilder<'a> {
        self.inner.binding_count = bindings.len() as _;
        self.inner.p_bindings = bindings.as_ptr();
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsDescriptorSetLayoutCreateInfo>(
        mut self,
        next: &'a mut T,
    ) -> DescriptorSetLayoutCreateInfoBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> DescriptorSetLayoutCreateInfo {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Default, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDescriptorPoolSize.html>"]
pub struct DescriptorPoolSize {
    pub ty: DescriptorType,
    pub descriptor_count: u32,
}
impl DescriptorPoolSize {
    pub fn builder<'a>() -> DescriptorPoolSizeBuilder<'a> {
        DescriptorPoolSizeBuilder {
            inner: DescriptorPoolSize::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct DescriptorPoolSizeBuilder<'a> {
    inner: DescriptorPoolSize,
    marker: ::std::marker::PhantomData<&'a ()>,
}
impl<'a> ::std::ops::Deref for DescriptorPoolSizeBuilder<'a> {
    type Target = DescriptorPoolSize;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for DescriptorPoolSizeBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> DescriptorPoolSizeBuilder<'a> {
    pub fn ty(mut self, ty: DescriptorType) -> DescriptorPoolSizeBuilder<'a> {
        self.inner.ty = ty;
        self
    }
    pub fn descriptor_count(mut self, descriptor_count: u32) -> DescriptorPoolSizeBuilder<'a> {
        self.inner.descriptor_count = descriptor_count;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> DescriptorPoolSize {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDescriptorPoolCreateInfo.html>"]
pub struct DescriptorPoolCreateInfo {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub flags: DescriptorPoolCreateFlags,
    pub max_sets: u32,
    pub pool_size_count: u32,
    pub p_pool_sizes: *const DescriptorPoolSize,
}
impl ::std::default::Default for DescriptorPoolCreateInfo {
    fn default() -> DescriptorPoolCreateInfo {
        DescriptorPoolCreateInfo {
            s_type: StructureType::DESCRIPTOR_POOL_CREATE_INFO,
            p_next: ::std::ptr::null(),
            flags: DescriptorPoolCreateFlags::default(),
            max_sets: u32::default(),
            pool_size_count: u32::default(),
            p_pool_sizes: ::std::ptr::null(),
        }
    }
}
impl DescriptorPoolCreateInfo {
    pub fn builder<'a>() -> DescriptorPoolCreateInfoBuilder<'a> {
        DescriptorPoolCreateInfoBuilder {
            inner: DescriptorPoolCreateInfo::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct DescriptorPoolCreateInfoBuilder<'a> {
    inner: DescriptorPoolCreateInfo,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsDescriptorPoolCreateInfo {}
impl<'a> ::std::ops::Deref for DescriptorPoolCreateInfoBuilder<'a> {
    type Target = DescriptorPoolCreateInfo;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for DescriptorPoolCreateInfoBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> DescriptorPoolCreateInfoBuilder<'a> {
    pub fn flags(
        mut self,
        flags: DescriptorPoolCreateFlags,
    ) -> DescriptorPoolCreateInfoBuilder<'a> {
        self.inner.flags = flags;
        self
    }
    pub fn max_sets(mut self, max_sets: u32) -> DescriptorPoolCreateInfoBuilder<'a> {
        self.inner.max_sets = max_sets;
        self
    }
    pub fn pool_sizes(
        mut self,
        pool_sizes: &'a [DescriptorPoolSize],
    ) -> DescriptorPoolCreateInfoBuilder<'a> {
        self.inner.pool_size_count = pool_sizes.len() as _;
        self.inner.p_pool_sizes = pool_sizes.as_ptr();
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsDescriptorPoolCreateInfo>(
        mut self,
        next: &'a mut T,
    ) -> DescriptorPoolCreateInfoBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> DescriptorPoolCreateInfo {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDescriptorSetAllocateInfo.html>"]
pub struct DescriptorSetAllocateInfo {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub descriptor_pool: DescriptorPool,
    pub descriptor_set_count: u32,
    pub p_set_layouts: *const DescriptorSetLayout,
}
impl ::std::default::Default for DescriptorSetAllocateInfo {
    fn default() -> DescriptorSetAllocateInfo {
        DescriptorSetAllocateInfo {
            s_type: StructureType::DESCRIPTOR_SET_ALLOCATE_INFO,
            p_next: ::std::ptr::null(),
            descriptor_pool: DescriptorPool::default(),
            descriptor_set_count: u32::default(),
            p_set_layouts: ::std::ptr::null(),
        }
    }
}
impl DescriptorSetAllocateInfo {
    pub fn builder<'a>() -> DescriptorSetAllocateInfoBuilder<'a> {
        DescriptorSetAllocateInfoBuilder {
            inner: DescriptorSetAllocateInfo::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct DescriptorSetAllocateInfoBuilder<'a> {
    inner: DescriptorSetAllocateInfo,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsDescriptorSetAllocateInfo {}
impl<'a> ::std::ops::Deref for DescriptorSetAllocateInfoBuilder<'a> {
    type Target = DescriptorSetAllocateInfo;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for DescriptorSetAllocateInfoBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> DescriptorSetAllocateInfoBuilder<'a> {
    pub fn descriptor_pool(
        mut self,
        descriptor_pool: DescriptorPool,
    ) -> DescriptorSetAllocateInfoBuilder<'a> {
        self.inner.descriptor_pool = descriptor_pool;
        self
    }
    pub fn set_layouts(
        mut self,
        set_layouts: &'a [DescriptorSetLayout],
    ) -> DescriptorSetAllocateInfoBuilder<'a> {
        self.inner.descriptor_set_count = set_layouts.len() as _;
        self.inner.p_set_layouts = set_layouts.as_ptr();
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsDescriptorSetAllocateInfo>(
        mut self,
        next: &'a mut T,
    ) -> DescriptorSetAllocateInfoBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> DescriptorSetAllocateInfo {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Default, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSpecializationMapEntry.html>"]
pub struct SpecializationMapEntry {
    pub constant_id: u32,
    pub offset: u32,
    pub size: usize,
}
impl SpecializationMapEntry {
    pub fn builder<'a>() -> SpecializationMapEntryBuilder<'a> {
        SpecializationMapEntryBuilder {
            inner: SpecializationMapEntry::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct SpecializationMapEntryBuilder<'a> {
    inner: SpecializationMapEntry,
    marker: ::std::marker::PhantomData<&'a ()>,
}
impl<'a> ::std::ops::Deref for SpecializationMapEntryBuilder<'a> {
    type Target = SpecializationMapEntry;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for SpecializationMapEntryBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> SpecializationMapEntryBuilder<'a> {
    pub fn constant_id(mut self, constant_id: u32) -> SpecializationMapEntryBuilder<'a> {
        self.inner.constant_id = constant_id;
        self
    }
    pub fn offset(mut self, offset: u32) -> SpecializationMapEntryBuilder<'a> {
        self.inner.offset = offset;
        self
    }
    pub fn size(mut self, size: usize) -> SpecializationMapEntryBuilder<'a> {
        self.inner.size = size;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> SpecializationMapEntry {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSpecializationInfo.html>"]
pub struct SpecializationInfo {
    pub map_entry_count: u32,
    pub p_map_entries: *const SpecializationMapEntry,
    pub data_size: usize,
    pub p_data: *const c_void,
}
impl ::std::default::Default for SpecializationInfo {
    fn default() -> SpecializationInfo {
        SpecializationInfo {
            map_entry_count: u32::default(),
            p_map_entries: ::std::ptr::null(),
            data_size: usize::default(),
            p_data: ::std::ptr::null(),
        }
    }
}
impl SpecializationInfo {
    pub fn builder<'a>() -> SpecializationInfoBuilder<'a> {
        SpecializationInfoBuilder {
            inner: SpecializationInfo::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct SpecializationInfoBuilder<'a> {
    inner: SpecializationInfo,
    marker: ::std::marker::PhantomData<&'a ()>,
}
impl<'a> ::std::ops::Deref for SpecializationInfoBuilder<'a> {
    type Target = SpecializationInfo;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for SpecializationInfoBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> SpecializationInfoBuilder<'a> {
    pub fn map_entries(
        mut self,
        map_entries: &'a [SpecializationMapEntry],
    ) -> SpecializationInfoBuilder<'a> {
        self.inner.map_entry_count = map_entries.len() as _;
        self.inner.p_map_entries = map_entries.as_ptr();
        self
    }
    pub fn data(mut self, data: &'a [u8]) -> SpecializationInfoBuilder<'a> {
        self.inner.data_size = data.len() as _;
        self.inner.p_data = data.as_ptr() as *const c_void;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> SpecializationInfo {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineShaderStageCreateInfo.html>"]
pub struct PipelineShaderStageCreateInfo {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub flags: PipelineShaderStageCreateFlags,
    pub stage: ShaderStageFlags,
    pub module: ShaderModule,
    pub p_name: *const c_char,
    pub p_specialization_info: *const SpecializationInfo,
}
impl ::std::default::Default for PipelineShaderStageCreateInfo {
    fn default() -> PipelineShaderStageCreateInfo {
        PipelineShaderStageCreateInfo {
            s_type: StructureType::PIPELINE_SHADER_STAGE_CREATE_INFO,
            p_next: ::std::ptr::null(),
            flags: PipelineShaderStageCreateFlags::default(),
            stage: ShaderStageFlags::default(),
            module: ShaderModule::default(),
            p_name: ::std::ptr::null(),
            p_specialization_info: ::std::ptr::null(),
        }
    }
}
impl PipelineShaderStageCreateInfo {
    pub fn builder<'a>() -> PipelineShaderStageCreateInfoBuilder<'a> {
        PipelineShaderStageCreateInfoBuilder {
            inner: PipelineShaderStageCreateInfo::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PipelineShaderStageCreateInfoBuilder<'a> {
    inner: PipelineShaderStageCreateInfo,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsPipelineShaderStageCreateInfo {}
impl<'a> ::std::ops::Deref for PipelineShaderStageCreateInfoBuilder<'a> {
    type Target = PipelineShaderStageCreateInfo;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PipelineShaderStageCreateInfoBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PipelineShaderStageCreateInfoBuilder<'a> {
    pub fn flags(
        mut self,
        flags: PipelineShaderStageCreateFlags,
    ) -> PipelineShaderStageCreateInfoBuilder<'a> {
        self.inner.flags = flags;
        self
    }
    pub fn stage(mut self, stage: ShaderStageFlags) -> PipelineShaderStageCreateInfoBuilder<'a> {
        self.inner.stage = stage;
        self
    }
    pub fn module(mut self, module: ShaderModule) -> PipelineShaderStageCreateInfoBuilder<'a> {
        self.inner.module = module;
        self
    }
    pub fn name(mut self, name: &'a ::std::ffi::CStr) -> PipelineShaderStageCreateInfoBuilder<'a> {
        self.inner.p_name = name.as_ptr();
        self
    }
    pub fn specialization_info(
        mut self,
        specialization_info: &'a SpecializationInfo,
    ) -> PipelineShaderStageCreateInfoBuilder<'a> {
        self.inner.p_specialization_info = specialization_info;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsPipelineShaderStageCreateInfo>(
        mut self,
        next: &'a mut T,
    ) -> PipelineShaderStageCreateInfoBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PipelineShaderStageCreateInfo {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkComputePipelineCreateInfo.html>"]
pub struct ComputePipelineCreateInfo {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub flags: PipelineCreateFlags,
    pub stage: PipelineShaderStageCreateInfo,
    pub layout: PipelineLayout,
    pub base_pipeline_handle: Pipeline,
    pub base_pipeline_index: i32,
}
impl ::std::default::Default for ComputePipelineCreateInfo {
    fn default() -> ComputePipelineCreateInfo {
        ComputePipelineCreateInfo {
            s_type: StructureType::COMPUTE_PIPELINE_CREATE_INFO,
            p_next: ::std::ptr::null(),
            flags: PipelineCreateFlags::default(),
            stage: PipelineShaderStageCreateInfo::default(),
            layout: PipelineLayout::default(),
            base_pipeline_handle: Pipeline::default(),
            base_pipeline_index: i32::default(),
        }
    }
}
impl ComputePipelineCreateInfo {
    pub fn builder<'a>() -> ComputePipelineCreateInfoBuilder<'a> {
        ComputePipelineCreateInfoBuilder {
            inner: ComputePipelineCreateInfo::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct ComputePipelineCreateInfoBuilder<'a> {
    inner: ComputePipelineCreateInfo,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsComputePipelineCreateInfo {}
impl<'a> ::std::ops::Deref for ComputePipelineCreateInfoBuilder<'a> {
    type Target = ComputePipelineCreateInfo;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for ComputePipelineCreateInfoBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> ComputePipelineCreateInfoBuilder<'a> {
    pub fn flags(mut self, flags: PipelineCreateFlags) -> ComputePipelineCreateInfoBuilder<'a> {
        self.inner.flags = flags;
        self
    }
    pub fn stage(
        mut self,
        stage: PipelineShaderStageCreateInfo,
    ) -> ComputePipelineCreateInfoBuilder<'a> {
        self.inner.stage = stage;
        self
    }
    pub fn layout(mut self, layout: PipelineLayout) -> ComputePipelineCreateInfoBuilder<'a> {
        self.inner.layout = layout;
        self
    }
    pub fn base_pipeline_handle(
        mut self,
        base_pipeline_handle: Pipeline,
    ) -> ComputePipelineCreateInfoBuilder<'a> {
        self.inner.base_pipeline_handle = base_pipeline_handle;
        self
    }
    pub fn base_pipeline_index(
        mut self,
        base_pipeline_index: i32,
    ) -> ComputePipelineCreateInfoBuilder<'a> {
        self.inner.base_pipeline_index = base_pipeline_index;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsComputePipelineCreateInfo>(
        mut self,
        next: &'a mut T,
    ) -> ComputePipelineCreateInfoBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> ComputePipelineCreateInfo {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Default, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVertexInputBindingDescription.html>"]
pub struct VertexInputBindingDescription {
    pub binding: u32,
    pub stride: u32,
    pub input_rate: VertexInputRate,
}
impl VertexInputBindingDescription {
    pub fn builder<'a>() -> VertexInputBindingDescriptionBuilder<'a> {
        VertexInputBindingDescriptionBuilder {
            inner: VertexInputBindingDescription::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct VertexInputBindingDescriptionBuilder<'a> {
    inner: VertexInputBindingDescription,
    marker: ::std::marker::PhantomData<&'a ()>,
}
impl<'a> ::std::ops::Deref for VertexInputBindingDescriptionBuilder<'a> {
    type Target = VertexInputBindingDescription;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for VertexInputBindingDescriptionBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> VertexInputBindingDescriptionBuilder<'a> {
    pub fn binding(mut self, binding: u32) -> VertexInputBindingDescriptionBuilder<'a> {
        self.inner.binding = binding;
        self
    }
    pub fn stride(mut self, stride: u32) -> VertexInputBindingDescriptionBuilder<'a> {
        self.inner.stride = stride;
        self
    }
    pub fn input_rate(
        mut self,
        input_rate: VertexInputRate,
    ) -> VertexInputBindingDescriptionBuilder<'a> {
        self.inner.input_rate = input_rate;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> VertexInputBindingDescription {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Default, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVertexInputAttributeDescription.html>"]
pub struct VertexInputAttributeDescription {
    pub location: u32,
    pub binding: u32,
    pub format: Format,
    pub offset: u32,
}
impl VertexInputAttributeDescription {
    pub fn builder<'a>() -> VertexInputAttributeDescriptionBuilder<'a> {
        VertexInputAttributeDescriptionBuilder {
            inner: VertexInputAttributeDescription::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct VertexInputAttributeDescriptionBuilder<'a> {
    inner: VertexInputAttributeDescription,
    marker: ::std::marker::PhantomData<&'a ()>,
}
impl<'a> ::std::ops::Deref for VertexInputAttributeDescriptionBuilder<'a> {
    type Target = VertexInputAttributeDescription;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for VertexInputAttributeDescriptionBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> VertexInputAttributeDescriptionBuilder<'a> {
    pub fn location(mut self, location: u32) -> VertexInputAttributeDescriptionBuilder<'a> {
        self.inner.location = location;
        self
    }
    pub fn binding(mut self, binding: u32) -> VertexInputAttributeDescriptionBuilder<'a> {
        self.inner.binding = binding;
        self
    }
    pub fn format(mut self, format: Format) -> VertexInputAttributeDescriptionBuilder<'a> {
        self.inner.format = format;
        self
    }
    pub fn offset(mut self, offset: u32) -> VertexInputAttributeDescriptionBuilder<'a> {
        self.inner.offset = offset;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> VertexInputAttributeDescription {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineVertexInputStateCreateInfo.html>"]
pub struct PipelineVertexInputStateCreateInfo {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub flags: PipelineVertexInputStateCreateFlags,
    pub vertex_binding_description_count: u32,
    pub p_vertex_binding_descriptions: *const VertexInputBindingDescription,
    pub vertex_attribute_description_count: u32,
    pub p_vertex_attribute_descriptions: *const VertexInputAttributeDescription,
}
impl ::std::default::Default for PipelineVertexInputStateCreateInfo {
    fn default() -> PipelineVertexInputStateCreateInfo {
        PipelineVertexInputStateCreateInfo {
            s_type: StructureType::PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO,
            p_next: ::std::ptr::null(),
            flags: PipelineVertexInputStateCreateFlags::default(),
            vertex_binding_description_count: u32::default(),
            p_vertex_binding_descriptions: ::std::ptr::null(),
            vertex_attribute_description_count: u32::default(),
            p_vertex_attribute_descriptions: ::std::ptr::null(),
        }
    }
}
impl PipelineVertexInputStateCreateInfo {
    pub fn builder<'a>() -> PipelineVertexInputStateCreateInfoBuilder<'a> {
        PipelineVertexInputStateCreateInfoBuilder {
            inner: PipelineVertexInputStateCreateInfo::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PipelineVertexInputStateCreateInfoBuilder<'a> {
    inner: PipelineVertexInputStateCreateInfo,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsPipelineVertexInputStateCreateInfo {}
impl<'a> ::std::ops::Deref for PipelineVertexInputStateCreateInfoBuilder<'a> {
    type Target = PipelineVertexInputStateCreateInfo;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PipelineVertexInputStateCreateInfoBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PipelineVertexInputStateCreateInfoBuilder<'a> {
    pub fn flags(
        mut self,
        flags: PipelineVertexInputStateCreateFlags,
    ) -> PipelineVertexInputStateCreateInfoBuilder<'a> {
        self.inner.flags = flags;
        self
    }
    pub fn vertex_binding_descriptions(
        mut self,
        vertex_binding_descriptions: &'a [VertexInputBindingDescription],
    ) -> PipelineVertexInputStateCreateInfoBuilder<'a> {
        self.inner.vertex_binding_description_count = vertex_binding_descriptions.len() as _;
        self.inner.p_vertex_binding_descriptions = vertex_binding_descriptions.as_ptr();
        self
    }
    pub fn vertex_attribute_descriptions(
        mut self,
        vertex_attribute_descriptions: &'a [VertexInputAttributeDescription],
    ) -> PipelineVertexInputStateCreateInfoBuilder<'a> {
        self.inner.vertex_attribute_description_count = vertex_attribute_descriptions.len() as _;
        self.inner.p_vertex_attribute_descriptions = vertex_attribute_descriptions.as_ptr();
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsPipelineVertexInputStateCreateInfo>(
        mut self,
        next: &'a mut T,
    ) -> PipelineVertexInputStateCreateInfoBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PipelineVertexInputStateCreateInfo {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineInputAssemblyStateCreateInfo.html>"]
pub struct PipelineInputAssemblyStateCreateInfo {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub flags: PipelineInputAssemblyStateCreateFlags,
    pub topology: PrimitiveTopology,
    pub primitive_restart_enable: Bool32,
}
impl ::std::default::Default for PipelineInputAssemblyStateCreateInfo {
    fn default() -> PipelineInputAssemblyStateCreateInfo {
        PipelineInputAssemblyStateCreateInfo {
            s_type: StructureType::PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO,
            p_next: ::std::ptr::null(),
            flags: PipelineInputAssemblyStateCreateFlags::default(),
            topology: PrimitiveTopology::default(),
            primitive_restart_enable: Bool32::default(),
        }
    }
}
impl PipelineInputAssemblyStateCreateInfo {
    pub fn builder<'a>() -> PipelineInputAssemblyStateCreateInfoBuilder<'a> {
        PipelineInputAssemblyStateCreateInfoBuilder {
            inner: PipelineInputAssemblyStateCreateInfo::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PipelineInputAssemblyStateCreateInfoBuilder<'a> {
    inner: PipelineInputAssemblyStateCreateInfo,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsPipelineInputAssemblyStateCreateInfo {}
impl<'a> ::std::ops::Deref for PipelineInputAssemblyStateCreateInfoBuilder<'a> {
    type Target = PipelineInputAssemblyStateCreateInfo;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PipelineInputAssemblyStateCreateInfoBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PipelineInputAssemblyStateCreateInfoBuilder<'a> {
    pub fn flags(
        mut self,
        flags: PipelineInputAssemblyStateCreateFlags,
    ) -> PipelineInputAssemblyStateCreateInfoBuilder<'a> {
        self.inner.flags = flags;
        self
    }
    pub fn topology(
        mut self,
        topology: PrimitiveTopology,
    ) -> PipelineInputAssemblyStateCreateInfoBuilder<'a> {
        self.inner.topology = topology;
        self
    }
    pub fn primitive_restart_enable(
        mut self,
        primitive_restart_enable: bool,
    ) -> PipelineInputAssemblyStateCreateInfoBuilder<'a> {
        self.inner.primitive_restart_enable = primitive_restart_enable.into();
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsPipelineInputAssemblyStateCreateInfo>(
        mut self,
        next: &'a mut T,
    ) -> PipelineInputAssemblyStateCreateInfoBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PipelineInputAssemblyStateCreateInfo {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineTessellationStateCreateInfo.html>"]
pub struct PipelineTessellationStateCreateInfo {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub flags: PipelineTessellationStateCreateFlags,
    pub patch_control_points: u32,
}
impl ::std::default::Default for PipelineTessellationStateCreateInfo {
    fn default() -> PipelineTessellationStateCreateInfo {
        PipelineTessellationStateCreateInfo {
            s_type: StructureType::PIPELINE_TESSELLATION_STATE_CREATE_INFO,
            p_next: ::std::ptr::null(),
            flags: PipelineTessellationStateCreateFlags::default(),
            patch_control_points: u32::default(),
        }
    }
}
impl PipelineTessellationStateCreateInfo {
    pub fn builder<'a>() -> PipelineTessellationStateCreateInfoBuilder<'a> {
        PipelineTessellationStateCreateInfoBuilder {
            inner: PipelineTessellationStateCreateInfo::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PipelineTessellationStateCreateInfoBuilder<'a> {
    inner: PipelineTessellationStateCreateInfo,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsPipelineTessellationStateCreateInfo {}
impl<'a> ::std::ops::Deref for PipelineTessellationStateCreateInfoBuilder<'a> {
    type Target = PipelineTessellationStateCreateInfo;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PipelineTessellationStateCreateInfoBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PipelineTessellationStateCreateInfoBuilder<'a> {
    pub fn flags(
        mut self,
        flags: PipelineTessellationStateCreateFlags,
    ) -> PipelineTessellationStateCreateInfoBuilder<'a> {
        self.inner.flags = flags;
        self
    }
    pub fn patch_control_points(
        mut self,
        patch_control_points: u32,
    ) -> PipelineTessellationStateCreateInfoBuilder<'a> {
        self.inner.patch_control_points = patch_control_points;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsPipelineTessellationStateCreateInfo>(
        mut self,
        next: &'a mut T,
    ) -> PipelineTessellationStateCreateInfoBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PipelineTessellationStateCreateInfo {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineViewportStateCreateInfo.html>"]
pub struct PipelineViewportStateCreateInfo {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub flags: PipelineViewportStateCreateFlags,
    pub viewport_count: u32,
    pub p_viewports: *const Viewport,
    pub scissor_count: u32,
    pub p_scissors: *const Rect2D,
}
impl ::std::default::Default for PipelineViewportStateCreateInfo {
    fn default() -> PipelineViewportStateCreateInfo {
        PipelineViewportStateCreateInfo {
            s_type: StructureType::PIPELINE_VIEWPORT_STATE_CREATE_INFO,
            p_next: ::std::ptr::null(),
            flags: PipelineViewportStateCreateFlags::default(),
            viewport_count: u32::default(),
            p_viewports: ::std::ptr::null(),
            scissor_count: u32::default(),
            p_scissors: ::std::ptr::null(),
        }
    }
}
impl PipelineViewportStateCreateInfo {
    pub fn builder<'a>() -> PipelineViewportStateCreateInfoBuilder<'a> {
        PipelineViewportStateCreateInfoBuilder {
            inner: PipelineViewportStateCreateInfo::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PipelineViewportStateCreateInfoBuilder<'a> {
    inner: PipelineViewportStateCreateInfo,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsPipelineViewportStateCreateInfo {}
impl<'a> ::std::ops::Deref for PipelineViewportStateCreateInfoBuilder<'a> {
    type Target = PipelineViewportStateCreateInfo;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PipelineViewportStateCreateInfoBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PipelineViewportStateCreateInfoBuilder<'a> {
    pub fn flags(
        mut self,
        flags: PipelineViewportStateCreateFlags,
    ) -> PipelineViewportStateCreateInfoBuilder<'a> {
        self.inner.flags = flags;
        self
    }
    pub fn viewport_count(
        mut self,
        viewport_count: u32,
    ) -> PipelineViewportStateCreateInfoBuilder<'a> {
        self.inner.viewport_count = viewport_count;
        self
    }
    pub fn viewports(
        mut self,
        viewports: &'a [Viewport],
    ) -> PipelineViewportStateCreateInfoBuilder<'a> {
        self.inner.viewport_count = viewports.len() as _;
        self.inner.p_viewports = viewports.as_ptr();
        self
    }
    pub fn scissor_count(
        mut self,
        scissor_count: u32,
    ) -> PipelineViewportStateCreateInfoBuilder<'a> {
        self.inner.scissor_count = scissor_count;
        self
    }
    pub fn scissors(
        mut self,
        scissors: &'a [Rect2D],
    ) -> PipelineViewportStateCreateInfoBuilder<'a> {
        self.inner.scissor_count = scissors.len() as _;
        self.inner.p_scissors = scissors.as_ptr();
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsPipelineViewportStateCreateInfo>(
        mut self,
        next: &'a mut T,
    ) -> PipelineViewportStateCreateInfoBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PipelineViewportStateCreateInfo {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineRasterizationStateCreateInfo.html>"]
pub struct PipelineRasterizationStateCreateInfo {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub flags: PipelineRasterizationStateCreateFlags,
    pub depth_clamp_enable: Bool32,
    pub rasterizer_discard_enable: Bool32,
    pub polygon_mode: PolygonMode,
    pub cull_mode: CullModeFlags,
    pub front_face: FrontFace,
    pub depth_bias_enable: Bool32,
    pub depth_bias_constant_factor: f32,
    pub depth_bias_clamp: f32,
    pub depth_bias_slope_factor: f32,
    pub line_width: f32,
}
impl ::std::default::Default for PipelineRasterizationStateCreateInfo {
    fn default() -> PipelineRasterizationStateCreateInfo {
        PipelineRasterizationStateCreateInfo {
            s_type: StructureType::PIPELINE_RASTERIZATION_STATE_CREATE_INFO,
            p_next: ::std::ptr::null(),
            flags: PipelineRasterizationStateCreateFlags::default(),
            depth_clamp_enable: Bool32::default(),
            rasterizer_discard_enable: Bool32::default(),
            polygon_mode: PolygonMode::default(),
            cull_mode: CullModeFlags::default(),
            front_face: FrontFace::default(),
            depth_bias_enable: Bool32::default(),
            depth_bias_constant_factor: f32::default(),
            depth_bias_clamp: f32::default(),
            depth_bias_slope_factor: f32::default(),
            line_width: f32::default(),
        }
    }
}
impl PipelineRasterizationStateCreateInfo {
    pub fn builder<'a>() -> PipelineRasterizationStateCreateInfoBuilder<'a> {
        PipelineRasterizationStateCreateInfoBuilder {
            inner: PipelineRasterizationStateCreateInfo::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PipelineRasterizationStateCreateInfoBuilder<'a> {
    inner: PipelineRasterizationStateCreateInfo,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsPipelineRasterizationStateCreateInfo {}
impl<'a> ::std::ops::Deref for PipelineRasterizationStateCreateInfoBuilder<'a> {
    type Target = PipelineRasterizationStateCreateInfo;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PipelineRasterizationStateCreateInfoBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PipelineRasterizationStateCreateInfoBuilder<'a> {
    pub fn flags(
        mut self,
        flags: PipelineRasterizationStateCreateFlags,
    ) -> PipelineRasterizationStateCreateInfoBuilder<'a> {
        self.inner.flags = flags;
        self
    }
    pub fn depth_clamp_enable(
        mut self,
        depth_clamp_enable: bool,
    ) -> PipelineRasterizationStateCreateInfoBuilder<'a> {
        self.inner.depth_clamp_enable = depth_clamp_enable.into();
        self
    }
    pub fn rasterizer_discard_enable(
        mut self,
        rasterizer_discard_enable: bool,
    ) -> PipelineRasterizationStateCreateInfoBuilder<'a> {
        self.inner.rasterizer_discard_enable = rasterizer_discard_enable.into();
        self
    }
    pub fn polygon_mode(
        mut self,
        polygon_mode: PolygonMode,
    ) -> PipelineRasterizationStateCreateInfoBuilder<'a> {
        self.inner.polygon_mode = polygon_mode;
        self
    }
    pub fn cull_mode(
        mut self,
        cull_mode: CullModeFlags,
    ) -> PipelineRasterizationStateCreateInfoBuilder<'a> {
        self.inner.cull_mode = cull_mode;
        self
    }
    pub fn front_face(
        mut self,
        front_face: FrontFace,
    ) -> PipelineRasterizationStateCreateInfoBuilder<'a> {
        self.inner.front_face = front_face;
        self
    }
    pub fn depth_bias_enable(
        mut self,
        depth_bias_enable: bool,
    ) -> PipelineRasterizationStateCreateInfoBuilder<'a> {
        self.inner.depth_bias_enable = depth_bias_enable.into();
        self
    }
    pub fn depth_bias_constant_factor(
        mut self,
        depth_bias_constant_factor: f32,
    ) -> PipelineRasterizationStateCreateInfoBuilder<'a> {
        self.inner.depth_bias_constant_factor = depth_bias_constant_factor;
        self
    }
    pub fn depth_bias_clamp(
        mut self,
        depth_bias_clamp: f32,
    ) -> PipelineRasterizationStateCreateInfoBuilder<'a> {
        self.inner.depth_bias_clamp = depth_bias_clamp;
        self
    }
    pub fn depth_bias_slope_factor(
        mut self,
        depth_bias_slope_factor: f32,
    ) -> PipelineRasterizationStateCreateInfoBuilder<'a> {
        self.inner.depth_bias_slope_factor = depth_bias_slope_factor;
        self
    }
    pub fn line_width(
        mut self,
        line_width: f32,
    ) -> PipelineRasterizationStateCreateInfoBuilder<'a> {
        self.inner.line_width = line_width;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsPipelineRasterizationStateCreateInfo>(
        mut self,
        next: &'a mut T,
    ) -> PipelineRasterizationStateCreateInfoBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PipelineRasterizationStateCreateInfo {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineMultisampleStateCreateInfo.html>"]
pub struct PipelineMultisampleStateCreateInfo {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub flags: PipelineMultisampleStateCreateFlags,
    pub rasterization_samples: SampleCountFlags,
    pub sample_shading_enable: Bool32,
    pub min_sample_shading: f32,
    pub p_sample_mask: *const SampleMask,
    pub alpha_to_coverage_enable: Bool32,
    pub alpha_to_one_enable: Bool32,
}
impl ::std::default::Default for PipelineMultisampleStateCreateInfo {
    fn default() -> PipelineMultisampleStateCreateInfo {
        PipelineMultisampleStateCreateInfo {
            s_type: StructureType::PIPELINE_MULTISAMPLE_STATE_CREATE_INFO,
            p_next: ::std::ptr::null(),
            flags: PipelineMultisampleStateCreateFlags::default(),
            rasterization_samples: SampleCountFlags::default(),
            sample_shading_enable: Bool32::default(),
            min_sample_shading: f32::default(),
            p_sample_mask: ::std::ptr::null(),
            alpha_to_coverage_enable: Bool32::default(),
            alpha_to_one_enable: Bool32::default(),
        }
    }
}
impl PipelineMultisampleStateCreateInfo {
    pub fn builder<'a>() -> PipelineMultisampleStateCreateInfoBuilder<'a> {
        PipelineMultisampleStateCreateInfoBuilder {
            inner: PipelineMultisampleStateCreateInfo::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PipelineMultisampleStateCreateInfoBuilder<'a> {
    inner: PipelineMultisampleStateCreateInfo,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsPipelineMultisampleStateCreateInfo {}
impl<'a> ::std::ops::Deref for PipelineMultisampleStateCreateInfoBuilder<'a> {
    type Target = PipelineMultisampleStateCreateInfo;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PipelineMultisampleStateCreateInfoBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PipelineMultisampleStateCreateInfoBuilder<'a> {
    pub fn flags(
        mut self,
        flags: PipelineMultisampleStateCreateFlags,
    ) -> PipelineMultisampleStateCreateInfoBuilder<'a> {
        self.inner.flags = flags;
        self
    }
    pub fn rasterization_samples(
        mut self,
        rasterization_samples: SampleCountFlags,
    ) -> PipelineMultisampleStateCreateInfoBuilder<'a> {
        self.inner.rasterization_samples = rasterization_samples;
        self
    }
    pub fn sample_shading_enable(
        mut self,
        sample_shading_enable: bool,
    ) -> PipelineMultisampleStateCreateInfoBuilder<'a> {
        self.inner.sample_shading_enable = sample_shading_enable.into();
        self
    }
    pub fn min_sample_shading(
        mut self,
        min_sample_shading: f32,
    ) -> PipelineMultisampleStateCreateInfoBuilder<'a> {
        self.inner.min_sample_shading = min_sample_shading;
        self
    }
    pub fn sample_mask(
        mut self,
        sample_mask: &'a [SampleMask],
    ) -> PipelineMultisampleStateCreateInfoBuilder<'a> {
        self.inner.p_sample_mask = sample_mask.as_ptr() as *const SampleMask;
        self
    }
    pub fn alpha_to_coverage_enable(
        mut self,
        alpha_to_coverage_enable: bool,
    ) -> PipelineMultisampleStateCreateInfoBuilder<'a> {
        self.inner.alpha_to_coverage_enable = alpha_to_coverage_enable.into();
        self
    }
    pub fn alpha_to_one_enable(
        mut self,
        alpha_to_one_enable: bool,
    ) -> PipelineMultisampleStateCreateInfoBuilder<'a> {
        self.inner.alpha_to_one_enable = alpha_to_one_enable.into();
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsPipelineMultisampleStateCreateInfo>(
        mut self,
        next: &'a mut T,
    ) -> PipelineMultisampleStateCreateInfoBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PipelineMultisampleStateCreateInfo {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Default, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineColorBlendAttachmentState.html>"]
pub struct PipelineColorBlendAttachmentState {
    pub blend_enable: Bool32,
    pub src_color_blend_factor: BlendFactor,
    pub dst_color_blend_factor: BlendFactor,
    pub color_blend_op: BlendOp,
    pub src_alpha_blend_factor: BlendFactor,
    pub dst_alpha_blend_factor: BlendFactor,
    pub alpha_blend_op: BlendOp,
    pub color_write_mask: ColorComponentFlags,
}
impl PipelineColorBlendAttachmentState {
    pub fn builder<'a>() -> PipelineColorBlendAttachmentStateBuilder<'a> {
        PipelineColorBlendAttachmentStateBuilder {
            inner: PipelineColorBlendAttachmentState::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PipelineColorBlendAttachmentStateBuilder<'a> {
    inner: PipelineColorBlendAttachmentState,
    marker: ::std::marker::PhantomData<&'a ()>,
}
impl<'a> ::std::ops::Deref for PipelineColorBlendAttachmentStateBuilder<'a> {
    type Target = PipelineColorBlendAttachmentState;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PipelineColorBlendAttachmentStateBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PipelineColorBlendAttachmentStateBuilder<'a> {
    pub fn blend_enable(
        mut self,
        blend_enable: bool,
    ) -> PipelineColorBlendAttachmentStateBuilder<'a> {
        self.inner.blend_enable = blend_enable.into();
        self
    }
    pub fn src_color_blend_factor(
        mut self,
        src_color_blend_factor: BlendFactor,
    ) -> PipelineColorBlendAttachmentStateBuilder<'a> {
        self.inner.src_color_blend_factor = src_color_blend_factor;
        self
    }
    pub fn dst_color_blend_factor(
        mut self,
        dst_color_blend_factor: BlendFactor,
    ) -> PipelineColorBlendAttachmentStateBuilder<'a> {
        self.inner.dst_color_blend_factor = dst_color_blend_factor;
        self
    }
    pub fn color_blend_op(
        mut self,
        color_blend_op: BlendOp,
    ) -> PipelineColorBlendAttachmentStateBuilder<'a> {
        self.inner.color_blend_op = color_blend_op;
        self
    }
    pub fn src_alpha_blend_factor(
        mut self,
        src_alpha_blend_factor: BlendFactor,
    ) -> PipelineColorBlendAttachmentStateBuilder<'a> {
        self.inner.src_alpha_blend_factor = src_alpha_blend_factor;
        self
    }
    pub fn dst_alpha_blend_factor(
        mut self,
        dst_alpha_blend_factor: BlendFactor,
    ) -> PipelineColorBlendAttachmentStateBuilder<'a> {
        self.inner.dst_alpha_blend_factor = dst_alpha_blend_factor;
        self
    }
    pub fn alpha_blend_op(
        mut self,
        alpha_blend_op: BlendOp,
    ) -> PipelineColorBlendAttachmentStateBuilder<'a> {
        self.inner.alpha_blend_op = alpha_blend_op;
        self
    }
    pub fn color_write_mask(
        mut self,
        color_write_mask: ColorComponentFlags,
    ) -> PipelineColorBlendAttachmentStateBuilder<'a> {
        self.inner.color_write_mask = color_write_mask;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PipelineColorBlendAttachmentState {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineColorBlendStateCreateInfo.html>"]
pub struct PipelineColorBlendStateCreateInfo {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub flags: PipelineColorBlendStateCreateFlags,
    pub logic_op_enable: Bool32,
    pub logic_op: LogicOp,
    pub attachment_count: u32,
    pub p_attachments: *const PipelineColorBlendAttachmentState,
    pub blend_constants: [f32; 4],
}
impl ::std::default::Default for PipelineColorBlendStateCreateInfo {
    fn default() -> PipelineColorBlendStateCreateInfo {
        PipelineColorBlendStateCreateInfo {
            s_type: StructureType::PIPELINE_COLOR_BLEND_STATE_CREATE_INFO,
            p_next: ::std::ptr::null(),
            flags: PipelineColorBlendStateCreateFlags::default(),
            logic_op_enable: Bool32::default(),
            logic_op: LogicOp::default(),
            attachment_count: u32::default(),
            p_attachments: ::std::ptr::null(),
            blend_constants: unsafe { ::std::mem::zeroed() },
        }
    }
}
impl PipelineColorBlendStateCreateInfo {
    pub fn builder<'a>() -> PipelineColorBlendStateCreateInfoBuilder<'a> {
        PipelineColorBlendStateCreateInfoBuilder {
            inner: PipelineColorBlendStateCreateInfo::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PipelineColorBlendStateCreateInfoBuilder<'a> {
    inner: PipelineColorBlendStateCreateInfo,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsPipelineColorBlendStateCreateInfo {}
impl<'a> ::std::ops::Deref for PipelineColorBlendStateCreateInfoBuilder<'a> {
    type Target = PipelineColorBlendStateCreateInfo;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PipelineColorBlendStateCreateInfoBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PipelineColorBlendStateCreateInfoBuilder<'a> {
    pub fn flags(
        mut self,
        flags: PipelineColorBlendStateCreateFlags,
    ) -> PipelineColorBlendStateCreateInfoBuilder<'a> {
        self.inner.flags = flags;
        self
    }
    pub fn logic_op_enable(
        mut self,
        logic_op_enable: bool,
    ) -> PipelineColorBlendStateCreateInfoBuilder<'a> {
        self.inner.logic_op_enable = logic_op_enable.into();
        self
    }
    pub fn logic_op(mut self, logic_op: LogicOp) -> PipelineColorBlendStateCreateInfoBuilder<'a> {
        self.inner.logic_op = logic_op;
        self
    }
    pub fn attachments(
        mut self,
        attachments: &'a [PipelineColorBlendAttachmentState],
    ) -> PipelineColorBlendStateCreateInfoBuilder<'a> {
        self.inner.attachment_count = attachments.len() as _;
        self.inner.p_attachments = attachments.as_ptr();
        self
    }
    pub fn blend_constants(
        mut self,
        blend_constants: [f32; 4],
    ) -> PipelineColorBlendStateCreateInfoBuilder<'a> {
        self.inner.blend_constants = blend_constants;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsPipelineColorBlendStateCreateInfo>(
        mut self,
        next: &'a mut T,
    ) -> PipelineColorBlendStateCreateInfoBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PipelineColorBlendStateCreateInfo {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineDynamicStateCreateInfo.html>"]
pub struct PipelineDynamicStateCreateInfo {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub flags: PipelineDynamicStateCreateFlags,
    pub dynamic_state_count: u32,
    pub p_dynamic_states: *const DynamicState,
}
impl ::std::default::Default for PipelineDynamicStateCreateInfo {
    fn default() -> PipelineDynamicStateCreateInfo {
        PipelineDynamicStateCreateInfo {
            s_type: StructureType::PIPELINE_DYNAMIC_STATE_CREATE_INFO,
            p_next: ::std::ptr::null(),
            flags: PipelineDynamicStateCreateFlags::default(),
            dynamic_state_count: u32::default(),
            p_dynamic_states: ::std::ptr::null(),
        }
    }
}
impl PipelineDynamicStateCreateInfo {
    pub fn builder<'a>() -> PipelineDynamicStateCreateInfoBuilder<'a> {
        PipelineDynamicStateCreateInfoBuilder {
            inner: PipelineDynamicStateCreateInfo::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PipelineDynamicStateCreateInfoBuilder<'a> {
    inner: PipelineDynamicStateCreateInfo,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsPipelineDynamicStateCreateInfo {}
impl<'a> ::std::ops::Deref for PipelineDynamicStateCreateInfoBuilder<'a> {
    type Target = PipelineDynamicStateCreateInfo;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PipelineDynamicStateCreateInfoBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PipelineDynamicStateCreateInfoBuilder<'a> {
    pub fn flags(
        mut self,
        flags: PipelineDynamicStateCreateFlags,
    ) -> PipelineDynamicStateCreateInfoBuilder<'a> {
        self.inner.flags = flags;
        self
    }
    pub fn dynamic_states(
        mut self,
        dynamic_states: &'a [DynamicState],
    ) -> PipelineDynamicStateCreateInfoBuilder<'a> {
        self.inner.dynamic_state_count = dynamic_states.len() as _;
        self.inner.p_dynamic_states = dynamic_states.as_ptr();
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsPipelineDynamicStateCreateInfo>(
        mut self,
        next: &'a mut T,
    ) -> PipelineDynamicStateCreateInfoBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PipelineDynamicStateCreateInfo {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Default, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkStencilOpState.html>"]
pub struct StencilOpState {
    pub fail_op: StencilOp,
    pub pass_op: StencilOp,
    pub depth_fail_op: StencilOp,
    pub compare_op: CompareOp,
    pub compare_mask: u32,
    pub write_mask: u32,
    pub reference: u32,
}
impl StencilOpState {
    pub fn builder<'a>() -> StencilOpStateBuilder<'a> {
        StencilOpStateBuilder {
            inner: StencilOpState::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct StencilOpStateBuilder<'a> {
    inner: StencilOpState,
    marker: ::std::marker::PhantomData<&'a ()>,
}
impl<'a> ::std::ops::Deref for StencilOpStateBuilder<'a> {
    type Target = StencilOpState;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for StencilOpStateBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> StencilOpStateBuilder<'a> {
    pub fn fail_op(mut self, fail_op: StencilOp) -> StencilOpStateBuilder<'a> {
        self.inner.fail_op = fail_op;
        self
    }
    pub fn pass_op(mut self, pass_op: StencilOp) -> StencilOpStateBuilder<'a> {
        self.inner.pass_op = pass_op;
        self
    }
    pub fn depth_fail_op(mut self, depth_fail_op: StencilOp) -> StencilOpStateBuilder<'a> {
        self.inner.depth_fail_op = depth_fail_op;
        self
    }
    pub fn compare_op(mut self, compare_op: CompareOp) -> StencilOpStateBuilder<'a> {
        self.inner.compare_op = compare_op;
        self
    }
    pub fn compare_mask(mut self, compare_mask: u32) -> StencilOpStateBuilder<'a> {
        self.inner.compare_mask = compare_mask;
        self
    }
    pub fn write_mask(mut self, write_mask: u32) -> StencilOpStateBuilder<'a> {
        self.inner.write_mask = write_mask;
        self
    }
    pub fn reference(mut self, reference: u32) -> StencilOpStateBuilder<'a> {
        self.inner.reference = reference;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> StencilOpState {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineDepthStencilStateCreateInfo.html>"]
pub struct PipelineDepthStencilStateCreateInfo {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub flags: PipelineDepthStencilStateCreateFlags,
    pub depth_test_enable: Bool32,
    pub depth_write_enable: Bool32,
    pub depth_compare_op: CompareOp,
    pub depth_bounds_test_enable: Bool32,
    pub stencil_test_enable: Bool32,
    pub front: StencilOpState,
    pub back: StencilOpState,
    pub min_depth_bounds: f32,
    pub max_depth_bounds: f32,
}
impl ::std::default::Default for PipelineDepthStencilStateCreateInfo {
    fn default() -> PipelineDepthStencilStateCreateInfo {
        PipelineDepthStencilStateCreateInfo {
            s_type: StructureType::PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO,
            p_next: ::std::ptr::null(),
            flags: PipelineDepthStencilStateCreateFlags::default(),
            depth_test_enable: Bool32::default(),
            depth_write_enable: Bool32::default(),
            depth_compare_op: CompareOp::default(),
            depth_bounds_test_enable: Bool32::default(),
            stencil_test_enable: Bool32::default(),
            front: StencilOpState::default(),
            back: StencilOpState::default(),
            min_depth_bounds: f32::default(),
            max_depth_bounds: f32::default(),
        }
    }
}
impl PipelineDepthStencilStateCreateInfo {
    pub fn builder<'a>() -> PipelineDepthStencilStateCreateInfoBuilder<'a> {
        PipelineDepthStencilStateCreateInfoBuilder {
            inner: PipelineDepthStencilStateCreateInfo::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PipelineDepthStencilStateCreateInfoBuilder<'a> {
    inner: PipelineDepthStencilStateCreateInfo,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsPipelineDepthStencilStateCreateInfo {}
impl<'a> ::std::ops::Deref for PipelineDepthStencilStateCreateInfoBuilder<'a> {
    type Target = PipelineDepthStencilStateCreateInfo;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PipelineDepthStencilStateCreateInfoBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PipelineDepthStencilStateCreateInfoBuilder<'a> {
    pub fn flags(
        mut self,
        flags: PipelineDepthStencilStateCreateFlags,
    ) -> PipelineDepthStencilStateCreateInfoBuilder<'a> {
        self.inner.flags = flags;
        self
    }
    pub fn depth_test_enable(
        mut self,
        depth_test_enable: bool,
    ) -> PipelineDepthStencilStateCreateInfoBuilder<'a> {
        self.inner.depth_test_enable = depth_test_enable.into();
        self
    }
    pub fn depth_write_enable(
        mut self,
        depth_write_enable: bool,
    ) -> PipelineDepthStencilStateCreateInfoBuilder<'a> {
        self.inner.depth_write_enable = depth_write_enable.into();
        self
    }
    pub fn depth_compare_op(
        mut self,
        depth_compare_op: CompareOp,
    ) -> PipelineDepthStencilStateCreateInfoBuilder<'a> {
        self.inner.depth_compare_op = depth_compare_op;
        self
    }
    pub fn depth_bounds_test_enable(
        mut self,
        depth_bounds_test_enable: bool,
    ) -> PipelineDepthStencilStateCreateInfoBuilder<'a> {
        self.inner.depth_bounds_test_enable = depth_bounds_test_enable.into();
        self
    }
    pub fn stencil_test_enable(
        mut self,
        stencil_test_enable: bool,
    ) -> PipelineDepthStencilStateCreateInfoBuilder<'a> {
        self.inner.stencil_test_enable = stencil_test_enable.into();
        self
    }
    pub fn front(
        mut self,
        front: StencilOpState,
    ) -> PipelineDepthStencilStateCreateInfoBuilder<'a> {
        self.inner.front = front;
        self
    }
    pub fn back(mut self, back: StencilOpState) -> PipelineDepthStencilStateCreateInfoBuilder<'a> {
        self.inner.back = back;
        self
    }
    pub fn min_depth_bounds(
        mut self,
        min_depth_bounds: f32,
    ) -> PipelineDepthStencilStateCreateInfoBuilder<'a> {
        self.inner.min_depth_bounds = min_depth_bounds;
        self
    }
    pub fn max_depth_bounds(
        mut self,
        max_depth_bounds: f32,
    ) -> PipelineDepthStencilStateCreateInfoBuilder<'a> {
        self.inner.max_depth_bounds = max_depth_bounds;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsPipelineDepthStencilStateCreateInfo>(
        mut self,
        next: &'a mut T,
    ) -> PipelineDepthStencilStateCreateInfoBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PipelineDepthStencilStateCreateInfo {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkGraphicsPipelineCreateInfo.html>"]
pub struct GraphicsPipelineCreateInfo {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub flags: PipelineCreateFlags,
    pub stage_count: u32,
    pub p_stages: *const PipelineShaderStageCreateInfo,
    pub p_vertex_input_state: *const PipelineVertexInputStateCreateInfo,
    pub p_input_assembly_state: *const PipelineInputAssemblyStateCreateInfo,
    pub p_tessellation_state: *const PipelineTessellationStateCreateInfo,
    pub p_viewport_state: *const PipelineViewportStateCreateInfo,
    pub p_rasterization_state: *const PipelineRasterizationStateCreateInfo,
    pub p_multisample_state: *const PipelineMultisampleStateCreateInfo,
    pub p_depth_stencil_state: *const PipelineDepthStencilStateCreateInfo,
    pub p_color_blend_state: *const PipelineColorBlendStateCreateInfo,
    pub p_dynamic_state: *const PipelineDynamicStateCreateInfo,
    pub layout: PipelineLayout,
    pub render_pass: RenderPass,
    pub subpass: u32,
    pub base_pipeline_handle: Pipeline,
    pub base_pipeline_index: i32,
}
impl ::std::default::Default for GraphicsPipelineCreateInfo {
    fn default() -> GraphicsPipelineCreateInfo {
        GraphicsPipelineCreateInfo {
            s_type: StructureType::GRAPHICS_PIPELINE_CREATE_INFO,
            p_next: ::std::ptr::null(),
            flags: PipelineCreateFlags::default(),
            stage_count: u32::default(),
            p_stages: ::std::ptr::null(),
            p_vertex_input_state: ::std::ptr::null(),
            p_input_assembly_state: ::std::ptr::null(),
            p_tessellation_state: ::std::ptr::null(),
            p_viewport_state: ::std::ptr::null(),
            p_rasterization_state: ::std::ptr::null(),
            p_multisample_state: ::std::ptr::null(),
            p_depth_stencil_state: ::std::ptr::null(),
            p_color_blend_state: ::std::ptr::null(),
            p_dynamic_state: ::std::ptr::null(),
            layout: PipelineLayout::default(),
            render_pass: RenderPass::default(),
            subpass: u32::default(),
            base_pipeline_handle: Pipeline::default(),
            base_pipeline_index: i32::default(),
        }
    }
}
impl GraphicsPipelineCreateInfo {
    pub fn builder<'a>() -> GraphicsPipelineCreateInfoBuilder<'a> {
        GraphicsPipelineCreateInfoBuilder {
            inner: GraphicsPipelineCreateInfo::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct GraphicsPipelineCreateInfoBuilder<'a> {
    inner: GraphicsPipelineCreateInfo,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsGraphicsPipelineCreateInfo {}
impl<'a> ::std::ops::Deref for GraphicsPipelineCreateInfoBuilder<'a> {
    type Target = GraphicsPipelineCreateInfo;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for GraphicsPipelineCreateInfoBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> GraphicsPipelineCreateInfoBuilder<'a> {
    pub fn flags(mut self, flags: PipelineCreateFlags) -> GraphicsPipelineCreateInfoBuilder<'a> {
        self.inner.flags = flags;
        self
    }
    pub fn stages(
        mut self,
        stages: &'a [PipelineShaderStageCreateInfo],
    ) -> GraphicsPipelineCreateInfoBuilder<'a> {
        self.inner.stage_count = stages.len() as _;
        self.inner.p_stages = stages.as_ptr();
        self
    }
    pub fn vertex_input_state(
        mut self,
        vertex_input_state: &'a PipelineVertexInputStateCreateInfo,
    ) -> GraphicsPipelineCreateInfoBuilder<'a> {
        self.inner.p_vertex_input_state = vertex_input_state;
        self
    }
    pub fn input_assembly_state(
        mut self,
        input_assembly_state: &'a PipelineInputAssemblyStateCreateInfo,
    ) -> GraphicsPipelineCreateInfoBuilder<'a> {
        self.inner.p_input_assembly_state = input_assembly_state;
        self
    }
    pub fn tessellation_state(
        mut self,
        tessellation_state: &'a PipelineTessellationStateCreateInfo,
    ) -> GraphicsPipelineCreateInfoBuilder<'a> {
        self.inner.p_tessellation_state = tessellation_state;
        self
    }
    pub fn viewport_state(
        mut self,
        viewport_state: &'a PipelineViewportStateCreateInfo,
    ) -> GraphicsPipelineCreateInfoBuilder<'a> {
        self.inner.p_viewport_state = viewport_state;
        self
    }
    pub fn rasterization_state(
        mut self,
        rasterization_state: &'a PipelineRasterizationStateCreateInfo,
    ) -> GraphicsPipelineCreateInfoBuilder<'a> {
        self.inner.p_rasterization_state = rasterization_state;
        self
    }
    pub fn multisample_state(
        mut self,
        multisample_state: &'a PipelineMultisampleStateCreateInfo,
    ) -> GraphicsPipelineCreateInfoBuilder<'a> {
        self.inner.p_multisample_state = multisample_state;
        self
    }
    pub fn depth_stencil_state(
        mut self,
        depth_stencil_state: &'a PipelineDepthStencilStateCreateInfo,
    ) -> GraphicsPipelineCreateInfoBuilder<'a> {
        self.inner.p_depth_stencil_state = depth_stencil_state;
        self
    }
    pub fn color_blend_state(
        mut self,
        color_blend_state: &'a PipelineColorBlendStateCreateInfo,
    ) -> GraphicsPipelineCreateInfoBuilder<'a> {
        self.inner.p_color_blend_state = color_blend_state;
        self
    }
    pub fn dynamic_state(
        mut self,
        dynamic_state: &'a PipelineDynamicStateCreateInfo,
    ) -> GraphicsPipelineCreateInfoBuilder<'a> {
        self.inner.p_dynamic_state = dynamic_state;
        self
    }
    pub fn layout(mut self, layout: PipelineLayout) -> GraphicsPipelineCreateInfoBuilder<'a> {
        self.inner.layout = layout;
        self
    }
    pub fn render_pass(mut self, render_pass: RenderPass) -> GraphicsPipelineCreateInfoBuilder<'a> {
        self.inner.render_pass = render_pass;
        self
    }
    pub fn subpass(mut self, subpass: u32) -> GraphicsPipelineCreateInfoBuilder<'a> {
        self.inner.subpass = subpass;
        self
    }
    pub fn base_pipeline_handle(
        mut self,
        base_pipeline_handle: Pipeline,
    ) -> GraphicsPipelineCreateInfoBuilder<'a> {
        self.inner.base_pipeline_handle = base_pipeline_handle;
        self
    }
    pub fn base_pipeline_index(
        mut self,
        base_pipeline_index: i32,
    ) -> GraphicsPipelineCreateInfoBuilder<'a> {
        self.inner.base_pipeline_index = base_pipeline_index;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsGraphicsPipelineCreateInfo>(
        mut self,
        next: &'a mut T,
    ) -> GraphicsPipelineCreateInfoBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> GraphicsPipelineCreateInfo {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineCacheCreateInfo.html>"]
pub struct PipelineCacheCreateInfo {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub flags: PipelineCacheCreateFlags,
    pub initial_data_size: usize,
    pub p_initial_data: *const c_void,
}
impl ::std::default::Default for PipelineCacheCreateInfo {
    fn default() -> PipelineCacheCreateInfo {
        PipelineCacheCreateInfo {
            s_type: StructureType::PIPELINE_CACHE_CREATE_INFO,
            p_next: ::std::ptr::null(),
            flags: PipelineCacheCreateFlags::default(),
            initial_data_size: usize::default(),
            p_initial_data: ::std::ptr::null(),
        }
    }
}
impl PipelineCacheCreateInfo {
    pub fn builder<'a>() -> PipelineCacheCreateInfoBuilder<'a> {
        PipelineCacheCreateInfoBuilder {
            inner: PipelineCacheCreateInfo::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PipelineCacheCreateInfoBuilder<'a> {
    inner: PipelineCacheCreateInfo,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsPipelineCacheCreateInfo {}
impl<'a> ::std::ops::Deref for PipelineCacheCreateInfoBuilder<'a> {
    type Target = PipelineCacheCreateInfo;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PipelineCacheCreateInfoBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PipelineCacheCreateInfoBuilder<'a> {
    pub fn flags(mut self, flags: PipelineCacheCreateFlags) -> PipelineCacheCreateInfoBuilder<'a> {
        self.inner.flags = flags;
        self
    }
    pub fn initial_data(mut self, initial_data: &'a [u8]) -> PipelineCacheCreateInfoBuilder<'a> {
        self.inner.initial_data_size = initial_data.len() as _;
        self.inner.p_initial_data = initial_data.as_ptr() as *const c_void;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsPipelineCacheCreateInfo>(
        mut self,
        next: &'a mut T,
    ) -> PipelineCacheCreateInfoBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PipelineCacheCreateInfo {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Default, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPushConstantRange.html>"]
pub struct PushConstantRange {
    pub stage_flags: ShaderStageFlags,
    pub offset: u32,
    pub size: u32,
}
impl PushConstantRange {
    pub fn builder<'a>() -> PushConstantRangeBuilder<'a> {
        PushConstantRangeBuilder {
            inner: PushConstantRange::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PushConstantRangeBuilder<'a> {
    inner: PushConstantRange,
    marker: ::std::marker::PhantomData<&'a ()>,
}
impl<'a> ::std::ops::Deref for PushConstantRangeBuilder<'a> {
    type Target = PushConstantRange;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PushConstantRangeBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PushConstantRangeBuilder<'a> {
    pub fn stage_flags(mut self, stage_flags: ShaderStageFlags) -> PushConstantRangeBuilder<'a> {
        self.inner.stage_flags = stage_flags;
        self
    }
    pub fn offset(mut self, offset: u32) -> PushConstantRangeBuilder<'a> {
        self.inner.offset = offset;
        self
    }
    pub fn size(mut self, size: u32) -> PushConstantRangeBuilder<'a> {
        self.inner.size = size;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PushConstantRange {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineLayoutCreateInfo.html>"]
pub struct PipelineLayoutCreateInfo {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub flags: PipelineLayoutCreateFlags,
    pub set_layout_count: u32,
    pub p_set_layouts: *const DescriptorSetLayout,
    pub push_constant_range_count: u32,
    pub p_push_constant_ranges: *const PushConstantRange,
}
impl ::std::default::Default for PipelineLayoutCreateInfo {
    fn default() -> PipelineLayoutCreateInfo {
        PipelineLayoutCreateInfo {
            s_type: StructureType::PIPELINE_LAYOUT_CREATE_INFO,
            p_next: ::std::ptr::null(),
            flags: PipelineLayoutCreateFlags::default(),
            set_layout_count: u32::default(),
            p_set_layouts: ::std::ptr::null(),
            push_constant_range_count: u32::default(),
            p_push_constant_ranges: ::std::ptr::null(),
        }
    }
}
impl PipelineLayoutCreateInfo {
    pub fn builder<'a>() -> PipelineLayoutCreateInfoBuilder<'a> {
        PipelineLayoutCreateInfoBuilder {
            inner: PipelineLayoutCreateInfo::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PipelineLayoutCreateInfoBuilder<'a> {
    inner: PipelineLayoutCreateInfo,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsPipelineLayoutCreateInfo {}
impl<'a> ::std::ops::Deref for PipelineLayoutCreateInfoBuilder<'a> {
    type Target = PipelineLayoutCreateInfo;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PipelineLayoutCreateInfoBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PipelineLayoutCreateInfoBuilder<'a> {
    pub fn flags(
        mut self,
        flags: PipelineLayoutCreateFlags,
    ) -> PipelineLayoutCreateInfoBuilder<'a> {
        self.inner.flags = flags;
        self
    }
    pub fn set_layouts(
        mut self,
        set_layouts: &'a [DescriptorSetLayout],
    ) -> PipelineLayoutCreateInfoBuilder<'a> {
        self.inner.set_layout_count = set_layouts.len() as _;
        self.inner.p_set_layouts = set_layouts.as_ptr();
        self
    }
    pub fn push_constant_ranges(
        mut self,
        push_constant_ranges: &'a [PushConstantRange],
    ) -> PipelineLayoutCreateInfoBuilder<'a> {
        self.inner.push_constant_range_count = push_constant_ranges.len() as _;
        self.inner.p_push_constant_ranges = push_constant_ranges.as_ptr();
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsPipelineLayoutCreateInfo>(
        mut self,
        next: &'a mut T,
    ) -> PipelineLayoutCreateInfoBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PipelineLayoutCreateInfo {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSamplerCreateInfo.html>"]
pub struct SamplerCreateInfo {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub flags: SamplerCreateFlags,
    pub mag_filter: Filter,
    pub min_filter: Filter,
    pub mipmap_mode: SamplerMipmapMode,
    pub address_mode_u: SamplerAddressMode,
    pub address_mode_v: SamplerAddressMode,
    pub address_mode_w: SamplerAddressMode,
    pub mip_lod_bias: f32,
    pub anisotropy_enable: Bool32,
    pub max_anisotropy: f32,
    pub compare_enable: Bool32,
    pub compare_op: CompareOp,
    pub min_lod: f32,
    pub max_lod: f32,
    pub border_color: BorderColor,
    pub unnormalized_coordinates: Bool32,
}
impl ::std::default::Default for SamplerCreateInfo {
    fn default() -> SamplerCreateInfo {
        SamplerCreateInfo {
            s_type: StructureType::SAMPLER_CREATE_INFO,
            p_next: ::std::ptr::null(),
            flags: SamplerCreateFlags::default(),
            mag_filter: Filter::default(),
            min_filter: Filter::default(),
            mipmap_mode: SamplerMipmapMode::default(),
            address_mode_u: SamplerAddressMode::default(),
            address_mode_v: SamplerAddressMode::default(),
            address_mode_w: SamplerAddressMode::default(),
            mip_lod_bias: f32::default(),
            anisotropy_enable: Bool32::default(),
            max_anisotropy: f32::default(),
            compare_enable: Bool32::default(),
            compare_op: CompareOp::default(),
            min_lod: f32::default(),
            max_lod: f32::default(),
            border_color: BorderColor::default(),
            unnormalized_coordinates: Bool32::default(),
        }
    }
}
impl SamplerCreateInfo {
    pub fn builder<'a>() -> SamplerCreateInfoBuilder<'a> {
        SamplerCreateInfoBuilder {
            inner: SamplerCreateInfo::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct SamplerCreateInfoBuilder<'a> {
    inner: SamplerCreateInfo,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsSamplerCreateInfo {}
impl<'a> ::std::ops::Deref for SamplerCreateInfoBuilder<'a> {
    type Target = SamplerCreateInfo;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for SamplerCreateInfoBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> SamplerCreateInfoBuilder<'a> {
    pub fn flags(mut self, flags: SamplerCreateFlags) -> SamplerCreateInfoBuilder<'a> {
        self.inner.flags = flags;
        self
    }
    pub fn mag_filter(mut self, mag_filter: Filter) -> SamplerCreateInfoBuilder<'a> {
        self.inner.mag_filter = mag_filter;
        self
    }
    pub fn min_filter(mut self, min_filter: Filter) -> SamplerCreateInfoBuilder<'a> {
        self.inner.min_filter = min_filter;
        self
    }
    pub fn mipmap_mode(mut self, mipmap_mode: SamplerMipmapMode) -> SamplerCreateInfoBuilder<'a> {
        self.inner.mipmap_mode = mipmap_mode;
        self
    }
    pub fn address_mode_u(
        mut self,
        address_mode_u: SamplerAddressMode,
    ) -> SamplerCreateInfoBuilder<'a> {
        self.inner.address_mode_u = address_mode_u;
        self
    }
    pub fn address_mode_v(
        mut self,
        address_mode_v: SamplerAddressMode,
    ) -> SamplerCreateInfoBuilder<'a> {
        self.inner.address_mode_v = address_mode_v;
        self
    }
    pub fn address_mode_w(
        mut self,
        address_mode_w: SamplerAddressMode,
    ) -> SamplerCreateInfoBuilder<'a> {
        self.inner.address_mode_w = address_mode_w;
        self
    }
    pub fn mip_lod_bias(mut self, mip_lod_bias: f32) -> SamplerCreateInfoBuilder<'a> {
        self.inner.mip_lod_bias = mip_lod_bias;
        self
    }
    pub fn anisotropy_enable(mut self, anisotropy_enable: bool) -> SamplerCreateInfoBuilder<'a> {
        self.inner.anisotropy_enable = anisotropy_enable.into();
        self
    }
    pub fn max_anisotropy(mut self, max_anisotropy: f32) -> SamplerCreateInfoBuilder<'a> {
        self.inner.max_anisotropy = max_anisotropy;
        self
    }
    pub fn compare_enable(mut self, compare_enable: bool) -> SamplerCreateInfoBuilder<'a> {
        self.inner.compare_enable = compare_enable.into();
        self
    }
    pub fn compare_op(mut self, compare_op: CompareOp) -> SamplerCreateInfoBuilder<'a> {
        self.inner.compare_op = compare_op;
        self
    }
    pub fn min_lod(mut self, min_lod: f32) -> SamplerCreateInfoBuilder<'a> {
        self.inner.min_lod = min_lod;
        self
    }
    pub fn max_lod(mut self, max_lod: f32) -> SamplerCreateInfoBuilder<'a> {
        self.inner.max_lod = max_lod;
        self
    }
    pub fn border_color(mut self, border_color: BorderColor) -> SamplerCreateInfoBuilder<'a> {
        self.inner.border_color = border_color;
        self
    }
    pub fn unnormalized_coordinates(
        mut self,
        unnormalized_coordinates: bool,
    ) -> SamplerCreateInfoBuilder<'a> {
        self.inner.unnormalized_coordinates = unnormalized_coordinates.into();
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsSamplerCreateInfo>(
        mut self,
        next: &'a mut T,
    ) -> SamplerCreateInfoBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> SamplerCreateInfo {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCommandPoolCreateInfo.html>"]
pub struct CommandPoolCreateInfo {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub flags: CommandPoolCreateFlags,
    pub queue_family_index: u32,
}
impl ::std::default::Default for CommandPoolCreateInfo {
    fn default() -> CommandPoolCreateInfo {
        CommandPoolCreateInfo {
            s_type: StructureType::COMMAND_POOL_CREATE_INFO,
            p_next: ::std::ptr::null(),
            flags: CommandPoolCreateFlags::default(),
            queue_family_index: u32::default(),
        }
    }
}
impl CommandPoolCreateInfo {
    pub fn builder<'a>() -> CommandPoolCreateInfoBuilder<'a> {
        CommandPoolCreateInfoBuilder {
            inner: CommandPoolCreateInfo::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct CommandPoolCreateInfoBuilder<'a> {
    inner: CommandPoolCreateInfo,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsCommandPoolCreateInfo {}
impl<'a> ::std::ops::Deref for CommandPoolCreateInfoBuilder<'a> {
    type Target = CommandPoolCreateInfo;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for CommandPoolCreateInfoBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> CommandPoolCreateInfoBuilder<'a> {
    pub fn flags(mut self, flags: CommandPoolCreateFlags) -> CommandPoolCreateInfoBuilder<'a> {
        self.inner.flags = flags;
        self
    }
    pub fn queue_family_index(
        mut self,
        queue_family_index: u32,
    ) -> CommandPoolCreateInfoBuilder<'a> {
        self.inner.queue_family_index = queue_family_index;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsCommandPoolCreateInfo>(
        mut self,
        next: &'a mut T,
    ) -> CommandPoolCreateInfoBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> CommandPoolCreateInfo {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCommandBufferAllocateInfo.html>"]
pub struct CommandBufferAllocateInfo {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub command_pool: CommandPool,
    pub level: CommandBufferLevel,
    pub command_buffer_count: u32,
}
impl ::std::default::Default for CommandBufferAllocateInfo {
    fn default() -> CommandBufferAllocateInfo {
        CommandBufferAllocateInfo {
            s_type: StructureType::COMMAND_BUFFER_ALLOCATE_INFO,
            p_next: ::std::ptr::null(),
            command_pool: CommandPool::default(),
            level: CommandBufferLevel::default(),
            command_buffer_count: u32::default(),
        }
    }
}
impl CommandBufferAllocateInfo {
    pub fn builder<'a>() -> CommandBufferAllocateInfoBuilder<'a> {
        CommandBufferAllocateInfoBuilder {
            inner: CommandBufferAllocateInfo::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct CommandBufferAllocateInfoBuilder<'a> {
    inner: CommandBufferAllocateInfo,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsCommandBufferAllocateInfo {}
impl<'a> ::std::ops::Deref for CommandBufferAllocateInfoBuilder<'a> {
    type Target = CommandBufferAllocateInfo;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for CommandBufferAllocateInfoBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> CommandBufferAllocateInfoBuilder<'a> {
    pub fn command_pool(
        mut self,
        command_pool: CommandPool,
    ) -> CommandBufferAllocateInfoBuilder<'a> {
        self.inner.command_pool = command_pool;
        self
    }
    pub fn level(mut self, level: CommandBufferLevel) -> CommandBufferAllocateInfoBuilder<'a> {
        self.inner.level = level;
        self
    }
    pub fn command_buffer_count(
        mut self,
        command_buffer_count: u32,
    ) -> CommandBufferAllocateInfoBuilder<'a> {
        self.inner.command_buffer_count = command_buffer_count;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsCommandBufferAllocateInfo>(
        mut self,
        next: &'a mut T,
    ) -> CommandBufferAllocateInfoBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> CommandBufferAllocateInfo {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCommandBufferInheritanceInfo.html>"]
pub struct CommandBufferInheritanceInfo {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub render_pass: RenderPass,
    pub subpass: u32,
    pub framebuffer: Framebuffer,
    pub occlusion_query_enable: Bool32,
    pub query_flags: QueryControlFlags,
    pub pipeline_statistics: QueryPipelineStatisticFlags,
}
impl ::std::default::Default for CommandBufferInheritanceInfo {
    fn default() -> CommandBufferInheritanceInfo {
        CommandBufferInheritanceInfo {
            s_type: StructureType::COMMAND_BUFFER_INHERITANCE_INFO,
            p_next: ::std::ptr::null(),
            render_pass: RenderPass::default(),
            subpass: u32::default(),
            framebuffer: Framebuffer::default(),
            occlusion_query_enable: Bool32::default(),
            query_flags: QueryControlFlags::default(),
            pipeline_statistics: QueryPipelineStatisticFlags::default(),
        }
    }
}
impl CommandBufferInheritanceInfo {
    pub fn builder<'a>() -> CommandBufferInheritanceInfoBuilder<'a> {
        CommandBufferInheritanceInfoBuilder {
            inner: CommandBufferInheritanceInfo::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct CommandBufferInheritanceInfoBuilder<'a> {
    inner: CommandBufferInheritanceInfo,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsCommandBufferInheritanceInfo {}
impl<'a> ::std::ops::Deref for CommandBufferInheritanceInfoBuilder<'a> {
    type Target = CommandBufferInheritanceInfo;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for CommandBufferInheritanceInfoBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> CommandBufferInheritanceInfoBuilder<'a> {
    pub fn render_pass(
        mut self,
        render_pass: RenderPass,
    ) -> CommandBufferInheritanceInfoBuilder<'a> {
        self.inner.render_pass = render_pass;
        self
    }
    pub fn subpass(mut self, subpass: u32) -> CommandBufferInheritanceInfoBuilder<'a> {
        self.inner.subpass = subpass;
        self
    }
    pub fn framebuffer(
        mut self,
        framebuffer: Framebuffer,
    ) -> CommandBufferInheritanceInfoBuilder<'a> {
        self.inner.framebuffer = framebuffer;
        self
    }
    pub fn occlusion_query_enable(
        mut self,
        occlusion_query_enable: bool,
    ) -> CommandBufferInheritanceInfoBuilder<'a> {
        self.inner.occlusion_query_enable = occlusion_query_enable.into();
        self
    }
    pub fn query_flags(
        mut self,
        query_flags: QueryControlFlags,
    ) -> CommandBufferInheritanceInfoBuilder<'a> {
        self.inner.query_flags = query_flags;
        self
    }
    pub fn pipeline_statistics(
        mut self,
        pipeline_statistics: QueryPipelineStatisticFlags,
    ) -> CommandBufferInheritanceInfoBuilder<'a> {
        self.inner.pipeline_statistics = pipeline_statistics;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsCommandBufferInheritanceInfo>(
        mut self,
        next: &'a mut T,
    ) -> CommandBufferInheritanceInfoBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> CommandBufferInheritanceInfo {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCommandBufferBeginInfo.html>"]
pub struct CommandBufferBeginInfo {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub flags: CommandBufferUsageFlags,
    pub p_inheritance_info: *const CommandBufferInheritanceInfo,
}
impl ::std::default::Default for CommandBufferBeginInfo {
    fn default() -> CommandBufferBeginInfo {
        CommandBufferBeginInfo {
            s_type: StructureType::COMMAND_BUFFER_BEGIN_INFO,
            p_next: ::std::ptr::null(),
            flags: CommandBufferUsageFlags::default(),
            p_inheritance_info: ::std::ptr::null(),
        }
    }
}
impl CommandBufferBeginInfo {
    pub fn builder<'a>() -> CommandBufferBeginInfoBuilder<'a> {
        CommandBufferBeginInfoBuilder {
            inner: CommandBufferBeginInfo::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct CommandBufferBeginInfoBuilder<'a> {
    inner: CommandBufferBeginInfo,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsCommandBufferBeginInfo {}
impl<'a> ::std::ops::Deref for CommandBufferBeginInfoBuilder<'a> {
    type Target = CommandBufferBeginInfo;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for CommandBufferBeginInfoBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> CommandBufferBeginInfoBuilder<'a> {
    pub fn flags(mut self, flags: CommandBufferUsageFlags) -> CommandBufferBeginInfoBuilder<'a> {
        self.inner.flags = flags;
        self
    }
    pub fn inheritance_info(
        mut self,
        inheritance_info: &'a CommandBufferInheritanceInfo,
    ) -> CommandBufferBeginInfoBuilder<'a> {
        self.inner.p_inheritance_info = inheritance_info;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsCommandBufferBeginInfo>(
        mut self,
        next: &'a mut T,
    ) -> CommandBufferBeginInfoBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> CommandBufferBeginInfo {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkRenderPassBeginInfo.html>"]
pub struct RenderPassBeginInfo {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub render_pass: RenderPass,
    pub framebuffer: Framebuffer,
    pub render_area: Rect2D,
    pub clear_value_count: u32,
    pub p_clear_values: *const ClearValue,
}
impl fmt::Debug for RenderPassBeginInfo {
    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
        fmt.debug_struct("RenderPassBeginInfo")
            .field("s_type", &self.s_type)
            .field("p_next", &self.p_next)
            .field("render_pass", &self.render_pass)
            .field("framebuffer", &self.framebuffer)
            .field("render_area", &self.render_area)
            .field("clear_value_count", &self.clear_value_count)
            .field("p_clear_values", &"union")
            .finish()
    }
}
impl ::std::default::Default for RenderPassBeginInfo {
    fn default() -> RenderPassBeginInfo {
        RenderPassBeginInfo {
            s_type: StructureType::RENDER_PASS_BEGIN_INFO,
            p_next: ::std::ptr::null(),
            render_pass: RenderPass::default(),
            framebuffer: Framebuffer::default(),
            render_area: Rect2D::default(),
            clear_value_count: u32::default(),
            p_clear_values: ::std::ptr::null(),
        }
    }
}
impl RenderPassBeginInfo {
    pub fn builder<'a>() -> RenderPassBeginInfoBuilder<'a> {
        RenderPassBeginInfoBuilder {
            inner: RenderPassBeginInfo::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct RenderPassBeginInfoBuilder<'a> {
    inner: RenderPassBeginInfo,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsRenderPassBeginInfo {}
impl<'a> ::std::ops::Deref for RenderPassBeginInfoBuilder<'a> {
    type Target = RenderPassBeginInfo;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for RenderPassBeginInfoBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> RenderPassBeginInfoBuilder<'a> {
    pub fn render_pass(mut self, render_pass: RenderPass) -> RenderPassBeginInfoBuilder<'a> {
        self.inner.render_pass = render_pass;
        self
    }
    pub fn framebuffer(mut self, framebuffer: Framebuffer) -> RenderPassBeginInfoBuilder<'a> {
        self.inner.framebuffer = framebuffer;
        self
    }
    pub fn render_area(mut self, render_area: Rect2D) -> RenderPassBeginInfoBuilder<'a> {
        self.inner.render_area = render_area;
        self
    }
    pub fn clear_values(
        mut self,
        clear_values: &'a [ClearValue],
    ) -> RenderPassBeginInfoBuilder<'a> {
        self.inner.clear_value_count = clear_values.len() as _;
        self.inner.p_clear_values = clear_values.as_ptr();
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsRenderPassBeginInfo>(
        mut self,
        next: &'a mut T,
    ) -> RenderPassBeginInfoBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> RenderPassBeginInfo {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkClearColorValue.html>"]
pub union ClearColorValue {
    pub float32: [f32; 4],
    pub int32: [i32; 4],
    pub uint32: [u32; 4],
}
impl ::std::default::Default for ClearColorValue {
    fn default() -> ClearColorValue {
        unsafe { ::std::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Copy, Clone, Default, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkClearDepthStencilValue.html>"]
pub struct ClearDepthStencilValue {
    pub depth: f32,
    pub stencil: u32,
}
impl ClearDepthStencilValue {
    pub fn builder<'a>() -> ClearDepthStencilValueBuilder<'a> {
        ClearDepthStencilValueBuilder {
            inner: ClearDepthStencilValue::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct ClearDepthStencilValueBuilder<'a> {
    inner: ClearDepthStencilValue,
    marker: ::std::marker::PhantomData<&'a ()>,
}
impl<'a> ::std::ops::Deref for ClearDepthStencilValueBuilder<'a> {
    type Target = ClearDepthStencilValue;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for ClearDepthStencilValueBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> ClearDepthStencilValueBuilder<'a> {
    pub fn depth(mut self, depth: f32) -> ClearDepthStencilValueBuilder<'a> {
        self.inner.depth = depth;
        self
    }
    pub fn stencil(mut self, stencil: u32) -> ClearDepthStencilValueBuilder<'a> {
        self.inner.stencil = stencil;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> ClearDepthStencilValue {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkClearValue.html>"]
pub union ClearValue {
    pub color: ClearColorValue,
    pub depth_stencil: ClearDepthStencilValue,
}
impl ::std::default::Default for ClearValue {
    fn default() -> ClearValue {
        unsafe { ::std::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Copy, Clone, Default)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkClearAttachment.html>"]
pub struct ClearAttachment {
    pub aspect_mask: ImageAspectFlags,
    pub color_attachment: u32,
    pub clear_value: ClearValue,
}
impl fmt::Debug for ClearAttachment {
    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
        fmt.debug_struct("ClearAttachment")
            .field("aspect_mask", &self.aspect_mask)
            .field("color_attachment", &self.color_attachment)
            .field("clear_value", &"union")
            .finish()
    }
}
impl ClearAttachment {
    pub fn builder<'a>() -> ClearAttachmentBuilder<'a> {
        ClearAttachmentBuilder {
            inner: ClearAttachment::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct ClearAttachmentBuilder<'a> {
    inner: ClearAttachment,
    marker: ::std::marker::PhantomData<&'a ()>,
}
impl<'a> ::std::ops::Deref for ClearAttachmentBuilder<'a> {
    type Target = ClearAttachment;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for ClearAttachmentBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> ClearAttachmentBuilder<'a> {
    pub fn aspect_mask(mut self, aspect_mask: ImageAspectFlags) -> ClearAttachmentBuilder<'a> {
        self.inner.aspect_mask = aspect_mask;
        self
    }
    pub fn color_attachment(mut self, color_attachment: u32) -> ClearAttachmentBuilder<'a> {
        self.inner.color_attachment = color_attachment;
        self
    }
    pub fn clear_value(mut self, clear_value: ClearValue) -> ClearAttachmentBuilder<'a> {
        self.inner.clear_value = clear_value;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> ClearAttachment {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Default, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAttachmentDescription.html>"]
pub struct AttachmentDescription {
    pub flags: AttachmentDescriptionFlags,
    pub format: Format,
    pub samples: SampleCountFlags,
    pub load_op: AttachmentLoadOp,
    pub store_op: AttachmentStoreOp,
    pub stencil_load_op: AttachmentLoadOp,
    pub stencil_store_op: AttachmentStoreOp,
    pub initial_layout: ImageLayout,
    pub final_layout: ImageLayout,
}
impl AttachmentDescription {
    pub fn builder<'a>() -> AttachmentDescriptionBuilder<'a> {
        AttachmentDescriptionBuilder {
            inner: AttachmentDescription::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct AttachmentDescriptionBuilder<'a> {
    inner: AttachmentDescription,
    marker: ::std::marker::PhantomData<&'a ()>,
}
impl<'a> ::std::ops::Deref for AttachmentDescriptionBuilder<'a> {
    type Target = AttachmentDescription;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for AttachmentDescriptionBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> AttachmentDescriptionBuilder<'a> {
    pub fn flags(mut self, flags: AttachmentDescriptionFlags) -> AttachmentDescriptionBuilder<'a> {
        self.inner.flags = flags;
        self
    }
    pub fn format(mut self, format: Format) -> AttachmentDescriptionBuilder<'a> {
        self.inner.format = format;
        self
    }
    pub fn samples(mut self, samples: SampleCountFlags) -> AttachmentDescriptionBuilder<'a> {
        self.inner.samples = samples;
        self
    }
    pub fn load_op(mut self, load_op: AttachmentLoadOp) -> AttachmentDescriptionBuilder<'a> {
        self.inner.load_op = load_op;
        self
    }
    pub fn store_op(mut self, store_op: AttachmentStoreOp) -> AttachmentDescriptionBuilder<'a> {
        self.inner.store_op = store_op;
        self
    }
    pub fn stencil_load_op(
        mut self,
        stencil_load_op: AttachmentLoadOp,
    ) -> AttachmentDescriptionBuilder<'a> {
        self.inner.stencil_load_op = stencil_load_op;
        self
    }
    pub fn stencil_store_op(
        mut self,
        stencil_store_op: AttachmentStoreOp,
    ) -> AttachmentDescriptionBuilder<'a> {
        self.inner.stencil_store_op = stencil_store_op;
        self
    }
    pub fn initial_layout(
        mut self,
        initial_layout: ImageLayout,
    ) -> AttachmentDescriptionBuilder<'a> {
        self.inner.initial_layout = initial_layout;
        self
    }
    pub fn final_layout(mut self, final_layout: ImageLayout) -> AttachmentDescriptionBuilder<'a> {
        self.inner.final_layout = final_layout;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> AttachmentDescription {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Default, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAttachmentReference.html>"]
pub struct AttachmentReference {
    pub attachment: u32,
    pub layout: ImageLayout,
}
impl AttachmentReference {
    pub fn builder<'a>() -> AttachmentReferenceBuilder<'a> {
        AttachmentReferenceBuilder {
            inner: AttachmentReference::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct AttachmentReferenceBuilder<'a> {
    inner: AttachmentReference,
    marker: ::std::marker::PhantomData<&'a ()>,
}
impl<'a> ::std::ops::Deref for AttachmentReferenceBuilder<'a> {
    type Target = AttachmentReference;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for AttachmentReferenceBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> AttachmentReferenceBuilder<'a> {
    pub fn attachment(mut self, attachment: u32) -> AttachmentReferenceBuilder<'a> {
        self.inner.attachment = attachment;
        self
    }
    pub fn layout(mut self, layout: ImageLayout) -> AttachmentReferenceBuilder<'a> {
        self.inner.layout = layout;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> AttachmentReference {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSubpassDescription.html>"]
pub struct SubpassDescription {
    pub flags: SubpassDescriptionFlags,
    pub pipeline_bind_point: PipelineBindPoint,
    pub input_attachment_count: u32,
    pub p_input_attachments: *const AttachmentReference,
    pub color_attachment_count: u32,
    pub p_color_attachments: *const AttachmentReference,
    pub p_resolve_attachments: *const AttachmentReference,
    pub p_depth_stencil_attachment: *const AttachmentReference,
    pub preserve_attachment_count: u32,
    pub p_preserve_attachments: *const u32,
}
impl ::std::default::Default for SubpassDescription {
    fn default() -> SubpassDescription {
        SubpassDescription {
            flags: SubpassDescriptionFlags::default(),
            pipeline_bind_point: PipelineBindPoint::default(),
            input_attachment_count: u32::default(),
            p_input_attachments: ::std::ptr::null(),
            color_attachment_count: u32::default(),
            p_color_attachments: ::std::ptr::null(),
            p_resolve_attachments: ::std::ptr::null(),
            p_depth_stencil_attachment: ::std::ptr::null(),
            preserve_attachment_count: u32::default(),
            p_preserve_attachments: ::std::ptr::null(),
        }
    }
}
impl SubpassDescription {
    pub fn builder<'a>() -> SubpassDescriptionBuilder<'a> {
        SubpassDescriptionBuilder {
            inner: SubpassDescription::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct SubpassDescriptionBuilder<'a> {
    inner: SubpassDescription,
    marker: ::std::marker::PhantomData<&'a ()>,
}
impl<'a> ::std::ops::Deref for SubpassDescriptionBuilder<'a> {
    type Target = SubpassDescription;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for SubpassDescriptionBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> SubpassDescriptionBuilder<'a> {
    pub fn flags(mut self, flags: SubpassDescriptionFlags) -> SubpassDescriptionBuilder<'a> {
        self.inner.flags = flags;
        self
    }
    pub fn pipeline_bind_point(
        mut self,
        pipeline_bind_point: PipelineBindPoint,
    ) -> SubpassDescriptionBuilder<'a> {
        self.inner.pipeline_bind_point = pipeline_bind_point;
        self
    }
    pub fn input_attachments(
        mut self,
        input_attachments: &'a [AttachmentReference],
    ) -> SubpassDescriptionBuilder<'a> {
        self.inner.input_attachment_count = input_attachments.len() as _;
        self.inner.p_input_attachments = input_attachments.as_ptr();
        self
    }
    pub fn color_attachments(
        mut self,
        color_attachments: &'a [AttachmentReference],
    ) -> SubpassDescriptionBuilder<'a> {
        self.inner.color_attachment_count = color_attachments.len() as _;
        self.inner.p_color_attachments = color_attachments.as_ptr();
        self
    }
    pub fn resolve_attachments(
        mut self,
        resolve_attachments: &'a [AttachmentReference],
    ) -> SubpassDescriptionBuilder<'a> {
        self.inner.color_attachment_count = resolve_attachments.len() as _;
        self.inner.p_resolve_attachments = resolve_attachments.as_ptr();
        self
    }
    pub fn depth_stencil_attachment(
        mut self,
        depth_stencil_attachment: &'a AttachmentReference,
    ) -> SubpassDescriptionBuilder<'a> {
        self.inner.p_depth_stencil_attachment = depth_stencil_attachment;
        self
    }
    pub fn preserve_attachments(
        mut self,
        preserve_attachments: &'a [u32],
    ) -> SubpassDescriptionBuilder<'a> {
        self.inner.preserve_attachment_count = preserve_attachments.len() as _;
        self.inner.p_preserve_attachments = preserve_attachments.as_ptr();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> SubpassDescription {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Default, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSubpassDependency.html>"]
pub struct SubpassDependency {
    pub src_subpass: u32,
    pub dst_subpass: u32,
    pub src_stage_mask: PipelineStageFlags,
    pub dst_stage_mask: PipelineStageFlags,
    pub src_access_mask: AccessFlags,
    pub dst_access_mask: AccessFlags,
    pub dependency_flags: DependencyFlags,
}
impl SubpassDependency {
    pub fn builder<'a>() -> SubpassDependencyBuilder<'a> {
        SubpassDependencyBuilder {
            inner: SubpassDependency::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct SubpassDependencyBuilder<'a> {
    inner: SubpassDependency,
    marker: ::std::marker::PhantomData<&'a ()>,
}
impl<'a> ::std::ops::Deref for SubpassDependencyBuilder<'a> {
    type Target = SubpassDependency;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for SubpassDependencyBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> SubpassDependencyBuilder<'a> {
    pub fn src_subpass(mut self, src_subpass: u32) -> SubpassDependencyBuilder<'a> {
        self.inner.src_subpass = src_subpass;
        self
    }
    pub fn dst_subpass(mut self, dst_subpass: u32) -> SubpassDependencyBuilder<'a> {
        self.inner.dst_subpass = dst_subpass;
        self
    }
    pub fn src_stage_mask(
        mut self,
        src_stage_mask: PipelineStageFlags,
    ) -> SubpassDependencyBuilder<'a> {
        self.inner.src_stage_mask = src_stage_mask;
        self
    }
    pub fn dst_stage_mask(
        mut self,
        dst_stage_mask: PipelineStageFlags,
    ) -> SubpassDependencyBuilder<'a> {
        self.inner.dst_stage_mask = dst_stage_mask;
        self
    }
    pub fn src_access_mask(mut self, src_access_mask: AccessFlags) -> SubpassDependencyBuilder<'a> {
        self.inner.src_access_mask = src_access_mask;
        self
    }
    pub fn dst_access_mask(mut self, dst_access_mask: AccessFlags) -> SubpassDependencyBuilder<'a> {
        self.inner.dst_access_mask = dst_access_mask;
        self
    }
    pub fn dependency_flags(
        mut self,
        dependency_flags: DependencyFlags,
    ) -> SubpassDependencyBuilder<'a> {
        self.inner.dependency_flags = dependency_flags;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> SubpassDependency {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkRenderPassCreateInfo.html>"]
pub struct RenderPassCreateInfo {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub flags: RenderPassCreateFlags,
    pub attachment_count: u32,
    pub p_attachments: *const AttachmentDescription,
    pub subpass_count: u32,
    pub p_subpasses: *const SubpassDescription,
    pub dependency_count: u32,
    pub p_dependencies: *const SubpassDependency,
}
impl ::std::default::Default for RenderPassCreateInfo {
    fn default() -> RenderPassCreateInfo {
        RenderPassCreateInfo {
            s_type: StructureType::RENDER_PASS_CREATE_INFO,
            p_next: ::std::ptr::null(),
            flags: RenderPassCreateFlags::default(),
            attachment_count: u32::default(),
            p_attachments: ::std::ptr::null(),
            subpass_count: u32::default(),
            p_subpasses: ::std::ptr::null(),
            dependency_count: u32::default(),
            p_dependencies: ::std::ptr::null(),
        }
    }
}
impl RenderPassCreateInfo {
    pub fn builder<'a>() -> RenderPassCreateInfoBuilder<'a> {
        RenderPassCreateInfoBuilder {
            inner: RenderPassCreateInfo::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct RenderPassCreateInfoBuilder<'a> {
    inner: RenderPassCreateInfo,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsRenderPassCreateInfo {}
impl<'a> ::std::ops::Deref for RenderPassCreateInfoBuilder<'a> {
    type Target = RenderPassCreateInfo;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for RenderPassCreateInfoBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> RenderPassCreateInfoBuilder<'a> {
    pub fn flags(mut self, flags: RenderPassCreateFlags) -> RenderPassCreateInfoBuilder<'a> {
        self.inner.flags = flags;
        self
    }
    pub fn attachments(
        mut self,
        attachments: &'a [AttachmentDescription],
    ) -> RenderPassCreateInfoBuilder<'a> {
        self.inner.attachment_count = attachments.len() as _;
        self.inner.p_attachments = attachments.as_ptr();
        self
    }
    pub fn subpasses(
        mut self,
        subpasses: &'a [SubpassDescription],
    ) -> RenderPassCreateInfoBuilder<'a> {
        self.inner.subpass_count = subpasses.len() as _;
        self.inner.p_subpasses = subpasses.as_ptr();
        self
    }
    pub fn dependencies(
        mut self,
        dependencies: &'a [SubpassDependency],
    ) -> RenderPassCreateInfoBuilder<'a> {
        self.inner.dependency_count = dependencies.len() as _;
        self.inner.p_dependencies = dependencies.as_ptr();
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsRenderPassCreateInfo>(
        mut self,
        next: &'a mut T,
    ) -> RenderPassCreateInfoBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> RenderPassCreateInfo {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkEventCreateInfo.html>"]
pub struct EventCreateInfo {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub flags: EventCreateFlags,
}
impl ::std::default::Default for EventCreateInfo {
    fn default() -> EventCreateInfo {
        EventCreateInfo {
            s_type: StructureType::EVENT_CREATE_INFO,
            p_next: ::std::ptr::null(),
            flags: EventCreateFlags::default(),
        }
    }
}
impl EventCreateInfo {
    pub fn builder<'a>() -> EventCreateInfoBuilder<'a> {
        EventCreateInfoBuilder {
            inner: EventCreateInfo::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct EventCreateInfoBuilder<'a> {
    inner: EventCreateInfo,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsEventCreateInfo {}
impl<'a> ::std::ops::Deref for EventCreateInfoBuilder<'a> {
    type Target = EventCreateInfo;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for EventCreateInfoBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> EventCreateInfoBuilder<'a> {
    pub fn flags(mut self, flags: EventCreateFlags) -> EventCreateInfoBuilder<'a> {
        self.inner.flags = flags;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsEventCreateInfo>(
        mut self,
        next: &'a mut T,
    ) -> EventCreateInfoBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> EventCreateInfo {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkFenceCreateInfo.html>"]
pub struct FenceCreateInfo {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub flags: FenceCreateFlags,
}
impl ::std::default::Default for FenceCreateInfo {
    fn default() -> FenceCreateInfo {
        FenceCreateInfo {
            s_type: StructureType::FENCE_CREATE_INFO,
            p_next: ::std::ptr::null(),
            flags: FenceCreateFlags::default(),
        }
    }
}
impl FenceCreateInfo {
    pub fn builder<'a>() -> FenceCreateInfoBuilder<'a> {
        FenceCreateInfoBuilder {
            inner: FenceCreateInfo::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct FenceCreateInfoBuilder<'a> {
    inner: FenceCreateInfo,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsFenceCreateInfo {}
impl<'a> ::std::ops::Deref for FenceCreateInfoBuilder<'a> {
    type Target = FenceCreateInfo;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for FenceCreateInfoBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> FenceCreateInfoBuilder<'a> {
    pub fn flags(mut self, flags: FenceCreateFlags) -> FenceCreateInfoBuilder<'a> {
        self.inner.flags = flags;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsFenceCreateInfo>(
        mut self,
        next: &'a mut T,
    ) -> FenceCreateInfoBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> FenceCreateInfo {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Default, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFeatures.html>"]
pub struct PhysicalDeviceFeatures {
    pub robust_buffer_access: Bool32,
    pub full_draw_index_uint32: Bool32,
    pub image_cube_array: Bool32,
    pub independent_blend: Bool32,
    pub geometry_shader: Bool32,
    pub tessellation_shader: Bool32,
    pub sample_rate_shading: Bool32,
    pub dual_src_blend: Bool32,
    pub logic_op: Bool32,
    pub multi_draw_indirect: Bool32,
    pub draw_indirect_first_instance: Bool32,
    pub depth_clamp: Bool32,
    pub depth_bias_clamp: Bool32,
    pub fill_mode_non_solid: Bool32,
    pub depth_bounds: Bool32,
    pub wide_lines: Bool32,
    pub large_points: Bool32,
    pub alpha_to_one: Bool32,
    pub multi_viewport: Bool32,
    pub sampler_anisotropy: Bool32,
    pub texture_compression_etc2: Bool32,
    pub texture_compression_astc_ldr: Bool32,
    pub texture_compression_bc: Bool32,
    pub occlusion_query_precise: Bool32,
    pub pipeline_statistics_query: Bool32,
    pub vertex_pipeline_stores_and_atomics: Bool32,
    pub fragment_stores_and_atomics: Bool32,
    pub shader_tessellation_and_geometry_point_size: Bool32,
    pub shader_image_gather_extended: Bool32,
    pub shader_storage_image_extended_formats: Bool32,
    pub shader_storage_image_multisample: Bool32,
    pub shader_storage_image_read_without_format: Bool32,
    pub shader_storage_image_write_without_format: Bool32,
    pub shader_uniform_buffer_array_dynamic_indexing: Bool32,
    pub shader_sampled_image_array_dynamic_indexing: Bool32,
    pub shader_storage_buffer_array_dynamic_indexing: Bool32,
    pub shader_storage_image_array_dynamic_indexing: Bool32,
    pub shader_clip_distance: Bool32,
    pub shader_cull_distance: Bool32,
    pub shader_float64: Bool32,
    pub shader_int64: Bool32,
    pub shader_int16: Bool32,
    pub shader_resource_residency: Bool32,
    pub shader_resource_min_lod: Bool32,
    pub sparse_binding: Bool32,
    pub sparse_residency_buffer: Bool32,
    pub sparse_residency_image2_d: Bool32,
    pub sparse_residency_image3_d: Bool32,
    pub sparse_residency2_samples: Bool32,
    pub sparse_residency4_samples: Bool32,
    pub sparse_residency8_samples: Bool32,
    pub sparse_residency16_samples: Bool32,
    pub sparse_residency_aliased: Bool32,
    pub variable_multisample_rate: Bool32,
    pub inherited_queries: Bool32,
}
impl PhysicalDeviceFeatures {
    pub fn builder<'a>() -> PhysicalDeviceFeaturesBuilder<'a> {
        PhysicalDeviceFeaturesBuilder {
            inner: PhysicalDeviceFeatures::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDeviceFeaturesBuilder<'a> {
    inner: PhysicalDeviceFeatures,
    marker: ::std::marker::PhantomData<&'a ()>,
}
impl<'a> ::std::ops::Deref for PhysicalDeviceFeaturesBuilder<'a> {
    type Target = PhysicalDeviceFeatures;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PhysicalDeviceFeaturesBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDeviceFeaturesBuilder<'a> {
    pub fn robust_buffer_access(
        mut self,
        robust_buffer_access: bool,
    ) -> PhysicalDeviceFeaturesBuilder<'a> {
        self.inner.robust_buffer_access = robust_buffer_access.into();
        self
    }
    pub fn full_draw_index_uint32(
        mut self,
        full_draw_index_uint32: bool,
    ) -> PhysicalDeviceFeaturesBuilder<'a> {
        self.inner.full_draw_index_uint32 = full_draw_index_uint32.into();
        self
    }
    pub fn image_cube_array(mut self, image_cube_array: bool) -> PhysicalDeviceFeaturesBuilder<'a> {
        self.inner.image_cube_array = image_cube_array.into();
        self
    }
    pub fn independent_blend(
        mut self,
        independent_blend: bool,
    ) -> PhysicalDeviceFeaturesBuilder<'a> {
        self.inner.independent_blend = independent_blend.into();
        self
    }
    pub fn geometry_shader(mut self, geometry_shader: bool) -> PhysicalDeviceFeaturesBuilder<'a> {
        self.inner.geometry_shader = geometry_shader.into();
        self
    }
    pub fn tessellation_shader(
        mut self,
        tessellation_shader: bool,
    ) -> PhysicalDeviceFeaturesBuilder<'a> {
        self.inner.tessellation_shader = tessellation_shader.into();
        self
    }
    pub fn sample_rate_shading(
        mut self,
        sample_rate_shading: bool,
    ) -> PhysicalDeviceFeaturesBuilder<'a> {
        self.inner.sample_rate_shading = sample_rate_shading.into();
        self
    }
    pub fn dual_src_blend(mut self, dual_src_blend: bool) -> PhysicalDeviceFeaturesBuilder<'a> {
        self.inner.dual_src_blend = dual_src_blend.into();
        self
    }
    pub fn logic_op(mut self, logic_op: bool) -> PhysicalDeviceFeaturesBuilder<'a> {
        self.inner.logic_op = logic_op.into();
        self
    }
    pub fn multi_draw_indirect(
        mut self,
        multi_draw_indirect: bool,
    ) -> PhysicalDeviceFeaturesBuilder<'a> {
        self.inner.multi_draw_indirect = multi_draw_indirect.into();
        self
    }
    pub fn draw_indirect_first_instance(
        mut self,
        draw_indirect_first_instance: bool,
    ) -> PhysicalDeviceFeaturesBuilder<'a> {
        self.inner.draw_indirect_first_instance = draw_indirect_first_instance.into();
        self
    }
    pub fn depth_clamp(mut self, depth_clamp: bool) -> PhysicalDeviceFeaturesBuilder<'a> {
        self.inner.depth_clamp = depth_clamp.into();
        self
    }
    pub fn depth_bias_clamp(mut self, depth_bias_clamp: bool) -> PhysicalDeviceFeaturesBuilder<'a> {
        self.inner.depth_bias_clamp = depth_bias_clamp.into();
        self
    }
    pub fn fill_mode_non_solid(
        mut self,
        fill_mode_non_solid: bool,
    ) -> PhysicalDeviceFeaturesBuilder<'a> {
        self.inner.fill_mode_non_solid = fill_mode_non_solid.into();
        self
    }
    pub fn depth_bounds(mut self, depth_bounds: bool) -> PhysicalDeviceFeaturesBuilder<'a> {
        self.inner.depth_bounds = depth_bounds.into();
        self
    }
    pub fn wide_lines(mut self, wide_lines: bool) -> PhysicalDeviceFeaturesBuilder<'a> {
        self.inner.wide_lines = wide_lines.into();
        self
    }
    pub fn large_points(mut self, large_points: bool) -> PhysicalDeviceFeaturesBuilder<'a> {
        self.inner.large_points = large_points.into();
        self
    }
    pub fn alpha_to_one(mut self, alpha_to_one: bool) -> PhysicalDeviceFeaturesBuilder<'a> {
        self.inner.alpha_to_one = alpha_to_one.into();
        self
    }
    pub fn multi_viewport(mut self, multi_viewport: bool) -> PhysicalDeviceFeaturesBuilder<'a> {
        self.inner.multi_viewport = multi_viewport.into();
        self
    }
    pub fn sampler_anisotropy(
        mut self,
        sampler_anisotropy: bool,
    ) -> PhysicalDeviceFeaturesBuilder<'a> {
        self.inner.sampler_anisotropy = sampler_anisotropy.into();
        self
    }
    pub fn texture_compression_etc2(
        mut self,
        texture_compression_etc2: bool,
    ) -> PhysicalDeviceFeaturesBuilder<'a> {
        self.inner.texture_compression_etc2 = texture_compression_etc2.into();
        self
    }
    pub fn texture_compression_astc_ldr(
        mut self,
        texture_compression_astc_ldr: bool,
    ) -> PhysicalDeviceFeaturesBuilder<'a> {
        self.inner.texture_compression_astc_ldr = texture_compression_astc_ldr.into();
        self
    }
    pub fn texture_compression_bc(
        mut self,
        texture_compression_bc: bool,
    ) -> PhysicalDeviceFeaturesBuilder<'a> {
        self.inner.texture_compression_bc = texture_compression_bc.into();
        self
    }
    pub fn occlusion_query_precise(
        mut self,
        occlusion_query_precise: bool,
    ) -> PhysicalDeviceFeaturesBuilder<'a> {
        self.inner.occlusion_query_precise = occlusion_query_precise.into();
        self
    }
    pub fn pipeline_statistics_query(
        mut self,
        pipeline_statistics_query: bool,
    ) -> PhysicalDeviceFeaturesBuilder<'a> {
        self.inner.pipeline_statistics_query = pipeline_statistics_query.into();
        self
    }
    pub fn vertex_pipeline_stores_and_atomics(
        mut self,
        vertex_pipeline_stores_and_atomics: bool,
    ) -> PhysicalDeviceFeaturesBuilder<'a> {
        self.inner.vertex_pipeline_stores_and_atomics = vertex_pipeline_stores_and_atomics.into();
        self
    }
    pub fn fragment_stores_and_atomics(
        mut self,
        fragment_stores_and_atomics: bool,
    ) -> PhysicalDeviceFeaturesBuilder<'a> {
        self.inner.fragment_stores_and_atomics = fragment_stores_and_atomics.into();
        self
    }
    pub fn shader_tessellation_and_geometry_point_size(
        mut self,
        shader_tessellation_and_geometry_point_size: bool,
    ) -> PhysicalDeviceFeaturesBuilder<'a> {
        self.inner.shader_tessellation_and_geometry_point_size =
            shader_tessellation_and_geometry_point_size.into();
        self
    }
    pub fn shader_image_gather_extended(
        mut self,
        shader_image_gather_extended: bool,
    ) -> PhysicalDeviceFeaturesBuilder<'a> {
        self.inner.shader_image_gather_extended = shader_image_gather_extended.into();
        self
    }
    pub fn shader_storage_image_extended_formats(
        mut self,
        shader_storage_image_extended_formats: bool,
    ) -> PhysicalDeviceFeaturesBuilder<'a> {
        self.inner.shader_storage_image_extended_formats =
            shader_storage_image_extended_formats.into();
        self
    }
    pub fn shader_storage_image_multisample(
        mut self,
        shader_storage_image_multisample: bool,
    ) -> PhysicalDeviceFeaturesBuilder<'a> {
        self.inner.shader_storage_image_multisample = shader_storage_image_multisample.into();
        self
    }
    pub fn shader_storage_image_read_without_format(
        mut self,
        shader_storage_image_read_without_format: bool,
    ) -> PhysicalDeviceFeaturesBuilder<'a> {
        self.inner.shader_storage_image_read_without_format =
            shader_storage_image_read_without_format.into();
        self
    }
    pub fn shader_storage_image_write_without_format(
        mut self,
        shader_storage_image_write_without_format: bool,
    ) -> PhysicalDeviceFeaturesBuilder<'a> {
        self.inner.shader_storage_image_write_without_format =
            shader_storage_image_write_without_format.into();
        self
    }
    pub fn shader_uniform_buffer_array_dynamic_indexing(
        mut self,
        shader_uniform_buffer_array_dynamic_indexing: bool,
    ) -> PhysicalDeviceFeaturesBuilder<'a> {
        self.inner.shader_uniform_buffer_array_dynamic_indexing =
            shader_uniform_buffer_array_dynamic_indexing.into();
        self
    }
    pub fn shader_sampled_image_array_dynamic_indexing(
        mut self,
        shader_sampled_image_array_dynamic_indexing: bool,
    ) -> PhysicalDeviceFeaturesBuilder<'a> {
        self.inner.shader_sampled_image_array_dynamic_indexing =
            shader_sampled_image_array_dynamic_indexing.into();
        self
    }
    pub fn shader_storage_buffer_array_dynamic_indexing(
        mut self,
        shader_storage_buffer_array_dynamic_indexing: bool,
    ) -> PhysicalDeviceFeaturesBuilder<'a> {
        self.inner.shader_storage_buffer_array_dynamic_indexing =
            shader_storage_buffer_array_dynamic_indexing.into();
        self
    }
    pub fn shader_storage_image_array_dynamic_indexing(
        mut self,
        shader_storage_image_array_dynamic_indexing: bool,
    ) -> PhysicalDeviceFeaturesBuilder<'a> {
        self.inner.shader_storage_image_array_dynamic_indexing =
            shader_storage_image_array_dynamic_indexing.into();
        self
    }
    pub fn shader_clip_distance(
        mut self,
        shader_clip_distance: bool,
    ) -> PhysicalDeviceFeaturesBuilder<'a> {
        self.inner.shader_clip_distance = shader_clip_distance.into();
        self
    }
    pub fn shader_cull_distance(
        mut self,
        shader_cull_distance: bool,
    ) -> PhysicalDeviceFeaturesBuilder<'a> {
        self.inner.shader_cull_distance = shader_cull_distance.into();
        self
    }
    pub fn shader_float64(mut self, shader_float64: bool) -> PhysicalDeviceFeaturesBuilder<'a> {
        self.inner.shader_float64 = shader_float64.into();
        self
    }
    pub fn shader_int64(mut self, shader_int64: bool) -> PhysicalDeviceFeaturesBuilder<'a> {
        self.inner.shader_int64 = shader_int64.into();
        self
    }
    pub fn shader_int16(mut self, shader_int16: bool) -> PhysicalDeviceFeaturesBuilder<'a> {
        self.inner.shader_int16 = shader_int16.into();
        self
    }
    pub fn shader_resource_residency(
        mut self,
        shader_resource_residency: bool,
    ) -> PhysicalDeviceFeaturesBuilder<'a> {
        self.inner.shader_resource_residency = shader_resource_residency.into();
        self
    }
    pub fn shader_resource_min_lod(
        mut self,
        shader_resource_min_lod: bool,
    ) -> PhysicalDeviceFeaturesBuilder<'a> {
        self.inner.shader_resource_min_lod = shader_resource_min_lod.into();
        self
    }
    pub fn sparse_binding(mut self, sparse_binding: bool) -> PhysicalDeviceFeaturesBuilder<'a> {
        self.inner.sparse_binding = sparse_binding.into();
        self
    }
    pub fn sparse_residency_buffer(
        mut self,
        sparse_residency_buffer: bool,
    ) -> PhysicalDeviceFeaturesBuilder<'a> {
        self.inner.sparse_residency_buffer = sparse_residency_buffer.into();
        self
    }
    pub fn sparse_residency_image2_d(
        mut self,
        sparse_residency_image2_d: bool,
    ) -> PhysicalDeviceFeaturesBuilder<'a> {
        self.inner.sparse_residency_image2_d = sparse_residency_image2_d.into();
        self
    }
    pub fn sparse_residency_image3_d(
        mut self,
        sparse_residency_image3_d: bool,
    ) -> PhysicalDeviceFeaturesBuilder<'a> {
        self.inner.sparse_residency_image3_d = sparse_residency_image3_d.into();
        self
    }
    pub fn sparse_residency2_samples(
        mut self,
        sparse_residency2_samples: bool,
    ) -> PhysicalDeviceFeaturesBuilder<'a> {
        self.inner.sparse_residency2_samples = sparse_residency2_samples.into();
        self
    }
    pub fn sparse_residency4_samples(
        mut self,
        sparse_residency4_samples: bool,
    ) -> PhysicalDeviceFeaturesBuilder<'a> {
        self.inner.sparse_residency4_samples = sparse_residency4_samples.into();
        self
    }
    pub fn sparse_residency8_samples(
        mut self,
        sparse_residency8_samples: bool,
    ) -> PhysicalDeviceFeaturesBuilder<'a> {
        self.inner.sparse_residency8_samples = sparse_residency8_samples.into();
        self
    }
    pub fn sparse_residency16_samples(
        mut self,
        sparse_residency16_samples: bool,
    ) -> PhysicalDeviceFeaturesBuilder<'a> {
        self.inner.sparse_residency16_samples = sparse_residency16_samples.into();
        self
    }
    pub fn sparse_residency_aliased(
        mut self,
        sparse_residency_aliased: bool,
    ) -> PhysicalDeviceFeaturesBuilder<'a> {
        self.inner.sparse_residency_aliased = sparse_residency_aliased.into();
        self
    }
    pub fn variable_multisample_rate(
        mut self,
        variable_multisample_rate: bool,
    ) -> PhysicalDeviceFeaturesBuilder<'a> {
        self.inner.variable_multisample_rate = variable_multisample_rate.into();
        self
    }
    pub fn inherited_queries(
        mut self,
        inherited_queries: bool,
    ) -> PhysicalDeviceFeaturesBuilder<'a> {
        self.inner.inherited_queries = inherited_queries.into();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDeviceFeatures {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Default, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceSparseProperties.html>"]
pub struct PhysicalDeviceSparseProperties {
    pub residency_standard2_d_block_shape: Bool32,
    pub residency_standard2_d_multisample_block_shape: Bool32,
    pub residency_standard3_d_block_shape: Bool32,
    pub residency_aligned_mip_size: Bool32,
    pub residency_non_resident_strict: Bool32,
}
impl PhysicalDeviceSparseProperties {
    pub fn builder<'a>() -> PhysicalDeviceSparsePropertiesBuilder<'a> {
        PhysicalDeviceSparsePropertiesBuilder {
            inner: PhysicalDeviceSparseProperties::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDeviceSparsePropertiesBuilder<'a> {
    inner: PhysicalDeviceSparseProperties,
    marker: ::std::marker::PhantomData<&'a ()>,
}
impl<'a> ::std::ops::Deref for PhysicalDeviceSparsePropertiesBuilder<'a> {
    type Target = PhysicalDeviceSparseProperties;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PhysicalDeviceSparsePropertiesBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDeviceSparsePropertiesBuilder<'a> {
    pub fn residency_standard2_d_block_shape(
        mut self,
        residency_standard2_d_block_shape: bool,
    ) -> PhysicalDeviceSparsePropertiesBuilder<'a> {
        self.inner.residency_standard2_d_block_shape = residency_standard2_d_block_shape.into();
        self
    }
    pub fn residency_standard2_d_multisample_block_shape(
        mut self,
        residency_standard2_d_multisample_block_shape: bool,
    ) -> PhysicalDeviceSparsePropertiesBuilder<'a> {
        self.inner.residency_standard2_d_multisample_block_shape =
            residency_standard2_d_multisample_block_shape.into();
        self
    }
    pub fn residency_standard3_d_block_shape(
        mut self,
        residency_standard3_d_block_shape: bool,
    ) -> PhysicalDeviceSparsePropertiesBuilder<'a> {
        self.inner.residency_standard3_d_block_shape = residency_standard3_d_block_shape.into();
        self
    }
    pub fn residency_aligned_mip_size(
        mut self,
        residency_aligned_mip_size: bool,
    ) -> PhysicalDeviceSparsePropertiesBuilder<'a> {
        self.inner.residency_aligned_mip_size = residency_aligned_mip_size.into();
        self
    }
    pub fn residency_non_resident_strict(
        mut self,
        residency_non_resident_strict: bool,
    ) -> PhysicalDeviceSparsePropertiesBuilder<'a> {
        self.inner.residency_non_resident_strict = residency_non_resident_strict.into();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDeviceSparseProperties {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLimits.html>"]
pub struct PhysicalDeviceLimits {
    pub max_image_dimension1_d: u32,
    pub max_image_dimension2_d: u32,
    pub max_image_dimension3_d: u32,
    pub max_image_dimension_cube: u32,
    pub max_image_array_layers: u32,
    pub max_texel_buffer_elements: u32,
    pub max_uniform_buffer_range: u32,
    pub max_storage_buffer_range: u32,
    pub max_push_constants_size: u32,
    pub max_memory_allocation_count: u32,
    pub max_sampler_allocation_count: u32,
    pub buffer_image_granularity: DeviceSize,
    pub sparse_address_space_size: DeviceSize,
    pub max_bound_descriptor_sets: u32,
    pub max_per_stage_descriptor_samplers: u32,
    pub max_per_stage_descriptor_uniform_buffers: u32,
    pub max_per_stage_descriptor_storage_buffers: u32,
    pub max_per_stage_descriptor_sampled_images: u32,
    pub max_per_stage_descriptor_storage_images: u32,
    pub max_per_stage_descriptor_input_attachments: u32,
    pub max_per_stage_resources: u32,
    pub max_descriptor_set_samplers: u32,
    pub max_descriptor_set_uniform_buffers: u32,
    pub max_descriptor_set_uniform_buffers_dynamic: u32,
    pub max_descriptor_set_storage_buffers: u32,
    pub max_descriptor_set_storage_buffers_dynamic: u32,
    pub max_descriptor_set_sampled_images: u32,
    pub max_descriptor_set_storage_images: u32,
    pub max_descriptor_set_input_attachments: u32,
    pub max_vertex_input_attributes: u32,
    pub max_vertex_input_bindings: u32,
    pub max_vertex_input_attribute_offset: u32,
    pub max_vertex_input_binding_stride: u32,
    pub max_vertex_output_components: u32,
    pub max_tessellation_generation_level: u32,
    pub max_tessellation_patch_size: u32,
    pub max_tessellation_control_per_vertex_input_components: u32,
    pub max_tessellation_control_per_vertex_output_components: u32,
    pub max_tessellation_control_per_patch_output_components: u32,
    pub max_tessellation_control_total_output_components: u32,
    pub max_tessellation_evaluation_input_components: u32,
    pub max_tessellation_evaluation_output_components: u32,
    pub max_geometry_shader_invocations: u32,
    pub max_geometry_input_components: u32,
    pub max_geometry_output_components: u32,
    pub max_geometry_output_vertices: u32,
    pub max_geometry_total_output_components: u32,
    pub max_fragment_input_components: u32,
    pub max_fragment_output_attachments: u32,
    pub max_fragment_dual_src_attachments: u32,
    pub max_fragment_combined_output_resources: u32,
    pub max_compute_shared_memory_size: u32,
    pub max_compute_work_group_count: [u32; 3],
    pub max_compute_work_group_invocations: u32,
    pub max_compute_work_group_size: [u32; 3],
    pub sub_pixel_precision_bits: u32,
    pub sub_texel_precision_bits: u32,
    pub mipmap_precision_bits: u32,
    pub max_draw_indexed_index_value: u32,
    pub max_draw_indirect_count: u32,
    pub max_sampler_lod_bias: f32,
    pub max_sampler_anisotropy: f32,
    pub max_viewports: u32,
    pub max_viewport_dimensions: [u32; 2],
    pub viewport_bounds_range: [f32; 2],
    pub viewport_sub_pixel_bits: u32,
    pub min_memory_map_alignment: usize,
    pub min_texel_buffer_offset_alignment: DeviceSize,
    pub min_uniform_buffer_offset_alignment: DeviceSize,
    pub min_storage_buffer_offset_alignment: DeviceSize,
    pub min_texel_offset: i32,
    pub max_texel_offset: u32,
    pub min_texel_gather_offset: i32,
    pub max_texel_gather_offset: u32,
    pub min_interpolation_offset: f32,
    pub max_interpolation_offset: f32,
    pub sub_pixel_interpolation_offset_bits: u32,
    pub max_framebuffer_width: u32,
    pub max_framebuffer_height: u32,
    pub max_framebuffer_layers: u32,
    pub framebuffer_color_sample_counts: SampleCountFlags,
    pub framebuffer_depth_sample_counts: SampleCountFlags,
    pub framebuffer_stencil_sample_counts: SampleCountFlags,
    pub framebuffer_no_attachments_sample_counts: SampleCountFlags,
    pub max_color_attachments: u32,
    pub sampled_image_color_sample_counts: SampleCountFlags,
    pub sampled_image_integer_sample_counts: SampleCountFlags,
    pub sampled_image_depth_sample_counts: SampleCountFlags,
    pub sampled_image_stencil_sample_counts: SampleCountFlags,
    pub storage_image_sample_counts: SampleCountFlags,
    pub max_sample_mask_words: u32,
    pub timestamp_compute_and_graphics: Bool32,
    pub timestamp_period: f32,
    pub max_clip_distances: u32,
    pub max_cull_distances: u32,
    pub max_combined_clip_and_cull_distances: u32,
    pub discrete_queue_priorities: u32,
    pub point_size_range: [f32; 2],
    pub line_width_range: [f32; 2],
    pub point_size_granularity: f32,
    pub line_width_granularity: f32,
    pub strict_lines: Bool32,
    pub standard_sample_locations: Bool32,
    pub optimal_buffer_copy_offset_alignment: DeviceSize,
    pub optimal_buffer_copy_row_pitch_alignment: DeviceSize,
    pub non_coherent_atom_size: DeviceSize,
}
impl ::std::default::Default for PhysicalDeviceLimits {
    fn default() -> PhysicalDeviceLimits {
        PhysicalDeviceLimits {
            max_image_dimension1_d: u32::default(),
            max_image_dimension2_d: u32::default(),
            max_image_dimension3_d: u32::default(),
            max_image_dimension_cube: u32::default(),
            max_image_array_layers: u32::default(),
            max_texel_buffer_elements: u32::default(),
            max_uniform_buffer_range: u32::default(),
            max_storage_buffer_range: u32::default(),
            max_push_constants_size: u32::default(),
            max_memory_allocation_count: u32::default(),
            max_sampler_allocation_count: u32::default(),
            buffer_image_granularity: DeviceSize::default(),
            sparse_address_space_size: DeviceSize::default(),
            max_bound_descriptor_sets: u32::default(),
            max_per_stage_descriptor_samplers: u32::default(),
            max_per_stage_descriptor_uniform_buffers: u32::default(),
            max_per_stage_descriptor_storage_buffers: u32::default(),
            max_per_stage_descriptor_sampled_images: u32::default(),
            max_per_stage_descriptor_storage_images: u32::default(),
            max_per_stage_descriptor_input_attachments: u32::default(),
            max_per_stage_resources: u32::default(),
            max_descriptor_set_samplers: u32::default(),
            max_descriptor_set_uniform_buffers: u32::default(),
            max_descriptor_set_uniform_buffers_dynamic: u32::default(),
            max_descriptor_set_storage_buffers: u32::default(),
            max_descriptor_set_storage_buffers_dynamic: u32::default(),
            max_descriptor_set_sampled_images: u32::default(),
            max_descriptor_set_storage_images: u32::default(),
            max_descriptor_set_input_attachments: u32::default(),
            max_vertex_input_attributes: u32::default(),
            max_vertex_input_bindings: u32::default(),
            max_vertex_input_attribute_offset: u32::default(),
            max_vertex_input_binding_stride: u32::default(),
            max_vertex_output_components: u32::default(),
            max_tessellation_generation_level: u32::default(),
            max_tessellation_patch_size: u32::default(),
            max_tessellation_control_per_vertex_input_components: u32::default(),
            max_tessellation_control_per_vertex_output_components: u32::default(),
            max_tessellation_control_per_patch_output_components: u32::default(),
            max_tessellation_control_total_output_components: u32::default(),
            max_tessellation_evaluation_input_components: u32::default(),
            max_tessellation_evaluation_output_components: u32::default(),
            max_geometry_shader_invocations: u32::default(),
            max_geometry_input_components: u32::default(),
            max_geometry_output_components: u32::default(),
            max_geometry_output_vertices: u32::default(),
            max_geometry_total_output_components: u32::default(),
            max_fragment_input_components: u32::default(),
            max_fragment_output_attachments: u32::default(),
            max_fragment_dual_src_attachments: u32::default(),
            max_fragment_combined_output_resources: u32::default(),
            max_compute_shared_memory_size: u32::default(),
            max_compute_work_group_count: unsafe { ::std::mem::zeroed() },
            max_compute_work_group_invocations: u32::default(),
            max_compute_work_group_size: unsafe { ::std::mem::zeroed() },
            sub_pixel_precision_bits: u32::default(),
            sub_texel_precision_bits: u32::default(),
            mipmap_precision_bits: u32::default(),
            max_draw_indexed_index_value: u32::default(),
            max_draw_indirect_count: u32::default(),
            max_sampler_lod_bias: f32::default(),
            max_sampler_anisotropy: f32::default(),
            max_viewports: u32::default(),
            max_viewport_dimensions: unsafe { ::std::mem::zeroed() },
            viewport_bounds_range: unsafe { ::std::mem::zeroed() },
            viewport_sub_pixel_bits: u32::default(),
            min_memory_map_alignment: usize::default(),
            min_texel_buffer_offset_alignment: DeviceSize::default(),
            min_uniform_buffer_offset_alignment: DeviceSize::default(),
            min_storage_buffer_offset_alignment: DeviceSize::default(),
            min_texel_offset: i32::default(),
            max_texel_offset: u32::default(),
            min_texel_gather_offset: i32::default(),
            max_texel_gather_offset: u32::default(),
            min_interpolation_offset: f32::default(),
            max_interpolation_offset: f32::default(),
            sub_pixel_interpolation_offset_bits: u32::default(),
            max_framebuffer_width: u32::default(),
            max_framebuffer_height: u32::default(),
            max_framebuffer_layers: u32::default(),
            framebuffer_color_sample_counts: SampleCountFlags::default(),
            framebuffer_depth_sample_counts: SampleCountFlags::default(),
            framebuffer_stencil_sample_counts: SampleCountFlags::default(),
            framebuffer_no_attachments_sample_counts: SampleCountFlags::default(),
            max_color_attachments: u32::default(),
            sampled_image_color_sample_counts: SampleCountFlags::default(),
            sampled_image_integer_sample_counts: SampleCountFlags::default(),
            sampled_image_depth_sample_counts: SampleCountFlags::default(),
            sampled_image_stencil_sample_counts: SampleCountFlags::default(),
            storage_image_sample_counts: SampleCountFlags::default(),
            max_sample_mask_words: u32::default(),
            timestamp_compute_and_graphics: Bool32::default(),
            timestamp_period: f32::default(),
            max_clip_distances: u32::default(),
            max_cull_distances: u32::default(),
            max_combined_clip_and_cull_distances: u32::default(),
            discrete_queue_priorities: u32::default(),
            point_size_range: unsafe { ::std::mem::zeroed() },
            line_width_range: unsafe { ::std::mem::zeroed() },
            point_size_granularity: f32::default(),
            line_width_granularity: f32::default(),
            strict_lines: Bool32::default(),
            standard_sample_locations: Bool32::default(),
            optimal_buffer_copy_offset_alignment: DeviceSize::default(),
            optimal_buffer_copy_row_pitch_alignment: DeviceSize::default(),
            non_coherent_atom_size: DeviceSize::default(),
        }
    }
}
impl PhysicalDeviceLimits {
    pub fn builder<'a>() -> PhysicalDeviceLimitsBuilder<'a> {
        PhysicalDeviceLimitsBuilder {
            inner: PhysicalDeviceLimits::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDeviceLimitsBuilder<'a> {
    inner: PhysicalDeviceLimits,
    marker: ::std::marker::PhantomData<&'a ()>,
}
impl<'a> ::std::ops::Deref for PhysicalDeviceLimitsBuilder<'a> {
    type Target = PhysicalDeviceLimits;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PhysicalDeviceLimitsBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDeviceLimitsBuilder<'a> {
    pub fn max_image_dimension1_d(
        mut self,
        max_image_dimension1_d: u32,
    ) -> PhysicalDeviceLimitsBuilder<'a> {
        self.inner.max_image_dimension1_d = max_image_dimension1_d;
        self
    }
    pub fn max_image_dimension2_d(
        mut self,
        max_image_dimension2_d: u32,
    ) -> PhysicalDeviceLimitsBuilder<'a> {
        self.inner.max_image_dimension2_d = max_image_dimension2_d;
        self
    }
    pub fn max_image_dimension3_d(
        mut self,
        max_image_dimension3_d: u32,
    ) -> PhysicalDeviceLimitsBuilder<'a> {
        self.inner.max_image_dimension3_d = max_image_dimension3_d;
        self
    }
    pub fn max_image_dimension_cube(
        mut self,
        max_image_dimension_cube: u32,
    ) -> PhysicalDeviceLimitsBuilder<'a> {
        self.inner.max_image_dimension_cube = max_image_dimension_cube;
        self
    }
    pub fn max_image_array_layers(
        mut self,
        max_image_array_layers: u32,
    ) -> PhysicalDeviceLimitsBuilder<'a> {
        self.inner.max_image_array_layers = max_image_array_layers;
        self
    }
    pub fn max_texel_buffer_elements(
        mut self,
        max_texel_buffer_elements: u32,
    ) -> PhysicalDeviceLimitsBuilder<'a> {
        self.inner.max_texel_buffer_elements = max_texel_buffer_elements;
        self
    }
    pub fn max_uniform_buffer_range(
        mut self,
        max_uniform_buffer_range: u32,
    ) -> PhysicalDeviceLimitsBuilder<'a> {
        self.inner.max_uniform_buffer_range = max_uniform_buffer_range;
        self
    }
    pub fn max_storage_buffer_range(
        mut self,
        max_storage_buffer_range: u32,
    ) -> PhysicalDeviceLimitsBuilder<'a> {
        self.inner.max_storage_buffer_range = max_storage_buffer_range;
        self
    }
    pub fn max_push_constants_size(
        mut self,
        max_push_constants_size: u32,
    ) -> PhysicalDeviceLimitsBuilder<'a> {
        self.inner.max_push_constants_size = max_push_constants_size;
        self
    }
    pub fn max_memory_allocation_count(
        mut self,
        max_memory_allocation_count: u32,
    ) -> PhysicalDeviceLimitsBuilder<'a> {
        self.inner.max_memory_allocation_count = max_memory_allocation_count;
        self
    }
    pub fn max_sampler_allocation_count(
        mut self,
        max_sampler_allocation_count: u32,
    ) -> PhysicalDeviceLimitsBuilder<'a> {
        self.inner.max_sampler_allocation_count = max_sampler_allocation_count;
        self
    }
    pub fn buffer_image_granularity(
        mut self,
        buffer_image_granularity: DeviceSize,
    ) -> PhysicalDeviceLimitsBuilder<'a> {
        self.inner.buffer_image_granularity = buffer_image_granularity;
        self
    }
    pub fn sparse_address_space_size(
        mut self,
        sparse_address_space_size: DeviceSize,
    ) -> PhysicalDeviceLimitsBuilder<'a> {
        self.inner.sparse_address_space_size = sparse_address_space_size;
        self
    }
    pub fn max_bound_descriptor_sets(
        mut self,
        max_bound_descriptor_sets: u32,
    ) -> PhysicalDeviceLimitsBuilder<'a> {
        self.inner.max_bound_descriptor_sets = max_bound_descriptor_sets;
        self
    }
    pub fn max_per_stage_descriptor_samplers(
        mut self,
        max_per_stage_descriptor_samplers: u32,
    ) -> PhysicalDeviceLimitsBuilder<'a> {
        self.inner.max_per_stage_descriptor_samplers = max_per_stage_descriptor_samplers;
        self
    }
    pub fn max_per_stage_descriptor_uniform_buffers(
        mut self,
        max_per_stage_descriptor_uniform_buffers: u32,
    ) -> PhysicalDeviceLimitsBuilder<'a> {
        self.inner.max_per_stage_descriptor_uniform_buffers =
            max_per_stage_descriptor_uniform_buffers;
        self
    }
    pub fn max_per_stage_descriptor_storage_buffers(
        mut self,
        max_per_stage_descriptor_storage_buffers: u32,
    ) -> PhysicalDeviceLimitsBuilder<'a> {
        self.inner.max_per_stage_descriptor_storage_buffers =
            max_per_stage_descriptor_storage_buffers;
        self
    }
    pub fn max_per_stage_descriptor_sampled_images(
        mut self,
        max_per_stage_descriptor_sampled_images: u32,
    ) -> PhysicalDeviceLimitsBuilder<'a> {
        self.inner.max_per_stage_descriptor_sampled_images =
            max_per_stage_descriptor_sampled_images;
        self
    }
    pub fn max_per_stage_descriptor_storage_images(
        mut self,
        max_per_stage_descriptor_storage_images: u32,
    ) -> PhysicalDeviceLimitsBuilder<'a> {
        self.inner.max_per_stage_descriptor_storage_images =
            max_per_stage_descriptor_storage_images;
        self
    }
    pub fn max_per_stage_descriptor_input_attachments(
        mut self,
        max_per_stage_descriptor_input_attachments: u32,
    ) -> PhysicalDeviceLimitsBuilder<'a> {
        self.inner.max_per_stage_descriptor_input_attachments =
            max_per_stage_descriptor_input_attachments;
        self
    }
    pub fn max_per_stage_resources(
        mut self,
        max_per_stage_resources: u32,
    ) -> PhysicalDeviceLimitsBuilder<'a> {
        self.inner.max_per_stage_resources = max_per_stage_resources;
        self
    }
    pub fn max_descriptor_set_samplers(
        mut self,
        max_descriptor_set_samplers: u32,
    ) -> PhysicalDeviceLimitsBuilder<'a> {
        self.inner.max_descriptor_set_samplers = max_descriptor_set_samplers;
        self
    }
    pub fn max_descriptor_set_uniform_buffers(
        mut self,
        max_descriptor_set_uniform_buffers: u32,
    ) -> PhysicalDeviceLimitsBuilder<'a> {
        self.inner.max_descriptor_set_uniform_buffers = max_descriptor_set_uniform_buffers;
        self
    }
    pub fn max_descriptor_set_uniform_buffers_dynamic(
        mut self,
        max_descriptor_set_uniform_buffers_dynamic: u32,
    ) -> PhysicalDeviceLimitsBuilder<'a> {
        self.inner.max_descriptor_set_uniform_buffers_dynamic =
            max_descriptor_set_uniform_buffers_dynamic;
        self
    }
    pub fn max_descriptor_set_storage_buffers(
        mut self,
        max_descriptor_set_storage_buffers: u32,
    ) -> PhysicalDeviceLimitsBuilder<'a> {
        self.inner.max_descriptor_set_storage_buffers = max_descriptor_set_storage_buffers;
        self
    }
    pub fn max_descriptor_set_storage_buffers_dynamic(
        mut self,
        max_descriptor_set_storage_buffers_dynamic: u32,
    ) -> PhysicalDeviceLimitsBuilder<'a> {
        self.inner.max_descriptor_set_storage_buffers_dynamic =
            max_descriptor_set_storage_buffers_dynamic;
        self
    }
    pub fn max_descriptor_set_sampled_images(
        mut self,
        max_descriptor_set_sampled_images: u32,
    ) -> PhysicalDeviceLimitsBuilder<'a> {
        self.inner.max_descriptor_set_sampled_images = max_descriptor_set_sampled_images;
        self
    }
    pub fn max_descriptor_set_storage_images(
        mut self,
        max_descriptor_set_storage_images: u32,
    ) -> PhysicalDeviceLimitsBuilder<'a> {
        self.inner.max_descriptor_set_storage_images = max_descriptor_set_storage_images;
        self
    }
    pub fn max_descriptor_set_input_attachments(
        mut self,
        max_descriptor_set_input_attachments: u32,
    ) -> PhysicalDeviceLimitsBuilder<'a> {
        self.inner.max_descriptor_set_input_attachments = max_descriptor_set_input_attachments;
        self
    }
    pub fn max_vertex_input_attributes(
        mut self,
        max_vertex_input_attributes: u32,
    ) -> PhysicalDeviceLimitsBuilder<'a> {
        self.inner.max_vertex_input_attributes = max_vertex_input_attributes;
        self
    }
    pub fn max_vertex_input_bindings(
        mut self,
        max_vertex_input_bindings: u32,
    ) -> PhysicalDeviceLimitsBuilder<'a> {
        self.inner.max_vertex_input_bindings = max_vertex_input_bindings;
        self
    }
    pub fn max_vertex_input_attribute_offset(
        mut self,
        max_vertex_input_attribute_offset: u32,
    ) -> PhysicalDeviceLimitsBuilder<'a> {
        self.inner.max_vertex_input_attribute_offset = max_vertex_input_attribute_offset;
        self
    }
    pub fn max_vertex_input_binding_stride(
        mut self,
        max_vertex_input_binding_stride: u32,
    ) -> PhysicalDeviceLimitsBuilder<'a> {
        self.inner.max_vertex_input_binding_stride = max_vertex_input_binding_stride;
        self
    }
    pub fn max_vertex_output_components(
        mut self,
        max_vertex_output_components: u32,
    ) -> PhysicalDeviceLimitsBuilder<'a> {
        self.inner.max_vertex_output_components = max_vertex_output_components;
        self
    }
    pub fn max_tessellation_generation_level(
        mut self,
        max_tessellation_generation_level: u32,
    ) -> PhysicalDeviceLimitsBuilder<'a> {
        self.inner.max_tessellation_generation_level = max_tessellation_generation_level;
        self
    }
    pub fn max_tessellation_patch_size(
        mut self,
        max_tessellation_patch_size: u32,
    ) -> PhysicalDeviceLimitsBuilder<'a> {
        self.inner.max_tessellation_patch_size = max_tessellation_patch_size;
        self
    }
    pub fn max_tessellation_control_per_vertex_input_components(
        mut self,
        max_tessellation_control_per_vertex_input_components: u32,
    ) -> PhysicalDeviceLimitsBuilder<'a> {
        self.inner
            .max_tessellation_control_per_vertex_input_components =
            max_tessellation_control_per_vertex_input_components;
        self
    }
    pub fn max_tessellation_control_per_vertex_output_components(
        mut self,
        max_tessellation_control_per_vertex_output_components: u32,
    ) -> PhysicalDeviceLimitsBuilder<'a> {
        self.inner
            .max_tessellation_control_per_vertex_output_components =
            max_tessellation_control_per_vertex_output_components;
        self
    }
    pub fn max_tessellation_control_per_patch_output_components(
        mut self,
        max_tessellation_control_per_patch_output_components: u32,
    ) -> PhysicalDeviceLimitsBuilder<'a> {
        self.inner
            .max_tessellation_control_per_patch_output_components =
            max_tessellation_control_per_patch_output_components;
        self
    }
    pub fn max_tessellation_control_total_output_components(
        mut self,
        max_tessellation_control_total_output_components: u32,
    ) -> PhysicalDeviceLimitsBuilder<'a> {
        self.inner.max_tessellation_control_total_output_components =
            max_tessellation_control_total_output_components;
        self
    }
    pub fn max_tessellation_evaluation_input_components(
        mut self,
        max_tessellation_evaluation_input_components: u32,
    ) -> PhysicalDeviceLimitsBuilder<'a> {
        self.inner.max_tessellation_evaluation_input_components =
            max_tessellation_evaluation_input_components;
        self
    }
    pub fn max_tessellation_evaluation_output_components(
        mut self,
        max_tessellation_evaluation_output_components: u32,
    ) -> PhysicalDeviceLimitsBuilder<'a> {
        self.inner.max_tessellation_evaluation_output_components =
            max_tessellation_evaluation_output_components;
        self
    }
    pub fn max_geometry_shader_invocations(
        mut self,
        max_geometry_shader_invocations: u32,
    ) -> PhysicalDeviceLimitsBuilder<'a> {
        self.inner.max_geometry_shader_invocations = max_geometry_shader_invocations;
        self
    }
    pub fn max_geometry_input_components(
        mut self,
        max_geometry_input_components: u32,
    ) -> PhysicalDeviceLimitsBuilder<'a> {
        self.inner.max_geometry_input_components = max_geometry_input_components;
        self
    }
    pub fn max_geometry_output_components(
        mut self,
        max_geometry_output_components: u32,
    ) -> PhysicalDeviceLimitsBuilder<'a> {
        self.inner.max_geometry_output_components = max_geometry_output_components;
        self
    }
    pub fn max_geometry_output_vertices(
        mut self,
        max_geometry_output_vertices: u32,
    ) -> PhysicalDeviceLimitsBuilder<'a> {
        self.inner.max_geometry_output_vertices = max_geometry_output_vertices;
        self
    }
    pub fn max_geometry_total_output_components(
        mut self,
        max_geometry_total_output_components: u32,
    ) -> PhysicalDeviceLimitsBuilder<'a> {
        self.inner.max_geometry_total_output_components = max_geometry_total_output_components;
        self
    }
    pub fn max_fragment_input_components(
        mut self,
        max_fragment_input_components: u32,
    ) -> PhysicalDeviceLimitsBuilder<'a> {
        self.inner.max_fragment_input_components = max_fragment_input_components;
        self
    }
    pub fn max_fragment_output_attachments(
        mut self,
        max_fragment_output_attachments: u32,
    ) -> PhysicalDeviceLimitsBuilder<'a> {
        self.inner.max_fragment_output_attachments = max_fragment_output_attachments;
        self
    }
    pub fn max_fragment_dual_src_attachments(
        mut self,
        max_fragment_dual_src_attachments: u32,
    ) -> PhysicalDeviceLimitsBuilder<'a> {
        self.inner.max_fragment_dual_src_attachments = max_fragment_dual_src_attachments;
        self
    }
    pub fn max_fragment_combined_output_resources(
        mut self,
        max_fragment_combined_output_resources: u32,
    ) -> PhysicalDeviceLimitsBuilder<'a> {
        self.inner.max_fragment_combined_output_resources = max_fragment_combined_output_resources;
        self
    }
    pub fn max_compute_shared_memory_size(
        mut self,
        max_compute_shared_memory_size: u32,
    ) -> PhysicalDeviceLimitsBuilder<'a> {
        self.inner.max_compute_shared_memory_size = max_compute_shared_memory_size;
        self
    }
    pub fn max_compute_work_group_count(
        mut self,
        max_compute_work_group_count: [u32; 3],
    ) -> PhysicalDeviceLimitsBuilder<'a> {
        self.inner.max_compute_work_group_count = max_compute_work_group_count;
        self
    }
    pub fn max_compute_work_group_invocations(
        mut self,
        max_compute_work_group_invocations: u32,
    ) -> PhysicalDeviceLimitsBuilder<'a> {
        self.inner.max_compute_work_group_invocations = max_compute_work_group_invocations;
        self
    }
    pub fn max_compute_work_group_size(
        mut self,
        max_compute_work_group_size: [u32; 3],
    ) -> PhysicalDeviceLimitsBuilder<'a> {
        self.inner.max_compute_work_group_size = max_compute_work_group_size;
        self
    }
    pub fn sub_pixel_precision_bits(
        mut self,
        sub_pixel_precision_bits: u32,
    ) -> PhysicalDeviceLimitsBuilder<'a> {
        self.inner.sub_pixel_precision_bits = sub_pixel_precision_bits;
        self
    }
    pub fn sub_texel_precision_bits(
        mut self,
        sub_texel_precision_bits: u32,
    ) -> PhysicalDeviceLimitsBuilder<'a> {
        self.inner.sub_texel_precision_bits = sub_texel_precision_bits;
        self
    }
    pub fn mipmap_precision_bits(
        mut self,
        mipmap_precision_bits: u32,
    ) -> PhysicalDeviceLimitsBuilder<'a> {
        self.inner.mipmap_precision_bits = mipmap_precision_bits;
        self
    }
    pub fn max_draw_indexed_index_value(
        mut self,
        max_draw_indexed_index_value: u32,
    ) -> PhysicalDeviceLimitsBuilder<'a> {
        self.inner.max_draw_indexed_index_value = max_draw_indexed_index_value;
        self
    }
    pub fn max_draw_indirect_count(
        mut self,
        max_draw_indirect_count: u32,
    ) -> PhysicalDeviceLimitsBuilder<'a> {
        self.inner.max_draw_indirect_count = max_draw_indirect_count;
        self
    }
    pub fn max_sampler_lod_bias(
        mut self,
        max_sampler_lod_bias: f32,
    ) -> PhysicalDeviceLimitsBuilder<'a> {
        self.inner.max_sampler_lod_bias = max_sampler_lod_bias;
        self
    }
    pub fn max_sampler_anisotropy(
        mut self,
        max_sampler_anisotropy: f32,
    ) -> PhysicalDeviceLimitsBuilder<'a> {
        self.inner.max_sampler_anisotropy = max_sampler_anisotropy;
        self
    }
    pub fn max_viewports(mut self, max_viewports: u32) -> PhysicalDeviceLimitsBuilder<'a> {
        self.inner.max_viewports = max_viewports;
        self
    }
    pub fn max_viewport_dimensions(
        mut self,
        max_viewport_dimensions: [u32; 2],
    ) -> PhysicalDeviceLimitsBuilder<'a> {
        self.inner.max_viewport_dimensions = max_viewport_dimensions;
        self
    }
    pub fn viewport_bounds_range(
        mut self,
        viewport_bounds_range: [f32; 2],
    ) -> PhysicalDeviceLimitsBuilder<'a> {
        self.inner.viewport_bounds_range = viewport_bounds_range;
        self
    }
    pub fn viewport_sub_pixel_bits(
        mut self,
        viewport_sub_pixel_bits: u32,
    ) -> PhysicalDeviceLimitsBuilder<'a> {
        self.inner.viewport_sub_pixel_bits = viewport_sub_pixel_bits;
        self
    }
    pub fn min_memory_map_alignment(
        mut self,
        min_memory_map_alignment: usize,
    ) -> PhysicalDeviceLimitsBuilder<'a> {
        self.inner.min_memory_map_alignment = min_memory_map_alignment;
        self
    }
    pub fn min_texel_buffer_offset_alignment(
        mut self,
        min_texel_buffer_offset_alignment: DeviceSize,
    ) -> PhysicalDeviceLimitsBuilder<'a> {
        self.inner.min_texel_buffer_offset_alignment = min_texel_buffer_offset_alignment;
        self
    }
    pub fn min_uniform_buffer_offset_alignment(
        mut self,
        min_uniform_buffer_offset_alignment: DeviceSize,
    ) -> PhysicalDeviceLimitsBuilder<'a> {
        self.inner.min_uniform_buffer_offset_alignment = min_uniform_buffer_offset_alignment;
        self
    }
    pub fn min_storage_buffer_offset_alignment(
        mut self,
        min_storage_buffer_offset_alignment: DeviceSize,
    ) -> PhysicalDeviceLimitsBuilder<'a> {
        self.inner.min_storage_buffer_offset_alignment = min_storage_buffer_offset_alignment;
        self
    }
    pub fn min_texel_offset(mut self, min_texel_offset: i32) -> PhysicalDeviceLimitsBuilder<'a> {
        self.inner.min_texel_offset = min_texel_offset;
        self
    }
    pub fn max_texel_offset(mut self, max_texel_offset: u32) -> PhysicalDeviceLimitsBuilder<'a> {
        self.inner.max_texel_offset = max_texel_offset;
        self
    }
    pub fn min_texel_gather_offset(
        mut self,
        min_texel_gather_offset: i32,
    ) -> PhysicalDeviceLimitsBuilder<'a> {
        self.inner.min_texel_gather_offset = min_texel_gather_offset;
        self
    }
    pub fn max_texel_gather_offset(
        mut self,
        max_texel_gather_offset: u32,
    ) -> PhysicalDeviceLimitsBuilder<'a> {
        self.inner.max_texel_gather_offset = max_texel_gather_offset;
        self
    }
    pub fn min_interpolation_offset(
        mut self,
        min_interpolation_offset: f32,
    ) -> PhysicalDeviceLimitsBuilder<'a> {
        self.inner.min_interpolation_offset = min_interpolation_offset;
        self
    }
    pub fn max_interpolation_offset(
        mut self,
        max_interpolation_offset: f32,
    ) -> PhysicalDeviceLimitsBuilder<'a> {
        self.inner.max_interpolation_offset = max_interpolation_offset;
        self
    }
    pub fn sub_pixel_interpolation_offset_bits(
        mut self,
        sub_pixel_interpolation_offset_bits: u32,
    ) -> PhysicalDeviceLimitsBuilder<'a> {
        self.inner.sub_pixel_interpolation_offset_bits = sub_pixel_interpolation_offset_bits;
        self
    }
    pub fn max_framebuffer_width(
        mut self,
        max_framebuffer_width: u32,
    ) -> PhysicalDeviceLimitsBuilder<'a> {
        self.inner.max_framebuffer_width = max_framebuffer_width;
        self
    }
    pub fn max_framebuffer_height(
        mut self,
        max_framebuffer_height: u32,
    ) -> PhysicalDeviceLimitsBuilder<'a> {
        self.inner.max_framebuffer_height = max_framebuffer_height;
        self
    }
    pub fn max_framebuffer_layers(
        mut self,
        max_framebuffer_layers: u32,
    ) -> PhysicalDeviceLimitsBuilder<'a> {
        self.inner.max_framebuffer_layers = max_framebuffer_layers;
        self
    }
    pub fn framebuffer_color_sample_counts(
        mut self,
        framebuffer_color_sample_counts: SampleCountFlags,
    ) -> PhysicalDeviceLimitsBuilder<'a> {
        self.inner.framebuffer_color_sample_counts = framebuffer_color_sample_counts;
        self
    }
    pub fn framebuffer_depth_sample_counts(
        mut self,
        framebuffer_depth_sample_counts: SampleCountFlags,
    ) -> PhysicalDeviceLimitsBuilder<'a> {
        self.inner.framebuffer_depth_sample_counts = framebuffer_depth_sample_counts;
        self
    }
    pub fn framebuffer_stencil_sample_counts(
        mut self,
        framebuffer_stencil_sample_counts: SampleCountFlags,
    ) -> PhysicalDeviceLimitsBuilder<'a> {
        self.inner.framebuffer_stencil_sample_counts = framebuffer_stencil_sample_counts;
        self
    }
    pub fn framebuffer_no_attachments_sample_counts(
        mut self,
        framebuffer_no_attachments_sample_counts: SampleCountFlags,
    ) -> PhysicalDeviceLimitsBuilder<'a> {
        self.inner.framebuffer_no_attachments_sample_counts =
            framebuffer_no_attachments_sample_counts;
        self
    }
    pub fn max_color_attachments(
        mut self,
        max_color_attachments: u32,
    ) -> PhysicalDeviceLimitsBuilder<'a> {
        self.inner.max_color_attachments = max_color_attachments;
        self
    }
    pub fn sampled_image_color_sample_counts(
        mut self,
        sampled_image_color_sample_counts: SampleCountFlags,
    ) -> PhysicalDeviceLimitsBuilder<'a> {
        self.inner.sampled_image_color_sample_counts = sampled_image_color_sample_counts;
        self
    }
    pub fn sampled_image_integer_sample_counts(
        mut self,
        sampled_image_integer_sample_counts: SampleCountFlags,
    ) -> PhysicalDeviceLimitsBuilder<'a> {
        self.inner.sampled_image_integer_sample_counts = sampled_image_integer_sample_counts;
        self
    }
    pub fn sampled_image_depth_sample_counts(
        mut self,
        sampled_image_depth_sample_counts: SampleCountFlags,
    ) -> PhysicalDeviceLimitsBuilder<'a> {
        self.inner.sampled_image_depth_sample_counts = sampled_image_depth_sample_counts;
        self
    }
    pub fn sampled_image_stencil_sample_counts(
        mut self,
        sampled_image_stencil_sample_counts: SampleCountFlags,
    ) -> PhysicalDeviceLimitsBuilder<'a> {
        self.inner.sampled_image_stencil_sample_counts = sampled_image_stencil_sample_counts;
        self
    }
    pub fn storage_image_sample_counts(
        mut self,
        storage_image_sample_counts: SampleCountFlags,
    ) -> PhysicalDeviceLimitsBuilder<'a> {
        self.inner.storage_image_sample_counts = storage_image_sample_counts;
        self
    }
    pub fn max_sample_mask_words(
        mut self,
        max_sample_mask_words: u32,
    ) -> PhysicalDeviceLimitsBuilder<'a> {
        self.inner.max_sample_mask_words = max_sample_mask_words;
        self
    }
    pub fn timestamp_compute_and_graphics(
        mut self,
        timestamp_compute_and_graphics: bool,
    ) -> PhysicalDeviceLimitsBuilder<'a> {
        self.inner.timestamp_compute_and_graphics = timestamp_compute_and_graphics.into();
        self
    }
    pub fn timestamp_period(mut self, timestamp_period: f32) -> PhysicalDeviceLimitsBuilder<'a> {
        self.inner.timestamp_period = timestamp_period;
        self
    }
    pub fn max_clip_distances(
        mut self,
        max_clip_distances: u32,
    ) -> PhysicalDeviceLimitsBuilder<'a> {
        self.inner.max_clip_distances = max_clip_distances;
        self
    }
    pub fn max_cull_distances(
        mut self,
        max_cull_distances: u32,
    ) -> PhysicalDeviceLimitsBuilder<'a> {
        self.inner.max_cull_distances = max_cull_distances;
        self
    }
    pub fn max_combined_clip_and_cull_distances(
        mut self,
        max_combined_clip_and_cull_distances: u32,
    ) -> PhysicalDeviceLimitsBuilder<'a> {
        self.inner.max_combined_clip_and_cull_distances = max_combined_clip_and_cull_distances;
        self
    }
    pub fn discrete_queue_priorities(
        mut self,
        discrete_queue_priorities: u32,
    ) -> PhysicalDeviceLimitsBuilder<'a> {
        self.inner.discrete_queue_priorities = discrete_queue_priorities;
        self
    }
    pub fn point_size_range(
        mut self,
        point_size_range: [f32; 2],
    ) -> PhysicalDeviceLimitsBuilder<'a> {
        self.inner.point_size_range = point_size_range;
        self
    }
    pub fn line_width_range(
        mut self,
        line_width_range: [f32; 2],
    ) -> PhysicalDeviceLimitsBuilder<'a> {
        self.inner.line_width_range = line_width_range;
        self
    }
    pub fn point_size_granularity(
        mut self,
        point_size_granularity: f32,
    ) -> PhysicalDeviceLimitsBuilder<'a> {
        self.inner.point_size_granularity = point_size_granularity;
        self
    }
    pub fn line_width_granularity(
        mut self,
        line_width_granularity: f32,
    ) -> PhysicalDeviceLimitsBuilder<'a> {
        self.inner.line_width_granularity = line_width_granularity;
        self
    }
    pub fn strict_lines(mut self, strict_lines: bool) -> PhysicalDeviceLimitsBuilder<'a> {
        self.inner.strict_lines = strict_lines.into();
        self
    }
    pub fn standard_sample_locations(
        mut self,
        standard_sample_locations: bool,
    ) -> PhysicalDeviceLimitsBuilder<'a> {
        self.inner.standard_sample_locations = standard_sample_locations.into();
        self
    }
    pub fn optimal_buffer_copy_offset_alignment(
        mut self,
        optimal_buffer_copy_offset_alignment: DeviceSize,
    ) -> PhysicalDeviceLimitsBuilder<'a> {
        self.inner.optimal_buffer_copy_offset_alignment = optimal_buffer_copy_offset_alignment;
        self
    }
    pub fn optimal_buffer_copy_row_pitch_alignment(
        mut self,
        optimal_buffer_copy_row_pitch_alignment: DeviceSize,
    ) -> PhysicalDeviceLimitsBuilder<'a> {
        self.inner.optimal_buffer_copy_row_pitch_alignment =
            optimal_buffer_copy_row_pitch_alignment;
        self
    }
    pub fn non_coherent_atom_size(
        mut self,
        non_coherent_atom_size: DeviceSize,
    ) -> PhysicalDeviceLimitsBuilder<'a> {
        self.inner.non_coherent_atom_size = non_coherent_atom_size;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDeviceLimits {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSemaphoreCreateInfo.html>"]
pub struct SemaphoreCreateInfo {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub flags: SemaphoreCreateFlags,
}
impl ::std::default::Default for SemaphoreCreateInfo {
    fn default() -> SemaphoreCreateInfo {
        SemaphoreCreateInfo {
            s_type: StructureType::SEMAPHORE_CREATE_INFO,
            p_next: ::std::ptr::null(),
            flags: SemaphoreCreateFlags::default(),
        }
    }
}
impl SemaphoreCreateInfo {
    pub fn builder<'a>() -> SemaphoreCreateInfoBuilder<'a> {
        SemaphoreCreateInfoBuilder {
            inner: SemaphoreCreateInfo::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct SemaphoreCreateInfoBuilder<'a> {
    inner: SemaphoreCreateInfo,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsSemaphoreCreateInfo {}
impl<'a> ::std::ops::Deref for SemaphoreCreateInfoBuilder<'a> {
    type Target = SemaphoreCreateInfo;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for SemaphoreCreateInfoBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> SemaphoreCreateInfoBuilder<'a> {
    pub fn flags(mut self, flags: SemaphoreCreateFlags) -> SemaphoreCreateInfoBuilder<'a> {
        self.inner.flags = flags;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsSemaphoreCreateInfo>(
        mut self,
        next: &'a mut T,
    ) -> SemaphoreCreateInfoBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> SemaphoreCreateInfo {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkQueryPoolCreateInfo.html>"]
pub struct QueryPoolCreateInfo {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub flags: QueryPoolCreateFlags,
    pub query_type: QueryType,
    pub query_count: u32,
    pub pipeline_statistics: QueryPipelineStatisticFlags,
}
impl ::std::default::Default for QueryPoolCreateInfo {
    fn default() -> QueryPoolCreateInfo {
        QueryPoolCreateInfo {
            s_type: StructureType::QUERY_POOL_CREATE_INFO,
            p_next: ::std::ptr::null(),
            flags: QueryPoolCreateFlags::default(),
            query_type: QueryType::default(),
            query_count: u32::default(),
            pipeline_statistics: QueryPipelineStatisticFlags::default(),
        }
    }
}
impl QueryPoolCreateInfo {
    pub fn builder<'a>() -> QueryPoolCreateInfoBuilder<'a> {
        QueryPoolCreateInfoBuilder {
            inner: QueryPoolCreateInfo::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct QueryPoolCreateInfoBuilder<'a> {
    inner: QueryPoolCreateInfo,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsQueryPoolCreateInfo {}
impl<'a> ::std::ops::Deref for QueryPoolCreateInfoBuilder<'a> {
    type Target = QueryPoolCreateInfo;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for QueryPoolCreateInfoBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> QueryPoolCreateInfoBuilder<'a> {
    pub fn flags(mut self, flags: QueryPoolCreateFlags) -> QueryPoolCreateInfoBuilder<'a> {
        self.inner.flags = flags;
        self
    }
    pub fn query_type(mut self, query_type: QueryType) -> QueryPoolCreateInfoBuilder<'a> {
        self.inner.query_type = query_type;
        self
    }
    pub fn query_count(mut self, query_count: u32) -> QueryPoolCreateInfoBuilder<'a> {
        self.inner.query_count = query_count;
        self
    }
    pub fn pipeline_statistics(
        mut self,
        pipeline_statistics: QueryPipelineStatisticFlags,
    ) -> QueryPoolCreateInfoBuilder<'a> {
        self.inner.pipeline_statistics = pipeline_statistics;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsQueryPoolCreateInfo>(
        mut self,
        next: &'a mut T,
    ) -> QueryPoolCreateInfoBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> QueryPoolCreateInfo {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkFramebufferCreateInfo.html>"]
pub struct FramebufferCreateInfo {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub flags: FramebufferCreateFlags,
    pub render_pass: RenderPass,
    pub attachment_count: u32,
    pub p_attachments: *const ImageView,
    pub width: u32,
    pub height: u32,
    pub layers: u32,
}
impl ::std::default::Default for FramebufferCreateInfo {
    fn default() -> FramebufferCreateInfo {
        FramebufferCreateInfo {
            s_type: StructureType::FRAMEBUFFER_CREATE_INFO,
            p_next: ::std::ptr::null(),
            flags: FramebufferCreateFlags::default(),
            render_pass: RenderPass::default(),
            attachment_count: u32::default(),
            p_attachments: ::std::ptr::null(),
            width: u32::default(),
            height: u32::default(),
            layers: u32::default(),
        }
    }
}
impl FramebufferCreateInfo {
    pub fn builder<'a>() -> FramebufferCreateInfoBuilder<'a> {
        FramebufferCreateInfoBuilder {
            inner: FramebufferCreateInfo::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct FramebufferCreateInfoBuilder<'a> {
    inner: FramebufferCreateInfo,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsFramebufferCreateInfo {}
impl<'a> ::std::ops::Deref for FramebufferCreateInfoBuilder<'a> {
    type Target = FramebufferCreateInfo;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for FramebufferCreateInfoBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> FramebufferCreateInfoBuilder<'a> {
    pub fn flags(mut self, flags: FramebufferCreateFlags) -> FramebufferCreateInfoBuilder<'a> {
        self.inner.flags = flags;
        self
    }
    pub fn render_pass(mut self, render_pass: RenderPass) -> FramebufferCreateInfoBuilder<'a> {
        self.inner.render_pass = render_pass;
        self
    }
    pub fn attachments(mut self, attachments: &'a [ImageView]) -> FramebufferCreateInfoBuilder<'a> {
        self.inner.attachment_count = attachments.len() as _;
        self.inner.p_attachments = attachments.as_ptr();
        self
    }
    pub fn width(mut self, width: u32) -> FramebufferCreateInfoBuilder<'a> {
        self.inner.width = width;
        self
    }
    pub fn height(mut self, height: u32) -> FramebufferCreateInfoBuilder<'a> {
        self.inner.height = height;
        self
    }
    pub fn layers(mut self, layers: u32) -> FramebufferCreateInfoBuilder<'a> {
        self.inner.layers = layers;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsFramebufferCreateInfo>(
        mut self,
        next: &'a mut T,
    ) -> FramebufferCreateInfoBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> FramebufferCreateInfo {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Default, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDrawIndirectCommand.html>"]
pub struct DrawIndirectCommand {
    pub vertex_count: u32,
    pub instance_count: u32,
    pub first_vertex: u32,
    pub first_instance: u32,
}
impl DrawIndirectCommand {
    pub fn builder<'a>() -> DrawIndirectCommandBuilder<'a> {
        DrawIndirectCommandBuilder {
            inner: DrawIndirectCommand::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct DrawIndirectCommandBuilder<'a> {
    inner: DrawIndirectCommand,
    marker: ::std::marker::PhantomData<&'a ()>,
}
impl<'a> ::std::ops::Deref for DrawIndirectCommandBuilder<'a> {
    type Target = DrawIndirectCommand;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for DrawIndirectCommandBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> DrawIndirectCommandBuilder<'a> {
    pub fn vertex_count(mut self, vertex_count: u32) -> DrawIndirectCommandBuilder<'a> {
        self.inner.vertex_count = vertex_count;
        self
    }
    pub fn instance_count(mut self, instance_count: u32) -> DrawIndirectCommandBuilder<'a> {
        self.inner.instance_count = instance_count;
        self
    }
    pub fn first_vertex(mut self, first_vertex: u32) -> DrawIndirectCommandBuilder<'a> {
        self.inner.first_vertex = first_vertex;
        self
    }
    pub fn first_instance(mut self, first_instance: u32) -> DrawIndirectCommandBuilder<'a> {
        self.inner.first_instance = first_instance;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> DrawIndirectCommand {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Default, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDrawIndexedIndirectCommand.html>"]
pub struct DrawIndexedIndirectCommand {
    pub index_count: u32,
    pub instance_count: u32,
    pub first_index: u32,
    pub vertex_offset: i32,
    pub first_instance: u32,
}
impl DrawIndexedIndirectCommand {
    pub fn builder<'a>() -> DrawIndexedIndirectCommandBuilder<'a> {
        DrawIndexedIndirectCommandBuilder {
            inner: DrawIndexedIndirectCommand::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct DrawIndexedIndirectCommandBuilder<'a> {
    inner: DrawIndexedIndirectCommand,
    marker: ::std::marker::PhantomData<&'a ()>,
}
impl<'a> ::std::ops::Deref for DrawIndexedIndirectCommandBuilder<'a> {
    type Target = DrawIndexedIndirectCommand;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for DrawIndexedIndirectCommandBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> DrawIndexedIndirectCommandBuilder<'a> {
    pub fn index_count(mut self, index_count: u32) -> DrawIndexedIndirectCommandBuilder<'a> {
        self.inner.index_count = index_count;
        self
    }
    pub fn instance_count(mut self, instance_count: u32) -> DrawIndexedIndirectCommandBuilder<'a> {
        self.inner.instance_count = instance_count;
        self
    }
    pub fn first_index(mut self, first_index: u32) -> DrawIndexedIndirectCommandBuilder<'a> {
        self.inner.first_index = first_index;
        self
    }
    pub fn vertex_offset(mut self, vertex_offset: i32) -> DrawIndexedIndirectCommandBuilder<'a> {
        self.inner.vertex_offset = vertex_offset;
        self
    }
    pub fn first_instance(mut self, first_instance: u32) -> DrawIndexedIndirectCommandBuilder<'a> {
        self.inner.first_instance = first_instance;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> DrawIndexedIndirectCommand {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Default, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDispatchIndirectCommand.html>"]
pub struct DispatchIndirectCommand {
    pub x: u32,
    pub y: u32,
    pub z: u32,
}
impl DispatchIndirectCommand {
    pub fn builder<'a>() -> DispatchIndirectCommandBuilder<'a> {
        DispatchIndirectCommandBuilder {
            inner: DispatchIndirectCommand::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct DispatchIndirectCommandBuilder<'a> {
    inner: DispatchIndirectCommand,
    marker: ::std::marker::PhantomData<&'a ()>,
}
impl<'a> ::std::ops::Deref for DispatchIndirectCommandBuilder<'a> {
    type Target = DispatchIndirectCommand;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for DispatchIndirectCommandBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> DispatchIndirectCommandBuilder<'a> {
    pub fn x(mut self, x: u32) -> DispatchIndirectCommandBuilder<'a> {
        self.inner.x = x;
        self
    }
    pub fn y(mut self, y: u32) -> DispatchIndirectCommandBuilder<'a> {
        self.inner.y = y;
        self
    }
    pub fn z(mut self, z: u32) -> DispatchIndirectCommandBuilder<'a> {
        self.inner.z = z;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> DispatchIndirectCommand {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSubmitInfo.html>"]
pub struct SubmitInfo {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub wait_semaphore_count: u32,
    pub p_wait_semaphores: *const Semaphore,
    pub p_wait_dst_stage_mask: *const PipelineStageFlags,
    pub command_buffer_count: u32,
    pub p_command_buffers: *const CommandBuffer,
    pub signal_semaphore_count: u32,
    pub p_signal_semaphores: *const Semaphore,
}
impl ::std::default::Default for SubmitInfo {
    fn default() -> SubmitInfo {
        SubmitInfo {
            s_type: StructureType::SUBMIT_INFO,
            p_next: ::std::ptr::null(),
            wait_semaphore_count: u32::default(),
            p_wait_semaphores: ::std::ptr::null(),
            p_wait_dst_stage_mask: ::std::ptr::null(),
            command_buffer_count: u32::default(),
            p_command_buffers: ::std::ptr::null(),
            signal_semaphore_count: u32::default(),
            p_signal_semaphores: ::std::ptr::null(),
        }
    }
}
impl SubmitInfo {
    pub fn builder<'a>() -> SubmitInfoBuilder<'a> {
        SubmitInfoBuilder {
            inner: SubmitInfo::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct SubmitInfoBuilder<'a> {
    inner: SubmitInfo,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsSubmitInfo {}
impl<'a> ::std::ops::Deref for SubmitInfoBuilder<'a> {
    type Target = SubmitInfo;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for SubmitInfoBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> SubmitInfoBuilder<'a> {
    pub fn wait_semaphores(mut self, wait_semaphores: &'a [Semaphore]) -> SubmitInfoBuilder<'a> {
        self.inner.wait_semaphore_count = wait_semaphores.len() as _;
        self.inner.p_wait_semaphores = wait_semaphores.as_ptr();
        self
    }
    pub fn wait_dst_stage_mask(
        mut self,
        wait_dst_stage_mask: &'a [PipelineStageFlags],
    ) -> SubmitInfoBuilder<'a> {
        self.inner.wait_semaphore_count = wait_dst_stage_mask.len() as _;
        self.inner.p_wait_dst_stage_mask = wait_dst_stage_mask.as_ptr();
        self
    }
    pub fn command_buffers(
        mut self,
        command_buffers: &'a [CommandBuffer],
    ) -> SubmitInfoBuilder<'a> {
        self.inner.command_buffer_count = command_buffers.len() as _;
        self.inner.p_command_buffers = command_buffers.as_ptr();
        self
    }
    pub fn signal_semaphores(
        mut self,
        signal_semaphores: &'a [Semaphore],
    ) -> SubmitInfoBuilder<'a> {
        self.inner.signal_semaphore_count = signal_semaphores.len() as _;
        self.inner.p_signal_semaphores = signal_semaphores.as_ptr();
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsSubmitInfo>(mut self, next: &'a mut T) -> SubmitInfoBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> SubmitInfo {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDisplayPropertiesKHR.html>"]
pub struct DisplayPropertiesKHR {
    pub display: DisplayKHR,
    pub display_name: *const c_char,
    pub physical_dimensions: Extent2D,
    pub physical_resolution: Extent2D,
    pub supported_transforms: SurfaceTransformFlagsKHR,
    pub plane_reorder_possible: Bool32,
    pub persistent_content: Bool32,
}
impl ::std::default::Default for DisplayPropertiesKHR {
    fn default() -> DisplayPropertiesKHR {
        DisplayPropertiesKHR {
            display: DisplayKHR::default(),
            display_name: ::std::ptr::null(),
            physical_dimensions: Extent2D::default(),
            physical_resolution: Extent2D::default(),
            supported_transforms: SurfaceTransformFlagsKHR::default(),
            plane_reorder_possible: Bool32::default(),
            persistent_content: Bool32::default(),
        }
    }
}
impl DisplayPropertiesKHR {
    pub fn builder<'a>() -> DisplayPropertiesKHRBuilder<'a> {
        DisplayPropertiesKHRBuilder {
            inner: DisplayPropertiesKHR::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct DisplayPropertiesKHRBuilder<'a> {
    inner: DisplayPropertiesKHR,
    marker: ::std::marker::PhantomData<&'a ()>,
}
impl<'a> ::std::ops::Deref for DisplayPropertiesKHRBuilder<'a> {
    type Target = DisplayPropertiesKHR;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for DisplayPropertiesKHRBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> DisplayPropertiesKHRBuilder<'a> {
    pub fn display(mut self, display: DisplayKHR) -> DisplayPropertiesKHRBuilder<'a> {
        self.inner.display = display;
        self
    }
    pub fn display_name(mut self, display_name: *const c_char) -> DisplayPropertiesKHRBuilder<'a> {
        self.inner.display_name = display_name;
        self
    }
    pub fn physical_dimensions(
        mut self,
        physical_dimensions: Extent2D,
    ) -> DisplayPropertiesKHRBuilder<'a> {
        self.inner.physical_dimensions = physical_dimensions;
        self
    }
    pub fn physical_resolution(
        mut self,
        physical_resolution: Extent2D,
    ) -> DisplayPropertiesKHRBuilder<'a> {
        self.inner.physical_resolution = physical_resolution;
        self
    }
    pub fn supported_transforms(
        mut self,
        supported_transforms: SurfaceTransformFlagsKHR,
    ) -> DisplayPropertiesKHRBuilder<'a> {
        self.inner.supported_transforms = supported_transforms;
        self
    }
    pub fn plane_reorder_possible(
        mut self,
        plane_reorder_possible: bool,
    ) -> DisplayPropertiesKHRBuilder<'a> {
        self.inner.plane_reorder_possible = plane_reorder_possible.into();
        self
    }
    pub fn persistent_content(
        mut self,
        persistent_content: bool,
    ) -> DisplayPropertiesKHRBuilder<'a> {
        self.inner.persistent_content = persistent_content.into();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> DisplayPropertiesKHR {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Default, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDisplayPlanePropertiesKHR.html>"]
pub struct DisplayPlanePropertiesKHR {
    pub current_display: DisplayKHR,
    pub current_stack_index: u32,
}
impl DisplayPlanePropertiesKHR {
    pub fn builder<'a>() -> DisplayPlanePropertiesKHRBuilder<'a> {
        DisplayPlanePropertiesKHRBuilder {
            inner: DisplayPlanePropertiesKHR::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct DisplayPlanePropertiesKHRBuilder<'a> {
    inner: DisplayPlanePropertiesKHR,
    marker: ::std::marker::PhantomData<&'a ()>,
}
impl<'a> ::std::ops::Deref for DisplayPlanePropertiesKHRBuilder<'a> {
    type Target = DisplayPlanePropertiesKHR;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for DisplayPlanePropertiesKHRBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> DisplayPlanePropertiesKHRBuilder<'a> {
    pub fn current_display(
        mut self,
        current_display: DisplayKHR,
    ) -> DisplayPlanePropertiesKHRBuilder<'a> {
        self.inner.current_display = current_display;
        self
    }
    pub fn current_stack_index(
        mut self,
        current_stack_index: u32,
    ) -> DisplayPlanePropertiesKHRBuilder<'a> {
        self.inner.current_stack_index = current_stack_index;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> DisplayPlanePropertiesKHR {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Default, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDisplayModeParametersKHR.html>"]
pub struct DisplayModeParametersKHR {
    pub visible_region: Extent2D,
    pub refresh_rate: u32,
}
impl DisplayModeParametersKHR {
    pub fn builder<'a>() -> DisplayModeParametersKHRBuilder<'a> {
        DisplayModeParametersKHRBuilder {
            inner: DisplayModeParametersKHR::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct DisplayModeParametersKHRBuilder<'a> {
    inner: DisplayModeParametersKHR,
    marker: ::std::marker::PhantomData<&'a ()>,
}
impl<'a> ::std::ops::Deref for DisplayModeParametersKHRBuilder<'a> {
    type Target = DisplayModeParametersKHR;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for DisplayModeParametersKHRBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> DisplayModeParametersKHRBuilder<'a> {
    pub fn visible_region(
        mut self,
        visible_region: Extent2D,
    ) -> DisplayModeParametersKHRBuilder<'a> {
        self.inner.visible_region = visible_region;
        self
    }
    pub fn refresh_rate(mut self, refresh_rate: u32) -> DisplayModeParametersKHRBuilder<'a> {
        self.inner.refresh_rate = refresh_rate;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> DisplayModeParametersKHR {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Default, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDisplayModePropertiesKHR.html>"]
pub struct DisplayModePropertiesKHR {
    pub display_mode: DisplayModeKHR,
    pub parameters: DisplayModeParametersKHR,
}
impl DisplayModePropertiesKHR {
    pub fn builder<'a>() -> DisplayModePropertiesKHRBuilder<'a> {
        DisplayModePropertiesKHRBuilder {
            inner: DisplayModePropertiesKHR::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct DisplayModePropertiesKHRBuilder<'a> {
    inner: DisplayModePropertiesKHR,
    marker: ::std::marker::PhantomData<&'a ()>,
}
impl<'a> ::std::ops::Deref for DisplayModePropertiesKHRBuilder<'a> {
    type Target = DisplayModePropertiesKHR;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for DisplayModePropertiesKHRBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> DisplayModePropertiesKHRBuilder<'a> {
    pub fn display_mode(
        mut self,
        display_mode: DisplayModeKHR,
    ) -> DisplayModePropertiesKHRBuilder<'a> {
        self.inner.display_mode = display_mode;
        self
    }
    pub fn parameters(
        mut self,
        parameters: DisplayModeParametersKHR,
    ) -> DisplayModePropertiesKHRBuilder<'a> {
        self.inner.parameters = parameters;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> DisplayModePropertiesKHR {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDisplayModeCreateInfoKHR.html>"]
pub struct DisplayModeCreateInfoKHR {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub flags: DisplayModeCreateFlagsKHR,
    pub parameters: DisplayModeParametersKHR,
}
impl ::std::default::Default for DisplayModeCreateInfoKHR {
    fn default() -> DisplayModeCreateInfoKHR {
        DisplayModeCreateInfoKHR {
            s_type: StructureType::DISPLAY_MODE_CREATE_INFO_KHR,
            p_next: ::std::ptr::null(),
            flags: DisplayModeCreateFlagsKHR::default(),
            parameters: DisplayModeParametersKHR::default(),
        }
    }
}
impl DisplayModeCreateInfoKHR {
    pub fn builder<'a>() -> DisplayModeCreateInfoKHRBuilder<'a> {
        DisplayModeCreateInfoKHRBuilder {
            inner: DisplayModeCreateInfoKHR::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct DisplayModeCreateInfoKHRBuilder<'a> {
    inner: DisplayModeCreateInfoKHR,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsDisplayModeCreateInfoKHR {}
impl<'a> ::std::ops::Deref for DisplayModeCreateInfoKHRBuilder<'a> {
    type Target = DisplayModeCreateInfoKHR;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for DisplayModeCreateInfoKHRBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> DisplayModeCreateInfoKHRBuilder<'a> {
    pub fn flags(
        mut self,
        flags: DisplayModeCreateFlagsKHR,
    ) -> DisplayModeCreateInfoKHRBuilder<'a> {
        self.inner.flags = flags;
        self
    }
    pub fn parameters(
        mut self,
        parameters: DisplayModeParametersKHR,
    ) -> DisplayModeCreateInfoKHRBuilder<'a> {
        self.inner.parameters = parameters;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsDisplayModeCreateInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> DisplayModeCreateInfoKHRBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> DisplayModeCreateInfoKHR {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Default, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDisplayPlaneCapabilitiesKHR.html>"]
pub struct DisplayPlaneCapabilitiesKHR {
    pub supported_alpha: DisplayPlaneAlphaFlagsKHR,
    pub min_src_position: Offset2D,
    pub max_src_position: Offset2D,
    pub min_src_extent: Extent2D,
    pub max_src_extent: Extent2D,
    pub min_dst_position: Offset2D,
    pub max_dst_position: Offset2D,
    pub min_dst_extent: Extent2D,
    pub max_dst_extent: Extent2D,
}
impl DisplayPlaneCapabilitiesKHR {
    pub fn builder<'a>() -> DisplayPlaneCapabilitiesKHRBuilder<'a> {
        DisplayPlaneCapabilitiesKHRBuilder {
            inner: DisplayPlaneCapabilitiesKHR::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct DisplayPlaneCapabilitiesKHRBuilder<'a> {
    inner: DisplayPlaneCapabilitiesKHR,
    marker: ::std::marker::PhantomData<&'a ()>,
}
impl<'a> ::std::ops::Deref for DisplayPlaneCapabilitiesKHRBuilder<'a> {
    type Target = DisplayPlaneCapabilitiesKHR;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for DisplayPlaneCapabilitiesKHRBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> DisplayPlaneCapabilitiesKHRBuilder<'a> {
    pub fn supported_alpha(
        mut self,
        supported_alpha: DisplayPlaneAlphaFlagsKHR,
    ) -> DisplayPlaneCapabilitiesKHRBuilder<'a> {
        self.inner.supported_alpha = supported_alpha;
        self
    }
    pub fn min_src_position(
        mut self,
        min_src_position: Offset2D,
    ) -> DisplayPlaneCapabilitiesKHRBuilder<'a> {
        self.inner.min_src_position = min_src_position;
        self
    }
    pub fn max_src_position(
        mut self,
        max_src_position: Offset2D,
    ) -> DisplayPlaneCapabilitiesKHRBuilder<'a> {
        self.inner.max_src_position = max_src_position;
        self
    }
    pub fn min_src_extent(
        mut self,
        min_src_extent: Extent2D,
    ) -> DisplayPlaneCapabilitiesKHRBuilder<'a> {
        self.inner.min_src_extent = min_src_extent;
        self
    }
    pub fn max_src_extent(
        mut self,
        max_src_extent: Extent2D,
    ) -> DisplayPlaneCapabilitiesKHRBuilder<'a> {
        self.inner.max_src_extent = max_src_extent;
        self
    }
    pub fn min_dst_position(
        mut self,
        min_dst_position: Offset2D,
    ) -> DisplayPlaneCapabilitiesKHRBuilder<'a> {
        self.inner.min_dst_position = min_dst_position;
        self
    }
    pub fn max_dst_position(
        mut self,
        max_dst_position: Offset2D,
    ) -> DisplayPlaneCapabilitiesKHRBuilder<'a> {
        self.inner.max_dst_position = max_dst_position;
        self
    }
    pub fn min_dst_extent(
        mut self,
        min_dst_extent: Extent2D,
    ) -> DisplayPlaneCapabilitiesKHRBuilder<'a> {
        self.inner.min_dst_extent = min_dst_extent;
        self
    }
    pub fn max_dst_extent(
        mut self,
        max_dst_extent: Extent2D,
    ) -> DisplayPlaneCapabilitiesKHRBuilder<'a> {
        self.inner.max_dst_extent = max_dst_extent;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> DisplayPlaneCapabilitiesKHR {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDisplaySurfaceCreateInfoKHR.html>"]
pub struct DisplaySurfaceCreateInfoKHR {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub flags: DisplaySurfaceCreateFlagsKHR,
    pub display_mode: DisplayModeKHR,
    pub plane_index: u32,
    pub plane_stack_index: u32,
    pub transform: SurfaceTransformFlagsKHR,
    pub global_alpha: f32,
    pub alpha_mode: DisplayPlaneAlphaFlagsKHR,
    pub image_extent: Extent2D,
}
impl ::std::default::Default for DisplaySurfaceCreateInfoKHR {
    fn default() -> DisplaySurfaceCreateInfoKHR {
        DisplaySurfaceCreateInfoKHR {
            s_type: StructureType::DISPLAY_SURFACE_CREATE_INFO_KHR,
            p_next: ::std::ptr::null(),
            flags: DisplaySurfaceCreateFlagsKHR::default(),
            display_mode: DisplayModeKHR::default(),
            plane_index: u32::default(),
            plane_stack_index: u32::default(),
            transform: SurfaceTransformFlagsKHR::default(),
            global_alpha: f32::default(),
            alpha_mode: DisplayPlaneAlphaFlagsKHR::default(),
            image_extent: Extent2D::default(),
        }
    }
}
impl DisplaySurfaceCreateInfoKHR {
    pub fn builder<'a>() -> DisplaySurfaceCreateInfoKHRBuilder<'a> {
        DisplaySurfaceCreateInfoKHRBuilder {
            inner: DisplaySurfaceCreateInfoKHR::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct DisplaySurfaceCreateInfoKHRBuilder<'a> {
    inner: DisplaySurfaceCreateInfoKHR,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsDisplaySurfaceCreateInfoKHR {}
impl<'a> ::std::ops::Deref for DisplaySurfaceCreateInfoKHRBuilder<'a> {
    type Target = DisplaySurfaceCreateInfoKHR;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for DisplaySurfaceCreateInfoKHRBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> DisplaySurfaceCreateInfoKHRBuilder<'a> {
    pub fn flags(
        mut self,
        flags: DisplaySurfaceCreateFlagsKHR,
    ) -> DisplaySurfaceCreateInfoKHRBuilder<'a> {
        self.inner.flags = flags;
        self
    }
    pub fn display_mode(
        mut self,
        display_mode: DisplayModeKHR,
    ) -> DisplaySurfaceCreateInfoKHRBuilder<'a> {
        self.inner.display_mode = display_mode;
        self
    }
    pub fn plane_index(mut self, plane_index: u32) -> DisplaySurfaceCreateInfoKHRBuilder<'a> {
        self.inner.plane_index = plane_index;
        self
    }
    pub fn plane_stack_index(
        mut self,
        plane_stack_index: u32,
    ) -> DisplaySurfaceCreateInfoKHRBuilder<'a> {
        self.inner.plane_stack_index = plane_stack_index;
        self
    }
    pub fn transform(
        mut self,
        transform: SurfaceTransformFlagsKHR,
    ) -> DisplaySurfaceCreateInfoKHRBuilder<'a> {
        self.inner.transform = transform;
        self
    }
    pub fn global_alpha(mut self, global_alpha: f32) -> DisplaySurfaceCreateInfoKHRBuilder<'a> {
        self.inner.global_alpha = global_alpha;
        self
    }
    pub fn alpha_mode(
        mut self,
        alpha_mode: DisplayPlaneAlphaFlagsKHR,
    ) -> DisplaySurfaceCreateInfoKHRBuilder<'a> {
        self.inner.alpha_mode = alpha_mode;
        self
    }
    pub fn image_extent(
        mut self,
        image_extent: Extent2D,
    ) -> DisplaySurfaceCreateInfoKHRBuilder<'a> {
        self.inner.image_extent = image_extent;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsDisplaySurfaceCreateInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> DisplaySurfaceCreateInfoKHRBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> DisplaySurfaceCreateInfoKHR {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDisplayPresentInfoKHR.html>"]
pub struct DisplayPresentInfoKHR {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub src_rect: Rect2D,
    pub dst_rect: Rect2D,
    pub persistent: Bool32,
}
impl ::std::default::Default for DisplayPresentInfoKHR {
    fn default() -> DisplayPresentInfoKHR {
        DisplayPresentInfoKHR {
            s_type: StructureType::DISPLAY_PRESENT_INFO_KHR,
            p_next: ::std::ptr::null(),
            src_rect: Rect2D::default(),
            dst_rect: Rect2D::default(),
            persistent: Bool32::default(),
        }
    }
}
impl DisplayPresentInfoKHR {
    pub fn builder<'a>() -> DisplayPresentInfoKHRBuilder<'a> {
        DisplayPresentInfoKHRBuilder {
            inner: DisplayPresentInfoKHR::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct DisplayPresentInfoKHRBuilder<'a> {
    inner: DisplayPresentInfoKHR,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsPresentInfoKHR for DisplayPresentInfoKHRBuilder<'_> {}
unsafe impl ExtendsPresentInfoKHR for DisplayPresentInfoKHR {}
impl<'a> ::std::ops::Deref for DisplayPresentInfoKHRBuilder<'a> {
    type Target = DisplayPresentInfoKHR;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for DisplayPresentInfoKHRBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> DisplayPresentInfoKHRBuilder<'a> {
    pub fn src_rect(mut self, src_rect: Rect2D) -> DisplayPresentInfoKHRBuilder<'a> {
        self.inner.src_rect = src_rect;
        self
    }
    pub fn dst_rect(mut self, dst_rect: Rect2D) -> DisplayPresentInfoKHRBuilder<'a> {
        self.inner.dst_rect = dst_rect;
        self
    }
    pub fn persistent(mut self, persistent: bool) -> DisplayPresentInfoKHRBuilder<'a> {
        self.inner.persistent = persistent.into();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> DisplayPresentInfoKHR {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Default, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSurfaceCapabilitiesKHR.html>"]
pub struct SurfaceCapabilitiesKHR {
    pub min_image_count: u32,
    pub max_image_count: u32,
    pub current_extent: Extent2D,
    pub min_image_extent: Extent2D,
    pub max_image_extent: Extent2D,
    pub max_image_array_layers: u32,
    pub supported_transforms: SurfaceTransformFlagsKHR,
    pub current_transform: SurfaceTransformFlagsKHR,
    pub supported_composite_alpha: CompositeAlphaFlagsKHR,
    pub supported_usage_flags: ImageUsageFlags,
}
impl SurfaceCapabilitiesKHR {
    pub fn builder<'a>() -> SurfaceCapabilitiesKHRBuilder<'a> {
        SurfaceCapabilitiesKHRBuilder {
            inner: SurfaceCapabilitiesKHR::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct SurfaceCapabilitiesKHRBuilder<'a> {
    inner: SurfaceCapabilitiesKHR,
    marker: ::std::marker::PhantomData<&'a ()>,
}
impl<'a> ::std::ops::Deref for SurfaceCapabilitiesKHRBuilder<'a> {
    type Target = SurfaceCapabilitiesKHR;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for SurfaceCapabilitiesKHRBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> SurfaceCapabilitiesKHRBuilder<'a> {
    pub fn min_image_count(mut self, min_image_count: u32) -> SurfaceCapabilitiesKHRBuilder<'a> {
        self.inner.min_image_count = min_image_count;
        self
    }
    pub fn max_image_count(mut self, max_image_count: u32) -> SurfaceCapabilitiesKHRBuilder<'a> {
        self.inner.max_image_count = max_image_count;
        self
    }
    pub fn current_extent(mut self, current_extent: Extent2D) -> SurfaceCapabilitiesKHRBuilder<'a> {
        self.inner.current_extent = current_extent;
        self
    }
    pub fn min_image_extent(
        mut self,
        min_image_extent: Extent2D,
    ) -> SurfaceCapabilitiesKHRBuilder<'a> {
        self.inner.min_image_extent = min_image_extent;
        self
    }
    pub fn max_image_extent(
        mut self,
        max_image_extent: Extent2D,
    ) -> SurfaceCapabilitiesKHRBuilder<'a> {
        self.inner.max_image_extent = max_image_extent;
        self
    }
    pub fn max_image_array_layers(
        mut self,
        max_image_array_layers: u32,
    ) -> SurfaceCapabilitiesKHRBuilder<'a> {
        self.inner.max_image_array_layers = max_image_array_layers;
        self
    }
    pub fn supported_transforms(
        mut self,
        supported_transforms: SurfaceTransformFlagsKHR,
    ) -> SurfaceCapabilitiesKHRBuilder<'a> {
        self.inner.supported_transforms = supported_transforms;
        self
    }
    pub fn current_transform(
        mut self,
        current_transform: SurfaceTransformFlagsKHR,
    ) -> SurfaceCapabilitiesKHRBuilder<'a> {
        self.inner.current_transform = current_transform;
        self
    }
    pub fn supported_composite_alpha(
        mut self,
        supported_composite_alpha: CompositeAlphaFlagsKHR,
    ) -> SurfaceCapabilitiesKHRBuilder<'a> {
        self.inner.supported_composite_alpha = supported_composite_alpha;
        self
    }
    pub fn supported_usage_flags(
        mut self,
        supported_usage_flags: ImageUsageFlags,
    ) -> SurfaceCapabilitiesKHRBuilder<'a> {
        self.inner.supported_usage_flags = supported_usage_flags;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> SurfaceCapabilitiesKHR {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAndroidSurfaceCreateInfoKHR.html>"]
pub struct AndroidSurfaceCreateInfoKHR {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub flags: AndroidSurfaceCreateFlagsKHR,
    pub window: *mut ANativeWindow,
}
impl ::std::default::Default for AndroidSurfaceCreateInfoKHR {
    fn default() -> AndroidSurfaceCreateInfoKHR {
        AndroidSurfaceCreateInfoKHR {
            s_type: StructureType::ANDROID_SURFACE_CREATE_INFO_KHR,
            p_next: ::std::ptr::null(),
            flags: AndroidSurfaceCreateFlagsKHR::default(),
            window: ::std::ptr::null_mut(),
        }
    }
}
impl AndroidSurfaceCreateInfoKHR {
    pub fn builder<'a>() -> AndroidSurfaceCreateInfoKHRBuilder<'a> {
        AndroidSurfaceCreateInfoKHRBuilder {
            inner: AndroidSurfaceCreateInfoKHR::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct AndroidSurfaceCreateInfoKHRBuilder<'a> {
    inner: AndroidSurfaceCreateInfoKHR,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsAndroidSurfaceCreateInfoKHR {}
impl<'a> ::std::ops::Deref for AndroidSurfaceCreateInfoKHRBuilder<'a> {
    type Target = AndroidSurfaceCreateInfoKHR;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for AndroidSurfaceCreateInfoKHRBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> AndroidSurfaceCreateInfoKHRBuilder<'a> {
    pub fn flags(
        mut self,
        flags: AndroidSurfaceCreateFlagsKHR,
    ) -> AndroidSurfaceCreateInfoKHRBuilder<'a> {
        self.inner.flags = flags;
        self
    }
    pub fn window(mut self, window: *mut ANativeWindow) -> AndroidSurfaceCreateInfoKHRBuilder<'a> {
        self.inner.window = window;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsAndroidSurfaceCreateInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> AndroidSurfaceCreateInfoKHRBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> AndroidSurfaceCreateInfoKHR {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkViSurfaceCreateInfoNN.html>"]
pub struct ViSurfaceCreateInfoNN {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub flags: ViSurfaceCreateFlagsNN,
    pub window: *mut c_void,
}
impl ::std::default::Default for ViSurfaceCreateInfoNN {
    fn default() -> ViSurfaceCreateInfoNN {
        ViSurfaceCreateInfoNN {
            s_type: StructureType::VI_SURFACE_CREATE_INFO_NN,
            p_next: ::std::ptr::null(),
            flags: ViSurfaceCreateFlagsNN::default(),
            window: ::std::ptr::null_mut(),
        }
    }
}
impl ViSurfaceCreateInfoNN {
    pub fn builder<'a>() -> ViSurfaceCreateInfoNNBuilder<'a> {
        ViSurfaceCreateInfoNNBuilder {
            inner: ViSurfaceCreateInfoNN::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct ViSurfaceCreateInfoNNBuilder<'a> {
    inner: ViSurfaceCreateInfoNN,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsViSurfaceCreateInfoNN {}
impl<'a> ::std::ops::Deref for ViSurfaceCreateInfoNNBuilder<'a> {
    type Target = ViSurfaceCreateInfoNN;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for ViSurfaceCreateInfoNNBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> ViSurfaceCreateInfoNNBuilder<'a> {
    pub fn flags(mut self, flags: ViSurfaceCreateFlagsNN) -> ViSurfaceCreateInfoNNBuilder<'a> {
        self.inner.flags = flags;
        self
    }
    pub fn window(mut self, window: *mut c_void) -> ViSurfaceCreateInfoNNBuilder<'a> {
        self.inner.window = window;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsViSurfaceCreateInfoNN>(
        mut self,
        next: &'a mut T,
    ) -> ViSurfaceCreateInfoNNBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> ViSurfaceCreateInfoNN {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkWaylandSurfaceCreateInfoKHR.html>"]
pub struct WaylandSurfaceCreateInfoKHR {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub flags: WaylandSurfaceCreateFlagsKHR,
    pub display: *mut wl_display,
    pub surface: *mut wl_surface,
}
impl ::std::default::Default for WaylandSurfaceCreateInfoKHR {
    fn default() -> WaylandSurfaceCreateInfoKHR {
        WaylandSurfaceCreateInfoKHR {
            s_type: StructureType::WAYLAND_SURFACE_CREATE_INFO_KHR,
            p_next: ::std::ptr::null(),
            flags: WaylandSurfaceCreateFlagsKHR::default(),
            display: ::std::ptr::null_mut(),
            surface: ::std::ptr::null_mut(),
        }
    }
}
impl WaylandSurfaceCreateInfoKHR {
    pub fn builder<'a>() -> WaylandSurfaceCreateInfoKHRBuilder<'a> {
        WaylandSurfaceCreateInfoKHRBuilder {
            inner: WaylandSurfaceCreateInfoKHR::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct WaylandSurfaceCreateInfoKHRBuilder<'a> {
    inner: WaylandSurfaceCreateInfoKHR,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsWaylandSurfaceCreateInfoKHR {}
impl<'a> ::std::ops::Deref for WaylandSurfaceCreateInfoKHRBuilder<'a> {
    type Target = WaylandSurfaceCreateInfoKHR;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for WaylandSurfaceCreateInfoKHRBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> WaylandSurfaceCreateInfoKHRBuilder<'a> {
    pub fn flags(
        mut self,
        flags: WaylandSurfaceCreateFlagsKHR,
    ) -> WaylandSurfaceCreateInfoKHRBuilder<'a> {
        self.inner.flags = flags;
        self
    }
    pub fn display(mut self, display: *mut wl_display) -> WaylandSurfaceCreateInfoKHRBuilder<'a> {
        self.inner.display = display;
        self
    }
    pub fn surface(mut self, surface: *mut wl_surface) -> WaylandSurfaceCreateInfoKHRBuilder<'a> {
        self.inner.surface = surface;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsWaylandSurfaceCreateInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> WaylandSurfaceCreateInfoKHRBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> WaylandSurfaceCreateInfoKHR {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkWin32SurfaceCreateInfoKHR.html>"]
pub struct Win32SurfaceCreateInfoKHR {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub flags: Win32SurfaceCreateFlagsKHR,
    pub hinstance: HINSTANCE,
    pub hwnd: HWND,
}
impl ::std::default::Default for Win32SurfaceCreateInfoKHR {
    fn default() -> Win32SurfaceCreateInfoKHR {
        Win32SurfaceCreateInfoKHR {
            s_type: StructureType::WIN32_SURFACE_CREATE_INFO_KHR,
            p_next: ::std::ptr::null(),
            flags: Win32SurfaceCreateFlagsKHR::default(),
            hinstance: unsafe { ::std::mem::zeroed() },
            hwnd: unsafe { ::std::mem::zeroed() },
        }
    }
}
impl Win32SurfaceCreateInfoKHR {
    pub fn builder<'a>() -> Win32SurfaceCreateInfoKHRBuilder<'a> {
        Win32SurfaceCreateInfoKHRBuilder {
            inner: Win32SurfaceCreateInfoKHR::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct Win32SurfaceCreateInfoKHRBuilder<'a> {
    inner: Win32SurfaceCreateInfoKHR,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsWin32SurfaceCreateInfoKHR {}
impl<'a> ::std::ops::Deref for Win32SurfaceCreateInfoKHRBuilder<'a> {
    type Target = Win32SurfaceCreateInfoKHR;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for Win32SurfaceCreateInfoKHRBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> Win32SurfaceCreateInfoKHRBuilder<'a> {
    pub fn flags(
        mut self,
        flags: Win32SurfaceCreateFlagsKHR,
    ) -> Win32SurfaceCreateInfoKHRBuilder<'a> {
        self.inner.flags = flags;
        self
    }
    pub fn hinstance(mut self, hinstance: HINSTANCE) -> Win32SurfaceCreateInfoKHRBuilder<'a> {
        self.inner.hinstance = hinstance;
        self
    }
    pub fn hwnd(mut self, hwnd: HWND) -> Win32SurfaceCreateInfoKHRBuilder<'a> {
        self.inner.hwnd = hwnd;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsWin32SurfaceCreateInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Win32SurfaceCreateInfoKHRBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> Win32SurfaceCreateInfoKHR {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkXlibSurfaceCreateInfoKHR.html>"]
pub struct XlibSurfaceCreateInfoKHR {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub flags: XlibSurfaceCreateFlagsKHR,
    pub dpy: *mut Display,
    pub window: Window,
}
impl ::std::default::Default for XlibSurfaceCreateInfoKHR {
    fn default() -> XlibSurfaceCreateInfoKHR {
        XlibSurfaceCreateInfoKHR {
            s_type: StructureType::XLIB_SURFACE_CREATE_INFO_KHR,
            p_next: ::std::ptr::null(),
            flags: XlibSurfaceCreateFlagsKHR::default(),
            dpy: ::std::ptr::null_mut(),
            window: Window::default(),
        }
    }
}
impl XlibSurfaceCreateInfoKHR {
    pub fn builder<'a>() -> XlibSurfaceCreateInfoKHRBuilder<'a> {
        XlibSurfaceCreateInfoKHRBuilder {
            inner: XlibSurfaceCreateInfoKHR::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct XlibSurfaceCreateInfoKHRBuilder<'a> {
    inner: XlibSurfaceCreateInfoKHR,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsXlibSurfaceCreateInfoKHR {}
impl<'a> ::std::ops::Deref for XlibSurfaceCreateInfoKHRBuilder<'a> {
    type Target = XlibSurfaceCreateInfoKHR;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for XlibSurfaceCreateInfoKHRBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> XlibSurfaceCreateInfoKHRBuilder<'a> {
    pub fn flags(
        mut self,
        flags: XlibSurfaceCreateFlagsKHR,
    ) -> XlibSurfaceCreateInfoKHRBuilder<'a> {
        self.inner.flags = flags;
        self
    }
    pub fn dpy(mut self, dpy: *mut Display) -> XlibSurfaceCreateInfoKHRBuilder<'a> {
        self.inner.dpy = dpy;
        self
    }
    pub fn window(mut self, window: Window) -> XlibSurfaceCreateInfoKHRBuilder<'a> {
        self.inner.window = window;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsXlibSurfaceCreateInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> XlibSurfaceCreateInfoKHRBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> XlibSurfaceCreateInfoKHR {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkXcbSurfaceCreateInfoKHR.html>"]
pub struct XcbSurfaceCreateInfoKHR {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub flags: XcbSurfaceCreateFlagsKHR,
    pub connection: *mut xcb_connection_t,
    pub window: xcb_window_t,
}
impl ::std::default::Default for XcbSurfaceCreateInfoKHR {
    fn default() -> XcbSurfaceCreateInfoKHR {
        XcbSurfaceCreateInfoKHR {
            s_type: StructureType::XCB_SURFACE_CREATE_INFO_KHR,
            p_next: ::std::ptr::null(),
            flags: XcbSurfaceCreateFlagsKHR::default(),
            connection: ::std::ptr::null_mut(),
            window: xcb_window_t::default(),
        }
    }
}
impl XcbSurfaceCreateInfoKHR {
    pub fn builder<'a>() -> XcbSurfaceCreateInfoKHRBuilder<'a> {
        XcbSurfaceCreateInfoKHRBuilder {
            inner: XcbSurfaceCreateInfoKHR::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct XcbSurfaceCreateInfoKHRBuilder<'a> {
    inner: XcbSurfaceCreateInfoKHR,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsXcbSurfaceCreateInfoKHR {}
impl<'a> ::std::ops::Deref for XcbSurfaceCreateInfoKHRBuilder<'a> {
    type Target = XcbSurfaceCreateInfoKHR;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for XcbSurfaceCreateInfoKHRBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> XcbSurfaceCreateInfoKHRBuilder<'a> {
    pub fn flags(mut self, flags: XcbSurfaceCreateFlagsKHR) -> XcbSurfaceCreateInfoKHRBuilder<'a> {
        self.inner.flags = flags;
        self
    }
    pub fn connection(
        mut self,
        connection: *mut xcb_connection_t,
    ) -> XcbSurfaceCreateInfoKHRBuilder<'a> {
        self.inner.connection = connection;
        self
    }
    pub fn window(mut self, window: xcb_window_t) -> XcbSurfaceCreateInfoKHRBuilder<'a> {
        self.inner.window = window;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsXcbSurfaceCreateInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> XcbSurfaceCreateInfoKHRBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> XcbSurfaceCreateInfoKHR {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImagePipeSurfaceCreateInfoFUCHSIA.html>"]
pub struct ImagePipeSurfaceCreateInfoFUCHSIA {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub flags: ImagePipeSurfaceCreateFlagsFUCHSIA,
    pub image_pipe_handle: zx_handle_t,
}
impl ::std::default::Default for ImagePipeSurfaceCreateInfoFUCHSIA {
    fn default() -> ImagePipeSurfaceCreateInfoFUCHSIA {
        ImagePipeSurfaceCreateInfoFUCHSIA {
            s_type: StructureType::IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA,
            p_next: ::std::ptr::null(),
            flags: ImagePipeSurfaceCreateFlagsFUCHSIA::default(),
            image_pipe_handle: zx_handle_t::default(),
        }
    }
}
impl ImagePipeSurfaceCreateInfoFUCHSIA {
    pub fn builder<'a>() -> ImagePipeSurfaceCreateInfoFUCHSIABuilder<'a> {
        ImagePipeSurfaceCreateInfoFUCHSIABuilder {
            inner: ImagePipeSurfaceCreateInfoFUCHSIA::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct ImagePipeSurfaceCreateInfoFUCHSIABuilder<'a> {
    inner: ImagePipeSurfaceCreateInfoFUCHSIA,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsImagePipeSurfaceCreateInfoFUCHSIA {}
impl<'a> ::std::ops::Deref for ImagePipeSurfaceCreateInfoFUCHSIABuilder<'a> {
    type Target = ImagePipeSurfaceCreateInfoFUCHSIA;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for ImagePipeSurfaceCreateInfoFUCHSIABuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> ImagePipeSurfaceCreateInfoFUCHSIABuilder<'a> {
    pub fn flags(
        mut self,
        flags: ImagePipeSurfaceCreateFlagsFUCHSIA,
    ) -> ImagePipeSurfaceCreateInfoFUCHSIABuilder<'a> {
        self.inner.flags = flags;
        self
    }
    pub fn image_pipe_handle(
        mut self,
        image_pipe_handle: zx_handle_t,
    ) -> ImagePipeSurfaceCreateInfoFUCHSIABuilder<'a> {
        self.inner.image_pipe_handle = image_pipe_handle;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsImagePipeSurfaceCreateInfoFUCHSIA>(
        mut self,
        next: &'a mut T,
    ) -> ImagePipeSurfaceCreateInfoFUCHSIABuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> ImagePipeSurfaceCreateInfoFUCHSIA {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkStreamDescriptorSurfaceCreateInfoGGP.html>"]
pub struct StreamDescriptorSurfaceCreateInfoGGP {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub flags: StreamDescriptorSurfaceCreateFlagsGGP,
    pub stream_descriptor: GgpStreamDescriptor,
}
impl ::std::default::Default for StreamDescriptorSurfaceCreateInfoGGP {
    fn default() -> StreamDescriptorSurfaceCreateInfoGGP {
        StreamDescriptorSurfaceCreateInfoGGP {
            s_type: StructureType::STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP,
            p_next: ::std::ptr::null(),
            flags: StreamDescriptorSurfaceCreateFlagsGGP::default(),
            stream_descriptor: GgpStreamDescriptor::default(),
        }
    }
}
impl StreamDescriptorSurfaceCreateInfoGGP {
    pub fn builder<'a>() -> StreamDescriptorSurfaceCreateInfoGGPBuilder<'a> {
        StreamDescriptorSurfaceCreateInfoGGPBuilder {
            inner: StreamDescriptorSurfaceCreateInfoGGP::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct StreamDescriptorSurfaceCreateInfoGGPBuilder<'a> {
    inner: StreamDescriptorSurfaceCreateInfoGGP,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsStreamDescriptorSurfaceCreateInfoGGP {}
impl<'a> ::std::ops::Deref for StreamDescriptorSurfaceCreateInfoGGPBuilder<'a> {
    type Target = StreamDescriptorSurfaceCreateInfoGGP;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for StreamDescriptorSurfaceCreateInfoGGPBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> StreamDescriptorSurfaceCreateInfoGGPBuilder<'a> {
    pub fn flags(
        mut self,
        flags: StreamDescriptorSurfaceCreateFlagsGGP,
    ) -> StreamDescriptorSurfaceCreateInfoGGPBuilder<'a> {
        self.inner.flags = flags;
        self
    }
    pub fn stream_descriptor(
        mut self,
        stream_descriptor: GgpStreamDescriptor,
    ) -> StreamDescriptorSurfaceCreateInfoGGPBuilder<'a> {
        self.inner.stream_descriptor = stream_descriptor;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsStreamDescriptorSurfaceCreateInfoGGP>(
        mut self,
        next: &'a mut T,
    ) -> StreamDescriptorSurfaceCreateInfoGGPBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> StreamDescriptorSurfaceCreateInfoGGP {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Default, Debug, PartialEq, Eq, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSurfaceFormatKHR.html>"]
pub struct SurfaceFormatKHR {
    pub format: Format,
    pub color_space: ColorSpaceKHR,
}
impl SurfaceFormatKHR {
    pub fn builder<'a>() -> SurfaceFormatKHRBuilder<'a> {
        SurfaceFormatKHRBuilder {
            inner: SurfaceFormatKHR::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct SurfaceFormatKHRBuilder<'a> {
    inner: SurfaceFormatKHR,
    marker: ::std::marker::PhantomData<&'a ()>,
}
impl<'a> ::std::ops::Deref for SurfaceFormatKHRBuilder<'a> {
    type Target = SurfaceFormatKHR;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for SurfaceFormatKHRBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> SurfaceFormatKHRBuilder<'a> {
    pub fn format(mut self, format: Format) -> SurfaceFormatKHRBuilder<'a> {
        self.inner.format = format;
        self
    }
    pub fn color_space(mut self, color_space: ColorSpaceKHR) -> SurfaceFormatKHRBuilder<'a> {
        self.inner.color_space = color_space;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> SurfaceFormatKHR {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSwapchainCreateInfoKHR.html>"]
pub struct SwapchainCreateInfoKHR {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub flags: SwapchainCreateFlagsKHR,
    pub surface: SurfaceKHR,
    pub min_image_count: u32,
    pub image_format: Format,
    pub image_color_space: ColorSpaceKHR,
    pub image_extent: Extent2D,
    pub image_array_layers: u32,
    pub image_usage: ImageUsageFlags,
    pub image_sharing_mode: SharingMode,
    pub queue_family_index_count: u32,
    pub p_queue_family_indices: *const u32,
    pub pre_transform: SurfaceTransformFlagsKHR,
    pub composite_alpha: CompositeAlphaFlagsKHR,
    pub present_mode: PresentModeKHR,
    pub clipped: Bool32,
    pub old_swapchain: SwapchainKHR,
}
impl ::std::default::Default for SwapchainCreateInfoKHR {
    fn default() -> SwapchainCreateInfoKHR {
        SwapchainCreateInfoKHR {
            s_type: StructureType::SWAPCHAIN_CREATE_INFO_KHR,
            p_next: ::std::ptr::null(),
            flags: SwapchainCreateFlagsKHR::default(),
            surface: SurfaceKHR::default(),
            min_image_count: u32::default(),
            image_format: Format::default(),
            image_color_space: ColorSpaceKHR::default(),
            image_extent: Extent2D::default(),
            image_array_layers: u32::default(),
            image_usage: ImageUsageFlags::default(),
            image_sharing_mode: SharingMode::default(),
            queue_family_index_count: u32::default(),
            p_queue_family_indices: ::std::ptr::null(),
            pre_transform: SurfaceTransformFlagsKHR::default(),
            composite_alpha: CompositeAlphaFlagsKHR::default(),
            present_mode: PresentModeKHR::default(),
            clipped: Bool32::default(),
            old_swapchain: SwapchainKHR::default(),
        }
    }
}
impl SwapchainCreateInfoKHR {
    pub fn builder<'a>() -> SwapchainCreateInfoKHRBuilder<'a> {
        SwapchainCreateInfoKHRBuilder {
            inner: SwapchainCreateInfoKHR::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct SwapchainCreateInfoKHRBuilder<'a> {
    inner: SwapchainCreateInfoKHR,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsSwapchainCreateInfoKHR {}
impl<'a> ::std::ops::Deref for SwapchainCreateInfoKHRBuilder<'a> {
    type Target = SwapchainCreateInfoKHR;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for SwapchainCreateInfoKHRBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> SwapchainCreateInfoKHRBuilder<'a> {
    pub fn flags(mut self, flags: SwapchainCreateFlagsKHR) -> SwapchainCreateInfoKHRBuilder<'a> {
        self.inner.flags = flags;
        self
    }
    pub fn surface(mut self, surface: SurfaceKHR) -> SwapchainCreateInfoKHRBuilder<'a> {
        self.inner.surface = surface;
        self
    }
    pub fn min_image_count(mut self, min_image_count: u32) -> SwapchainCreateInfoKHRBuilder<'a> {
        self.inner.min_image_count = min_image_count;
        self
    }
    pub fn image_format(mut self, image_format: Format) -> SwapchainCreateInfoKHRBuilder<'a> {
        self.inner.image_format = image_format;
        self
    }
    pub fn image_color_space(
        mut self,
        image_color_space: ColorSpaceKHR,
    ) -> SwapchainCreateInfoKHRBuilder<'a> {
        self.inner.image_color_space = image_color_space;
        self
    }
    pub fn image_extent(mut self, image_extent: Extent2D) -> SwapchainCreateInfoKHRBuilder<'a> {
        self.inner.image_extent = image_extent;
        self
    }
    pub fn image_array_layers(
        mut self,
        image_array_layers: u32,
    ) -> SwapchainCreateInfoKHRBuilder<'a> {
        self.inner.image_array_layers = image_array_layers;
        self
    }
    pub fn image_usage(
        mut self,
        image_usage: ImageUsageFlags,
    ) -> SwapchainCreateInfoKHRBuilder<'a> {
        self.inner.image_usage = image_usage;
        self
    }
    pub fn image_sharing_mode(
        mut self,
        image_sharing_mode: SharingMode,
    ) -> SwapchainCreateInfoKHRBuilder<'a> {
        self.inner.image_sharing_mode = image_sharing_mode;
        self
    }
    pub fn queue_family_indices(
        mut self,
        queue_family_indices: &'a [u32],
    ) -> SwapchainCreateInfoKHRBuilder<'a> {
        self.inner.queue_family_index_count = queue_family_indices.len() as _;
        self.inner.p_queue_family_indices = queue_family_indices.as_ptr();
        self
    }
    pub fn pre_transform(
        mut self,
        pre_transform: SurfaceTransformFlagsKHR,
    ) -> SwapchainCreateInfoKHRBuilder<'a> {
        self.inner.pre_transform = pre_transform;
        self
    }
    pub fn composite_alpha(
        mut self,
        composite_alpha: CompositeAlphaFlagsKHR,
    ) -> SwapchainCreateInfoKHRBuilder<'a> {
        self.inner.composite_alpha = composite_alpha;
        self
    }
    pub fn present_mode(
        mut self,
        present_mode: PresentModeKHR,
    ) -> SwapchainCreateInfoKHRBuilder<'a> {
        self.inner.present_mode = present_mode;
        self
    }
    pub fn clipped(mut self, clipped: bool) -> SwapchainCreateInfoKHRBuilder<'a> {
        self.inner.clipped = clipped.into();
        self
    }
    pub fn old_swapchain(
        mut self,
        old_swapchain: SwapchainKHR,
    ) -> SwapchainCreateInfoKHRBuilder<'a> {
        self.inner.old_swapchain = old_swapchain;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsSwapchainCreateInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> SwapchainCreateInfoKHRBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> SwapchainCreateInfoKHR {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPresentInfoKHR.html>"]
pub struct PresentInfoKHR {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub wait_semaphore_count: u32,
    pub p_wait_semaphores: *const Semaphore,
    pub swapchain_count: u32,
    pub p_swapchains: *const SwapchainKHR,
    pub p_image_indices: *const u32,
    pub p_results: *mut Result,
}
impl ::std::default::Default for PresentInfoKHR {
    fn default() -> PresentInfoKHR {
        PresentInfoKHR {
            s_type: StructureType::PRESENT_INFO_KHR,
            p_next: ::std::ptr::null(),
            wait_semaphore_count: u32::default(),
            p_wait_semaphores: ::std::ptr::null(),
            swapchain_count: u32::default(),
            p_swapchains: ::std::ptr::null(),
            p_image_indices: ::std::ptr::null(),
            p_results: ::std::ptr::null_mut(),
        }
    }
}
impl PresentInfoKHR {
    pub fn builder<'a>() -> PresentInfoKHRBuilder<'a> {
        PresentInfoKHRBuilder {
            inner: PresentInfoKHR::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PresentInfoKHRBuilder<'a> {
    inner: PresentInfoKHR,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsPresentInfoKHR {}
impl<'a> ::std::ops::Deref for PresentInfoKHRBuilder<'a> {
    type Target = PresentInfoKHR;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PresentInfoKHRBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PresentInfoKHRBuilder<'a> {
    pub fn wait_semaphores(
        mut self,
        wait_semaphores: &'a [Semaphore],
    ) -> PresentInfoKHRBuilder<'a> {
        self.inner.wait_semaphore_count = wait_semaphores.len() as _;
        self.inner.p_wait_semaphores = wait_semaphores.as_ptr();
        self
    }
    pub fn swapchains(mut self, swapchains: &'a [SwapchainKHR]) -> PresentInfoKHRBuilder<'a> {
        self.inner.swapchain_count = swapchains.len() as _;
        self.inner.p_swapchains = swapchains.as_ptr();
        self
    }
    pub fn image_indices(mut self, image_indices: &'a [u32]) -> PresentInfoKHRBuilder<'a> {
        self.inner.swapchain_count = image_indices.len() as _;
        self.inner.p_image_indices = image_indices.as_ptr();
        self
    }
    pub fn results(mut self, results: &'a mut [Result]) -> PresentInfoKHRBuilder<'a> {
        self.inner.swapchain_count = results.len() as _;
        self.inner.p_results = results.as_mut_ptr();
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsPresentInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> PresentInfoKHRBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PresentInfoKHR {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDebugReportCallbackCreateInfoEXT.html>"]
pub struct DebugReportCallbackCreateInfoEXT {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub flags: DebugReportFlagsEXT,
    pub pfn_callback: PFN_vkDebugReportCallbackEXT,
    pub p_user_data: *mut c_void,
}
impl fmt::Debug for DebugReportCallbackCreateInfoEXT {
    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
        fmt.debug_struct("DebugReportCallbackCreateInfoEXT")
            .field("s_type", &self.s_type)
            .field("p_next", &self.p_next)
            .field("flags", &self.flags)
            .field("pfn_callback", &(self.pfn_callback.map(|x| x as *const ())))
            .field("p_user_data", &self.p_user_data)
            .finish()
    }
}
impl ::std::default::Default for DebugReportCallbackCreateInfoEXT {
    fn default() -> DebugReportCallbackCreateInfoEXT {
        DebugReportCallbackCreateInfoEXT {
            s_type: StructureType::DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT,
            p_next: ::std::ptr::null(),
            flags: DebugReportFlagsEXT::default(),
            pfn_callback: PFN_vkDebugReportCallbackEXT::default(),
            p_user_data: ::std::ptr::null_mut(),
        }
    }
}
impl DebugReportCallbackCreateInfoEXT {
    pub fn builder<'a>() -> DebugReportCallbackCreateInfoEXTBuilder<'a> {
        DebugReportCallbackCreateInfoEXTBuilder {
            inner: DebugReportCallbackCreateInfoEXT::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct DebugReportCallbackCreateInfoEXTBuilder<'a> {
    inner: DebugReportCallbackCreateInfoEXT,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsInstanceCreateInfo for DebugReportCallbackCreateInfoEXTBuilder<'_> {}
unsafe impl ExtendsInstanceCreateInfo for DebugReportCallbackCreateInfoEXT {}
impl<'a> ::std::ops::Deref for DebugReportCallbackCreateInfoEXTBuilder<'a> {
    type Target = DebugReportCallbackCreateInfoEXT;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for DebugReportCallbackCreateInfoEXTBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> DebugReportCallbackCreateInfoEXTBuilder<'a> {
    pub fn flags(
        mut self,
        flags: DebugReportFlagsEXT,
    ) -> DebugReportCallbackCreateInfoEXTBuilder<'a> {
        self.inner.flags = flags;
        self
    }
    pub fn pfn_callback(
        mut self,
        pfn_callback: PFN_vkDebugReportCallbackEXT,
    ) -> DebugReportCallbackCreateInfoEXTBuilder<'a> {
        self.inner.pfn_callback = pfn_callback;
        self
    }
    pub fn user_data(
        mut self,
        user_data: *mut c_void,
    ) -> DebugReportCallbackCreateInfoEXTBuilder<'a> {
        self.inner.p_user_data = user_data;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> DebugReportCallbackCreateInfoEXT {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkValidationFlagsEXT.html>"]
pub struct ValidationFlagsEXT {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub disabled_validation_check_count: u32,
    pub p_disabled_validation_checks: *const ValidationCheckEXT,
}
impl ::std::default::Default for ValidationFlagsEXT {
    fn default() -> ValidationFlagsEXT {
        ValidationFlagsEXT {
            s_type: StructureType::VALIDATION_FLAGS_EXT,
            p_next: ::std::ptr::null(),
            disabled_validation_check_count: u32::default(),
            p_disabled_validation_checks: ::std::ptr::null(),
        }
    }
}
impl ValidationFlagsEXT {
    pub fn builder<'a>() -> ValidationFlagsEXTBuilder<'a> {
        ValidationFlagsEXTBuilder {
            inner: ValidationFlagsEXT::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct ValidationFlagsEXTBuilder<'a> {
    inner: ValidationFlagsEXT,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsInstanceCreateInfo for ValidationFlagsEXTBuilder<'_> {}
unsafe impl ExtendsInstanceCreateInfo for ValidationFlagsEXT {}
impl<'a> ::std::ops::Deref for ValidationFlagsEXTBuilder<'a> {
    type Target = ValidationFlagsEXT;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for ValidationFlagsEXTBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> ValidationFlagsEXTBuilder<'a> {
    pub fn disabled_validation_checks(
        mut self,
        disabled_validation_checks: &'a [ValidationCheckEXT],
    ) -> ValidationFlagsEXTBuilder<'a> {
        self.inner.disabled_validation_check_count = disabled_validation_checks.len() as _;
        self.inner.p_disabled_validation_checks = disabled_validation_checks.as_ptr();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> ValidationFlagsEXT {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkValidationFeaturesEXT.html>"]
pub struct ValidationFeaturesEXT {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub enabled_validation_feature_count: u32,
    pub p_enabled_validation_features: *const ValidationFeatureEnableEXT,
    pub disabled_validation_feature_count: u32,
    pub p_disabled_validation_features: *const ValidationFeatureDisableEXT,
}
impl ::std::default::Default for ValidationFeaturesEXT {
    fn default() -> ValidationFeaturesEXT {
        ValidationFeaturesEXT {
            s_type: StructureType::VALIDATION_FEATURES_EXT,
            p_next: ::std::ptr::null(),
            enabled_validation_feature_count: u32::default(),
            p_enabled_validation_features: ::std::ptr::null(),
            disabled_validation_feature_count: u32::default(),
            p_disabled_validation_features: ::std::ptr::null(),
        }
    }
}
impl ValidationFeaturesEXT {
    pub fn builder<'a>() -> ValidationFeaturesEXTBuilder<'a> {
        ValidationFeaturesEXTBuilder {
            inner: ValidationFeaturesEXT::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct ValidationFeaturesEXTBuilder<'a> {
    inner: ValidationFeaturesEXT,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsInstanceCreateInfo for ValidationFeaturesEXTBuilder<'_> {}
unsafe impl ExtendsInstanceCreateInfo for ValidationFeaturesEXT {}
impl<'a> ::std::ops::Deref for ValidationFeaturesEXTBuilder<'a> {
    type Target = ValidationFeaturesEXT;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for ValidationFeaturesEXTBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> ValidationFeaturesEXTBuilder<'a> {
    pub fn enabled_validation_features(
        mut self,
        enabled_validation_features: &'a [ValidationFeatureEnableEXT],
    ) -> ValidationFeaturesEXTBuilder<'a> {
        self.inner.enabled_validation_feature_count = enabled_validation_features.len() as _;
        self.inner.p_enabled_validation_features = enabled_validation_features.as_ptr();
        self
    }
    pub fn disabled_validation_features(
        mut self,
        disabled_validation_features: &'a [ValidationFeatureDisableEXT],
    ) -> ValidationFeaturesEXTBuilder<'a> {
        self.inner.disabled_validation_feature_count = disabled_validation_features.len() as _;
        self.inner.p_disabled_validation_features = disabled_validation_features.as_ptr();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> ValidationFeaturesEXT {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineRasterizationStateRasterizationOrderAMD.html>"]
pub struct PipelineRasterizationStateRasterizationOrderAMD {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub rasterization_order: RasterizationOrderAMD,
}
impl ::std::default::Default for PipelineRasterizationStateRasterizationOrderAMD {
    fn default() -> PipelineRasterizationStateRasterizationOrderAMD {
        PipelineRasterizationStateRasterizationOrderAMD {
            s_type: StructureType::PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD,
            p_next: ::std::ptr::null(),
            rasterization_order: RasterizationOrderAMD::default(),
        }
    }
}
impl PipelineRasterizationStateRasterizationOrderAMD {
    pub fn builder<'a>() -> PipelineRasterizationStateRasterizationOrderAMDBuilder<'a> {
        PipelineRasterizationStateRasterizationOrderAMDBuilder {
            inner: PipelineRasterizationStateRasterizationOrderAMD::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PipelineRasterizationStateRasterizationOrderAMDBuilder<'a> {
    inner: PipelineRasterizationStateRasterizationOrderAMD,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsPipelineRasterizationStateCreateInfo
    for PipelineRasterizationStateRasterizationOrderAMDBuilder<'_>
{
}
unsafe impl ExtendsPipelineRasterizationStateCreateInfo
    for PipelineRasterizationStateRasterizationOrderAMD
{
}
impl<'a> ::std::ops::Deref for PipelineRasterizationStateRasterizationOrderAMDBuilder<'a> {
    type Target = PipelineRasterizationStateRasterizationOrderAMD;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PipelineRasterizationStateRasterizationOrderAMDBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PipelineRasterizationStateRasterizationOrderAMDBuilder<'a> {
    pub fn rasterization_order(
        mut self,
        rasterization_order: RasterizationOrderAMD,
    ) -> PipelineRasterizationStateRasterizationOrderAMDBuilder<'a> {
        self.inner.rasterization_order = rasterization_order;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PipelineRasterizationStateRasterizationOrderAMD {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDebugMarkerObjectNameInfoEXT.html>"]
pub struct DebugMarkerObjectNameInfoEXT {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub object_type: DebugReportObjectTypeEXT,
    pub object: u64,
    pub p_object_name: *const c_char,
}
impl ::std::default::Default for DebugMarkerObjectNameInfoEXT {
    fn default() -> DebugMarkerObjectNameInfoEXT {
        DebugMarkerObjectNameInfoEXT {
            s_type: StructureType::DEBUG_MARKER_OBJECT_NAME_INFO_EXT,
            p_next: ::std::ptr::null(),
            object_type: DebugReportObjectTypeEXT::default(),
            object: u64::default(),
            p_object_name: ::std::ptr::null(),
        }
    }
}
impl DebugMarkerObjectNameInfoEXT {
    pub fn builder<'a>() -> DebugMarkerObjectNameInfoEXTBuilder<'a> {
        DebugMarkerObjectNameInfoEXTBuilder {
            inner: DebugMarkerObjectNameInfoEXT::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct DebugMarkerObjectNameInfoEXTBuilder<'a> {
    inner: DebugMarkerObjectNameInfoEXT,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsDebugMarkerObjectNameInfoEXT {}
impl<'a> ::std::ops::Deref for DebugMarkerObjectNameInfoEXTBuilder<'a> {
    type Target = DebugMarkerObjectNameInfoEXT;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for DebugMarkerObjectNameInfoEXTBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> DebugMarkerObjectNameInfoEXTBuilder<'a> {
    pub fn object_type(
        mut self,
        object_type: DebugReportObjectTypeEXT,
    ) -> DebugMarkerObjectNameInfoEXTBuilder<'a> {
        self.inner.object_type = object_type;
        self
    }
    pub fn object(mut self, object: u64) -> DebugMarkerObjectNameInfoEXTBuilder<'a> {
        self.inner.object = object;
        self
    }
    pub fn object_name(
        mut self,
        object_name: &'a ::std::ffi::CStr,
    ) -> DebugMarkerObjectNameInfoEXTBuilder<'a> {
        self.inner.p_object_name = object_name.as_ptr();
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsDebugMarkerObjectNameInfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> DebugMarkerObjectNameInfoEXTBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> DebugMarkerObjectNameInfoEXT {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDebugMarkerObjectTagInfoEXT.html>"]
pub struct DebugMarkerObjectTagInfoEXT {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub object_type: DebugReportObjectTypeEXT,
    pub object: u64,
    pub tag_name: u64,
    pub tag_size: usize,
    pub p_tag: *const c_void,
}
impl ::std::default::Default for DebugMarkerObjectTagInfoEXT {
    fn default() -> DebugMarkerObjectTagInfoEXT {
        DebugMarkerObjectTagInfoEXT {
            s_type: StructureType::DEBUG_MARKER_OBJECT_TAG_INFO_EXT,
            p_next: ::std::ptr::null(),
            object_type: DebugReportObjectTypeEXT::default(),
            object: u64::default(),
            tag_name: u64::default(),
            tag_size: usize::default(),
            p_tag: ::std::ptr::null(),
        }
    }
}
impl DebugMarkerObjectTagInfoEXT {
    pub fn builder<'a>() -> DebugMarkerObjectTagInfoEXTBuilder<'a> {
        DebugMarkerObjectTagInfoEXTBuilder {
            inner: DebugMarkerObjectTagInfoEXT::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct DebugMarkerObjectTagInfoEXTBuilder<'a> {
    inner: DebugMarkerObjectTagInfoEXT,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsDebugMarkerObjectTagInfoEXT {}
impl<'a> ::std::ops::Deref for DebugMarkerObjectTagInfoEXTBuilder<'a> {
    type Target = DebugMarkerObjectTagInfoEXT;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for DebugMarkerObjectTagInfoEXTBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> DebugMarkerObjectTagInfoEXTBuilder<'a> {
    pub fn object_type(
        mut self,
        object_type: DebugReportObjectTypeEXT,
    ) -> DebugMarkerObjectTagInfoEXTBuilder<'a> {
        self.inner.object_type = object_type;
        self
    }
    pub fn object(mut self, object: u64) -> DebugMarkerObjectTagInfoEXTBuilder<'a> {
        self.inner.object = object;
        self
    }
    pub fn tag_name(mut self, tag_name: u64) -> DebugMarkerObjectTagInfoEXTBuilder<'a> {
        self.inner.tag_name = tag_name;
        self
    }
    pub fn tag(mut self, tag: &'a [u8]) -> DebugMarkerObjectTagInfoEXTBuilder<'a> {
        self.inner.tag_size = tag.len() as _;
        self.inner.p_tag = tag.as_ptr() as *const c_void;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsDebugMarkerObjectTagInfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> DebugMarkerObjectTagInfoEXTBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> DebugMarkerObjectTagInfoEXT {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDebugMarkerMarkerInfoEXT.html>"]
pub struct DebugMarkerMarkerInfoEXT {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub p_marker_name: *const c_char,
    pub color: [f32; 4],
}
impl ::std::default::Default for DebugMarkerMarkerInfoEXT {
    fn default() -> DebugMarkerMarkerInfoEXT {
        DebugMarkerMarkerInfoEXT {
            s_type: StructureType::DEBUG_MARKER_MARKER_INFO_EXT,
            p_next: ::std::ptr::null(),
            p_marker_name: ::std::ptr::null(),
            color: unsafe { ::std::mem::zeroed() },
        }
    }
}
impl DebugMarkerMarkerInfoEXT {
    pub fn builder<'a>() -> DebugMarkerMarkerInfoEXTBuilder<'a> {
        DebugMarkerMarkerInfoEXTBuilder {
            inner: DebugMarkerMarkerInfoEXT::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct DebugMarkerMarkerInfoEXTBuilder<'a> {
    inner: DebugMarkerMarkerInfoEXT,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsDebugMarkerMarkerInfoEXT {}
impl<'a> ::std::ops::Deref for DebugMarkerMarkerInfoEXTBuilder<'a> {
    type Target = DebugMarkerMarkerInfoEXT;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for DebugMarkerMarkerInfoEXTBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> DebugMarkerMarkerInfoEXTBuilder<'a> {
    pub fn marker_name(
        mut self,
        marker_name: &'a ::std::ffi::CStr,
    ) -> DebugMarkerMarkerInfoEXTBuilder<'a> {
        self.inner.p_marker_name = marker_name.as_ptr();
        self
    }
    pub fn color(mut self, color: [f32; 4]) -> DebugMarkerMarkerInfoEXTBuilder<'a> {
        self.inner.color = color;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsDebugMarkerMarkerInfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> DebugMarkerMarkerInfoEXTBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> DebugMarkerMarkerInfoEXT {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDedicatedAllocationImageCreateInfoNV.html>"]
pub struct DedicatedAllocationImageCreateInfoNV {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub dedicated_allocation: Bool32,
}
impl ::std::default::Default for DedicatedAllocationImageCreateInfoNV {
    fn default() -> DedicatedAllocationImageCreateInfoNV {
        DedicatedAllocationImageCreateInfoNV {
            s_type: StructureType::DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV,
            p_next: ::std::ptr::null(),
            dedicated_allocation: Bool32::default(),
        }
    }
}
impl DedicatedAllocationImageCreateInfoNV {
    pub fn builder<'a>() -> DedicatedAllocationImageCreateInfoNVBuilder<'a> {
        DedicatedAllocationImageCreateInfoNVBuilder {
            inner: DedicatedAllocationImageCreateInfoNV::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct DedicatedAllocationImageCreateInfoNVBuilder<'a> {
    inner: DedicatedAllocationImageCreateInfoNV,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsImageCreateInfo for DedicatedAllocationImageCreateInfoNVBuilder<'_> {}
unsafe impl ExtendsImageCreateInfo for DedicatedAllocationImageCreateInfoNV {}
impl<'a> ::std::ops::Deref for DedicatedAllocationImageCreateInfoNVBuilder<'a> {
    type Target = DedicatedAllocationImageCreateInfoNV;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for DedicatedAllocationImageCreateInfoNVBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> DedicatedAllocationImageCreateInfoNVBuilder<'a> {
    pub fn dedicated_allocation(
        mut self,
        dedicated_allocation: bool,
    ) -> DedicatedAllocationImageCreateInfoNVBuilder<'a> {
        self.inner.dedicated_allocation = dedicated_allocation.into();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> DedicatedAllocationImageCreateInfoNV {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDedicatedAllocationBufferCreateInfoNV.html>"]
pub struct DedicatedAllocationBufferCreateInfoNV {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub dedicated_allocation: Bool32,
}
impl ::std::default::Default for DedicatedAllocationBufferCreateInfoNV {
    fn default() -> DedicatedAllocationBufferCreateInfoNV {
        DedicatedAllocationBufferCreateInfoNV {
            s_type: StructureType::DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV,
            p_next: ::std::ptr::null(),
            dedicated_allocation: Bool32::default(),
        }
    }
}
impl DedicatedAllocationBufferCreateInfoNV {
    pub fn builder<'a>() -> DedicatedAllocationBufferCreateInfoNVBuilder<'a> {
        DedicatedAllocationBufferCreateInfoNVBuilder {
            inner: DedicatedAllocationBufferCreateInfoNV::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct DedicatedAllocationBufferCreateInfoNVBuilder<'a> {
    inner: DedicatedAllocationBufferCreateInfoNV,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsBufferCreateInfo for DedicatedAllocationBufferCreateInfoNVBuilder<'_> {}
unsafe impl ExtendsBufferCreateInfo for DedicatedAllocationBufferCreateInfoNV {}
impl<'a> ::std::ops::Deref for DedicatedAllocationBufferCreateInfoNVBuilder<'a> {
    type Target = DedicatedAllocationBufferCreateInfoNV;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for DedicatedAllocationBufferCreateInfoNVBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> DedicatedAllocationBufferCreateInfoNVBuilder<'a> {
    pub fn dedicated_allocation(
        mut self,
        dedicated_allocation: bool,
    ) -> DedicatedAllocationBufferCreateInfoNVBuilder<'a> {
        self.inner.dedicated_allocation = dedicated_allocation.into();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> DedicatedAllocationBufferCreateInfoNV {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDedicatedAllocationMemoryAllocateInfoNV.html>"]
pub struct DedicatedAllocationMemoryAllocateInfoNV {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub image: Image,
    pub buffer: Buffer,
}
impl ::std::default::Default for DedicatedAllocationMemoryAllocateInfoNV {
    fn default() -> DedicatedAllocationMemoryAllocateInfoNV {
        DedicatedAllocationMemoryAllocateInfoNV {
            s_type: StructureType::DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV,
            p_next: ::std::ptr::null(),
            image: Image::default(),
            buffer: Buffer::default(),
        }
    }
}
impl DedicatedAllocationMemoryAllocateInfoNV {
    pub fn builder<'a>() -> DedicatedAllocationMemoryAllocateInfoNVBuilder<'a> {
        DedicatedAllocationMemoryAllocateInfoNVBuilder {
            inner: DedicatedAllocationMemoryAllocateInfoNV::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct DedicatedAllocationMemoryAllocateInfoNVBuilder<'a> {
    inner: DedicatedAllocationMemoryAllocateInfoNV,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsMemoryAllocateInfo for DedicatedAllocationMemoryAllocateInfoNVBuilder<'_> {}
unsafe impl ExtendsMemoryAllocateInfo for DedicatedAllocationMemoryAllocateInfoNV {}
impl<'a> ::std::ops::Deref for DedicatedAllocationMemoryAllocateInfoNVBuilder<'a> {
    type Target = DedicatedAllocationMemoryAllocateInfoNV;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for DedicatedAllocationMemoryAllocateInfoNVBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> DedicatedAllocationMemoryAllocateInfoNVBuilder<'a> {
    pub fn image(mut self, image: Image) -> DedicatedAllocationMemoryAllocateInfoNVBuilder<'a> {
        self.inner.image = image;
        self
    }
    pub fn buffer(mut self, buffer: Buffer) -> DedicatedAllocationMemoryAllocateInfoNVBuilder<'a> {
        self.inner.buffer = buffer;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> DedicatedAllocationMemoryAllocateInfoNV {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Default, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkExternalImageFormatPropertiesNV.html>"]
pub struct ExternalImageFormatPropertiesNV {
    pub image_format_properties: ImageFormatProperties,
    pub external_memory_features: ExternalMemoryFeatureFlagsNV,
    pub export_from_imported_handle_types: ExternalMemoryHandleTypeFlagsNV,
    pub compatible_handle_types: ExternalMemoryHandleTypeFlagsNV,
}
impl ExternalImageFormatPropertiesNV {
    pub fn builder<'a>() -> ExternalImageFormatPropertiesNVBuilder<'a> {
        ExternalImageFormatPropertiesNVBuilder {
            inner: ExternalImageFormatPropertiesNV::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct ExternalImageFormatPropertiesNVBuilder<'a> {
    inner: ExternalImageFormatPropertiesNV,
    marker: ::std::marker::PhantomData<&'a ()>,
}
impl<'a> ::std::ops::Deref for ExternalImageFormatPropertiesNVBuilder<'a> {
    type Target = ExternalImageFormatPropertiesNV;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for ExternalImageFormatPropertiesNVBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> ExternalImageFormatPropertiesNVBuilder<'a> {
    pub fn image_format_properties(
        mut self,
        image_format_properties: ImageFormatProperties,
    ) -> ExternalImageFormatPropertiesNVBuilder<'a> {
        self.inner.image_format_properties = image_format_properties;
        self
    }
    pub fn external_memory_features(
        mut self,
        external_memory_features: ExternalMemoryFeatureFlagsNV,
    ) -> ExternalImageFormatPropertiesNVBuilder<'a> {
        self.inner.external_memory_features = external_memory_features;
        self
    }
    pub fn export_from_imported_handle_types(
        mut self,
        export_from_imported_handle_types: ExternalMemoryHandleTypeFlagsNV,
    ) -> ExternalImageFormatPropertiesNVBuilder<'a> {
        self.inner.export_from_imported_handle_types = export_from_imported_handle_types;
        self
    }
    pub fn compatible_handle_types(
        mut self,
        compatible_handle_types: ExternalMemoryHandleTypeFlagsNV,
    ) -> ExternalImageFormatPropertiesNVBuilder<'a> {
        self.inner.compatible_handle_types = compatible_handle_types;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> ExternalImageFormatPropertiesNV {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkExternalMemoryImageCreateInfoNV.html>"]
pub struct ExternalMemoryImageCreateInfoNV {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub handle_types: ExternalMemoryHandleTypeFlagsNV,
}
impl ::std::default::Default for ExternalMemoryImageCreateInfoNV {
    fn default() -> ExternalMemoryImageCreateInfoNV {
        ExternalMemoryImageCreateInfoNV {
            s_type: StructureType::EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV,
            p_next: ::std::ptr::null(),
            handle_types: ExternalMemoryHandleTypeFlagsNV::default(),
        }
    }
}
impl ExternalMemoryImageCreateInfoNV {
    pub fn builder<'a>() -> ExternalMemoryImageCreateInfoNVBuilder<'a> {
        ExternalMemoryImageCreateInfoNVBuilder {
            inner: ExternalMemoryImageCreateInfoNV::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct ExternalMemoryImageCreateInfoNVBuilder<'a> {
    inner: ExternalMemoryImageCreateInfoNV,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsImageCreateInfo for ExternalMemoryImageCreateInfoNVBuilder<'_> {}
unsafe impl ExtendsImageCreateInfo for ExternalMemoryImageCreateInfoNV {}
impl<'a> ::std::ops::Deref for ExternalMemoryImageCreateInfoNVBuilder<'a> {
    type Target = ExternalMemoryImageCreateInfoNV;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for ExternalMemoryImageCreateInfoNVBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> ExternalMemoryImageCreateInfoNVBuilder<'a> {
    pub fn handle_types(
        mut self,
        handle_types: ExternalMemoryHandleTypeFlagsNV,
    ) -> ExternalMemoryImageCreateInfoNVBuilder<'a> {
        self.inner.handle_types = handle_types;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> ExternalMemoryImageCreateInfoNV {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkExportMemoryAllocateInfoNV.html>"]
pub struct ExportMemoryAllocateInfoNV {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub handle_types: ExternalMemoryHandleTypeFlagsNV,
}
impl ::std::default::Default for ExportMemoryAllocateInfoNV {
    fn default() -> ExportMemoryAllocateInfoNV {
        ExportMemoryAllocateInfoNV {
            s_type: StructureType::EXPORT_MEMORY_ALLOCATE_INFO_NV,
            p_next: ::std::ptr::null(),
            handle_types: ExternalMemoryHandleTypeFlagsNV::default(),
        }
    }
}
impl ExportMemoryAllocateInfoNV {
    pub fn builder<'a>() -> ExportMemoryAllocateInfoNVBuilder<'a> {
        ExportMemoryAllocateInfoNVBuilder {
            inner: ExportMemoryAllocateInfoNV::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct ExportMemoryAllocateInfoNVBuilder<'a> {
    inner: ExportMemoryAllocateInfoNV,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsMemoryAllocateInfo for ExportMemoryAllocateInfoNVBuilder<'_> {}
unsafe impl ExtendsMemoryAllocateInfo for ExportMemoryAllocateInfoNV {}
impl<'a> ::std::ops::Deref for ExportMemoryAllocateInfoNVBuilder<'a> {
    type Target = ExportMemoryAllocateInfoNV;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for ExportMemoryAllocateInfoNVBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> ExportMemoryAllocateInfoNVBuilder<'a> {
    pub fn handle_types(
        mut self,
        handle_types: ExternalMemoryHandleTypeFlagsNV,
    ) -> ExportMemoryAllocateInfoNVBuilder<'a> {
        self.inner.handle_types = handle_types;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> ExportMemoryAllocateInfoNV {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImportMemoryWin32HandleInfoNV.html>"]
pub struct ImportMemoryWin32HandleInfoNV {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub handle_type: ExternalMemoryHandleTypeFlagsNV,
    pub handle: HANDLE,
}
impl ::std::default::Default for ImportMemoryWin32HandleInfoNV {
    fn default() -> ImportMemoryWin32HandleInfoNV {
        ImportMemoryWin32HandleInfoNV {
            s_type: StructureType::IMPORT_MEMORY_WIN32_HANDLE_INFO_NV,
            p_next: ::std::ptr::null(),
            handle_type: ExternalMemoryHandleTypeFlagsNV::default(),
            handle: unsafe { ::std::mem::zeroed() },
        }
    }
}
impl ImportMemoryWin32HandleInfoNV {
    pub fn builder<'a>() -> ImportMemoryWin32HandleInfoNVBuilder<'a> {
        ImportMemoryWin32HandleInfoNVBuilder {
            inner: ImportMemoryWin32HandleInfoNV::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct ImportMemoryWin32HandleInfoNVBuilder<'a> {
    inner: ImportMemoryWin32HandleInfoNV,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryWin32HandleInfoNVBuilder<'_> {}
unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryWin32HandleInfoNV {}
impl<'a> ::std::ops::Deref for ImportMemoryWin32HandleInfoNVBuilder<'a> {
    type Target = ImportMemoryWin32HandleInfoNV;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for ImportMemoryWin32HandleInfoNVBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> ImportMemoryWin32HandleInfoNVBuilder<'a> {
    pub fn handle_type(
        mut self,
        handle_type: ExternalMemoryHandleTypeFlagsNV,
    ) -> ImportMemoryWin32HandleInfoNVBuilder<'a> {
        self.inner.handle_type = handle_type;
        self
    }
    pub fn handle(mut self, handle: HANDLE) -> ImportMemoryWin32HandleInfoNVBuilder<'a> {
        self.inner.handle = handle;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> ImportMemoryWin32HandleInfoNV {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkExportMemoryWin32HandleInfoNV.html>"]
pub struct ExportMemoryWin32HandleInfoNV {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub p_attributes: *const SECURITY_ATTRIBUTES,
    pub dw_access: DWORD,
}
impl ::std::default::Default for ExportMemoryWin32HandleInfoNV {
    fn default() -> ExportMemoryWin32HandleInfoNV {
        ExportMemoryWin32HandleInfoNV {
            s_type: StructureType::EXPORT_MEMORY_WIN32_HANDLE_INFO_NV,
            p_next: ::std::ptr::null(),
            p_attributes: ::std::ptr::null(),
            dw_access: DWORD::default(),
        }
    }
}
impl ExportMemoryWin32HandleInfoNV {
    pub fn builder<'a>() -> ExportMemoryWin32HandleInfoNVBuilder<'a> {
        ExportMemoryWin32HandleInfoNVBuilder {
            inner: ExportMemoryWin32HandleInfoNV::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct ExportMemoryWin32HandleInfoNVBuilder<'a> {
    inner: ExportMemoryWin32HandleInfoNV,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsMemoryAllocateInfo for ExportMemoryWin32HandleInfoNVBuilder<'_> {}
unsafe impl ExtendsMemoryAllocateInfo for ExportMemoryWin32HandleInfoNV {}
impl<'a> ::std::ops::Deref for ExportMemoryWin32HandleInfoNVBuilder<'a> {
    type Target = ExportMemoryWin32HandleInfoNV;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for ExportMemoryWin32HandleInfoNVBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> ExportMemoryWin32HandleInfoNVBuilder<'a> {
    pub fn attributes(
        mut self,
        attributes: &'a SECURITY_ATTRIBUTES,
    ) -> ExportMemoryWin32HandleInfoNVBuilder<'a> {
        self.inner.p_attributes = attributes;
        self
    }
    pub fn dw_access(mut self, dw_access: DWORD) -> ExportMemoryWin32HandleInfoNVBuilder<'a> {
        self.inner.dw_access = dw_access;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> ExportMemoryWin32HandleInfoNV {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkWin32KeyedMutexAcquireReleaseInfoNV.html>"]
pub struct Win32KeyedMutexAcquireReleaseInfoNV {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub acquire_count: u32,
    pub p_acquire_syncs: *const DeviceMemory,
    pub p_acquire_keys: *const u64,
    pub p_acquire_timeout_milliseconds: *const u32,
    pub release_count: u32,
    pub p_release_syncs: *const DeviceMemory,
    pub p_release_keys: *const u64,
}
impl ::std::default::Default for Win32KeyedMutexAcquireReleaseInfoNV {
    fn default() -> Win32KeyedMutexAcquireReleaseInfoNV {
        Win32KeyedMutexAcquireReleaseInfoNV {
            s_type: StructureType::WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV,
            p_next: ::std::ptr::null(),
            acquire_count: u32::default(),
            p_acquire_syncs: ::std::ptr::null(),
            p_acquire_keys: ::std::ptr::null(),
            p_acquire_timeout_milliseconds: ::std::ptr::null(),
            release_count: u32::default(),
            p_release_syncs: ::std::ptr::null(),
            p_release_keys: ::std::ptr::null(),
        }
    }
}
impl Win32KeyedMutexAcquireReleaseInfoNV {
    pub fn builder<'a>() -> Win32KeyedMutexAcquireReleaseInfoNVBuilder<'a> {
        Win32KeyedMutexAcquireReleaseInfoNVBuilder {
            inner: Win32KeyedMutexAcquireReleaseInfoNV::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct Win32KeyedMutexAcquireReleaseInfoNVBuilder<'a> {
    inner: Win32KeyedMutexAcquireReleaseInfoNV,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsSubmitInfo for Win32KeyedMutexAcquireReleaseInfoNVBuilder<'_> {}
unsafe impl ExtendsSubmitInfo for Win32KeyedMutexAcquireReleaseInfoNV {}
impl<'a> ::std::ops::Deref for Win32KeyedMutexAcquireReleaseInfoNVBuilder<'a> {
    type Target = Win32KeyedMutexAcquireReleaseInfoNV;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for Win32KeyedMutexAcquireReleaseInfoNVBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> Win32KeyedMutexAcquireReleaseInfoNVBuilder<'a> {
    pub fn acquire_syncs(
        mut self,
        acquire_syncs: &'a [DeviceMemory],
    ) -> Win32KeyedMutexAcquireReleaseInfoNVBuilder<'a> {
        self.inner.acquire_count = acquire_syncs.len() as _;
        self.inner.p_acquire_syncs = acquire_syncs.as_ptr();
        self
    }
    pub fn acquire_keys(
        mut self,
        acquire_keys: &'a [u64],
    ) -> Win32KeyedMutexAcquireReleaseInfoNVBuilder<'a> {
        self.inner.acquire_count = acquire_keys.len() as _;
        self.inner.p_acquire_keys = acquire_keys.as_ptr();
        self
    }
    pub fn acquire_timeout_milliseconds(
        mut self,
        acquire_timeout_milliseconds: &'a [u32],
    ) -> Win32KeyedMutexAcquireReleaseInfoNVBuilder<'a> {
        self.inner.acquire_count = acquire_timeout_milliseconds.len() as _;
        self.inner.p_acquire_timeout_milliseconds = acquire_timeout_milliseconds.as_ptr();
        self
    }
    pub fn release_syncs(
        mut self,
        release_syncs: &'a [DeviceMemory],
    ) -> Win32KeyedMutexAcquireReleaseInfoNVBuilder<'a> {
        self.inner.release_count = release_syncs.len() as _;
        self.inner.p_release_syncs = release_syncs.as_ptr();
        self
    }
    pub fn release_keys(
        mut self,
        release_keys: &'a [u64],
    ) -> Win32KeyedMutexAcquireReleaseInfoNVBuilder<'a> {
        self.inner.release_count = release_keys.len() as _;
        self.inner.p_release_keys = release_keys.as_ptr();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> Win32KeyedMutexAcquireReleaseInfoNV {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV.html>"]
pub struct PhysicalDeviceDeviceGeneratedCommandsFeaturesNV {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub device_generated_commands: Bool32,
}
impl ::std::default::Default for PhysicalDeviceDeviceGeneratedCommandsFeaturesNV {
    fn default() -> PhysicalDeviceDeviceGeneratedCommandsFeaturesNV {
        PhysicalDeviceDeviceGeneratedCommandsFeaturesNV {
            s_type: StructureType::PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV,
            p_next: ::std::ptr::null_mut(),
            device_generated_commands: Bool32::default(),
        }
    }
}
impl PhysicalDeviceDeviceGeneratedCommandsFeaturesNV {
    pub fn builder<'a>() -> PhysicalDeviceDeviceGeneratedCommandsFeaturesNVBuilder<'a> {
        PhysicalDeviceDeviceGeneratedCommandsFeaturesNVBuilder {
            inner: PhysicalDeviceDeviceGeneratedCommandsFeaturesNV::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDeviceDeviceGeneratedCommandsFeaturesNVBuilder<'a> {
    inner: PhysicalDeviceDeviceGeneratedCommandsFeaturesNV,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDeviceGeneratedCommandsFeaturesNVBuilder<'_> {}
unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDeviceGeneratedCommandsFeaturesNV {}
impl<'a> ::std::ops::Deref for PhysicalDeviceDeviceGeneratedCommandsFeaturesNVBuilder<'a> {
    type Target = PhysicalDeviceDeviceGeneratedCommandsFeaturesNV;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PhysicalDeviceDeviceGeneratedCommandsFeaturesNVBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDeviceDeviceGeneratedCommandsFeaturesNVBuilder<'a> {
    pub fn device_generated_commands(
        mut self,
        device_generated_commands: bool,
    ) -> PhysicalDeviceDeviceGeneratedCommandsFeaturesNVBuilder<'a> {
        self.inner.device_generated_commands = device_generated_commands.into();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDeviceDeviceGeneratedCommandsFeaturesNV {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV.html>"]
pub struct PhysicalDeviceDeviceGeneratedCommandsPropertiesNV {
    pub s_type: StructureType,
    pub p_next: *const 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 ::std::default::Default for PhysicalDeviceDeviceGeneratedCommandsPropertiesNV {
    fn default() -> PhysicalDeviceDeviceGeneratedCommandsPropertiesNV {
        PhysicalDeviceDeviceGeneratedCommandsPropertiesNV {
            s_type: StructureType::PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV,
            p_next: ::std::ptr::null(),
            max_graphics_shader_group_count: u32::default(),
            max_indirect_sequence_count: u32::default(),
            max_indirect_commands_token_count: u32::default(),
            max_indirect_commands_stream_count: u32::default(),
            max_indirect_commands_token_offset: u32::default(),
            max_indirect_commands_stream_stride: u32::default(),
            min_sequences_count_buffer_offset_alignment: u32::default(),
            min_sequences_index_buffer_offset_alignment: u32::default(),
            min_indirect_commands_buffer_offset_alignment: u32::default(),
        }
    }
}
impl PhysicalDeviceDeviceGeneratedCommandsPropertiesNV {
    pub fn builder<'a>() -> PhysicalDeviceDeviceGeneratedCommandsPropertiesNVBuilder<'a> {
        PhysicalDeviceDeviceGeneratedCommandsPropertiesNVBuilder {
            inner: PhysicalDeviceDeviceGeneratedCommandsPropertiesNV::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDeviceDeviceGeneratedCommandsPropertiesNVBuilder<'a> {
    inner: PhysicalDeviceDeviceGeneratedCommandsPropertiesNV,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsPhysicalDeviceProperties2
    for PhysicalDeviceDeviceGeneratedCommandsPropertiesNVBuilder<'_>
{
}
unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceDeviceGeneratedCommandsPropertiesNV {}
impl<'a> ::std::ops::Deref for PhysicalDeviceDeviceGeneratedCommandsPropertiesNVBuilder<'a> {
    type Target = PhysicalDeviceDeviceGeneratedCommandsPropertiesNV;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PhysicalDeviceDeviceGeneratedCommandsPropertiesNVBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDeviceDeviceGeneratedCommandsPropertiesNVBuilder<'a> {
    pub fn max_graphics_shader_group_count(
        mut self,
        max_graphics_shader_group_count: u32,
    ) -> PhysicalDeviceDeviceGeneratedCommandsPropertiesNVBuilder<'a> {
        self.inner.max_graphics_shader_group_count = max_graphics_shader_group_count;
        self
    }
    pub fn max_indirect_sequence_count(
        mut self,
        max_indirect_sequence_count: u32,
    ) -> PhysicalDeviceDeviceGeneratedCommandsPropertiesNVBuilder<'a> {
        self.inner.max_indirect_sequence_count = max_indirect_sequence_count;
        self
    }
    pub fn max_indirect_commands_token_count(
        mut self,
        max_indirect_commands_token_count: u32,
    ) -> PhysicalDeviceDeviceGeneratedCommandsPropertiesNVBuilder<'a> {
        self.inner.max_indirect_commands_token_count = max_indirect_commands_token_count;
        self
    }
    pub fn max_indirect_commands_stream_count(
        mut self,
        max_indirect_commands_stream_count: u32,
    ) -> PhysicalDeviceDeviceGeneratedCommandsPropertiesNVBuilder<'a> {
        self.inner.max_indirect_commands_stream_count = max_indirect_commands_stream_count;
        self
    }
    pub fn max_indirect_commands_token_offset(
        mut self,
        max_indirect_commands_token_offset: u32,
    ) -> PhysicalDeviceDeviceGeneratedCommandsPropertiesNVBuilder<'a> {
        self.inner.max_indirect_commands_token_offset = max_indirect_commands_token_offset;
        self
    }
    pub fn max_indirect_commands_stream_stride(
        mut self,
        max_indirect_commands_stream_stride: u32,
    ) -> PhysicalDeviceDeviceGeneratedCommandsPropertiesNVBuilder<'a> {
        self.inner.max_indirect_commands_stream_stride = max_indirect_commands_stream_stride;
        self
    }
    pub fn min_sequences_count_buffer_offset_alignment(
        mut self,
        min_sequences_count_buffer_offset_alignment: u32,
    ) -> PhysicalDeviceDeviceGeneratedCommandsPropertiesNVBuilder<'a> {
        self.inner.min_sequences_count_buffer_offset_alignment =
            min_sequences_count_buffer_offset_alignment;
        self
    }
    pub fn min_sequences_index_buffer_offset_alignment(
        mut self,
        min_sequences_index_buffer_offset_alignment: u32,
    ) -> PhysicalDeviceDeviceGeneratedCommandsPropertiesNVBuilder<'a> {
        self.inner.min_sequences_index_buffer_offset_alignment =
            min_sequences_index_buffer_offset_alignment;
        self
    }
    pub fn min_indirect_commands_buffer_offset_alignment(
        mut self,
        min_indirect_commands_buffer_offset_alignment: u32,
    ) -> PhysicalDeviceDeviceGeneratedCommandsPropertiesNVBuilder<'a> {
        self.inner.min_indirect_commands_buffer_offset_alignment =
            min_indirect_commands_buffer_offset_alignment;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDeviceDeviceGeneratedCommandsPropertiesNV {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkGraphicsShaderGroupCreateInfoNV.html>"]
pub struct GraphicsShaderGroupCreateInfoNV {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub stage_count: u32,
    pub p_stages: *const PipelineShaderStageCreateInfo,
    pub p_vertex_input_state: *const PipelineVertexInputStateCreateInfo,
    pub p_tessellation_state: *const PipelineTessellationStateCreateInfo,
}
impl ::std::default::Default for GraphicsShaderGroupCreateInfoNV {
    fn default() -> GraphicsShaderGroupCreateInfoNV {
        GraphicsShaderGroupCreateInfoNV {
            s_type: StructureType::GRAPHICS_SHADER_GROUP_CREATE_INFO_NV,
            p_next: ::std::ptr::null(),
            stage_count: u32::default(),
            p_stages: ::std::ptr::null(),
            p_vertex_input_state: ::std::ptr::null(),
            p_tessellation_state: ::std::ptr::null(),
        }
    }
}
impl GraphicsShaderGroupCreateInfoNV {
    pub fn builder<'a>() -> GraphicsShaderGroupCreateInfoNVBuilder<'a> {
        GraphicsShaderGroupCreateInfoNVBuilder {
            inner: GraphicsShaderGroupCreateInfoNV::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct GraphicsShaderGroupCreateInfoNVBuilder<'a> {
    inner: GraphicsShaderGroupCreateInfoNV,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsGraphicsShaderGroupCreateInfoNV {}
impl<'a> ::std::ops::Deref for GraphicsShaderGroupCreateInfoNVBuilder<'a> {
    type Target = GraphicsShaderGroupCreateInfoNV;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for GraphicsShaderGroupCreateInfoNVBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> GraphicsShaderGroupCreateInfoNVBuilder<'a> {
    pub fn stages(
        mut self,
        stages: &'a [PipelineShaderStageCreateInfo],
    ) -> GraphicsShaderGroupCreateInfoNVBuilder<'a> {
        self.inner.stage_count = stages.len() as _;
        self.inner.p_stages = stages.as_ptr();
        self
    }
    pub fn vertex_input_state(
        mut self,
        vertex_input_state: &'a PipelineVertexInputStateCreateInfo,
    ) -> GraphicsShaderGroupCreateInfoNVBuilder<'a> {
        self.inner.p_vertex_input_state = vertex_input_state;
        self
    }
    pub fn tessellation_state(
        mut self,
        tessellation_state: &'a PipelineTessellationStateCreateInfo,
    ) -> GraphicsShaderGroupCreateInfoNVBuilder<'a> {
        self.inner.p_tessellation_state = tessellation_state;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsGraphicsShaderGroupCreateInfoNV>(
        mut self,
        next: &'a mut T,
    ) -> GraphicsShaderGroupCreateInfoNVBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> GraphicsShaderGroupCreateInfoNV {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkGraphicsPipelineShaderGroupsCreateInfoNV.html>"]
pub struct GraphicsPipelineShaderGroupsCreateInfoNV {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub group_count: u32,
    pub p_groups: *const GraphicsShaderGroupCreateInfoNV,
    pub pipeline_count: u32,
    pub p_pipelines: *const Pipeline,
}
impl ::std::default::Default for GraphicsPipelineShaderGroupsCreateInfoNV {
    fn default() -> GraphicsPipelineShaderGroupsCreateInfoNV {
        GraphicsPipelineShaderGroupsCreateInfoNV {
            s_type: StructureType::GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV,
            p_next: ::std::ptr::null(),
            group_count: u32::default(),
            p_groups: ::std::ptr::null(),
            pipeline_count: u32::default(),
            p_pipelines: ::std::ptr::null(),
        }
    }
}
impl GraphicsPipelineShaderGroupsCreateInfoNV {
    pub fn builder<'a>() -> GraphicsPipelineShaderGroupsCreateInfoNVBuilder<'a> {
        GraphicsPipelineShaderGroupsCreateInfoNVBuilder {
            inner: GraphicsPipelineShaderGroupsCreateInfoNV::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct GraphicsPipelineShaderGroupsCreateInfoNVBuilder<'a> {
    inner: GraphicsPipelineShaderGroupsCreateInfoNV,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsGraphicsPipelineCreateInfo
    for GraphicsPipelineShaderGroupsCreateInfoNVBuilder<'_>
{
}
unsafe impl ExtendsGraphicsPipelineCreateInfo for GraphicsPipelineShaderGroupsCreateInfoNV {}
impl<'a> ::std::ops::Deref for GraphicsPipelineShaderGroupsCreateInfoNVBuilder<'a> {
    type Target = GraphicsPipelineShaderGroupsCreateInfoNV;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for GraphicsPipelineShaderGroupsCreateInfoNVBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> GraphicsPipelineShaderGroupsCreateInfoNVBuilder<'a> {
    pub fn groups(
        mut self,
        groups: &'a [GraphicsShaderGroupCreateInfoNV],
    ) -> GraphicsPipelineShaderGroupsCreateInfoNVBuilder<'a> {
        self.inner.group_count = groups.len() as _;
        self.inner.p_groups = groups.as_ptr();
        self
    }
    pub fn pipelines(
        mut self,
        pipelines: &'a [Pipeline],
    ) -> GraphicsPipelineShaderGroupsCreateInfoNVBuilder<'a> {
        self.inner.pipeline_count = pipelines.len() as _;
        self.inner.p_pipelines = pipelines.as_ptr();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> GraphicsPipelineShaderGroupsCreateInfoNV {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Default, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkBindShaderGroupIndirectCommandNV.html>"]
pub struct BindShaderGroupIndirectCommandNV {
    pub group_index: u32,
}
impl BindShaderGroupIndirectCommandNV {
    pub fn builder<'a>() -> BindShaderGroupIndirectCommandNVBuilder<'a> {
        BindShaderGroupIndirectCommandNVBuilder {
            inner: BindShaderGroupIndirectCommandNV::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct BindShaderGroupIndirectCommandNVBuilder<'a> {
    inner: BindShaderGroupIndirectCommandNV,
    marker: ::std::marker::PhantomData<&'a ()>,
}
impl<'a> ::std::ops::Deref for BindShaderGroupIndirectCommandNVBuilder<'a> {
    type Target = BindShaderGroupIndirectCommandNV;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for BindShaderGroupIndirectCommandNVBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> BindShaderGroupIndirectCommandNVBuilder<'a> {
    pub fn group_index(mut self, group_index: u32) -> BindShaderGroupIndirectCommandNVBuilder<'a> {
        self.inner.group_index = group_index;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> BindShaderGroupIndirectCommandNV {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Default, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkBindIndexBufferIndirectCommandNV.html>"]
pub struct BindIndexBufferIndirectCommandNV {
    pub buffer_address: DeviceAddress,
    pub size: u32,
    pub index_type: IndexType,
}
impl BindIndexBufferIndirectCommandNV {
    pub fn builder<'a>() -> BindIndexBufferIndirectCommandNVBuilder<'a> {
        BindIndexBufferIndirectCommandNVBuilder {
            inner: BindIndexBufferIndirectCommandNV::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct BindIndexBufferIndirectCommandNVBuilder<'a> {
    inner: BindIndexBufferIndirectCommandNV,
    marker: ::std::marker::PhantomData<&'a ()>,
}
impl<'a> ::std::ops::Deref for BindIndexBufferIndirectCommandNVBuilder<'a> {
    type Target = BindIndexBufferIndirectCommandNV;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for BindIndexBufferIndirectCommandNVBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> BindIndexBufferIndirectCommandNVBuilder<'a> {
    pub fn buffer_address(
        mut self,
        buffer_address: DeviceAddress,
    ) -> BindIndexBufferIndirectCommandNVBuilder<'a> {
        self.inner.buffer_address = buffer_address;
        self
    }
    pub fn size(mut self, size: u32) -> BindIndexBufferIndirectCommandNVBuilder<'a> {
        self.inner.size = size;
        self
    }
    pub fn index_type(
        mut self,
        index_type: IndexType,
    ) -> BindIndexBufferIndirectCommandNVBuilder<'a> {
        self.inner.index_type = index_type;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> BindIndexBufferIndirectCommandNV {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Default, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkBindVertexBufferIndirectCommandNV.html>"]
pub struct BindVertexBufferIndirectCommandNV {
    pub buffer_address: DeviceAddress,
    pub size: u32,
    pub stride: u32,
}
impl BindVertexBufferIndirectCommandNV {
    pub fn builder<'a>() -> BindVertexBufferIndirectCommandNVBuilder<'a> {
        BindVertexBufferIndirectCommandNVBuilder {
            inner: BindVertexBufferIndirectCommandNV::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct BindVertexBufferIndirectCommandNVBuilder<'a> {
    inner: BindVertexBufferIndirectCommandNV,
    marker: ::std::marker::PhantomData<&'a ()>,
}
impl<'a> ::std::ops::Deref for BindVertexBufferIndirectCommandNVBuilder<'a> {
    type Target = BindVertexBufferIndirectCommandNV;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for BindVertexBufferIndirectCommandNVBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> BindVertexBufferIndirectCommandNVBuilder<'a> {
    pub fn buffer_address(
        mut self,
        buffer_address: DeviceAddress,
    ) -> BindVertexBufferIndirectCommandNVBuilder<'a> {
        self.inner.buffer_address = buffer_address;
        self
    }
    pub fn size(mut self, size: u32) -> BindVertexBufferIndirectCommandNVBuilder<'a> {
        self.inner.size = size;
        self
    }
    pub fn stride(mut self, stride: u32) -> BindVertexBufferIndirectCommandNVBuilder<'a> {
        self.inner.stride = stride;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> BindVertexBufferIndirectCommandNV {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Default, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSetStateFlagsIndirectCommandNV.html>"]
pub struct SetStateFlagsIndirectCommandNV {
    pub data: u32,
}
impl SetStateFlagsIndirectCommandNV {
    pub fn builder<'a>() -> SetStateFlagsIndirectCommandNVBuilder<'a> {
        SetStateFlagsIndirectCommandNVBuilder {
            inner: SetStateFlagsIndirectCommandNV::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct SetStateFlagsIndirectCommandNVBuilder<'a> {
    inner: SetStateFlagsIndirectCommandNV,
    marker: ::std::marker::PhantomData<&'a ()>,
}
impl<'a> ::std::ops::Deref for SetStateFlagsIndirectCommandNVBuilder<'a> {
    type Target = SetStateFlagsIndirectCommandNV;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for SetStateFlagsIndirectCommandNVBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> SetStateFlagsIndirectCommandNVBuilder<'a> {
    pub fn data(mut self, data: u32) -> SetStateFlagsIndirectCommandNVBuilder<'a> {
        self.inner.data = data;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> SetStateFlagsIndirectCommandNV {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Default, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkIndirectCommandsStreamNV.html>"]
pub struct IndirectCommandsStreamNV {
    pub buffer: Buffer,
    pub offset: DeviceSize,
}
impl IndirectCommandsStreamNV {
    pub fn builder<'a>() -> IndirectCommandsStreamNVBuilder<'a> {
        IndirectCommandsStreamNVBuilder {
            inner: IndirectCommandsStreamNV::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct IndirectCommandsStreamNVBuilder<'a> {
    inner: IndirectCommandsStreamNV,
    marker: ::std::marker::PhantomData<&'a ()>,
}
impl<'a> ::std::ops::Deref for IndirectCommandsStreamNVBuilder<'a> {
    type Target = IndirectCommandsStreamNV;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for IndirectCommandsStreamNVBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> IndirectCommandsStreamNVBuilder<'a> {
    pub fn buffer(mut self, buffer: Buffer) -> IndirectCommandsStreamNVBuilder<'a> {
        self.inner.buffer = buffer;
        self
    }
    pub fn offset(mut self, offset: DeviceSize) -> IndirectCommandsStreamNVBuilder<'a> {
        self.inner.offset = offset;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> IndirectCommandsStreamNV {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkIndirectCommandsLayoutTokenNV.html>"]
pub struct IndirectCommandsLayoutTokenNV {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub token_type: IndirectCommandsTokenTypeNV,
    pub stream: u32,
    pub offset: u32,
    pub vertex_binding_unit: u32,
    pub vertex_dynamic_stride: Bool32,
    pub pushconstant_pipeline_layout: PipelineLayout,
    pub pushconstant_shader_stage_flags: ShaderStageFlags,
    pub pushconstant_offset: u32,
    pub pushconstant_size: u32,
    pub indirect_state_flags: IndirectStateFlagsNV,
    pub index_type_count: u32,
    pub p_index_types: *const IndexType,
    pub p_index_type_values: *const u32,
}
impl ::std::default::Default for IndirectCommandsLayoutTokenNV {
    fn default() -> IndirectCommandsLayoutTokenNV {
        IndirectCommandsLayoutTokenNV {
            s_type: StructureType::INDIRECT_COMMANDS_LAYOUT_TOKEN_NV,
            p_next: ::std::ptr::null(),
            token_type: IndirectCommandsTokenTypeNV::default(),
            stream: u32::default(),
            offset: u32::default(),
            vertex_binding_unit: u32::default(),
            vertex_dynamic_stride: Bool32::default(),
            pushconstant_pipeline_layout: PipelineLayout::default(),
            pushconstant_shader_stage_flags: ShaderStageFlags::default(),
            pushconstant_offset: u32::default(),
            pushconstant_size: u32::default(),
            indirect_state_flags: IndirectStateFlagsNV::default(),
            index_type_count: u32::default(),
            p_index_types: ::std::ptr::null(),
            p_index_type_values: ::std::ptr::null(),
        }
    }
}
impl IndirectCommandsLayoutTokenNV {
    pub fn builder<'a>() -> IndirectCommandsLayoutTokenNVBuilder<'a> {
        IndirectCommandsLayoutTokenNVBuilder {
            inner: IndirectCommandsLayoutTokenNV::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct IndirectCommandsLayoutTokenNVBuilder<'a> {
    inner: IndirectCommandsLayoutTokenNV,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsIndirectCommandsLayoutTokenNV {}
impl<'a> ::std::ops::Deref for IndirectCommandsLayoutTokenNVBuilder<'a> {
    type Target = IndirectCommandsLayoutTokenNV;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for IndirectCommandsLayoutTokenNVBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> IndirectCommandsLayoutTokenNVBuilder<'a> {
    pub fn token_type(
        mut self,
        token_type: IndirectCommandsTokenTypeNV,
    ) -> IndirectCommandsLayoutTokenNVBuilder<'a> {
        self.inner.token_type = token_type;
        self
    }
    pub fn stream(mut self, stream: u32) -> IndirectCommandsLayoutTokenNVBuilder<'a> {
        self.inner.stream = stream;
        self
    }
    pub fn offset(mut self, offset: u32) -> IndirectCommandsLayoutTokenNVBuilder<'a> {
        self.inner.offset = offset;
        self
    }
    pub fn vertex_binding_unit(
        mut self,
        vertex_binding_unit: u32,
    ) -> IndirectCommandsLayoutTokenNVBuilder<'a> {
        self.inner.vertex_binding_unit = vertex_binding_unit;
        self
    }
    pub fn vertex_dynamic_stride(
        mut self,
        vertex_dynamic_stride: bool,
    ) -> IndirectCommandsLayoutTokenNVBuilder<'a> {
        self.inner.vertex_dynamic_stride = vertex_dynamic_stride.into();
        self
    }
    pub fn pushconstant_pipeline_layout(
        mut self,
        pushconstant_pipeline_layout: PipelineLayout,
    ) -> IndirectCommandsLayoutTokenNVBuilder<'a> {
        self.inner.pushconstant_pipeline_layout = pushconstant_pipeline_layout;
        self
    }
    pub fn pushconstant_shader_stage_flags(
        mut self,
        pushconstant_shader_stage_flags: ShaderStageFlags,
    ) -> IndirectCommandsLayoutTokenNVBuilder<'a> {
        self.inner.pushconstant_shader_stage_flags = pushconstant_shader_stage_flags;
        self
    }
    pub fn pushconstant_offset(
        mut self,
        pushconstant_offset: u32,
    ) -> IndirectCommandsLayoutTokenNVBuilder<'a> {
        self.inner.pushconstant_offset = pushconstant_offset;
        self
    }
    pub fn pushconstant_size(
        mut self,
        pushconstant_size: u32,
    ) -> IndirectCommandsLayoutTokenNVBuilder<'a> {
        self.inner.pushconstant_size = pushconstant_size;
        self
    }
    pub fn indirect_state_flags(
        mut self,
        indirect_state_flags: IndirectStateFlagsNV,
    ) -> IndirectCommandsLayoutTokenNVBuilder<'a> {
        self.inner.indirect_state_flags = indirect_state_flags;
        self
    }
    pub fn index_types(
        mut self,
        index_types: &'a [IndexType],
    ) -> IndirectCommandsLayoutTokenNVBuilder<'a> {
        self.inner.index_type_count = index_types.len() as _;
        self.inner.p_index_types = index_types.as_ptr();
        self
    }
    pub fn index_type_values(
        mut self,
        index_type_values: &'a [u32],
    ) -> IndirectCommandsLayoutTokenNVBuilder<'a> {
        self.inner.index_type_count = index_type_values.len() as _;
        self.inner.p_index_type_values = index_type_values.as_ptr();
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsIndirectCommandsLayoutTokenNV>(
        mut self,
        next: &'a mut T,
    ) -> IndirectCommandsLayoutTokenNVBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> IndirectCommandsLayoutTokenNV {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkIndirectCommandsLayoutCreateInfoNV.html>"]
pub struct IndirectCommandsLayoutCreateInfoNV {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub flags: IndirectCommandsLayoutUsageFlagsNV,
    pub pipeline_bind_point: PipelineBindPoint,
    pub token_count: u32,
    pub p_tokens: *const IndirectCommandsLayoutTokenNV,
    pub stream_count: u32,
    pub p_stream_strides: *const u32,
}
impl ::std::default::Default for IndirectCommandsLayoutCreateInfoNV {
    fn default() -> IndirectCommandsLayoutCreateInfoNV {
        IndirectCommandsLayoutCreateInfoNV {
            s_type: StructureType::INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NV,
            p_next: ::std::ptr::null(),
            flags: IndirectCommandsLayoutUsageFlagsNV::default(),
            pipeline_bind_point: PipelineBindPoint::default(),
            token_count: u32::default(),
            p_tokens: ::std::ptr::null(),
            stream_count: u32::default(),
            p_stream_strides: ::std::ptr::null(),
        }
    }
}
impl IndirectCommandsLayoutCreateInfoNV {
    pub fn builder<'a>() -> IndirectCommandsLayoutCreateInfoNVBuilder<'a> {
        IndirectCommandsLayoutCreateInfoNVBuilder {
            inner: IndirectCommandsLayoutCreateInfoNV::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct IndirectCommandsLayoutCreateInfoNVBuilder<'a> {
    inner: IndirectCommandsLayoutCreateInfoNV,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsIndirectCommandsLayoutCreateInfoNV {}
impl<'a> ::std::ops::Deref for IndirectCommandsLayoutCreateInfoNVBuilder<'a> {
    type Target = IndirectCommandsLayoutCreateInfoNV;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for IndirectCommandsLayoutCreateInfoNVBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> IndirectCommandsLayoutCreateInfoNVBuilder<'a> {
    pub fn flags(
        mut self,
        flags: IndirectCommandsLayoutUsageFlagsNV,
    ) -> IndirectCommandsLayoutCreateInfoNVBuilder<'a> {
        self.inner.flags = flags;
        self
    }
    pub fn pipeline_bind_point(
        mut self,
        pipeline_bind_point: PipelineBindPoint,
    ) -> IndirectCommandsLayoutCreateInfoNVBuilder<'a> {
        self.inner.pipeline_bind_point = pipeline_bind_point;
        self
    }
    pub fn tokens(
        mut self,
        tokens: &'a [IndirectCommandsLayoutTokenNV],
    ) -> IndirectCommandsLayoutCreateInfoNVBuilder<'a> {
        self.inner.token_count = tokens.len() as _;
        self.inner.p_tokens = tokens.as_ptr();
        self
    }
    pub fn stream_strides(
        mut self,
        stream_strides: &'a [u32],
    ) -> IndirectCommandsLayoutCreateInfoNVBuilder<'a> {
        self.inner.stream_count = stream_strides.len() as _;
        self.inner.p_stream_strides = stream_strides.as_ptr();
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsIndirectCommandsLayoutCreateInfoNV>(
        mut self,
        next: &'a mut T,
    ) -> IndirectCommandsLayoutCreateInfoNVBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> IndirectCommandsLayoutCreateInfoNV {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkGeneratedCommandsInfoNV.html>"]
pub struct GeneratedCommandsInfoNV {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub pipeline_bind_point: PipelineBindPoint,
    pub pipeline: Pipeline,
    pub indirect_commands_layout: IndirectCommandsLayoutNV,
    pub stream_count: u32,
    pub p_streams: *const IndirectCommandsStreamNV,
    pub sequences_count: u32,
    pub preprocess_buffer: Buffer,
    pub preprocess_offset: DeviceSize,
    pub preprocess_size: DeviceSize,
    pub sequences_count_buffer: Buffer,
    pub sequences_count_offset: DeviceSize,
    pub sequences_index_buffer: Buffer,
    pub sequences_index_offset: DeviceSize,
}
impl ::std::default::Default for GeneratedCommandsInfoNV {
    fn default() -> GeneratedCommandsInfoNV {
        GeneratedCommandsInfoNV {
            s_type: StructureType::GENERATED_COMMANDS_INFO_NV,
            p_next: ::std::ptr::null(),
            pipeline_bind_point: PipelineBindPoint::default(),
            pipeline: Pipeline::default(),
            indirect_commands_layout: IndirectCommandsLayoutNV::default(),
            stream_count: u32::default(),
            p_streams: ::std::ptr::null(),
            sequences_count: u32::default(),
            preprocess_buffer: Buffer::default(),
            preprocess_offset: DeviceSize::default(),
            preprocess_size: DeviceSize::default(),
            sequences_count_buffer: Buffer::default(),
            sequences_count_offset: DeviceSize::default(),
            sequences_index_buffer: Buffer::default(),
            sequences_index_offset: DeviceSize::default(),
        }
    }
}
impl GeneratedCommandsInfoNV {
    pub fn builder<'a>() -> GeneratedCommandsInfoNVBuilder<'a> {
        GeneratedCommandsInfoNVBuilder {
            inner: GeneratedCommandsInfoNV::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct GeneratedCommandsInfoNVBuilder<'a> {
    inner: GeneratedCommandsInfoNV,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsGeneratedCommandsInfoNV {}
impl<'a> ::std::ops::Deref for GeneratedCommandsInfoNVBuilder<'a> {
    type Target = GeneratedCommandsInfoNV;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for GeneratedCommandsInfoNVBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> GeneratedCommandsInfoNVBuilder<'a> {
    pub fn pipeline_bind_point(
        mut self,
        pipeline_bind_point: PipelineBindPoint,
    ) -> GeneratedCommandsInfoNVBuilder<'a> {
        self.inner.pipeline_bind_point = pipeline_bind_point;
        self
    }
    pub fn pipeline(mut self, pipeline: Pipeline) -> GeneratedCommandsInfoNVBuilder<'a> {
        self.inner.pipeline = pipeline;
        self
    }
    pub fn indirect_commands_layout(
        mut self,
        indirect_commands_layout: IndirectCommandsLayoutNV,
    ) -> GeneratedCommandsInfoNVBuilder<'a> {
        self.inner.indirect_commands_layout = indirect_commands_layout;
        self
    }
    pub fn streams(
        mut self,
        streams: &'a [IndirectCommandsStreamNV],
    ) -> GeneratedCommandsInfoNVBuilder<'a> {
        self.inner.stream_count = streams.len() as _;
        self.inner.p_streams = streams.as_ptr();
        self
    }
    pub fn sequences_count(mut self, sequences_count: u32) -> GeneratedCommandsInfoNVBuilder<'a> {
        self.inner.sequences_count = sequences_count;
        self
    }
    pub fn preprocess_buffer(
        mut self,
        preprocess_buffer: Buffer,
    ) -> GeneratedCommandsInfoNVBuilder<'a> {
        self.inner.preprocess_buffer = preprocess_buffer;
        self
    }
    pub fn preprocess_offset(
        mut self,
        preprocess_offset: DeviceSize,
    ) -> GeneratedCommandsInfoNVBuilder<'a> {
        self.inner.preprocess_offset = preprocess_offset;
        self
    }
    pub fn preprocess_size(
        mut self,
        preprocess_size: DeviceSize,
    ) -> GeneratedCommandsInfoNVBuilder<'a> {
        self.inner.preprocess_size = preprocess_size;
        self
    }
    pub fn sequences_count_buffer(
        mut self,
        sequences_count_buffer: Buffer,
    ) -> GeneratedCommandsInfoNVBuilder<'a> {
        self.inner.sequences_count_buffer = sequences_count_buffer;
        self
    }
    pub fn sequences_count_offset(
        mut self,
        sequences_count_offset: DeviceSize,
    ) -> GeneratedCommandsInfoNVBuilder<'a> {
        self.inner.sequences_count_offset = sequences_count_offset;
        self
    }
    pub fn sequences_index_buffer(
        mut self,
        sequences_index_buffer: Buffer,
    ) -> GeneratedCommandsInfoNVBuilder<'a> {
        self.inner.sequences_index_buffer = sequences_index_buffer;
        self
    }
    pub fn sequences_index_offset(
        mut self,
        sequences_index_offset: DeviceSize,
    ) -> GeneratedCommandsInfoNVBuilder<'a> {
        self.inner.sequences_index_offset = sequences_index_offset;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsGeneratedCommandsInfoNV>(
        mut self,
        next: &'a mut T,
    ) -> GeneratedCommandsInfoNVBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> GeneratedCommandsInfoNV {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkGeneratedCommandsMemoryRequirementsInfoNV.html>"]
pub struct GeneratedCommandsMemoryRequirementsInfoNV {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub pipeline_bind_point: PipelineBindPoint,
    pub pipeline: Pipeline,
    pub indirect_commands_layout: IndirectCommandsLayoutNV,
    pub max_sequences_count: u32,
}
impl ::std::default::Default for GeneratedCommandsMemoryRequirementsInfoNV {
    fn default() -> GeneratedCommandsMemoryRequirementsInfoNV {
        GeneratedCommandsMemoryRequirementsInfoNV {
            s_type: StructureType::GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_NV,
            p_next: ::std::ptr::null(),
            pipeline_bind_point: PipelineBindPoint::default(),
            pipeline: Pipeline::default(),
            indirect_commands_layout: IndirectCommandsLayoutNV::default(),
            max_sequences_count: u32::default(),
        }
    }
}
impl GeneratedCommandsMemoryRequirementsInfoNV {
    pub fn builder<'a>() -> GeneratedCommandsMemoryRequirementsInfoNVBuilder<'a> {
        GeneratedCommandsMemoryRequirementsInfoNVBuilder {
            inner: GeneratedCommandsMemoryRequirementsInfoNV::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct GeneratedCommandsMemoryRequirementsInfoNVBuilder<'a> {
    inner: GeneratedCommandsMemoryRequirementsInfoNV,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsGeneratedCommandsMemoryRequirementsInfoNV {}
impl<'a> ::std::ops::Deref for GeneratedCommandsMemoryRequirementsInfoNVBuilder<'a> {
    type Target = GeneratedCommandsMemoryRequirementsInfoNV;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for GeneratedCommandsMemoryRequirementsInfoNVBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> GeneratedCommandsMemoryRequirementsInfoNVBuilder<'a> {
    pub fn pipeline_bind_point(
        mut self,
        pipeline_bind_point: PipelineBindPoint,
    ) -> GeneratedCommandsMemoryRequirementsInfoNVBuilder<'a> {
        self.inner.pipeline_bind_point = pipeline_bind_point;
        self
    }
    pub fn pipeline(
        mut self,
        pipeline: Pipeline,
    ) -> GeneratedCommandsMemoryRequirementsInfoNVBuilder<'a> {
        self.inner.pipeline = pipeline;
        self
    }
    pub fn indirect_commands_layout(
        mut self,
        indirect_commands_layout: IndirectCommandsLayoutNV,
    ) -> GeneratedCommandsMemoryRequirementsInfoNVBuilder<'a> {
        self.inner.indirect_commands_layout = indirect_commands_layout;
        self
    }
    pub fn max_sequences_count(
        mut self,
        max_sequences_count: u32,
    ) -> GeneratedCommandsMemoryRequirementsInfoNVBuilder<'a> {
        self.inner.max_sequences_count = max_sequences_count;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsGeneratedCommandsMemoryRequirementsInfoNV>(
        mut self,
        next: &'a mut T,
    ) -> GeneratedCommandsMemoryRequirementsInfoNVBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> GeneratedCommandsMemoryRequirementsInfoNV {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFeatures2.html>"]
pub struct PhysicalDeviceFeatures2 {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub features: PhysicalDeviceFeatures,
}
impl ::std::default::Default for PhysicalDeviceFeatures2 {
    fn default() -> PhysicalDeviceFeatures2 {
        PhysicalDeviceFeatures2 {
            s_type: StructureType::PHYSICAL_DEVICE_FEATURES_2,
            p_next: ::std::ptr::null_mut(),
            features: PhysicalDeviceFeatures::default(),
        }
    }
}
impl PhysicalDeviceFeatures2 {
    pub fn builder<'a>() -> PhysicalDeviceFeatures2Builder<'a> {
        PhysicalDeviceFeatures2Builder {
            inner: PhysicalDeviceFeatures2::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDeviceFeatures2Builder<'a> {
    inner: PhysicalDeviceFeatures2,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFeatures2Builder<'_> {}
unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFeatures2 {}
impl<'a> ::std::ops::Deref for PhysicalDeviceFeatures2Builder<'a> {
    type Target = PhysicalDeviceFeatures2;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PhysicalDeviceFeatures2Builder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDeviceFeatures2Builder<'a> {
    pub fn features(
        mut self,
        features: PhysicalDeviceFeatures,
    ) -> PhysicalDeviceFeatures2Builder<'a> {
        self.inner.features = features;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDeviceFeatures2 {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceProperties2.html>"]
pub struct PhysicalDeviceProperties2 {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub properties: PhysicalDeviceProperties,
}
impl ::std::default::Default for PhysicalDeviceProperties2 {
    fn default() -> PhysicalDeviceProperties2 {
        PhysicalDeviceProperties2 {
            s_type: StructureType::PHYSICAL_DEVICE_PROPERTIES_2,
            p_next: ::std::ptr::null_mut(),
            properties: PhysicalDeviceProperties::default(),
        }
    }
}
impl PhysicalDeviceProperties2 {
    pub fn builder<'a>() -> PhysicalDeviceProperties2Builder<'a> {
        PhysicalDeviceProperties2Builder {
            inner: PhysicalDeviceProperties2::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDeviceProperties2Builder<'a> {
    inner: PhysicalDeviceProperties2,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsPhysicalDeviceProperties2 {}
impl<'a> ::std::ops::Deref for PhysicalDeviceProperties2Builder<'a> {
    type Target = PhysicalDeviceProperties2;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PhysicalDeviceProperties2Builder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDeviceProperties2Builder<'a> {
    pub fn properties(
        mut self,
        properties: PhysicalDeviceProperties,
    ) -> PhysicalDeviceProperties2Builder<'a> {
        self.inner.properties = properties;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsPhysicalDeviceProperties2>(
        mut self,
        next: &'a mut T,
    ) -> PhysicalDeviceProperties2Builder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDeviceProperties2 {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkFormatProperties2.html>"]
pub struct FormatProperties2 {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub format_properties: FormatProperties,
}
impl ::std::default::Default for FormatProperties2 {
    fn default() -> FormatProperties2 {
        FormatProperties2 {
            s_type: StructureType::FORMAT_PROPERTIES_2,
            p_next: ::std::ptr::null_mut(),
            format_properties: FormatProperties::default(),
        }
    }
}
impl FormatProperties2 {
    pub fn builder<'a>() -> FormatProperties2Builder<'a> {
        FormatProperties2Builder {
            inner: FormatProperties2::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct FormatProperties2Builder<'a> {
    inner: FormatProperties2,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsFormatProperties2 {}
impl<'a> ::std::ops::Deref for FormatProperties2Builder<'a> {
    type Target = FormatProperties2;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for FormatProperties2Builder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> FormatProperties2Builder<'a> {
    pub fn format_properties(
        mut self,
        format_properties: FormatProperties,
    ) -> FormatProperties2Builder<'a> {
        self.inner.format_properties = format_properties;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsFormatProperties2>(
        mut self,
        next: &'a mut T,
    ) -> FormatProperties2Builder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> FormatProperties2 {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImageFormatProperties2.html>"]
pub struct ImageFormatProperties2 {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub image_format_properties: ImageFormatProperties,
}
impl ::std::default::Default for ImageFormatProperties2 {
    fn default() -> ImageFormatProperties2 {
        ImageFormatProperties2 {
            s_type: StructureType::IMAGE_FORMAT_PROPERTIES_2,
            p_next: ::std::ptr::null_mut(),
            image_format_properties: ImageFormatProperties::default(),
        }
    }
}
impl ImageFormatProperties2 {
    pub fn builder<'a>() -> ImageFormatProperties2Builder<'a> {
        ImageFormatProperties2Builder {
            inner: ImageFormatProperties2::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct ImageFormatProperties2Builder<'a> {
    inner: ImageFormatProperties2,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsImageFormatProperties2 {}
impl<'a> ::std::ops::Deref for ImageFormatProperties2Builder<'a> {
    type Target = ImageFormatProperties2;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for ImageFormatProperties2Builder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> ImageFormatProperties2Builder<'a> {
    pub fn image_format_properties(
        mut self,
        image_format_properties: ImageFormatProperties,
    ) -> ImageFormatProperties2Builder<'a> {
        self.inner.image_format_properties = image_format_properties;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsImageFormatProperties2>(
        mut self,
        next: &'a mut T,
    ) -> ImageFormatProperties2Builder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> ImageFormatProperties2 {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceImageFormatInfo2.html>"]
pub struct PhysicalDeviceImageFormatInfo2 {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub format: Format,
    pub ty: ImageType,
    pub tiling: ImageTiling,
    pub usage: ImageUsageFlags,
    pub flags: ImageCreateFlags,
}
impl ::std::default::Default for PhysicalDeviceImageFormatInfo2 {
    fn default() -> PhysicalDeviceImageFormatInfo2 {
        PhysicalDeviceImageFormatInfo2 {
            s_type: StructureType::PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2,
            p_next: ::std::ptr::null(),
            format: Format::default(),
            ty: ImageType::default(),
            tiling: ImageTiling::default(),
            usage: ImageUsageFlags::default(),
            flags: ImageCreateFlags::default(),
        }
    }
}
impl PhysicalDeviceImageFormatInfo2 {
    pub fn builder<'a>() -> PhysicalDeviceImageFormatInfo2Builder<'a> {
        PhysicalDeviceImageFormatInfo2Builder {
            inner: PhysicalDeviceImageFormatInfo2::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDeviceImageFormatInfo2Builder<'a> {
    inner: PhysicalDeviceImageFormatInfo2,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsPhysicalDeviceImageFormatInfo2 {}
impl<'a> ::std::ops::Deref for PhysicalDeviceImageFormatInfo2Builder<'a> {
    type Target = PhysicalDeviceImageFormatInfo2;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PhysicalDeviceImageFormatInfo2Builder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDeviceImageFormatInfo2Builder<'a> {
    pub fn format(mut self, format: Format) -> PhysicalDeviceImageFormatInfo2Builder<'a> {
        self.inner.format = format;
        self
    }
    pub fn ty(mut self, ty: ImageType) -> PhysicalDeviceImageFormatInfo2Builder<'a> {
        self.inner.ty = ty;
        self
    }
    pub fn tiling(mut self, tiling: ImageTiling) -> PhysicalDeviceImageFormatInfo2Builder<'a> {
        self.inner.tiling = tiling;
        self
    }
    pub fn usage(mut self, usage: ImageUsageFlags) -> PhysicalDeviceImageFormatInfo2Builder<'a> {
        self.inner.usage = usage;
        self
    }
    pub fn flags(mut self, flags: ImageCreateFlags) -> PhysicalDeviceImageFormatInfo2Builder<'a> {
        self.inner.flags = flags;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsPhysicalDeviceImageFormatInfo2>(
        mut self,
        next: &'a mut T,
    ) -> PhysicalDeviceImageFormatInfo2Builder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDeviceImageFormatInfo2 {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkQueueFamilyProperties2.html>"]
pub struct QueueFamilyProperties2 {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub queue_family_properties: QueueFamilyProperties,
}
impl ::std::default::Default for QueueFamilyProperties2 {
    fn default() -> QueueFamilyProperties2 {
        QueueFamilyProperties2 {
            s_type: StructureType::QUEUE_FAMILY_PROPERTIES_2,
            p_next: ::std::ptr::null_mut(),
            queue_family_properties: QueueFamilyProperties::default(),
        }
    }
}
impl QueueFamilyProperties2 {
    pub fn builder<'a>() -> QueueFamilyProperties2Builder<'a> {
        QueueFamilyProperties2Builder {
            inner: QueueFamilyProperties2::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct QueueFamilyProperties2Builder<'a> {
    inner: QueueFamilyProperties2,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsQueueFamilyProperties2 {}
impl<'a> ::std::ops::Deref for QueueFamilyProperties2Builder<'a> {
    type Target = QueueFamilyProperties2;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for QueueFamilyProperties2Builder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> QueueFamilyProperties2Builder<'a> {
    pub fn queue_family_properties(
        mut self,
        queue_family_properties: QueueFamilyProperties,
    ) -> QueueFamilyProperties2Builder<'a> {
        self.inner.queue_family_properties = queue_family_properties;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsQueueFamilyProperties2>(
        mut self,
        next: &'a mut T,
    ) -> QueueFamilyProperties2Builder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> QueueFamilyProperties2 {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceMemoryProperties2.html>"]
pub struct PhysicalDeviceMemoryProperties2 {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub memory_properties: PhysicalDeviceMemoryProperties,
}
impl ::std::default::Default for PhysicalDeviceMemoryProperties2 {
    fn default() -> PhysicalDeviceMemoryProperties2 {
        PhysicalDeviceMemoryProperties2 {
            s_type: StructureType::PHYSICAL_DEVICE_MEMORY_PROPERTIES_2,
            p_next: ::std::ptr::null_mut(),
            memory_properties: PhysicalDeviceMemoryProperties::default(),
        }
    }
}
impl PhysicalDeviceMemoryProperties2 {
    pub fn builder<'a>() -> PhysicalDeviceMemoryProperties2Builder<'a> {
        PhysicalDeviceMemoryProperties2Builder {
            inner: PhysicalDeviceMemoryProperties2::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDeviceMemoryProperties2Builder<'a> {
    inner: PhysicalDeviceMemoryProperties2,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsPhysicalDeviceMemoryProperties2 {}
impl<'a> ::std::ops::Deref for PhysicalDeviceMemoryProperties2Builder<'a> {
    type Target = PhysicalDeviceMemoryProperties2;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PhysicalDeviceMemoryProperties2Builder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDeviceMemoryProperties2Builder<'a> {
    pub fn memory_properties(
        mut self,
        memory_properties: PhysicalDeviceMemoryProperties,
    ) -> PhysicalDeviceMemoryProperties2Builder<'a> {
        self.inner.memory_properties = memory_properties;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsPhysicalDeviceMemoryProperties2>(
        mut self,
        next: &'a mut T,
    ) -> PhysicalDeviceMemoryProperties2Builder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDeviceMemoryProperties2 {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSparseImageFormatProperties2.html>"]
pub struct SparseImageFormatProperties2 {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub properties: SparseImageFormatProperties,
}
impl ::std::default::Default for SparseImageFormatProperties2 {
    fn default() -> SparseImageFormatProperties2 {
        SparseImageFormatProperties2 {
            s_type: StructureType::SPARSE_IMAGE_FORMAT_PROPERTIES_2,
            p_next: ::std::ptr::null_mut(),
            properties: SparseImageFormatProperties::default(),
        }
    }
}
impl SparseImageFormatProperties2 {
    pub fn builder<'a>() -> SparseImageFormatProperties2Builder<'a> {
        SparseImageFormatProperties2Builder {
            inner: SparseImageFormatProperties2::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct SparseImageFormatProperties2Builder<'a> {
    inner: SparseImageFormatProperties2,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsSparseImageFormatProperties2 {}
impl<'a> ::std::ops::Deref for SparseImageFormatProperties2Builder<'a> {
    type Target = SparseImageFormatProperties2;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for SparseImageFormatProperties2Builder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> SparseImageFormatProperties2Builder<'a> {
    pub fn properties(
        mut self,
        properties: SparseImageFormatProperties,
    ) -> SparseImageFormatProperties2Builder<'a> {
        self.inner.properties = properties;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsSparseImageFormatProperties2>(
        mut self,
        next: &'a mut T,
    ) -> SparseImageFormatProperties2Builder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> SparseImageFormatProperties2 {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceSparseImageFormatInfo2.html>"]
pub struct PhysicalDeviceSparseImageFormatInfo2 {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub format: Format,
    pub ty: ImageType,
    pub samples: SampleCountFlags,
    pub usage: ImageUsageFlags,
    pub tiling: ImageTiling,
}
impl ::std::default::Default for PhysicalDeviceSparseImageFormatInfo2 {
    fn default() -> PhysicalDeviceSparseImageFormatInfo2 {
        PhysicalDeviceSparseImageFormatInfo2 {
            s_type: StructureType::PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2,
            p_next: ::std::ptr::null(),
            format: Format::default(),
            ty: ImageType::default(),
            samples: SampleCountFlags::default(),
            usage: ImageUsageFlags::default(),
            tiling: ImageTiling::default(),
        }
    }
}
impl PhysicalDeviceSparseImageFormatInfo2 {
    pub fn builder<'a>() -> PhysicalDeviceSparseImageFormatInfo2Builder<'a> {
        PhysicalDeviceSparseImageFormatInfo2Builder {
            inner: PhysicalDeviceSparseImageFormatInfo2::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDeviceSparseImageFormatInfo2Builder<'a> {
    inner: PhysicalDeviceSparseImageFormatInfo2,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsPhysicalDeviceSparseImageFormatInfo2 {}
impl<'a> ::std::ops::Deref for PhysicalDeviceSparseImageFormatInfo2Builder<'a> {
    type Target = PhysicalDeviceSparseImageFormatInfo2;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PhysicalDeviceSparseImageFormatInfo2Builder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDeviceSparseImageFormatInfo2Builder<'a> {
    pub fn format(mut self, format: Format) -> PhysicalDeviceSparseImageFormatInfo2Builder<'a> {
        self.inner.format = format;
        self
    }
    pub fn ty(mut self, ty: ImageType) -> PhysicalDeviceSparseImageFormatInfo2Builder<'a> {
        self.inner.ty = ty;
        self
    }
    pub fn samples(
        mut self,
        samples: SampleCountFlags,
    ) -> PhysicalDeviceSparseImageFormatInfo2Builder<'a> {
        self.inner.samples = samples;
        self
    }
    pub fn usage(
        mut self,
        usage: ImageUsageFlags,
    ) -> PhysicalDeviceSparseImageFormatInfo2Builder<'a> {
        self.inner.usage = usage;
        self
    }
    pub fn tiling(
        mut self,
        tiling: ImageTiling,
    ) -> PhysicalDeviceSparseImageFormatInfo2Builder<'a> {
        self.inner.tiling = tiling;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsPhysicalDeviceSparseImageFormatInfo2>(
        mut self,
        next: &'a mut T,
    ) -> PhysicalDeviceSparseImageFormatInfo2Builder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDeviceSparseImageFormatInfo2 {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDevicePushDescriptorPropertiesKHR.html>"]
pub struct PhysicalDevicePushDescriptorPropertiesKHR {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub max_push_descriptors: u32,
}
impl ::std::default::Default for PhysicalDevicePushDescriptorPropertiesKHR {
    fn default() -> PhysicalDevicePushDescriptorPropertiesKHR {
        PhysicalDevicePushDescriptorPropertiesKHR {
            s_type: StructureType::PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR,
            p_next: ::std::ptr::null_mut(),
            max_push_descriptors: u32::default(),
        }
    }
}
impl PhysicalDevicePushDescriptorPropertiesKHR {
    pub fn builder<'a>() -> PhysicalDevicePushDescriptorPropertiesKHRBuilder<'a> {
        PhysicalDevicePushDescriptorPropertiesKHRBuilder {
            inner: PhysicalDevicePushDescriptorPropertiesKHR::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDevicePushDescriptorPropertiesKHRBuilder<'a> {
    inner: PhysicalDevicePushDescriptorPropertiesKHR,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsPhysicalDeviceProperties2
    for PhysicalDevicePushDescriptorPropertiesKHRBuilder<'_>
{
}
unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDevicePushDescriptorPropertiesKHR {}
impl<'a> ::std::ops::Deref for PhysicalDevicePushDescriptorPropertiesKHRBuilder<'a> {
    type Target = PhysicalDevicePushDescriptorPropertiesKHR;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PhysicalDevicePushDescriptorPropertiesKHRBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDevicePushDescriptorPropertiesKHRBuilder<'a> {
    pub fn max_push_descriptors(
        mut self,
        max_push_descriptors: u32,
    ) -> PhysicalDevicePushDescriptorPropertiesKHRBuilder<'a> {
        self.inner.max_push_descriptors = max_push_descriptors;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDevicePushDescriptorPropertiesKHR {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Default, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkConformanceVersion.html>"]
pub struct ConformanceVersion {
    pub major: u8,
    pub minor: u8,
    pub subminor: u8,
    pub patch: u8,
}
impl ConformanceVersion {
    pub fn builder<'a>() -> ConformanceVersionBuilder<'a> {
        ConformanceVersionBuilder {
            inner: ConformanceVersion::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct ConformanceVersionBuilder<'a> {
    inner: ConformanceVersion,
    marker: ::std::marker::PhantomData<&'a ()>,
}
impl<'a> ::std::ops::Deref for ConformanceVersionBuilder<'a> {
    type Target = ConformanceVersion;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for ConformanceVersionBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> ConformanceVersionBuilder<'a> {
    pub fn major(mut self, major: u8) -> ConformanceVersionBuilder<'a> {
        self.inner.major = major;
        self
    }
    pub fn minor(mut self, minor: u8) -> ConformanceVersionBuilder<'a> {
        self.inner.minor = minor;
        self
    }
    pub fn subminor(mut self, subminor: u8) -> ConformanceVersionBuilder<'a> {
        self.inner.subminor = subminor;
        self
    }
    pub fn patch(mut self, patch: u8) -> ConformanceVersionBuilder<'a> {
        self.inner.patch = patch;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> ConformanceVersion {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceDriverProperties.html>"]
pub struct PhysicalDeviceDriverProperties {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub driver_id: DriverId,
    pub driver_name: [c_char; MAX_DRIVER_NAME_SIZE],
    pub driver_info: [c_char; MAX_DRIVER_INFO_SIZE],
    pub conformance_version: ConformanceVersion,
}
impl fmt::Debug for PhysicalDeviceDriverProperties {
    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
        fmt.debug_struct("PhysicalDeviceDriverProperties")
            .field("s_type", &self.s_type)
            .field("p_next", &self.p_next)
            .field("driver_id", &self.driver_id)
            .field("driver_name", &unsafe {
                ::std::ffi::CStr::from_ptr(self.driver_name.as_ptr() as *const c_char)
            })
            .field("driver_info", &unsafe {
                ::std::ffi::CStr::from_ptr(self.driver_info.as_ptr() as *const c_char)
            })
            .field("conformance_version", &self.conformance_version)
            .finish()
    }
}
impl ::std::default::Default for PhysicalDeviceDriverProperties {
    fn default() -> PhysicalDeviceDriverProperties {
        PhysicalDeviceDriverProperties {
            s_type: StructureType::PHYSICAL_DEVICE_DRIVER_PROPERTIES,
            p_next: ::std::ptr::null_mut(),
            driver_id: DriverId::default(),
            driver_name: unsafe { ::std::mem::zeroed() },
            driver_info: unsafe { ::std::mem::zeroed() },
            conformance_version: ConformanceVersion::default(),
        }
    }
}
impl PhysicalDeviceDriverProperties {
    pub fn builder<'a>() -> PhysicalDeviceDriverPropertiesBuilder<'a> {
        PhysicalDeviceDriverPropertiesBuilder {
            inner: PhysicalDeviceDriverProperties::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDeviceDriverPropertiesBuilder<'a> {
    inner: PhysicalDeviceDriverProperties,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceDriverPropertiesBuilder<'_> {}
unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceDriverProperties {}
impl<'a> ::std::ops::Deref for PhysicalDeviceDriverPropertiesBuilder<'a> {
    type Target = PhysicalDeviceDriverProperties;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PhysicalDeviceDriverPropertiesBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDeviceDriverPropertiesBuilder<'a> {
    pub fn driver_id(mut self, driver_id: DriverId) -> PhysicalDeviceDriverPropertiesBuilder<'a> {
        self.inner.driver_id = driver_id;
        self
    }
    pub fn driver_name(
        mut self,
        driver_name: [c_char; MAX_DRIVER_NAME_SIZE],
    ) -> PhysicalDeviceDriverPropertiesBuilder<'a> {
        self.inner.driver_name = driver_name;
        self
    }
    pub fn driver_info(
        mut self,
        driver_info: [c_char; MAX_DRIVER_INFO_SIZE],
    ) -> PhysicalDeviceDriverPropertiesBuilder<'a> {
        self.inner.driver_info = driver_info;
        self
    }
    pub fn conformance_version(
        mut self,
        conformance_version: ConformanceVersion,
    ) -> PhysicalDeviceDriverPropertiesBuilder<'a> {
        self.inner.conformance_version = conformance_version;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDeviceDriverProperties {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPresentRegionsKHR.html>"]
pub struct PresentRegionsKHR {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub swapchain_count: u32,
    pub p_regions: *const PresentRegionKHR,
}
impl ::std::default::Default for PresentRegionsKHR {
    fn default() -> PresentRegionsKHR {
        PresentRegionsKHR {
            s_type: StructureType::PRESENT_REGIONS_KHR,
            p_next: ::std::ptr::null(),
            swapchain_count: u32::default(),
            p_regions: ::std::ptr::null(),
        }
    }
}
impl PresentRegionsKHR {
    pub fn builder<'a>() -> PresentRegionsKHRBuilder<'a> {
        PresentRegionsKHRBuilder {
            inner: PresentRegionsKHR::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PresentRegionsKHRBuilder<'a> {
    inner: PresentRegionsKHR,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsPresentInfoKHR for PresentRegionsKHRBuilder<'_> {}
unsafe impl ExtendsPresentInfoKHR for PresentRegionsKHR {}
impl<'a> ::std::ops::Deref for PresentRegionsKHRBuilder<'a> {
    type Target = PresentRegionsKHR;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PresentRegionsKHRBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PresentRegionsKHRBuilder<'a> {
    pub fn regions(mut self, regions: &'a [PresentRegionKHR]) -> PresentRegionsKHRBuilder<'a> {
        self.inner.swapchain_count = regions.len() as _;
        self.inner.p_regions = regions.as_ptr();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PresentRegionsKHR {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPresentRegionKHR.html>"]
pub struct PresentRegionKHR {
    pub rectangle_count: u32,
    pub p_rectangles: *const RectLayerKHR,
}
impl ::std::default::Default for PresentRegionKHR {
    fn default() -> PresentRegionKHR {
        PresentRegionKHR {
            rectangle_count: u32::default(),
            p_rectangles: ::std::ptr::null(),
        }
    }
}
impl PresentRegionKHR {
    pub fn builder<'a>() -> PresentRegionKHRBuilder<'a> {
        PresentRegionKHRBuilder {
            inner: PresentRegionKHR::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PresentRegionKHRBuilder<'a> {
    inner: PresentRegionKHR,
    marker: ::std::marker::PhantomData<&'a ()>,
}
impl<'a> ::std::ops::Deref for PresentRegionKHRBuilder<'a> {
    type Target = PresentRegionKHR;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PresentRegionKHRBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PresentRegionKHRBuilder<'a> {
    pub fn rectangles(mut self, rectangles: &'a [RectLayerKHR]) -> PresentRegionKHRBuilder<'a> {
        self.inner.rectangle_count = rectangles.len() as _;
        self.inner.p_rectangles = rectangles.as_ptr();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PresentRegionKHR {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Default, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkRectLayerKHR.html>"]
pub struct RectLayerKHR {
    pub offset: Offset2D,
    pub extent: Extent2D,
    pub layer: u32,
}
impl RectLayerKHR {
    pub fn builder<'a>() -> RectLayerKHRBuilder<'a> {
        RectLayerKHRBuilder {
            inner: RectLayerKHR::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct RectLayerKHRBuilder<'a> {
    inner: RectLayerKHR,
    marker: ::std::marker::PhantomData<&'a ()>,
}
impl<'a> ::std::ops::Deref for RectLayerKHRBuilder<'a> {
    type Target = RectLayerKHR;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for RectLayerKHRBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> RectLayerKHRBuilder<'a> {
    pub fn offset(mut self, offset: Offset2D) -> RectLayerKHRBuilder<'a> {
        self.inner.offset = offset;
        self
    }
    pub fn extent(mut self, extent: Extent2D) -> RectLayerKHRBuilder<'a> {
        self.inner.extent = extent;
        self
    }
    pub fn layer(mut self, layer: u32) -> RectLayerKHRBuilder<'a> {
        self.inner.layer = layer;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> RectLayerKHR {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVariablePointersFeatures.html>"]
pub struct PhysicalDeviceVariablePointersFeatures {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub variable_pointers_storage_buffer: Bool32,
    pub variable_pointers: Bool32,
}
impl ::std::default::Default for PhysicalDeviceVariablePointersFeatures {
    fn default() -> PhysicalDeviceVariablePointersFeatures {
        PhysicalDeviceVariablePointersFeatures {
            s_type: StructureType::PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES,
            p_next: ::std::ptr::null_mut(),
            variable_pointers_storage_buffer: Bool32::default(),
            variable_pointers: Bool32::default(),
        }
    }
}
impl PhysicalDeviceVariablePointersFeatures {
    pub fn builder<'a>() -> PhysicalDeviceVariablePointersFeaturesBuilder<'a> {
        PhysicalDeviceVariablePointersFeaturesBuilder {
            inner: PhysicalDeviceVariablePointersFeatures::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDeviceVariablePointersFeaturesBuilder<'a> {
    inner: PhysicalDeviceVariablePointersFeatures,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVariablePointersFeaturesBuilder<'_> {}
unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVariablePointersFeatures {}
impl<'a> ::std::ops::Deref for PhysicalDeviceVariablePointersFeaturesBuilder<'a> {
    type Target = PhysicalDeviceVariablePointersFeatures;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PhysicalDeviceVariablePointersFeaturesBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDeviceVariablePointersFeaturesBuilder<'a> {
    pub fn variable_pointers_storage_buffer(
        mut self,
        variable_pointers_storage_buffer: bool,
    ) -> PhysicalDeviceVariablePointersFeaturesBuilder<'a> {
        self.inner.variable_pointers_storage_buffer = variable_pointers_storage_buffer.into();
        self
    }
    pub fn variable_pointers(
        mut self,
        variable_pointers: bool,
    ) -> PhysicalDeviceVariablePointersFeaturesBuilder<'a> {
        self.inner.variable_pointers = variable_pointers.into();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDeviceVariablePointersFeatures {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Default, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkExternalMemoryProperties.html>"]
pub struct ExternalMemoryProperties {
    pub external_memory_features: ExternalMemoryFeatureFlags,
    pub export_from_imported_handle_types: ExternalMemoryHandleTypeFlags,
    pub compatible_handle_types: ExternalMemoryHandleTypeFlags,
}
impl ExternalMemoryProperties {
    pub fn builder<'a>() -> ExternalMemoryPropertiesBuilder<'a> {
        ExternalMemoryPropertiesBuilder {
            inner: ExternalMemoryProperties::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct ExternalMemoryPropertiesBuilder<'a> {
    inner: ExternalMemoryProperties,
    marker: ::std::marker::PhantomData<&'a ()>,
}
impl<'a> ::std::ops::Deref for ExternalMemoryPropertiesBuilder<'a> {
    type Target = ExternalMemoryProperties;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for ExternalMemoryPropertiesBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> ExternalMemoryPropertiesBuilder<'a> {
    pub fn external_memory_features(
        mut self,
        external_memory_features: ExternalMemoryFeatureFlags,
    ) -> ExternalMemoryPropertiesBuilder<'a> {
        self.inner.external_memory_features = external_memory_features;
        self
    }
    pub fn export_from_imported_handle_types(
        mut self,
        export_from_imported_handle_types: ExternalMemoryHandleTypeFlags,
    ) -> ExternalMemoryPropertiesBuilder<'a> {
        self.inner.export_from_imported_handle_types = export_from_imported_handle_types;
        self
    }
    pub fn compatible_handle_types(
        mut self,
        compatible_handle_types: ExternalMemoryHandleTypeFlags,
    ) -> ExternalMemoryPropertiesBuilder<'a> {
        self.inner.compatible_handle_types = compatible_handle_types;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> ExternalMemoryProperties {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceExternalImageFormatInfo.html>"]
pub struct PhysicalDeviceExternalImageFormatInfo {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub handle_type: ExternalMemoryHandleTypeFlags,
}
impl ::std::default::Default for PhysicalDeviceExternalImageFormatInfo {
    fn default() -> PhysicalDeviceExternalImageFormatInfo {
        PhysicalDeviceExternalImageFormatInfo {
            s_type: StructureType::PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO,
            p_next: ::std::ptr::null(),
            handle_type: ExternalMemoryHandleTypeFlags::default(),
        }
    }
}
impl PhysicalDeviceExternalImageFormatInfo {
    pub fn builder<'a>() -> PhysicalDeviceExternalImageFormatInfoBuilder<'a> {
        PhysicalDeviceExternalImageFormatInfoBuilder {
            inner: PhysicalDeviceExternalImageFormatInfo::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDeviceExternalImageFormatInfoBuilder<'a> {
    inner: PhysicalDeviceExternalImageFormatInfo,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsPhysicalDeviceImageFormatInfo2
    for PhysicalDeviceExternalImageFormatInfoBuilder<'_>
{
}
unsafe impl ExtendsPhysicalDeviceImageFormatInfo2 for PhysicalDeviceExternalImageFormatInfo {}
impl<'a> ::std::ops::Deref for PhysicalDeviceExternalImageFormatInfoBuilder<'a> {
    type Target = PhysicalDeviceExternalImageFormatInfo;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PhysicalDeviceExternalImageFormatInfoBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDeviceExternalImageFormatInfoBuilder<'a> {
    pub fn handle_type(
        mut self,
        handle_type: ExternalMemoryHandleTypeFlags,
    ) -> PhysicalDeviceExternalImageFormatInfoBuilder<'a> {
        self.inner.handle_type = handle_type;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDeviceExternalImageFormatInfo {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkExternalImageFormatProperties.html>"]
pub struct ExternalImageFormatProperties {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub external_memory_properties: ExternalMemoryProperties,
}
impl ::std::default::Default for ExternalImageFormatProperties {
    fn default() -> ExternalImageFormatProperties {
        ExternalImageFormatProperties {
            s_type: StructureType::EXTERNAL_IMAGE_FORMAT_PROPERTIES,
            p_next: ::std::ptr::null_mut(),
            external_memory_properties: ExternalMemoryProperties::default(),
        }
    }
}
impl ExternalImageFormatProperties {
    pub fn builder<'a>() -> ExternalImageFormatPropertiesBuilder<'a> {
        ExternalImageFormatPropertiesBuilder {
            inner: ExternalImageFormatProperties::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct ExternalImageFormatPropertiesBuilder<'a> {
    inner: ExternalImageFormatProperties,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsImageFormatProperties2 for ExternalImageFormatPropertiesBuilder<'_> {}
unsafe impl ExtendsImageFormatProperties2 for ExternalImageFormatProperties {}
impl<'a> ::std::ops::Deref for ExternalImageFormatPropertiesBuilder<'a> {
    type Target = ExternalImageFormatProperties;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for ExternalImageFormatPropertiesBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> ExternalImageFormatPropertiesBuilder<'a> {
    pub fn external_memory_properties(
        mut self,
        external_memory_properties: ExternalMemoryProperties,
    ) -> ExternalImageFormatPropertiesBuilder<'a> {
        self.inner.external_memory_properties = external_memory_properties;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> ExternalImageFormatProperties {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceExternalBufferInfo.html>"]
pub struct PhysicalDeviceExternalBufferInfo {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub flags: BufferCreateFlags,
    pub usage: BufferUsageFlags,
    pub handle_type: ExternalMemoryHandleTypeFlags,
}
impl ::std::default::Default for PhysicalDeviceExternalBufferInfo {
    fn default() -> PhysicalDeviceExternalBufferInfo {
        PhysicalDeviceExternalBufferInfo {
            s_type: StructureType::PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO,
            p_next: ::std::ptr::null(),
            flags: BufferCreateFlags::default(),
            usage: BufferUsageFlags::default(),
            handle_type: ExternalMemoryHandleTypeFlags::default(),
        }
    }
}
impl PhysicalDeviceExternalBufferInfo {
    pub fn builder<'a>() -> PhysicalDeviceExternalBufferInfoBuilder<'a> {
        PhysicalDeviceExternalBufferInfoBuilder {
            inner: PhysicalDeviceExternalBufferInfo::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDeviceExternalBufferInfoBuilder<'a> {
    inner: PhysicalDeviceExternalBufferInfo,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsPhysicalDeviceExternalBufferInfo {}
impl<'a> ::std::ops::Deref for PhysicalDeviceExternalBufferInfoBuilder<'a> {
    type Target = PhysicalDeviceExternalBufferInfo;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PhysicalDeviceExternalBufferInfoBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDeviceExternalBufferInfoBuilder<'a> {
    pub fn flags(
        mut self,
        flags: BufferCreateFlags,
    ) -> PhysicalDeviceExternalBufferInfoBuilder<'a> {
        self.inner.flags = flags;
        self
    }
    pub fn usage(mut self, usage: BufferUsageFlags) -> PhysicalDeviceExternalBufferInfoBuilder<'a> {
        self.inner.usage = usage;
        self
    }
    pub fn handle_type(
        mut self,
        handle_type: ExternalMemoryHandleTypeFlags,
    ) -> PhysicalDeviceExternalBufferInfoBuilder<'a> {
        self.inner.handle_type = handle_type;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsPhysicalDeviceExternalBufferInfo>(
        mut self,
        next: &'a mut T,
    ) -> PhysicalDeviceExternalBufferInfoBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDeviceExternalBufferInfo {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkExternalBufferProperties.html>"]
pub struct ExternalBufferProperties {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub external_memory_properties: ExternalMemoryProperties,
}
impl ::std::default::Default for ExternalBufferProperties {
    fn default() -> ExternalBufferProperties {
        ExternalBufferProperties {
            s_type: StructureType::EXTERNAL_BUFFER_PROPERTIES,
            p_next: ::std::ptr::null_mut(),
            external_memory_properties: ExternalMemoryProperties::default(),
        }
    }
}
impl ExternalBufferProperties {
    pub fn builder<'a>() -> ExternalBufferPropertiesBuilder<'a> {
        ExternalBufferPropertiesBuilder {
            inner: ExternalBufferProperties::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct ExternalBufferPropertiesBuilder<'a> {
    inner: ExternalBufferProperties,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsExternalBufferProperties {}
impl<'a> ::std::ops::Deref for ExternalBufferPropertiesBuilder<'a> {
    type Target = ExternalBufferProperties;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for ExternalBufferPropertiesBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> ExternalBufferPropertiesBuilder<'a> {
    pub fn external_memory_properties(
        mut self,
        external_memory_properties: ExternalMemoryProperties,
    ) -> ExternalBufferPropertiesBuilder<'a> {
        self.inner.external_memory_properties = external_memory_properties;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsExternalBufferProperties>(
        mut self,
        next: &'a mut T,
    ) -> ExternalBufferPropertiesBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> ExternalBufferProperties {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceIDProperties.html>"]
pub struct PhysicalDeviceIDProperties {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub device_uuid: [u8; UUID_SIZE],
    pub driver_uuid: [u8; UUID_SIZE],
    pub device_luid: [u8; LUID_SIZE],
    pub device_node_mask: u32,
    pub device_luid_valid: Bool32,
}
impl ::std::default::Default for PhysicalDeviceIDProperties {
    fn default() -> PhysicalDeviceIDProperties {
        PhysicalDeviceIDProperties {
            s_type: StructureType::PHYSICAL_DEVICE_ID_PROPERTIES,
            p_next: ::std::ptr::null_mut(),
            device_uuid: unsafe { ::std::mem::zeroed() },
            driver_uuid: unsafe { ::std::mem::zeroed() },
            device_luid: unsafe { ::std::mem::zeroed() },
            device_node_mask: u32::default(),
            device_luid_valid: Bool32::default(),
        }
    }
}
impl PhysicalDeviceIDProperties {
    pub fn builder<'a>() -> PhysicalDeviceIDPropertiesBuilder<'a> {
        PhysicalDeviceIDPropertiesBuilder {
            inner: PhysicalDeviceIDProperties::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDeviceIDPropertiesBuilder<'a> {
    inner: PhysicalDeviceIDProperties,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceIDPropertiesBuilder<'_> {}
unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceIDProperties {}
impl<'a> ::std::ops::Deref for PhysicalDeviceIDPropertiesBuilder<'a> {
    type Target = PhysicalDeviceIDProperties;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PhysicalDeviceIDPropertiesBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDeviceIDPropertiesBuilder<'a> {
    pub fn device_uuid(
        mut self,
        device_uuid: [u8; UUID_SIZE],
    ) -> PhysicalDeviceIDPropertiesBuilder<'a> {
        self.inner.device_uuid = device_uuid;
        self
    }
    pub fn driver_uuid(
        mut self,
        driver_uuid: [u8; UUID_SIZE],
    ) -> PhysicalDeviceIDPropertiesBuilder<'a> {
        self.inner.driver_uuid = driver_uuid;
        self
    }
    pub fn device_luid(
        mut self,
        device_luid: [u8; LUID_SIZE],
    ) -> PhysicalDeviceIDPropertiesBuilder<'a> {
        self.inner.device_luid = device_luid;
        self
    }
    pub fn device_node_mask(
        mut self,
        device_node_mask: u32,
    ) -> PhysicalDeviceIDPropertiesBuilder<'a> {
        self.inner.device_node_mask = device_node_mask;
        self
    }
    pub fn device_luid_valid(
        mut self,
        device_luid_valid: bool,
    ) -> PhysicalDeviceIDPropertiesBuilder<'a> {
        self.inner.device_luid_valid = device_luid_valid.into();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDeviceIDProperties {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkExternalMemoryImageCreateInfo.html>"]
pub struct ExternalMemoryImageCreateInfo {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub handle_types: ExternalMemoryHandleTypeFlags,
}
impl ::std::default::Default for ExternalMemoryImageCreateInfo {
    fn default() -> ExternalMemoryImageCreateInfo {
        ExternalMemoryImageCreateInfo {
            s_type: StructureType::EXTERNAL_MEMORY_IMAGE_CREATE_INFO,
            p_next: ::std::ptr::null(),
            handle_types: ExternalMemoryHandleTypeFlags::default(),
        }
    }
}
impl ExternalMemoryImageCreateInfo {
    pub fn builder<'a>() -> ExternalMemoryImageCreateInfoBuilder<'a> {
        ExternalMemoryImageCreateInfoBuilder {
            inner: ExternalMemoryImageCreateInfo::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct ExternalMemoryImageCreateInfoBuilder<'a> {
    inner: ExternalMemoryImageCreateInfo,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsImageCreateInfo for ExternalMemoryImageCreateInfoBuilder<'_> {}
unsafe impl ExtendsImageCreateInfo for ExternalMemoryImageCreateInfo {}
impl<'a> ::std::ops::Deref for ExternalMemoryImageCreateInfoBuilder<'a> {
    type Target = ExternalMemoryImageCreateInfo;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for ExternalMemoryImageCreateInfoBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> ExternalMemoryImageCreateInfoBuilder<'a> {
    pub fn handle_types(
        mut self,
        handle_types: ExternalMemoryHandleTypeFlags,
    ) -> ExternalMemoryImageCreateInfoBuilder<'a> {
        self.inner.handle_types = handle_types;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> ExternalMemoryImageCreateInfo {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkExternalMemoryBufferCreateInfo.html>"]
pub struct ExternalMemoryBufferCreateInfo {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub handle_types: ExternalMemoryHandleTypeFlags,
}
impl ::std::default::Default for ExternalMemoryBufferCreateInfo {
    fn default() -> ExternalMemoryBufferCreateInfo {
        ExternalMemoryBufferCreateInfo {
            s_type: StructureType::EXTERNAL_MEMORY_BUFFER_CREATE_INFO,
            p_next: ::std::ptr::null(),
            handle_types: ExternalMemoryHandleTypeFlags::default(),
        }
    }
}
impl ExternalMemoryBufferCreateInfo {
    pub fn builder<'a>() -> ExternalMemoryBufferCreateInfoBuilder<'a> {
        ExternalMemoryBufferCreateInfoBuilder {
            inner: ExternalMemoryBufferCreateInfo::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct ExternalMemoryBufferCreateInfoBuilder<'a> {
    inner: ExternalMemoryBufferCreateInfo,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsBufferCreateInfo for ExternalMemoryBufferCreateInfoBuilder<'_> {}
unsafe impl ExtendsBufferCreateInfo for ExternalMemoryBufferCreateInfo {}
impl<'a> ::std::ops::Deref for ExternalMemoryBufferCreateInfoBuilder<'a> {
    type Target = ExternalMemoryBufferCreateInfo;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for ExternalMemoryBufferCreateInfoBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> ExternalMemoryBufferCreateInfoBuilder<'a> {
    pub fn handle_types(
        mut self,
        handle_types: ExternalMemoryHandleTypeFlags,
    ) -> ExternalMemoryBufferCreateInfoBuilder<'a> {
        self.inner.handle_types = handle_types;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> ExternalMemoryBufferCreateInfo {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkExportMemoryAllocateInfo.html>"]
pub struct ExportMemoryAllocateInfo {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub handle_types: ExternalMemoryHandleTypeFlags,
}
impl ::std::default::Default for ExportMemoryAllocateInfo {
    fn default() -> ExportMemoryAllocateInfo {
        ExportMemoryAllocateInfo {
            s_type: StructureType::EXPORT_MEMORY_ALLOCATE_INFO,
            p_next: ::std::ptr::null(),
            handle_types: ExternalMemoryHandleTypeFlags::default(),
        }
    }
}
impl ExportMemoryAllocateInfo {
    pub fn builder<'a>() -> ExportMemoryAllocateInfoBuilder<'a> {
        ExportMemoryAllocateInfoBuilder {
            inner: ExportMemoryAllocateInfo::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct ExportMemoryAllocateInfoBuilder<'a> {
    inner: ExportMemoryAllocateInfo,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsMemoryAllocateInfo for ExportMemoryAllocateInfoBuilder<'_> {}
unsafe impl ExtendsMemoryAllocateInfo for ExportMemoryAllocateInfo {}
impl<'a> ::std::ops::Deref for ExportMemoryAllocateInfoBuilder<'a> {
    type Target = ExportMemoryAllocateInfo;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for ExportMemoryAllocateInfoBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> ExportMemoryAllocateInfoBuilder<'a> {
    pub fn handle_types(
        mut self,
        handle_types: ExternalMemoryHandleTypeFlags,
    ) -> ExportMemoryAllocateInfoBuilder<'a> {
        self.inner.handle_types = handle_types;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> ExportMemoryAllocateInfo {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImportMemoryWin32HandleInfoKHR.html>"]
pub struct ImportMemoryWin32HandleInfoKHR {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub handle_type: ExternalMemoryHandleTypeFlags,
    pub handle: HANDLE,
    pub name: LPCWSTR,
}
impl ::std::default::Default for ImportMemoryWin32HandleInfoKHR {
    fn default() -> ImportMemoryWin32HandleInfoKHR {
        ImportMemoryWin32HandleInfoKHR {
            s_type: StructureType::IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR,
            p_next: ::std::ptr::null(),
            handle_type: ExternalMemoryHandleTypeFlags::default(),
            handle: unsafe { ::std::mem::zeroed() },
            name: unsafe { ::std::mem::zeroed() },
        }
    }
}
impl ImportMemoryWin32HandleInfoKHR {
    pub fn builder<'a>() -> ImportMemoryWin32HandleInfoKHRBuilder<'a> {
        ImportMemoryWin32HandleInfoKHRBuilder {
            inner: ImportMemoryWin32HandleInfoKHR::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct ImportMemoryWin32HandleInfoKHRBuilder<'a> {
    inner: ImportMemoryWin32HandleInfoKHR,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryWin32HandleInfoKHRBuilder<'_> {}
unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryWin32HandleInfoKHR {}
impl<'a> ::std::ops::Deref for ImportMemoryWin32HandleInfoKHRBuilder<'a> {
    type Target = ImportMemoryWin32HandleInfoKHR;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for ImportMemoryWin32HandleInfoKHRBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> ImportMemoryWin32HandleInfoKHRBuilder<'a> {
    pub fn handle_type(
        mut self,
        handle_type: ExternalMemoryHandleTypeFlags,
    ) -> ImportMemoryWin32HandleInfoKHRBuilder<'a> {
        self.inner.handle_type = handle_type;
        self
    }
    pub fn handle(mut self, handle: HANDLE) -> ImportMemoryWin32HandleInfoKHRBuilder<'a> {
        self.inner.handle = handle;
        self
    }
    pub fn name(mut self, name: LPCWSTR) -> ImportMemoryWin32HandleInfoKHRBuilder<'a> {
        self.inner.name = name;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> ImportMemoryWin32HandleInfoKHR {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkExportMemoryWin32HandleInfoKHR.html>"]
pub struct ExportMemoryWin32HandleInfoKHR {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub p_attributes: *const SECURITY_ATTRIBUTES,
    pub dw_access: DWORD,
    pub name: LPCWSTR,
}
impl ::std::default::Default for ExportMemoryWin32HandleInfoKHR {
    fn default() -> ExportMemoryWin32HandleInfoKHR {
        ExportMemoryWin32HandleInfoKHR {
            s_type: StructureType::EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR,
            p_next: ::std::ptr::null(),
            p_attributes: ::std::ptr::null(),
            dw_access: DWORD::default(),
            name: unsafe { ::std::mem::zeroed() },
        }
    }
}
impl ExportMemoryWin32HandleInfoKHR {
    pub fn builder<'a>() -> ExportMemoryWin32HandleInfoKHRBuilder<'a> {
        ExportMemoryWin32HandleInfoKHRBuilder {
            inner: ExportMemoryWin32HandleInfoKHR::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct ExportMemoryWin32HandleInfoKHRBuilder<'a> {
    inner: ExportMemoryWin32HandleInfoKHR,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsMemoryAllocateInfo for ExportMemoryWin32HandleInfoKHRBuilder<'_> {}
unsafe impl ExtendsMemoryAllocateInfo for ExportMemoryWin32HandleInfoKHR {}
impl<'a> ::std::ops::Deref for ExportMemoryWin32HandleInfoKHRBuilder<'a> {
    type Target = ExportMemoryWin32HandleInfoKHR;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for ExportMemoryWin32HandleInfoKHRBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> ExportMemoryWin32HandleInfoKHRBuilder<'a> {
    pub fn attributes(
        mut self,
        attributes: &'a SECURITY_ATTRIBUTES,
    ) -> ExportMemoryWin32HandleInfoKHRBuilder<'a> {
        self.inner.p_attributes = attributes;
        self
    }
    pub fn dw_access(mut self, dw_access: DWORD) -> ExportMemoryWin32HandleInfoKHRBuilder<'a> {
        self.inner.dw_access = dw_access;
        self
    }
    pub fn name(mut self, name: LPCWSTR) -> ExportMemoryWin32HandleInfoKHRBuilder<'a> {
        self.inner.name = name;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> ExportMemoryWin32HandleInfoKHR {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkMemoryWin32HandlePropertiesKHR.html>"]
pub struct MemoryWin32HandlePropertiesKHR {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub memory_type_bits: u32,
}
impl ::std::default::Default for MemoryWin32HandlePropertiesKHR {
    fn default() -> MemoryWin32HandlePropertiesKHR {
        MemoryWin32HandlePropertiesKHR {
            s_type: StructureType::MEMORY_WIN32_HANDLE_PROPERTIES_KHR,
            p_next: ::std::ptr::null_mut(),
            memory_type_bits: u32::default(),
        }
    }
}
impl MemoryWin32HandlePropertiesKHR {
    pub fn builder<'a>() -> MemoryWin32HandlePropertiesKHRBuilder<'a> {
        MemoryWin32HandlePropertiesKHRBuilder {
            inner: MemoryWin32HandlePropertiesKHR::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct MemoryWin32HandlePropertiesKHRBuilder<'a> {
    inner: MemoryWin32HandlePropertiesKHR,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsMemoryWin32HandlePropertiesKHR {}
impl<'a> ::std::ops::Deref for MemoryWin32HandlePropertiesKHRBuilder<'a> {
    type Target = MemoryWin32HandlePropertiesKHR;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for MemoryWin32HandlePropertiesKHRBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> MemoryWin32HandlePropertiesKHRBuilder<'a> {
    pub fn memory_type_bits(
        mut self,
        memory_type_bits: u32,
    ) -> MemoryWin32HandlePropertiesKHRBuilder<'a> {
        self.inner.memory_type_bits = memory_type_bits;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsMemoryWin32HandlePropertiesKHR>(
        mut self,
        next: &'a mut T,
    ) -> MemoryWin32HandlePropertiesKHRBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> MemoryWin32HandlePropertiesKHR {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkMemoryGetWin32HandleInfoKHR.html>"]
pub struct MemoryGetWin32HandleInfoKHR {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub memory: DeviceMemory,
    pub handle_type: ExternalMemoryHandleTypeFlags,
}
impl ::std::default::Default for MemoryGetWin32HandleInfoKHR {
    fn default() -> MemoryGetWin32HandleInfoKHR {
        MemoryGetWin32HandleInfoKHR {
            s_type: StructureType::MEMORY_GET_WIN32_HANDLE_INFO_KHR,
            p_next: ::std::ptr::null(),
            memory: DeviceMemory::default(),
            handle_type: ExternalMemoryHandleTypeFlags::default(),
        }
    }
}
impl MemoryGetWin32HandleInfoKHR {
    pub fn builder<'a>() -> MemoryGetWin32HandleInfoKHRBuilder<'a> {
        MemoryGetWin32HandleInfoKHRBuilder {
            inner: MemoryGetWin32HandleInfoKHR::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct MemoryGetWin32HandleInfoKHRBuilder<'a> {
    inner: MemoryGetWin32HandleInfoKHR,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsMemoryGetWin32HandleInfoKHR {}
impl<'a> ::std::ops::Deref for MemoryGetWin32HandleInfoKHRBuilder<'a> {
    type Target = MemoryGetWin32HandleInfoKHR;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for MemoryGetWin32HandleInfoKHRBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> MemoryGetWin32HandleInfoKHRBuilder<'a> {
    pub fn memory(mut self, memory: DeviceMemory) -> MemoryGetWin32HandleInfoKHRBuilder<'a> {
        self.inner.memory = memory;
        self
    }
    pub fn handle_type(
        mut self,
        handle_type: ExternalMemoryHandleTypeFlags,
    ) -> MemoryGetWin32HandleInfoKHRBuilder<'a> {
        self.inner.handle_type = handle_type;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsMemoryGetWin32HandleInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> MemoryGetWin32HandleInfoKHRBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> MemoryGetWin32HandleInfoKHR {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImportMemoryFdInfoKHR.html>"]
pub struct ImportMemoryFdInfoKHR {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub handle_type: ExternalMemoryHandleTypeFlags,
    pub fd: c_int,
}
impl ::std::default::Default for ImportMemoryFdInfoKHR {
    fn default() -> ImportMemoryFdInfoKHR {
        ImportMemoryFdInfoKHR {
            s_type: StructureType::IMPORT_MEMORY_FD_INFO_KHR,
            p_next: ::std::ptr::null(),
            handle_type: ExternalMemoryHandleTypeFlags::default(),
            fd: c_int::default(),
        }
    }
}
impl ImportMemoryFdInfoKHR {
    pub fn builder<'a>() -> ImportMemoryFdInfoKHRBuilder<'a> {
        ImportMemoryFdInfoKHRBuilder {
            inner: ImportMemoryFdInfoKHR::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct ImportMemoryFdInfoKHRBuilder<'a> {
    inner: ImportMemoryFdInfoKHR,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryFdInfoKHRBuilder<'_> {}
unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryFdInfoKHR {}
impl<'a> ::std::ops::Deref for ImportMemoryFdInfoKHRBuilder<'a> {
    type Target = ImportMemoryFdInfoKHR;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for ImportMemoryFdInfoKHRBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> ImportMemoryFdInfoKHRBuilder<'a> {
    pub fn handle_type(
        mut self,
        handle_type: ExternalMemoryHandleTypeFlags,
    ) -> ImportMemoryFdInfoKHRBuilder<'a> {
        self.inner.handle_type = handle_type;
        self
    }
    pub fn fd(mut self, fd: c_int) -> ImportMemoryFdInfoKHRBuilder<'a> {
        self.inner.fd = fd;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> ImportMemoryFdInfoKHR {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkMemoryFdPropertiesKHR.html>"]
pub struct MemoryFdPropertiesKHR {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub memory_type_bits: u32,
}
impl ::std::default::Default for MemoryFdPropertiesKHR {
    fn default() -> MemoryFdPropertiesKHR {
        MemoryFdPropertiesKHR {
            s_type: StructureType::MEMORY_FD_PROPERTIES_KHR,
            p_next: ::std::ptr::null_mut(),
            memory_type_bits: u32::default(),
        }
    }
}
impl MemoryFdPropertiesKHR {
    pub fn builder<'a>() -> MemoryFdPropertiesKHRBuilder<'a> {
        MemoryFdPropertiesKHRBuilder {
            inner: MemoryFdPropertiesKHR::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct MemoryFdPropertiesKHRBuilder<'a> {
    inner: MemoryFdPropertiesKHR,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsMemoryFdPropertiesKHR {}
impl<'a> ::std::ops::Deref for MemoryFdPropertiesKHRBuilder<'a> {
    type Target = MemoryFdPropertiesKHR;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for MemoryFdPropertiesKHRBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> MemoryFdPropertiesKHRBuilder<'a> {
    pub fn memory_type_bits(mut self, memory_type_bits: u32) -> MemoryFdPropertiesKHRBuilder<'a> {
        self.inner.memory_type_bits = memory_type_bits;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsMemoryFdPropertiesKHR>(
        mut self,
        next: &'a mut T,
    ) -> MemoryFdPropertiesKHRBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> MemoryFdPropertiesKHR {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkMemoryGetFdInfoKHR.html>"]
pub struct MemoryGetFdInfoKHR {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub memory: DeviceMemory,
    pub handle_type: ExternalMemoryHandleTypeFlags,
}
impl ::std::default::Default for MemoryGetFdInfoKHR {
    fn default() -> MemoryGetFdInfoKHR {
        MemoryGetFdInfoKHR {
            s_type: StructureType::MEMORY_GET_FD_INFO_KHR,
            p_next: ::std::ptr::null(),
            memory: DeviceMemory::default(),
            handle_type: ExternalMemoryHandleTypeFlags::default(),
        }
    }
}
impl MemoryGetFdInfoKHR {
    pub fn builder<'a>() -> MemoryGetFdInfoKHRBuilder<'a> {
        MemoryGetFdInfoKHRBuilder {
            inner: MemoryGetFdInfoKHR::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct MemoryGetFdInfoKHRBuilder<'a> {
    inner: MemoryGetFdInfoKHR,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsMemoryGetFdInfoKHR {}
impl<'a> ::std::ops::Deref for MemoryGetFdInfoKHRBuilder<'a> {
    type Target = MemoryGetFdInfoKHR;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for MemoryGetFdInfoKHRBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> MemoryGetFdInfoKHRBuilder<'a> {
    pub fn memory(mut self, memory: DeviceMemory) -> MemoryGetFdInfoKHRBuilder<'a> {
        self.inner.memory = memory;
        self
    }
    pub fn handle_type(
        mut self,
        handle_type: ExternalMemoryHandleTypeFlags,
    ) -> MemoryGetFdInfoKHRBuilder<'a> {
        self.inner.handle_type = handle_type;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsMemoryGetFdInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> MemoryGetFdInfoKHRBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> MemoryGetFdInfoKHR {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkWin32KeyedMutexAcquireReleaseInfoKHR.html>"]
pub struct Win32KeyedMutexAcquireReleaseInfoKHR {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub acquire_count: u32,
    pub p_acquire_syncs: *const DeviceMemory,
    pub p_acquire_keys: *const u64,
    pub p_acquire_timeouts: *const u32,
    pub release_count: u32,
    pub p_release_syncs: *const DeviceMemory,
    pub p_release_keys: *const u64,
}
impl ::std::default::Default for Win32KeyedMutexAcquireReleaseInfoKHR {
    fn default() -> Win32KeyedMutexAcquireReleaseInfoKHR {
        Win32KeyedMutexAcquireReleaseInfoKHR {
            s_type: StructureType::WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR,
            p_next: ::std::ptr::null(),
            acquire_count: u32::default(),
            p_acquire_syncs: ::std::ptr::null(),
            p_acquire_keys: ::std::ptr::null(),
            p_acquire_timeouts: ::std::ptr::null(),
            release_count: u32::default(),
            p_release_syncs: ::std::ptr::null(),
            p_release_keys: ::std::ptr::null(),
        }
    }
}
impl Win32KeyedMutexAcquireReleaseInfoKHR {
    pub fn builder<'a>() -> Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'a> {
        Win32KeyedMutexAcquireReleaseInfoKHRBuilder {
            inner: Win32KeyedMutexAcquireReleaseInfoKHR::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'a> {
    inner: Win32KeyedMutexAcquireReleaseInfoKHR,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsSubmitInfo for Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'_> {}
unsafe impl ExtendsSubmitInfo for Win32KeyedMutexAcquireReleaseInfoKHR {}
impl<'a> ::std::ops::Deref for Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'a> {
    type Target = Win32KeyedMutexAcquireReleaseInfoKHR;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'a> {
    pub fn acquire_syncs(
        mut self,
        acquire_syncs: &'a [DeviceMemory],
    ) -> Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'a> {
        self.inner.acquire_count = acquire_syncs.len() as _;
        self.inner.p_acquire_syncs = acquire_syncs.as_ptr();
        self
    }
    pub fn acquire_keys(
        mut self,
        acquire_keys: &'a [u64],
    ) -> Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'a> {
        self.inner.acquire_count = acquire_keys.len() as _;
        self.inner.p_acquire_keys = acquire_keys.as_ptr();
        self
    }
    pub fn acquire_timeouts(
        mut self,
        acquire_timeouts: &'a [u32],
    ) -> Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'a> {
        self.inner.acquire_count = acquire_timeouts.len() as _;
        self.inner.p_acquire_timeouts = acquire_timeouts.as_ptr();
        self
    }
    pub fn release_syncs(
        mut self,
        release_syncs: &'a [DeviceMemory],
    ) -> Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'a> {
        self.inner.release_count = release_syncs.len() as _;
        self.inner.p_release_syncs = release_syncs.as_ptr();
        self
    }
    pub fn release_keys(
        mut self,
        release_keys: &'a [u64],
    ) -> Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'a> {
        self.inner.release_count = release_keys.len() as _;
        self.inner.p_release_keys = release_keys.as_ptr();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> Win32KeyedMutexAcquireReleaseInfoKHR {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceExternalSemaphoreInfo.html>"]
pub struct PhysicalDeviceExternalSemaphoreInfo {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub handle_type: ExternalSemaphoreHandleTypeFlags,
}
impl ::std::default::Default for PhysicalDeviceExternalSemaphoreInfo {
    fn default() -> PhysicalDeviceExternalSemaphoreInfo {
        PhysicalDeviceExternalSemaphoreInfo {
            s_type: StructureType::PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO,
            p_next: ::std::ptr::null(),
            handle_type: ExternalSemaphoreHandleTypeFlags::default(),
        }
    }
}
impl PhysicalDeviceExternalSemaphoreInfo {
    pub fn builder<'a>() -> PhysicalDeviceExternalSemaphoreInfoBuilder<'a> {
        PhysicalDeviceExternalSemaphoreInfoBuilder {
            inner: PhysicalDeviceExternalSemaphoreInfo::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDeviceExternalSemaphoreInfoBuilder<'a> {
    inner: PhysicalDeviceExternalSemaphoreInfo,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsPhysicalDeviceExternalSemaphoreInfo {}
impl<'a> ::std::ops::Deref for PhysicalDeviceExternalSemaphoreInfoBuilder<'a> {
    type Target = PhysicalDeviceExternalSemaphoreInfo;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PhysicalDeviceExternalSemaphoreInfoBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDeviceExternalSemaphoreInfoBuilder<'a> {
    pub fn handle_type(
        mut self,
        handle_type: ExternalSemaphoreHandleTypeFlags,
    ) -> PhysicalDeviceExternalSemaphoreInfoBuilder<'a> {
        self.inner.handle_type = handle_type;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsPhysicalDeviceExternalSemaphoreInfo>(
        mut self,
        next: &'a mut T,
    ) -> PhysicalDeviceExternalSemaphoreInfoBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDeviceExternalSemaphoreInfo {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkExternalSemaphoreProperties.html>"]
pub struct ExternalSemaphoreProperties {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub export_from_imported_handle_types: ExternalSemaphoreHandleTypeFlags,
    pub compatible_handle_types: ExternalSemaphoreHandleTypeFlags,
    pub external_semaphore_features: ExternalSemaphoreFeatureFlags,
}
impl ::std::default::Default for ExternalSemaphoreProperties {
    fn default() -> ExternalSemaphoreProperties {
        ExternalSemaphoreProperties {
            s_type: StructureType::EXTERNAL_SEMAPHORE_PROPERTIES,
            p_next: ::std::ptr::null_mut(),
            export_from_imported_handle_types: ExternalSemaphoreHandleTypeFlags::default(),
            compatible_handle_types: ExternalSemaphoreHandleTypeFlags::default(),
            external_semaphore_features: ExternalSemaphoreFeatureFlags::default(),
        }
    }
}
impl ExternalSemaphoreProperties {
    pub fn builder<'a>() -> ExternalSemaphorePropertiesBuilder<'a> {
        ExternalSemaphorePropertiesBuilder {
            inner: ExternalSemaphoreProperties::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct ExternalSemaphorePropertiesBuilder<'a> {
    inner: ExternalSemaphoreProperties,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsExternalSemaphoreProperties {}
impl<'a> ::std::ops::Deref for ExternalSemaphorePropertiesBuilder<'a> {
    type Target = ExternalSemaphoreProperties;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for ExternalSemaphorePropertiesBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> ExternalSemaphorePropertiesBuilder<'a> {
    pub fn export_from_imported_handle_types(
        mut self,
        export_from_imported_handle_types: ExternalSemaphoreHandleTypeFlags,
    ) -> ExternalSemaphorePropertiesBuilder<'a> {
        self.inner.export_from_imported_handle_types = export_from_imported_handle_types;
        self
    }
    pub fn compatible_handle_types(
        mut self,
        compatible_handle_types: ExternalSemaphoreHandleTypeFlags,
    ) -> ExternalSemaphorePropertiesBuilder<'a> {
        self.inner.compatible_handle_types = compatible_handle_types;
        self
    }
    pub fn external_semaphore_features(
        mut self,
        external_semaphore_features: ExternalSemaphoreFeatureFlags,
    ) -> ExternalSemaphorePropertiesBuilder<'a> {
        self.inner.external_semaphore_features = external_semaphore_features;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsExternalSemaphoreProperties>(
        mut self,
        next: &'a mut T,
    ) -> ExternalSemaphorePropertiesBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> ExternalSemaphoreProperties {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkExportSemaphoreCreateInfo.html>"]
pub struct ExportSemaphoreCreateInfo {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub handle_types: ExternalSemaphoreHandleTypeFlags,
}
impl ::std::default::Default for ExportSemaphoreCreateInfo {
    fn default() -> ExportSemaphoreCreateInfo {
        ExportSemaphoreCreateInfo {
            s_type: StructureType::EXPORT_SEMAPHORE_CREATE_INFO,
            p_next: ::std::ptr::null(),
            handle_types: ExternalSemaphoreHandleTypeFlags::default(),
        }
    }
}
impl ExportSemaphoreCreateInfo {
    pub fn builder<'a>() -> ExportSemaphoreCreateInfoBuilder<'a> {
        ExportSemaphoreCreateInfoBuilder {
            inner: ExportSemaphoreCreateInfo::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct ExportSemaphoreCreateInfoBuilder<'a> {
    inner: ExportSemaphoreCreateInfo,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsSemaphoreCreateInfo for ExportSemaphoreCreateInfoBuilder<'_> {}
unsafe impl ExtendsSemaphoreCreateInfo for ExportSemaphoreCreateInfo {}
impl<'a> ::std::ops::Deref for ExportSemaphoreCreateInfoBuilder<'a> {
    type Target = ExportSemaphoreCreateInfo;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for ExportSemaphoreCreateInfoBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> ExportSemaphoreCreateInfoBuilder<'a> {
    pub fn handle_types(
        mut self,
        handle_types: ExternalSemaphoreHandleTypeFlags,
    ) -> ExportSemaphoreCreateInfoBuilder<'a> {
        self.inner.handle_types = handle_types;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> ExportSemaphoreCreateInfo {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImportSemaphoreWin32HandleInfoKHR.html>"]
pub struct ImportSemaphoreWin32HandleInfoKHR {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub semaphore: Semaphore,
    pub flags: SemaphoreImportFlags,
    pub handle_type: ExternalSemaphoreHandleTypeFlags,
    pub handle: HANDLE,
    pub name: LPCWSTR,
}
impl ::std::default::Default for ImportSemaphoreWin32HandleInfoKHR {
    fn default() -> ImportSemaphoreWin32HandleInfoKHR {
        ImportSemaphoreWin32HandleInfoKHR {
            s_type: StructureType::IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR,
            p_next: ::std::ptr::null(),
            semaphore: Semaphore::default(),
            flags: SemaphoreImportFlags::default(),
            handle_type: ExternalSemaphoreHandleTypeFlags::default(),
            handle: unsafe { ::std::mem::zeroed() },
            name: unsafe { ::std::mem::zeroed() },
        }
    }
}
impl ImportSemaphoreWin32HandleInfoKHR {
    pub fn builder<'a>() -> ImportSemaphoreWin32HandleInfoKHRBuilder<'a> {
        ImportSemaphoreWin32HandleInfoKHRBuilder {
            inner: ImportSemaphoreWin32HandleInfoKHR::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct ImportSemaphoreWin32HandleInfoKHRBuilder<'a> {
    inner: ImportSemaphoreWin32HandleInfoKHR,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsImportSemaphoreWin32HandleInfoKHR {}
impl<'a> ::std::ops::Deref for ImportSemaphoreWin32HandleInfoKHRBuilder<'a> {
    type Target = ImportSemaphoreWin32HandleInfoKHR;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for ImportSemaphoreWin32HandleInfoKHRBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> ImportSemaphoreWin32HandleInfoKHRBuilder<'a> {
    pub fn semaphore(
        mut self,
        semaphore: Semaphore,
    ) -> ImportSemaphoreWin32HandleInfoKHRBuilder<'a> {
        self.inner.semaphore = semaphore;
        self
    }
    pub fn flags(
        mut self,
        flags: SemaphoreImportFlags,
    ) -> ImportSemaphoreWin32HandleInfoKHRBuilder<'a> {
        self.inner.flags = flags;
        self
    }
    pub fn handle_type(
        mut self,
        handle_type: ExternalSemaphoreHandleTypeFlags,
    ) -> ImportSemaphoreWin32HandleInfoKHRBuilder<'a> {
        self.inner.handle_type = handle_type;
        self
    }
    pub fn handle(mut self, handle: HANDLE) -> ImportSemaphoreWin32HandleInfoKHRBuilder<'a> {
        self.inner.handle = handle;
        self
    }
    pub fn name(mut self, name: LPCWSTR) -> ImportSemaphoreWin32HandleInfoKHRBuilder<'a> {
        self.inner.name = name;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsImportSemaphoreWin32HandleInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> ImportSemaphoreWin32HandleInfoKHRBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> ImportSemaphoreWin32HandleInfoKHR {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkExportSemaphoreWin32HandleInfoKHR.html>"]
pub struct ExportSemaphoreWin32HandleInfoKHR {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub p_attributes: *const SECURITY_ATTRIBUTES,
    pub dw_access: DWORD,
    pub name: LPCWSTR,
}
impl ::std::default::Default for ExportSemaphoreWin32HandleInfoKHR {
    fn default() -> ExportSemaphoreWin32HandleInfoKHR {
        ExportSemaphoreWin32HandleInfoKHR {
            s_type: StructureType::EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR,
            p_next: ::std::ptr::null(),
            p_attributes: ::std::ptr::null(),
            dw_access: DWORD::default(),
            name: unsafe { ::std::mem::zeroed() },
        }
    }
}
impl ExportSemaphoreWin32HandleInfoKHR {
    pub fn builder<'a>() -> ExportSemaphoreWin32HandleInfoKHRBuilder<'a> {
        ExportSemaphoreWin32HandleInfoKHRBuilder {
            inner: ExportSemaphoreWin32HandleInfoKHR::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct ExportSemaphoreWin32HandleInfoKHRBuilder<'a> {
    inner: ExportSemaphoreWin32HandleInfoKHR,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsSemaphoreCreateInfo for ExportSemaphoreWin32HandleInfoKHRBuilder<'_> {}
unsafe impl ExtendsSemaphoreCreateInfo for ExportSemaphoreWin32HandleInfoKHR {}
impl<'a> ::std::ops::Deref for ExportSemaphoreWin32HandleInfoKHRBuilder<'a> {
    type Target = ExportSemaphoreWin32HandleInfoKHR;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for ExportSemaphoreWin32HandleInfoKHRBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> ExportSemaphoreWin32HandleInfoKHRBuilder<'a> {
    pub fn attributes(
        mut self,
        attributes: &'a SECURITY_ATTRIBUTES,
    ) -> ExportSemaphoreWin32HandleInfoKHRBuilder<'a> {
        self.inner.p_attributes = attributes;
        self
    }
    pub fn dw_access(mut self, dw_access: DWORD) -> ExportSemaphoreWin32HandleInfoKHRBuilder<'a> {
        self.inner.dw_access = dw_access;
        self
    }
    pub fn name(mut self, name: LPCWSTR) -> ExportSemaphoreWin32HandleInfoKHRBuilder<'a> {
        self.inner.name = name;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> ExportSemaphoreWin32HandleInfoKHR {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkD3D12FenceSubmitInfoKHR.html>"]
pub struct D3D12FenceSubmitInfoKHR {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub wait_semaphore_values_count: u32,
    pub p_wait_semaphore_values: *const u64,
    pub signal_semaphore_values_count: u32,
    pub p_signal_semaphore_values: *const u64,
}
impl ::std::default::Default for D3D12FenceSubmitInfoKHR {
    fn default() -> D3D12FenceSubmitInfoKHR {
        D3D12FenceSubmitInfoKHR {
            s_type: StructureType::D3D12_FENCE_SUBMIT_INFO_KHR,
            p_next: ::std::ptr::null(),
            wait_semaphore_values_count: u32::default(),
            p_wait_semaphore_values: ::std::ptr::null(),
            signal_semaphore_values_count: u32::default(),
            p_signal_semaphore_values: ::std::ptr::null(),
        }
    }
}
impl D3D12FenceSubmitInfoKHR {
    pub fn builder<'a>() -> D3D12FenceSubmitInfoKHRBuilder<'a> {
        D3D12FenceSubmitInfoKHRBuilder {
            inner: D3D12FenceSubmitInfoKHR::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct D3D12FenceSubmitInfoKHRBuilder<'a> {
    inner: D3D12FenceSubmitInfoKHR,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsSubmitInfo for D3D12FenceSubmitInfoKHRBuilder<'_> {}
unsafe impl ExtendsSubmitInfo for D3D12FenceSubmitInfoKHR {}
impl<'a> ::std::ops::Deref for D3D12FenceSubmitInfoKHRBuilder<'a> {
    type Target = D3D12FenceSubmitInfoKHR;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for D3D12FenceSubmitInfoKHRBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> D3D12FenceSubmitInfoKHRBuilder<'a> {
    pub fn wait_semaphore_values(
        mut self,
        wait_semaphore_values: &'a [u64],
    ) -> D3D12FenceSubmitInfoKHRBuilder<'a> {
        self.inner.wait_semaphore_values_count = wait_semaphore_values.len() as _;
        self.inner.p_wait_semaphore_values = wait_semaphore_values.as_ptr();
        self
    }
    pub fn signal_semaphore_values(
        mut self,
        signal_semaphore_values: &'a [u64],
    ) -> D3D12FenceSubmitInfoKHRBuilder<'a> {
        self.inner.signal_semaphore_values_count = signal_semaphore_values.len() as _;
        self.inner.p_signal_semaphore_values = signal_semaphore_values.as_ptr();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> D3D12FenceSubmitInfoKHR {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSemaphoreGetWin32HandleInfoKHR.html>"]
pub struct SemaphoreGetWin32HandleInfoKHR {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub semaphore: Semaphore,
    pub handle_type: ExternalSemaphoreHandleTypeFlags,
}
impl ::std::default::Default for SemaphoreGetWin32HandleInfoKHR {
    fn default() -> SemaphoreGetWin32HandleInfoKHR {
        SemaphoreGetWin32HandleInfoKHR {
            s_type: StructureType::SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR,
            p_next: ::std::ptr::null(),
            semaphore: Semaphore::default(),
            handle_type: ExternalSemaphoreHandleTypeFlags::default(),
        }
    }
}
impl SemaphoreGetWin32HandleInfoKHR {
    pub fn builder<'a>() -> SemaphoreGetWin32HandleInfoKHRBuilder<'a> {
        SemaphoreGetWin32HandleInfoKHRBuilder {
            inner: SemaphoreGetWin32HandleInfoKHR::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct SemaphoreGetWin32HandleInfoKHRBuilder<'a> {
    inner: SemaphoreGetWin32HandleInfoKHR,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsSemaphoreGetWin32HandleInfoKHR {}
impl<'a> ::std::ops::Deref for SemaphoreGetWin32HandleInfoKHRBuilder<'a> {
    type Target = SemaphoreGetWin32HandleInfoKHR;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for SemaphoreGetWin32HandleInfoKHRBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> SemaphoreGetWin32HandleInfoKHRBuilder<'a> {
    pub fn semaphore(mut self, semaphore: Semaphore) -> SemaphoreGetWin32HandleInfoKHRBuilder<'a> {
        self.inner.semaphore = semaphore;
        self
    }
    pub fn handle_type(
        mut self,
        handle_type: ExternalSemaphoreHandleTypeFlags,
    ) -> SemaphoreGetWin32HandleInfoKHRBuilder<'a> {
        self.inner.handle_type = handle_type;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsSemaphoreGetWin32HandleInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> SemaphoreGetWin32HandleInfoKHRBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> SemaphoreGetWin32HandleInfoKHR {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImportSemaphoreFdInfoKHR.html>"]
pub struct ImportSemaphoreFdInfoKHR {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub semaphore: Semaphore,
    pub flags: SemaphoreImportFlags,
    pub handle_type: ExternalSemaphoreHandleTypeFlags,
    pub fd: c_int,
}
impl ::std::default::Default for ImportSemaphoreFdInfoKHR {
    fn default() -> ImportSemaphoreFdInfoKHR {
        ImportSemaphoreFdInfoKHR {
            s_type: StructureType::IMPORT_SEMAPHORE_FD_INFO_KHR,
            p_next: ::std::ptr::null(),
            semaphore: Semaphore::default(),
            flags: SemaphoreImportFlags::default(),
            handle_type: ExternalSemaphoreHandleTypeFlags::default(),
            fd: c_int::default(),
        }
    }
}
impl ImportSemaphoreFdInfoKHR {
    pub fn builder<'a>() -> ImportSemaphoreFdInfoKHRBuilder<'a> {
        ImportSemaphoreFdInfoKHRBuilder {
            inner: ImportSemaphoreFdInfoKHR::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct ImportSemaphoreFdInfoKHRBuilder<'a> {
    inner: ImportSemaphoreFdInfoKHR,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsImportSemaphoreFdInfoKHR {}
impl<'a> ::std::ops::Deref for ImportSemaphoreFdInfoKHRBuilder<'a> {
    type Target = ImportSemaphoreFdInfoKHR;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for ImportSemaphoreFdInfoKHRBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> ImportSemaphoreFdInfoKHRBuilder<'a> {
    pub fn semaphore(mut self, semaphore: Semaphore) -> ImportSemaphoreFdInfoKHRBuilder<'a> {
        self.inner.semaphore = semaphore;
        self
    }
    pub fn flags(mut self, flags: SemaphoreImportFlags) -> ImportSemaphoreFdInfoKHRBuilder<'a> {
        self.inner.flags = flags;
        self
    }
    pub fn handle_type(
        mut self,
        handle_type: ExternalSemaphoreHandleTypeFlags,
    ) -> ImportSemaphoreFdInfoKHRBuilder<'a> {
        self.inner.handle_type = handle_type;
        self
    }
    pub fn fd(mut self, fd: c_int) -> ImportSemaphoreFdInfoKHRBuilder<'a> {
        self.inner.fd = fd;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsImportSemaphoreFdInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> ImportSemaphoreFdInfoKHRBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> ImportSemaphoreFdInfoKHR {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSemaphoreGetFdInfoKHR.html>"]
pub struct SemaphoreGetFdInfoKHR {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub semaphore: Semaphore,
    pub handle_type: ExternalSemaphoreHandleTypeFlags,
}
impl ::std::default::Default for SemaphoreGetFdInfoKHR {
    fn default() -> SemaphoreGetFdInfoKHR {
        SemaphoreGetFdInfoKHR {
            s_type: StructureType::SEMAPHORE_GET_FD_INFO_KHR,
            p_next: ::std::ptr::null(),
            semaphore: Semaphore::default(),
            handle_type: ExternalSemaphoreHandleTypeFlags::default(),
        }
    }
}
impl SemaphoreGetFdInfoKHR {
    pub fn builder<'a>() -> SemaphoreGetFdInfoKHRBuilder<'a> {
        SemaphoreGetFdInfoKHRBuilder {
            inner: SemaphoreGetFdInfoKHR::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct SemaphoreGetFdInfoKHRBuilder<'a> {
    inner: SemaphoreGetFdInfoKHR,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsSemaphoreGetFdInfoKHR {}
impl<'a> ::std::ops::Deref for SemaphoreGetFdInfoKHRBuilder<'a> {
    type Target = SemaphoreGetFdInfoKHR;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for SemaphoreGetFdInfoKHRBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> SemaphoreGetFdInfoKHRBuilder<'a> {
    pub fn semaphore(mut self, semaphore: Semaphore) -> SemaphoreGetFdInfoKHRBuilder<'a> {
        self.inner.semaphore = semaphore;
        self
    }
    pub fn handle_type(
        mut self,
        handle_type: ExternalSemaphoreHandleTypeFlags,
    ) -> SemaphoreGetFdInfoKHRBuilder<'a> {
        self.inner.handle_type = handle_type;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsSemaphoreGetFdInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> SemaphoreGetFdInfoKHRBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> SemaphoreGetFdInfoKHR {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceExternalFenceInfo.html>"]
pub struct PhysicalDeviceExternalFenceInfo {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub handle_type: ExternalFenceHandleTypeFlags,
}
impl ::std::default::Default for PhysicalDeviceExternalFenceInfo {
    fn default() -> PhysicalDeviceExternalFenceInfo {
        PhysicalDeviceExternalFenceInfo {
            s_type: StructureType::PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO,
            p_next: ::std::ptr::null(),
            handle_type: ExternalFenceHandleTypeFlags::default(),
        }
    }
}
impl PhysicalDeviceExternalFenceInfo {
    pub fn builder<'a>() -> PhysicalDeviceExternalFenceInfoBuilder<'a> {
        PhysicalDeviceExternalFenceInfoBuilder {
            inner: PhysicalDeviceExternalFenceInfo::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDeviceExternalFenceInfoBuilder<'a> {
    inner: PhysicalDeviceExternalFenceInfo,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsPhysicalDeviceExternalFenceInfo {}
impl<'a> ::std::ops::Deref for PhysicalDeviceExternalFenceInfoBuilder<'a> {
    type Target = PhysicalDeviceExternalFenceInfo;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PhysicalDeviceExternalFenceInfoBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDeviceExternalFenceInfoBuilder<'a> {
    pub fn handle_type(
        mut self,
        handle_type: ExternalFenceHandleTypeFlags,
    ) -> PhysicalDeviceExternalFenceInfoBuilder<'a> {
        self.inner.handle_type = handle_type;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsPhysicalDeviceExternalFenceInfo>(
        mut self,
        next: &'a mut T,
    ) -> PhysicalDeviceExternalFenceInfoBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDeviceExternalFenceInfo {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkExternalFenceProperties.html>"]
pub struct ExternalFenceProperties {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub export_from_imported_handle_types: ExternalFenceHandleTypeFlags,
    pub compatible_handle_types: ExternalFenceHandleTypeFlags,
    pub external_fence_features: ExternalFenceFeatureFlags,
}
impl ::std::default::Default for ExternalFenceProperties {
    fn default() -> ExternalFenceProperties {
        ExternalFenceProperties {
            s_type: StructureType::EXTERNAL_FENCE_PROPERTIES,
            p_next: ::std::ptr::null_mut(),
            export_from_imported_handle_types: ExternalFenceHandleTypeFlags::default(),
            compatible_handle_types: ExternalFenceHandleTypeFlags::default(),
            external_fence_features: ExternalFenceFeatureFlags::default(),
        }
    }
}
impl ExternalFenceProperties {
    pub fn builder<'a>() -> ExternalFencePropertiesBuilder<'a> {
        ExternalFencePropertiesBuilder {
            inner: ExternalFenceProperties::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct ExternalFencePropertiesBuilder<'a> {
    inner: ExternalFenceProperties,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsExternalFenceProperties {}
impl<'a> ::std::ops::Deref for ExternalFencePropertiesBuilder<'a> {
    type Target = ExternalFenceProperties;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for ExternalFencePropertiesBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> ExternalFencePropertiesBuilder<'a> {
    pub fn export_from_imported_handle_types(
        mut self,
        export_from_imported_handle_types: ExternalFenceHandleTypeFlags,
    ) -> ExternalFencePropertiesBuilder<'a> {
        self.inner.export_from_imported_handle_types = export_from_imported_handle_types;
        self
    }
    pub fn compatible_handle_types(
        mut self,
        compatible_handle_types: ExternalFenceHandleTypeFlags,
    ) -> ExternalFencePropertiesBuilder<'a> {
        self.inner.compatible_handle_types = compatible_handle_types;
        self
    }
    pub fn external_fence_features(
        mut self,
        external_fence_features: ExternalFenceFeatureFlags,
    ) -> ExternalFencePropertiesBuilder<'a> {
        self.inner.external_fence_features = external_fence_features;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsExternalFenceProperties>(
        mut self,
        next: &'a mut T,
    ) -> ExternalFencePropertiesBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> ExternalFenceProperties {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkExportFenceCreateInfo.html>"]
pub struct ExportFenceCreateInfo {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub handle_types: ExternalFenceHandleTypeFlags,
}
impl ::std::default::Default for ExportFenceCreateInfo {
    fn default() -> ExportFenceCreateInfo {
        ExportFenceCreateInfo {
            s_type: StructureType::EXPORT_FENCE_CREATE_INFO,
            p_next: ::std::ptr::null(),
            handle_types: ExternalFenceHandleTypeFlags::default(),
        }
    }
}
impl ExportFenceCreateInfo {
    pub fn builder<'a>() -> ExportFenceCreateInfoBuilder<'a> {
        ExportFenceCreateInfoBuilder {
            inner: ExportFenceCreateInfo::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct ExportFenceCreateInfoBuilder<'a> {
    inner: ExportFenceCreateInfo,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsFenceCreateInfo for ExportFenceCreateInfoBuilder<'_> {}
unsafe impl ExtendsFenceCreateInfo for ExportFenceCreateInfo {}
impl<'a> ::std::ops::Deref for ExportFenceCreateInfoBuilder<'a> {
    type Target = ExportFenceCreateInfo;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for ExportFenceCreateInfoBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> ExportFenceCreateInfoBuilder<'a> {
    pub fn handle_types(
        mut self,
        handle_types: ExternalFenceHandleTypeFlags,
    ) -> ExportFenceCreateInfoBuilder<'a> {
        self.inner.handle_types = handle_types;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> ExportFenceCreateInfo {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImportFenceWin32HandleInfoKHR.html>"]
pub struct ImportFenceWin32HandleInfoKHR {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub fence: Fence,
    pub flags: FenceImportFlags,
    pub handle_type: ExternalFenceHandleTypeFlags,
    pub handle: HANDLE,
    pub name: LPCWSTR,
}
impl ::std::default::Default for ImportFenceWin32HandleInfoKHR {
    fn default() -> ImportFenceWin32HandleInfoKHR {
        ImportFenceWin32HandleInfoKHR {
            s_type: StructureType::IMPORT_FENCE_WIN32_HANDLE_INFO_KHR,
            p_next: ::std::ptr::null(),
            fence: Fence::default(),
            flags: FenceImportFlags::default(),
            handle_type: ExternalFenceHandleTypeFlags::default(),
            handle: unsafe { ::std::mem::zeroed() },
            name: unsafe { ::std::mem::zeroed() },
        }
    }
}
impl ImportFenceWin32HandleInfoKHR {
    pub fn builder<'a>() -> ImportFenceWin32HandleInfoKHRBuilder<'a> {
        ImportFenceWin32HandleInfoKHRBuilder {
            inner: ImportFenceWin32HandleInfoKHR::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct ImportFenceWin32HandleInfoKHRBuilder<'a> {
    inner: ImportFenceWin32HandleInfoKHR,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsImportFenceWin32HandleInfoKHR {}
impl<'a> ::std::ops::Deref for ImportFenceWin32HandleInfoKHRBuilder<'a> {
    type Target = ImportFenceWin32HandleInfoKHR;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for ImportFenceWin32HandleInfoKHRBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> ImportFenceWin32HandleInfoKHRBuilder<'a> {
    pub fn fence(mut self, fence: Fence) -> ImportFenceWin32HandleInfoKHRBuilder<'a> {
        self.inner.fence = fence;
        self
    }
    pub fn flags(mut self, flags: FenceImportFlags) -> ImportFenceWin32HandleInfoKHRBuilder<'a> {
        self.inner.flags = flags;
        self
    }
    pub fn handle_type(
        mut self,
        handle_type: ExternalFenceHandleTypeFlags,
    ) -> ImportFenceWin32HandleInfoKHRBuilder<'a> {
        self.inner.handle_type = handle_type;
        self
    }
    pub fn handle(mut self, handle: HANDLE) -> ImportFenceWin32HandleInfoKHRBuilder<'a> {
        self.inner.handle = handle;
        self
    }
    pub fn name(mut self, name: LPCWSTR) -> ImportFenceWin32HandleInfoKHRBuilder<'a> {
        self.inner.name = name;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsImportFenceWin32HandleInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> ImportFenceWin32HandleInfoKHRBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> ImportFenceWin32HandleInfoKHR {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkExportFenceWin32HandleInfoKHR.html>"]
pub struct ExportFenceWin32HandleInfoKHR {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub p_attributes: *const SECURITY_ATTRIBUTES,
    pub dw_access: DWORD,
    pub name: LPCWSTR,
}
impl ::std::default::Default for ExportFenceWin32HandleInfoKHR {
    fn default() -> ExportFenceWin32HandleInfoKHR {
        ExportFenceWin32HandleInfoKHR {
            s_type: StructureType::EXPORT_FENCE_WIN32_HANDLE_INFO_KHR,
            p_next: ::std::ptr::null(),
            p_attributes: ::std::ptr::null(),
            dw_access: DWORD::default(),
            name: unsafe { ::std::mem::zeroed() },
        }
    }
}
impl ExportFenceWin32HandleInfoKHR {
    pub fn builder<'a>() -> ExportFenceWin32HandleInfoKHRBuilder<'a> {
        ExportFenceWin32HandleInfoKHRBuilder {
            inner: ExportFenceWin32HandleInfoKHR::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct ExportFenceWin32HandleInfoKHRBuilder<'a> {
    inner: ExportFenceWin32HandleInfoKHR,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsFenceCreateInfo for ExportFenceWin32HandleInfoKHRBuilder<'_> {}
unsafe impl ExtendsFenceCreateInfo for ExportFenceWin32HandleInfoKHR {}
impl<'a> ::std::ops::Deref for ExportFenceWin32HandleInfoKHRBuilder<'a> {
    type Target = ExportFenceWin32HandleInfoKHR;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for ExportFenceWin32HandleInfoKHRBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> ExportFenceWin32HandleInfoKHRBuilder<'a> {
    pub fn attributes(
        mut self,
        attributes: &'a SECURITY_ATTRIBUTES,
    ) -> ExportFenceWin32HandleInfoKHRBuilder<'a> {
        self.inner.p_attributes = attributes;
        self
    }
    pub fn dw_access(mut self, dw_access: DWORD) -> ExportFenceWin32HandleInfoKHRBuilder<'a> {
        self.inner.dw_access = dw_access;
        self
    }
    pub fn name(mut self, name: LPCWSTR) -> ExportFenceWin32HandleInfoKHRBuilder<'a> {
        self.inner.name = name;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> ExportFenceWin32HandleInfoKHR {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkFenceGetWin32HandleInfoKHR.html>"]
pub struct FenceGetWin32HandleInfoKHR {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub fence: Fence,
    pub handle_type: ExternalFenceHandleTypeFlags,
}
impl ::std::default::Default for FenceGetWin32HandleInfoKHR {
    fn default() -> FenceGetWin32HandleInfoKHR {
        FenceGetWin32HandleInfoKHR {
            s_type: StructureType::FENCE_GET_WIN32_HANDLE_INFO_KHR,
            p_next: ::std::ptr::null(),
            fence: Fence::default(),
            handle_type: ExternalFenceHandleTypeFlags::default(),
        }
    }
}
impl FenceGetWin32HandleInfoKHR {
    pub fn builder<'a>() -> FenceGetWin32HandleInfoKHRBuilder<'a> {
        FenceGetWin32HandleInfoKHRBuilder {
            inner: FenceGetWin32HandleInfoKHR::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct FenceGetWin32HandleInfoKHRBuilder<'a> {
    inner: FenceGetWin32HandleInfoKHR,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsFenceGetWin32HandleInfoKHR {}
impl<'a> ::std::ops::Deref for FenceGetWin32HandleInfoKHRBuilder<'a> {
    type Target = FenceGetWin32HandleInfoKHR;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for FenceGetWin32HandleInfoKHRBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> FenceGetWin32HandleInfoKHRBuilder<'a> {
    pub fn fence(mut self, fence: Fence) -> FenceGetWin32HandleInfoKHRBuilder<'a> {
        self.inner.fence = fence;
        self
    }
    pub fn handle_type(
        mut self,
        handle_type: ExternalFenceHandleTypeFlags,
    ) -> FenceGetWin32HandleInfoKHRBuilder<'a> {
        self.inner.handle_type = handle_type;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsFenceGetWin32HandleInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> FenceGetWin32HandleInfoKHRBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> FenceGetWin32HandleInfoKHR {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImportFenceFdInfoKHR.html>"]
pub struct ImportFenceFdInfoKHR {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub fence: Fence,
    pub flags: FenceImportFlags,
    pub handle_type: ExternalFenceHandleTypeFlags,
    pub fd: c_int,
}
impl ::std::default::Default for ImportFenceFdInfoKHR {
    fn default() -> ImportFenceFdInfoKHR {
        ImportFenceFdInfoKHR {
            s_type: StructureType::IMPORT_FENCE_FD_INFO_KHR,
            p_next: ::std::ptr::null(),
            fence: Fence::default(),
            flags: FenceImportFlags::default(),
            handle_type: ExternalFenceHandleTypeFlags::default(),
            fd: c_int::default(),
        }
    }
}
impl ImportFenceFdInfoKHR {
    pub fn builder<'a>() -> ImportFenceFdInfoKHRBuilder<'a> {
        ImportFenceFdInfoKHRBuilder {
            inner: ImportFenceFdInfoKHR::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct ImportFenceFdInfoKHRBuilder<'a> {
    inner: ImportFenceFdInfoKHR,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsImportFenceFdInfoKHR {}
impl<'a> ::std::ops::Deref for ImportFenceFdInfoKHRBuilder<'a> {
    type Target = ImportFenceFdInfoKHR;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for ImportFenceFdInfoKHRBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> ImportFenceFdInfoKHRBuilder<'a> {
    pub fn fence(mut self, fence: Fence) -> ImportFenceFdInfoKHRBuilder<'a> {
        self.inner.fence = fence;
        self
    }
    pub fn flags(mut self, flags: FenceImportFlags) -> ImportFenceFdInfoKHRBuilder<'a> {
        self.inner.flags = flags;
        self
    }
    pub fn handle_type(
        mut self,
        handle_type: ExternalFenceHandleTypeFlags,
    ) -> ImportFenceFdInfoKHRBuilder<'a> {
        self.inner.handle_type = handle_type;
        self
    }
    pub fn fd(mut self, fd: c_int) -> ImportFenceFdInfoKHRBuilder<'a> {
        self.inner.fd = fd;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsImportFenceFdInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> ImportFenceFdInfoKHRBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> ImportFenceFdInfoKHR {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkFenceGetFdInfoKHR.html>"]
pub struct FenceGetFdInfoKHR {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub fence: Fence,
    pub handle_type: ExternalFenceHandleTypeFlags,
}
impl ::std::default::Default for FenceGetFdInfoKHR {
    fn default() -> FenceGetFdInfoKHR {
        FenceGetFdInfoKHR {
            s_type: StructureType::FENCE_GET_FD_INFO_KHR,
            p_next: ::std::ptr::null(),
            fence: Fence::default(),
            handle_type: ExternalFenceHandleTypeFlags::default(),
        }
    }
}
impl FenceGetFdInfoKHR {
    pub fn builder<'a>() -> FenceGetFdInfoKHRBuilder<'a> {
        FenceGetFdInfoKHRBuilder {
            inner: FenceGetFdInfoKHR::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct FenceGetFdInfoKHRBuilder<'a> {
    inner: FenceGetFdInfoKHR,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsFenceGetFdInfoKHR {}
impl<'a> ::std::ops::Deref for FenceGetFdInfoKHRBuilder<'a> {
    type Target = FenceGetFdInfoKHR;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for FenceGetFdInfoKHRBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> FenceGetFdInfoKHRBuilder<'a> {
    pub fn fence(mut self, fence: Fence) -> FenceGetFdInfoKHRBuilder<'a> {
        self.inner.fence = fence;
        self
    }
    pub fn handle_type(
        mut self,
        handle_type: ExternalFenceHandleTypeFlags,
    ) -> FenceGetFdInfoKHRBuilder<'a> {
        self.inner.handle_type = handle_type;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsFenceGetFdInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> FenceGetFdInfoKHRBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> FenceGetFdInfoKHR {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceMultiviewFeatures.html>"]
pub struct PhysicalDeviceMultiviewFeatures {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub multiview: Bool32,
    pub multiview_geometry_shader: Bool32,
    pub multiview_tessellation_shader: Bool32,
}
impl ::std::default::Default for PhysicalDeviceMultiviewFeatures {
    fn default() -> PhysicalDeviceMultiviewFeatures {
        PhysicalDeviceMultiviewFeatures {
            s_type: StructureType::PHYSICAL_DEVICE_MULTIVIEW_FEATURES,
            p_next: ::std::ptr::null_mut(),
            multiview: Bool32::default(),
            multiview_geometry_shader: Bool32::default(),
            multiview_tessellation_shader: Bool32::default(),
        }
    }
}
impl PhysicalDeviceMultiviewFeatures {
    pub fn builder<'a>() -> PhysicalDeviceMultiviewFeaturesBuilder<'a> {
        PhysicalDeviceMultiviewFeaturesBuilder {
            inner: PhysicalDeviceMultiviewFeatures::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDeviceMultiviewFeaturesBuilder<'a> {
    inner: PhysicalDeviceMultiviewFeatures,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMultiviewFeaturesBuilder<'_> {}
unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMultiviewFeatures {}
impl<'a> ::std::ops::Deref for PhysicalDeviceMultiviewFeaturesBuilder<'a> {
    type Target = PhysicalDeviceMultiviewFeatures;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PhysicalDeviceMultiviewFeaturesBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDeviceMultiviewFeaturesBuilder<'a> {
    pub fn multiview(mut self, multiview: bool) -> PhysicalDeviceMultiviewFeaturesBuilder<'a> {
        self.inner.multiview = multiview.into();
        self
    }
    pub fn multiview_geometry_shader(
        mut self,
        multiview_geometry_shader: bool,
    ) -> PhysicalDeviceMultiviewFeaturesBuilder<'a> {
        self.inner.multiview_geometry_shader = multiview_geometry_shader.into();
        self
    }
    pub fn multiview_tessellation_shader(
        mut self,
        multiview_tessellation_shader: bool,
    ) -> PhysicalDeviceMultiviewFeaturesBuilder<'a> {
        self.inner.multiview_tessellation_shader = multiview_tessellation_shader.into();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDeviceMultiviewFeatures {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceMultiviewProperties.html>"]
pub struct PhysicalDeviceMultiviewProperties {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub max_multiview_view_count: u32,
    pub max_multiview_instance_index: u32,
}
impl ::std::default::Default for PhysicalDeviceMultiviewProperties {
    fn default() -> PhysicalDeviceMultiviewProperties {
        PhysicalDeviceMultiviewProperties {
            s_type: StructureType::PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES,
            p_next: ::std::ptr::null_mut(),
            max_multiview_view_count: u32::default(),
            max_multiview_instance_index: u32::default(),
        }
    }
}
impl PhysicalDeviceMultiviewProperties {
    pub fn builder<'a>() -> PhysicalDeviceMultiviewPropertiesBuilder<'a> {
        PhysicalDeviceMultiviewPropertiesBuilder {
            inner: PhysicalDeviceMultiviewProperties::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDeviceMultiviewPropertiesBuilder<'a> {
    inner: PhysicalDeviceMultiviewProperties,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMultiviewPropertiesBuilder<'_> {}
unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMultiviewProperties {}
impl<'a> ::std::ops::Deref for PhysicalDeviceMultiviewPropertiesBuilder<'a> {
    type Target = PhysicalDeviceMultiviewProperties;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PhysicalDeviceMultiviewPropertiesBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDeviceMultiviewPropertiesBuilder<'a> {
    pub fn max_multiview_view_count(
        mut self,
        max_multiview_view_count: u32,
    ) -> PhysicalDeviceMultiviewPropertiesBuilder<'a> {
        self.inner.max_multiview_view_count = max_multiview_view_count;
        self
    }
    pub fn max_multiview_instance_index(
        mut self,
        max_multiview_instance_index: u32,
    ) -> PhysicalDeviceMultiviewPropertiesBuilder<'a> {
        self.inner.max_multiview_instance_index = max_multiview_instance_index;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDeviceMultiviewProperties {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkRenderPassMultiviewCreateInfo.html>"]
pub struct RenderPassMultiviewCreateInfo {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub subpass_count: u32,
    pub p_view_masks: *const u32,
    pub dependency_count: u32,
    pub p_view_offsets: *const i32,
    pub correlation_mask_count: u32,
    pub p_correlation_masks: *const u32,
}
impl ::std::default::Default for RenderPassMultiviewCreateInfo {
    fn default() -> RenderPassMultiviewCreateInfo {
        RenderPassMultiviewCreateInfo {
            s_type: StructureType::RENDER_PASS_MULTIVIEW_CREATE_INFO,
            p_next: ::std::ptr::null(),
            subpass_count: u32::default(),
            p_view_masks: ::std::ptr::null(),
            dependency_count: u32::default(),
            p_view_offsets: ::std::ptr::null(),
            correlation_mask_count: u32::default(),
            p_correlation_masks: ::std::ptr::null(),
        }
    }
}
impl RenderPassMultiviewCreateInfo {
    pub fn builder<'a>() -> RenderPassMultiviewCreateInfoBuilder<'a> {
        RenderPassMultiviewCreateInfoBuilder {
            inner: RenderPassMultiviewCreateInfo::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct RenderPassMultiviewCreateInfoBuilder<'a> {
    inner: RenderPassMultiviewCreateInfo,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsRenderPassCreateInfo for RenderPassMultiviewCreateInfoBuilder<'_> {}
unsafe impl ExtendsRenderPassCreateInfo for RenderPassMultiviewCreateInfo {}
impl<'a> ::std::ops::Deref for RenderPassMultiviewCreateInfoBuilder<'a> {
    type Target = RenderPassMultiviewCreateInfo;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for RenderPassMultiviewCreateInfoBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> RenderPassMultiviewCreateInfoBuilder<'a> {
    pub fn view_masks(mut self, view_masks: &'a [u32]) -> RenderPassMultiviewCreateInfoBuilder<'a> {
        self.inner.subpass_count = view_masks.len() as _;
        self.inner.p_view_masks = view_masks.as_ptr();
        self
    }
    pub fn view_offsets(
        mut self,
        view_offsets: &'a [i32],
    ) -> RenderPassMultiviewCreateInfoBuilder<'a> {
        self.inner.dependency_count = view_offsets.len() as _;
        self.inner.p_view_offsets = view_offsets.as_ptr();
        self
    }
    pub fn correlation_masks(
        mut self,
        correlation_masks: &'a [u32],
    ) -> RenderPassMultiviewCreateInfoBuilder<'a> {
        self.inner.correlation_mask_count = correlation_masks.len() as _;
        self.inner.p_correlation_masks = correlation_masks.as_ptr();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> RenderPassMultiviewCreateInfo {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSurfaceCapabilities2EXT.html>"]
pub struct SurfaceCapabilities2EXT {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub min_image_count: u32,
    pub max_image_count: u32,
    pub current_extent: Extent2D,
    pub min_image_extent: Extent2D,
    pub max_image_extent: Extent2D,
    pub max_image_array_layers: u32,
    pub supported_transforms: SurfaceTransformFlagsKHR,
    pub current_transform: SurfaceTransformFlagsKHR,
    pub supported_composite_alpha: CompositeAlphaFlagsKHR,
    pub supported_usage_flags: ImageUsageFlags,
    pub supported_surface_counters: SurfaceCounterFlagsEXT,
}
impl ::std::default::Default for SurfaceCapabilities2EXT {
    fn default() -> SurfaceCapabilities2EXT {
        SurfaceCapabilities2EXT {
            s_type: StructureType::SURFACE_CAPABILITIES_2_EXT,
            p_next: ::std::ptr::null_mut(),
            min_image_count: u32::default(),
            max_image_count: u32::default(),
            current_extent: Extent2D::default(),
            min_image_extent: Extent2D::default(),
            max_image_extent: Extent2D::default(),
            max_image_array_layers: u32::default(),
            supported_transforms: SurfaceTransformFlagsKHR::default(),
            current_transform: SurfaceTransformFlagsKHR::default(),
            supported_composite_alpha: CompositeAlphaFlagsKHR::default(),
            supported_usage_flags: ImageUsageFlags::default(),
            supported_surface_counters: SurfaceCounterFlagsEXT::default(),
        }
    }
}
impl SurfaceCapabilities2EXT {
    pub fn builder<'a>() -> SurfaceCapabilities2EXTBuilder<'a> {
        SurfaceCapabilities2EXTBuilder {
            inner: SurfaceCapabilities2EXT::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct SurfaceCapabilities2EXTBuilder<'a> {
    inner: SurfaceCapabilities2EXT,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsSurfaceCapabilities2EXT {}
impl<'a> ::std::ops::Deref for SurfaceCapabilities2EXTBuilder<'a> {
    type Target = SurfaceCapabilities2EXT;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for SurfaceCapabilities2EXTBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> SurfaceCapabilities2EXTBuilder<'a> {
    pub fn min_image_count(mut self, min_image_count: u32) -> SurfaceCapabilities2EXTBuilder<'a> {
        self.inner.min_image_count = min_image_count;
        self
    }
    pub fn max_image_count(mut self, max_image_count: u32) -> SurfaceCapabilities2EXTBuilder<'a> {
        self.inner.max_image_count = max_image_count;
        self
    }
    pub fn current_extent(
        mut self,
        current_extent: Extent2D,
    ) -> SurfaceCapabilities2EXTBuilder<'a> {
        self.inner.current_extent = current_extent;
        self
    }
    pub fn min_image_extent(
        mut self,
        min_image_extent: Extent2D,
    ) -> SurfaceCapabilities2EXTBuilder<'a> {
        self.inner.min_image_extent = min_image_extent;
        self
    }
    pub fn max_image_extent(
        mut self,
        max_image_extent: Extent2D,
    ) -> SurfaceCapabilities2EXTBuilder<'a> {
        self.inner.max_image_extent = max_image_extent;
        self
    }
    pub fn max_image_array_layers(
        mut self,
        max_image_array_layers: u32,
    ) -> SurfaceCapabilities2EXTBuilder<'a> {
        self.inner.max_image_array_layers = max_image_array_layers;
        self
    }
    pub fn supported_transforms(
        mut self,
        supported_transforms: SurfaceTransformFlagsKHR,
    ) -> SurfaceCapabilities2EXTBuilder<'a> {
        self.inner.supported_transforms = supported_transforms;
        self
    }
    pub fn current_transform(
        mut self,
        current_transform: SurfaceTransformFlagsKHR,
    ) -> SurfaceCapabilities2EXTBuilder<'a> {
        self.inner.current_transform = current_transform;
        self
    }
    pub fn supported_composite_alpha(
        mut self,
        supported_composite_alpha: CompositeAlphaFlagsKHR,
    ) -> SurfaceCapabilities2EXTBuilder<'a> {
        self.inner.supported_composite_alpha = supported_composite_alpha;
        self
    }
    pub fn supported_usage_flags(
        mut self,
        supported_usage_flags: ImageUsageFlags,
    ) -> SurfaceCapabilities2EXTBuilder<'a> {
        self.inner.supported_usage_flags = supported_usage_flags;
        self
    }
    pub fn supported_surface_counters(
        mut self,
        supported_surface_counters: SurfaceCounterFlagsEXT,
    ) -> SurfaceCapabilities2EXTBuilder<'a> {
        self.inner.supported_surface_counters = supported_surface_counters;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsSurfaceCapabilities2EXT>(
        mut self,
        next: &'a mut T,
    ) -> SurfaceCapabilities2EXTBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> SurfaceCapabilities2EXT {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDisplayPowerInfoEXT.html>"]
pub struct DisplayPowerInfoEXT {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub power_state: DisplayPowerStateEXT,
}
impl ::std::default::Default for DisplayPowerInfoEXT {
    fn default() -> DisplayPowerInfoEXT {
        DisplayPowerInfoEXT {
            s_type: StructureType::DISPLAY_POWER_INFO_EXT,
            p_next: ::std::ptr::null(),
            power_state: DisplayPowerStateEXT::default(),
        }
    }
}
impl DisplayPowerInfoEXT {
    pub fn builder<'a>() -> DisplayPowerInfoEXTBuilder<'a> {
        DisplayPowerInfoEXTBuilder {
            inner: DisplayPowerInfoEXT::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct DisplayPowerInfoEXTBuilder<'a> {
    inner: DisplayPowerInfoEXT,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsDisplayPowerInfoEXT {}
impl<'a> ::std::ops::Deref for DisplayPowerInfoEXTBuilder<'a> {
    type Target = DisplayPowerInfoEXT;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for DisplayPowerInfoEXTBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> DisplayPowerInfoEXTBuilder<'a> {
    pub fn power_state(
        mut self,
        power_state: DisplayPowerStateEXT,
    ) -> DisplayPowerInfoEXTBuilder<'a> {
        self.inner.power_state = power_state;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsDisplayPowerInfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> DisplayPowerInfoEXTBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> DisplayPowerInfoEXT {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDeviceEventInfoEXT.html>"]
pub struct DeviceEventInfoEXT {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub device_event: DeviceEventTypeEXT,
}
impl ::std::default::Default for DeviceEventInfoEXT {
    fn default() -> DeviceEventInfoEXT {
        DeviceEventInfoEXT {
            s_type: StructureType::DEVICE_EVENT_INFO_EXT,
            p_next: ::std::ptr::null(),
            device_event: DeviceEventTypeEXT::default(),
        }
    }
}
impl DeviceEventInfoEXT {
    pub fn builder<'a>() -> DeviceEventInfoEXTBuilder<'a> {
        DeviceEventInfoEXTBuilder {
            inner: DeviceEventInfoEXT::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct DeviceEventInfoEXTBuilder<'a> {
    inner: DeviceEventInfoEXT,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsDeviceEventInfoEXT {}
impl<'a> ::std::ops::Deref for DeviceEventInfoEXTBuilder<'a> {
    type Target = DeviceEventInfoEXT;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for DeviceEventInfoEXTBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> DeviceEventInfoEXTBuilder<'a> {
    pub fn device_event(
        mut self,
        device_event: DeviceEventTypeEXT,
    ) -> DeviceEventInfoEXTBuilder<'a> {
        self.inner.device_event = device_event;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsDeviceEventInfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> DeviceEventInfoEXTBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> DeviceEventInfoEXT {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDisplayEventInfoEXT.html>"]
pub struct DisplayEventInfoEXT {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub display_event: DisplayEventTypeEXT,
}
impl ::std::default::Default for DisplayEventInfoEXT {
    fn default() -> DisplayEventInfoEXT {
        DisplayEventInfoEXT {
            s_type: StructureType::DISPLAY_EVENT_INFO_EXT,
            p_next: ::std::ptr::null(),
            display_event: DisplayEventTypeEXT::default(),
        }
    }
}
impl DisplayEventInfoEXT {
    pub fn builder<'a>() -> DisplayEventInfoEXTBuilder<'a> {
        DisplayEventInfoEXTBuilder {
            inner: DisplayEventInfoEXT::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct DisplayEventInfoEXTBuilder<'a> {
    inner: DisplayEventInfoEXT,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsDisplayEventInfoEXT {}
impl<'a> ::std::ops::Deref for DisplayEventInfoEXTBuilder<'a> {
    type Target = DisplayEventInfoEXT;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for DisplayEventInfoEXTBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> DisplayEventInfoEXTBuilder<'a> {
    pub fn display_event(
        mut self,
        display_event: DisplayEventTypeEXT,
    ) -> DisplayEventInfoEXTBuilder<'a> {
        self.inner.display_event = display_event;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsDisplayEventInfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> DisplayEventInfoEXTBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> DisplayEventInfoEXT {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSwapchainCounterCreateInfoEXT.html>"]
pub struct SwapchainCounterCreateInfoEXT {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub surface_counters: SurfaceCounterFlagsEXT,
}
impl ::std::default::Default for SwapchainCounterCreateInfoEXT {
    fn default() -> SwapchainCounterCreateInfoEXT {
        SwapchainCounterCreateInfoEXT {
            s_type: StructureType::SWAPCHAIN_COUNTER_CREATE_INFO_EXT,
            p_next: ::std::ptr::null(),
            surface_counters: SurfaceCounterFlagsEXT::default(),
        }
    }
}
impl SwapchainCounterCreateInfoEXT {
    pub fn builder<'a>() -> SwapchainCounterCreateInfoEXTBuilder<'a> {
        SwapchainCounterCreateInfoEXTBuilder {
            inner: SwapchainCounterCreateInfoEXT::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct SwapchainCounterCreateInfoEXTBuilder<'a> {
    inner: SwapchainCounterCreateInfoEXT,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsSwapchainCreateInfoKHR for SwapchainCounterCreateInfoEXTBuilder<'_> {}
unsafe impl ExtendsSwapchainCreateInfoKHR for SwapchainCounterCreateInfoEXT {}
impl<'a> ::std::ops::Deref for SwapchainCounterCreateInfoEXTBuilder<'a> {
    type Target = SwapchainCounterCreateInfoEXT;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for SwapchainCounterCreateInfoEXTBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> SwapchainCounterCreateInfoEXTBuilder<'a> {
    pub fn surface_counters(
        mut self,
        surface_counters: SurfaceCounterFlagsEXT,
    ) -> SwapchainCounterCreateInfoEXTBuilder<'a> {
        self.inner.surface_counters = surface_counters;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> SwapchainCounterCreateInfoEXT {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceGroupProperties.html>"]
pub struct PhysicalDeviceGroupProperties {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub physical_device_count: u32,
    pub physical_devices: [PhysicalDevice; MAX_DEVICE_GROUP_SIZE],
    pub subset_allocation: Bool32,
}
impl ::std::default::Default for PhysicalDeviceGroupProperties {
    fn default() -> PhysicalDeviceGroupProperties {
        PhysicalDeviceGroupProperties {
            s_type: StructureType::PHYSICAL_DEVICE_GROUP_PROPERTIES,
            p_next: ::std::ptr::null_mut(),
            physical_device_count: u32::default(),
            physical_devices: unsafe { ::std::mem::zeroed() },
            subset_allocation: Bool32::default(),
        }
    }
}
impl PhysicalDeviceGroupProperties {
    pub fn builder<'a>() -> PhysicalDeviceGroupPropertiesBuilder<'a> {
        PhysicalDeviceGroupPropertiesBuilder {
            inner: PhysicalDeviceGroupProperties::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDeviceGroupPropertiesBuilder<'a> {
    inner: PhysicalDeviceGroupProperties,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsPhysicalDeviceGroupProperties {}
impl<'a> ::std::ops::Deref for PhysicalDeviceGroupPropertiesBuilder<'a> {
    type Target = PhysicalDeviceGroupProperties;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PhysicalDeviceGroupPropertiesBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDeviceGroupPropertiesBuilder<'a> {
    pub fn physical_device_count(
        mut self,
        physical_device_count: u32,
    ) -> PhysicalDeviceGroupPropertiesBuilder<'a> {
        self.inner.physical_device_count = physical_device_count;
        self
    }
    pub fn physical_devices(
        mut self,
        physical_devices: [PhysicalDevice; MAX_DEVICE_GROUP_SIZE],
    ) -> PhysicalDeviceGroupPropertiesBuilder<'a> {
        self.inner.physical_devices = physical_devices;
        self
    }
    pub fn subset_allocation(
        mut self,
        subset_allocation: bool,
    ) -> PhysicalDeviceGroupPropertiesBuilder<'a> {
        self.inner.subset_allocation = subset_allocation.into();
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsPhysicalDeviceGroupProperties>(
        mut self,
        next: &'a mut T,
    ) -> PhysicalDeviceGroupPropertiesBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDeviceGroupProperties {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkMemoryAllocateFlagsInfo.html>"]
pub struct MemoryAllocateFlagsInfo {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub flags: MemoryAllocateFlags,
    pub device_mask: u32,
}
impl ::std::default::Default for MemoryAllocateFlagsInfo {
    fn default() -> MemoryAllocateFlagsInfo {
        MemoryAllocateFlagsInfo {
            s_type: StructureType::MEMORY_ALLOCATE_FLAGS_INFO,
            p_next: ::std::ptr::null(),
            flags: MemoryAllocateFlags::default(),
            device_mask: u32::default(),
        }
    }
}
impl MemoryAllocateFlagsInfo {
    pub fn builder<'a>() -> MemoryAllocateFlagsInfoBuilder<'a> {
        MemoryAllocateFlagsInfoBuilder {
            inner: MemoryAllocateFlagsInfo::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct MemoryAllocateFlagsInfoBuilder<'a> {
    inner: MemoryAllocateFlagsInfo,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsMemoryAllocateInfo for MemoryAllocateFlagsInfoBuilder<'_> {}
unsafe impl ExtendsMemoryAllocateInfo for MemoryAllocateFlagsInfo {}
impl<'a> ::std::ops::Deref for MemoryAllocateFlagsInfoBuilder<'a> {
    type Target = MemoryAllocateFlagsInfo;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for MemoryAllocateFlagsInfoBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> MemoryAllocateFlagsInfoBuilder<'a> {
    pub fn flags(mut self, flags: MemoryAllocateFlags) -> MemoryAllocateFlagsInfoBuilder<'a> {
        self.inner.flags = flags;
        self
    }
    pub fn device_mask(mut self, device_mask: u32) -> MemoryAllocateFlagsInfoBuilder<'a> {
        self.inner.device_mask = device_mask;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> MemoryAllocateFlagsInfo {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkBindBufferMemoryInfo.html>"]
pub struct BindBufferMemoryInfo {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub buffer: Buffer,
    pub memory: DeviceMemory,
    pub memory_offset: DeviceSize,
}
impl ::std::default::Default for BindBufferMemoryInfo {
    fn default() -> BindBufferMemoryInfo {
        BindBufferMemoryInfo {
            s_type: StructureType::BIND_BUFFER_MEMORY_INFO,
            p_next: ::std::ptr::null(),
            buffer: Buffer::default(),
            memory: DeviceMemory::default(),
            memory_offset: DeviceSize::default(),
        }
    }
}
impl BindBufferMemoryInfo {
    pub fn builder<'a>() -> BindBufferMemoryInfoBuilder<'a> {
        BindBufferMemoryInfoBuilder {
            inner: BindBufferMemoryInfo::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct BindBufferMemoryInfoBuilder<'a> {
    inner: BindBufferMemoryInfo,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsBindBufferMemoryInfo {}
impl<'a> ::std::ops::Deref for BindBufferMemoryInfoBuilder<'a> {
    type Target = BindBufferMemoryInfo;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for BindBufferMemoryInfoBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> BindBufferMemoryInfoBuilder<'a> {
    pub fn buffer(mut self, buffer: Buffer) -> BindBufferMemoryInfoBuilder<'a> {
        self.inner.buffer = buffer;
        self
    }
    pub fn memory(mut self, memory: DeviceMemory) -> BindBufferMemoryInfoBuilder<'a> {
        self.inner.memory = memory;
        self
    }
    pub fn memory_offset(mut self, memory_offset: DeviceSize) -> BindBufferMemoryInfoBuilder<'a> {
        self.inner.memory_offset = memory_offset;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsBindBufferMemoryInfo>(
        mut self,
        next: &'a mut T,
    ) -> BindBufferMemoryInfoBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> BindBufferMemoryInfo {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkBindBufferMemoryDeviceGroupInfo.html>"]
pub struct BindBufferMemoryDeviceGroupInfo {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub device_index_count: u32,
    pub p_device_indices: *const u32,
}
impl ::std::default::Default for BindBufferMemoryDeviceGroupInfo {
    fn default() -> BindBufferMemoryDeviceGroupInfo {
        BindBufferMemoryDeviceGroupInfo {
            s_type: StructureType::BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO,
            p_next: ::std::ptr::null(),
            device_index_count: u32::default(),
            p_device_indices: ::std::ptr::null(),
        }
    }
}
impl BindBufferMemoryDeviceGroupInfo {
    pub fn builder<'a>() -> BindBufferMemoryDeviceGroupInfoBuilder<'a> {
        BindBufferMemoryDeviceGroupInfoBuilder {
            inner: BindBufferMemoryDeviceGroupInfo::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct BindBufferMemoryDeviceGroupInfoBuilder<'a> {
    inner: BindBufferMemoryDeviceGroupInfo,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsBindBufferMemoryInfo for BindBufferMemoryDeviceGroupInfoBuilder<'_> {}
unsafe impl ExtendsBindBufferMemoryInfo for BindBufferMemoryDeviceGroupInfo {}
impl<'a> ::std::ops::Deref for BindBufferMemoryDeviceGroupInfoBuilder<'a> {
    type Target = BindBufferMemoryDeviceGroupInfo;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for BindBufferMemoryDeviceGroupInfoBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> BindBufferMemoryDeviceGroupInfoBuilder<'a> {
    pub fn device_indices(
        mut self,
        device_indices: &'a [u32],
    ) -> BindBufferMemoryDeviceGroupInfoBuilder<'a> {
        self.inner.device_index_count = device_indices.len() as _;
        self.inner.p_device_indices = device_indices.as_ptr();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> BindBufferMemoryDeviceGroupInfo {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkBindImageMemoryInfo.html>"]
pub struct BindImageMemoryInfo {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub image: Image,
    pub memory: DeviceMemory,
    pub memory_offset: DeviceSize,
}
impl ::std::default::Default for BindImageMemoryInfo {
    fn default() -> BindImageMemoryInfo {
        BindImageMemoryInfo {
            s_type: StructureType::BIND_IMAGE_MEMORY_INFO,
            p_next: ::std::ptr::null(),
            image: Image::default(),
            memory: DeviceMemory::default(),
            memory_offset: DeviceSize::default(),
        }
    }
}
impl BindImageMemoryInfo {
    pub fn builder<'a>() -> BindImageMemoryInfoBuilder<'a> {
        BindImageMemoryInfoBuilder {
            inner: BindImageMemoryInfo::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct BindImageMemoryInfoBuilder<'a> {
    inner: BindImageMemoryInfo,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsBindImageMemoryInfo {}
impl<'a> ::std::ops::Deref for BindImageMemoryInfoBuilder<'a> {
    type Target = BindImageMemoryInfo;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for BindImageMemoryInfoBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> BindImageMemoryInfoBuilder<'a> {
    pub fn image(mut self, image: Image) -> BindImageMemoryInfoBuilder<'a> {
        self.inner.image = image;
        self
    }
    pub fn memory(mut self, memory: DeviceMemory) -> BindImageMemoryInfoBuilder<'a> {
        self.inner.memory = memory;
        self
    }
    pub fn memory_offset(mut self, memory_offset: DeviceSize) -> BindImageMemoryInfoBuilder<'a> {
        self.inner.memory_offset = memory_offset;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsBindImageMemoryInfo>(
        mut self,
        next: &'a mut T,
    ) -> BindImageMemoryInfoBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> BindImageMemoryInfo {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkBindImageMemoryDeviceGroupInfo.html>"]
pub struct BindImageMemoryDeviceGroupInfo {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub device_index_count: u32,
    pub p_device_indices: *const u32,
    pub split_instance_bind_region_count: u32,
    pub p_split_instance_bind_regions: *const Rect2D,
}
impl ::std::default::Default for BindImageMemoryDeviceGroupInfo {
    fn default() -> BindImageMemoryDeviceGroupInfo {
        BindImageMemoryDeviceGroupInfo {
            s_type: StructureType::BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO,
            p_next: ::std::ptr::null(),
            device_index_count: u32::default(),
            p_device_indices: ::std::ptr::null(),
            split_instance_bind_region_count: u32::default(),
            p_split_instance_bind_regions: ::std::ptr::null(),
        }
    }
}
impl BindImageMemoryDeviceGroupInfo {
    pub fn builder<'a>() -> BindImageMemoryDeviceGroupInfoBuilder<'a> {
        BindImageMemoryDeviceGroupInfoBuilder {
            inner: BindImageMemoryDeviceGroupInfo::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct BindImageMemoryDeviceGroupInfoBuilder<'a> {
    inner: BindImageMemoryDeviceGroupInfo,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsBindImageMemoryInfo for BindImageMemoryDeviceGroupInfoBuilder<'_> {}
unsafe impl ExtendsBindImageMemoryInfo for BindImageMemoryDeviceGroupInfo {}
impl<'a> ::std::ops::Deref for BindImageMemoryDeviceGroupInfoBuilder<'a> {
    type Target = BindImageMemoryDeviceGroupInfo;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for BindImageMemoryDeviceGroupInfoBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> BindImageMemoryDeviceGroupInfoBuilder<'a> {
    pub fn device_indices(
        mut self,
        device_indices: &'a [u32],
    ) -> BindImageMemoryDeviceGroupInfoBuilder<'a> {
        self.inner.device_index_count = device_indices.len() as _;
        self.inner.p_device_indices = device_indices.as_ptr();
        self
    }
    pub fn split_instance_bind_regions(
        mut self,
        split_instance_bind_regions: &'a [Rect2D],
    ) -> BindImageMemoryDeviceGroupInfoBuilder<'a> {
        self.inner.split_instance_bind_region_count = split_instance_bind_regions.len() as _;
        self.inner.p_split_instance_bind_regions = split_instance_bind_regions.as_ptr();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> BindImageMemoryDeviceGroupInfo {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDeviceGroupRenderPassBeginInfo.html>"]
pub struct DeviceGroupRenderPassBeginInfo {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub device_mask: u32,
    pub device_render_area_count: u32,
    pub p_device_render_areas: *const Rect2D,
}
impl ::std::default::Default for DeviceGroupRenderPassBeginInfo {
    fn default() -> DeviceGroupRenderPassBeginInfo {
        DeviceGroupRenderPassBeginInfo {
            s_type: StructureType::DEVICE_GROUP_RENDER_PASS_BEGIN_INFO,
            p_next: ::std::ptr::null(),
            device_mask: u32::default(),
            device_render_area_count: u32::default(),
            p_device_render_areas: ::std::ptr::null(),
        }
    }
}
impl DeviceGroupRenderPassBeginInfo {
    pub fn builder<'a>() -> DeviceGroupRenderPassBeginInfoBuilder<'a> {
        DeviceGroupRenderPassBeginInfoBuilder {
            inner: DeviceGroupRenderPassBeginInfo::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct DeviceGroupRenderPassBeginInfoBuilder<'a> {
    inner: DeviceGroupRenderPassBeginInfo,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsRenderPassBeginInfo for DeviceGroupRenderPassBeginInfoBuilder<'_> {}
unsafe impl ExtendsRenderPassBeginInfo for DeviceGroupRenderPassBeginInfo {}
impl<'a> ::std::ops::Deref for DeviceGroupRenderPassBeginInfoBuilder<'a> {
    type Target = DeviceGroupRenderPassBeginInfo;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for DeviceGroupRenderPassBeginInfoBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> DeviceGroupRenderPassBeginInfoBuilder<'a> {
    pub fn device_mask(mut self, device_mask: u32) -> DeviceGroupRenderPassBeginInfoBuilder<'a> {
        self.inner.device_mask = device_mask;
        self
    }
    pub fn device_render_areas(
        mut self,
        device_render_areas: &'a [Rect2D],
    ) -> DeviceGroupRenderPassBeginInfoBuilder<'a> {
        self.inner.device_render_area_count = device_render_areas.len() as _;
        self.inner.p_device_render_areas = device_render_areas.as_ptr();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> DeviceGroupRenderPassBeginInfo {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDeviceGroupCommandBufferBeginInfo.html>"]
pub struct DeviceGroupCommandBufferBeginInfo {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub device_mask: u32,
}
impl ::std::default::Default for DeviceGroupCommandBufferBeginInfo {
    fn default() -> DeviceGroupCommandBufferBeginInfo {
        DeviceGroupCommandBufferBeginInfo {
            s_type: StructureType::DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO,
            p_next: ::std::ptr::null(),
            device_mask: u32::default(),
        }
    }
}
impl DeviceGroupCommandBufferBeginInfo {
    pub fn builder<'a>() -> DeviceGroupCommandBufferBeginInfoBuilder<'a> {
        DeviceGroupCommandBufferBeginInfoBuilder {
            inner: DeviceGroupCommandBufferBeginInfo::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct DeviceGroupCommandBufferBeginInfoBuilder<'a> {
    inner: DeviceGroupCommandBufferBeginInfo,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsCommandBufferBeginInfo for DeviceGroupCommandBufferBeginInfoBuilder<'_> {}
unsafe impl ExtendsCommandBufferBeginInfo for DeviceGroupCommandBufferBeginInfo {}
impl<'a> ::std::ops::Deref for DeviceGroupCommandBufferBeginInfoBuilder<'a> {
    type Target = DeviceGroupCommandBufferBeginInfo;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for DeviceGroupCommandBufferBeginInfoBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> DeviceGroupCommandBufferBeginInfoBuilder<'a> {
    pub fn device_mask(mut self, device_mask: u32) -> DeviceGroupCommandBufferBeginInfoBuilder<'a> {
        self.inner.device_mask = device_mask;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> DeviceGroupCommandBufferBeginInfo {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDeviceGroupSubmitInfo.html>"]
pub struct DeviceGroupSubmitInfo {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub wait_semaphore_count: u32,
    pub p_wait_semaphore_device_indices: *const u32,
    pub command_buffer_count: u32,
    pub p_command_buffer_device_masks: *const u32,
    pub signal_semaphore_count: u32,
    pub p_signal_semaphore_device_indices: *const u32,
}
impl ::std::default::Default for DeviceGroupSubmitInfo {
    fn default() -> DeviceGroupSubmitInfo {
        DeviceGroupSubmitInfo {
            s_type: StructureType::DEVICE_GROUP_SUBMIT_INFO,
            p_next: ::std::ptr::null(),
            wait_semaphore_count: u32::default(),
            p_wait_semaphore_device_indices: ::std::ptr::null(),
            command_buffer_count: u32::default(),
            p_command_buffer_device_masks: ::std::ptr::null(),
            signal_semaphore_count: u32::default(),
            p_signal_semaphore_device_indices: ::std::ptr::null(),
        }
    }
}
impl DeviceGroupSubmitInfo {
    pub fn builder<'a>() -> DeviceGroupSubmitInfoBuilder<'a> {
        DeviceGroupSubmitInfoBuilder {
            inner: DeviceGroupSubmitInfo::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct DeviceGroupSubmitInfoBuilder<'a> {
    inner: DeviceGroupSubmitInfo,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsSubmitInfo for DeviceGroupSubmitInfoBuilder<'_> {}
unsafe impl ExtendsSubmitInfo for DeviceGroupSubmitInfo {}
impl<'a> ::std::ops::Deref for DeviceGroupSubmitInfoBuilder<'a> {
    type Target = DeviceGroupSubmitInfo;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for DeviceGroupSubmitInfoBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> DeviceGroupSubmitInfoBuilder<'a> {
    pub fn wait_semaphore_device_indices(
        mut self,
        wait_semaphore_device_indices: &'a [u32],
    ) -> DeviceGroupSubmitInfoBuilder<'a> {
        self.inner.wait_semaphore_count = wait_semaphore_device_indices.len() as _;
        self.inner.p_wait_semaphore_device_indices = wait_semaphore_device_indices.as_ptr();
        self
    }
    pub fn command_buffer_device_masks(
        mut self,
        command_buffer_device_masks: &'a [u32],
    ) -> DeviceGroupSubmitInfoBuilder<'a> {
        self.inner.command_buffer_count = command_buffer_device_masks.len() as _;
        self.inner.p_command_buffer_device_masks = command_buffer_device_masks.as_ptr();
        self
    }
    pub fn signal_semaphore_device_indices(
        mut self,
        signal_semaphore_device_indices: &'a [u32],
    ) -> DeviceGroupSubmitInfoBuilder<'a> {
        self.inner.signal_semaphore_count = signal_semaphore_device_indices.len() as _;
        self.inner.p_signal_semaphore_device_indices = signal_semaphore_device_indices.as_ptr();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> DeviceGroupSubmitInfo {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDeviceGroupBindSparseInfo.html>"]
pub struct DeviceGroupBindSparseInfo {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub resource_device_index: u32,
    pub memory_device_index: u32,
}
impl ::std::default::Default for DeviceGroupBindSparseInfo {
    fn default() -> DeviceGroupBindSparseInfo {
        DeviceGroupBindSparseInfo {
            s_type: StructureType::DEVICE_GROUP_BIND_SPARSE_INFO,
            p_next: ::std::ptr::null(),
            resource_device_index: u32::default(),
            memory_device_index: u32::default(),
        }
    }
}
impl DeviceGroupBindSparseInfo {
    pub fn builder<'a>() -> DeviceGroupBindSparseInfoBuilder<'a> {
        DeviceGroupBindSparseInfoBuilder {
            inner: DeviceGroupBindSparseInfo::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct DeviceGroupBindSparseInfoBuilder<'a> {
    inner: DeviceGroupBindSparseInfo,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsBindSparseInfo for DeviceGroupBindSparseInfoBuilder<'_> {}
unsafe impl ExtendsBindSparseInfo for DeviceGroupBindSparseInfo {}
impl<'a> ::std::ops::Deref for DeviceGroupBindSparseInfoBuilder<'a> {
    type Target = DeviceGroupBindSparseInfo;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for DeviceGroupBindSparseInfoBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> DeviceGroupBindSparseInfoBuilder<'a> {
    pub fn resource_device_index(
        mut self,
        resource_device_index: u32,
    ) -> DeviceGroupBindSparseInfoBuilder<'a> {
        self.inner.resource_device_index = resource_device_index;
        self
    }
    pub fn memory_device_index(
        mut self,
        memory_device_index: u32,
    ) -> DeviceGroupBindSparseInfoBuilder<'a> {
        self.inner.memory_device_index = memory_device_index;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> DeviceGroupBindSparseInfo {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDeviceGroupPresentCapabilitiesKHR.html>"]
pub struct DeviceGroupPresentCapabilitiesKHR {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub present_mask: [u32; MAX_DEVICE_GROUP_SIZE],
    pub modes: DeviceGroupPresentModeFlagsKHR,
}
impl ::std::default::Default for DeviceGroupPresentCapabilitiesKHR {
    fn default() -> DeviceGroupPresentCapabilitiesKHR {
        DeviceGroupPresentCapabilitiesKHR {
            s_type: StructureType::DEVICE_GROUP_PRESENT_CAPABILITIES_KHR,
            p_next: ::std::ptr::null(),
            present_mask: unsafe { ::std::mem::zeroed() },
            modes: DeviceGroupPresentModeFlagsKHR::default(),
        }
    }
}
impl DeviceGroupPresentCapabilitiesKHR {
    pub fn builder<'a>() -> DeviceGroupPresentCapabilitiesKHRBuilder<'a> {
        DeviceGroupPresentCapabilitiesKHRBuilder {
            inner: DeviceGroupPresentCapabilitiesKHR::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct DeviceGroupPresentCapabilitiesKHRBuilder<'a> {
    inner: DeviceGroupPresentCapabilitiesKHR,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsDeviceGroupPresentCapabilitiesKHR {}
impl<'a> ::std::ops::Deref for DeviceGroupPresentCapabilitiesKHRBuilder<'a> {
    type Target = DeviceGroupPresentCapabilitiesKHR;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for DeviceGroupPresentCapabilitiesKHRBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> DeviceGroupPresentCapabilitiesKHRBuilder<'a> {
    pub fn present_mask(
        mut self,
        present_mask: [u32; MAX_DEVICE_GROUP_SIZE],
    ) -> DeviceGroupPresentCapabilitiesKHRBuilder<'a> {
        self.inner.present_mask = present_mask;
        self
    }
    pub fn modes(
        mut self,
        modes: DeviceGroupPresentModeFlagsKHR,
    ) -> DeviceGroupPresentCapabilitiesKHRBuilder<'a> {
        self.inner.modes = modes;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsDeviceGroupPresentCapabilitiesKHR>(
        mut self,
        next: &'a mut T,
    ) -> DeviceGroupPresentCapabilitiesKHRBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> DeviceGroupPresentCapabilitiesKHR {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImageSwapchainCreateInfoKHR.html>"]
pub struct ImageSwapchainCreateInfoKHR {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub swapchain: SwapchainKHR,
}
impl ::std::default::Default for ImageSwapchainCreateInfoKHR {
    fn default() -> ImageSwapchainCreateInfoKHR {
        ImageSwapchainCreateInfoKHR {
            s_type: StructureType::IMAGE_SWAPCHAIN_CREATE_INFO_KHR,
            p_next: ::std::ptr::null(),
            swapchain: SwapchainKHR::default(),
        }
    }
}
impl ImageSwapchainCreateInfoKHR {
    pub fn builder<'a>() -> ImageSwapchainCreateInfoKHRBuilder<'a> {
        ImageSwapchainCreateInfoKHRBuilder {
            inner: ImageSwapchainCreateInfoKHR::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct ImageSwapchainCreateInfoKHRBuilder<'a> {
    inner: ImageSwapchainCreateInfoKHR,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsImageCreateInfo for ImageSwapchainCreateInfoKHRBuilder<'_> {}
unsafe impl ExtendsImageCreateInfo for ImageSwapchainCreateInfoKHR {}
impl<'a> ::std::ops::Deref for ImageSwapchainCreateInfoKHRBuilder<'a> {
    type Target = ImageSwapchainCreateInfoKHR;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for ImageSwapchainCreateInfoKHRBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> ImageSwapchainCreateInfoKHRBuilder<'a> {
    pub fn swapchain(mut self, swapchain: SwapchainKHR) -> ImageSwapchainCreateInfoKHRBuilder<'a> {
        self.inner.swapchain = swapchain;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> ImageSwapchainCreateInfoKHR {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkBindImageMemorySwapchainInfoKHR.html>"]
pub struct BindImageMemorySwapchainInfoKHR {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub swapchain: SwapchainKHR,
    pub image_index: u32,
}
impl ::std::default::Default for BindImageMemorySwapchainInfoKHR {
    fn default() -> BindImageMemorySwapchainInfoKHR {
        BindImageMemorySwapchainInfoKHR {
            s_type: StructureType::BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR,
            p_next: ::std::ptr::null(),
            swapchain: SwapchainKHR::default(),
            image_index: u32::default(),
        }
    }
}
impl BindImageMemorySwapchainInfoKHR {
    pub fn builder<'a>() -> BindImageMemorySwapchainInfoKHRBuilder<'a> {
        BindImageMemorySwapchainInfoKHRBuilder {
            inner: BindImageMemorySwapchainInfoKHR::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct BindImageMemorySwapchainInfoKHRBuilder<'a> {
    inner: BindImageMemorySwapchainInfoKHR,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsBindImageMemoryInfo for BindImageMemorySwapchainInfoKHRBuilder<'_> {}
unsafe impl ExtendsBindImageMemoryInfo for BindImageMemorySwapchainInfoKHR {}
impl<'a> ::std::ops::Deref for BindImageMemorySwapchainInfoKHRBuilder<'a> {
    type Target = BindImageMemorySwapchainInfoKHR;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for BindImageMemorySwapchainInfoKHRBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> BindImageMemorySwapchainInfoKHRBuilder<'a> {
    pub fn swapchain(
        mut self,
        swapchain: SwapchainKHR,
    ) -> BindImageMemorySwapchainInfoKHRBuilder<'a> {
        self.inner.swapchain = swapchain;
        self
    }
    pub fn image_index(mut self, image_index: u32) -> BindImageMemorySwapchainInfoKHRBuilder<'a> {
        self.inner.image_index = image_index;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> BindImageMemorySwapchainInfoKHR {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAcquireNextImageInfoKHR.html>"]
pub struct AcquireNextImageInfoKHR {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub swapchain: SwapchainKHR,
    pub timeout: u64,
    pub semaphore: Semaphore,
    pub fence: Fence,
    pub device_mask: u32,
}
impl ::std::default::Default for AcquireNextImageInfoKHR {
    fn default() -> AcquireNextImageInfoKHR {
        AcquireNextImageInfoKHR {
            s_type: StructureType::ACQUIRE_NEXT_IMAGE_INFO_KHR,
            p_next: ::std::ptr::null(),
            swapchain: SwapchainKHR::default(),
            timeout: u64::default(),
            semaphore: Semaphore::default(),
            fence: Fence::default(),
            device_mask: u32::default(),
        }
    }
}
impl AcquireNextImageInfoKHR {
    pub fn builder<'a>() -> AcquireNextImageInfoKHRBuilder<'a> {
        AcquireNextImageInfoKHRBuilder {
            inner: AcquireNextImageInfoKHR::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct AcquireNextImageInfoKHRBuilder<'a> {
    inner: AcquireNextImageInfoKHR,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsAcquireNextImageInfoKHR {}
impl<'a> ::std::ops::Deref for AcquireNextImageInfoKHRBuilder<'a> {
    type Target = AcquireNextImageInfoKHR;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for AcquireNextImageInfoKHRBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> AcquireNextImageInfoKHRBuilder<'a> {
    pub fn swapchain(mut self, swapchain: SwapchainKHR) -> AcquireNextImageInfoKHRBuilder<'a> {
        self.inner.swapchain = swapchain;
        self
    }
    pub fn timeout(mut self, timeout: u64) -> AcquireNextImageInfoKHRBuilder<'a> {
        self.inner.timeout = timeout;
        self
    }
    pub fn semaphore(mut self, semaphore: Semaphore) -> AcquireNextImageInfoKHRBuilder<'a> {
        self.inner.semaphore = semaphore;
        self
    }
    pub fn fence(mut self, fence: Fence) -> AcquireNextImageInfoKHRBuilder<'a> {
        self.inner.fence = fence;
        self
    }
    pub fn device_mask(mut self, device_mask: u32) -> AcquireNextImageInfoKHRBuilder<'a> {
        self.inner.device_mask = device_mask;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsAcquireNextImageInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> AcquireNextImageInfoKHRBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> AcquireNextImageInfoKHR {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDeviceGroupPresentInfoKHR.html>"]
pub struct DeviceGroupPresentInfoKHR {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub swapchain_count: u32,
    pub p_device_masks: *const u32,
    pub mode: DeviceGroupPresentModeFlagsKHR,
}
impl ::std::default::Default for DeviceGroupPresentInfoKHR {
    fn default() -> DeviceGroupPresentInfoKHR {
        DeviceGroupPresentInfoKHR {
            s_type: StructureType::DEVICE_GROUP_PRESENT_INFO_KHR,
            p_next: ::std::ptr::null(),
            swapchain_count: u32::default(),
            p_device_masks: ::std::ptr::null(),
            mode: DeviceGroupPresentModeFlagsKHR::default(),
        }
    }
}
impl DeviceGroupPresentInfoKHR {
    pub fn builder<'a>() -> DeviceGroupPresentInfoKHRBuilder<'a> {
        DeviceGroupPresentInfoKHRBuilder {
            inner: DeviceGroupPresentInfoKHR::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct DeviceGroupPresentInfoKHRBuilder<'a> {
    inner: DeviceGroupPresentInfoKHR,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsPresentInfoKHR for DeviceGroupPresentInfoKHRBuilder<'_> {}
unsafe impl ExtendsPresentInfoKHR for DeviceGroupPresentInfoKHR {}
impl<'a> ::std::ops::Deref for DeviceGroupPresentInfoKHRBuilder<'a> {
    type Target = DeviceGroupPresentInfoKHR;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for DeviceGroupPresentInfoKHRBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> DeviceGroupPresentInfoKHRBuilder<'a> {
    pub fn device_masks(mut self, device_masks: &'a [u32]) -> DeviceGroupPresentInfoKHRBuilder<'a> {
        self.inner.swapchain_count = device_masks.len() as _;
        self.inner.p_device_masks = device_masks.as_ptr();
        self
    }
    pub fn mode(
        mut self,
        mode: DeviceGroupPresentModeFlagsKHR,
    ) -> DeviceGroupPresentInfoKHRBuilder<'a> {
        self.inner.mode = mode;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> DeviceGroupPresentInfoKHR {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDeviceGroupDeviceCreateInfo.html>"]
pub struct DeviceGroupDeviceCreateInfo {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub physical_device_count: u32,
    pub p_physical_devices: *const PhysicalDevice,
}
impl ::std::default::Default for DeviceGroupDeviceCreateInfo {
    fn default() -> DeviceGroupDeviceCreateInfo {
        DeviceGroupDeviceCreateInfo {
            s_type: StructureType::DEVICE_GROUP_DEVICE_CREATE_INFO,
            p_next: ::std::ptr::null(),
            physical_device_count: u32::default(),
            p_physical_devices: ::std::ptr::null(),
        }
    }
}
impl DeviceGroupDeviceCreateInfo {
    pub fn builder<'a>() -> DeviceGroupDeviceCreateInfoBuilder<'a> {
        DeviceGroupDeviceCreateInfoBuilder {
            inner: DeviceGroupDeviceCreateInfo::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct DeviceGroupDeviceCreateInfoBuilder<'a> {
    inner: DeviceGroupDeviceCreateInfo,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsDeviceCreateInfo for DeviceGroupDeviceCreateInfoBuilder<'_> {}
unsafe impl ExtendsDeviceCreateInfo for DeviceGroupDeviceCreateInfo {}
impl<'a> ::std::ops::Deref for DeviceGroupDeviceCreateInfoBuilder<'a> {
    type Target = DeviceGroupDeviceCreateInfo;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for DeviceGroupDeviceCreateInfoBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> DeviceGroupDeviceCreateInfoBuilder<'a> {
    pub fn physical_devices(
        mut self,
        physical_devices: &'a [PhysicalDevice],
    ) -> DeviceGroupDeviceCreateInfoBuilder<'a> {
        self.inner.physical_device_count = physical_devices.len() as _;
        self.inner.p_physical_devices = physical_devices.as_ptr();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> DeviceGroupDeviceCreateInfo {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDeviceGroupSwapchainCreateInfoKHR.html>"]
pub struct DeviceGroupSwapchainCreateInfoKHR {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub modes: DeviceGroupPresentModeFlagsKHR,
}
impl ::std::default::Default for DeviceGroupSwapchainCreateInfoKHR {
    fn default() -> DeviceGroupSwapchainCreateInfoKHR {
        DeviceGroupSwapchainCreateInfoKHR {
            s_type: StructureType::DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR,
            p_next: ::std::ptr::null(),
            modes: DeviceGroupPresentModeFlagsKHR::default(),
        }
    }
}
impl DeviceGroupSwapchainCreateInfoKHR {
    pub fn builder<'a>() -> DeviceGroupSwapchainCreateInfoKHRBuilder<'a> {
        DeviceGroupSwapchainCreateInfoKHRBuilder {
            inner: DeviceGroupSwapchainCreateInfoKHR::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct DeviceGroupSwapchainCreateInfoKHRBuilder<'a> {
    inner: DeviceGroupSwapchainCreateInfoKHR,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsSwapchainCreateInfoKHR for DeviceGroupSwapchainCreateInfoKHRBuilder<'_> {}
unsafe impl ExtendsSwapchainCreateInfoKHR for DeviceGroupSwapchainCreateInfoKHR {}
impl<'a> ::std::ops::Deref for DeviceGroupSwapchainCreateInfoKHRBuilder<'a> {
    type Target = DeviceGroupSwapchainCreateInfoKHR;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for DeviceGroupSwapchainCreateInfoKHRBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> DeviceGroupSwapchainCreateInfoKHRBuilder<'a> {
    pub fn modes(
        mut self,
        modes: DeviceGroupPresentModeFlagsKHR,
    ) -> DeviceGroupSwapchainCreateInfoKHRBuilder<'a> {
        self.inner.modes = modes;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> DeviceGroupSwapchainCreateInfoKHR {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Default, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDescriptorUpdateTemplateEntry.html>"]
pub struct DescriptorUpdateTemplateEntry {
    pub dst_binding: u32,
    pub dst_array_element: u32,
    pub descriptor_count: u32,
    pub descriptor_type: DescriptorType,
    pub offset: usize,
    pub stride: usize,
}
impl DescriptorUpdateTemplateEntry {
    pub fn builder<'a>() -> DescriptorUpdateTemplateEntryBuilder<'a> {
        DescriptorUpdateTemplateEntryBuilder {
            inner: DescriptorUpdateTemplateEntry::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct DescriptorUpdateTemplateEntryBuilder<'a> {
    inner: DescriptorUpdateTemplateEntry,
    marker: ::std::marker::PhantomData<&'a ()>,
}
impl<'a> ::std::ops::Deref for DescriptorUpdateTemplateEntryBuilder<'a> {
    type Target = DescriptorUpdateTemplateEntry;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for DescriptorUpdateTemplateEntryBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> DescriptorUpdateTemplateEntryBuilder<'a> {
    pub fn dst_binding(mut self, dst_binding: u32) -> DescriptorUpdateTemplateEntryBuilder<'a> {
        self.inner.dst_binding = dst_binding;
        self
    }
    pub fn dst_array_element(
        mut self,
        dst_array_element: u32,
    ) -> DescriptorUpdateTemplateEntryBuilder<'a> {
        self.inner.dst_array_element = dst_array_element;
        self
    }
    pub fn descriptor_count(
        mut self,
        descriptor_count: u32,
    ) -> DescriptorUpdateTemplateEntryBuilder<'a> {
        self.inner.descriptor_count = descriptor_count;
        self
    }
    pub fn descriptor_type(
        mut self,
        descriptor_type: DescriptorType,
    ) -> DescriptorUpdateTemplateEntryBuilder<'a> {
        self.inner.descriptor_type = descriptor_type;
        self
    }
    pub fn offset(mut self, offset: usize) -> DescriptorUpdateTemplateEntryBuilder<'a> {
        self.inner.offset = offset;
        self
    }
    pub fn stride(mut self, stride: usize) -> DescriptorUpdateTemplateEntryBuilder<'a> {
        self.inner.stride = stride;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> DescriptorUpdateTemplateEntry {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDescriptorUpdateTemplateCreateInfo.html>"]
pub struct DescriptorUpdateTemplateCreateInfo {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub flags: DescriptorUpdateTemplateCreateFlags,
    pub descriptor_update_entry_count: u32,
    pub p_descriptor_update_entries: *const DescriptorUpdateTemplateEntry,
    pub template_type: DescriptorUpdateTemplateType,
    pub descriptor_set_layout: DescriptorSetLayout,
    pub pipeline_bind_point: PipelineBindPoint,
    pub pipeline_layout: PipelineLayout,
    pub set: u32,
}
impl ::std::default::Default for DescriptorUpdateTemplateCreateInfo {
    fn default() -> DescriptorUpdateTemplateCreateInfo {
        DescriptorUpdateTemplateCreateInfo {
            s_type: StructureType::DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO,
            p_next: ::std::ptr::null(),
            flags: DescriptorUpdateTemplateCreateFlags::default(),
            descriptor_update_entry_count: u32::default(),
            p_descriptor_update_entries: ::std::ptr::null(),
            template_type: DescriptorUpdateTemplateType::default(),
            descriptor_set_layout: DescriptorSetLayout::default(),
            pipeline_bind_point: PipelineBindPoint::default(),
            pipeline_layout: PipelineLayout::default(),
            set: u32::default(),
        }
    }
}
impl DescriptorUpdateTemplateCreateInfo {
    pub fn builder<'a>() -> DescriptorUpdateTemplateCreateInfoBuilder<'a> {
        DescriptorUpdateTemplateCreateInfoBuilder {
            inner: DescriptorUpdateTemplateCreateInfo::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct DescriptorUpdateTemplateCreateInfoBuilder<'a> {
    inner: DescriptorUpdateTemplateCreateInfo,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsDescriptorUpdateTemplateCreateInfo {}
impl<'a> ::std::ops::Deref for DescriptorUpdateTemplateCreateInfoBuilder<'a> {
    type Target = DescriptorUpdateTemplateCreateInfo;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for DescriptorUpdateTemplateCreateInfoBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> DescriptorUpdateTemplateCreateInfoBuilder<'a> {
    pub fn flags(
        mut self,
        flags: DescriptorUpdateTemplateCreateFlags,
    ) -> DescriptorUpdateTemplateCreateInfoBuilder<'a> {
        self.inner.flags = flags;
        self
    }
    pub fn descriptor_update_entries(
        mut self,
        descriptor_update_entries: &'a [DescriptorUpdateTemplateEntry],
    ) -> DescriptorUpdateTemplateCreateInfoBuilder<'a> {
        self.inner.descriptor_update_entry_count = descriptor_update_entries.len() as _;
        self.inner.p_descriptor_update_entries = descriptor_update_entries.as_ptr();
        self
    }
    pub fn template_type(
        mut self,
        template_type: DescriptorUpdateTemplateType,
    ) -> DescriptorUpdateTemplateCreateInfoBuilder<'a> {
        self.inner.template_type = template_type;
        self
    }
    pub fn descriptor_set_layout(
        mut self,
        descriptor_set_layout: DescriptorSetLayout,
    ) -> DescriptorUpdateTemplateCreateInfoBuilder<'a> {
        self.inner.descriptor_set_layout = descriptor_set_layout;
        self
    }
    pub fn pipeline_bind_point(
        mut self,
        pipeline_bind_point: PipelineBindPoint,
    ) -> DescriptorUpdateTemplateCreateInfoBuilder<'a> {
        self.inner.pipeline_bind_point = pipeline_bind_point;
        self
    }
    pub fn pipeline_layout(
        mut self,
        pipeline_layout: PipelineLayout,
    ) -> DescriptorUpdateTemplateCreateInfoBuilder<'a> {
        self.inner.pipeline_layout = pipeline_layout;
        self
    }
    pub fn set(mut self, set: u32) -> DescriptorUpdateTemplateCreateInfoBuilder<'a> {
        self.inner.set = set;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsDescriptorUpdateTemplateCreateInfo>(
        mut self,
        next: &'a mut T,
    ) -> DescriptorUpdateTemplateCreateInfoBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> DescriptorUpdateTemplateCreateInfo {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Default, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkXYColorEXT.html>"]
pub struct XYColorEXT {
    pub x: f32,
    pub y: f32,
}
impl XYColorEXT {
    pub fn builder<'a>() -> XYColorEXTBuilder<'a> {
        XYColorEXTBuilder {
            inner: XYColorEXT::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct XYColorEXTBuilder<'a> {
    inner: XYColorEXT,
    marker: ::std::marker::PhantomData<&'a ()>,
}
impl<'a> ::std::ops::Deref for XYColorEXTBuilder<'a> {
    type Target = XYColorEXT;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for XYColorEXTBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> XYColorEXTBuilder<'a> {
    pub fn x(mut self, x: f32) -> XYColorEXTBuilder<'a> {
        self.inner.x = x;
        self
    }
    pub fn y(mut self, y: f32) -> XYColorEXTBuilder<'a> {
        self.inner.y = y;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> XYColorEXT {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkHdrMetadataEXT.html>"]
pub struct HdrMetadataEXT {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub display_primary_red: XYColorEXT,
    pub display_primary_green: XYColorEXT,
    pub display_primary_blue: XYColorEXT,
    pub white_point: XYColorEXT,
    pub max_luminance: f32,
    pub min_luminance: f32,
    pub max_content_light_level: f32,
    pub max_frame_average_light_level: f32,
}
impl ::std::default::Default for HdrMetadataEXT {
    fn default() -> HdrMetadataEXT {
        HdrMetadataEXT {
            s_type: StructureType::HDR_METADATA_EXT,
            p_next: ::std::ptr::null(),
            display_primary_red: XYColorEXT::default(),
            display_primary_green: XYColorEXT::default(),
            display_primary_blue: XYColorEXT::default(),
            white_point: XYColorEXT::default(),
            max_luminance: f32::default(),
            min_luminance: f32::default(),
            max_content_light_level: f32::default(),
            max_frame_average_light_level: f32::default(),
        }
    }
}
impl HdrMetadataEXT {
    pub fn builder<'a>() -> HdrMetadataEXTBuilder<'a> {
        HdrMetadataEXTBuilder {
            inner: HdrMetadataEXT::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct HdrMetadataEXTBuilder<'a> {
    inner: HdrMetadataEXT,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsHdrMetadataEXT {}
impl<'a> ::std::ops::Deref for HdrMetadataEXTBuilder<'a> {
    type Target = HdrMetadataEXT;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for HdrMetadataEXTBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> HdrMetadataEXTBuilder<'a> {
    pub fn display_primary_red(
        mut self,
        display_primary_red: XYColorEXT,
    ) -> HdrMetadataEXTBuilder<'a> {
        self.inner.display_primary_red = display_primary_red;
        self
    }
    pub fn display_primary_green(
        mut self,
        display_primary_green: XYColorEXT,
    ) -> HdrMetadataEXTBuilder<'a> {
        self.inner.display_primary_green = display_primary_green;
        self
    }
    pub fn display_primary_blue(
        mut self,
        display_primary_blue: XYColorEXT,
    ) -> HdrMetadataEXTBuilder<'a> {
        self.inner.display_primary_blue = display_primary_blue;
        self
    }
    pub fn white_point(mut self, white_point: XYColorEXT) -> HdrMetadataEXTBuilder<'a> {
        self.inner.white_point = white_point;
        self
    }
    pub fn max_luminance(mut self, max_luminance: f32) -> HdrMetadataEXTBuilder<'a> {
        self.inner.max_luminance = max_luminance;
        self
    }
    pub fn min_luminance(mut self, min_luminance: f32) -> HdrMetadataEXTBuilder<'a> {
        self.inner.min_luminance = min_luminance;
        self
    }
    pub fn max_content_light_level(
        mut self,
        max_content_light_level: f32,
    ) -> HdrMetadataEXTBuilder<'a> {
        self.inner.max_content_light_level = max_content_light_level;
        self
    }
    pub fn max_frame_average_light_level(
        mut self,
        max_frame_average_light_level: f32,
    ) -> HdrMetadataEXTBuilder<'a> {
        self.inner.max_frame_average_light_level = max_frame_average_light_level;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsHdrMetadataEXT>(
        mut self,
        next: &'a mut T,
    ) -> HdrMetadataEXTBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> HdrMetadataEXT {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDisplayNativeHdrSurfaceCapabilitiesAMD.html>"]
pub struct DisplayNativeHdrSurfaceCapabilitiesAMD {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub local_dimming_support: Bool32,
}
impl ::std::default::Default for DisplayNativeHdrSurfaceCapabilitiesAMD {
    fn default() -> DisplayNativeHdrSurfaceCapabilitiesAMD {
        DisplayNativeHdrSurfaceCapabilitiesAMD {
            s_type: StructureType::DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD,
            p_next: ::std::ptr::null_mut(),
            local_dimming_support: Bool32::default(),
        }
    }
}
impl DisplayNativeHdrSurfaceCapabilitiesAMD {
    pub fn builder<'a>() -> DisplayNativeHdrSurfaceCapabilitiesAMDBuilder<'a> {
        DisplayNativeHdrSurfaceCapabilitiesAMDBuilder {
            inner: DisplayNativeHdrSurfaceCapabilitiesAMD::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct DisplayNativeHdrSurfaceCapabilitiesAMDBuilder<'a> {
    inner: DisplayNativeHdrSurfaceCapabilitiesAMD,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsSurfaceCapabilities2KHR for DisplayNativeHdrSurfaceCapabilitiesAMDBuilder<'_> {}
unsafe impl ExtendsSurfaceCapabilities2KHR for DisplayNativeHdrSurfaceCapabilitiesAMD {}
impl<'a> ::std::ops::Deref for DisplayNativeHdrSurfaceCapabilitiesAMDBuilder<'a> {
    type Target = DisplayNativeHdrSurfaceCapabilitiesAMD;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for DisplayNativeHdrSurfaceCapabilitiesAMDBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> DisplayNativeHdrSurfaceCapabilitiesAMDBuilder<'a> {
    pub fn local_dimming_support(
        mut self,
        local_dimming_support: bool,
    ) -> DisplayNativeHdrSurfaceCapabilitiesAMDBuilder<'a> {
        self.inner.local_dimming_support = local_dimming_support.into();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> DisplayNativeHdrSurfaceCapabilitiesAMD {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSwapchainDisplayNativeHdrCreateInfoAMD.html>"]
pub struct SwapchainDisplayNativeHdrCreateInfoAMD {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub local_dimming_enable: Bool32,
}
impl ::std::default::Default for SwapchainDisplayNativeHdrCreateInfoAMD {
    fn default() -> SwapchainDisplayNativeHdrCreateInfoAMD {
        SwapchainDisplayNativeHdrCreateInfoAMD {
            s_type: StructureType::SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD,
            p_next: ::std::ptr::null(),
            local_dimming_enable: Bool32::default(),
        }
    }
}
impl SwapchainDisplayNativeHdrCreateInfoAMD {
    pub fn builder<'a>() -> SwapchainDisplayNativeHdrCreateInfoAMDBuilder<'a> {
        SwapchainDisplayNativeHdrCreateInfoAMDBuilder {
            inner: SwapchainDisplayNativeHdrCreateInfoAMD::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct SwapchainDisplayNativeHdrCreateInfoAMDBuilder<'a> {
    inner: SwapchainDisplayNativeHdrCreateInfoAMD,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsSwapchainCreateInfoKHR for SwapchainDisplayNativeHdrCreateInfoAMDBuilder<'_> {}
unsafe impl ExtendsSwapchainCreateInfoKHR for SwapchainDisplayNativeHdrCreateInfoAMD {}
impl<'a> ::std::ops::Deref for SwapchainDisplayNativeHdrCreateInfoAMDBuilder<'a> {
    type Target = SwapchainDisplayNativeHdrCreateInfoAMD;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for SwapchainDisplayNativeHdrCreateInfoAMDBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> SwapchainDisplayNativeHdrCreateInfoAMDBuilder<'a> {
    pub fn local_dimming_enable(
        mut self,
        local_dimming_enable: bool,
    ) -> SwapchainDisplayNativeHdrCreateInfoAMDBuilder<'a> {
        self.inner.local_dimming_enable = local_dimming_enable.into();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> SwapchainDisplayNativeHdrCreateInfoAMD {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Default, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkRefreshCycleDurationGOOGLE.html>"]
pub struct RefreshCycleDurationGOOGLE {
    pub refresh_duration: u64,
}
impl RefreshCycleDurationGOOGLE {
    pub fn builder<'a>() -> RefreshCycleDurationGOOGLEBuilder<'a> {
        RefreshCycleDurationGOOGLEBuilder {
            inner: RefreshCycleDurationGOOGLE::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct RefreshCycleDurationGOOGLEBuilder<'a> {
    inner: RefreshCycleDurationGOOGLE,
    marker: ::std::marker::PhantomData<&'a ()>,
}
impl<'a> ::std::ops::Deref for RefreshCycleDurationGOOGLEBuilder<'a> {
    type Target = RefreshCycleDurationGOOGLE;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for RefreshCycleDurationGOOGLEBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> RefreshCycleDurationGOOGLEBuilder<'a> {
    pub fn refresh_duration(
        mut self,
        refresh_duration: u64,
    ) -> RefreshCycleDurationGOOGLEBuilder<'a> {
        self.inner.refresh_duration = refresh_duration;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> RefreshCycleDurationGOOGLE {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Default, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPastPresentationTimingGOOGLE.html>"]
pub struct PastPresentationTimingGOOGLE {
    pub present_id: u32,
    pub desired_present_time: u64,
    pub actual_present_time: u64,
    pub earliest_present_time: u64,
    pub present_margin: u64,
}
impl PastPresentationTimingGOOGLE {
    pub fn builder<'a>() -> PastPresentationTimingGOOGLEBuilder<'a> {
        PastPresentationTimingGOOGLEBuilder {
            inner: PastPresentationTimingGOOGLE::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PastPresentationTimingGOOGLEBuilder<'a> {
    inner: PastPresentationTimingGOOGLE,
    marker: ::std::marker::PhantomData<&'a ()>,
}
impl<'a> ::std::ops::Deref for PastPresentationTimingGOOGLEBuilder<'a> {
    type Target = PastPresentationTimingGOOGLE;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PastPresentationTimingGOOGLEBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PastPresentationTimingGOOGLEBuilder<'a> {
    pub fn present_id(mut self, present_id: u32) -> PastPresentationTimingGOOGLEBuilder<'a> {
        self.inner.present_id = present_id;
        self
    }
    pub fn desired_present_time(
        mut self,
        desired_present_time: u64,
    ) -> PastPresentationTimingGOOGLEBuilder<'a> {
        self.inner.desired_present_time = desired_present_time;
        self
    }
    pub fn actual_present_time(
        mut self,
        actual_present_time: u64,
    ) -> PastPresentationTimingGOOGLEBuilder<'a> {
        self.inner.actual_present_time = actual_present_time;
        self
    }
    pub fn earliest_present_time(
        mut self,
        earliest_present_time: u64,
    ) -> PastPresentationTimingGOOGLEBuilder<'a> {
        self.inner.earliest_present_time = earliest_present_time;
        self
    }
    pub fn present_margin(
        mut self,
        present_margin: u64,
    ) -> PastPresentationTimingGOOGLEBuilder<'a> {
        self.inner.present_margin = present_margin;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PastPresentationTimingGOOGLE {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPresentTimesInfoGOOGLE.html>"]
pub struct PresentTimesInfoGOOGLE {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub swapchain_count: u32,
    pub p_times: *const PresentTimeGOOGLE,
}
impl ::std::default::Default for PresentTimesInfoGOOGLE {
    fn default() -> PresentTimesInfoGOOGLE {
        PresentTimesInfoGOOGLE {
            s_type: StructureType::PRESENT_TIMES_INFO_GOOGLE,
            p_next: ::std::ptr::null(),
            swapchain_count: u32::default(),
            p_times: ::std::ptr::null(),
        }
    }
}
impl PresentTimesInfoGOOGLE {
    pub fn builder<'a>() -> PresentTimesInfoGOOGLEBuilder<'a> {
        PresentTimesInfoGOOGLEBuilder {
            inner: PresentTimesInfoGOOGLE::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PresentTimesInfoGOOGLEBuilder<'a> {
    inner: PresentTimesInfoGOOGLE,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsPresentInfoKHR for PresentTimesInfoGOOGLEBuilder<'_> {}
unsafe impl ExtendsPresentInfoKHR for PresentTimesInfoGOOGLE {}
impl<'a> ::std::ops::Deref for PresentTimesInfoGOOGLEBuilder<'a> {
    type Target = PresentTimesInfoGOOGLE;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PresentTimesInfoGOOGLEBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PresentTimesInfoGOOGLEBuilder<'a> {
    pub fn times(mut self, times: &'a [PresentTimeGOOGLE]) -> PresentTimesInfoGOOGLEBuilder<'a> {
        self.inner.swapchain_count = times.len() as _;
        self.inner.p_times = times.as_ptr();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PresentTimesInfoGOOGLE {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Default, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPresentTimeGOOGLE.html>"]
pub struct PresentTimeGOOGLE {
    pub present_id: u32,
    pub desired_present_time: u64,
}
impl PresentTimeGOOGLE {
    pub fn builder<'a>() -> PresentTimeGOOGLEBuilder<'a> {
        PresentTimeGOOGLEBuilder {
            inner: PresentTimeGOOGLE::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PresentTimeGOOGLEBuilder<'a> {
    inner: PresentTimeGOOGLE,
    marker: ::std::marker::PhantomData<&'a ()>,
}
impl<'a> ::std::ops::Deref for PresentTimeGOOGLEBuilder<'a> {
    type Target = PresentTimeGOOGLE;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PresentTimeGOOGLEBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PresentTimeGOOGLEBuilder<'a> {
    pub fn present_id(mut self, present_id: u32) -> PresentTimeGOOGLEBuilder<'a> {
        self.inner.present_id = present_id;
        self
    }
    pub fn desired_present_time(
        mut self,
        desired_present_time: u64,
    ) -> PresentTimeGOOGLEBuilder<'a> {
        self.inner.desired_present_time = desired_present_time;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PresentTimeGOOGLE {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkIOSSurfaceCreateInfoMVK.html>"]
pub struct IOSSurfaceCreateInfoMVK {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub flags: IOSSurfaceCreateFlagsMVK,
    pub p_view: *const c_void,
}
impl ::std::default::Default for IOSSurfaceCreateInfoMVK {
    fn default() -> IOSSurfaceCreateInfoMVK {
        IOSSurfaceCreateInfoMVK {
            s_type: StructureType::IOS_SURFACE_CREATE_INFO_M,
            p_next: ::std::ptr::null(),
            flags: IOSSurfaceCreateFlagsMVK::default(),
            p_view: ::std::ptr::null(),
        }
    }
}
impl IOSSurfaceCreateInfoMVK {
    pub fn builder<'a>() -> IOSSurfaceCreateInfoMVKBuilder<'a> {
        IOSSurfaceCreateInfoMVKBuilder {
            inner: IOSSurfaceCreateInfoMVK::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct IOSSurfaceCreateInfoMVKBuilder<'a> {
    inner: IOSSurfaceCreateInfoMVK,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsIOSSurfaceCreateInfoMVK {}
impl<'a> ::std::ops::Deref for IOSSurfaceCreateInfoMVKBuilder<'a> {
    type Target = IOSSurfaceCreateInfoMVK;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for IOSSurfaceCreateInfoMVKBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> IOSSurfaceCreateInfoMVKBuilder<'a> {
    pub fn flags(mut self, flags: IOSSurfaceCreateFlagsMVK) -> IOSSurfaceCreateInfoMVKBuilder<'a> {
        self.inner.flags = flags;
        self
    }
    pub fn view(mut self, view: &'a c_void) -> IOSSurfaceCreateInfoMVKBuilder<'a> {
        self.inner.p_view = view;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsIOSSurfaceCreateInfoMVK>(
        mut self,
        next: &'a mut T,
    ) -> IOSSurfaceCreateInfoMVKBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> IOSSurfaceCreateInfoMVK {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkMacOSSurfaceCreateInfoMVK.html>"]
pub struct MacOSSurfaceCreateInfoMVK {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub flags: MacOSSurfaceCreateFlagsMVK,
    pub p_view: *const c_void,
}
impl ::std::default::Default for MacOSSurfaceCreateInfoMVK {
    fn default() -> MacOSSurfaceCreateInfoMVK {
        MacOSSurfaceCreateInfoMVK {
            s_type: StructureType::MACOS_SURFACE_CREATE_INFO_M,
            p_next: ::std::ptr::null(),
            flags: MacOSSurfaceCreateFlagsMVK::default(),
            p_view: ::std::ptr::null(),
        }
    }
}
impl MacOSSurfaceCreateInfoMVK {
    pub fn builder<'a>() -> MacOSSurfaceCreateInfoMVKBuilder<'a> {
        MacOSSurfaceCreateInfoMVKBuilder {
            inner: MacOSSurfaceCreateInfoMVK::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct MacOSSurfaceCreateInfoMVKBuilder<'a> {
    inner: MacOSSurfaceCreateInfoMVK,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsMacOSSurfaceCreateInfoMVK {}
impl<'a> ::std::ops::Deref for MacOSSurfaceCreateInfoMVKBuilder<'a> {
    type Target = MacOSSurfaceCreateInfoMVK;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for MacOSSurfaceCreateInfoMVKBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> MacOSSurfaceCreateInfoMVKBuilder<'a> {
    pub fn flags(
        mut self,
        flags: MacOSSurfaceCreateFlagsMVK,
    ) -> MacOSSurfaceCreateInfoMVKBuilder<'a> {
        self.inner.flags = flags;
        self
    }
    pub fn view(mut self, view: &'a c_void) -> MacOSSurfaceCreateInfoMVKBuilder<'a> {
        self.inner.p_view = view;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsMacOSSurfaceCreateInfoMVK>(
        mut self,
        next: &'a mut T,
    ) -> MacOSSurfaceCreateInfoMVKBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> MacOSSurfaceCreateInfoMVK {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkMetalSurfaceCreateInfoEXT.html>"]
pub struct MetalSurfaceCreateInfoEXT {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub flags: MetalSurfaceCreateFlagsEXT,
    pub p_layer: *const CAMetalLayer,
}
impl ::std::default::Default for MetalSurfaceCreateInfoEXT {
    fn default() -> MetalSurfaceCreateInfoEXT {
        MetalSurfaceCreateInfoEXT {
            s_type: StructureType::METAL_SURFACE_CREATE_INFO_EXT,
            p_next: ::std::ptr::null(),
            flags: MetalSurfaceCreateFlagsEXT::default(),
            p_layer: ::std::ptr::null(),
        }
    }
}
impl MetalSurfaceCreateInfoEXT {
    pub fn builder<'a>() -> MetalSurfaceCreateInfoEXTBuilder<'a> {
        MetalSurfaceCreateInfoEXTBuilder {
            inner: MetalSurfaceCreateInfoEXT::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct MetalSurfaceCreateInfoEXTBuilder<'a> {
    inner: MetalSurfaceCreateInfoEXT,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsMetalSurfaceCreateInfoEXT {}
impl<'a> ::std::ops::Deref for MetalSurfaceCreateInfoEXTBuilder<'a> {
    type Target = MetalSurfaceCreateInfoEXT;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for MetalSurfaceCreateInfoEXTBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> MetalSurfaceCreateInfoEXTBuilder<'a> {
    pub fn flags(
        mut self,
        flags: MetalSurfaceCreateFlagsEXT,
    ) -> MetalSurfaceCreateInfoEXTBuilder<'a> {
        self.inner.flags = flags;
        self
    }
    pub fn layer(mut self, layer: &'a CAMetalLayer) -> MetalSurfaceCreateInfoEXTBuilder<'a> {
        self.inner.p_layer = layer;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsMetalSurfaceCreateInfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> MetalSurfaceCreateInfoEXTBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> MetalSurfaceCreateInfoEXT {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Default, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkViewportWScalingNV.html>"]
pub struct ViewportWScalingNV {
    pub xcoeff: f32,
    pub ycoeff: f32,
}
impl ViewportWScalingNV {
    pub fn builder<'a>() -> ViewportWScalingNVBuilder<'a> {
        ViewportWScalingNVBuilder {
            inner: ViewportWScalingNV::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct ViewportWScalingNVBuilder<'a> {
    inner: ViewportWScalingNV,
    marker: ::std::marker::PhantomData<&'a ()>,
}
impl<'a> ::std::ops::Deref for ViewportWScalingNVBuilder<'a> {
    type Target = ViewportWScalingNV;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for ViewportWScalingNVBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> ViewportWScalingNVBuilder<'a> {
    pub fn xcoeff(mut self, xcoeff: f32) -> ViewportWScalingNVBuilder<'a> {
        self.inner.xcoeff = xcoeff;
        self
    }
    pub fn ycoeff(mut self, ycoeff: f32) -> ViewportWScalingNVBuilder<'a> {
        self.inner.ycoeff = ycoeff;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> ViewportWScalingNV {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineViewportWScalingStateCreateInfoNV.html>"]
pub struct PipelineViewportWScalingStateCreateInfoNV {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub viewport_w_scaling_enable: Bool32,
    pub viewport_count: u32,
    pub p_viewport_w_scalings: *const ViewportWScalingNV,
}
impl ::std::default::Default for PipelineViewportWScalingStateCreateInfoNV {
    fn default() -> PipelineViewportWScalingStateCreateInfoNV {
        PipelineViewportWScalingStateCreateInfoNV {
            s_type: StructureType::PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV,
            p_next: ::std::ptr::null(),
            viewport_w_scaling_enable: Bool32::default(),
            viewport_count: u32::default(),
            p_viewport_w_scalings: ::std::ptr::null(),
        }
    }
}
impl PipelineViewportWScalingStateCreateInfoNV {
    pub fn builder<'a>() -> PipelineViewportWScalingStateCreateInfoNVBuilder<'a> {
        PipelineViewportWScalingStateCreateInfoNVBuilder {
            inner: PipelineViewportWScalingStateCreateInfoNV::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PipelineViewportWScalingStateCreateInfoNVBuilder<'a> {
    inner: PipelineViewportWScalingStateCreateInfoNV,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsPipelineViewportStateCreateInfo
    for PipelineViewportWScalingStateCreateInfoNVBuilder<'_>
{
}
unsafe impl ExtendsPipelineViewportStateCreateInfo for PipelineViewportWScalingStateCreateInfoNV {}
impl<'a> ::std::ops::Deref for PipelineViewportWScalingStateCreateInfoNVBuilder<'a> {
    type Target = PipelineViewportWScalingStateCreateInfoNV;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PipelineViewportWScalingStateCreateInfoNVBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PipelineViewportWScalingStateCreateInfoNVBuilder<'a> {
    pub fn viewport_w_scaling_enable(
        mut self,
        viewport_w_scaling_enable: bool,
    ) -> PipelineViewportWScalingStateCreateInfoNVBuilder<'a> {
        self.inner.viewport_w_scaling_enable = viewport_w_scaling_enable.into();
        self
    }
    pub fn viewport_w_scalings(
        mut self,
        viewport_w_scalings: &'a [ViewportWScalingNV],
    ) -> PipelineViewportWScalingStateCreateInfoNVBuilder<'a> {
        self.inner.viewport_count = viewport_w_scalings.len() as _;
        self.inner.p_viewport_w_scalings = viewport_w_scalings.as_ptr();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PipelineViewportWScalingStateCreateInfoNV {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Default, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkViewportSwizzleNV.html>"]
pub struct ViewportSwizzleNV {
    pub x: ViewportCoordinateSwizzleNV,
    pub y: ViewportCoordinateSwizzleNV,
    pub z: ViewportCoordinateSwizzleNV,
    pub w: ViewportCoordinateSwizzleNV,
}
impl ViewportSwizzleNV {
    pub fn builder<'a>() -> ViewportSwizzleNVBuilder<'a> {
        ViewportSwizzleNVBuilder {
            inner: ViewportSwizzleNV::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct ViewportSwizzleNVBuilder<'a> {
    inner: ViewportSwizzleNV,
    marker: ::std::marker::PhantomData<&'a ()>,
}
impl<'a> ::std::ops::Deref for ViewportSwizzleNVBuilder<'a> {
    type Target = ViewportSwizzleNV;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for ViewportSwizzleNVBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> ViewportSwizzleNVBuilder<'a> {
    pub fn x(mut self, x: ViewportCoordinateSwizzleNV) -> ViewportSwizzleNVBuilder<'a> {
        self.inner.x = x;
        self
    }
    pub fn y(mut self, y: ViewportCoordinateSwizzleNV) -> ViewportSwizzleNVBuilder<'a> {
        self.inner.y = y;
        self
    }
    pub fn z(mut self, z: ViewportCoordinateSwizzleNV) -> ViewportSwizzleNVBuilder<'a> {
        self.inner.z = z;
        self
    }
    pub fn w(mut self, w: ViewportCoordinateSwizzleNV) -> ViewportSwizzleNVBuilder<'a> {
        self.inner.w = w;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> ViewportSwizzleNV {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineViewportSwizzleStateCreateInfoNV.html>"]
pub struct PipelineViewportSwizzleStateCreateInfoNV {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub flags: PipelineViewportSwizzleStateCreateFlagsNV,
    pub viewport_count: u32,
    pub p_viewport_swizzles: *const ViewportSwizzleNV,
}
impl ::std::default::Default for PipelineViewportSwizzleStateCreateInfoNV {
    fn default() -> PipelineViewportSwizzleStateCreateInfoNV {
        PipelineViewportSwizzleStateCreateInfoNV {
            s_type: StructureType::PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV,
            p_next: ::std::ptr::null(),
            flags: PipelineViewportSwizzleStateCreateFlagsNV::default(),
            viewport_count: u32::default(),
            p_viewport_swizzles: ::std::ptr::null(),
        }
    }
}
impl PipelineViewportSwizzleStateCreateInfoNV {
    pub fn builder<'a>() -> PipelineViewportSwizzleStateCreateInfoNVBuilder<'a> {
        PipelineViewportSwizzleStateCreateInfoNVBuilder {
            inner: PipelineViewportSwizzleStateCreateInfoNV::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PipelineViewportSwizzleStateCreateInfoNVBuilder<'a> {
    inner: PipelineViewportSwizzleStateCreateInfoNV,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsPipelineViewportStateCreateInfo
    for PipelineViewportSwizzleStateCreateInfoNVBuilder<'_>
{
}
unsafe impl ExtendsPipelineViewportStateCreateInfo for PipelineViewportSwizzleStateCreateInfoNV {}
impl<'a> ::std::ops::Deref for PipelineViewportSwizzleStateCreateInfoNVBuilder<'a> {
    type Target = PipelineViewportSwizzleStateCreateInfoNV;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PipelineViewportSwizzleStateCreateInfoNVBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PipelineViewportSwizzleStateCreateInfoNVBuilder<'a> {
    pub fn flags(
        mut self,
        flags: PipelineViewportSwizzleStateCreateFlagsNV,
    ) -> PipelineViewportSwizzleStateCreateInfoNVBuilder<'a> {
        self.inner.flags = flags;
        self
    }
    pub fn viewport_swizzles(
        mut self,
        viewport_swizzles: &'a [ViewportSwizzleNV],
    ) -> PipelineViewportSwizzleStateCreateInfoNVBuilder<'a> {
        self.inner.viewport_count = viewport_swizzles.len() as _;
        self.inner.p_viewport_swizzles = viewport_swizzles.as_ptr();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PipelineViewportSwizzleStateCreateInfoNV {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceDiscardRectanglePropertiesEXT.html>"]
pub struct PhysicalDeviceDiscardRectanglePropertiesEXT {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub max_discard_rectangles: u32,
}
impl ::std::default::Default for PhysicalDeviceDiscardRectanglePropertiesEXT {
    fn default() -> PhysicalDeviceDiscardRectanglePropertiesEXT {
        PhysicalDeviceDiscardRectanglePropertiesEXT {
            s_type: StructureType::PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT,
            p_next: ::std::ptr::null_mut(),
            max_discard_rectangles: u32::default(),
        }
    }
}
impl PhysicalDeviceDiscardRectanglePropertiesEXT {
    pub fn builder<'a>() -> PhysicalDeviceDiscardRectanglePropertiesEXTBuilder<'a> {
        PhysicalDeviceDiscardRectanglePropertiesEXTBuilder {
            inner: PhysicalDeviceDiscardRectanglePropertiesEXT::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDeviceDiscardRectanglePropertiesEXTBuilder<'a> {
    inner: PhysicalDeviceDiscardRectanglePropertiesEXT,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsPhysicalDeviceProperties2
    for PhysicalDeviceDiscardRectanglePropertiesEXTBuilder<'_>
{
}
unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceDiscardRectanglePropertiesEXT {}
impl<'a> ::std::ops::Deref for PhysicalDeviceDiscardRectanglePropertiesEXTBuilder<'a> {
    type Target = PhysicalDeviceDiscardRectanglePropertiesEXT;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PhysicalDeviceDiscardRectanglePropertiesEXTBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDeviceDiscardRectanglePropertiesEXTBuilder<'a> {
    pub fn max_discard_rectangles(
        mut self,
        max_discard_rectangles: u32,
    ) -> PhysicalDeviceDiscardRectanglePropertiesEXTBuilder<'a> {
        self.inner.max_discard_rectangles = max_discard_rectangles;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDeviceDiscardRectanglePropertiesEXT {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineDiscardRectangleStateCreateInfoEXT.html>"]
pub struct PipelineDiscardRectangleStateCreateInfoEXT {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub flags: PipelineDiscardRectangleStateCreateFlagsEXT,
    pub discard_rectangle_mode: DiscardRectangleModeEXT,
    pub discard_rectangle_count: u32,
    pub p_discard_rectangles: *const Rect2D,
}
impl ::std::default::Default for PipelineDiscardRectangleStateCreateInfoEXT {
    fn default() -> PipelineDiscardRectangleStateCreateInfoEXT {
        PipelineDiscardRectangleStateCreateInfoEXT {
            s_type: StructureType::PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT,
            p_next: ::std::ptr::null(),
            flags: PipelineDiscardRectangleStateCreateFlagsEXT::default(),
            discard_rectangle_mode: DiscardRectangleModeEXT::default(),
            discard_rectangle_count: u32::default(),
            p_discard_rectangles: ::std::ptr::null(),
        }
    }
}
impl PipelineDiscardRectangleStateCreateInfoEXT {
    pub fn builder<'a>() -> PipelineDiscardRectangleStateCreateInfoEXTBuilder<'a> {
        PipelineDiscardRectangleStateCreateInfoEXTBuilder {
            inner: PipelineDiscardRectangleStateCreateInfoEXT::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PipelineDiscardRectangleStateCreateInfoEXTBuilder<'a> {
    inner: PipelineDiscardRectangleStateCreateInfoEXT,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsGraphicsPipelineCreateInfo
    for PipelineDiscardRectangleStateCreateInfoEXTBuilder<'_>
{
}
unsafe impl ExtendsGraphicsPipelineCreateInfo for PipelineDiscardRectangleStateCreateInfoEXT {}
impl<'a> ::std::ops::Deref for PipelineDiscardRectangleStateCreateInfoEXTBuilder<'a> {
    type Target = PipelineDiscardRectangleStateCreateInfoEXT;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PipelineDiscardRectangleStateCreateInfoEXTBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PipelineDiscardRectangleStateCreateInfoEXTBuilder<'a> {
    pub fn flags(
        mut self,
        flags: PipelineDiscardRectangleStateCreateFlagsEXT,
    ) -> PipelineDiscardRectangleStateCreateInfoEXTBuilder<'a> {
        self.inner.flags = flags;
        self
    }
    pub fn discard_rectangle_mode(
        mut self,
        discard_rectangle_mode: DiscardRectangleModeEXT,
    ) -> PipelineDiscardRectangleStateCreateInfoEXTBuilder<'a> {
        self.inner.discard_rectangle_mode = discard_rectangle_mode;
        self
    }
    pub fn discard_rectangles(
        mut self,
        discard_rectangles: &'a [Rect2D],
    ) -> PipelineDiscardRectangleStateCreateInfoEXTBuilder<'a> {
        self.inner.discard_rectangle_count = discard_rectangles.len() as _;
        self.inner.p_discard_rectangles = discard_rectangles.as_ptr();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PipelineDiscardRectangleStateCreateInfoEXT {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX.html>"]
pub struct PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub per_view_position_all_components: Bool32,
}
impl ::std::default::Default for PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX {
    fn default() -> PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX {
        PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX {
            s_type: StructureType::PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX,
            p_next: ::std::ptr::null_mut(),
            per_view_position_all_components: Bool32::default(),
        }
    }
}
impl PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX {
    pub fn builder<'a>() -> PhysicalDeviceMultiviewPerViewAttributesPropertiesNVXBuilder<'a> {
        PhysicalDeviceMultiviewPerViewAttributesPropertiesNVXBuilder {
            inner: PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDeviceMultiviewPerViewAttributesPropertiesNVXBuilder<'a> {
    inner: PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsPhysicalDeviceProperties2
    for PhysicalDeviceMultiviewPerViewAttributesPropertiesNVXBuilder<'_>
{
}
unsafe impl ExtendsPhysicalDeviceProperties2
    for PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX
{
}
impl<'a> ::std::ops::Deref for PhysicalDeviceMultiviewPerViewAttributesPropertiesNVXBuilder<'a> {
    type Target = PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PhysicalDeviceMultiviewPerViewAttributesPropertiesNVXBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDeviceMultiviewPerViewAttributesPropertiesNVXBuilder<'a> {
    pub fn per_view_position_all_components(
        mut self,
        per_view_position_all_components: bool,
    ) -> PhysicalDeviceMultiviewPerViewAttributesPropertiesNVXBuilder<'a> {
        self.inner.per_view_position_all_components = per_view_position_all_components.into();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Default, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkInputAttachmentAspectReference.html>"]
pub struct InputAttachmentAspectReference {
    pub subpass: u32,
    pub input_attachment_index: u32,
    pub aspect_mask: ImageAspectFlags,
}
impl InputAttachmentAspectReference {
    pub fn builder<'a>() -> InputAttachmentAspectReferenceBuilder<'a> {
        InputAttachmentAspectReferenceBuilder {
            inner: InputAttachmentAspectReference::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct InputAttachmentAspectReferenceBuilder<'a> {
    inner: InputAttachmentAspectReference,
    marker: ::std::marker::PhantomData<&'a ()>,
}
impl<'a> ::std::ops::Deref for InputAttachmentAspectReferenceBuilder<'a> {
    type Target = InputAttachmentAspectReference;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for InputAttachmentAspectReferenceBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> InputAttachmentAspectReferenceBuilder<'a> {
    pub fn subpass(mut self, subpass: u32) -> InputAttachmentAspectReferenceBuilder<'a> {
        self.inner.subpass = subpass;
        self
    }
    pub fn input_attachment_index(
        mut self,
        input_attachment_index: u32,
    ) -> InputAttachmentAspectReferenceBuilder<'a> {
        self.inner.input_attachment_index = input_attachment_index;
        self
    }
    pub fn aspect_mask(
        mut self,
        aspect_mask: ImageAspectFlags,
    ) -> InputAttachmentAspectReferenceBuilder<'a> {
        self.inner.aspect_mask = aspect_mask;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> InputAttachmentAspectReference {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkRenderPassInputAttachmentAspectCreateInfo.html>"]
pub struct RenderPassInputAttachmentAspectCreateInfo {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub aspect_reference_count: u32,
    pub p_aspect_references: *const InputAttachmentAspectReference,
}
impl ::std::default::Default for RenderPassInputAttachmentAspectCreateInfo {
    fn default() -> RenderPassInputAttachmentAspectCreateInfo {
        RenderPassInputAttachmentAspectCreateInfo {
            s_type: StructureType::RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO,
            p_next: ::std::ptr::null(),
            aspect_reference_count: u32::default(),
            p_aspect_references: ::std::ptr::null(),
        }
    }
}
impl RenderPassInputAttachmentAspectCreateInfo {
    pub fn builder<'a>() -> RenderPassInputAttachmentAspectCreateInfoBuilder<'a> {
        RenderPassInputAttachmentAspectCreateInfoBuilder {
            inner: RenderPassInputAttachmentAspectCreateInfo::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct RenderPassInputAttachmentAspectCreateInfoBuilder<'a> {
    inner: RenderPassInputAttachmentAspectCreateInfo,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsRenderPassCreateInfo for RenderPassInputAttachmentAspectCreateInfoBuilder<'_> {}
unsafe impl ExtendsRenderPassCreateInfo for RenderPassInputAttachmentAspectCreateInfo {}
impl<'a> ::std::ops::Deref for RenderPassInputAttachmentAspectCreateInfoBuilder<'a> {
    type Target = RenderPassInputAttachmentAspectCreateInfo;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for RenderPassInputAttachmentAspectCreateInfoBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> RenderPassInputAttachmentAspectCreateInfoBuilder<'a> {
    pub fn aspect_references(
        mut self,
        aspect_references: &'a [InputAttachmentAspectReference],
    ) -> RenderPassInputAttachmentAspectCreateInfoBuilder<'a> {
        self.inner.aspect_reference_count = aspect_references.len() as _;
        self.inner.p_aspect_references = aspect_references.as_ptr();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> RenderPassInputAttachmentAspectCreateInfo {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceSurfaceInfo2KHR.html>"]
pub struct PhysicalDeviceSurfaceInfo2KHR {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub surface: SurfaceKHR,
}
impl ::std::default::Default for PhysicalDeviceSurfaceInfo2KHR {
    fn default() -> PhysicalDeviceSurfaceInfo2KHR {
        PhysicalDeviceSurfaceInfo2KHR {
            s_type: StructureType::PHYSICAL_DEVICE_SURFACE_INFO_2_KHR,
            p_next: ::std::ptr::null(),
            surface: SurfaceKHR::default(),
        }
    }
}
impl PhysicalDeviceSurfaceInfo2KHR {
    pub fn builder<'a>() -> PhysicalDeviceSurfaceInfo2KHRBuilder<'a> {
        PhysicalDeviceSurfaceInfo2KHRBuilder {
            inner: PhysicalDeviceSurfaceInfo2KHR::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDeviceSurfaceInfo2KHRBuilder<'a> {
    inner: PhysicalDeviceSurfaceInfo2KHR,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsPhysicalDeviceSurfaceInfo2KHR {}
impl<'a> ::std::ops::Deref for PhysicalDeviceSurfaceInfo2KHRBuilder<'a> {
    type Target = PhysicalDeviceSurfaceInfo2KHR;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PhysicalDeviceSurfaceInfo2KHRBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDeviceSurfaceInfo2KHRBuilder<'a> {
    pub fn surface(mut self, surface: SurfaceKHR) -> PhysicalDeviceSurfaceInfo2KHRBuilder<'a> {
        self.inner.surface = surface;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsPhysicalDeviceSurfaceInfo2KHR>(
        mut self,
        next: &'a mut T,
    ) -> PhysicalDeviceSurfaceInfo2KHRBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDeviceSurfaceInfo2KHR {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSurfaceCapabilities2KHR.html>"]
pub struct SurfaceCapabilities2KHR {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub surface_capabilities: SurfaceCapabilitiesKHR,
}
impl ::std::default::Default for SurfaceCapabilities2KHR {
    fn default() -> SurfaceCapabilities2KHR {
        SurfaceCapabilities2KHR {
            s_type: StructureType::SURFACE_CAPABILITIES_2_KHR,
            p_next: ::std::ptr::null_mut(),
            surface_capabilities: SurfaceCapabilitiesKHR::default(),
        }
    }
}
impl SurfaceCapabilities2KHR {
    pub fn builder<'a>() -> SurfaceCapabilities2KHRBuilder<'a> {
        SurfaceCapabilities2KHRBuilder {
            inner: SurfaceCapabilities2KHR::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct SurfaceCapabilities2KHRBuilder<'a> {
    inner: SurfaceCapabilities2KHR,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsSurfaceCapabilities2KHR {}
impl<'a> ::std::ops::Deref for SurfaceCapabilities2KHRBuilder<'a> {
    type Target = SurfaceCapabilities2KHR;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for SurfaceCapabilities2KHRBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> SurfaceCapabilities2KHRBuilder<'a> {
    pub fn surface_capabilities(
        mut self,
        surface_capabilities: SurfaceCapabilitiesKHR,
    ) -> SurfaceCapabilities2KHRBuilder<'a> {
        self.inner.surface_capabilities = surface_capabilities;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsSurfaceCapabilities2KHR>(
        mut self,
        next: &'a mut T,
    ) -> SurfaceCapabilities2KHRBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> SurfaceCapabilities2KHR {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSurfaceFormat2KHR.html>"]
pub struct SurfaceFormat2KHR {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub surface_format: SurfaceFormatKHR,
}
impl ::std::default::Default for SurfaceFormat2KHR {
    fn default() -> SurfaceFormat2KHR {
        SurfaceFormat2KHR {
            s_type: StructureType::SURFACE_FORMAT_2_KHR,
            p_next: ::std::ptr::null_mut(),
            surface_format: SurfaceFormatKHR::default(),
        }
    }
}
impl SurfaceFormat2KHR {
    pub fn builder<'a>() -> SurfaceFormat2KHRBuilder<'a> {
        SurfaceFormat2KHRBuilder {
            inner: SurfaceFormat2KHR::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct SurfaceFormat2KHRBuilder<'a> {
    inner: SurfaceFormat2KHR,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsSurfaceFormat2KHR {}
impl<'a> ::std::ops::Deref for SurfaceFormat2KHRBuilder<'a> {
    type Target = SurfaceFormat2KHR;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for SurfaceFormat2KHRBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> SurfaceFormat2KHRBuilder<'a> {
    pub fn surface_format(
        mut self,
        surface_format: SurfaceFormatKHR,
    ) -> SurfaceFormat2KHRBuilder<'a> {
        self.inner.surface_format = surface_format;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsSurfaceFormat2KHR>(
        mut self,
        next: &'a mut T,
    ) -> SurfaceFormat2KHRBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> SurfaceFormat2KHR {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDisplayProperties2KHR.html>"]
pub struct DisplayProperties2KHR {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub display_properties: DisplayPropertiesKHR,
}
impl ::std::default::Default for DisplayProperties2KHR {
    fn default() -> DisplayProperties2KHR {
        DisplayProperties2KHR {
            s_type: StructureType::DISPLAY_PROPERTIES_2_KHR,
            p_next: ::std::ptr::null_mut(),
            display_properties: DisplayPropertiesKHR::default(),
        }
    }
}
impl DisplayProperties2KHR {
    pub fn builder<'a>() -> DisplayProperties2KHRBuilder<'a> {
        DisplayProperties2KHRBuilder {
            inner: DisplayProperties2KHR::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct DisplayProperties2KHRBuilder<'a> {
    inner: DisplayProperties2KHR,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsDisplayProperties2KHR {}
impl<'a> ::std::ops::Deref for DisplayProperties2KHRBuilder<'a> {
    type Target = DisplayProperties2KHR;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for DisplayProperties2KHRBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> DisplayProperties2KHRBuilder<'a> {
    pub fn display_properties(
        mut self,
        display_properties: DisplayPropertiesKHR,
    ) -> DisplayProperties2KHRBuilder<'a> {
        self.inner.display_properties = display_properties;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsDisplayProperties2KHR>(
        mut self,
        next: &'a mut T,
    ) -> DisplayProperties2KHRBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> DisplayProperties2KHR {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDisplayPlaneProperties2KHR.html>"]
pub struct DisplayPlaneProperties2KHR {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub display_plane_properties: DisplayPlanePropertiesKHR,
}
impl ::std::default::Default for DisplayPlaneProperties2KHR {
    fn default() -> DisplayPlaneProperties2KHR {
        DisplayPlaneProperties2KHR {
            s_type: StructureType::DISPLAY_PLANE_PROPERTIES_2_KHR,
            p_next: ::std::ptr::null_mut(),
            display_plane_properties: DisplayPlanePropertiesKHR::default(),
        }
    }
}
impl DisplayPlaneProperties2KHR {
    pub fn builder<'a>() -> DisplayPlaneProperties2KHRBuilder<'a> {
        DisplayPlaneProperties2KHRBuilder {
            inner: DisplayPlaneProperties2KHR::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct DisplayPlaneProperties2KHRBuilder<'a> {
    inner: DisplayPlaneProperties2KHR,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsDisplayPlaneProperties2KHR {}
impl<'a> ::std::ops::Deref for DisplayPlaneProperties2KHRBuilder<'a> {
    type Target = DisplayPlaneProperties2KHR;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for DisplayPlaneProperties2KHRBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> DisplayPlaneProperties2KHRBuilder<'a> {
    pub fn display_plane_properties(
        mut self,
        display_plane_properties: DisplayPlanePropertiesKHR,
    ) -> DisplayPlaneProperties2KHRBuilder<'a> {
        self.inner.display_plane_properties = display_plane_properties;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsDisplayPlaneProperties2KHR>(
        mut self,
        next: &'a mut T,
    ) -> DisplayPlaneProperties2KHRBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> DisplayPlaneProperties2KHR {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDisplayModeProperties2KHR.html>"]
pub struct DisplayModeProperties2KHR {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub display_mode_properties: DisplayModePropertiesKHR,
}
impl ::std::default::Default for DisplayModeProperties2KHR {
    fn default() -> DisplayModeProperties2KHR {
        DisplayModeProperties2KHR {
            s_type: StructureType::DISPLAY_MODE_PROPERTIES_2_KHR,
            p_next: ::std::ptr::null_mut(),
            display_mode_properties: DisplayModePropertiesKHR::default(),
        }
    }
}
impl DisplayModeProperties2KHR {
    pub fn builder<'a>() -> DisplayModeProperties2KHRBuilder<'a> {
        DisplayModeProperties2KHRBuilder {
            inner: DisplayModeProperties2KHR::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct DisplayModeProperties2KHRBuilder<'a> {
    inner: DisplayModeProperties2KHR,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsDisplayModeProperties2KHR {}
impl<'a> ::std::ops::Deref for DisplayModeProperties2KHRBuilder<'a> {
    type Target = DisplayModeProperties2KHR;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for DisplayModeProperties2KHRBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> DisplayModeProperties2KHRBuilder<'a> {
    pub fn display_mode_properties(
        mut self,
        display_mode_properties: DisplayModePropertiesKHR,
    ) -> DisplayModeProperties2KHRBuilder<'a> {
        self.inner.display_mode_properties = display_mode_properties;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsDisplayModeProperties2KHR>(
        mut self,
        next: &'a mut T,
    ) -> DisplayModeProperties2KHRBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> DisplayModeProperties2KHR {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDisplayPlaneInfo2KHR.html>"]
pub struct DisplayPlaneInfo2KHR {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub mode: DisplayModeKHR,
    pub plane_index: u32,
}
impl ::std::default::Default for DisplayPlaneInfo2KHR {
    fn default() -> DisplayPlaneInfo2KHR {
        DisplayPlaneInfo2KHR {
            s_type: StructureType::DISPLAY_PLANE_INFO_2_KHR,
            p_next: ::std::ptr::null(),
            mode: DisplayModeKHR::default(),
            plane_index: u32::default(),
        }
    }
}
impl DisplayPlaneInfo2KHR {
    pub fn builder<'a>() -> DisplayPlaneInfo2KHRBuilder<'a> {
        DisplayPlaneInfo2KHRBuilder {
            inner: DisplayPlaneInfo2KHR::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct DisplayPlaneInfo2KHRBuilder<'a> {
    inner: DisplayPlaneInfo2KHR,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsDisplayPlaneInfo2KHR {}
impl<'a> ::std::ops::Deref for DisplayPlaneInfo2KHRBuilder<'a> {
    type Target = DisplayPlaneInfo2KHR;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for DisplayPlaneInfo2KHRBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> DisplayPlaneInfo2KHRBuilder<'a> {
    pub fn mode(mut self, mode: DisplayModeKHR) -> DisplayPlaneInfo2KHRBuilder<'a> {
        self.inner.mode = mode;
        self
    }
    pub fn plane_index(mut self, plane_index: u32) -> DisplayPlaneInfo2KHRBuilder<'a> {
        self.inner.plane_index = plane_index;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsDisplayPlaneInfo2KHR>(
        mut self,
        next: &'a mut T,
    ) -> DisplayPlaneInfo2KHRBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> DisplayPlaneInfo2KHR {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDisplayPlaneCapabilities2KHR.html>"]
pub struct DisplayPlaneCapabilities2KHR {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub capabilities: DisplayPlaneCapabilitiesKHR,
}
impl ::std::default::Default for DisplayPlaneCapabilities2KHR {
    fn default() -> DisplayPlaneCapabilities2KHR {
        DisplayPlaneCapabilities2KHR {
            s_type: StructureType::DISPLAY_PLANE_CAPABILITIES_2_KHR,
            p_next: ::std::ptr::null_mut(),
            capabilities: DisplayPlaneCapabilitiesKHR::default(),
        }
    }
}
impl DisplayPlaneCapabilities2KHR {
    pub fn builder<'a>() -> DisplayPlaneCapabilities2KHRBuilder<'a> {
        DisplayPlaneCapabilities2KHRBuilder {
            inner: DisplayPlaneCapabilities2KHR::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct DisplayPlaneCapabilities2KHRBuilder<'a> {
    inner: DisplayPlaneCapabilities2KHR,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsDisplayPlaneCapabilities2KHR {}
impl<'a> ::std::ops::Deref for DisplayPlaneCapabilities2KHRBuilder<'a> {
    type Target = DisplayPlaneCapabilities2KHR;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for DisplayPlaneCapabilities2KHRBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> DisplayPlaneCapabilities2KHRBuilder<'a> {
    pub fn capabilities(
        mut self,
        capabilities: DisplayPlaneCapabilitiesKHR,
    ) -> DisplayPlaneCapabilities2KHRBuilder<'a> {
        self.inner.capabilities = capabilities;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsDisplayPlaneCapabilities2KHR>(
        mut self,
        next: &'a mut T,
    ) -> DisplayPlaneCapabilities2KHRBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> DisplayPlaneCapabilities2KHR {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSharedPresentSurfaceCapabilitiesKHR.html>"]
pub struct SharedPresentSurfaceCapabilitiesKHR {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub shared_present_supported_usage_flags: ImageUsageFlags,
}
impl ::std::default::Default for SharedPresentSurfaceCapabilitiesKHR {
    fn default() -> SharedPresentSurfaceCapabilitiesKHR {
        SharedPresentSurfaceCapabilitiesKHR {
            s_type: StructureType::SHARED_PRESENT_SURFACE_CAPABILITIES_KHR,
            p_next: ::std::ptr::null_mut(),
            shared_present_supported_usage_flags: ImageUsageFlags::default(),
        }
    }
}
impl SharedPresentSurfaceCapabilitiesKHR {
    pub fn builder<'a>() -> SharedPresentSurfaceCapabilitiesKHRBuilder<'a> {
        SharedPresentSurfaceCapabilitiesKHRBuilder {
            inner: SharedPresentSurfaceCapabilitiesKHR::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct SharedPresentSurfaceCapabilitiesKHRBuilder<'a> {
    inner: SharedPresentSurfaceCapabilitiesKHR,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsSurfaceCapabilities2KHR for SharedPresentSurfaceCapabilitiesKHRBuilder<'_> {}
unsafe impl ExtendsSurfaceCapabilities2KHR for SharedPresentSurfaceCapabilitiesKHR {}
impl<'a> ::std::ops::Deref for SharedPresentSurfaceCapabilitiesKHRBuilder<'a> {
    type Target = SharedPresentSurfaceCapabilitiesKHR;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for SharedPresentSurfaceCapabilitiesKHRBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> SharedPresentSurfaceCapabilitiesKHRBuilder<'a> {
    pub fn shared_present_supported_usage_flags(
        mut self,
        shared_present_supported_usage_flags: ImageUsageFlags,
    ) -> SharedPresentSurfaceCapabilitiesKHRBuilder<'a> {
        self.inner.shared_present_supported_usage_flags = shared_present_supported_usage_flags;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> SharedPresentSurfaceCapabilitiesKHR {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDevice16BitStorageFeatures.html>"]
pub struct PhysicalDevice16BitStorageFeatures {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub storage_buffer16_bit_access: Bool32,
    pub uniform_and_storage_buffer16_bit_access: Bool32,
    pub storage_push_constant16: Bool32,
    pub storage_input_output16: Bool32,
}
impl ::std::default::Default for PhysicalDevice16BitStorageFeatures {
    fn default() -> PhysicalDevice16BitStorageFeatures {
        PhysicalDevice16BitStorageFeatures {
            s_type: StructureType::PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES,
            p_next: ::std::ptr::null_mut(),
            storage_buffer16_bit_access: Bool32::default(),
            uniform_and_storage_buffer16_bit_access: Bool32::default(),
            storage_push_constant16: Bool32::default(),
            storage_input_output16: Bool32::default(),
        }
    }
}
impl PhysicalDevice16BitStorageFeatures {
    pub fn builder<'a>() -> PhysicalDevice16BitStorageFeaturesBuilder<'a> {
        PhysicalDevice16BitStorageFeaturesBuilder {
            inner: PhysicalDevice16BitStorageFeatures::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDevice16BitStorageFeaturesBuilder<'a> {
    inner: PhysicalDevice16BitStorageFeatures,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsDeviceCreateInfo for PhysicalDevice16BitStorageFeaturesBuilder<'_> {}
unsafe impl ExtendsDeviceCreateInfo for PhysicalDevice16BitStorageFeatures {}
impl<'a> ::std::ops::Deref for PhysicalDevice16BitStorageFeaturesBuilder<'a> {
    type Target = PhysicalDevice16BitStorageFeatures;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PhysicalDevice16BitStorageFeaturesBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDevice16BitStorageFeaturesBuilder<'a> {
    pub fn storage_buffer16_bit_access(
        mut self,
        storage_buffer16_bit_access: bool,
    ) -> PhysicalDevice16BitStorageFeaturesBuilder<'a> {
        self.inner.storage_buffer16_bit_access = storage_buffer16_bit_access.into();
        self
    }
    pub fn uniform_and_storage_buffer16_bit_access(
        mut self,
        uniform_and_storage_buffer16_bit_access: bool,
    ) -> PhysicalDevice16BitStorageFeaturesBuilder<'a> {
        self.inner.uniform_and_storage_buffer16_bit_access =
            uniform_and_storage_buffer16_bit_access.into();
        self
    }
    pub fn storage_push_constant16(
        mut self,
        storage_push_constant16: bool,
    ) -> PhysicalDevice16BitStorageFeaturesBuilder<'a> {
        self.inner.storage_push_constant16 = storage_push_constant16.into();
        self
    }
    pub fn storage_input_output16(
        mut self,
        storage_input_output16: bool,
    ) -> PhysicalDevice16BitStorageFeaturesBuilder<'a> {
        self.inner.storage_input_output16 = storage_input_output16.into();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDevice16BitStorageFeatures {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceSubgroupProperties.html>"]
pub struct PhysicalDeviceSubgroupProperties {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub subgroup_size: u32,
    pub supported_stages: ShaderStageFlags,
    pub supported_operations: SubgroupFeatureFlags,
    pub quad_operations_in_all_stages: Bool32,
}
impl ::std::default::Default for PhysicalDeviceSubgroupProperties {
    fn default() -> PhysicalDeviceSubgroupProperties {
        PhysicalDeviceSubgroupProperties {
            s_type: StructureType::PHYSICAL_DEVICE_SUBGROUP_PROPERTIES,
            p_next: ::std::ptr::null_mut(),
            subgroup_size: u32::default(),
            supported_stages: ShaderStageFlags::default(),
            supported_operations: SubgroupFeatureFlags::default(),
            quad_operations_in_all_stages: Bool32::default(),
        }
    }
}
impl PhysicalDeviceSubgroupProperties {
    pub fn builder<'a>() -> PhysicalDeviceSubgroupPropertiesBuilder<'a> {
        PhysicalDeviceSubgroupPropertiesBuilder {
            inner: PhysicalDeviceSubgroupProperties::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDeviceSubgroupPropertiesBuilder<'a> {
    inner: PhysicalDeviceSubgroupProperties,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceSubgroupPropertiesBuilder<'_> {}
unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceSubgroupProperties {}
impl<'a> ::std::ops::Deref for PhysicalDeviceSubgroupPropertiesBuilder<'a> {
    type Target = PhysicalDeviceSubgroupProperties;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PhysicalDeviceSubgroupPropertiesBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDeviceSubgroupPropertiesBuilder<'a> {
    pub fn subgroup_size(
        mut self,
        subgroup_size: u32,
    ) -> PhysicalDeviceSubgroupPropertiesBuilder<'a> {
        self.inner.subgroup_size = subgroup_size;
        self
    }
    pub fn supported_stages(
        mut self,
        supported_stages: ShaderStageFlags,
    ) -> PhysicalDeviceSubgroupPropertiesBuilder<'a> {
        self.inner.supported_stages = supported_stages;
        self
    }
    pub fn supported_operations(
        mut self,
        supported_operations: SubgroupFeatureFlags,
    ) -> PhysicalDeviceSubgroupPropertiesBuilder<'a> {
        self.inner.supported_operations = supported_operations;
        self
    }
    pub fn quad_operations_in_all_stages(
        mut self,
        quad_operations_in_all_stages: bool,
    ) -> PhysicalDeviceSubgroupPropertiesBuilder<'a> {
        self.inner.quad_operations_in_all_stages = quad_operations_in_all_stages.into();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDeviceSubgroupProperties {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures.html>"]
pub struct PhysicalDeviceShaderSubgroupExtendedTypesFeatures {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub shader_subgroup_extended_types: Bool32,
}
impl ::std::default::Default for PhysicalDeviceShaderSubgroupExtendedTypesFeatures {
    fn default() -> PhysicalDeviceShaderSubgroupExtendedTypesFeatures {
        PhysicalDeviceShaderSubgroupExtendedTypesFeatures {
            s_type: StructureType::PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES,
            p_next: ::std::ptr::null_mut(),
            shader_subgroup_extended_types: Bool32::default(),
        }
    }
}
impl PhysicalDeviceShaderSubgroupExtendedTypesFeatures {
    pub fn builder<'a>() -> PhysicalDeviceShaderSubgroupExtendedTypesFeaturesBuilder<'a> {
        PhysicalDeviceShaderSubgroupExtendedTypesFeaturesBuilder {
            inner: PhysicalDeviceShaderSubgroupExtendedTypesFeatures::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDeviceShaderSubgroupExtendedTypesFeaturesBuilder<'a> {
    inner: PhysicalDeviceShaderSubgroupExtendedTypesFeatures,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsDeviceCreateInfo
    for PhysicalDeviceShaderSubgroupExtendedTypesFeaturesBuilder<'_>
{
}
unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderSubgroupExtendedTypesFeatures {}
impl<'a> ::std::ops::Deref for PhysicalDeviceShaderSubgroupExtendedTypesFeaturesBuilder<'a> {
    type Target = PhysicalDeviceShaderSubgroupExtendedTypesFeatures;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderSubgroupExtendedTypesFeaturesBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDeviceShaderSubgroupExtendedTypesFeaturesBuilder<'a> {
    pub fn shader_subgroup_extended_types(
        mut self,
        shader_subgroup_extended_types: bool,
    ) -> PhysicalDeviceShaderSubgroupExtendedTypesFeaturesBuilder<'a> {
        self.inner.shader_subgroup_extended_types = shader_subgroup_extended_types.into();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDeviceShaderSubgroupExtendedTypesFeatures {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkBufferMemoryRequirementsInfo2.html>"]
pub struct BufferMemoryRequirementsInfo2 {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub buffer: Buffer,
}
impl ::std::default::Default for BufferMemoryRequirementsInfo2 {
    fn default() -> BufferMemoryRequirementsInfo2 {
        BufferMemoryRequirementsInfo2 {
            s_type: StructureType::BUFFER_MEMORY_REQUIREMENTS_INFO_2,
            p_next: ::std::ptr::null(),
            buffer: Buffer::default(),
        }
    }
}
impl BufferMemoryRequirementsInfo2 {
    pub fn builder<'a>() -> BufferMemoryRequirementsInfo2Builder<'a> {
        BufferMemoryRequirementsInfo2Builder {
            inner: BufferMemoryRequirementsInfo2::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct BufferMemoryRequirementsInfo2Builder<'a> {
    inner: BufferMemoryRequirementsInfo2,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsBufferMemoryRequirementsInfo2 {}
impl<'a> ::std::ops::Deref for BufferMemoryRequirementsInfo2Builder<'a> {
    type Target = BufferMemoryRequirementsInfo2;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for BufferMemoryRequirementsInfo2Builder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> BufferMemoryRequirementsInfo2Builder<'a> {
    pub fn buffer(mut self, buffer: Buffer) -> BufferMemoryRequirementsInfo2Builder<'a> {
        self.inner.buffer = buffer;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsBufferMemoryRequirementsInfo2>(
        mut self,
        next: &'a mut T,
    ) -> BufferMemoryRequirementsInfo2Builder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> BufferMemoryRequirementsInfo2 {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImageMemoryRequirementsInfo2.html>"]
pub struct ImageMemoryRequirementsInfo2 {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub image: Image,
}
impl ::std::default::Default for ImageMemoryRequirementsInfo2 {
    fn default() -> ImageMemoryRequirementsInfo2 {
        ImageMemoryRequirementsInfo2 {
            s_type: StructureType::IMAGE_MEMORY_REQUIREMENTS_INFO_2,
            p_next: ::std::ptr::null(),
            image: Image::default(),
        }
    }
}
impl ImageMemoryRequirementsInfo2 {
    pub fn builder<'a>() -> ImageMemoryRequirementsInfo2Builder<'a> {
        ImageMemoryRequirementsInfo2Builder {
            inner: ImageMemoryRequirementsInfo2::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct ImageMemoryRequirementsInfo2Builder<'a> {
    inner: ImageMemoryRequirementsInfo2,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsImageMemoryRequirementsInfo2 {}
impl<'a> ::std::ops::Deref for ImageMemoryRequirementsInfo2Builder<'a> {
    type Target = ImageMemoryRequirementsInfo2;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for ImageMemoryRequirementsInfo2Builder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> ImageMemoryRequirementsInfo2Builder<'a> {
    pub fn image(mut self, image: Image) -> ImageMemoryRequirementsInfo2Builder<'a> {
        self.inner.image = image;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsImageMemoryRequirementsInfo2>(
        mut self,
        next: &'a mut T,
    ) -> ImageMemoryRequirementsInfo2Builder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> ImageMemoryRequirementsInfo2 {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImageSparseMemoryRequirementsInfo2.html>"]
pub struct ImageSparseMemoryRequirementsInfo2 {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub image: Image,
}
impl ::std::default::Default for ImageSparseMemoryRequirementsInfo2 {
    fn default() -> ImageSparseMemoryRequirementsInfo2 {
        ImageSparseMemoryRequirementsInfo2 {
            s_type: StructureType::IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2,
            p_next: ::std::ptr::null(),
            image: Image::default(),
        }
    }
}
impl ImageSparseMemoryRequirementsInfo2 {
    pub fn builder<'a>() -> ImageSparseMemoryRequirementsInfo2Builder<'a> {
        ImageSparseMemoryRequirementsInfo2Builder {
            inner: ImageSparseMemoryRequirementsInfo2::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct ImageSparseMemoryRequirementsInfo2Builder<'a> {
    inner: ImageSparseMemoryRequirementsInfo2,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsImageSparseMemoryRequirementsInfo2 {}
impl<'a> ::std::ops::Deref for ImageSparseMemoryRequirementsInfo2Builder<'a> {
    type Target = ImageSparseMemoryRequirementsInfo2;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for ImageSparseMemoryRequirementsInfo2Builder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> ImageSparseMemoryRequirementsInfo2Builder<'a> {
    pub fn image(mut self, image: Image) -> ImageSparseMemoryRequirementsInfo2Builder<'a> {
        self.inner.image = image;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsImageSparseMemoryRequirementsInfo2>(
        mut self,
        next: &'a mut T,
    ) -> ImageSparseMemoryRequirementsInfo2Builder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> ImageSparseMemoryRequirementsInfo2 {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkMemoryRequirements2.html>"]
pub struct MemoryRequirements2 {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub memory_requirements: MemoryRequirements,
}
impl ::std::default::Default for MemoryRequirements2 {
    fn default() -> MemoryRequirements2 {
        MemoryRequirements2 {
            s_type: StructureType::MEMORY_REQUIREMENTS_2,
            p_next: ::std::ptr::null_mut(),
            memory_requirements: MemoryRequirements::default(),
        }
    }
}
impl MemoryRequirements2 {
    pub fn builder<'a>() -> MemoryRequirements2Builder<'a> {
        MemoryRequirements2Builder {
            inner: MemoryRequirements2::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct MemoryRequirements2Builder<'a> {
    inner: MemoryRequirements2,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsMemoryRequirements2 {}
impl<'a> ::std::ops::Deref for MemoryRequirements2Builder<'a> {
    type Target = MemoryRequirements2;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for MemoryRequirements2Builder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> MemoryRequirements2Builder<'a> {
    pub fn memory_requirements(
        mut self,
        memory_requirements: MemoryRequirements,
    ) -> MemoryRequirements2Builder<'a> {
        self.inner.memory_requirements = memory_requirements;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsMemoryRequirements2>(
        mut self,
        next: &'a mut T,
    ) -> MemoryRequirements2Builder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> MemoryRequirements2 {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSparseImageMemoryRequirements2.html>"]
pub struct SparseImageMemoryRequirements2 {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub memory_requirements: SparseImageMemoryRequirements,
}
impl ::std::default::Default for SparseImageMemoryRequirements2 {
    fn default() -> SparseImageMemoryRequirements2 {
        SparseImageMemoryRequirements2 {
            s_type: StructureType::SPARSE_IMAGE_MEMORY_REQUIREMENTS_2,
            p_next: ::std::ptr::null_mut(),
            memory_requirements: SparseImageMemoryRequirements::default(),
        }
    }
}
impl SparseImageMemoryRequirements2 {
    pub fn builder<'a>() -> SparseImageMemoryRequirements2Builder<'a> {
        SparseImageMemoryRequirements2Builder {
            inner: SparseImageMemoryRequirements2::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct SparseImageMemoryRequirements2Builder<'a> {
    inner: SparseImageMemoryRequirements2,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsSparseImageMemoryRequirements2 {}
impl<'a> ::std::ops::Deref for SparseImageMemoryRequirements2Builder<'a> {
    type Target = SparseImageMemoryRequirements2;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for SparseImageMemoryRequirements2Builder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> SparseImageMemoryRequirements2Builder<'a> {
    pub fn memory_requirements(
        mut self,
        memory_requirements: SparseImageMemoryRequirements,
    ) -> SparseImageMemoryRequirements2Builder<'a> {
        self.inner.memory_requirements = memory_requirements;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsSparseImageMemoryRequirements2>(
        mut self,
        next: &'a mut T,
    ) -> SparseImageMemoryRequirements2Builder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> SparseImageMemoryRequirements2 {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDevicePointClippingProperties.html>"]
pub struct PhysicalDevicePointClippingProperties {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub point_clipping_behavior: PointClippingBehavior,
}
impl ::std::default::Default for PhysicalDevicePointClippingProperties {
    fn default() -> PhysicalDevicePointClippingProperties {
        PhysicalDevicePointClippingProperties {
            s_type: StructureType::PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES,
            p_next: ::std::ptr::null_mut(),
            point_clipping_behavior: PointClippingBehavior::default(),
        }
    }
}
impl PhysicalDevicePointClippingProperties {
    pub fn builder<'a>() -> PhysicalDevicePointClippingPropertiesBuilder<'a> {
        PhysicalDevicePointClippingPropertiesBuilder {
            inner: PhysicalDevicePointClippingProperties::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDevicePointClippingPropertiesBuilder<'a> {
    inner: PhysicalDevicePointClippingProperties,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDevicePointClippingPropertiesBuilder<'_> {}
unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDevicePointClippingProperties {}
impl<'a> ::std::ops::Deref for PhysicalDevicePointClippingPropertiesBuilder<'a> {
    type Target = PhysicalDevicePointClippingProperties;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PhysicalDevicePointClippingPropertiesBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDevicePointClippingPropertiesBuilder<'a> {
    pub fn point_clipping_behavior(
        mut self,
        point_clipping_behavior: PointClippingBehavior,
    ) -> PhysicalDevicePointClippingPropertiesBuilder<'a> {
        self.inner.point_clipping_behavior = point_clipping_behavior;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDevicePointClippingProperties {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkMemoryDedicatedRequirements.html>"]
pub struct MemoryDedicatedRequirements {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub prefers_dedicated_allocation: Bool32,
    pub requires_dedicated_allocation: Bool32,
}
impl ::std::default::Default for MemoryDedicatedRequirements {
    fn default() -> MemoryDedicatedRequirements {
        MemoryDedicatedRequirements {
            s_type: StructureType::MEMORY_DEDICATED_REQUIREMENTS,
            p_next: ::std::ptr::null_mut(),
            prefers_dedicated_allocation: Bool32::default(),
            requires_dedicated_allocation: Bool32::default(),
        }
    }
}
impl MemoryDedicatedRequirements {
    pub fn builder<'a>() -> MemoryDedicatedRequirementsBuilder<'a> {
        MemoryDedicatedRequirementsBuilder {
            inner: MemoryDedicatedRequirements::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct MemoryDedicatedRequirementsBuilder<'a> {
    inner: MemoryDedicatedRequirements,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsMemoryRequirements2 for MemoryDedicatedRequirementsBuilder<'_> {}
unsafe impl ExtendsMemoryRequirements2 for MemoryDedicatedRequirements {}
impl<'a> ::std::ops::Deref for MemoryDedicatedRequirementsBuilder<'a> {
    type Target = MemoryDedicatedRequirements;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for MemoryDedicatedRequirementsBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> MemoryDedicatedRequirementsBuilder<'a> {
    pub fn prefers_dedicated_allocation(
        mut self,
        prefers_dedicated_allocation: bool,
    ) -> MemoryDedicatedRequirementsBuilder<'a> {
        self.inner.prefers_dedicated_allocation = prefers_dedicated_allocation.into();
        self
    }
    pub fn requires_dedicated_allocation(
        mut self,
        requires_dedicated_allocation: bool,
    ) -> MemoryDedicatedRequirementsBuilder<'a> {
        self.inner.requires_dedicated_allocation = requires_dedicated_allocation.into();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> MemoryDedicatedRequirements {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkMemoryDedicatedAllocateInfo.html>"]
pub struct MemoryDedicatedAllocateInfo {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub image: Image,
    pub buffer: Buffer,
}
impl ::std::default::Default for MemoryDedicatedAllocateInfo {
    fn default() -> MemoryDedicatedAllocateInfo {
        MemoryDedicatedAllocateInfo {
            s_type: StructureType::MEMORY_DEDICATED_ALLOCATE_INFO,
            p_next: ::std::ptr::null(),
            image: Image::default(),
            buffer: Buffer::default(),
        }
    }
}
impl MemoryDedicatedAllocateInfo {
    pub fn builder<'a>() -> MemoryDedicatedAllocateInfoBuilder<'a> {
        MemoryDedicatedAllocateInfoBuilder {
            inner: MemoryDedicatedAllocateInfo::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct MemoryDedicatedAllocateInfoBuilder<'a> {
    inner: MemoryDedicatedAllocateInfo,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsMemoryAllocateInfo for MemoryDedicatedAllocateInfoBuilder<'_> {}
unsafe impl ExtendsMemoryAllocateInfo for MemoryDedicatedAllocateInfo {}
impl<'a> ::std::ops::Deref for MemoryDedicatedAllocateInfoBuilder<'a> {
    type Target = MemoryDedicatedAllocateInfo;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for MemoryDedicatedAllocateInfoBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> MemoryDedicatedAllocateInfoBuilder<'a> {
    pub fn image(mut self, image: Image) -> MemoryDedicatedAllocateInfoBuilder<'a> {
        self.inner.image = image;
        self
    }
    pub fn buffer(mut self, buffer: Buffer) -> MemoryDedicatedAllocateInfoBuilder<'a> {
        self.inner.buffer = buffer;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> MemoryDedicatedAllocateInfo {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImageViewUsageCreateInfo.html>"]
pub struct ImageViewUsageCreateInfo {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub usage: ImageUsageFlags,
}
impl ::std::default::Default for ImageViewUsageCreateInfo {
    fn default() -> ImageViewUsageCreateInfo {
        ImageViewUsageCreateInfo {
            s_type: StructureType::IMAGE_VIEW_USAGE_CREATE_INFO,
            p_next: ::std::ptr::null(),
            usage: ImageUsageFlags::default(),
        }
    }
}
impl ImageViewUsageCreateInfo {
    pub fn builder<'a>() -> ImageViewUsageCreateInfoBuilder<'a> {
        ImageViewUsageCreateInfoBuilder {
            inner: ImageViewUsageCreateInfo::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct ImageViewUsageCreateInfoBuilder<'a> {
    inner: ImageViewUsageCreateInfo,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsImageViewCreateInfo for ImageViewUsageCreateInfoBuilder<'_> {}
unsafe impl ExtendsImageViewCreateInfo for ImageViewUsageCreateInfo {}
impl<'a> ::std::ops::Deref for ImageViewUsageCreateInfoBuilder<'a> {
    type Target = ImageViewUsageCreateInfo;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for ImageViewUsageCreateInfoBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> ImageViewUsageCreateInfoBuilder<'a> {
    pub fn usage(mut self, usage: ImageUsageFlags) -> ImageViewUsageCreateInfoBuilder<'a> {
        self.inner.usage = usage;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> ImageViewUsageCreateInfo {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineTessellationDomainOriginStateCreateInfo.html>"]
pub struct PipelineTessellationDomainOriginStateCreateInfo {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub domain_origin: TessellationDomainOrigin,
}
impl ::std::default::Default for PipelineTessellationDomainOriginStateCreateInfo {
    fn default() -> PipelineTessellationDomainOriginStateCreateInfo {
        PipelineTessellationDomainOriginStateCreateInfo {
            s_type: StructureType::PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO,
            p_next: ::std::ptr::null(),
            domain_origin: TessellationDomainOrigin::default(),
        }
    }
}
impl PipelineTessellationDomainOriginStateCreateInfo {
    pub fn builder<'a>() -> PipelineTessellationDomainOriginStateCreateInfoBuilder<'a> {
        PipelineTessellationDomainOriginStateCreateInfoBuilder {
            inner: PipelineTessellationDomainOriginStateCreateInfo::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PipelineTessellationDomainOriginStateCreateInfoBuilder<'a> {
    inner: PipelineTessellationDomainOriginStateCreateInfo,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsPipelineTessellationStateCreateInfo
    for PipelineTessellationDomainOriginStateCreateInfoBuilder<'_>
{
}
unsafe impl ExtendsPipelineTessellationStateCreateInfo
    for PipelineTessellationDomainOriginStateCreateInfo
{
}
impl<'a> ::std::ops::Deref for PipelineTessellationDomainOriginStateCreateInfoBuilder<'a> {
    type Target = PipelineTessellationDomainOriginStateCreateInfo;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PipelineTessellationDomainOriginStateCreateInfoBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PipelineTessellationDomainOriginStateCreateInfoBuilder<'a> {
    pub fn domain_origin(
        mut self,
        domain_origin: TessellationDomainOrigin,
    ) -> PipelineTessellationDomainOriginStateCreateInfoBuilder<'a> {
        self.inner.domain_origin = domain_origin;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PipelineTessellationDomainOriginStateCreateInfo {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSamplerYcbcrConversionInfo.html>"]
pub struct SamplerYcbcrConversionInfo {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub conversion: SamplerYcbcrConversion,
}
impl ::std::default::Default for SamplerYcbcrConversionInfo {
    fn default() -> SamplerYcbcrConversionInfo {
        SamplerYcbcrConversionInfo {
            s_type: StructureType::SAMPLER_YCBCR_CONVERSION_INFO,
            p_next: ::std::ptr::null(),
            conversion: SamplerYcbcrConversion::default(),
        }
    }
}
impl SamplerYcbcrConversionInfo {
    pub fn builder<'a>() -> SamplerYcbcrConversionInfoBuilder<'a> {
        SamplerYcbcrConversionInfoBuilder {
            inner: SamplerYcbcrConversionInfo::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct SamplerYcbcrConversionInfoBuilder<'a> {
    inner: SamplerYcbcrConversionInfo,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsSamplerCreateInfo for SamplerYcbcrConversionInfoBuilder<'_> {}
unsafe impl ExtendsSamplerCreateInfo for SamplerYcbcrConversionInfo {}
unsafe impl ExtendsImageViewCreateInfo for SamplerYcbcrConversionInfoBuilder<'_> {}
unsafe impl ExtendsImageViewCreateInfo for SamplerYcbcrConversionInfo {}
impl<'a> ::std::ops::Deref for SamplerYcbcrConversionInfoBuilder<'a> {
    type Target = SamplerYcbcrConversionInfo;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for SamplerYcbcrConversionInfoBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> SamplerYcbcrConversionInfoBuilder<'a> {
    pub fn conversion(
        mut self,
        conversion: SamplerYcbcrConversion,
    ) -> SamplerYcbcrConversionInfoBuilder<'a> {
        self.inner.conversion = conversion;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> SamplerYcbcrConversionInfo {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSamplerYcbcrConversionCreateInfo.html>"]
pub struct SamplerYcbcrConversionCreateInfo {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub format: Format,
    pub ycbcr_model: SamplerYcbcrModelConversion,
    pub ycbcr_range: SamplerYcbcrRange,
    pub components: ComponentMapping,
    pub x_chroma_offset: ChromaLocation,
    pub y_chroma_offset: ChromaLocation,
    pub chroma_filter: Filter,
    pub force_explicit_reconstruction: Bool32,
}
impl ::std::default::Default for SamplerYcbcrConversionCreateInfo {
    fn default() -> SamplerYcbcrConversionCreateInfo {
        SamplerYcbcrConversionCreateInfo {
            s_type: StructureType::SAMPLER_YCBCR_CONVERSION_CREATE_INFO,
            p_next: ::std::ptr::null(),
            format: Format::default(),
            ycbcr_model: SamplerYcbcrModelConversion::default(),
            ycbcr_range: SamplerYcbcrRange::default(),
            components: ComponentMapping::default(),
            x_chroma_offset: ChromaLocation::default(),
            y_chroma_offset: ChromaLocation::default(),
            chroma_filter: Filter::default(),
            force_explicit_reconstruction: Bool32::default(),
        }
    }
}
impl SamplerYcbcrConversionCreateInfo {
    pub fn builder<'a>() -> SamplerYcbcrConversionCreateInfoBuilder<'a> {
        SamplerYcbcrConversionCreateInfoBuilder {
            inner: SamplerYcbcrConversionCreateInfo::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct SamplerYcbcrConversionCreateInfoBuilder<'a> {
    inner: SamplerYcbcrConversionCreateInfo,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsSamplerYcbcrConversionCreateInfo {}
impl<'a> ::std::ops::Deref for SamplerYcbcrConversionCreateInfoBuilder<'a> {
    type Target = SamplerYcbcrConversionCreateInfo;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for SamplerYcbcrConversionCreateInfoBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> SamplerYcbcrConversionCreateInfoBuilder<'a> {
    pub fn format(mut self, format: Format) -> SamplerYcbcrConversionCreateInfoBuilder<'a> {
        self.inner.format = format;
        self
    }
    pub fn ycbcr_model(
        mut self,
        ycbcr_model: SamplerYcbcrModelConversion,
    ) -> SamplerYcbcrConversionCreateInfoBuilder<'a> {
        self.inner.ycbcr_model = ycbcr_model;
        self
    }
    pub fn ycbcr_range(
        mut self,
        ycbcr_range: SamplerYcbcrRange,
    ) -> SamplerYcbcrConversionCreateInfoBuilder<'a> {
        self.inner.ycbcr_range = ycbcr_range;
        self
    }
    pub fn components(
        mut self,
        components: ComponentMapping,
    ) -> SamplerYcbcrConversionCreateInfoBuilder<'a> {
        self.inner.components = components;
        self
    }
    pub fn x_chroma_offset(
        mut self,
        x_chroma_offset: ChromaLocation,
    ) -> SamplerYcbcrConversionCreateInfoBuilder<'a> {
        self.inner.x_chroma_offset = x_chroma_offset;
        self
    }
    pub fn y_chroma_offset(
        mut self,
        y_chroma_offset: ChromaLocation,
    ) -> SamplerYcbcrConversionCreateInfoBuilder<'a> {
        self.inner.y_chroma_offset = y_chroma_offset;
        self
    }
    pub fn chroma_filter(
        mut self,
        chroma_filter: Filter,
    ) -> SamplerYcbcrConversionCreateInfoBuilder<'a> {
        self.inner.chroma_filter = chroma_filter;
        self
    }
    pub fn force_explicit_reconstruction(
        mut self,
        force_explicit_reconstruction: bool,
    ) -> SamplerYcbcrConversionCreateInfoBuilder<'a> {
        self.inner.force_explicit_reconstruction = force_explicit_reconstruction.into();
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsSamplerYcbcrConversionCreateInfo>(
        mut self,
        next: &'a mut T,
    ) -> SamplerYcbcrConversionCreateInfoBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> SamplerYcbcrConversionCreateInfo {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkBindImagePlaneMemoryInfo.html>"]
pub struct BindImagePlaneMemoryInfo {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub plane_aspect: ImageAspectFlags,
}
impl ::std::default::Default for BindImagePlaneMemoryInfo {
    fn default() -> BindImagePlaneMemoryInfo {
        BindImagePlaneMemoryInfo {
            s_type: StructureType::BIND_IMAGE_PLANE_MEMORY_INFO,
            p_next: ::std::ptr::null(),
            plane_aspect: ImageAspectFlags::default(),
        }
    }
}
impl BindImagePlaneMemoryInfo {
    pub fn builder<'a>() -> BindImagePlaneMemoryInfoBuilder<'a> {
        BindImagePlaneMemoryInfoBuilder {
            inner: BindImagePlaneMemoryInfo::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct BindImagePlaneMemoryInfoBuilder<'a> {
    inner: BindImagePlaneMemoryInfo,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsBindImageMemoryInfo for BindImagePlaneMemoryInfoBuilder<'_> {}
unsafe impl ExtendsBindImageMemoryInfo for BindImagePlaneMemoryInfo {}
impl<'a> ::std::ops::Deref for BindImagePlaneMemoryInfoBuilder<'a> {
    type Target = BindImagePlaneMemoryInfo;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for BindImagePlaneMemoryInfoBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> BindImagePlaneMemoryInfoBuilder<'a> {
    pub fn plane_aspect(
        mut self,
        plane_aspect: ImageAspectFlags,
    ) -> BindImagePlaneMemoryInfoBuilder<'a> {
        self.inner.plane_aspect = plane_aspect;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> BindImagePlaneMemoryInfo {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImagePlaneMemoryRequirementsInfo.html>"]
pub struct ImagePlaneMemoryRequirementsInfo {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub plane_aspect: ImageAspectFlags,
}
impl ::std::default::Default for ImagePlaneMemoryRequirementsInfo {
    fn default() -> ImagePlaneMemoryRequirementsInfo {
        ImagePlaneMemoryRequirementsInfo {
            s_type: StructureType::IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO,
            p_next: ::std::ptr::null(),
            plane_aspect: ImageAspectFlags::default(),
        }
    }
}
impl ImagePlaneMemoryRequirementsInfo {
    pub fn builder<'a>() -> ImagePlaneMemoryRequirementsInfoBuilder<'a> {
        ImagePlaneMemoryRequirementsInfoBuilder {
            inner: ImagePlaneMemoryRequirementsInfo::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct ImagePlaneMemoryRequirementsInfoBuilder<'a> {
    inner: ImagePlaneMemoryRequirementsInfo,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsImageMemoryRequirementsInfo2 for ImagePlaneMemoryRequirementsInfoBuilder<'_> {}
unsafe impl ExtendsImageMemoryRequirementsInfo2 for ImagePlaneMemoryRequirementsInfo {}
impl<'a> ::std::ops::Deref for ImagePlaneMemoryRequirementsInfoBuilder<'a> {
    type Target = ImagePlaneMemoryRequirementsInfo;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for ImagePlaneMemoryRequirementsInfoBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> ImagePlaneMemoryRequirementsInfoBuilder<'a> {
    pub fn plane_aspect(
        mut self,
        plane_aspect: ImageAspectFlags,
    ) -> ImagePlaneMemoryRequirementsInfoBuilder<'a> {
        self.inner.plane_aspect = plane_aspect;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> ImagePlaneMemoryRequirementsInfo {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceSamplerYcbcrConversionFeatures.html>"]
pub struct PhysicalDeviceSamplerYcbcrConversionFeatures {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub sampler_ycbcr_conversion: Bool32,
}
impl ::std::default::Default for PhysicalDeviceSamplerYcbcrConversionFeatures {
    fn default() -> PhysicalDeviceSamplerYcbcrConversionFeatures {
        PhysicalDeviceSamplerYcbcrConversionFeatures {
            s_type: StructureType::PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES,
            p_next: ::std::ptr::null_mut(),
            sampler_ycbcr_conversion: Bool32::default(),
        }
    }
}
impl PhysicalDeviceSamplerYcbcrConversionFeatures {
    pub fn builder<'a>() -> PhysicalDeviceSamplerYcbcrConversionFeaturesBuilder<'a> {
        PhysicalDeviceSamplerYcbcrConversionFeaturesBuilder {
            inner: PhysicalDeviceSamplerYcbcrConversionFeatures::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDeviceSamplerYcbcrConversionFeaturesBuilder<'a> {
    inner: PhysicalDeviceSamplerYcbcrConversionFeatures,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceSamplerYcbcrConversionFeaturesBuilder<'_> {}
unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceSamplerYcbcrConversionFeatures {}
impl<'a> ::std::ops::Deref for PhysicalDeviceSamplerYcbcrConversionFeaturesBuilder<'a> {
    type Target = PhysicalDeviceSamplerYcbcrConversionFeatures;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PhysicalDeviceSamplerYcbcrConversionFeaturesBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDeviceSamplerYcbcrConversionFeaturesBuilder<'a> {
    pub fn sampler_ycbcr_conversion(
        mut self,
        sampler_ycbcr_conversion: bool,
    ) -> PhysicalDeviceSamplerYcbcrConversionFeaturesBuilder<'a> {
        self.inner.sampler_ycbcr_conversion = sampler_ycbcr_conversion.into();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDeviceSamplerYcbcrConversionFeatures {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSamplerYcbcrConversionImageFormatProperties.html>"]
pub struct SamplerYcbcrConversionImageFormatProperties {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub combined_image_sampler_descriptor_count: u32,
}
impl ::std::default::Default for SamplerYcbcrConversionImageFormatProperties {
    fn default() -> SamplerYcbcrConversionImageFormatProperties {
        SamplerYcbcrConversionImageFormatProperties {
            s_type: StructureType::SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES,
            p_next: ::std::ptr::null_mut(),
            combined_image_sampler_descriptor_count: u32::default(),
        }
    }
}
impl SamplerYcbcrConversionImageFormatProperties {
    pub fn builder<'a>() -> SamplerYcbcrConversionImageFormatPropertiesBuilder<'a> {
        SamplerYcbcrConversionImageFormatPropertiesBuilder {
            inner: SamplerYcbcrConversionImageFormatProperties::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct SamplerYcbcrConversionImageFormatPropertiesBuilder<'a> {
    inner: SamplerYcbcrConversionImageFormatProperties,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsImageFormatProperties2
    for SamplerYcbcrConversionImageFormatPropertiesBuilder<'_>
{
}
unsafe impl ExtendsImageFormatProperties2 for SamplerYcbcrConversionImageFormatProperties {}
impl<'a> ::std::ops::Deref for SamplerYcbcrConversionImageFormatPropertiesBuilder<'a> {
    type Target = SamplerYcbcrConversionImageFormatProperties;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for SamplerYcbcrConversionImageFormatPropertiesBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> SamplerYcbcrConversionImageFormatPropertiesBuilder<'a> {
    pub fn combined_image_sampler_descriptor_count(
        mut self,
        combined_image_sampler_descriptor_count: u32,
    ) -> SamplerYcbcrConversionImageFormatPropertiesBuilder<'a> {
        self.inner.combined_image_sampler_descriptor_count =
            combined_image_sampler_descriptor_count;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> SamplerYcbcrConversionImageFormatProperties {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkTextureLODGatherFormatPropertiesAMD.html>"]
pub struct TextureLODGatherFormatPropertiesAMD {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub supports_texture_gather_lod_bias_amd: Bool32,
}
impl ::std::default::Default for TextureLODGatherFormatPropertiesAMD {
    fn default() -> TextureLODGatherFormatPropertiesAMD {
        TextureLODGatherFormatPropertiesAMD {
            s_type: StructureType::TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD,
            p_next: ::std::ptr::null_mut(),
            supports_texture_gather_lod_bias_amd: Bool32::default(),
        }
    }
}
impl TextureLODGatherFormatPropertiesAMD {
    pub fn builder<'a>() -> TextureLODGatherFormatPropertiesAMDBuilder<'a> {
        TextureLODGatherFormatPropertiesAMDBuilder {
            inner: TextureLODGatherFormatPropertiesAMD::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct TextureLODGatherFormatPropertiesAMDBuilder<'a> {
    inner: TextureLODGatherFormatPropertiesAMD,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsImageFormatProperties2 for TextureLODGatherFormatPropertiesAMDBuilder<'_> {}
unsafe impl ExtendsImageFormatProperties2 for TextureLODGatherFormatPropertiesAMD {}
impl<'a> ::std::ops::Deref for TextureLODGatherFormatPropertiesAMDBuilder<'a> {
    type Target = TextureLODGatherFormatPropertiesAMD;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for TextureLODGatherFormatPropertiesAMDBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> TextureLODGatherFormatPropertiesAMDBuilder<'a> {
    pub fn supports_texture_gather_lod_bias_amd(
        mut self,
        supports_texture_gather_lod_bias_amd: bool,
    ) -> TextureLODGatherFormatPropertiesAMDBuilder<'a> {
        self.inner.supports_texture_gather_lod_bias_amd =
            supports_texture_gather_lod_bias_amd.into();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> TextureLODGatherFormatPropertiesAMD {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkConditionalRenderingBeginInfoEXT.html>"]
pub struct ConditionalRenderingBeginInfoEXT {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub buffer: Buffer,
    pub offset: DeviceSize,
    pub flags: ConditionalRenderingFlagsEXT,
}
impl ::std::default::Default for ConditionalRenderingBeginInfoEXT {
    fn default() -> ConditionalRenderingBeginInfoEXT {
        ConditionalRenderingBeginInfoEXT {
            s_type: StructureType::CONDITIONAL_RENDERING_BEGIN_INFO_EXT,
            p_next: ::std::ptr::null(),
            buffer: Buffer::default(),
            offset: DeviceSize::default(),
            flags: ConditionalRenderingFlagsEXT::default(),
        }
    }
}
impl ConditionalRenderingBeginInfoEXT {
    pub fn builder<'a>() -> ConditionalRenderingBeginInfoEXTBuilder<'a> {
        ConditionalRenderingBeginInfoEXTBuilder {
            inner: ConditionalRenderingBeginInfoEXT::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct ConditionalRenderingBeginInfoEXTBuilder<'a> {
    inner: ConditionalRenderingBeginInfoEXT,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsConditionalRenderingBeginInfoEXT {}
impl<'a> ::std::ops::Deref for ConditionalRenderingBeginInfoEXTBuilder<'a> {
    type Target = ConditionalRenderingBeginInfoEXT;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for ConditionalRenderingBeginInfoEXTBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> ConditionalRenderingBeginInfoEXTBuilder<'a> {
    pub fn buffer(mut self, buffer: Buffer) -> ConditionalRenderingBeginInfoEXTBuilder<'a> {
        self.inner.buffer = buffer;
        self
    }
    pub fn offset(mut self, offset: DeviceSize) -> ConditionalRenderingBeginInfoEXTBuilder<'a> {
        self.inner.offset = offset;
        self
    }
    pub fn flags(
        mut self,
        flags: ConditionalRenderingFlagsEXT,
    ) -> ConditionalRenderingBeginInfoEXTBuilder<'a> {
        self.inner.flags = flags;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsConditionalRenderingBeginInfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> ConditionalRenderingBeginInfoEXTBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> ConditionalRenderingBeginInfoEXT {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkProtectedSubmitInfo.html>"]
pub struct ProtectedSubmitInfo {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub protected_submit: Bool32,
}
impl ::std::default::Default for ProtectedSubmitInfo {
    fn default() -> ProtectedSubmitInfo {
        ProtectedSubmitInfo {
            s_type: StructureType::PROTECTED_SUBMIT_INFO,
            p_next: ::std::ptr::null(),
            protected_submit: Bool32::default(),
        }
    }
}
impl ProtectedSubmitInfo {
    pub fn builder<'a>() -> ProtectedSubmitInfoBuilder<'a> {
        ProtectedSubmitInfoBuilder {
            inner: ProtectedSubmitInfo::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct ProtectedSubmitInfoBuilder<'a> {
    inner: ProtectedSubmitInfo,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsSubmitInfo for ProtectedSubmitInfoBuilder<'_> {}
unsafe impl ExtendsSubmitInfo for ProtectedSubmitInfo {}
impl<'a> ::std::ops::Deref for ProtectedSubmitInfoBuilder<'a> {
    type Target = ProtectedSubmitInfo;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for ProtectedSubmitInfoBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> ProtectedSubmitInfoBuilder<'a> {
    pub fn protected_submit(mut self, protected_submit: bool) -> ProtectedSubmitInfoBuilder<'a> {
        self.inner.protected_submit = protected_submit.into();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> ProtectedSubmitInfo {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceProtectedMemoryFeatures.html>"]
pub struct PhysicalDeviceProtectedMemoryFeatures {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub protected_memory: Bool32,
}
impl ::std::default::Default for PhysicalDeviceProtectedMemoryFeatures {
    fn default() -> PhysicalDeviceProtectedMemoryFeatures {
        PhysicalDeviceProtectedMemoryFeatures {
            s_type: StructureType::PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES,
            p_next: ::std::ptr::null_mut(),
            protected_memory: Bool32::default(),
        }
    }
}
impl PhysicalDeviceProtectedMemoryFeatures {
    pub fn builder<'a>() -> PhysicalDeviceProtectedMemoryFeaturesBuilder<'a> {
        PhysicalDeviceProtectedMemoryFeaturesBuilder {
            inner: PhysicalDeviceProtectedMemoryFeatures::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDeviceProtectedMemoryFeaturesBuilder<'a> {
    inner: PhysicalDeviceProtectedMemoryFeatures,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceProtectedMemoryFeaturesBuilder<'_> {}
unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceProtectedMemoryFeatures {}
impl<'a> ::std::ops::Deref for PhysicalDeviceProtectedMemoryFeaturesBuilder<'a> {
    type Target = PhysicalDeviceProtectedMemoryFeatures;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PhysicalDeviceProtectedMemoryFeaturesBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDeviceProtectedMemoryFeaturesBuilder<'a> {
    pub fn protected_memory(
        mut self,
        protected_memory: bool,
    ) -> PhysicalDeviceProtectedMemoryFeaturesBuilder<'a> {
        self.inner.protected_memory = protected_memory.into();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDeviceProtectedMemoryFeatures {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceProtectedMemoryProperties.html>"]
pub struct PhysicalDeviceProtectedMemoryProperties {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub protected_no_fault: Bool32,
}
impl ::std::default::Default for PhysicalDeviceProtectedMemoryProperties {
    fn default() -> PhysicalDeviceProtectedMemoryProperties {
        PhysicalDeviceProtectedMemoryProperties {
            s_type: StructureType::PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES,
            p_next: ::std::ptr::null_mut(),
            protected_no_fault: Bool32::default(),
        }
    }
}
impl PhysicalDeviceProtectedMemoryProperties {
    pub fn builder<'a>() -> PhysicalDeviceProtectedMemoryPropertiesBuilder<'a> {
        PhysicalDeviceProtectedMemoryPropertiesBuilder {
            inner: PhysicalDeviceProtectedMemoryProperties::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDeviceProtectedMemoryPropertiesBuilder<'a> {
    inner: PhysicalDeviceProtectedMemoryProperties,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsPhysicalDeviceProperties2
    for PhysicalDeviceProtectedMemoryPropertiesBuilder<'_>
{
}
unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceProtectedMemoryProperties {}
impl<'a> ::std::ops::Deref for PhysicalDeviceProtectedMemoryPropertiesBuilder<'a> {
    type Target = PhysicalDeviceProtectedMemoryProperties;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PhysicalDeviceProtectedMemoryPropertiesBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDeviceProtectedMemoryPropertiesBuilder<'a> {
    pub fn protected_no_fault(
        mut self,
        protected_no_fault: bool,
    ) -> PhysicalDeviceProtectedMemoryPropertiesBuilder<'a> {
        self.inner.protected_no_fault = protected_no_fault.into();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDeviceProtectedMemoryProperties {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDeviceQueueInfo2.html>"]
pub struct DeviceQueueInfo2 {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub flags: DeviceQueueCreateFlags,
    pub queue_family_index: u32,
    pub queue_index: u32,
}
impl ::std::default::Default for DeviceQueueInfo2 {
    fn default() -> DeviceQueueInfo2 {
        DeviceQueueInfo2 {
            s_type: StructureType::DEVICE_QUEUE_INFO_2,
            p_next: ::std::ptr::null(),
            flags: DeviceQueueCreateFlags::default(),
            queue_family_index: u32::default(),
            queue_index: u32::default(),
        }
    }
}
impl DeviceQueueInfo2 {
    pub fn builder<'a>() -> DeviceQueueInfo2Builder<'a> {
        DeviceQueueInfo2Builder {
            inner: DeviceQueueInfo2::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct DeviceQueueInfo2Builder<'a> {
    inner: DeviceQueueInfo2,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsDeviceQueueInfo2 {}
impl<'a> ::std::ops::Deref for DeviceQueueInfo2Builder<'a> {
    type Target = DeviceQueueInfo2;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for DeviceQueueInfo2Builder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> DeviceQueueInfo2Builder<'a> {
    pub fn flags(mut self, flags: DeviceQueueCreateFlags) -> DeviceQueueInfo2Builder<'a> {
        self.inner.flags = flags;
        self
    }
    pub fn queue_family_index(mut self, queue_family_index: u32) -> DeviceQueueInfo2Builder<'a> {
        self.inner.queue_family_index = queue_family_index;
        self
    }
    pub fn queue_index(mut self, queue_index: u32) -> DeviceQueueInfo2Builder<'a> {
        self.inner.queue_index = queue_index;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsDeviceQueueInfo2>(
        mut self,
        next: &'a mut T,
    ) -> DeviceQueueInfo2Builder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> DeviceQueueInfo2 {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineCoverageToColorStateCreateInfoNV.html>"]
pub struct PipelineCoverageToColorStateCreateInfoNV {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub flags: PipelineCoverageToColorStateCreateFlagsNV,
    pub coverage_to_color_enable: Bool32,
    pub coverage_to_color_location: u32,
}
impl ::std::default::Default for PipelineCoverageToColorStateCreateInfoNV {
    fn default() -> PipelineCoverageToColorStateCreateInfoNV {
        PipelineCoverageToColorStateCreateInfoNV {
            s_type: StructureType::PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV,
            p_next: ::std::ptr::null(),
            flags: PipelineCoverageToColorStateCreateFlagsNV::default(),
            coverage_to_color_enable: Bool32::default(),
            coverage_to_color_location: u32::default(),
        }
    }
}
impl PipelineCoverageToColorStateCreateInfoNV {
    pub fn builder<'a>() -> PipelineCoverageToColorStateCreateInfoNVBuilder<'a> {
        PipelineCoverageToColorStateCreateInfoNVBuilder {
            inner: PipelineCoverageToColorStateCreateInfoNV::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PipelineCoverageToColorStateCreateInfoNVBuilder<'a> {
    inner: PipelineCoverageToColorStateCreateInfoNV,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsPipelineMultisampleStateCreateInfo
    for PipelineCoverageToColorStateCreateInfoNVBuilder<'_>
{
}
unsafe impl ExtendsPipelineMultisampleStateCreateInfo for PipelineCoverageToColorStateCreateInfoNV {}
impl<'a> ::std::ops::Deref for PipelineCoverageToColorStateCreateInfoNVBuilder<'a> {
    type Target = PipelineCoverageToColorStateCreateInfoNV;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PipelineCoverageToColorStateCreateInfoNVBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PipelineCoverageToColorStateCreateInfoNVBuilder<'a> {
    pub fn flags(
        mut self,
        flags: PipelineCoverageToColorStateCreateFlagsNV,
    ) -> PipelineCoverageToColorStateCreateInfoNVBuilder<'a> {
        self.inner.flags = flags;
        self
    }
    pub fn coverage_to_color_enable(
        mut self,
        coverage_to_color_enable: bool,
    ) -> PipelineCoverageToColorStateCreateInfoNVBuilder<'a> {
        self.inner.coverage_to_color_enable = coverage_to_color_enable.into();
        self
    }
    pub fn coverage_to_color_location(
        mut self,
        coverage_to_color_location: u32,
    ) -> PipelineCoverageToColorStateCreateInfoNVBuilder<'a> {
        self.inner.coverage_to_color_location = coverage_to_color_location;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PipelineCoverageToColorStateCreateInfoNV {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceSamplerFilterMinmaxProperties.html>"]
pub struct PhysicalDeviceSamplerFilterMinmaxProperties {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub filter_minmax_single_component_formats: Bool32,
    pub filter_minmax_image_component_mapping: Bool32,
}
impl ::std::default::Default for PhysicalDeviceSamplerFilterMinmaxProperties {
    fn default() -> PhysicalDeviceSamplerFilterMinmaxProperties {
        PhysicalDeviceSamplerFilterMinmaxProperties {
            s_type: StructureType::PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES,
            p_next: ::std::ptr::null_mut(),
            filter_minmax_single_component_formats: Bool32::default(),
            filter_minmax_image_component_mapping: Bool32::default(),
        }
    }
}
impl PhysicalDeviceSamplerFilterMinmaxProperties {
    pub fn builder<'a>() -> PhysicalDeviceSamplerFilterMinmaxPropertiesBuilder<'a> {
        PhysicalDeviceSamplerFilterMinmaxPropertiesBuilder {
            inner: PhysicalDeviceSamplerFilterMinmaxProperties::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDeviceSamplerFilterMinmaxPropertiesBuilder<'a> {
    inner: PhysicalDeviceSamplerFilterMinmaxProperties,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsPhysicalDeviceProperties2
    for PhysicalDeviceSamplerFilterMinmaxPropertiesBuilder<'_>
{
}
unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceSamplerFilterMinmaxProperties {}
impl<'a> ::std::ops::Deref for PhysicalDeviceSamplerFilterMinmaxPropertiesBuilder<'a> {
    type Target = PhysicalDeviceSamplerFilterMinmaxProperties;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PhysicalDeviceSamplerFilterMinmaxPropertiesBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDeviceSamplerFilterMinmaxPropertiesBuilder<'a> {
    pub fn filter_minmax_single_component_formats(
        mut self,
        filter_minmax_single_component_formats: bool,
    ) -> PhysicalDeviceSamplerFilterMinmaxPropertiesBuilder<'a> {
        self.inner.filter_minmax_single_component_formats =
            filter_minmax_single_component_formats.into();
        self
    }
    pub fn filter_minmax_image_component_mapping(
        mut self,
        filter_minmax_image_component_mapping: bool,
    ) -> PhysicalDeviceSamplerFilterMinmaxPropertiesBuilder<'a> {
        self.inner.filter_minmax_image_component_mapping =
            filter_minmax_image_component_mapping.into();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDeviceSamplerFilterMinmaxProperties {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Default, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSampleLocationEXT.html>"]
pub struct SampleLocationEXT {
    pub x: f32,
    pub y: f32,
}
impl SampleLocationEXT {
    pub fn builder<'a>() -> SampleLocationEXTBuilder<'a> {
        SampleLocationEXTBuilder {
            inner: SampleLocationEXT::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct SampleLocationEXTBuilder<'a> {
    inner: SampleLocationEXT,
    marker: ::std::marker::PhantomData<&'a ()>,
}
impl<'a> ::std::ops::Deref for SampleLocationEXTBuilder<'a> {
    type Target = SampleLocationEXT;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for SampleLocationEXTBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> SampleLocationEXTBuilder<'a> {
    pub fn x(mut self, x: f32) -> SampleLocationEXTBuilder<'a> {
        self.inner.x = x;
        self
    }
    pub fn y(mut self, y: f32) -> SampleLocationEXTBuilder<'a> {
        self.inner.y = y;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> SampleLocationEXT {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSampleLocationsInfoEXT.html>"]
pub struct SampleLocationsInfoEXT {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub sample_locations_per_pixel: SampleCountFlags,
    pub sample_location_grid_size: Extent2D,
    pub sample_locations_count: u32,
    pub p_sample_locations: *const SampleLocationEXT,
}
impl ::std::default::Default for SampleLocationsInfoEXT {
    fn default() -> SampleLocationsInfoEXT {
        SampleLocationsInfoEXT {
            s_type: StructureType::SAMPLE_LOCATIONS_INFO_EXT,
            p_next: ::std::ptr::null(),
            sample_locations_per_pixel: SampleCountFlags::default(),
            sample_location_grid_size: Extent2D::default(),
            sample_locations_count: u32::default(),
            p_sample_locations: ::std::ptr::null(),
        }
    }
}
impl SampleLocationsInfoEXT {
    pub fn builder<'a>() -> SampleLocationsInfoEXTBuilder<'a> {
        SampleLocationsInfoEXTBuilder {
            inner: SampleLocationsInfoEXT::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct SampleLocationsInfoEXTBuilder<'a> {
    inner: SampleLocationsInfoEXT,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsImageMemoryBarrier for SampleLocationsInfoEXTBuilder<'_> {}
unsafe impl ExtendsImageMemoryBarrier for SampleLocationsInfoEXT {}
impl<'a> ::std::ops::Deref for SampleLocationsInfoEXTBuilder<'a> {
    type Target = SampleLocationsInfoEXT;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for SampleLocationsInfoEXTBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> SampleLocationsInfoEXTBuilder<'a> {
    pub fn sample_locations_per_pixel(
        mut self,
        sample_locations_per_pixel: SampleCountFlags,
    ) -> SampleLocationsInfoEXTBuilder<'a> {
        self.inner.sample_locations_per_pixel = sample_locations_per_pixel;
        self
    }
    pub fn sample_location_grid_size(
        mut self,
        sample_location_grid_size: Extent2D,
    ) -> SampleLocationsInfoEXTBuilder<'a> {
        self.inner.sample_location_grid_size = sample_location_grid_size;
        self
    }
    pub fn sample_locations(
        mut self,
        sample_locations: &'a [SampleLocationEXT],
    ) -> SampleLocationsInfoEXTBuilder<'a> {
        self.inner.sample_locations_count = sample_locations.len() as _;
        self.inner.p_sample_locations = sample_locations.as_ptr();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> SampleLocationsInfoEXT {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Default, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAttachmentSampleLocationsEXT.html>"]
pub struct AttachmentSampleLocationsEXT {
    pub attachment_index: u32,
    pub sample_locations_info: SampleLocationsInfoEXT,
}
impl AttachmentSampleLocationsEXT {
    pub fn builder<'a>() -> AttachmentSampleLocationsEXTBuilder<'a> {
        AttachmentSampleLocationsEXTBuilder {
            inner: AttachmentSampleLocationsEXT::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct AttachmentSampleLocationsEXTBuilder<'a> {
    inner: AttachmentSampleLocationsEXT,
    marker: ::std::marker::PhantomData<&'a ()>,
}
impl<'a> ::std::ops::Deref for AttachmentSampleLocationsEXTBuilder<'a> {
    type Target = AttachmentSampleLocationsEXT;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for AttachmentSampleLocationsEXTBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> AttachmentSampleLocationsEXTBuilder<'a> {
    pub fn attachment_index(
        mut self,
        attachment_index: u32,
    ) -> AttachmentSampleLocationsEXTBuilder<'a> {
        self.inner.attachment_index = attachment_index;
        self
    }
    pub fn sample_locations_info(
        mut self,
        sample_locations_info: SampleLocationsInfoEXT,
    ) -> AttachmentSampleLocationsEXTBuilder<'a> {
        self.inner.sample_locations_info = sample_locations_info;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> AttachmentSampleLocationsEXT {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Default, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSubpassSampleLocationsEXT.html>"]
pub struct SubpassSampleLocationsEXT {
    pub subpass_index: u32,
    pub sample_locations_info: SampleLocationsInfoEXT,
}
impl SubpassSampleLocationsEXT {
    pub fn builder<'a>() -> SubpassSampleLocationsEXTBuilder<'a> {
        SubpassSampleLocationsEXTBuilder {
            inner: SubpassSampleLocationsEXT::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct SubpassSampleLocationsEXTBuilder<'a> {
    inner: SubpassSampleLocationsEXT,
    marker: ::std::marker::PhantomData<&'a ()>,
}
impl<'a> ::std::ops::Deref for SubpassSampleLocationsEXTBuilder<'a> {
    type Target = SubpassSampleLocationsEXT;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for SubpassSampleLocationsEXTBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> SubpassSampleLocationsEXTBuilder<'a> {
    pub fn subpass_index(mut self, subpass_index: u32) -> SubpassSampleLocationsEXTBuilder<'a> {
        self.inner.subpass_index = subpass_index;
        self
    }
    pub fn sample_locations_info(
        mut self,
        sample_locations_info: SampleLocationsInfoEXT,
    ) -> SubpassSampleLocationsEXTBuilder<'a> {
        self.inner.sample_locations_info = sample_locations_info;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> SubpassSampleLocationsEXT {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkRenderPassSampleLocationsBeginInfoEXT.html>"]
pub struct RenderPassSampleLocationsBeginInfoEXT {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub attachment_initial_sample_locations_count: u32,
    pub p_attachment_initial_sample_locations: *const AttachmentSampleLocationsEXT,
    pub post_subpass_sample_locations_count: u32,
    pub p_post_subpass_sample_locations: *const SubpassSampleLocationsEXT,
}
impl ::std::default::Default for RenderPassSampleLocationsBeginInfoEXT {
    fn default() -> RenderPassSampleLocationsBeginInfoEXT {
        RenderPassSampleLocationsBeginInfoEXT {
            s_type: StructureType::RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT,
            p_next: ::std::ptr::null(),
            attachment_initial_sample_locations_count: u32::default(),
            p_attachment_initial_sample_locations: ::std::ptr::null(),
            post_subpass_sample_locations_count: u32::default(),
            p_post_subpass_sample_locations: ::std::ptr::null(),
        }
    }
}
impl RenderPassSampleLocationsBeginInfoEXT {
    pub fn builder<'a>() -> RenderPassSampleLocationsBeginInfoEXTBuilder<'a> {
        RenderPassSampleLocationsBeginInfoEXTBuilder {
            inner: RenderPassSampleLocationsBeginInfoEXT::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct RenderPassSampleLocationsBeginInfoEXTBuilder<'a> {
    inner: RenderPassSampleLocationsBeginInfoEXT,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsRenderPassBeginInfo for RenderPassSampleLocationsBeginInfoEXTBuilder<'_> {}
unsafe impl ExtendsRenderPassBeginInfo for RenderPassSampleLocationsBeginInfoEXT {}
impl<'a> ::std::ops::Deref for RenderPassSampleLocationsBeginInfoEXTBuilder<'a> {
    type Target = RenderPassSampleLocationsBeginInfoEXT;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for RenderPassSampleLocationsBeginInfoEXTBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> RenderPassSampleLocationsBeginInfoEXTBuilder<'a> {
    pub fn attachment_initial_sample_locations(
        mut self,
        attachment_initial_sample_locations: &'a [AttachmentSampleLocationsEXT],
    ) -> RenderPassSampleLocationsBeginInfoEXTBuilder<'a> {
        self.inner.attachment_initial_sample_locations_count =
            attachment_initial_sample_locations.len() as _;
        self.inner.p_attachment_initial_sample_locations =
            attachment_initial_sample_locations.as_ptr();
        self
    }
    pub fn post_subpass_sample_locations(
        mut self,
        post_subpass_sample_locations: &'a [SubpassSampleLocationsEXT],
    ) -> RenderPassSampleLocationsBeginInfoEXTBuilder<'a> {
        self.inner.post_subpass_sample_locations_count = post_subpass_sample_locations.len() as _;
        self.inner.p_post_subpass_sample_locations = post_subpass_sample_locations.as_ptr();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> RenderPassSampleLocationsBeginInfoEXT {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineSampleLocationsStateCreateInfoEXT.html>"]
pub struct PipelineSampleLocationsStateCreateInfoEXT {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub sample_locations_enable: Bool32,
    pub sample_locations_info: SampleLocationsInfoEXT,
}
impl ::std::default::Default for PipelineSampleLocationsStateCreateInfoEXT {
    fn default() -> PipelineSampleLocationsStateCreateInfoEXT {
        PipelineSampleLocationsStateCreateInfoEXT {
            s_type: StructureType::PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT,
            p_next: ::std::ptr::null(),
            sample_locations_enable: Bool32::default(),
            sample_locations_info: SampleLocationsInfoEXT::default(),
        }
    }
}
impl PipelineSampleLocationsStateCreateInfoEXT {
    pub fn builder<'a>() -> PipelineSampleLocationsStateCreateInfoEXTBuilder<'a> {
        PipelineSampleLocationsStateCreateInfoEXTBuilder {
            inner: PipelineSampleLocationsStateCreateInfoEXT::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PipelineSampleLocationsStateCreateInfoEXTBuilder<'a> {
    inner: PipelineSampleLocationsStateCreateInfoEXT,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsPipelineMultisampleStateCreateInfo
    for PipelineSampleLocationsStateCreateInfoEXTBuilder<'_>
{
}
unsafe impl ExtendsPipelineMultisampleStateCreateInfo
    for PipelineSampleLocationsStateCreateInfoEXT
{
}
impl<'a> ::std::ops::Deref for PipelineSampleLocationsStateCreateInfoEXTBuilder<'a> {
    type Target = PipelineSampleLocationsStateCreateInfoEXT;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PipelineSampleLocationsStateCreateInfoEXTBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PipelineSampleLocationsStateCreateInfoEXTBuilder<'a> {
    pub fn sample_locations_enable(
        mut self,
        sample_locations_enable: bool,
    ) -> PipelineSampleLocationsStateCreateInfoEXTBuilder<'a> {
        self.inner.sample_locations_enable = sample_locations_enable.into();
        self
    }
    pub fn sample_locations_info(
        mut self,
        sample_locations_info: SampleLocationsInfoEXT,
    ) -> PipelineSampleLocationsStateCreateInfoEXTBuilder<'a> {
        self.inner.sample_locations_info = sample_locations_info;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PipelineSampleLocationsStateCreateInfoEXT {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceSampleLocationsPropertiesEXT.html>"]
pub struct PhysicalDeviceSampleLocationsPropertiesEXT {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub sample_location_sample_counts: SampleCountFlags,
    pub max_sample_location_grid_size: Extent2D,
    pub sample_location_coordinate_range: [f32; 2],
    pub sample_location_sub_pixel_bits: u32,
    pub variable_sample_locations: Bool32,
}
impl ::std::default::Default for PhysicalDeviceSampleLocationsPropertiesEXT {
    fn default() -> PhysicalDeviceSampleLocationsPropertiesEXT {
        PhysicalDeviceSampleLocationsPropertiesEXT {
            s_type: StructureType::PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT,
            p_next: ::std::ptr::null_mut(),
            sample_location_sample_counts: SampleCountFlags::default(),
            max_sample_location_grid_size: Extent2D::default(),
            sample_location_coordinate_range: unsafe { ::std::mem::zeroed() },
            sample_location_sub_pixel_bits: u32::default(),
            variable_sample_locations: Bool32::default(),
        }
    }
}
impl PhysicalDeviceSampleLocationsPropertiesEXT {
    pub fn builder<'a>() -> PhysicalDeviceSampleLocationsPropertiesEXTBuilder<'a> {
        PhysicalDeviceSampleLocationsPropertiesEXTBuilder {
            inner: PhysicalDeviceSampleLocationsPropertiesEXT::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDeviceSampleLocationsPropertiesEXTBuilder<'a> {
    inner: PhysicalDeviceSampleLocationsPropertiesEXT,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsPhysicalDeviceProperties2
    for PhysicalDeviceSampleLocationsPropertiesEXTBuilder<'_>
{
}
unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceSampleLocationsPropertiesEXT {}
impl<'a> ::std::ops::Deref for PhysicalDeviceSampleLocationsPropertiesEXTBuilder<'a> {
    type Target = PhysicalDeviceSampleLocationsPropertiesEXT;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PhysicalDeviceSampleLocationsPropertiesEXTBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDeviceSampleLocationsPropertiesEXTBuilder<'a> {
    pub fn sample_location_sample_counts(
        mut self,
        sample_location_sample_counts: SampleCountFlags,
    ) -> PhysicalDeviceSampleLocationsPropertiesEXTBuilder<'a> {
        self.inner.sample_location_sample_counts = sample_location_sample_counts;
        self
    }
    pub fn max_sample_location_grid_size(
        mut self,
        max_sample_location_grid_size: Extent2D,
    ) -> PhysicalDeviceSampleLocationsPropertiesEXTBuilder<'a> {
        self.inner.max_sample_location_grid_size = max_sample_location_grid_size;
        self
    }
    pub fn sample_location_coordinate_range(
        mut self,
        sample_location_coordinate_range: [f32; 2],
    ) -> PhysicalDeviceSampleLocationsPropertiesEXTBuilder<'a> {
        self.inner.sample_location_coordinate_range = sample_location_coordinate_range;
        self
    }
    pub fn sample_location_sub_pixel_bits(
        mut self,
        sample_location_sub_pixel_bits: u32,
    ) -> PhysicalDeviceSampleLocationsPropertiesEXTBuilder<'a> {
        self.inner.sample_location_sub_pixel_bits = sample_location_sub_pixel_bits;
        self
    }
    pub fn variable_sample_locations(
        mut self,
        variable_sample_locations: bool,
    ) -> PhysicalDeviceSampleLocationsPropertiesEXTBuilder<'a> {
        self.inner.variable_sample_locations = variable_sample_locations.into();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDeviceSampleLocationsPropertiesEXT {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkMultisamplePropertiesEXT.html>"]
pub struct MultisamplePropertiesEXT {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub max_sample_location_grid_size: Extent2D,
}
impl ::std::default::Default for MultisamplePropertiesEXT {
    fn default() -> MultisamplePropertiesEXT {
        MultisamplePropertiesEXT {
            s_type: StructureType::MULTISAMPLE_PROPERTIES_EXT,
            p_next: ::std::ptr::null_mut(),
            max_sample_location_grid_size: Extent2D::default(),
        }
    }
}
impl MultisamplePropertiesEXT {
    pub fn builder<'a>() -> MultisamplePropertiesEXTBuilder<'a> {
        MultisamplePropertiesEXTBuilder {
            inner: MultisamplePropertiesEXT::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct MultisamplePropertiesEXTBuilder<'a> {
    inner: MultisamplePropertiesEXT,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsMultisamplePropertiesEXT {}
impl<'a> ::std::ops::Deref for MultisamplePropertiesEXTBuilder<'a> {
    type Target = MultisamplePropertiesEXT;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for MultisamplePropertiesEXTBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> MultisamplePropertiesEXTBuilder<'a> {
    pub fn max_sample_location_grid_size(
        mut self,
        max_sample_location_grid_size: Extent2D,
    ) -> MultisamplePropertiesEXTBuilder<'a> {
        self.inner.max_sample_location_grid_size = max_sample_location_grid_size;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsMultisamplePropertiesEXT>(
        mut self,
        next: &'a mut T,
    ) -> MultisamplePropertiesEXTBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> MultisamplePropertiesEXT {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSamplerReductionModeCreateInfo.html>"]
pub struct SamplerReductionModeCreateInfo {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub reduction_mode: SamplerReductionMode,
}
impl ::std::default::Default for SamplerReductionModeCreateInfo {
    fn default() -> SamplerReductionModeCreateInfo {
        SamplerReductionModeCreateInfo {
            s_type: StructureType::SAMPLER_REDUCTION_MODE_CREATE_INFO,
            p_next: ::std::ptr::null(),
            reduction_mode: SamplerReductionMode::default(),
        }
    }
}
impl SamplerReductionModeCreateInfo {
    pub fn builder<'a>() -> SamplerReductionModeCreateInfoBuilder<'a> {
        SamplerReductionModeCreateInfoBuilder {
            inner: SamplerReductionModeCreateInfo::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct SamplerReductionModeCreateInfoBuilder<'a> {
    inner: SamplerReductionModeCreateInfo,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsSamplerCreateInfo for SamplerReductionModeCreateInfoBuilder<'_> {}
unsafe impl ExtendsSamplerCreateInfo for SamplerReductionModeCreateInfo {}
impl<'a> ::std::ops::Deref for SamplerReductionModeCreateInfoBuilder<'a> {
    type Target = SamplerReductionModeCreateInfo;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for SamplerReductionModeCreateInfoBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> SamplerReductionModeCreateInfoBuilder<'a> {
    pub fn reduction_mode(
        mut self,
        reduction_mode: SamplerReductionMode,
    ) -> SamplerReductionModeCreateInfoBuilder<'a> {
        self.inner.reduction_mode = reduction_mode;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> SamplerReductionModeCreateInfo {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT.html>"]
pub struct PhysicalDeviceBlendOperationAdvancedFeaturesEXT {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub advanced_blend_coherent_operations: Bool32,
}
impl ::std::default::Default for PhysicalDeviceBlendOperationAdvancedFeaturesEXT {
    fn default() -> PhysicalDeviceBlendOperationAdvancedFeaturesEXT {
        PhysicalDeviceBlendOperationAdvancedFeaturesEXT {
            s_type: StructureType::PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT,
            p_next: ::std::ptr::null_mut(),
            advanced_blend_coherent_operations: Bool32::default(),
        }
    }
}
impl PhysicalDeviceBlendOperationAdvancedFeaturesEXT {
    pub fn builder<'a>() -> PhysicalDeviceBlendOperationAdvancedFeaturesEXTBuilder<'a> {
        PhysicalDeviceBlendOperationAdvancedFeaturesEXTBuilder {
            inner: PhysicalDeviceBlendOperationAdvancedFeaturesEXT::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDeviceBlendOperationAdvancedFeaturesEXTBuilder<'a> {
    inner: PhysicalDeviceBlendOperationAdvancedFeaturesEXT,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceBlendOperationAdvancedFeaturesEXTBuilder<'_> {}
unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceBlendOperationAdvancedFeaturesEXT {}
impl<'a> ::std::ops::Deref for PhysicalDeviceBlendOperationAdvancedFeaturesEXTBuilder<'a> {
    type Target = PhysicalDeviceBlendOperationAdvancedFeaturesEXT;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PhysicalDeviceBlendOperationAdvancedFeaturesEXTBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDeviceBlendOperationAdvancedFeaturesEXTBuilder<'a> {
    pub fn advanced_blend_coherent_operations(
        mut self,
        advanced_blend_coherent_operations: bool,
    ) -> PhysicalDeviceBlendOperationAdvancedFeaturesEXTBuilder<'a> {
        self.inner.advanced_blend_coherent_operations = advanced_blend_coherent_operations.into();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDeviceBlendOperationAdvancedFeaturesEXT {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT.html>"]
pub struct PhysicalDeviceBlendOperationAdvancedPropertiesEXT {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub advanced_blend_max_color_attachments: u32,
    pub advanced_blend_independent_blend: Bool32,
    pub advanced_blend_non_premultiplied_src_color: Bool32,
    pub advanced_blend_non_premultiplied_dst_color: Bool32,
    pub advanced_blend_correlated_overlap: Bool32,
    pub advanced_blend_all_operations: Bool32,
}
impl ::std::default::Default for PhysicalDeviceBlendOperationAdvancedPropertiesEXT {
    fn default() -> PhysicalDeviceBlendOperationAdvancedPropertiesEXT {
        PhysicalDeviceBlendOperationAdvancedPropertiesEXT {
            s_type: StructureType::PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT,
            p_next: ::std::ptr::null_mut(),
            advanced_blend_max_color_attachments: u32::default(),
            advanced_blend_independent_blend: Bool32::default(),
            advanced_blend_non_premultiplied_src_color: Bool32::default(),
            advanced_blend_non_premultiplied_dst_color: Bool32::default(),
            advanced_blend_correlated_overlap: Bool32::default(),
            advanced_blend_all_operations: Bool32::default(),
        }
    }
}
impl PhysicalDeviceBlendOperationAdvancedPropertiesEXT {
    pub fn builder<'a>() -> PhysicalDeviceBlendOperationAdvancedPropertiesEXTBuilder<'a> {
        PhysicalDeviceBlendOperationAdvancedPropertiesEXTBuilder {
            inner: PhysicalDeviceBlendOperationAdvancedPropertiesEXT::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDeviceBlendOperationAdvancedPropertiesEXTBuilder<'a> {
    inner: PhysicalDeviceBlendOperationAdvancedPropertiesEXT,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsPhysicalDeviceProperties2
    for PhysicalDeviceBlendOperationAdvancedPropertiesEXTBuilder<'_>
{
}
unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceBlendOperationAdvancedPropertiesEXT {}
impl<'a> ::std::ops::Deref for PhysicalDeviceBlendOperationAdvancedPropertiesEXTBuilder<'a> {
    type Target = PhysicalDeviceBlendOperationAdvancedPropertiesEXT;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PhysicalDeviceBlendOperationAdvancedPropertiesEXTBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDeviceBlendOperationAdvancedPropertiesEXTBuilder<'a> {
    pub fn advanced_blend_max_color_attachments(
        mut self,
        advanced_blend_max_color_attachments: u32,
    ) -> PhysicalDeviceBlendOperationAdvancedPropertiesEXTBuilder<'a> {
        self.inner.advanced_blend_max_color_attachments = advanced_blend_max_color_attachments;
        self
    }
    pub fn advanced_blend_independent_blend(
        mut self,
        advanced_blend_independent_blend: bool,
    ) -> PhysicalDeviceBlendOperationAdvancedPropertiesEXTBuilder<'a> {
        self.inner.advanced_blend_independent_blend = advanced_blend_independent_blend.into();
        self
    }
    pub fn advanced_blend_non_premultiplied_src_color(
        mut self,
        advanced_blend_non_premultiplied_src_color: bool,
    ) -> PhysicalDeviceBlendOperationAdvancedPropertiesEXTBuilder<'a> {
        self.inner.advanced_blend_non_premultiplied_src_color =
            advanced_blend_non_premultiplied_src_color.into();
        self
    }
    pub fn advanced_blend_non_premultiplied_dst_color(
        mut self,
        advanced_blend_non_premultiplied_dst_color: bool,
    ) -> PhysicalDeviceBlendOperationAdvancedPropertiesEXTBuilder<'a> {
        self.inner.advanced_blend_non_premultiplied_dst_color =
            advanced_blend_non_premultiplied_dst_color.into();
        self
    }
    pub fn advanced_blend_correlated_overlap(
        mut self,
        advanced_blend_correlated_overlap: bool,
    ) -> PhysicalDeviceBlendOperationAdvancedPropertiesEXTBuilder<'a> {
        self.inner.advanced_blend_correlated_overlap = advanced_blend_correlated_overlap.into();
        self
    }
    pub fn advanced_blend_all_operations(
        mut self,
        advanced_blend_all_operations: bool,
    ) -> PhysicalDeviceBlendOperationAdvancedPropertiesEXTBuilder<'a> {
        self.inner.advanced_blend_all_operations = advanced_blend_all_operations.into();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDeviceBlendOperationAdvancedPropertiesEXT {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineColorBlendAdvancedStateCreateInfoEXT.html>"]
pub struct PipelineColorBlendAdvancedStateCreateInfoEXT {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub src_premultiplied: Bool32,
    pub dst_premultiplied: Bool32,
    pub blend_overlap: BlendOverlapEXT,
}
impl ::std::default::Default for PipelineColorBlendAdvancedStateCreateInfoEXT {
    fn default() -> PipelineColorBlendAdvancedStateCreateInfoEXT {
        PipelineColorBlendAdvancedStateCreateInfoEXT {
            s_type: StructureType::PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT,
            p_next: ::std::ptr::null(),
            src_premultiplied: Bool32::default(),
            dst_premultiplied: Bool32::default(),
            blend_overlap: BlendOverlapEXT::default(),
        }
    }
}
impl PipelineColorBlendAdvancedStateCreateInfoEXT {
    pub fn builder<'a>() -> PipelineColorBlendAdvancedStateCreateInfoEXTBuilder<'a> {
        PipelineColorBlendAdvancedStateCreateInfoEXTBuilder {
            inner: PipelineColorBlendAdvancedStateCreateInfoEXT::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PipelineColorBlendAdvancedStateCreateInfoEXTBuilder<'a> {
    inner: PipelineColorBlendAdvancedStateCreateInfoEXT,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsPipelineColorBlendStateCreateInfo
    for PipelineColorBlendAdvancedStateCreateInfoEXTBuilder<'_>
{
}
unsafe impl ExtendsPipelineColorBlendStateCreateInfo
    for PipelineColorBlendAdvancedStateCreateInfoEXT
{
}
impl<'a> ::std::ops::Deref for PipelineColorBlendAdvancedStateCreateInfoEXTBuilder<'a> {
    type Target = PipelineColorBlendAdvancedStateCreateInfoEXT;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PipelineColorBlendAdvancedStateCreateInfoEXTBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PipelineColorBlendAdvancedStateCreateInfoEXTBuilder<'a> {
    pub fn src_premultiplied(
        mut self,
        src_premultiplied: bool,
    ) -> PipelineColorBlendAdvancedStateCreateInfoEXTBuilder<'a> {
        self.inner.src_premultiplied = src_premultiplied.into();
        self
    }
    pub fn dst_premultiplied(
        mut self,
        dst_premultiplied: bool,
    ) -> PipelineColorBlendAdvancedStateCreateInfoEXTBuilder<'a> {
        self.inner.dst_premultiplied = dst_premultiplied.into();
        self
    }
    pub fn blend_overlap(
        mut self,
        blend_overlap: BlendOverlapEXT,
    ) -> PipelineColorBlendAdvancedStateCreateInfoEXTBuilder<'a> {
        self.inner.blend_overlap = blend_overlap;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PipelineColorBlendAdvancedStateCreateInfoEXT {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceInlineUniformBlockFeaturesEXT.html>"]
pub struct PhysicalDeviceInlineUniformBlockFeaturesEXT {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub inline_uniform_block: Bool32,
    pub descriptor_binding_inline_uniform_block_update_after_bind: Bool32,
}
impl ::std::default::Default for PhysicalDeviceInlineUniformBlockFeaturesEXT {
    fn default() -> PhysicalDeviceInlineUniformBlockFeaturesEXT {
        PhysicalDeviceInlineUniformBlockFeaturesEXT {
            s_type: StructureType::PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT,
            p_next: ::std::ptr::null_mut(),
            inline_uniform_block: Bool32::default(),
            descriptor_binding_inline_uniform_block_update_after_bind: Bool32::default(),
        }
    }
}
impl PhysicalDeviceInlineUniformBlockFeaturesEXT {
    pub fn builder<'a>() -> PhysicalDeviceInlineUniformBlockFeaturesEXTBuilder<'a> {
        PhysicalDeviceInlineUniformBlockFeaturesEXTBuilder {
            inner: PhysicalDeviceInlineUniformBlockFeaturesEXT::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDeviceInlineUniformBlockFeaturesEXTBuilder<'a> {
    inner: PhysicalDeviceInlineUniformBlockFeaturesEXT,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceInlineUniformBlockFeaturesEXTBuilder<'_> {}
unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceInlineUniformBlockFeaturesEXT {}
impl<'a> ::std::ops::Deref for PhysicalDeviceInlineUniformBlockFeaturesEXTBuilder<'a> {
    type Target = PhysicalDeviceInlineUniformBlockFeaturesEXT;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PhysicalDeviceInlineUniformBlockFeaturesEXTBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDeviceInlineUniformBlockFeaturesEXTBuilder<'a> {
    pub fn inline_uniform_block(
        mut self,
        inline_uniform_block: bool,
    ) -> PhysicalDeviceInlineUniformBlockFeaturesEXTBuilder<'a> {
        self.inner.inline_uniform_block = inline_uniform_block.into();
        self
    }
    pub fn descriptor_binding_inline_uniform_block_update_after_bind(
        mut self,
        descriptor_binding_inline_uniform_block_update_after_bind: bool,
    ) -> PhysicalDeviceInlineUniformBlockFeaturesEXTBuilder<'a> {
        self.inner
            .descriptor_binding_inline_uniform_block_update_after_bind =
            descriptor_binding_inline_uniform_block_update_after_bind.into();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDeviceInlineUniformBlockFeaturesEXT {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceInlineUniformBlockPropertiesEXT.html>"]
pub struct PhysicalDeviceInlineUniformBlockPropertiesEXT {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub max_inline_uniform_block_size: u32,
    pub max_per_stage_descriptor_inline_uniform_blocks: u32,
    pub max_per_stage_descriptor_update_after_bind_inline_uniform_blocks: u32,
    pub max_descriptor_set_inline_uniform_blocks: u32,
    pub max_descriptor_set_update_after_bind_inline_uniform_blocks: u32,
}
impl ::std::default::Default for PhysicalDeviceInlineUniformBlockPropertiesEXT {
    fn default() -> PhysicalDeviceInlineUniformBlockPropertiesEXT {
        PhysicalDeviceInlineUniformBlockPropertiesEXT {
            s_type: StructureType::PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT,
            p_next: ::std::ptr::null_mut(),
            max_inline_uniform_block_size: u32::default(),
            max_per_stage_descriptor_inline_uniform_blocks: u32::default(),
            max_per_stage_descriptor_update_after_bind_inline_uniform_blocks: u32::default(),
            max_descriptor_set_inline_uniform_blocks: u32::default(),
            max_descriptor_set_update_after_bind_inline_uniform_blocks: u32::default(),
        }
    }
}
impl PhysicalDeviceInlineUniformBlockPropertiesEXT {
    pub fn builder<'a>() -> PhysicalDeviceInlineUniformBlockPropertiesEXTBuilder<'a> {
        PhysicalDeviceInlineUniformBlockPropertiesEXTBuilder {
            inner: PhysicalDeviceInlineUniformBlockPropertiesEXT::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDeviceInlineUniformBlockPropertiesEXTBuilder<'a> {
    inner: PhysicalDeviceInlineUniformBlockPropertiesEXT,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsPhysicalDeviceProperties2
    for PhysicalDeviceInlineUniformBlockPropertiesEXTBuilder<'_>
{
}
unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceInlineUniformBlockPropertiesEXT {}
impl<'a> ::std::ops::Deref for PhysicalDeviceInlineUniformBlockPropertiesEXTBuilder<'a> {
    type Target = PhysicalDeviceInlineUniformBlockPropertiesEXT;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PhysicalDeviceInlineUniformBlockPropertiesEXTBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDeviceInlineUniformBlockPropertiesEXTBuilder<'a> {
    pub fn max_inline_uniform_block_size(
        mut self,
        max_inline_uniform_block_size: u32,
    ) -> PhysicalDeviceInlineUniformBlockPropertiesEXTBuilder<'a> {
        self.inner.max_inline_uniform_block_size = max_inline_uniform_block_size;
        self
    }
    pub fn max_per_stage_descriptor_inline_uniform_blocks(
        mut self,
        max_per_stage_descriptor_inline_uniform_blocks: u32,
    ) -> PhysicalDeviceInlineUniformBlockPropertiesEXTBuilder<'a> {
        self.inner.max_per_stage_descriptor_inline_uniform_blocks =
            max_per_stage_descriptor_inline_uniform_blocks;
        self
    }
    pub fn max_per_stage_descriptor_update_after_bind_inline_uniform_blocks(
        mut self,
        max_per_stage_descriptor_update_after_bind_inline_uniform_blocks: u32,
    ) -> PhysicalDeviceInlineUniformBlockPropertiesEXTBuilder<'a> {
        self.inner
            .max_per_stage_descriptor_update_after_bind_inline_uniform_blocks =
            max_per_stage_descriptor_update_after_bind_inline_uniform_blocks;
        self
    }
    pub fn max_descriptor_set_inline_uniform_blocks(
        mut self,
        max_descriptor_set_inline_uniform_blocks: u32,
    ) -> PhysicalDeviceInlineUniformBlockPropertiesEXTBuilder<'a> {
        self.inner.max_descriptor_set_inline_uniform_blocks =
            max_descriptor_set_inline_uniform_blocks;
        self
    }
    pub fn max_descriptor_set_update_after_bind_inline_uniform_blocks(
        mut self,
        max_descriptor_set_update_after_bind_inline_uniform_blocks: u32,
    ) -> PhysicalDeviceInlineUniformBlockPropertiesEXTBuilder<'a> {
        self.inner
            .max_descriptor_set_update_after_bind_inline_uniform_blocks =
            max_descriptor_set_update_after_bind_inline_uniform_blocks;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDeviceInlineUniformBlockPropertiesEXT {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkWriteDescriptorSetInlineUniformBlockEXT.html>"]
pub struct WriteDescriptorSetInlineUniformBlockEXT {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub data_size: u32,
    pub p_data: *const c_void,
}
impl ::std::default::Default for WriteDescriptorSetInlineUniformBlockEXT {
    fn default() -> WriteDescriptorSetInlineUniformBlockEXT {
        WriteDescriptorSetInlineUniformBlockEXT {
            s_type: StructureType::WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK_EXT,
            p_next: ::std::ptr::null(),
            data_size: u32::default(),
            p_data: ::std::ptr::null(),
        }
    }
}
impl WriteDescriptorSetInlineUniformBlockEXT {
    pub fn builder<'a>() -> WriteDescriptorSetInlineUniformBlockEXTBuilder<'a> {
        WriteDescriptorSetInlineUniformBlockEXTBuilder {
            inner: WriteDescriptorSetInlineUniformBlockEXT::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct WriteDescriptorSetInlineUniformBlockEXTBuilder<'a> {
    inner: WriteDescriptorSetInlineUniformBlockEXT,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsWriteDescriptorSet for WriteDescriptorSetInlineUniformBlockEXTBuilder<'_> {}
unsafe impl ExtendsWriteDescriptorSet for WriteDescriptorSetInlineUniformBlockEXT {}
impl<'a> ::std::ops::Deref for WriteDescriptorSetInlineUniformBlockEXTBuilder<'a> {
    type Target = WriteDescriptorSetInlineUniformBlockEXT;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for WriteDescriptorSetInlineUniformBlockEXTBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> WriteDescriptorSetInlineUniformBlockEXTBuilder<'a> {
    pub fn data(mut self, data: &'a [u8]) -> WriteDescriptorSetInlineUniformBlockEXTBuilder<'a> {
        self.inner.data_size = data.len() as _;
        self.inner.p_data = data.as_ptr() as *const c_void;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> WriteDescriptorSetInlineUniformBlockEXT {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDescriptorPoolInlineUniformBlockCreateInfoEXT.html>"]
pub struct DescriptorPoolInlineUniformBlockCreateInfoEXT {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub max_inline_uniform_block_bindings: u32,
}
impl ::std::default::Default for DescriptorPoolInlineUniformBlockCreateInfoEXT {
    fn default() -> DescriptorPoolInlineUniformBlockCreateInfoEXT {
        DescriptorPoolInlineUniformBlockCreateInfoEXT {
            s_type: StructureType::DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO_EXT,
            p_next: ::std::ptr::null(),
            max_inline_uniform_block_bindings: u32::default(),
        }
    }
}
impl DescriptorPoolInlineUniformBlockCreateInfoEXT {
    pub fn builder<'a>() -> DescriptorPoolInlineUniformBlockCreateInfoEXTBuilder<'a> {
        DescriptorPoolInlineUniformBlockCreateInfoEXTBuilder {
            inner: DescriptorPoolInlineUniformBlockCreateInfoEXT::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct DescriptorPoolInlineUniformBlockCreateInfoEXTBuilder<'a> {
    inner: DescriptorPoolInlineUniformBlockCreateInfoEXT,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsDescriptorPoolCreateInfo
    for DescriptorPoolInlineUniformBlockCreateInfoEXTBuilder<'_>
{
}
unsafe impl ExtendsDescriptorPoolCreateInfo for DescriptorPoolInlineUniformBlockCreateInfoEXT {}
impl<'a> ::std::ops::Deref for DescriptorPoolInlineUniformBlockCreateInfoEXTBuilder<'a> {
    type Target = DescriptorPoolInlineUniformBlockCreateInfoEXT;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for DescriptorPoolInlineUniformBlockCreateInfoEXTBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> DescriptorPoolInlineUniformBlockCreateInfoEXTBuilder<'a> {
    pub fn max_inline_uniform_block_bindings(
        mut self,
        max_inline_uniform_block_bindings: u32,
    ) -> DescriptorPoolInlineUniformBlockCreateInfoEXTBuilder<'a> {
        self.inner.max_inline_uniform_block_bindings = max_inline_uniform_block_bindings;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> DescriptorPoolInlineUniformBlockCreateInfoEXT {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineCoverageModulationStateCreateInfoNV.html>"]
pub struct PipelineCoverageModulationStateCreateInfoNV {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub flags: PipelineCoverageModulationStateCreateFlagsNV,
    pub coverage_modulation_mode: CoverageModulationModeNV,
    pub coverage_modulation_table_enable: Bool32,
    pub coverage_modulation_table_count: u32,
    pub p_coverage_modulation_table: *const f32,
}
impl ::std::default::Default for PipelineCoverageModulationStateCreateInfoNV {
    fn default() -> PipelineCoverageModulationStateCreateInfoNV {
        PipelineCoverageModulationStateCreateInfoNV {
            s_type: StructureType::PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV,
            p_next: ::std::ptr::null(),
            flags: PipelineCoverageModulationStateCreateFlagsNV::default(),
            coverage_modulation_mode: CoverageModulationModeNV::default(),
            coverage_modulation_table_enable: Bool32::default(),
            coverage_modulation_table_count: u32::default(),
            p_coverage_modulation_table: ::std::ptr::null(),
        }
    }
}
impl PipelineCoverageModulationStateCreateInfoNV {
    pub fn builder<'a>() -> PipelineCoverageModulationStateCreateInfoNVBuilder<'a> {
        PipelineCoverageModulationStateCreateInfoNVBuilder {
            inner: PipelineCoverageModulationStateCreateInfoNV::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PipelineCoverageModulationStateCreateInfoNVBuilder<'a> {
    inner: PipelineCoverageModulationStateCreateInfoNV,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsPipelineMultisampleStateCreateInfo
    for PipelineCoverageModulationStateCreateInfoNVBuilder<'_>
{
}
unsafe impl ExtendsPipelineMultisampleStateCreateInfo
    for PipelineCoverageModulationStateCreateInfoNV
{
}
impl<'a> ::std::ops::Deref for PipelineCoverageModulationStateCreateInfoNVBuilder<'a> {
    type Target = PipelineCoverageModulationStateCreateInfoNV;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PipelineCoverageModulationStateCreateInfoNVBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PipelineCoverageModulationStateCreateInfoNVBuilder<'a> {
    pub fn flags(
        mut self,
        flags: PipelineCoverageModulationStateCreateFlagsNV,
    ) -> PipelineCoverageModulationStateCreateInfoNVBuilder<'a> {
        self.inner.flags = flags;
        self
    }
    pub fn coverage_modulation_mode(
        mut self,
        coverage_modulation_mode: CoverageModulationModeNV,
    ) -> PipelineCoverageModulationStateCreateInfoNVBuilder<'a> {
        self.inner.coverage_modulation_mode = coverage_modulation_mode;
        self
    }
    pub fn coverage_modulation_table_enable(
        mut self,
        coverage_modulation_table_enable: bool,
    ) -> PipelineCoverageModulationStateCreateInfoNVBuilder<'a> {
        self.inner.coverage_modulation_table_enable = coverage_modulation_table_enable.into();
        self
    }
    pub fn coverage_modulation_table(
        mut self,
        coverage_modulation_table: &'a [f32],
    ) -> PipelineCoverageModulationStateCreateInfoNVBuilder<'a> {
        self.inner.coverage_modulation_table_count = coverage_modulation_table.len() as _;
        self.inner.p_coverage_modulation_table = coverage_modulation_table.as_ptr();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PipelineCoverageModulationStateCreateInfoNV {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImageFormatListCreateInfo.html>"]
pub struct ImageFormatListCreateInfo {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub view_format_count: u32,
    pub p_view_formats: *const Format,
}
impl ::std::default::Default for ImageFormatListCreateInfo {
    fn default() -> ImageFormatListCreateInfo {
        ImageFormatListCreateInfo {
            s_type: StructureType::IMAGE_FORMAT_LIST_CREATE_INFO,
            p_next: ::std::ptr::null(),
            view_format_count: u32::default(),
            p_view_formats: ::std::ptr::null(),
        }
    }
}
impl ImageFormatListCreateInfo {
    pub fn builder<'a>() -> ImageFormatListCreateInfoBuilder<'a> {
        ImageFormatListCreateInfoBuilder {
            inner: ImageFormatListCreateInfo::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct ImageFormatListCreateInfoBuilder<'a> {
    inner: ImageFormatListCreateInfo,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsImageCreateInfo for ImageFormatListCreateInfoBuilder<'_> {}
unsafe impl ExtendsImageCreateInfo for ImageFormatListCreateInfo {}
unsafe impl ExtendsSwapchainCreateInfoKHR for ImageFormatListCreateInfoBuilder<'_> {}
unsafe impl ExtendsSwapchainCreateInfoKHR for ImageFormatListCreateInfo {}
unsafe impl ExtendsPhysicalDeviceImageFormatInfo2 for ImageFormatListCreateInfoBuilder<'_> {}
unsafe impl ExtendsPhysicalDeviceImageFormatInfo2 for ImageFormatListCreateInfo {}
impl<'a> ::std::ops::Deref for ImageFormatListCreateInfoBuilder<'a> {
    type Target = ImageFormatListCreateInfo;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for ImageFormatListCreateInfoBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> ImageFormatListCreateInfoBuilder<'a> {
    pub fn view_formats(
        mut self,
        view_formats: &'a [Format],
    ) -> ImageFormatListCreateInfoBuilder<'a> {
        self.inner.view_format_count = view_formats.len() as _;
        self.inner.p_view_formats = view_formats.as_ptr();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> ImageFormatListCreateInfo {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkValidationCacheCreateInfoEXT.html>"]
pub struct ValidationCacheCreateInfoEXT {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub flags: ValidationCacheCreateFlagsEXT,
    pub initial_data_size: usize,
    pub p_initial_data: *const c_void,
}
impl ::std::default::Default for ValidationCacheCreateInfoEXT {
    fn default() -> ValidationCacheCreateInfoEXT {
        ValidationCacheCreateInfoEXT {
            s_type: StructureType::VALIDATION_CACHE_CREATE_INFO_EXT,
            p_next: ::std::ptr::null(),
            flags: ValidationCacheCreateFlagsEXT::default(),
            initial_data_size: usize::default(),
            p_initial_data: ::std::ptr::null(),
        }
    }
}
impl ValidationCacheCreateInfoEXT {
    pub fn builder<'a>() -> ValidationCacheCreateInfoEXTBuilder<'a> {
        ValidationCacheCreateInfoEXTBuilder {
            inner: ValidationCacheCreateInfoEXT::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct ValidationCacheCreateInfoEXTBuilder<'a> {
    inner: ValidationCacheCreateInfoEXT,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsValidationCacheCreateInfoEXT {}
impl<'a> ::std::ops::Deref for ValidationCacheCreateInfoEXTBuilder<'a> {
    type Target = ValidationCacheCreateInfoEXT;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for ValidationCacheCreateInfoEXTBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> ValidationCacheCreateInfoEXTBuilder<'a> {
    pub fn flags(
        mut self,
        flags: ValidationCacheCreateFlagsEXT,
    ) -> ValidationCacheCreateInfoEXTBuilder<'a> {
        self.inner.flags = flags;
        self
    }
    pub fn initial_data(
        mut self,
        initial_data: &'a [u8],
    ) -> ValidationCacheCreateInfoEXTBuilder<'a> {
        self.inner.initial_data_size = initial_data.len() as _;
        self.inner.p_initial_data = initial_data.as_ptr() as *const c_void;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsValidationCacheCreateInfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> ValidationCacheCreateInfoEXTBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> ValidationCacheCreateInfoEXT {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkShaderModuleValidationCacheCreateInfoEXT.html>"]
pub struct ShaderModuleValidationCacheCreateInfoEXT {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub validation_cache: ValidationCacheEXT,
}
impl ::std::default::Default for ShaderModuleValidationCacheCreateInfoEXT {
    fn default() -> ShaderModuleValidationCacheCreateInfoEXT {
        ShaderModuleValidationCacheCreateInfoEXT {
            s_type: StructureType::SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT,
            p_next: ::std::ptr::null(),
            validation_cache: ValidationCacheEXT::default(),
        }
    }
}
impl ShaderModuleValidationCacheCreateInfoEXT {
    pub fn builder<'a>() -> ShaderModuleValidationCacheCreateInfoEXTBuilder<'a> {
        ShaderModuleValidationCacheCreateInfoEXTBuilder {
            inner: ShaderModuleValidationCacheCreateInfoEXT::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct ShaderModuleValidationCacheCreateInfoEXTBuilder<'a> {
    inner: ShaderModuleValidationCacheCreateInfoEXT,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsShaderModuleCreateInfo for ShaderModuleValidationCacheCreateInfoEXTBuilder<'_> {}
unsafe impl ExtendsShaderModuleCreateInfo for ShaderModuleValidationCacheCreateInfoEXT {}
impl<'a> ::std::ops::Deref for ShaderModuleValidationCacheCreateInfoEXTBuilder<'a> {
    type Target = ShaderModuleValidationCacheCreateInfoEXT;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for ShaderModuleValidationCacheCreateInfoEXTBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> ShaderModuleValidationCacheCreateInfoEXTBuilder<'a> {
    pub fn validation_cache(
        mut self,
        validation_cache: ValidationCacheEXT,
    ) -> ShaderModuleValidationCacheCreateInfoEXTBuilder<'a> {
        self.inner.validation_cache = validation_cache;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> ShaderModuleValidationCacheCreateInfoEXT {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceMaintenance3Properties.html>"]
pub struct PhysicalDeviceMaintenance3Properties {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub max_per_set_descriptors: u32,
    pub max_memory_allocation_size: DeviceSize,
}
impl ::std::default::Default for PhysicalDeviceMaintenance3Properties {
    fn default() -> PhysicalDeviceMaintenance3Properties {
        PhysicalDeviceMaintenance3Properties {
            s_type: StructureType::PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES,
            p_next: ::std::ptr::null_mut(),
            max_per_set_descriptors: u32::default(),
            max_memory_allocation_size: DeviceSize::default(),
        }
    }
}
impl PhysicalDeviceMaintenance3Properties {
    pub fn builder<'a>() -> PhysicalDeviceMaintenance3PropertiesBuilder<'a> {
        PhysicalDeviceMaintenance3PropertiesBuilder {
            inner: PhysicalDeviceMaintenance3Properties::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDeviceMaintenance3PropertiesBuilder<'a> {
    inner: PhysicalDeviceMaintenance3Properties,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMaintenance3PropertiesBuilder<'_> {}
unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMaintenance3Properties {}
impl<'a> ::std::ops::Deref for PhysicalDeviceMaintenance3PropertiesBuilder<'a> {
    type Target = PhysicalDeviceMaintenance3Properties;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PhysicalDeviceMaintenance3PropertiesBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDeviceMaintenance3PropertiesBuilder<'a> {
    pub fn max_per_set_descriptors(
        mut self,
        max_per_set_descriptors: u32,
    ) -> PhysicalDeviceMaintenance3PropertiesBuilder<'a> {
        self.inner.max_per_set_descriptors = max_per_set_descriptors;
        self
    }
    pub fn max_memory_allocation_size(
        mut self,
        max_memory_allocation_size: DeviceSize,
    ) -> PhysicalDeviceMaintenance3PropertiesBuilder<'a> {
        self.inner.max_memory_allocation_size = max_memory_allocation_size;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDeviceMaintenance3Properties {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDescriptorSetLayoutSupport.html>"]
pub struct DescriptorSetLayoutSupport {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub supported: Bool32,
}
impl ::std::default::Default for DescriptorSetLayoutSupport {
    fn default() -> DescriptorSetLayoutSupport {
        DescriptorSetLayoutSupport {
            s_type: StructureType::DESCRIPTOR_SET_LAYOUT_SUPPORT,
            p_next: ::std::ptr::null_mut(),
            supported: Bool32::default(),
        }
    }
}
impl DescriptorSetLayoutSupport {
    pub fn builder<'a>() -> DescriptorSetLayoutSupportBuilder<'a> {
        DescriptorSetLayoutSupportBuilder {
            inner: DescriptorSetLayoutSupport::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct DescriptorSetLayoutSupportBuilder<'a> {
    inner: DescriptorSetLayoutSupport,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsDescriptorSetLayoutSupport {}
impl<'a> ::std::ops::Deref for DescriptorSetLayoutSupportBuilder<'a> {
    type Target = DescriptorSetLayoutSupport;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for DescriptorSetLayoutSupportBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> DescriptorSetLayoutSupportBuilder<'a> {
    pub fn supported(mut self, supported: bool) -> DescriptorSetLayoutSupportBuilder<'a> {
        self.inner.supported = supported.into();
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsDescriptorSetLayoutSupport>(
        mut self,
        next: &'a mut T,
    ) -> DescriptorSetLayoutSupportBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> DescriptorSetLayoutSupport {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceShaderDrawParametersFeatures.html>"]
pub struct PhysicalDeviceShaderDrawParametersFeatures {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub shader_draw_parameters: Bool32,
}
impl ::std::default::Default for PhysicalDeviceShaderDrawParametersFeatures {
    fn default() -> PhysicalDeviceShaderDrawParametersFeatures {
        PhysicalDeviceShaderDrawParametersFeatures {
            s_type: StructureType::PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES,
            p_next: ::std::ptr::null_mut(),
            shader_draw_parameters: Bool32::default(),
        }
    }
}
impl PhysicalDeviceShaderDrawParametersFeatures {
    pub fn builder<'a>() -> PhysicalDeviceShaderDrawParametersFeaturesBuilder<'a> {
        PhysicalDeviceShaderDrawParametersFeaturesBuilder {
            inner: PhysicalDeviceShaderDrawParametersFeatures::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDeviceShaderDrawParametersFeaturesBuilder<'a> {
    inner: PhysicalDeviceShaderDrawParametersFeatures,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderDrawParametersFeaturesBuilder<'_> {}
unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderDrawParametersFeatures {}
impl<'a> ::std::ops::Deref for PhysicalDeviceShaderDrawParametersFeaturesBuilder<'a> {
    type Target = PhysicalDeviceShaderDrawParametersFeatures;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderDrawParametersFeaturesBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDeviceShaderDrawParametersFeaturesBuilder<'a> {
    pub fn shader_draw_parameters(
        mut self,
        shader_draw_parameters: bool,
    ) -> PhysicalDeviceShaderDrawParametersFeaturesBuilder<'a> {
        self.inner.shader_draw_parameters = shader_draw_parameters.into();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDeviceShaderDrawParametersFeatures {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceShaderFloat16Int8Features.html>"]
pub struct PhysicalDeviceShaderFloat16Int8Features {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub shader_float16: Bool32,
    pub shader_int8: Bool32,
}
impl ::std::default::Default for PhysicalDeviceShaderFloat16Int8Features {
    fn default() -> PhysicalDeviceShaderFloat16Int8Features {
        PhysicalDeviceShaderFloat16Int8Features {
            s_type: StructureType::PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES,
            p_next: ::std::ptr::null_mut(),
            shader_float16: Bool32::default(),
            shader_int8: Bool32::default(),
        }
    }
}
impl PhysicalDeviceShaderFloat16Int8Features {
    pub fn builder<'a>() -> PhysicalDeviceShaderFloat16Int8FeaturesBuilder<'a> {
        PhysicalDeviceShaderFloat16Int8FeaturesBuilder {
            inner: PhysicalDeviceShaderFloat16Int8Features::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDeviceShaderFloat16Int8FeaturesBuilder<'a> {
    inner: PhysicalDeviceShaderFloat16Int8Features,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderFloat16Int8FeaturesBuilder<'_> {}
unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderFloat16Int8Features {}
impl<'a> ::std::ops::Deref for PhysicalDeviceShaderFloat16Int8FeaturesBuilder<'a> {
    type Target = PhysicalDeviceShaderFloat16Int8Features;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderFloat16Int8FeaturesBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDeviceShaderFloat16Int8FeaturesBuilder<'a> {
    pub fn shader_float16(
        mut self,
        shader_float16: bool,
    ) -> PhysicalDeviceShaderFloat16Int8FeaturesBuilder<'a> {
        self.inner.shader_float16 = shader_float16.into();
        self
    }
    pub fn shader_int8(
        mut self,
        shader_int8: bool,
    ) -> PhysicalDeviceShaderFloat16Int8FeaturesBuilder<'a> {
        self.inner.shader_int8 = shader_int8.into();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDeviceShaderFloat16Int8Features {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFloatControlsProperties.html>"]
pub struct PhysicalDeviceFloatControlsProperties {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub denorm_behavior_independence: ShaderFloatControlsIndependence,
    pub rounding_mode_independence: ShaderFloatControlsIndependence,
    pub shader_signed_zero_inf_nan_preserve_float16: Bool32,
    pub shader_signed_zero_inf_nan_preserve_float32: Bool32,
    pub shader_signed_zero_inf_nan_preserve_float64: Bool32,
    pub shader_denorm_preserve_float16: Bool32,
    pub shader_denorm_preserve_float32: Bool32,
    pub shader_denorm_preserve_float64: Bool32,
    pub shader_denorm_flush_to_zero_float16: Bool32,
    pub shader_denorm_flush_to_zero_float32: Bool32,
    pub shader_denorm_flush_to_zero_float64: Bool32,
    pub shader_rounding_mode_rte_float16: Bool32,
    pub shader_rounding_mode_rte_float32: Bool32,
    pub shader_rounding_mode_rte_float64: Bool32,
    pub shader_rounding_mode_rtz_float16: Bool32,
    pub shader_rounding_mode_rtz_float32: Bool32,
    pub shader_rounding_mode_rtz_float64: Bool32,
}
impl ::std::default::Default for PhysicalDeviceFloatControlsProperties {
    fn default() -> PhysicalDeviceFloatControlsProperties {
        PhysicalDeviceFloatControlsProperties {
            s_type: StructureType::PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES,
            p_next: ::std::ptr::null_mut(),
            denorm_behavior_independence: ShaderFloatControlsIndependence::default(),
            rounding_mode_independence: ShaderFloatControlsIndependence::default(),
            shader_signed_zero_inf_nan_preserve_float16: Bool32::default(),
            shader_signed_zero_inf_nan_preserve_float32: Bool32::default(),
            shader_signed_zero_inf_nan_preserve_float64: Bool32::default(),
            shader_denorm_preserve_float16: Bool32::default(),
            shader_denorm_preserve_float32: Bool32::default(),
            shader_denorm_preserve_float64: Bool32::default(),
            shader_denorm_flush_to_zero_float16: Bool32::default(),
            shader_denorm_flush_to_zero_float32: Bool32::default(),
            shader_denorm_flush_to_zero_float64: Bool32::default(),
            shader_rounding_mode_rte_float16: Bool32::default(),
            shader_rounding_mode_rte_float32: Bool32::default(),
            shader_rounding_mode_rte_float64: Bool32::default(),
            shader_rounding_mode_rtz_float16: Bool32::default(),
            shader_rounding_mode_rtz_float32: Bool32::default(),
            shader_rounding_mode_rtz_float64: Bool32::default(),
        }
    }
}
impl PhysicalDeviceFloatControlsProperties {
    pub fn builder<'a>() -> PhysicalDeviceFloatControlsPropertiesBuilder<'a> {
        PhysicalDeviceFloatControlsPropertiesBuilder {
            inner: PhysicalDeviceFloatControlsProperties::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDeviceFloatControlsPropertiesBuilder<'a> {
    inner: PhysicalDeviceFloatControlsProperties,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceFloatControlsPropertiesBuilder<'_> {}
unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceFloatControlsProperties {}
impl<'a> ::std::ops::Deref for PhysicalDeviceFloatControlsPropertiesBuilder<'a> {
    type Target = PhysicalDeviceFloatControlsProperties;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PhysicalDeviceFloatControlsPropertiesBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDeviceFloatControlsPropertiesBuilder<'a> {
    pub fn denorm_behavior_independence(
        mut self,
        denorm_behavior_independence: ShaderFloatControlsIndependence,
    ) -> PhysicalDeviceFloatControlsPropertiesBuilder<'a> {
        self.inner.denorm_behavior_independence = denorm_behavior_independence;
        self
    }
    pub fn rounding_mode_independence(
        mut self,
        rounding_mode_independence: ShaderFloatControlsIndependence,
    ) -> PhysicalDeviceFloatControlsPropertiesBuilder<'a> {
        self.inner.rounding_mode_independence = rounding_mode_independence;
        self
    }
    pub fn shader_signed_zero_inf_nan_preserve_float16(
        mut self,
        shader_signed_zero_inf_nan_preserve_float16: bool,
    ) -> PhysicalDeviceFloatControlsPropertiesBuilder<'a> {
        self.inner.shader_signed_zero_inf_nan_preserve_float16 =
            shader_signed_zero_inf_nan_preserve_float16.into();
        self
    }
    pub fn shader_signed_zero_inf_nan_preserve_float32(
        mut self,
        shader_signed_zero_inf_nan_preserve_float32: bool,
    ) -> PhysicalDeviceFloatControlsPropertiesBuilder<'a> {
        self.inner.shader_signed_zero_inf_nan_preserve_float32 =
            shader_signed_zero_inf_nan_preserve_float32.into();
        self
    }
    pub fn shader_signed_zero_inf_nan_preserve_float64(
        mut self,
        shader_signed_zero_inf_nan_preserve_float64: bool,
    ) -> PhysicalDeviceFloatControlsPropertiesBuilder<'a> {
        self.inner.shader_signed_zero_inf_nan_preserve_float64 =
            shader_signed_zero_inf_nan_preserve_float64.into();
        self
    }
    pub fn shader_denorm_preserve_float16(
        mut self,
        shader_denorm_preserve_float16: bool,
    ) -> PhysicalDeviceFloatControlsPropertiesBuilder<'a> {
        self.inner.shader_denorm_preserve_float16 = shader_denorm_preserve_float16.into();
        self
    }
    pub fn shader_denorm_preserve_float32(
        mut self,
        shader_denorm_preserve_float32: bool,
    ) -> PhysicalDeviceFloatControlsPropertiesBuilder<'a> {
        self.inner.shader_denorm_preserve_float32 = shader_denorm_preserve_float32.into();
        self
    }
    pub fn shader_denorm_preserve_float64(
        mut self,
        shader_denorm_preserve_float64: bool,
    ) -> PhysicalDeviceFloatControlsPropertiesBuilder<'a> {
        self.inner.shader_denorm_preserve_float64 = shader_denorm_preserve_float64.into();
        self
    }
    pub fn shader_denorm_flush_to_zero_float16(
        mut self,
        shader_denorm_flush_to_zero_float16: bool,
    ) -> PhysicalDeviceFloatControlsPropertiesBuilder<'a> {
        self.inner.shader_denorm_flush_to_zero_float16 = shader_denorm_flush_to_zero_float16.into();
        self
    }
    pub fn shader_denorm_flush_to_zero_float32(
        mut self,
        shader_denorm_flush_to_zero_float32: bool,
    ) -> PhysicalDeviceFloatControlsPropertiesBuilder<'a> {
        self.inner.shader_denorm_flush_to_zero_float32 = shader_denorm_flush_to_zero_float32.into();
        self
    }
    pub fn shader_denorm_flush_to_zero_float64(
        mut self,
        shader_denorm_flush_to_zero_float64: bool,
    ) -> PhysicalDeviceFloatControlsPropertiesBuilder<'a> {
        self.inner.shader_denorm_flush_to_zero_float64 = shader_denorm_flush_to_zero_float64.into();
        self
    }
    pub fn shader_rounding_mode_rte_float16(
        mut self,
        shader_rounding_mode_rte_float16: bool,
    ) -> PhysicalDeviceFloatControlsPropertiesBuilder<'a> {
        self.inner.shader_rounding_mode_rte_float16 = shader_rounding_mode_rte_float16.into();
        self
    }
    pub fn shader_rounding_mode_rte_float32(
        mut self,
        shader_rounding_mode_rte_float32: bool,
    ) -> PhysicalDeviceFloatControlsPropertiesBuilder<'a> {
        self.inner.shader_rounding_mode_rte_float32 = shader_rounding_mode_rte_float32.into();
        self
    }
    pub fn shader_rounding_mode_rte_float64(
        mut self,
        shader_rounding_mode_rte_float64: bool,
    ) -> PhysicalDeviceFloatControlsPropertiesBuilder<'a> {
        self.inner.shader_rounding_mode_rte_float64 = shader_rounding_mode_rte_float64.into();
        self
    }
    pub fn shader_rounding_mode_rtz_float16(
        mut self,
        shader_rounding_mode_rtz_float16: bool,
    ) -> PhysicalDeviceFloatControlsPropertiesBuilder<'a> {
        self.inner.shader_rounding_mode_rtz_float16 = shader_rounding_mode_rtz_float16.into();
        self
    }
    pub fn shader_rounding_mode_rtz_float32(
        mut self,
        shader_rounding_mode_rtz_float32: bool,
    ) -> PhysicalDeviceFloatControlsPropertiesBuilder<'a> {
        self.inner.shader_rounding_mode_rtz_float32 = shader_rounding_mode_rtz_float32.into();
        self
    }
    pub fn shader_rounding_mode_rtz_float64(
        mut self,
        shader_rounding_mode_rtz_float64: bool,
    ) -> PhysicalDeviceFloatControlsPropertiesBuilder<'a> {
        self.inner.shader_rounding_mode_rtz_float64 = shader_rounding_mode_rtz_float64.into();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDeviceFloatControlsProperties {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceHostQueryResetFeatures.html>"]
pub struct PhysicalDeviceHostQueryResetFeatures {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub host_query_reset: Bool32,
}
impl ::std::default::Default for PhysicalDeviceHostQueryResetFeatures {
    fn default() -> PhysicalDeviceHostQueryResetFeatures {
        PhysicalDeviceHostQueryResetFeatures {
            s_type: StructureType::PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES,
            p_next: ::std::ptr::null_mut(),
            host_query_reset: Bool32::default(),
        }
    }
}
impl PhysicalDeviceHostQueryResetFeatures {
    pub fn builder<'a>() -> PhysicalDeviceHostQueryResetFeaturesBuilder<'a> {
        PhysicalDeviceHostQueryResetFeaturesBuilder {
            inner: PhysicalDeviceHostQueryResetFeatures::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDeviceHostQueryResetFeaturesBuilder<'a> {
    inner: PhysicalDeviceHostQueryResetFeatures,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceHostQueryResetFeaturesBuilder<'_> {}
unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceHostQueryResetFeatures {}
impl<'a> ::std::ops::Deref for PhysicalDeviceHostQueryResetFeaturesBuilder<'a> {
    type Target = PhysicalDeviceHostQueryResetFeatures;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PhysicalDeviceHostQueryResetFeaturesBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDeviceHostQueryResetFeaturesBuilder<'a> {
    pub fn host_query_reset(
        mut self,
        host_query_reset: bool,
    ) -> PhysicalDeviceHostQueryResetFeaturesBuilder<'a> {
        self.inner.host_query_reset = host_query_reset.into();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDeviceHostQueryResetFeatures {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Default, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkNativeBufferUsage2ANDROID.html>"]
pub struct NativeBufferUsage2ANDROID {
    pub consumer: u64,
    pub producer: u64,
}
impl NativeBufferUsage2ANDROID {
    pub fn builder<'a>() -> NativeBufferUsage2ANDROIDBuilder<'a> {
        NativeBufferUsage2ANDROIDBuilder {
            inner: NativeBufferUsage2ANDROID::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct NativeBufferUsage2ANDROIDBuilder<'a> {
    inner: NativeBufferUsage2ANDROID,
    marker: ::std::marker::PhantomData<&'a ()>,
}
impl<'a> ::std::ops::Deref for NativeBufferUsage2ANDROIDBuilder<'a> {
    type Target = NativeBufferUsage2ANDROID;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for NativeBufferUsage2ANDROIDBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> NativeBufferUsage2ANDROIDBuilder<'a> {
    pub fn consumer(mut self, consumer: u64) -> NativeBufferUsage2ANDROIDBuilder<'a> {
        self.inner.consumer = consumer;
        self
    }
    pub fn producer(mut self, producer: u64) -> NativeBufferUsage2ANDROIDBuilder<'a> {
        self.inner.producer = producer;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> NativeBufferUsage2ANDROID {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkNativeBufferANDROID.html>"]
pub struct NativeBufferANDROID {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub handle: *const c_void,
    pub stride: c_int,
    pub format: c_int,
    pub usage: c_int,
    pub usage2: NativeBufferUsage2ANDROID,
}
impl ::std::default::Default for NativeBufferANDROID {
    fn default() -> NativeBufferANDROID {
        NativeBufferANDROID {
            s_type: StructureType::NATIVE_BUFFER_ANDROID,
            p_next: ::std::ptr::null(),
            handle: ::std::ptr::null(),
            stride: c_int::default(),
            format: c_int::default(),
            usage: c_int::default(),
            usage2: NativeBufferUsage2ANDROID::default(),
        }
    }
}
impl NativeBufferANDROID {
    pub fn builder<'a>() -> NativeBufferANDROIDBuilder<'a> {
        NativeBufferANDROIDBuilder {
            inner: NativeBufferANDROID::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct NativeBufferANDROIDBuilder<'a> {
    inner: NativeBufferANDROID,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsNativeBufferANDROID {}
impl<'a> ::std::ops::Deref for NativeBufferANDROIDBuilder<'a> {
    type Target = NativeBufferANDROID;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for NativeBufferANDROIDBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> NativeBufferANDROIDBuilder<'a> {
    pub fn handle(mut self, handle: *const c_void) -> NativeBufferANDROIDBuilder<'a> {
        self.inner.handle = handle;
        self
    }
    pub fn stride(mut self, stride: c_int) -> NativeBufferANDROIDBuilder<'a> {
        self.inner.stride = stride;
        self
    }
    pub fn format(mut self, format: c_int) -> NativeBufferANDROIDBuilder<'a> {
        self.inner.format = format;
        self
    }
    pub fn usage(mut self, usage: c_int) -> NativeBufferANDROIDBuilder<'a> {
        self.inner.usage = usage;
        self
    }
    pub fn usage2(mut self, usage2: NativeBufferUsage2ANDROID) -> NativeBufferANDROIDBuilder<'a> {
        self.inner.usage2 = usage2;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsNativeBufferANDROID>(
        mut self,
        next: &'a mut T,
    ) -> NativeBufferANDROIDBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> NativeBufferANDROID {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSwapchainImageCreateInfoANDROID.html>"]
pub struct SwapchainImageCreateInfoANDROID {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub usage: SwapchainImageUsageFlagsANDROID,
}
impl ::std::default::Default for SwapchainImageCreateInfoANDROID {
    fn default() -> SwapchainImageCreateInfoANDROID {
        SwapchainImageCreateInfoANDROID {
            s_type: StructureType::SWAPCHAIN_IMAGE_CREATE_INFO_ANDROID,
            p_next: ::std::ptr::null(),
            usage: SwapchainImageUsageFlagsANDROID::default(),
        }
    }
}
impl SwapchainImageCreateInfoANDROID {
    pub fn builder<'a>() -> SwapchainImageCreateInfoANDROIDBuilder<'a> {
        SwapchainImageCreateInfoANDROIDBuilder {
            inner: SwapchainImageCreateInfoANDROID::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct SwapchainImageCreateInfoANDROIDBuilder<'a> {
    inner: SwapchainImageCreateInfoANDROID,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsSwapchainImageCreateInfoANDROID {}
impl<'a> ::std::ops::Deref for SwapchainImageCreateInfoANDROIDBuilder<'a> {
    type Target = SwapchainImageCreateInfoANDROID;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for SwapchainImageCreateInfoANDROIDBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> SwapchainImageCreateInfoANDROIDBuilder<'a> {
    pub fn usage(
        mut self,
        usage: SwapchainImageUsageFlagsANDROID,
    ) -> SwapchainImageCreateInfoANDROIDBuilder<'a> {
        self.inner.usage = usage;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsSwapchainImageCreateInfoANDROID>(
        mut self,
        next: &'a mut T,
    ) -> SwapchainImageCreateInfoANDROIDBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> SwapchainImageCreateInfoANDROID {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDevicePresentationPropertiesANDROID.html>"]
pub struct PhysicalDevicePresentationPropertiesANDROID {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub shared_image: Bool32,
}
impl ::std::default::Default for PhysicalDevicePresentationPropertiesANDROID {
    fn default() -> PhysicalDevicePresentationPropertiesANDROID {
        PhysicalDevicePresentationPropertiesANDROID {
            s_type: StructureType::PHYSICAL_DEVICE_PRESENTATION_PROPERTIES_ANDROID,
            p_next: ::std::ptr::null(),
            shared_image: Bool32::default(),
        }
    }
}
impl PhysicalDevicePresentationPropertiesANDROID {
    pub fn builder<'a>() -> PhysicalDevicePresentationPropertiesANDROIDBuilder<'a> {
        PhysicalDevicePresentationPropertiesANDROIDBuilder {
            inner: PhysicalDevicePresentationPropertiesANDROID::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDevicePresentationPropertiesANDROIDBuilder<'a> {
    inner: PhysicalDevicePresentationPropertiesANDROID,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsPhysicalDevicePresentationPropertiesANDROID {}
impl<'a> ::std::ops::Deref for PhysicalDevicePresentationPropertiesANDROIDBuilder<'a> {
    type Target = PhysicalDevicePresentationPropertiesANDROID;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PhysicalDevicePresentationPropertiesANDROIDBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDevicePresentationPropertiesANDROIDBuilder<'a> {
    pub fn shared_image(
        mut self,
        shared_image: bool,
    ) -> PhysicalDevicePresentationPropertiesANDROIDBuilder<'a> {
        self.inner.shared_image = shared_image.into();
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsPhysicalDevicePresentationPropertiesANDROID>(
        mut self,
        next: &'a mut T,
    ) -> PhysicalDevicePresentationPropertiesANDROIDBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDevicePresentationPropertiesANDROID {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Default, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkShaderResourceUsageAMD.html>"]
pub struct ShaderResourceUsageAMD {
    pub num_used_vgprs: u32,
    pub num_used_sgprs: u32,
    pub lds_size_per_local_work_group: u32,
    pub lds_usage_size_in_bytes: usize,
    pub scratch_mem_usage_in_bytes: usize,
}
impl ShaderResourceUsageAMD {
    pub fn builder<'a>() -> ShaderResourceUsageAMDBuilder<'a> {
        ShaderResourceUsageAMDBuilder {
            inner: ShaderResourceUsageAMD::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct ShaderResourceUsageAMDBuilder<'a> {
    inner: ShaderResourceUsageAMD,
    marker: ::std::marker::PhantomData<&'a ()>,
}
impl<'a> ::std::ops::Deref for ShaderResourceUsageAMDBuilder<'a> {
    type Target = ShaderResourceUsageAMD;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for ShaderResourceUsageAMDBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> ShaderResourceUsageAMDBuilder<'a> {
    pub fn num_used_vgprs(mut self, num_used_vgprs: u32) -> ShaderResourceUsageAMDBuilder<'a> {
        self.inner.num_used_vgprs = num_used_vgprs;
        self
    }
    pub fn num_used_sgprs(mut self, num_used_sgprs: u32) -> ShaderResourceUsageAMDBuilder<'a> {
        self.inner.num_used_sgprs = num_used_sgprs;
        self
    }
    pub fn lds_size_per_local_work_group(
        mut self,
        lds_size_per_local_work_group: u32,
    ) -> ShaderResourceUsageAMDBuilder<'a> {
        self.inner.lds_size_per_local_work_group = lds_size_per_local_work_group;
        self
    }
    pub fn lds_usage_size_in_bytes(
        mut self,
        lds_usage_size_in_bytes: usize,
    ) -> ShaderResourceUsageAMDBuilder<'a> {
        self.inner.lds_usage_size_in_bytes = lds_usage_size_in_bytes;
        self
    }
    pub fn scratch_mem_usage_in_bytes(
        mut self,
        scratch_mem_usage_in_bytes: usize,
    ) -> ShaderResourceUsageAMDBuilder<'a> {
        self.inner.scratch_mem_usage_in_bytes = scratch_mem_usage_in_bytes;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> ShaderResourceUsageAMD {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkShaderStatisticsInfoAMD.html>"]
pub struct ShaderStatisticsInfoAMD {
    pub shader_stage_mask: ShaderStageFlags,
    pub resource_usage: ShaderResourceUsageAMD,
    pub num_physical_vgprs: u32,
    pub num_physical_sgprs: u32,
    pub num_available_vgprs: u32,
    pub num_available_sgprs: u32,
    pub compute_work_group_size: [u32; 3],
}
impl ::std::default::Default for ShaderStatisticsInfoAMD {
    fn default() -> ShaderStatisticsInfoAMD {
        ShaderStatisticsInfoAMD {
            shader_stage_mask: ShaderStageFlags::default(),
            resource_usage: ShaderResourceUsageAMD::default(),
            num_physical_vgprs: u32::default(),
            num_physical_sgprs: u32::default(),
            num_available_vgprs: u32::default(),
            num_available_sgprs: u32::default(),
            compute_work_group_size: unsafe { ::std::mem::zeroed() },
        }
    }
}
impl ShaderStatisticsInfoAMD {
    pub fn builder<'a>() -> ShaderStatisticsInfoAMDBuilder<'a> {
        ShaderStatisticsInfoAMDBuilder {
            inner: ShaderStatisticsInfoAMD::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct ShaderStatisticsInfoAMDBuilder<'a> {
    inner: ShaderStatisticsInfoAMD,
    marker: ::std::marker::PhantomData<&'a ()>,
}
impl<'a> ::std::ops::Deref for ShaderStatisticsInfoAMDBuilder<'a> {
    type Target = ShaderStatisticsInfoAMD;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for ShaderStatisticsInfoAMDBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> ShaderStatisticsInfoAMDBuilder<'a> {
    pub fn shader_stage_mask(
        mut self,
        shader_stage_mask: ShaderStageFlags,
    ) -> ShaderStatisticsInfoAMDBuilder<'a> {
        self.inner.shader_stage_mask = shader_stage_mask;
        self
    }
    pub fn resource_usage(
        mut self,
        resource_usage: ShaderResourceUsageAMD,
    ) -> ShaderStatisticsInfoAMDBuilder<'a> {
        self.inner.resource_usage = resource_usage;
        self
    }
    pub fn num_physical_vgprs(
        mut self,
        num_physical_vgprs: u32,
    ) -> ShaderStatisticsInfoAMDBuilder<'a> {
        self.inner.num_physical_vgprs = num_physical_vgprs;
        self
    }
    pub fn num_physical_sgprs(
        mut self,
        num_physical_sgprs: u32,
    ) -> ShaderStatisticsInfoAMDBuilder<'a> {
        self.inner.num_physical_sgprs = num_physical_sgprs;
        self
    }
    pub fn num_available_vgprs(
        mut self,
        num_available_vgprs: u32,
    ) -> ShaderStatisticsInfoAMDBuilder<'a> {
        self.inner.num_available_vgprs = num_available_vgprs;
        self
    }
    pub fn num_available_sgprs(
        mut self,
        num_available_sgprs: u32,
    ) -> ShaderStatisticsInfoAMDBuilder<'a> {
        self.inner.num_available_sgprs = num_available_sgprs;
        self
    }
    pub fn compute_work_group_size(
        mut self,
        compute_work_group_size: [u32; 3],
    ) -> ShaderStatisticsInfoAMDBuilder<'a> {
        self.inner.compute_work_group_size = compute_work_group_size;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> ShaderStatisticsInfoAMD {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDeviceQueueGlobalPriorityCreateInfoEXT.html>"]
pub struct DeviceQueueGlobalPriorityCreateInfoEXT {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub global_priority: QueueGlobalPriorityEXT,
}
impl ::std::default::Default for DeviceQueueGlobalPriorityCreateInfoEXT {
    fn default() -> DeviceQueueGlobalPriorityCreateInfoEXT {
        DeviceQueueGlobalPriorityCreateInfoEXT {
            s_type: StructureType::DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT,
            p_next: ::std::ptr::null(),
            global_priority: QueueGlobalPriorityEXT::default(),
        }
    }
}
impl DeviceQueueGlobalPriorityCreateInfoEXT {
    pub fn builder<'a>() -> DeviceQueueGlobalPriorityCreateInfoEXTBuilder<'a> {
        DeviceQueueGlobalPriorityCreateInfoEXTBuilder {
            inner: DeviceQueueGlobalPriorityCreateInfoEXT::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct DeviceQueueGlobalPriorityCreateInfoEXTBuilder<'a> {
    inner: DeviceQueueGlobalPriorityCreateInfoEXT,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsDeviceQueueCreateInfo for DeviceQueueGlobalPriorityCreateInfoEXTBuilder<'_> {}
unsafe impl ExtendsDeviceQueueCreateInfo for DeviceQueueGlobalPriorityCreateInfoEXT {}
impl<'a> ::std::ops::Deref for DeviceQueueGlobalPriorityCreateInfoEXTBuilder<'a> {
    type Target = DeviceQueueGlobalPriorityCreateInfoEXT;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for DeviceQueueGlobalPriorityCreateInfoEXTBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> DeviceQueueGlobalPriorityCreateInfoEXTBuilder<'a> {
    pub fn global_priority(
        mut self,
        global_priority: QueueGlobalPriorityEXT,
    ) -> DeviceQueueGlobalPriorityCreateInfoEXTBuilder<'a> {
        self.inner.global_priority = global_priority;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> DeviceQueueGlobalPriorityCreateInfoEXT {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDebugUtilsObjectNameInfoEXT.html>"]
pub struct DebugUtilsObjectNameInfoEXT {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub object_type: ObjectType,
    pub object_handle: u64,
    pub p_object_name: *const c_char,
}
impl ::std::default::Default for DebugUtilsObjectNameInfoEXT {
    fn default() -> DebugUtilsObjectNameInfoEXT {
        DebugUtilsObjectNameInfoEXT {
            s_type: StructureType::DEBUG_UTILS_OBJECT_NAME_INFO_EXT,
            p_next: ::std::ptr::null(),
            object_type: ObjectType::default(),
            object_handle: u64::default(),
            p_object_name: ::std::ptr::null(),
        }
    }
}
impl DebugUtilsObjectNameInfoEXT {
    pub fn builder<'a>() -> DebugUtilsObjectNameInfoEXTBuilder<'a> {
        DebugUtilsObjectNameInfoEXTBuilder {
            inner: DebugUtilsObjectNameInfoEXT::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct DebugUtilsObjectNameInfoEXTBuilder<'a> {
    inner: DebugUtilsObjectNameInfoEXT,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsDebugUtilsObjectNameInfoEXT {}
impl<'a> ::std::ops::Deref for DebugUtilsObjectNameInfoEXTBuilder<'a> {
    type Target = DebugUtilsObjectNameInfoEXT;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for DebugUtilsObjectNameInfoEXTBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> DebugUtilsObjectNameInfoEXTBuilder<'a> {
    pub fn object_type(
        mut self,
        object_type: ObjectType,
    ) -> DebugUtilsObjectNameInfoEXTBuilder<'a> {
        self.inner.object_type = object_type;
        self
    }
    pub fn object_handle(mut self, object_handle: u64) -> DebugUtilsObjectNameInfoEXTBuilder<'a> {
        self.inner.object_handle = object_handle;
        self
    }
    pub fn object_name(
        mut self,
        object_name: &'a ::std::ffi::CStr,
    ) -> DebugUtilsObjectNameInfoEXTBuilder<'a> {
        self.inner.p_object_name = object_name.as_ptr();
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsDebugUtilsObjectNameInfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> DebugUtilsObjectNameInfoEXTBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> DebugUtilsObjectNameInfoEXT {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDebugUtilsObjectTagInfoEXT.html>"]
pub struct DebugUtilsObjectTagInfoEXT {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub object_type: ObjectType,
    pub object_handle: u64,
    pub tag_name: u64,
    pub tag_size: usize,
    pub p_tag: *const c_void,
}
impl ::std::default::Default for DebugUtilsObjectTagInfoEXT {
    fn default() -> DebugUtilsObjectTagInfoEXT {
        DebugUtilsObjectTagInfoEXT {
            s_type: StructureType::DEBUG_UTILS_OBJECT_TAG_INFO_EXT,
            p_next: ::std::ptr::null(),
            object_type: ObjectType::default(),
            object_handle: u64::default(),
            tag_name: u64::default(),
            tag_size: usize::default(),
            p_tag: ::std::ptr::null(),
        }
    }
}
impl DebugUtilsObjectTagInfoEXT {
    pub fn builder<'a>() -> DebugUtilsObjectTagInfoEXTBuilder<'a> {
        DebugUtilsObjectTagInfoEXTBuilder {
            inner: DebugUtilsObjectTagInfoEXT::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct DebugUtilsObjectTagInfoEXTBuilder<'a> {
    inner: DebugUtilsObjectTagInfoEXT,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsDebugUtilsObjectTagInfoEXT {}
impl<'a> ::std::ops::Deref for DebugUtilsObjectTagInfoEXTBuilder<'a> {
    type Target = DebugUtilsObjectTagInfoEXT;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for DebugUtilsObjectTagInfoEXTBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> DebugUtilsObjectTagInfoEXTBuilder<'a> {
    pub fn object_type(mut self, object_type: ObjectType) -> DebugUtilsObjectTagInfoEXTBuilder<'a> {
        self.inner.object_type = object_type;
        self
    }
    pub fn object_handle(mut self, object_handle: u64) -> DebugUtilsObjectTagInfoEXTBuilder<'a> {
        self.inner.object_handle = object_handle;
        self
    }
    pub fn tag_name(mut self, tag_name: u64) -> DebugUtilsObjectTagInfoEXTBuilder<'a> {
        self.inner.tag_name = tag_name;
        self
    }
    pub fn tag(mut self, tag: &'a [u8]) -> DebugUtilsObjectTagInfoEXTBuilder<'a> {
        self.inner.tag_size = tag.len() as _;
        self.inner.p_tag = tag.as_ptr() as *const c_void;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsDebugUtilsObjectTagInfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> DebugUtilsObjectTagInfoEXTBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> DebugUtilsObjectTagInfoEXT {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDebugUtilsLabelEXT.html>"]
pub struct DebugUtilsLabelEXT {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub p_label_name: *const c_char,
    pub color: [f32; 4],
}
impl ::std::default::Default for DebugUtilsLabelEXT {
    fn default() -> DebugUtilsLabelEXT {
        DebugUtilsLabelEXT {
            s_type: StructureType::DEBUG_UTILS_LABEL_EXT,
            p_next: ::std::ptr::null(),
            p_label_name: ::std::ptr::null(),
            color: unsafe { ::std::mem::zeroed() },
        }
    }
}
impl DebugUtilsLabelEXT {
    pub fn builder<'a>() -> DebugUtilsLabelEXTBuilder<'a> {
        DebugUtilsLabelEXTBuilder {
            inner: DebugUtilsLabelEXT::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct DebugUtilsLabelEXTBuilder<'a> {
    inner: DebugUtilsLabelEXT,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsDebugUtilsLabelEXT {}
impl<'a> ::std::ops::Deref for DebugUtilsLabelEXTBuilder<'a> {
    type Target = DebugUtilsLabelEXT;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for DebugUtilsLabelEXTBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> DebugUtilsLabelEXTBuilder<'a> {
    pub fn label_name(mut self, label_name: &'a ::std::ffi::CStr) -> DebugUtilsLabelEXTBuilder<'a> {
        self.inner.p_label_name = label_name.as_ptr();
        self
    }
    pub fn color(mut self, color: [f32; 4]) -> DebugUtilsLabelEXTBuilder<'a> {
        self.inner.color = color;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsDebugUtilsLabelEXT>(
        mut self,
        next: &'a mut T,
    ) -> DebugUtilsLabelEXTBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> DebugUtilsLabelEXT {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDebugUtilsMessengerCreateInfoEXT.html>"]
pub struct DebugUtilsMessengerCreateInfoEXT {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub flags: DebugUtilsMessengerCreateFlagsEXT,
    pub message_severity: DebugUtilsMessageSeverityFlagsEXT,
    pub message_type: DebugUtilsMessageTypeFlagsEXT,
    pub pfn_user_callback: PFN_vkDebugUtilsMessengerCallbackEXT,
    pub p_user_data: *mut c_void,
}
impl fmt::Debug for DebugUtilsMessengerCreateInfoEXT {
    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
        fmt.debug_struct("DebugUtilsMessengerCreateInfoEXT")
            .field("s_type", &self.s_type)
            .field("p_next", &self.p_next)
            .field("flags", &self.flags)
            .field("message_severity", &self.message_severity)
            .field("message_type", &self.message_type)
            .field(
                "pfn_user_callback",
                &(self.pfn_user_callback.map(|x| x as *const ())),
            )
            .field("p_user_data", &self.p_user_data)
            .finish()
    }
}
impl ::std::default::Default for DebugUtilsMessengerCreateInfoEXT {
    fn default() -> DebugUtilsMessengerCreateInfoEXT {
        DebugUtilsMessengerCreateInfoEXT {
            s_type: StructureType::DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT,
            p_next: ::std::ptr::null(),
            flags: DebugUtilsMessengerCreateFlagsEXT::default(),
            message_severity: DebugUtilsMessageSeverityFlagsEXT::default(),
            message_type: DebugUtilsMessageTypeFlagsEXT::default(),
            pfn_user_callback: PFN_vkDebugUtilsMessengerCallbackEXT::default(),
            p_user_data: ::std::ptr::null_mut(),
        }
    }
}
impl DebugUtilsMessengerCreateInfoEXT {
    pub fn builder<'a>() -> DebugUtilsMessengerCreateInfoEXTBuilder<'a> {
        DebugUtilsMessengerCreateInfoEXTBuilder {
            inner: DebugUtilsMessengerCreateInfoEXT::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct DebugUtilsMessengerCreateInfoEXTBuilder<'a> {
    inner: DebugUtilsMessengerCreateInfoEXT,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsInstanceCreateInfo for DebugUtilsMessengerCreateInfoEXTBuilder<'_> {}
unsafe impl ExtendsInstanceCreateInfo for DebugUtilsMessengerCreateInfoEXT {}
impl<'a> ::std::ops::Deref for DebugUtilsMessengerCreateInfoEXTBuilder<'a> {
    type Target = DebugUtilsMessengerCreateInfoEXT;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for DebugUtilsMessengerCreateInfoEXTBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> DebugUtilsMessengerCreateInfoEXTBuilder<'a> {
    pub fn flags(
        mut self,
        flags: DebugUtilsMessengerCreateFlagsEXT,
    ) -> DebugUtilsMessengerCreateInfoEXTBuilder<'a> {
        self.inner.flags = flags;
        self
    }
    pub fn message_severity(
        mut self,
        message_severity: DebugUtilsMessageSeverityFlagsEXT,
    ) -> DebugUtilsMessengerCreateInfoEXTBuilder<'a> {
        self.inner.message_severity = message_severity;
        self
    }
    pub fn message_type(
        mut self,
        message_type: DebugUtilsMessageTypeFlagsEXT,
    ) -> DebugUtilsMessengerCreateInfoEXTBuilder<'a> {
        self.inner.message_type = message_type;
        self
    }
    pub fn pfn_user_callback(
        mut self,
        pfn_user_callback: PFN_vkDebugUtilsMessengerCallbackEXT,
    ) -> DebugUtilsMessengerCreateInfoEXTBuilder<'a> {
        self.inner.pfn_user_callback = pfn_user_callback;
        self
    }
    pub fn user_data(
        mut self,
        user_data: *mut c_void,
    ) -> DebugUtilsMessengerCreateInfoEXTBuilder<'a> {
        self.inner.p_user_data = user_data;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> DebugUtilsMessengerCreateInfoEXT {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDebugUtilsMessengerCallbackDataEXT.html>"]
pub struct DebugUtilsMessengerCallbackDataEXT {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub flags: DebugUtilsMessengerCallbackDataFlagsEXT,
    pub p_message_id_name: *const c_char,
    pub message_id_number: i32,
    pub p_message: *const c_char,
    pub queue_label_count: u32,
    pub p_queue_labels: *const DebugUtilsLabelEXT,
    pub cmd_buf_label_count: u32,
    pub p_cmd_buf_labels: *const DebugUtilsLabelEXT,
    pub object_count: u32,
    pub p_objects: *const DebugUtilsObjectNameInfoEXT,
}
impl ::std::default::Default for DebugUtilsMessengerCallbackDataEXT {
    fn default() -> DebugUtilsMessengerCallbackDataEXT {
        DebugUtilsMessengerCallbackDataEXT {
            s_type: StructureType::DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT,
            p_next: ::std::ptr::null(),
            flags: DebugUtilsMessengerCallbackDataFlagsEXT::default(),
            p_message_id_name: ::std::ptr::null(),
            message_id_number: i32::default(),
            p_message: ::std::ptr::null(),
            queue_label_count: u32::default(),
            p_queue_labels: ::std::ptr::null(),
            cmd_buf_label_count: u32::default(),
            p_cmd_buf_labels: ::std::ptr::null(),
            object_count: u32::default(),
            p_objects: ::std::ptr::null(),
        }
    }
}
impl DebugUtilsMessengerCallbackDataEXT {
    pub fn builder<'a>() -> DebugUtilsMessengerCallbackDataEXTBuilder<'a> {
        DebugUtilsMessengerCallbackDataEXTBuilder {
            inner: DebugUtilsMessengerCallbackDataEXT::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct DebugUtilsMessengerCallbackDataEXTBuilder<'a> {
    inner: DebugUtilsMessengerCallbackDataEXT,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsDebugUtilsMessengerCallbackDataEXT {}
impl<'a> ::std::ops::Deref for DebugUtilsMessengerCallbackDataEXTBuilder<'a> {
    type Target = DebugUtilsMessengerCallbackDataEXT;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for DebugUtilsMessengerCallbackDataEXTBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> DebugUtilsMessengerCallbackDataEXTBuilder<'a> {
    pub fn flags(
        mut self,
        flags: DebugUtilsMessengerCallbackDataFlagsEXT,
    ) -> DebugUtilsMessengerCallbackDataEXTBuilder<'a> {
        self.inner.flags = flags;
        self
    }
    pub fn message_id_name(
        mut self,
        message_id_name: &'a ::std::ffi::CStr,
    ) -> DebugUtilsMessengerCallbackDataEXTBuilder<'a> {
        self.inner.p_message_id_name = message_id_name.as_ptr();
        self
    }
    pub fn message_id_number(
        mut self,
        message_id_number: i32,
    ) -> DebugUtilsMessengerCallbackDataEXTBuilder<'a> {
        self.inner.message_id_number = message_id_number;
        self
    }
    pub fn message(
        mut self,
        message: &'a ::std::ffi::CStr,
    ) -> DebugUtilsMessengerCallbackDataEXTBuilder<'a> {
        self.inner.p_message = message.as_ptr();
        self
    }
    pub fn queue_labels(
        mut self,
        queue_labels: &'a [DebugUtilsLabelEXT],
    ) -> DebugUtilsMessengerCallbackDataEXTBuilder<'a> {
        self.inner.queue_label_count = queue_labels.len() as _;
        self.inner.p_queue_labels = queue_labels.as_ptr();
        self
    }
    pub fn cmd_buf_labels(
        mut self,
        cmd_buf_labels: &'a [DebugUtilsLabelEXT],
    ) -> DebugUtilsMessengerCallbackDataEXTBuilder<'a> {
        self.inner.cmd_buf_label_count = cmd_buf_labels.len() as _;
        self.inner.p_cmd_buf_labels = cmd_buf_labels.as_ptr();
        self
    }
    pub fn objects(
        mut self,
        objects: &'a [DebugUtilsObjectNameInfoEXT],
    ) -> DebugUtilsMessengerCallbackDataEXTBuilder<'a> {
        self.inner.object_count = objects.len() as _;
        self.inner.p_objects = objects.as_ptr();
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsDebugUtilsMessengerCallbackDataEXT>(
        mut self,
        next: &'a mut T,
    ) -> DebugUtilsMessengerCallbackDataEXTBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> DebugUtilsMessengerCallbackDataEXT {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImportMemoryHostPointerInfoEXT.html>"]
pub struct ImportMemoryHostPointerInfoEXT {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub handle_type: ExternalMemoryHandleTypeFlags,
    pub p_host_pointer: *mut c_void,
}
impl ::std::default::Default for ImportMemoryHostPointerInfoEXT {
    fn default() -> ImportMemoryHostPointerInfoEXT {
        ImportMemoryHostPointerInfoEXT {
            s_type: StructureType::IMPORT_MEMORY_HOST_POINTER_INFO_EXT,
            p_next: ::std::ptr::null(),
            handle_type: ExternalMemoryHandleTypeFlags::default(),
            p_host_pointer: ::std::ptr::null_mut(),
        }
    }
}
impl ImportMemoryHostPointerInfoEXT {
    pub fn builder<'a>() -> ImportMemoryHostPointerInfoEXTBuilder<'a> {
        ImportMemoryHostPointerInfoEXTBuilder {
            inner: ImportMemoryHostPointerInfoEXT::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct ImportMemoryHostPointerInfoEXTBuilder<'a> {
    inner: ImportMemoryHostPointerInfoEXT,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryHostPointerInfoEXTBuilder<'_> {}
unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryHostPointerInfoEXT {}
impl<'a> ::std::ops::Deref for ImportMemoryHostPointerInfoEXTBuilder<'a> {
    type Target = ImportMemoryHostPointerInfoEXT;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for ImportMemoryHostPointerInfoEXTBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> ImportMemoryHostPointerInfoEXTBuilder<'a> {
    pub fn handle_type(
        mut self,
        handle_type: ExternalMemoryHandleTypeFlags,
    ) -> ImportMemoryHostPointerInfoEXTBuilder<'a> {
        self.inner.handle_type = handle_type;
        self
    }
    pub fn host_pointer(
        mut self,
        host_pointer: *mut c_void,
    ) -> ImportMemoryHostPointerInfoEXTBuilder<'a> {
        self.inner.p_host_pointer = host_pointer;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> ImportMemoryHostPointerInfoEXT {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkMemoryHostPointerPropertiesEXT.html>"]
pub struct MemoryHostPointerPropertiesEXT {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub memory_type_bits: u32,
}
impl ::std::default::Default for MemoryHostPointerPropertiesEXT {
    fn default() -> MemoryHostPointerPropertiesEXT {
        MemoryHostPointerPropertiesEXT {
            s_type: StructureType::MEMORY_HOST_POINTER_PROPERTIES_EXT,
            p_next: ::std::ptr::null_mut(),
            memory_type_bits: u32::default(),
        }
    }
}
impl MemoryHostPointerPropertiesEXT {
    pub fn builder<'a>() -> MemoryHostPointerPropertiesEXTBuilder<'a> {
        MemoryHostPointerPropertiesEXTBuilder {
            inner: MemoryHostPointerPropertiesEXT::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct MemoryHostPointerPropertiesEXTBuilder<'a> {
    inner: MemoryHostPointerPropertiesEXT,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsMemoryHostPointerPropertiesEXT {}
impl<'a> ::std::ops::Deref for MemoryHostPointerPropertiesEXTBuilder<'a> {
    type Target = MemoryHostPointerPropertiesEXT;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for MemoryHostPointerPropertiesEXTBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> MemoryHostPointerPropertiesEXTBuilder<'a> {
    pub fn memory_type_bits(
        mut self,
        memory_type_bits: u32,
    ) -> MemoryHostPointerPropertiesEXTBuilder<'a> {
        self.inner.memory_type_bits = memory_type_bits;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsMemoryHostPointerPropertiesEXT>(
        mut self,
        next: &'a mut T,
    ) -> MemoryHostPointerPropertiesEXTBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> MemoryHostPointerPropertiesEXT {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceExternalMemoryHostPropertiesEXT.html>"]
pub struct PhysicalDeviceExternalMemoryHostPropertiesEXT {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub min_imported_host_pointer_alignment: DeviceSize,
}
impl ::std::default::Default for PhysicalDeviceExternalMemoryHostPropertiesEXT {
    fn default() -> PhysicalDeviceExternalMemoryHostPropertiesEXT {
        PhysicalDeviceExternalMemoryHostPropertiesEXT {
            s_type: StructureType::PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT,
            p_next: ::std::ptr::null_mut(),
            min_imported_host_pointer_alignment: DeviceSize::default(),
        }
    }
}
impl PhysicalDeviceExternalMemoryHostPropertiesEXT {
    pub fn builder<'a>() -> PhysicalDeviceExternalMemoryHostPropertiesEXTBuilder<'a> {
        PhysicalDeviceExternalMemoryHostPropertiesEXTBuilder {
            inner: PhysicalDeviceExternalMemoryHostPropertiesEXT::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDeviceExternalMemoryHostPropertiesEXTBuilder<'a> {
    inner: PhysicalDeviceExternalMemoryHostPropertiesEXT,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsPhysicalDeviceProperties2
    for PhysicalDeviceExternalMemoryHostPropertiesEXTBuilder<'_>
{
}
unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceExternalMemoryHostPropertiesEXT {}
impl<'a> ::std::ops::Deref for PhysicalDeviceExternalMemoryHostPropertiesEXTBuilder<'a> {
    type Target = PhysicalDeviceExternalMemoryHostPropertiesEXT;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PhysicalDeviceExternalMemoryHostPropertiesEXTBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDeviceExternalMemoryHostPropertiesEXTBuilder<'a> {
    pub fn min_imported_host_pointer_alignment(
        mut self,
        min_imported_host_pointer_alignment: DeviceSize,
    ) -> PhysicalDeviceExternalMemoryHostPropertiesEXTBuilder<'a> {
        self.inner.min_imported_host_pointer_alignment = min_imported_host_pointer_alignment;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDeviceExternalMemoryHostPropertiesEXT {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceConservativeRasterizationPropertiesEXT.html>"]
pub struct PhysicalDeviceConservativeRasterizationPropertiesEXT {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub primitive_overestimation_size: f32,
    pub max_extra_primitive_overestimation_size: f32,
    pub extra_primitive_overestimation_size_granularity: f32,
    pub primitive_underestimation: Bool32,
    pub conservative_point_and_line_rasterization: Bool32,
    pub degenerate_triangles_rasterized: Bool32,
    pub degenerate_lines_rasterized: Bool32,
    pub fully_covered_fragment_shader_input_variable: Bool32,
    pub conservative_rasterization_post_depth_coverage: Bool32,
}
impl ::std::default::Default for PhysicalDeviceConservativeRasterizationPropertiesEXT {
    fn default() -> PhysicalDeviceConservativeRasterizationPropertiesEXT {
        PhysicalDeviceConservativeRasterizationPropertiesEXT {
            s_type: StructureType::PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT,
            p_next: ::std::ptr::null_mut(),
            primitive_overestimation_size: f32::default(),
            max_extra_primitive_overestimation_size: f32::default(),
            extra_primitive_overestimation_size_granularity: f32::default(),
            primitive_underestimation: Bool32::default(),
            conservative_point_and_line_rasterization: Bool32::default(),
            degenerate_triangles_rasterized: Bool32::default(),
            degenerate_lines_rasterized: Bool32::default(),
            fully_covered_fragment_shader_input_variable: Bool32::default(),
            conservative_rasterization_post_depth_coverage: Bool32::default(),
        }
    }
}
impl PhysicalDeviceConservativeRasterizationPropertiesEXT {
    pub fn builder<'a>() -> PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'a> {
        PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder {
            inner: PhysicalDeviceConservativeRasterizationPropertiesEXT::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'a> {
    inner: PhysicalDeviceConservativeRasterizationPropertiesEXT,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsPhysicalDeviceProperties2
    for PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'_>
{
}
unsafe impl ExtendsPhysicalDeviceProperties2
    for PhysicalDeviceConservativeRasterizationPropertiesEXT
{
}
impl<'a> ::std::ops::Deref for PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'a> {
    type Target = PhysicalDeviceConservativeRasterizationPropertiesEXT;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'a> {
    pub fn primitive_overestimation_size(
        mut self,
        primitive_overestimation_size: f32,
    ) -> PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'a> {
        self.inner.primitive_overestimation_size = primitive_overestimation_size;
        self
    }
    pub fn max_extra_primitive_overestimation_size(
        mut self,
        max_extra_primitive_overestimation_size: f32,
    ) -> PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'a> {
        self.inner.max_extra_primitive_overestimation_size =
            max_extra_primitive_overestimation_size;
        self
    }
    pub fn extra_primitive_overestimation_size_granularity(
        mut self,
        extra_primitive_overestimation_size_granularity: f32,
    ) -> PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'a> {
        self.inner.extra_primitive_overestimation_size_granularity =
            extra_primitive_overestimation_size_granularity;
        self
    }
    pub fn primitive_underestimation(
        mut self,
        primitive_underestimation: bool,
    ) -> PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'a> {
        self.inner.primitive_underestimation = primitive_underestimation.into();
        self
    }
    pub fn conservative_point_and_line_rasterization(
        mut self,
        conservative_point_and_line_rasterization: bool,
    ) -> PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'a> {
        self.inner.conservative_point_and_line_rasterization =
            conservative_point_and_line_rasterization.into();
        self
    }
    pub fn degenerate_triangles_rasterized(
        mut self,
        degenerate_triangles_rasterized: bool,
    ) -> PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'a> {
        self.inner.degenerate_triangles_rasterized = degenerate_triangles_rasterized.into();
        self
    }
    pub fn degenerate_lines_rasterized(
        mut self,
        degenerate_lines_rasterized: bool,
    ) -> PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'a> {
        self.inner.degenerate_lines_rasterized = degenerate_lines_rasterized.into();
        self
    }
    pub fn fully_covered_fragment_shader_input_variable(
        mut self,
        fully_covered_fragment_shader_input_variable: bool,
    ) -> PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'a> {
        self.inner.fully_covered_fragment_shader_input_variable =
            fully_covered_fragment_shader_input_variable.into();
        self
    }
    pub fn conservative_rasterization_post_depth_coverage(
        mut self,
        conservative_rasterization_post_depth_coverage: bool,
    ) -> PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'a> {
        self.inner.conservative_rasterization_post_depth_coverage =
            conservative_rasterization_post_depth_coverage.into();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDeviceConservativeRasterizationPropertiesEXT {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCalibratedTimestampInfoEXT.html>"]
pub struct CalibratedTimestampInfoEXT {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub time_domain: TimeDomainEXT,
}
impl ::std::default::Default for CalibratedTimestampInfoEXT {
    fn default() -> CalibratedTimestampInfoEXT {
        CalibratedTimestampInfoEXT {
            s_type: StructureType::CALIBRATED_TIMESTAMP_INFO_EXT,
            p_next: ::std::ptr::null(),
            time_domain: TimeDomainEXT::default(),
        }
    }
}
impl CalibratedTimestampInfoEXT {
    pub fn builder<'a>() -> CalibratedTimestampInfoEXTBuilder<'a> {
        CalibratedTimestampInfoEXTBuilder {
            inner: CalibratedTimestampInfoEXT::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct CalibratedTimestampInfoEXTBuilder<'a> {
    inner: CalibratedTimestampInfoEXT,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsCalibratedTimestampInfoEXT {}
impl<'a> ::std::ops::Deref for CalibratedTimestampInfoEXTBuilder<'a> {
    type Target = CalibratedTimestampInfoEXT;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for CalibratedTimestampInfoEXTBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> CalibratedTimestampInfoEXTBuilder<'a> {
    pub fn time_domain(
        mut self,
        time_domain: TimeDomainEXT,
    ) -> CalibratedTimestampInfoEXTBuilder<'a> {
        self.inner.time_domain = time_domain;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsCalibratedTimestampInfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> CalibratedTimestampInfoEXTBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> CalibratedTimestampInfoEXT {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceShaderCorePropertiesAMD.html>"]
pub struct PhysicalDeviceShaderCorePropertiesAMD {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub shader_engine_count: u32,
    pub shader_arrays_per_engine_count: u32,
    pub compute_units_per_shader_array: u32,
    pub simd_per_compute_unit: u32,
    pub wavefronts_per_simd: u32,
    pub wavefront_size: u32,
    pub sgprs_per_simd: u32,
    pub min_sgpr_allocation: u32,
    pub max_sgpr_allocation: u32,
    pub sgpr_allocation_granularity: u32,
    pub vgprs_per_simd: u32,
    pub min_vgpr_allocation: u32,
    pub max_vgpr_allocation: u32,
    pub vgpr_allocation_granularity: u32,
}
impl ::std::default::Default for PhysicalDeviceShaderCorePropertiesAMD {
    fn default() -> PhysicalDeviceShaderCorePropertiesAMD {
        PhysicalDeviceShaderCorePropertiesAMD {
            s_type: StructureType::PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD,
            p_next: ::std::ptr::null_mut(),
            shader_engine_count: u32::default(),
            shader_arrays_per_engine_count: u32::default(),
            compute_units_per_shader_array: u32::default(),
            simd_per_compute_unit: u32::default(),
            wavefronts_per_simd: u32::default(),
            wavefront_size: u32::default(),
            sgprs_per_simd: u32::default(),
            min_sgpr_allocation: u32::default(),
            max_sgpr_allocation: u32::default(),
            sgpr_allocation_granularity: u32::default(),
            vgprs_per_simd: u32::default(),
            min_vgpr_allocation: u32::default(),
            max_vgpr_allocation: u32::default(),
            vgpr_allocation_granularity: u32::default(),
        }
    }
}
impl PhysicalDeviceShaderCorePropertiesAMD {
    pub fn builder<'a>() -> PhysicalDeviceShaderCorePropertiesAMDBuilder<'a> {
        PhysicalDeviceShaderCorePropertiesAMDBuilder {
            inner: PhysicalDeviceShaderCorePropertiesAMD::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDeviceShaderCorePropertiesAMDBuilder<'a> {
    inner: PhysicalDeviceShaderCorePropertiesAMD,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceShaderCorePropertiesAMDBuilder<'_> {}
unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceShaderCorePropertiesAMD {}
impl<'a> ::std::ops::Deref for PhysicalDeviceShaderCorePropertiesAMDBuilder<'a> {
    type Target = PhysicalDeviceShaderCorePropertiesAMD;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderCorePropertiesAMDBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDeviceShaderCorePropertiesAMDBuilder<'a> {
    pub fn shader_engine_count(
        mut self,
        shader_engine_count: u32,
    ) -> PhysicalDeviceShaderCorePropertiesAMDBuilder<'a> {
        self.inner.shader_engine_count = shader_engine_count;
        self
    }
    pub fn shader_arrays_per_engine_count(
        mut self,
        shader_arrays_per_engine_count: u32,
    ) -> PhysicalDeviceShaderCorePropertiesAMDBuilder<'a> {
        self.inner.shader_arrays_per_engine_count = shader_arrays_per_engine_count;
        self
    }
    pub fn compute_units_per_shader_array(
        mut self,
        compute_units_per_shader_array: u32,
    ) -> PhysicalDeviceShaderCorePropertiesAMDBuilder<'a> {
        self.inner.compute_units_per_shader_array = compute_units_per_shader_array;
        self
    }
    pub fn simd_per_compute_unit(
        mut self,
        simd_per_compute_unit: u32,
    ) -> PhysicalDeviceShaderCorePropertiesAMDBuilder<'a> {
        self.inner.simd_per_compute_unit = simd_per_compute_unit;
        self
    }
    pub fn wavefronts_per_simd(
        mut self,
        wavefronts_per_simd: u32,
    ) -> PhysicalDeviceShaderCorePropertiesAMDBuilder<'a> {
        self.inner.wavefronts_per_simd = wavefronts_per_simd;
        self
    }
    pub fn wavefront_size(
        mut self,
        wavefront_size: u32,
    ) -> PhysicalDeviceShaderCorePropertiesAMDBuilder<'a> {
        self.inner.wavefront_size = wavefront_size;
        self
    }
    pub fn sgprs_per_simd(
        mut self,
        sgprs_per_simd: u32,
    ) -> PhysicalDeviceShaderCorePropertiesAMDBuilder<'a> {
        self.inner.sgprs_per_simd = sgprs_per_simd;
        self
    }
    pub fn min_sgpr_allocation(
        mut self,
        min_sgpr_allocation: u32,
    ) -> PhysicalDeviceShaderCorePropertiesAMDBuilder<'a> {
        self.inner.min_sgpr_allocation = min_sgpr_allocation;
        self
    }
    pub fn max_sgpr_allocation(
        mut self,
        max_sgpr_allocation: u32,
    ) -> PhysicalDeviceShaderCorePropertiesAMDBuilder<'a> {
        self.inner.max_sgpr_allocation = max_sgpr_allocation;
        self
    }
    pub fn sgpr_allocation_granularity(
        mut self,
        sgpr_allocation_granularity: u32,
    ) -> PhysicalDeviceShaderCorePropertiesAMDBuilder<'a> {
        self.inner.sgpr_allocation_granularity = sgpr_allocation_granularity;
        self
    }
    pub fn vgprs_per_simd(
        mut self,
        vgprs_per_simd: u32,
    ) -> PhysicalDeviceShaderCorePropertiesAMDBuilder<'a> {
        self.inner.vgprs_per_simd = vgprs_per_simd;
        self
    }
    pub fn min_vgpr_allocation(
        mut self,
        min_vgpr_allocation: u32,
    ) -> PhysicalDeviceShaderCorePropertiesAMDBuilder<'a> {
        self.inner.min_vgpr_allocation = min_vgpr_allocation;
        self
    }
    pub fn max_vgpr_allocation(
        mut self,
        max_vgpr_allocation: u32,
    ) -> PhysicalDeviceShaderCorePropertiesAMDBuilder<'a> {
        self.inner.max_vgpr_allocation = max_vgpr_allocation;
        self
    }
    pub fn vgpr_allocation_granularity(
        mut self,
        vgpr_allocation_granularity: u32,
    ) -> PhysicalDeviceShaderCorePropertiesAMDBuilder<'a> {
        self.inner.vgpr_allocation_granularity = vgpr_allocation_granularity;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDeviceShaderCorePropertiesAMD {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceShaderCoreProperties2AMD.html>"]
pub struct PhysicalDeviceShaderCoreProperties2AMD {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub shader_core_features: ShaderCorePropertiesFlagsAMD,
    pub active_compute_unit_count: u32,
}
impl ::std::default::Default for PhysicalDeviceShaderCoreProperties2AMD {
    fn default() -> PhysicalDeviceShaderCoreProperties2AMD {
        PhysicalDeviceShaderCoreProperties2AMD {
            s_type: StructureType::PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD,
            p_next: ::std::ptr::null_mut(),
            shader_core_features: ShaderCorePropertiesFlagsAMD::default(),
            active_compute_unit_count: u32::default(),
        }
    }
}
impl PhysicalDeviceShaderCoreProperties2AMD {
    pub fn builder<'a>() -> PhysicalDeviceShaderCoreProperties2AMDBuilder<'a> {
        PhysicalDeviceShaderCoreProperties2AMDBuilder {
            inner: PhysicalDeviceShaderCoreProperties2AMD::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDeviceShaderCoreProperties2AMDBuilder<'a> {
    inner: PhysicalDeviceShaderCoreProperties2AMD,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceShaderCoreProperties2AMDBuilder<'_> {}
unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceShaderCoreProperties2AMD {}
impl<'a> ::std::ops::Deref for PhysicalDeviceShaderCoreProperties2AMDBuilder<'a> {
    type Target = PhysicalDeviceShaderCoreProperties2AMD;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderCoreProperties2AMDBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDeviceShaderCoreProperties2AMDBuilder<'a> {
    pub fn shader_core_features(
        mut self,
        shader_core_features: ShaderCorePropertiesFlagsAMD,
    ) -> PhysicalDeviceShaderCoreProperties2AMDBuilder<'a> {
        self.inner.shader_core_features = shader_core_features;
        self
    }
    pub fn active_compute_unit_count(
        mut self,
        active_compute_unit_count: u32,
    ) -> PhysicalDeviceShaderCoreProperties2AMDBuilder<'a> {
        self.inner.active_compute_unit_count = active_compute_unit_count;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDeviceShaderCoreProperties2AMD {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineRasterizationConservativeStateCreateInfoEXT.html>"]
pub struct PipelineRasterizationConservativeStateCreateInfoEXT {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub flags: PipelineRasterizationConservativeStateCreateFlagsEXT,
    pub conservative_rasterization_mode: ConservativeRasterizationModeEXT,
    pub extra_primitive_overestimation_size: f32,
}
impl ::std::default::Default for PipelineRasterizationConservativeStateCreateInfoEXT {
    fn default() -> PipelineRasterizationConservativeStateCreateInfoEXT {
        PipelineRasterizationConservativeStateCreateInfoEXT {
            s_type: StructureType::PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT,
            p_next: ::std::ptr::null(),
            flags: PipelineRasterizationConservativeStateCreateFlagsEXT::default(),
            conservative_rasterization_mode: ConservativeRasterizationModeEXT::default(),
            extra_primitive_overestimation_size: f32::default(),
        }
    }
}
impl PipelineRasterizationConservativeStateCreateInfoEXT {
    pub fn builder<'a>() -> PipelineRasterizationConservativeStateCreateInfoEXTBuilder<'a> {
        PipelineRasterizationConservativeStateCreateInfoEXTBuilder {
            inner: PipelineRasterizationConservativeStateCreateInfoEXT::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PipelineRasterizationConservativeStateCreateInfoEXTBuilder<'a> {
    inner: PipelineRasterizationConservativeStateCreateInfoEXT,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsPipelineRasterizationStateCreateInfo
    for PipelineRasterizationConservativeStateCreateInfoEXTBuilder<'_>
{
}
unsafe impl ExtendsPipelineRasterizationStateCreateInfo
    for PipelineRasterizationConservativeStateCreateInfoEXT
{
}
impl<'a> ::std::ops::Deref for PipelineRasterizationConservativeStateCreateInfoEXTBuilder<'a> {
    type Target = PipelineRasterizationConservativeStateCreateInfoEXT;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PipelineRasterizationConservativeStateCreateInfoEXTBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PipelineRasterizationConservativeStateCreateInfoEXTBuilder<'a> {
    pub fn flags(
        mut self,
        flags: PipelineRasterizationConservativeStateCreateFlagsEXT,
    ) -> PipelineRasterizationConservativeStateCreateInfoEXTBuilder<'a> {
        self.inner.flags = flags;
        self
    }
    pub fn conservative_rasterization_mode(
        mut self,
        conservative_rasterization_mode: ConservativeRasterizationModeEXT,
    ) -> PipelineRasterizationConservativeStateCreateInfoEXTBuilder<'a> {
        self.inner.conservative_rasterization_mode = conservative_rasterization_mode;
        self
    }
    pub fn extra_primitive_overestimation_size(
        mut self,
        extra_primitive_overestimation_size: f32,
    ) -> PipelineRasterizationConservativeStateCreateInfoEXTBuilder<'a> {
        self.inner.extra_primitive_overestimation_size = extra_primitive_overestimation_size;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PipelineRasterizationConservativeStateCreateInfoEXT {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceDescriptorIndexingFeatures.html>"]
pub struct PhysicalDeviceDescriptorIndexingFeatures {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub shader_input_attachment_array_dynamic_indexing: Bool32,
    pub shader_uniform_texel_buffer_array_dynamic_indexing: Bool32,
    pub shader_storage_texel_buffer_array_dynamic_indexing: Bool32,
    pub shader_uniform_buffer_array_non_uniform_indexing: Bool32,
    pub shader_sampled_image_array_non_uniform_indexing: Bool32,
    pub shader_storage_buffer_array_non_uniform_indexing: Bool32,
    pub shader_storage_image_array_non_uniform_indexing: Bool32,
    pub shader_input_attachment_array_non_uniform_indexing: Bool32,
    pub shader_uniform_texel_buffer_array_non_uniform_indexing: Bool32,
    pub shader_storage_texel_buffer_array_non_uniform_indexing: Bool32,
    pub descriptor_binding_uniform_buffer_update_after_bind: Bool32,
    pub descriptor_binding_sampled_image_update_after_bind: Bool32,
    pub descriptor_binding_storage_image_update_after_bind: Bool32,
    pub descriptor_binding_storage_buffer_update_after_bind: Bool32,
    pub descriptor_binding_uniform_texel_buffer_update_after_bind: Bool32,
    pub descriptor_binding_storage_texel_buffer_update_after_bind: Bool32,
    pub descriptor_binding_update_unused_while_pending: Bool32,
    pub descriptor_binding_partially_bound: Bool32,
    pub descriptor_binding_variable_descriptor_count: Bool32,
    pub runtime_descriptor_array: Bool32,
}
impl ::std::default::Default for PhysicalDeviceDescriptorIndexingFeatures {
    fn default() -> PhysicalDeviceDescriptorIndexingFeatures {
        PhysicalDeviceDescriptorIndexingFeatures {
            s_type: StructureType::PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES,
            p_next: ::std::ptr::null_mut(),
            shader_input_attachment_array_dynamic_indexing: Bool32::default(),
            shader_uniform_texel_buffer_array_dynamic_indexing: Bool32::default(),
            shader_storage_texel_buffer_array_dynamic_indexing: Bool32::default(),
            shader_uniform_buffer_array_non_uniform_indexing: Bool32::default(),
            shader_sampled_image_array_non_uniform_indexing: Bool32::default(),
            shader_storage_buffer_array_non_uniform_indexing: Bool32::default(),
            shader_storage_image_array_non_uniform_indexing: Bool32::default(),
            shader_input_attachment_array_non_uniform_indexing: Bool32::default(),
            shader_uniform_texel_buffer_array_non_uniform_indexing: Bool32::default(),
            shader_storage_texel_buffer_array_non_uniform_indexing: Bool32::default(),
            descriptor_binding_uniform_buffer_update_after_bind: Bool32::default(),
            descriptor_binding_sampled_image_update_after_bind: Bool32::default(),
            descriptor_binding_storage_image_update_after_bind: Bool32::default(),
            descriptor_binding_storage_buffer_update_after_bind: Bool32::default(),
            descriptor_binding_uniform_texel_buffer_update_after_bind: Bool32::default(),
            descriptor_binding_storage_texel_buffer_update_after_bind: Bool32::default(),
            descriptor_binding_update_unused_while_pending: Bool32::default(),
            descriptor_binding_partially_bound: Bool32::default(),
            descriptor_binding_variable_descriptor_count: Bool32::default(),
            runtime_descriptor_array: Bool32::default(),
        }
    }
}
impl PhysicalDeviceDescriptorIndexingFeatures {
    pub fn builder<'a>() -> PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a> {
        PhysicalDeviceDescriptorIndexingFeaturesBuilder {
            inner: PhysicalDeviceDescriptorIndexingFeatures::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a> {
    inner: PhysicalDeviceDescriptorIndexingFeatures,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDescriptorIndexingFeaturesBuilder<'_> {}
unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDescriptorIndexingFeatures {}
impl<'a> ::std::ops::Deref for PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a> {
    type Target = PhysicalDeviceDescriptorIndexingFeatures;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a> {
    pub fn shader_input_attachment_array_dynamic_indexing(
        mut self,
        shader_input_attachment_array_dynamic_indexing: bool,
    ) -> PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a> {
        self.inner.shader_input_attachment_array_dynamic_indexing =
            shader_input_attachment_array_dynamic_indexing.into();
        self
    }
    pub fn shader_uniform_texel_buffer_array_dynamic_indexing(
        mut self,
        shader_uniform_texel_buffer_array_dynamic_indexing: bool,
    ) -> PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a> {
        self.inner
            .shader_uniform_texel_buffer_array_dynamic_indexing =
            shader_uniform_texel_buffer_array_dynamic_indexing.into();
        self
    }
    pub fn shader_storage_texel_buffer_array_dynamic_indexing(
        mut self,
        shader_storage_texel_buffer_array_dynamic_indexing: bool,
    ) -> PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a> {
        self.inner
            .shader_storage_texel_buffer_array_dynamic_indexing =
            shader_storage_texel_buffer_array_dynamic_indexing.into();
        self
    }
    pub fn shader_uniform_buffer_array_non_uniform_indexing(
        mut self,
        shader_uniform_buffer_array_non_uniform_indexing: bool,
    ) -> PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a> {
        self.inner.shader_uniform_buffer_array_non_uniform_indexing =
            shader_uniform_buffer_array_non_uniform_indexing.into();
        self
    }
    pub fn shader_sampled_image_array_non_uniform_indexing(
        mut self,
        shader_sampled_image_array_non_uniform_indexing: bool,
    ) -> PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a> {
        self.inner.shader_sampled_image_array_non_uniform_indexing =
            shader_sampled_image_array_non_uniform_indexing.into();
        self
    }
    pub fn shader_storage_buffer_array_non_uniform_indexing(
        mut self,
        shader_storage_buffer_array_non_uniform_indexing: bool,
    ) -> PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a> {
        self.inner.shader_storage_buffer_array_non_uniform_indexing =
            shader_storage_buffer_array_non_uniform_indexing.into();
        self
    }
    pub fn shader_storage_image_array_non_uniform_indexing(
        mut self,
        shader_storage_image_array_non_uniform_indexing: bool,
    ) -> PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a> {
        self.inner.shader_storage_image_array_non_uniform_indexing =
            shader_storage_image_array_non_uniform_indexing.into();
        self
    }
    pub fn shader_input_attachment_array_non_uniform_indexing(
        mut self,
        shader_input_attachment_array_non_uniform_indexing: bool,
    ) -> PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a> {
        self.inner
            .shader_input_attachment_array_non_uniform_indexing =
            shader_input_attachment_array_non_uniform_indexing.into();
        self
    }
    pub fn shader_uniform_texel_buffer_array_non_uniform_indexing(
        mut self,
        shader_uniform_texel_buffer_array_non_uniform_indexing: bool,
    ) -> PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a> {
        self.inner
            .shader_uniform_texel_buffer_array_non_uniform_indexing =
            shader_uniform_texel_buffer_array_non_uniform_indexing.into();
        self
    }
    pub fn shader_storage_texel_buffer_array_non_uniform_indexing(
        mut self,
        shader_storage_texel_buffer_array_non_uniform_indexing: bool,
    ) -> PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a> {
        self.inner
            .shader_storage_texel_buffer_array_non_uniform_indexing =
            shader_storage_texel_buffer_array_non_uniform_indexing.into();
        self
    }
    pub fn descriptor_binding_uniform_buffer_update_after_bind(
        mut self,
        descriptor_binding_uniform_buffer_update_after_bind: bool,
    ) -> PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a> {
        self.inner
            .descriptor_binding_uniform_buffer_update_after_bind =
            descriptor_binding_uniform_buffer_update_after_bind.into();
        self
    }
    pub fn descriptor_binding_sampled_image_update_after_bind(
        mut self,
        descriptor_binding_sampled_image_update_after_bind: bool,
    ) -> PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a> {
        self.inner
            .descriptor_binding_sampled_image_update_after_bind =
            descriptor_binding_sampled_image_update_after_bind.into();
        self
    }
    pub fn descriptor_binding_storage_image_update_after_bind(
        mut self,
        descriptor_binding_storage_image_update_after_bind: bool,
    ) -> PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a> {
        self.inner
            .descriptor_binding_storage_image_update_after_bind =
            descriptor_binding_storage_image_update_after_bind.into();
        self
    }
    pub fn descriptor_binding_storage_buffer_update_after_bind(
        mut self,
        descriptor_binding_storage_buffer_update_after_bind: bool,
    ) -> PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a> {
        self.inner
            .descriptor_binding_storage_buffer_update_after_bind =
            descriptor_binding_storage_buffer_update_after_bind.into();
        self
    }
    pub fn descriptor_binding_uniform_texel_buffer_update_after_bind(
        mut self,
        descriptor_binding_uniform_texel_buffer_update_after_bind: bool,
    ) -> PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a> {
        self.inner
            .descriptor_binding_uniform_texel_buffer_update_after_bind =
            descriptor_binding_uniform_texel_buffer_update_after_bind.into();
        self
    }
    pub fn descriptor_binding_storage_texel_buffer_update_after_bind(
        mut self,
        descriptor_binding_storage_texel_buffer_update_after_bind: bool,
    ) -> PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a> {
        self.inner
            .descriptor_binding_storage_texel_buffer_update_after_bind =
            descriptor_binding_storage_texel_buffer_update_after_bind.into();
        self
    }
    pub fn descriptor_binding_update_unused_while_pending(
        mut self,
        descriptor_binding_update_unused_while_pending: bool,
    ) -> PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a> {
        self.inner.descriptor_binding_update_unused_while_pending =
            descriptor_binding_update_unused_while_pending.into();
        self
    }
    pub fn descriptor_binding_partially_bound(
        mut self,
        descriptor_binding_partially_bound: bool,
    ) -> PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a> {
        self.inner.descriptor_binding_partially_bound = descriptor_binding_partially_bound.into();
        self
    }
    pub fn descriptor_binding_variable_descriptor_count(
        mut self,
        descriptor_binding_variable_descriptor_count: bool,
    ) -> PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a> {
        self.inner.descriptor_binding_variable_descriptor_count =
            descriptor_binding_variable_descriptor_count.into();
        self
    }
    pub fn runtime_descriptor_array(
        mut self,
        runtime_descriptor_array: bool,
    ) -> PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a> {
        self.inner.runtime_descriptor_array = runtime_descriptor_array.into();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDeviceDescriptorIndexingFeatures {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceDescriptorIndexingProperties.html>"]
pub struct PhysicalDeviceDescriptorIndexingProperties {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub max_update_after_bind_descriptors_in_all_pools: u32,
    pub shader_uniform_buffer_array_non_uniform_indexing_native: Bool32,
    pub shader_sampled_image_array_non_uniform_indexing_native: Bool32,
    pub shader_storage_buffer_array_non_uniform_indexing_native: Bool32,
    pub shader_storage_image_array_non_uniform_indexing_native: Bool32,
    pub shader_input_attachment_array_non_uniform_indexing_native: Bool32,
    pub robust_buffer_access_update_after_bind: Bool32,
    pub quad_divergent_implicit_lod: Bool32,
    pub max_per_stage_descriptor_update_after_bind_samplers: u32,
    pub max_per_stage_descriptor_update_after_bind_uniform_buffers: u32,
    pub max_per_stage_descriptor_update_after_bind_storage_buffers: u32,
    pub max_per_stage_descriptor_update_after_bind_sampled_images: u32,
    pub max_per_stage_descriptor_update_after_bind_storage_images: u32,
    pub max_per_stage_descriptor_update_after_bind_input_attachments: u32,
    pub max_per_stage_update_after_bind_resources: u32,
    pub max_descriptor_set_update_after_bind_samplers: u32,
    pub max_descriptor_set_update_after_bind_uniform_buffers: u32,
    pub max_descriptor_set_update_after_bind_uniform_buffers_dynamic: u32,
    pub max_descriptor_set_update_after_bind_storage_buffers: u32,
    pub max_descriptor_set_update_after_bind_storage_buffers_dynamic: u32,
    pub max_descriptor_set_update_after_bind_sampled_images: u32,
    pub max_descriptor_set_update_after_bind_storage_images: u32,
    pub max_descriptor_set_update_after_bind_input_attachments: u32,
}
impl ::std::default::Default for PhysicalDeviceDescriptorIndexingProperties {
    fn default() -> PhysicalDeviceDescriptorIndexingProperties {
        PhysicalDeviceDescriptorIndexingProperties {
            s_type: StructureType::PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES,
            p_next: ::std::ptr::null_mut(),
            max_update_after_bind_descriptors_in_all_pools: u32::default(),
            shader_uniform_buffer_array_non_uniform_indexing_native: Bool32::default(),
            shader_sampled_image_array_non_uniform_indexing_native: Bool32::default(),
            shader_storage_buffer_array_non_uniform_indexing_native: Bool32::default(),
            shader_storage_image_array_non_uniform_indexing_native: Bool32::default(),
            shader_input_attachment_array_non_uniform_indexing_native: Bool32::default(),
            robust_buffer_access_update_after_bind: Bool32::default(),
            quad_divergent_implicit_lod: Bool32::default(),
            max_per_stage_descriptor_update_after_bind_samplers: u32::default(),
            max_per_stage_descriptor_update_after_bind_uniform_buffers: u32::default(),
            max_per_stage_descriptor_update_after_bind_storage_buffers: u32::default(),
            max_per_stage_descriptor_update_after_bind_sampled_images: u32::default(),
            max_per_stage_descriptor_update_after_bind_storage_images: u32::default(),
            max_per_stage_descriptor_update_after_bind_input_attachments: u32::default(),
            max_per_stage_update_after_bind_resources: u32::default(),
            max_descriptor_set_update_after_bind_samplers: u32::default(),
            max_descriptor_set_update_after_bind_uniform_buffers: u32::default(),
            max_descriptor_set_update_after_bind_uniform_buffers_dynamic: u32::default(),
            max_descriptor_set_update_after_bind_storage_buffers: u32::default(),
            max_descriptor_set_update_after_bind_storage_buffers_dynamic: u32::default(),
            max_descriptor_set_update_after_bind_sampled_images: u32::default(),
            max_descriptor_set_update_after_bind_storage_images: u32::default(),
            max_descriptor_set_update_after_bind_input_attachments: u32::default(),
        }
    }
}
impl PhysicalDeviceDescriptorIndexingProperties {
    pub fn builder<'a>() -> PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a> {
        PhysicalDeviceDescriptorIndexingPropertiesBuilder {
            inner: PhysicalDeviceDescriptorIndexingProperties::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a> {
    inner: PhysicalDeviceDescriptorIndexingProperties,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsPhysicalDeviceProperties2
    for PhysicalDeviceDescriptorIndexingPropertiesBuilder<'_>
{
}
unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceDescriptorIndexingProperties {}
impl<'a> ::std::ops::Deref for PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a> {
    type Target = PhysicalDeviceDescriptorIndexingProperties;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a> {
    pub fn max_update_after_bind_descriptors_in_all_pools(
        mut self,
        max_update_after_bind_descriptors_in_all_pools: u32,
    ) -> PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a> {
        self.inner.max_update_after_bind_descriptors_in_all_pools =
            max_update_after_bind_descriptors_in_all_pools;
        self
    }
    pub fn shader_uniform_buffer_array_non_uniform_indexing_native(
        mut self,
        shader_uniform_buffer_array_non_uniform_indexing_native: bool,
    ) -> PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a> {
        self.inner
            .shader_uniform_buffer_array_non_uniform_indexing_native =
            shader_uniform_buffer_array_non_uniform_indexing_native.into();
        self
    }
    pub fn shader_sampled_image_array_non_uniform_indexing_native(
        mut self,
        shader_sampled_image_array_non_uniform_indexing_native: bool,
    ) -> PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a> {
        self.inner
            .shader_sampled_image_array_non_uniform_indexing_native =
            shader_sampled_image_array_non_uniform_indexing_native.into();
        self
    }
    pub fn shader_storage_buffer_array_non_uniform_indexing_native(
        mut self,
        shader_storage_buffer_array_non_uniform_indexing_native: bool,
    ) -> PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a> {
        self.inner
            .shader_storage_buffer_array_non_uniform_indexing_native =
            shader_storage_buffer_array_non_uniform_indexing_native.into();
        self
    }
    pub fn shader_storage_image_array_non_uniform_indexing_native(
        mut self,
        shader_storage_image_array_non_uniform_indexing_native: bool,
    ) -> PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a> {
        self.inner
            .shader_storage_image_array_non_uniform_indexing_native =
            shader_storage_image_array_non_uniform_indexing_native.into();
        self
    }
    pub fn shader_input_attachment_array_non_uniform_indexing_native(
        mut self,
        shader_input_attachment_array_non_uniform_indexing_native: bool,
    ) -> PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a> {
        self.inner
            .shader_input_attachment_array_non_uniform_indexing_native =
            shader_input_attachment_array_non_uniform_indexing_native.into();
        self
    }
    pub fn robust_buffer_access_update_after_bind(
        mut self,
        robust_buffer_access_update_after_bind: bool,
    ) -> PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a> {
        self.inner.robust_buffer_access_update_after_bind =
            robust_buffer_access_update_after_bind.into();
        self
    }
    pub fn quad_divergent_implicit_lod(
        mut self,
        quad_divergent_implicit_lod: bool,
    ) -> PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a> {
        self.inner.quad_divergent_implicit_lod = quad_divergent_implicit_lod.into();
        self
    }
    pub fn max_per_stage_descriptor_update_after_bind_samplers(
        mut self,
        max_per_stage_descriptor_update_after_bind_samplers: u32,
    ) -> PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a> {
        self.inner
            .max_per_stage_descriptor_update_after_bind_samplers =
            max_per_stage_descriptor_update_after_bind_samplers;
        self
    }
    pub fn max_per_stage_descriptor_update_after_bind_uniform_buffers(
        mut self,
        max_per_stage_descriptor_update_after_bind_uniform_buffers: u32,
    ) -> PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a> {
        self.inner
            .max_per_stage_descriptor_update_after_bind_uniform_buffers =
            max_per_stage_descriptor_update_after_bind_uniform_buffers;
        self
    }
    pub fn max_per_stage_descriptor_update_after_bind_storage_buffers(
        mut self,
        max_per_stage_descriptor_update_after_bind_storage_buffers: u32,
    ) -> PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a> {
        self.inner
            .max_per_stage_descriptor_update_after_bind_storage_buffers =
            max_per_stage_descriptor_update_after_bind_storage_buffers;
        self
    }
    pub fn max_per_stage_descriptor_update_after_bind_sampled_images(
        mut self,
        max_per_stage_descriptor_update_after_bind_sampled_images: u32,
    ) -> PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a> {
        self.inner
            .max_per_stage_descriptor_update_after_bind_sampled_images =
            max_per_stage_descriptor_update_after_bind_sampled_images;
        self
    }
    pub fn max_per_stage_descriptor_update_after_bind_storage_images(
        mut self,
        max_per_stage_descriptor_update_after_bind_storage_images: u32,
    ) -> PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a> {
        self.inner
            .max_per_stage_descriptor_update_after_bind_storage_images =
            max_per_stage_descriptor_update_after_bind_storage_images;
        self
    }
    pub fn max_per_stage_descriptor_update_after_bind_input_attachments(
        mut self,
        max_per_stage_descriptor_update_after_bind_input_attachments: u32,
    ) -> PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a> {
        self.inner
            .max_per_stage_descriptor_update_after_bind_input_attachments =
            max_per_stage_descriptor_update_after_bind_input_attachments;
        self
    }
    pub fn max_per_stage_update_after_bind_resources(
        mut self,
        max_per_stage_update_after_bind_resources: u32,
    ) -> PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a> {
        self.inner.max_per_stage_update_after_bind_resources =
            max_per_stage_update_after_bind_resources;
        self
    }
    pub fn max_descriptor_set_update_after_bind_samplers(
        mut self,
        max_descriptor_set_update_after_bind_samplers: u32,
    ) -> PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a> {
        self.inner.max_descriptor_set_update_after_bind_samplers =
            max_descriptor_set_update_after_bind_samplers;
        self
    }
    pub fn max_descriptor_set_update_after_bind_uniform_buffers(
        mut self,
        max_descriptor_set_update_after_bind_uniform_buffers: u32,
    ) -> PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a> {
        self.inner
            .max_descriptor_set_update_after_bind_uniform_buffers =
            max_descriptor_set_update_after_bind_uniform_buffers;
        self
    }
    pub fn max_descriptor_set_update_after_bind_uniform_buffers_dynamic(
        mut self,
        max_descriptor_set_update_after_bind_uniform_buffers_dynamic: u32,
    ) -> PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a> {
        self.inner
            .max_descriptor_set_update_after_bind_uniform_buffers_dynamic =
            max_descriptor_set_update_after_bind_uniform_buffers_dynamic;
        self
    }
    pub fn max_descriptor_set_update_after_bind_storage_buffers(
        mut self,
        max_descriptor_set_update_after_bind_storage_buffers: u32,
    ) -> PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a> {
        self.inner
            .max_descriptor_set_update_after_bind_storage_buffers =
            max_descriptor_set_update_after_bind_storage_buffers;
        self
    }
    pub fn max_descriptor_set_update_after_bind_storage_buffers_dynamic(
        mut self,
        max_descriptor_set_update_after_bind_storage_buffers_dynamic: u32,
    ) -> PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a> {
        self.inner
            .max_descriptor_set_update_after_bind_storage_buffers_dynamic =
            max_descriptor_set_update_after_bind_storage_buffers_dynamic;
        self
    }
    pub fn max_descriptor_set_update_after_bind_sampled_images(
        mut self,
        max_descriptor_set_update_after_bind_sampled_images: u32,
    ) -> PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a> {
        self.inner
            .max_descriptor_set_update_after_bind_sampled_images =
            max_descriptor_set_update_after_bind_sampled_images;
        self
    }
    pub fn max_descriptor_set_update_after_bind_storage_images(
        mut self,
        max_descriptor_set_update_after_bind_storage_images: u32,
    ) -> PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a> {
        self.inner
            .max_descriptor_set_update_after_bind_storage_images =
            max_descriptor_set_update_after_bind_storage_images;
        self
    }
    pub fn max_descriptor_set_update_after_bind_input_attachments(
        mut self,
        max_descriptor_set_update_after_bind_input_attachments: u32,
    ) -> PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a> {
        self.inner
            .max_descriptor_set_update_after_bind_input_attachments =
            max_descriptor_set_update_after_bind_input_attachments;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDeviceDescriptorIndexingProperties {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDescriptorSetLayoutBindingFlagsCreateInfo.html>"]
pub struct DescriptorSetLayoutBindingFlagsCreateInfo {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub binding_count: u32,
    pub p_binding_flags: *const DescriptorBindingFlags,
}
impl ::std::default::Default for DescriptorSetLayoutBindingFlagsCreateInfo {
    fn default() -> DescriptorSetLayoutBindingFlagsCreateInfo {
        DescriptorSetLayoutBindingFlagsCreateInfo {
            s_type: StructureType::DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO,
            p_next: ::std::ptr::null(),
            binding_count: u32::default(),
            p_binding_flags: ::std::ptr::null(),
        }
    }
}
impl DescriptorSetLayoutBindingFlagsCreateInfo {
    pub fn builder<'a>() -> DescriptorSetLayoutBindingFlagsCreateInfoBuilder<'a> {
        DescriptorSetLayoutBindingFlagsCreateInfoBuilder {
            inner: DescriptorSetLayoutBindingFlagsCreateInfo::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct DescriptorSetLayoutBindingFlagsCreateInfoBuilder<'a> {
    inner: DescriptorSetLayoutBindingFlagsCreateInfo,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsDescriptorSetLayoutCreateInfo
    for DescriptorSetLayoutBindingFlagsCreateInfoBuilder<'_>
{
}
unsafe impl ExtendsDescriptorSetLayoutCreateInfo for DescriptorSetLayoutBindingFlagsCreateInfo {}
impl<'a> ::std::ops::Deref for DescriptorSetLayoutBindingFlagsCreateInfoBuilder<'a> {
    type Target = DescriptorSetLayoutBindingFlagsCreateInfo;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for DescriptorSetLayoutBindingFlagsCreateInfoBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> DescriptorSetLayoutBindingFlagsCreateInfoBuilder<'a> {
    pub fn binding_flags(
        mut self,
        binding_flags: &'a [DescriptorBindingFlags],
    ) -> DescriptorSetLayoutBindingFlagsCreateInfoBuilder<'a> {
        self.inner.binding_count = binding_flags.len() as _;
        self.inner.p_binding_flags = binding_flags.as_ptr();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> DescriptorSetLayoutBindingFlagsCreateInfo {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDescriptorSetVariableDescriptorCountAllocateInfo.html>"]
pub struct DescriptorSetVariableDescriptorCountAllocateInfo {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub descriptor_set_count: u32,
    pub p_descriptor_counts: *const u32,
}
impl ::std::default::Default for DescriptorSetVariableDescriptorCountAllocateInfo {
    fn default() -> DescriptorSetVariableDescriptorCountAllocateInfo {
        DescriptorSetVariableDescriptorCountAllocateInfo {
            s_type: StructureType::DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO,
            p_next: ::std::ptr::null(),
            descriptor_set_count: u32::default(),
            p_descriptor_counts: ::std::ptr::null(),
        }
    }
}
impl DescriptorSetVariableDescriptorCountAllocateInfo {
    pub fn builder<'a>() -> DescriptorSetVariableDescriptorCountAllocateInfoBuilder<'a> {
        DescriptorSetVariableDescriptorCountAllocateInfoBuilder {
            inner: DescriptorSetVariableDescriptorCountAllocateInfo::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct DescriptorSetVariableDescriptorCountAllocateInfoBuilder<'a> {
    inner: DescriptorSetVariableDescriptorCountAllocateInfo,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsDescriptorSetAllocateInfo
    for DescriptorSetVariableDescriptorCountAllocateInfoBuilder<'_>
{
}
unsafe impl ExtendsDescriptorSetAllocateInfo for DescriptorSetVariableDescriptorCountAllocateInfo {}
impl<'a> ::std::ops::Deref for DescriptorSetVariableDescriptorCountAllocateInfoBuilder<'a> {
    type Target = DescriptorSetVariableDescriptorCountAllocateInfo;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for DescriptorSetVariableDescriptorCountAllocateInfoBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> DescriptorSetVariableDescriptorCountAllocateInfoBuilder<'a> {
    pub fn descriptor_counts(
        mut self,
        descriptor_counts: &'a [u32],
    ) -> DescriptorSetVariableDescriptorCountAllocateInfoBuilder<'a> {
        self.inner.descriptor_set_count = descriptor_counts.len() as _;
        self.inner.p_descriptor_counts = descriptor_counts.as_ptr();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> DescriptorSetVariableDescriptorCountAllocateInfo {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDescriptorSetVariableDescriptorCountLayoutSupport.html>"]
pub struct DescriptorSetVariableDescriptorCountLayoutSupport {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub max_variable_descriptor_count: u32,
}
impl ::std::default::Default for DescriptorSetVariableDescriptorCountLayoutSupport {
    fn default() -> DescriptorSetVariableDescriptorCountLayoutSupport {
        DescriptorSetVariableDescriptorCountLayoutSupport {
            s_type: StructureType::DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT,
            p_next: ::std::ptr::null_mut(),
            max_variable_descriptor_count: u32::default(),
        }
    }
}
impl DescriptorSetVariableDescriptorCountLayoutSupport {
    pub fn builder<'a>() -> DescriptorSetVariableDescriptorCountLayoutSupportBuilder<'a> {
        DescriptorSetVariableDescriptorCountLayoutSupportBuilder {
            inner: DescriptorSetVariableDescriptorCountLayoutSupport::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct DescriptorSetVariableDescriptorCountLayoutSupportBuilder<'a> {
    inner: DescriptorSetVariableDescriptorCountLayoutSupport,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsDescriptorSetLayoutSupport
    for DescriptorSetVariableDescriptorCountLayoutSupportBuilder<'_>
{
}
unsafe impl ExtendsDescriptorSetLayoutSupport
    for DescriptorSetVariableDescriptorCountLayoutSupport
{
}
impl<'a> ::std::ops::Deref for DescriptorSetVariableDescriptorCountLayoutSupportBuilder<'a> {
    type Target = DescriptorSetVariableDescriptorCountLayoutSupport;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for DescriptorSetVariableDescriptorCountLayoutSupportBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> DescriptorSetVariableDescriptorCountLayoutSupportBuilder<'a> {
    pub fn max_variable_descriptor_count(
        mut self,
        max_variable_descriptor_count: u32,
    ) -> DescriptorSetVariableDescriptorCountLayoutSupportBuilder<'a> {
        self.inner.max_variable_descriptor_count = max_variable_descriptor_count;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> DescriptorSetVariableDescriptorCountLayoutSupport {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAttachmentDescription2.html>"]
pub struct AttachmentDescription2 {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub flags: AttachmentDescriptionFlags,
    pub format: Format,
    pub samples: SampleCountFlags,
    pub load_op: AttachmentLoadOp,
    pub store_op: AttachmentStoreOp,
    pub stencil_load_op: AttachmentLoadOp,
    pub stencil_store_op: AttachmentStoreOp,
    pub initial_layout: ImageLayout,
    pub final_layout: ImageLayout,
}
impl ::std::default::Default for AttachmentDescription2 {
    fn default() -> AttachmentDescription2 {
        AttachmentDescription2 {
            s_type: StructureType::ATTACHMENT_DESCRIPTION_2,
            p_next: ::std::ptr::null(),
            flags: AttachmentDescriptionFlags::default(),
            format: Format::default(),
            samples: SampleCountFlags::default(),
            load_op: AttachmentLoadOp::default(),
            store_op: AttachmentStoreOp::default(),
            stencil_load_op: AttachmentLoadOp::default(),
            stencil_store_op: AttachmentStoreOp::default(),
            initial_layout: ImageLayout::default(),
            final_layout: ImageLayout::default(),
        }
    }
}
impl AttachmentDescription2 {
    pub fn builder<'a>() -> AttachmentDescription2Builder<'a> {
        AttachmentDescription2Builder {
            inner: AttachmentDescription2::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct AttachmentDescription2Builder<'a> {
    inner: AttachmentDescription2,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsAttachmentDescription2 {}
impl<'a> ::std::ops::Deref for AttachmentDescription2Builder<'a> {
    type Target = AttachmentDescription2;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for AttachmentDescription2Builder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> AttachmentDescription2Builder<'a> {
    pub fn flags(mut self, flags: AttachmentDescriptionFlags) -> AttachmentDescription2Builder<'a> {
        self.inner.flags = flags;
        self
    }
    pub fn format(mut self, format: Format) -> AttachmentDescription2Builder<'a> {
        self.inner.format = format;
        self
    }
    pub fn samples(mut self, samples: SampleCountFlags) -> AttachmentDescription2Builder<'a> {
        self.inner.samples = samples;
        self
    }
    pub fn load_op(mut self, load_op: AttachmentLoadOp) -> AttachmentDescription2Builder<'a> {
        self.inner.load_op = load_op;
        self
    }
    pub fn store_op(mut self, store_op: AttachmentStoreOp) -> AttachmentDescription2Builder<'a> {
        self.inner.store_op = store_op;
        self
    }
    pub fn stencil_load_op(
        mut self,
        stencil_load_op: AttachmentLoadOp,
    ) -> AttachmentDescription2Builder<'a> {
        self.inner.stencil_load_op = stencil_load_op;
        self
    }
    pub fn stencil_store_op(
        mut self,
        stencil_store_op: AttachmentStoreOp,
    ) -> AttachmentDescription2Builder<'a> {
        self.inner.stencil_store_op = stencil_store_op;
        self
    }
    pub fn initial_layout(
        mut self,
        initial_layout: ImageLayout,
    ) -> AttachmentDescription2Builder<'a> {
        self.inner.initial_layout = initial_layout;
        self
    }
    pub fn final_layout(mut self, final_layout: ImageLayout) -> AttachmentDescription2Builder<'a> {
        self.inner.final_layout = final_layout;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsAttachmentDescription2>(
        mut self,
        next: &'a mut T,
    ) -> AttachmentDescription2Builder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> AttachmentDescription2 {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAttachmentReference2.html>"]
pub struct AttachmentReference2 {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub attachment: u32,
    pub layout: ImageLayout,
    pub aspect_mask: ImageAspectFlags,
}
impl ::std::default::Default for AttachmentReference2 {
    fn default() -> AttachmentReference2 {
        AttachmentReference2 {
            s_type: StructureType::ATTACHMENT_REFERENCE_2,
            p_next: ::std::ptr::null(),
            attachment: u32::default(),
            layout: ImageLayout::default(),
            aspect_mask: ImageAspectFlags::default(),
        }
    }
}
impl AttachmentReference2 {
    pub fn builder<'a>() -> AttachmentReference2Builder<'a> {
        AttachmentReference2Builder {
            inner: AttachmentReference2::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct AttachmentReference2Builder<'a> {
    inner: AttachmentReference2,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsAttachmentReference2 {}
impl<'a> ::std::ops::Deref for AttachmentReference2Builder<'a> {
    type Target = AttachmentReference2;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for AttachmentReference2Builder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> AttachmentReference2Builder<'a> {
    pub fn attachment(mut self, attachment: u32) -> AttachmentReference2Builder<'a> {
        self.inner.attachment = attachment;
        self
    }
    pub fn layout(mut self, layout: ImageLayout) -> AttachmentReference2Builder<'a> {
        self.inner.layout = layout;
        self
    }
    pub fn aspect_mask(mut self, aspect_mask: ImageAspectFlags) -> AttachmentReference2Builder<'a> {
        self.inner.aspect_mask = aspect_mask;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsAttachmentReference2>(
        mut self,
        next: &'a mut T,
    ) -> AttachmentReference2Builder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> AttachmentReference2 {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSubpassDescription2.html>"]
pub struct SubpassDescription2 {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub flags: SubpassDescriptionFlags,
    pub pipeline_bind_point: PipelineBindPoint,
    pub view_mask: u32,
    pub input_attachment_count: u32,
    pub p_input_attachments: *const AttachmentReference2,
    pub color_attachment_count: u32,
    pub p_color_attachments: *const AttachmentReference2,
    pub p_resolve_attachments: *const AttachmentReference2,
    pub p_depth_stencil_attachment: *const AttachmentReference2,
    pub preserve_attachment_count: u32,
    pub p_preserve_attachments: *const u32,
}
impl ::std::default::Default for SubpassDescription2 {
    fn default() -> SubpassDescription2 {
        SubpassDescription2 {
            s_type: StructureType::SUBPASS_DESCRIPTION_2,
            p_next: ::std::ptr::null(),
            flags: SubpassDescriptionFlags::default(),
            pipeline_bind_point: PipelineBindPoint::default(),
            view_mask: u32::default(),
            input_attachment_count: u32::default(),
            p_input_attachments: ::std::ptr::null(),
            color_attachment_count: u32::default(),
            p_color_attachments: ::std::ptr::null(),
            p_resolve_attachments: ::std::ptr::null(),
            p_depth_stencil_attachment: ::std::ptr::null(),
            preserve_attachment_count: u32::default(),
            p_preserve_attachments: ::std::ptr::null(),
        }
    }
}
impl SubpassDescription2 {
    pub fn builder<'a>() -> SubpassDescription2Builder<'a> {
        SubpassDescription2Builder {
            inner: SubpassDescription2::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct SubpassDescription2Builder<'a> {
    inner: SubpassDescription2,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsSubpassDescription2 {}
impl<'a> ::std::ops::Deref for SubpassDescription2Builder<'a> {
    type Target = SubpassDescription2;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for SubpassDescription2Builder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> SubpassDescription2Builder<'a> {
    pub fn flags(mut self, flags: SubpassDescriptionFlags) -> SubpassDescription2Builder<'a> {
        self.inner.flags = flags;
        self
    }
    pub fn pipeline_bind_point(
        mut self,
        pipeline_bind_point: PipelineBindPoint,
    ) -> SubpassDescription2Builder<'a> {
        self.inner.pipeline_bind_point = pipeline_bind_point;
        self
    }
    pub fn view_mask(mut self, view_mask: u32) -> SubpassDescription2Builder<'a> {
        self.inner.view_mask = view_mask;
        self
    }
    pub fn input_attachments(
        mut self,
        input_attachments: &'a [AttachmentReference2],
    ) -> SubpassDescription2Builder<'a> {
        self.inner.input_attachment_count = input_attachments.len() as _;
        self.inner.p_input_attachments = input_attachments.as_ptr();
        self
    }
    pub fn color_attachments(
        mut self,
        color_attachments: &'a [AttachmentReference2],
    ) -> SubpassDescription2Builder<'a> {
        self.inner.color_attachment_count = color_attachments.len() as _;
        self.inner.p_color_attachments = color_attachments.as_ptr();
        self
    }
    pub fn resolve_attachments(
        mut self,
        resolve_attachments: &'a [AttachmentReference2],
    ) -> SubpassDescription2Builder<'a> {
        self.inner.color_attachment_count = resolve_attachments.len() as _;
        self.inner.p_resolve_attachments = resolve_attachments.as_ptr();
        self
    }
    pub fn depth_stencil_attachment(
        mut self,
        depth_stencil_attachment: &'a AttachmentReference2,
    ) -> SubpassDescription2Builder<'a> {
        self.inner.p_depth_stencil_attachment = depth_stencil_attachment;
        self
    }
    pub fn preserve_attachments(
        mut self,
        preserve_attachments: &'a [u32],
    ) -> SubpassDescription2Builder<'a> {
        self.inner.preserve_attachment_count = preserve_attachments.len() as _;
        self.inner.p_preserve_attachments = preserve_attachments.as_ptr();
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsSubpassDescription2>(
        mut self,
        next: &'a mut T,
    ) -> SubpassDescription2Builder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> SubpassDescription2 {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSubpassDependency2.html>"]
pub struct SubpassDependency2 {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub src_subpass: u32,
    pub dst_subpass: u32,
    pub src_stage_mask: PipelineStageFlags,
    pub dst_stage_mask: PipelineStageFlags,
    pub src_access_mask: AccessFlags,
    pub dst_access_mask: AccessFlags,
    pub dependency_flags: DependencyFlags,
    pub view_offset: i32,
}
impl ::std::default::Default for SubpassDependency2 {
    fn default() -> SubpassDependency2 {
        SubpassDependency2 {
            s_type: StructureType::SUBPASS_DEPENDENCY_2,
            p_next: ::std::ptr::null(),
            src_subpass: u32::default(),
            dst_subpass: u32::default(),
            src_stage_mask: PipelineStageFlags::default(),
            dst_stage_mask: PipelineStageFlags::default(),
            src_access_mask: AccessFlags::default(),
            dst_access_mask: AccessFlags::default(),
            dependency_flags: DependencyFlags::default(),
            view_offset: i32::default(),
        }
    }
}
impl SubpassDependency2 {
    pub fn builder<'a>() -> SubpassDependency2Builder<'a> {
        SubpassDependency2Builder {
            inner: SubpassDependency2::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct SubpassDependency2Builder<'a> {
    inner: SubpassDependency2,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsSubpassDependency2 {}
impl<'a> ::std::ops::Deref for SubpassDependency2Builder<'a> {
    type Target = SubpassDependency2;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for SubpassDependency2Builder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> SubpassDependency2Builder<'a> {
    pub fn src_subpass(mut self, src_subpass: u32) -> SubpassDependency2Builder<'a> {
        self.inner.src_subpass = src_subpass;
        self
    }
    pub fn dst_subpass(mut self, dst_subpass: u32) -> SubpassDependency2Builder<'a> {
        self.inner.dst_subpass = dst_subpass;
        self
    }
    pub fn src_stage_mask(
        mut self,
        src_stage_mask: PipelineStageFlags,
    ) -> SubpassDependency2Builder<'a> {
        self.inner.src_stage_mask = src_stage_mask;
        self
    }
    pub fn dst_stage_mask(
        mut self,
        dst_stage_mask: PipelineStageFlags,
    ) -> SubpassDependency2Builder<'a> {
        self.inner.dst_stage_mask = dst_stage_mask;
        self
    }
    pub fn src_access_mask(
        mut self,
        src_access_mask: AccessFlags,
    ) -> SubpassDependency2Builder<'a> {
        self.inner.src_access_mask = src_access_mask;
        self
    }
    pub fn dst_access_mask(
        mut self,
        dst_access_mask: AccessFlags,
    ) -> SubpassDependency2Builder<'a> {
        self.inner.dst_access_mask = dst_access_mask;
        self
    }
    pub fn dependency_flags(
        mut self,
        dependency_flags: DependencyFlags,
    ) -> SubpassDependency2Builder<'a> {
        self.inner.dependency_flags = dependency_flags;
        self
    }
    pub fn view_offset(mut self, view_offset: i32) -> SubpassDependency2Builder<'a> {
        self.inner.view_offset = view_offset;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsSubpassDependency2>(
        mut self,
        next: &'a mut T,
    ) -> SubpassDependency2Builder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> SubpassDependency2 {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkRenderPassCreateInfo2.html>"]
pub struct RenderPassCreateInfo2 {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub flags: RenderPassCreateFlags,
    pub attachment_count: u32,
    pub p_attachments: *const AttachmentDescription2,
    pub subpass_count: u32,
    pub p_subpasses: *const SubpassDescription2,
    pub dependency_count: u32,
    pub p_dependencies: *const SubpassDependency2,
    pub correlated_view_mask_count: u32,
    pub p_correlated_view_masks: *const u32,
}
impl ::std::default::Default for RenderPassCreateInfo2 {
    fn default() -> RenderPassCreateInfo2 {
        RenderPassCreateInfo2 {
            s_type: StructureType::RENDER_PASS_CREATE_INFO_2,
            p_next: ::std::ptr::null(),
            flags: RenderPassCreateFlags::default(),
            attachment_count: u32::default(),
            p_attachments: ::std::ptr::null(),
            subpass_count: u32::default(),
            p_subpasses: ::std::ptr::null(),
            dependency_count: u32::default(),
            p_dependencies: ::std::ptr::null(),
            correlated_view_mask_count: u32::default(),
            p_correlated_view_masks: ::std::ptr::null(),
        }
    }
}
impl RenderPassCreateInfo2 {
    pub fn builder<'a>() -> RenderPassCreateInfo2Builder<'a> {
        RenderPassCreateInfo2Builder {
            inner: RenderPassCreateInfo2::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct RenderPassCreateInfo2Builder<'a> {
    inner: RenderPassCreateInfo2,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsRenderPassCreateInfo2 {}
impl<'a> ::std::ops::Deref for RenderPassCreateInfo2Builder<'a> {
    type Target = RenderPassCreateInfo2;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for RenderPassCreateInfo2Builder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> RenderPassCreateInfo2Builder<'a> {
    pub fn flags(mut self, flags: RenderPassCreateFlags) -> RenderPassCreateInfo2Builder<'a> {
        self.inner.flags = flags;
        self
    }
    pub fn attachments(
        mut self,
        attachments: &'a [AttachmentDescription2],
    ) -> RenderPassCreateInfo2Builder<'a> {
        self.inner.attachment_count = attachments.len() as _;
        self.inner.p_attachments = attachments.as_ptr();
        self
    }
    pub fn subpasses(
        mut self,
        subpasses: &'a [SubpassDescription2],
    ) -> RenderPassCreateInfo2Builder<'a> {
        self.inner.subpass_count = subpasses.len() as _;
        self.inner.p_subpasses = subpasses.as_ptr();
        self
    }
    pub fn dependencies(
        mut self,
        dependencies: &'a [SubpassDependency2],
    ) -> RenderPassCreateInfo2Builder<'a> {
        self.inner.dependency_count = dependencies.len() as _;
        self.inner.p_dependencies = dependencies.as_ptr();
        self
    }
    pub fn correlated_view_masks(
        mut self,
        correlated_view_masks: &'a [u32],
    ) -> RenderPassCreateInfo2Builder<'a> {
        self.inner.correlated_view_mask_count = correlated_view_masks.len() as _;
        self.inner.p_correlated_view_masks = correlated_view_masks.as_ptr();
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsRenderPassCreateInfo2>(
        mut self,
        next: &'a mut T,
    ) -> RenderPassCreateInfo2Builder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> RenderPassCreateInfo2 {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSubpassBeginInfo.html>"]
pub struct SubpassBeginInfo {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub contents: SubpassContents,
}
impl ::std::default::Default for SubpassBeginInfo {
    fn default() -> SubpassBeginInfo {
        SubpassBeginInfo {
            s_type: StructureType::SUBPASS_BEGIN_INFO,
            p_next: ::std::ptr::null(),
            contents: SubpassContents::default(),
        }
    }
}
impl SubpassBeginInfo {
    pub fn builder<'a>() -> SubpassBeginInfoBuilder<'a> {
        SubpassBeginInfoBuilder {
            inner: SubpassBeginInfo::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct SubpassBeginInfoBuilder<'a> {
    inner: SubpassBeginInfo,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsSubpassBeginInfo {}
impl<'a> ::std::ops::Deref for SubpassBeginInfoBuilder<'a> {
    type Target = SubpassBeginInfo;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for SubpassBeginInfoBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> SubpassBeginInfoBuilder<'a> {
    pub fn contents(mut self, contents: SubpassContents) -> SubpassBeginInfoBuilder<'a> {
        self.inner.contents = contents;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsSubpassBeginInfo>(
        mut self,
        next: &'a mut T,
    ) -> SubpassBeginInfoBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> SubpassBeginInfo {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSubpassEndInfo.html>"]
pub struct SubpassEndInfo {
    pub s_type: StructureType,
    pub p_next: *const c_void,
}
impl ::std::default::Default for SubpassEndInfo {
    fn default() -> SubpassEndInfo {
        SubpassEndInfo {
            s_type: StructureType::SUBPASS_END_INFO,
            p_next: ::std::ptr::null(),
        }
    }
}
impl SubpassEndInfo {
    pub fn builder<'a>() -> SubpassEndInfoBuilder<'a> {
        SubpassEndInfoBuilder {
            inner: SubpassEndInfo::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct SubpassEndInfoBuilder<'a> {
    inner: SubpassEndInfo,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsSubpassEndInfo {}
impl<'a> ::std::ops::Deref for SubpassEndInfoBuilder<'a> {
    type Target = SubpassEndInfo;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for SubpassEndInfoBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> SubpassEndInfoBuilder<'a> {
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsSubpassEndInfo>(
        mut self,
        next: &'a mut T,
    ) -> SubpassEndInfoBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> SubpassEndInfo {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceTimelineSemaphoreFeatures.html>"]
pub struct PhysicalDeviceTimelineSemaphoreFeatures {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub timeline_semaphore: Bool32,
}
impl ::std::default::Default for PhysicalDeviceTimelineSemaphoreFeatures {
    fn default() -> PhysicalDeviceTimelineSemaphoreFeatures {
        PhysicalDeviceTimelineSemaphoreFeatures {
            s_type: StructureType::PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES,
            p_next: ::std::ptr::null_mut(),
            timeline_semaphore: Bool32::default(),
        }
    }
}
impl PhysicalDeviceTimelineSemaphoreFeatures {
    pub fn builder<'a>() -> PhysicalDeviceTimelineSemaphoreFeaturesBuilder<'a> {
        PhysicalDeviceTimelineSemaphoreFeaturesBuilder {
            inner: PhysicalDeviceTimelineSemaphoreFeatures::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDeviceTimelineSemaphoreFeaturesBuilder<'a> {
    inner: PhysicalDeviceTimelineSemaphoreFeatures,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceTimelineSemaphoreFeaturesBuilder<'_> {}
unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceTimelineSemaphoreFeatures {}
impl<'a> ::std::ops::Deref for PhysicalDeviceTimelineSemaphoreFeaturesBuilder<'a> {
    type Target = PhysicalDeviceTimelineSemaphoreFeatures;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PhysicalDeviceTimelineSemaphoreFeaturesBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDeviceTimelineSemaphoreFeaturesBuilder<'a> {
    pub fn timeline_semaphore(
        mut self,
        timeline_semaphore: bool,
    ) -> PhysicalDeviceTimelineSemaphoreFeaturesBuilder<'a> {
        self.inner.timeline_semaphore = timeline_semaphore.into();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDeviceTimelineSemaphoreFeatures {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceTimelineSemaphoreProperties.html>"]
pub struct PhysicalDeviceTimelineSemaphoreProperties {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub max_timeline_semaphore_value_difference: u64,
}
impl ::std::default::Default for PhysicalDeviceTimelineSemaphoreProperties {
    fn default() -> PhysicalDeviceTimelineSemaphoreProperties {
        PhysicalDeviceTimelineSemaphoreProperties {
            s_type: StructureType::PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES,
            p_next: ::std::ptr::null_mut(),
            max_timeline_semaphore_value_difference: u64::default(),
        }
    }
}
impl PhysicalDeviceTimelineSemaphoreProperties {
    pub fn builder<'a>() -> PhysicalDeviceTimelineSemaphorePropertiesBuilder<'a> {
        PhysicalDeviceTimelineSemaphorePropertiesBuilder {
            inner: PhysicalDeviceTimelineSemaphoreProperties::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDeviceTimelineSemaphorePropertiesBuilder<'a> {
    inner: PhysicalDeviceTimelineSemaphoreProperties,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsPhysicalDeviceProperties2
    for PhysicalDeviceTimelineSemaphorePropertiesBuilder<'_>
{
}
unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceTimelineSemaphoreProperties {}
impl<'a> ::std::ops::Deref for PhysicalDeviceTimelineSemaphorePropertiesBuilder<'a> {
    type Target = PhysicalDeviceTimelineSemaphoreProperties;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PhysicalDeviceTimelineSemaphorePropertiesBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDeviceTimelineSemaphorePropertiesBuilder<'a> {
    pub fn max_timeline_semaphore_value_difference(
        mut self,
        max_timeline_semaphore_value_difference: u64,
    ) -> PhysicalDeviceTimelineSemaphorePropertiesBuilder<'a> {
        self.inner.max_timeline_semaphore_value_difference =
            max_timeline_semaphore_value_difference;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDeviceTimelineSemaphoreProperties {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSemaphoreTypeCreateInfo.html>"]
pub struct SemaphoreTypeCreateInfo {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub semaphore_type: SemaphoreType,
    pub initial_value: u64,
}
impl ::std::default::Default for SemaphoreTypeCreateInfo {
    fn default() -> SemaphoreTypeCreateInfo {
        SemaphoreTypeCreateInfo {
            s_type: StructureType::SEMAPHORE_TYPE_CREATE_INFO,
            p_next: ::std::ptr::null(),
            semaphore_type: SemaphoreType::default(),
            initial_value: u64::default(),
        }
    }
}
impl SemaphoreTypeCreateInfo {
    pub fn builder<'a>() -> SemaphoreTypeCreateInfoBuilder<'a> {
        SemaphoreTypeCreateInfoBuilder {
            inner: SemaphoreTypeCreateInfo::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct SemaphoreTypeCreateInfoBuilder<'a> {
    inner: SemaphoreTypeCreateInfo,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsSemaphoreCreateInfo for SemaphoreTypeCreateInfoBuilder<'_> {}
unsafe impl ExtendsSemaphoreCreateInfo for SemaphoreTypeCreateInfo {}
unsafe impl ExtendsPhysicalDeviceExternalSemaphoreInfo for SemaphoreTypeCreateInfoBuilder<'_> {}
unsafe impl ExtendsPhysicalDeviceExternalSemaphoreInfo for SemaphoreTypeCreateInfo {}
impl<'a> ::std::ops::Deref for SemaphoreTypeCreateInfoBuilder<'a> {
    type Target = SemaphoreTypeCreateInfo;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for SemaphoreTypeCreateInfoBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> SemaphoreTypeCreateInfoBuilder<'a> {
    pub fn semaphore_type(
        mut self,
        semaphore_type: SemaphoreType,
    ) -> SemaphoreTypeCreateInfoBuilder<'a> {
        self.inner.semaphore_type = semaphore_type;
        self
    }
    pub fn initial_value(mut self, initial_value: u64) -> SemaphoreTypeCreateInfoBuilder<'a> {
        self.inner.initial_value = initial_value;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> SemaphoreTypeCreateInfo {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkTimelineSemaphoreSubmitInfo.html>"]
pub struct TimelineSemaphoreSubmitInfo {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub wait_semaphore_value_count: u32,
    pub p_wait_semaphore_values: *const u64,
    pub signal_semaphore_value_count: u32,
    pub p_signal_semaphore_values: *const u64,
}
impl ::std::default::Default for TimelineSemaphoreSubmitInfo {
    fn default() -> TimelineSemaphoreSubmitInfo {
        TimelineSemaphoreSubmitInfo {
            s_type: StructureType::TIMELINE_SEMAPHORE_SUBMIT_INFO,
            p_next: ::std::ptr::null(),
            wait_semaphore_value_count: u32::default(),
            p_wait_semaphore_values: ::std::ptr::null(),
            signal_semaphore_value_count: u32::default(),
            p_signal_semaphore_values: ::std::ptr::null(),
        }
    }
}
impl TimelineSemaphoreSubmitInfo {
    pub fn builder<'a>() -> TimelineSemaphoreSubmitInfoBuilder<'a> {
        TimelineSemaphoreSubmitInfoBuilder {
            inner: TimelineSemaphoreSubmitInfo::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct TimelineSemaphoreSubmitInfoBuilder<'a> {
    inner: TimelineSemaphoreSubmitInfo,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsSubmitInfo for TimelineSemaphoreSubmitInfoBuilder<'_> {}
unsafe impl ExtendsSubmitInfo for TimelineSemaphoreSubmitInfo {}
unsafe impl ExtendsBindSparseInfo for TimelineSemaphoreSubmitInfoBuilder<'_> {}
unsafe impl ExtendsBindSparseInfo for TimelineSemaphoreSubmitInfo {}
impl<'a> ::std::ops::Deref for TimelineSemaphoreSubmitInfoBuilder<'a> {
    type Target = TimelineSemaphoreSubmitInfo;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for TimelineSemaphoreSubmitInfoBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> TimelineSemaphoreSubmitInfoBuilder<'a> {
    pub fn wait_semaphore_values(
        mut self,
        wait_semaphore_values: &'a [u64],
    ) -> TimelineSemaphoreSubmitInfoBuilder<'a> {
        self.inner.wait_semaphore_value_count = wait_semaphore_values.len() as _;
        self.inner.p_wait_semaphore_values = wait_semaphore_values.as_ptr();
        self
    }
    pub fn signal_semaphore_values(
        mut self,
        signal_semaphore_values: &'a [u64],
    ) -> TimelineSemaphoreSubmitInfoBuilder<'a> {
        self.inner.signal_semaphore_value_count = signal_semaphore_values.len() as _;
        self.inner.p_signal_semaphore_values = signal_semaphore_values.as_ptr();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> TimelineSemaphoreSubmitInfo {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSemaphoreWaitInfo.html>"]
pub struct SemaphoreWaitInfo {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub flags: SemaphoreWaitFlags,
    pub semaphore_count: u32,
    pub p_semaphores: *const Semaphore,
    pub p_values: *const u64,
}
impl ::std::default::Default for SemaphoreWaitInfo {
    fn default() -> SemaphoreWaitInfo {
        SemaphoreWaitInfo {
            s_type: StructureType::SEMAPHORE_WAIT_INFO,
            p_next: ::std::ptr::null(),
            flags: SemaphoreWaitFlags::default(),
            semaphore_count: u32::default(),
            p_semaphores: ::std::ptr::null(),
            p_values: ::std::ptr::null(),
        }
    }
}
impl SemaphoreWaitInfo {
    pub fn builder<'a>() -> SemaphoreWaitInfoBuilder<'a> {
        SemaphoreWaitInfoBuilder {
            inner: SemaphoreWaitInfo::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct SemaphoreWaitInfoBuilder<'a> {
    inner: SemaphoreWaitInfo,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsSemaphoreWaitInfo {}
impl<'a> ::std::ops::Deref for SemaphoreWaitInfoBuilder<'a> {
    type Target = SemaphoreWaitInfo;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for SemaphoreWaitInfoBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> SemaphoreWaitInfoBuilder<'a> {
    pub fn flags(mut self, flags: SemaphoreWaitFlags) -> SemaphoreWaitInfoBuilder<'a> {
        self.inner.flags = flags;
        self
    }
    pub fn semaphores(mut self, semaphores: &'a [Semaphore]) -> SemaphoreWaitInfoBuilder<'a> {
        self.inner.semaphore_count = semaphores.len() as _;
        self.inner.p_semaphores = semaphores.as_ptr();
        self
    }
    pub fn values(mut self, values: &'a [u64]) -> SemaphoreWaitInfoBuilder<'a> {
        self.inner.semaphore_count = values.len() as _;
        self.inner.p_values = values.as_ptr();
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsSemaphoreWaitInfo>(
        mut self,
        next: &'a mut T,
    ) -> SemaphoreWaitInfoBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> SemaphoreWaitInfo {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSemaphoreSignalInfo.html>"]
pub struct SemaphoreSignalInfo {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub semaphore: Semaphore,
    pub value: u64,
}
impl ::std::default::Default for SemaphoreSignalInfo {
    fn default() -> SemaphoreSignalInfo {
        SemaphoreSignalInfo {
            s_type: StructureType::SEMAPHORE_SIGNAL_INFO,
            p_next: ::std::ptr::null(),
            semaphore: Semaphore::default(),
            value: u64::default(),
        }
    }
}
impl SemaphoreSignalInfo {
    pub fn builder<'a>() -> SemaphoreSignalInfoBuilder<'a> {
        SemaphoreSignalInfoBuilder {
            inner: SemaphoreSignalInfo::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct SemaphoreSignalInfoBuilder<'a> {
    inner: SemaphoreSignalInfo,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsSemaphoreSignalInfo {}
impl<'a> ::std::ops::Deref for SemaphoreSignalInfoBuilder<'a> {
    type Target = SemaphoreSignalInfo;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for SemaphoreSignalInfoBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> SemaphoreSignalInfoBuilder<'a> {
    pub fn semaphore(mut self, semaphore: Semaphore) -> SemaphoreSignalInfoBuilder<'a> {
        self.inner.semaphore = semaphore;
        self
    }
    pub fn value(mut self, value: u64) -> SemaphoreSignalInfoBuilder<'a> {
        self.inner.value = value;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsSemaphoreSignalInfo>(
        mut self,
        next: &'a mut T,
    ) -> SemaphoreSignalInfoBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> SemaphoreSignalInfo {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Default, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVertexInputBindingDivisorDescriptionEXT.html>"]
pub struct VertexInputBindingDivisorDescriptionEXT {
    pub binding: u32,
    pub divisor: u32,
}
impl VertexInputBindingDivisorDescriptionEXT {
    pub fn builder<'a>() -> VertexInputBindingDivisorDescriptionEXTBuilder<'a> {
        VertexInputBindingDivisorDescriptionEXTBuilder {
            inner: VertexInputBindingDivisorDescriptionEXT::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct VertexInputBindingDivisorDescriptionEXTBuilder<'a> {
    inner: VertexInputBindingDivisorDescriptionEXT,
    marker: ::std::marker::PhantomData<&'a ()>,
}
impl<'a> ::std::ops::Deref for VertexInputBindingDivisorDescriptionEXTBuilder<'a> {
    type Target = VertexInputBindingDivisorDescriptionEXT;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for VertexInputBindingDivisorDescriptionEXTBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> VertexInputBindingDivisorDescriptionEXTBuilder<'a> {
    pub fn binding(mut self, binding: u32) -> VertexInputBindingDivisorDescriptionEXTBuilder<'a> {
        self.inner.binding = binding;
        self
    }
    pub fn divisor(mut self, divisor: u32) -> VertexInputBindingDivisorDescriptionEXTBuilder<'a> {
        self.inner.divisor = divisor;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> VertexInputBindingDivisorDescriptionEXT {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineVertexInputDivisorStateCreateInfoEXT.html>"]
pub struct PipelineVertexInputDivisorStateCreateInfoEXT {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub vertex_binding_divisor_count: u32,
    pub p_vertex_binding_divisors: *const VertexInputBindingDivisorDescriptionEXT,
}
impl ::std::default::Default for PipelineVertexInputDivisorStateCreateInfoEXT {
    fn default() -> PipelineVertexInputDivisorStateCreateInfoEXT {
        PipelineVertexInputDivisorStateCreateInfoEXT {
            s_type: StructureType::PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT,
            p_next: ::std::ptr::null(),
            vertex_binding_divisor_count: u32::default(),
            p_vertex_binding_divisors: ::std::ptr::null(),
        }
    }
}
impl PipelineVertexInputDivisorStateCreateInfoEXT {
    pub fn builder<'a>() -> PipelineVertexInputDivisorStateCreateInfoEXTBuilder<'a> {
        PipelineVertexInputDivisorStateCreateInfoEXTBuilder {
            inner: PipelineVertexInputDivisorStateCreateInfoEXT::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PipelineVertexInputDivisorStateCreateInfoEXTBuilder<'a> {
    inner: PipelineVertexInputDivisorStateCreateInfoEXT,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsPipelineVertexInputStateCreateInfo
    for PipelineVertexInputDivisorStateCreateInfoEXTBuilder<'_>
{
}
unsafe impl ExtendsPipelineVertexInputStateCreateInfo
    for PipelineVertexInputDivisorStateCreateInfoEXT
{
}
impl<'a> ::std::ops::Deref for PipelineVertexInputDivisorStateCreateInfoEXTBuilder<'a> {
    type Target = PipelineVertexInputDivisorStateCreateInfoEXT;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PipelineVertexInputDivisorStateCreateInfoEXTBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PipelineVertexInputDivisorStateCreateInfoEXTBuilder<'a> {
    pub fn vertex_binding_divisors(
        mut self,
        vertex_binding_divisors: &'a [VertexInputBindingDivisorDescriptionEXT],
    ) -> PipelineVertexInputDivisorStateCreateInfoEXTBuilder<'a> {
        self.inner.vertex_binding_divisor_count = vertex_binding_divisors.len() as _;
        self.inner.p_vertex_binding_divisors = vertex_binding_divisors.as_ptr();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PipelineVertexInputDivisorStateCreateInfoEXT {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT.html>"]
pub struct PhysicalDeviceVertexAttributeDivisorPropertiesEXT {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub max_vertex_attrib_divisor: u32,
}
impl ::std::default::Default for PhysicalDeviceVertexAttributeDivisorPropertiesEXT {
    fn default() -> PhysicalDeviceVertexAttributeDivisorPropertiesEXT {
        PhysicalDeviceVertexAttributeDivisorPropertiesEXT {
            s_type: StructureType::PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT,
            p_next: ::std::ptr::null_mut(),
            max_vertex_attrib_divisor: u32::default(),
        }
    }
}
impl PhysicalDeviceVertexAttributeDivisorPropertiesEXT {
    pub fn builder<'a>() -> PhysicalDeviceVertexAttributeDivisorPropertiesEXTBuilder<'a> {
        PhysicalDeviceVertexAttributeDivisorPropertiesEXTBuilder {
            inner: PhysicalDeviceVertexAttributeDivisorPropertiesEXT::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDeviceVertexAttributeDivisorPropertiesEXTBuilder<'a> {
    inner: PhysicalDeviceVertexAttributeDivisorPropertiesEXT,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsPhysicalDeviceProperties2
    for PhysicalDeviceVertexAttributeDivisorPropertiesEXTBuilder<'_>
{
}
unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceVertexAttributeDivisorPropertiesEXT {}
impl<'a> ::std::ops::Deref for PhysicalDeviceVertexAttributeDivisorPropertiesEXTBuilder<'a> {
    type Target = PhysicalDeviceVertexAttributeDivisorPropertiesEXT;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PhysicalDeviceVertexAttributeDivisorPropertiesEXTBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDeviceVertexAttributeDivisorPropertiesEXTBuilder<'a> {
    pub fn max_vertex_attrib_divisor(
        mut self,
        max_vertex_attrib_divisor: u32,
    ) -> PhysicalDeviceVertexAttributeDivisorPropertiesEXTBuilder<'a> {
        self.inner.max_vertex_attrib_divisor = max_vertex_attrib_divisor;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDeviceVertexAttributeDivisorPropertiesEXT {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDevicePCIBusInfoPropertiesEXT.html>"]
pub struct PhysicalDevicePCIBusInfoPropertiesEXT {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub pci_domain: u32,
    pub pci_bus: u32,
    pub pci_device: u32,
    pub pci_function: u32,
}
impl ::std::default::Default for PhysicalDevicePCIBusInfoPropertiesEXT {
    fn default() -> PhysicalDevicePCIBusInfoPropertiesEXT {
        PhysicalDevicePCIBusInfoPropertiesEXT {
            s_type: StructureType::PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT,
            p_next: ::std::ptr::null_mut(),
            pci_domain: u32::default(),
            pci_bus: u32::default(),
            pci_device: u32::default(),
            pci_function: u32::default(),
        }
    }
}
impl PhysicalDevicePCIBusInfoPropertiesEXT {
    pub fn builder<'a>() -> PhysicalDevicePCIBusInfoPropertiesEXTBuilder<'a> {
        PhysicalDevicePCIBusInfoPropertiesEXTBuilder {
            inner: PhysicalDevicePCIBusInfoPropertiesEXT::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDevicePCIBusInfoPropertiesEXTBuilder<'a> {
    inner: PhysicalDevicePCIBusInfoPropertiesEXT,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDevicePCIBusInfoPropertiesEXTBuilder<'_> {}
unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDevicePCIBusInfoPropertiesEXT {}
impl<'a> ::std::ops::Deref for PhysicalDevicePCIBusInfoPropertiesEXTBuilder<'a> {
    type Target = PhysicalDevicePCIBusInfoPropertiesEXT;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PhysicalDevicePCIBusInfoPropertiesEXTBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDevicePCIBusInfoPropertiesEXTBuilder<'a> {
    pub fn pci_domain(
        mut self,
        pci_domain: u32,
    ) -> PhysicalDevicePCIBusInfoPropertiesEXTBuilder<'a> {
        self.inner.pci_domain = pci_domain;
        self
    }
    pub fn pci_bus(mut self, pci_bus: u32) -> PhysicalDevicePCIBusInfoPropertiesEXTBuilder<'a> {
        self.inner.pci_bus = pci_bus;
        self
    }
    pub fn pci_device(
        mut self,
        pci_device: u32,
    ) -> PhysicalDevicePCIBusInfoPropertiesEXTBuilder<'a> {
        self.inner.pci_device = pci_device;
        self
    }
    pub fn pci_function(
        mut self,
        pci_function: u32,
    ) -> PhysicalDevicePCIBusInfoPropertiesEXTBuilder<'a> {
        self.inner.pci_function = pci_function;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDevicePCIBusInfoPropertiesEXT {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImportAndroidHardwareBufferInfoANDROID.html>"]
pub struct ImportAndroidHardwareBufferInfoANDROID {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub buffer: *mut AHardwareBuffer,
}
impl ::std::default::Default for ImportAndroidHardwareBufferInfoANDROID {
    fn default() -> ImportAndroidHardwareBufferInfoANDROID {
        ImportAndroidHardwareBufferInfoANDROID {
            s_type: StructureType::IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID,
            p_next: ::std::ptr::null(),
            buffer: ::std::ptr::null_mut(),
        }
    }
}
impl ImportAndroidHardwareBufferInfoANDROID {
    pub fn builder<'a>() -> ImportAndroidHardwareBufferInfoANDROIDBuilder<'a> {
        ImportAndroidHardwareBufferInfoANDROIDBuilder {
            inner: ImportAndroidHardwareBufferInfoANDROID::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct ImportAndroidHardwareBufferInfoANDROIDBuilder<'a> {
    inner: ImportAndroidHardwareBufferInfoANDROID,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsMemoryAllocateInfo for ImportAndroidHardwareBufferInfoANDROIDBuilder<'_> {}
unsafe impl ExtendsMemoryAllocateInfo for ImportAndroidHardwareBufferInfoANDROID {}
impl<'a> ::std::ops::Deref for ImportAndroidHardwareBufferInfoANDROIDBuilder<'a> {
    type Target = ImportAndroidHardwareBufferInfoANDROID;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for ImportAndroidHardwareBufferInfoANDROIDBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> ImportAndroidHardwareBufferInfoANDROIDBuilder<'a> {
    pub fn buffer(
        mut self,
        buffer: *mut AHardwareBuffer,
    ) -> ImportAndroidHardwareBufferInfoANDROIDBuilder<'a> {
        self.inner.buffer = buffer;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> ImportAndroidHardwareBufferInfoANDROID {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAndroidHardwareBufferUsageANDROID.html>"]
pub struct AndroidHardwareBufferUsageANDROID {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub android_hardware_buffer_usage: u64,
}
impl ::std::default::Default for AndroidHardwareBufferUsageANDROID {
    fn default() -> AndroidHardwareBufferUsageANDROID {
        AndroidHardwareBufferUsageANDROID {
            s_type: StructureType::ANDROID_HARDWARE_BUFFER_USAGE_ANDROID,
            p_next: ::std::ptr::null_mut(),
            android_hardware_buffer_usage: u64::default(),
        }
    }
}
impl AndroidHardwareBufferUsageANDROID {
    pub fn builder<'a>() -> AndroidHardwareBufferUsageANDROIDBuilder<'a> {
        AndroidHardwareBufferUsageANDROIDBuilder {
            inner: AndroidHardwareBufferUsageANDROID::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct AndroidHardwareBufferUsageANDROIDBuilder<'a> {
    inner: AndroidHardwareBufferUsageANDROID,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsImageFormatProperties2 for AndroidHardwareBufferUsageANDROIDBuilder<'_> {}
unsafe impl ExtendsImageFormatProperties2 for AndroidHardwareBufferUsageANDROID {}
impl<'a> ::std::ops::Deref for AndroidHardwareBufferUsageANDROIDBuilder<'a> {
    type Target = AndroidHardwareBufferUsageANDROID;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for AndroidHardwareBufferUsageANDROIDBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> AndroidHardwareBufferUsageANDROIDBuilder<'a> {
    pub fn android_hardware_buffer_usage(
        mut self,
        android_hardware_buffer_usage: u64,
    ) -> AndroidHardwareBufferUsageANDROIDBuilder<'a> {
        self.inner.android_hardware_buffer_usage = android_hardware_buffer_usage;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> AndroidHardwareBufferUsageANDROID {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAndroidHardwareBufferPropertiesANDROID.html>"]
pub struct AndroidHardwareBufferPropertiesANDROID {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub allocation_size: DeviceSize,
    pub memory_type_bits: u32,
}
impl ::std::default::Default for AndroidHardwareBufferPropertiesANDROID {
    fn default() -> AndroidHardwareBufferPropertiesANDROID {
        AndroidHardwareBufferPropertiesANDROID {
            s_type: StructureType::ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID,
            p_next: ::std::ptr::null_mut(),
            allocation_size: DeviceSize::default(),
            memory_type_bits: u32::default(),
        }
    }
}
impl AndroidHardwareBufferPropertiesANDROID {
    pub fn builder<'a>() -> AndroidHardwareBufferPropertiesANDROIDBuilder<'a> {
        AndroidHardwareBufferPropertiesANDROIDBuilder {
            inner: AndroidHardwareBufferPropertiesANDROID::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct AndroidHardwareBufferPropertiesANDROIDBuilder<'a> {
    inner: AndroidHardwareBufferPropertiesANDROID,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsAndroidHardwareBufferPropertiesANDROID {}
impl<'a> ::std::ops::Deref for AndroidHardwareBufferPropertiesANDROIDBuilder<'a> {
    type Target = AndroidHardwareBufferPropertiesANDROID;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for AndroidHardwareBufferPropertiesANDROIDBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> AndroidHardwareBufferPropertiesANDROIDBuilder<'a> {
    pub fn allocation_size(
        mut self,
        allocation_size: DeviceSize,
    ) -> AndroidHardwareBufferPropertiesANDROIDBuilder<'a> {
        self.inner.allocation_size = allocation_size;
        self
    }
    pub fn memory_type_bits(
        mut self,
        memory_type_bits: u32,
    ) -> AndroidHardwareBufferPropertiesANDROIDBuilder<'a> {
        self.inner.memory_type_bits = memory_type_bits;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsAndroidHardwareBufferPropertiesANDROID>(
        mut self,
        next: &'a mut T,
    ) -> AndroidHardwareBufferPropertiesANDROIDBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> AndroidHardwareBufferPropertiesANDROID {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkMemoryGetAndroidHardwareBufferInfoANDROID.html>"]
pub struct MemoryGetAndroidHardwareBufferInfoANDROID {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub memory: DeviceMemory,
}
impl ::std::default::Default for MemoryGetAndroidHardwareBufferInfoANDROID {
    fn default() -> MemoryGetAndroidHardwareBufferInfoANDROID {
        MemoryGetAndroidHardwareBufferInfoANDROID {
            s_type: StructureType::MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID,
            p_next: ::std::ptr::null(),
            memory: DeviceMemory::default(),
        }
    }
}
impl MemoryGetAndroidHardwareBufferInfoANDROID {
    pub fn builder<'a>() -> MemoryGetAndroidHardwareBufferInfoANDROIDBuilder<'a> {
        MemoryGetAndroidHardwareBufferInfoANDROIDBuilder {
            inner: MemoryGetAndroidHardwareBufferInfoANDROID::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct MemoryGetAndroidHardwareBufferInfoANDROIDBuilder<'a> {
    inner: MemoryGetAndroidHardwareBufferInfoANDROID,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsMemoryGetAndroidHardwareBufferInfoANDROID {}
impl<'a> ::std::ops::Deref for MemoryGetAndroidHardwareBufferInfoANDROIDBuilder<'a> {
    type Target = MemoryGetAndroidHardwareBufferInfoANDROID;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for MemoryGetAndroidHardwareBufferInfoANDROIDBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> MemoryGetAndroidHardwareBufferInfoANDROIDBuilder<'a> {
    pub fn memory(
        mut self,
        memory: DeviceMemory,
    ) -> MemoryGetAndroidHardwareBufferInfoANDROIDBuilder<'a> {
        self.inner.memory = memory;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsMemoryGetAndroidHardwareBufferInfoANDROID>(
        mut self,
        next: &'a mut T,
    ) -> MemoryGetAndroidHardwareBufferInfoANDROIDBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> MemoryGetAndroidHardwareBufferInfoANDROID {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAndroidHardwareBufferFormatPropertiesANDROID.html>"]
pub struct AndroidHardwareBufferFormatPropertiesANDROID {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub format: Format,
    pub external_format: u64,
    pub format_features: FormatFeatureFlags,
    pub sampler_ycbcr_conversion_components: ComponentMapping,
    pub suggested_ycbcr_model: SamplerYcbcrModelConversion,
    pub suggested_ycbcr_range: SamplerYcbcrRange,
    pub suggested_x_chroma_offset: ChromaLocation,
    pub suggested_y_chroma_offset: ChromaLocation,
}
impl ::std::default::Default for AndroidHardwareBufferFormatPropertiesANDROID {
    fn default() -> AndroidHardwareBufferFormatPropertiesANDROID {
        AndroidHardwareBufferFormatPropertiesANDROID {
            s_type: StructureType::ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID,
            p_next: ::std::ptr::null_mut(),
            format: Format::default(),
            external_format: u64::default(),
            format_features: FormatFeatureFlags::default(),
            sampler_ycbcr_conversion_components: ComponentMapping::default(),
            suggested_ycbcr_model: SamplerYcbcrModelConversion::default(),
            suggested_ycbcr_range: SamplerYcbcrRange::default(),
            suggested_x_chroma_offset: ChromaLocation::default(),
            suggested_y_chroma_offset: ChromaLocation::default(),
        }
    }
}
impl AndroidHardwareBufferFormatPropertiesANDROID {
    pub fn builder<'a>() -> AndroidHardwareBufferFormatPropertiesANDROIDBuilder<'a> {
        AndroidHardwareBufferFormatPropertiesANDROIDBuilder {
            inner: AndroidHardwareBufferFormatPropertiesANDROID::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct AndroidHardwareBufferFormatPropertiesANDROIDBuilder<'a> {
    inner: AndroidHardwareBufferFormatPropertiesANDROID,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsAndroidHardwareBufferPropertiesANDROID
    for AndroidHardwareBufferFormatPropertiesANDROIDBuilder<'_>
{
}
unsafe impl ExtendsAndroidHardwareBufferPropertiesANDROID
    for AndroidHardwareBufferFormatPropertiesANDROID
{
}
impl<'a> ::std::ops::Deref for AndroidHardwareBufferFormatPropertiesANDROIDBuilder<'a> {
    type Target = AndroidHardwareBufferFormatPropertiesANDROID;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for AndroidHardwareBufferFormatPropertiesANDROIDBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> AndroidHardwareBufferFormatPropertiesANDROIDBuilder<'a> {
    pub fn format(
        mut self,
        format: Format,
    ) -> AndroidHardwareBufferFormatPropertiesANDROIDBuilder<'a> {
        self.inner.format = format;
        self
    }
    pub fn external_format(
        mut self,
        external_format: u64,
    ) -> AndroidHardwareBufferFormatPropertiesANDROIDBuilder<'a> {
        self.inner.external_format = external_format;
        self
    }
    pub fn format_features(
        mut self,
        format_features: FormatFeatureFlags,
    ) -> AndroidHardwareBufferFormatPropertiesANDROIDBuilder<'a> {
        self.inner.format_features = format_features;
        self
    }
    pub fn sampler_ycbcr_conversion_components(
        mut self,
        sampler_ycbcr_conversion_components: ComponentMapping,
    ) -> AndroidHardwareBufferFormatPropertiesANDROIDBuilder<'a> {
        self.inner.sampler_ycbcr_conversion_components = sampler_ycbcr_conversion_components;
        self
    }
    pub fn suggested_ycbcr_model(
        mut self,
        suggested_ycbcr_model: SamplerYcbcrModelConversion,
    ) -> AndroidHardwareBufferFormatPropertiesANDROIDBuilder<'a> {
        self.inner.suggested_ycbcr_model = suggested_ycbcr_model;
        self
    }
    pub fn suggested_ycbcr_range(
        mut self,
        suggested_ycbcr_range: SamplerYcbcrRange,
    ) -> AndroidHardwareBufferFormatPropertiesANDROIDBuilder<'a> {
        self.inner.suggested_ycbcr_range = suggested_ycbcr_range;
        self
    }
    pub fn suggested_x_chroma_offset(
        mut self,
        suggested_x_chroma_offset: ChromaLocation,
    ) -> AndroidHardwareBufferFormatPropertiesANDROIDBuilder<'a> {
        self.inner.suggested_x_chroma_offset = suggested_x_chroma_offset;
        self
    }
    pub fn suggested_y_chroma_offset(
        mut self,
        suggested_y_chroma_offset: ChromaLocation,
    ) -> AndroidHardwareBufferFormatPropertiesANDROIDBuilder<'a> {
        self.inner.suggested_y_chroma_offset = suggested_y_chroma_offset;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> AndroidHardwareBufferFormatPropertiesANDROID {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCommandBufferInheritanceConditionalRenderingInfoEXT.html>"]
pub struct CommandBufferInheritanceConditionalRenderingInfoEXT {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub conditional_rendering_enable: Bool32,
}
impl ::std::default::Default for CommandBufferInheritanceConditionalRenderingInfoEXT {
    fn default() -> CommandBufferInheritanceConditionalRenderingInfoEXT {
        CommandBufferInheritanceConditionalRenderingInfoEXT {
            s_type: StructureType::COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT,
            p_next: ::std::ptr::null(),
            conditional_rendering_enable: Bool32::default(),
        }
    }
}
impl CommandBufferInheritanceConditionalRenderingInfoEXT {
    pub fn builder<'a>() -> CommandBufferInheritanceConditionalRenderingInfoEXTBuilder<'a> {
        CommandBufferInheritanceConditionalRenderingInfoEXTBuilder {
            inner: CommandBufferInheritanceConditionalRenderingInfoEXT::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct CommandBufferInheritanceConditionalRenderingInfoEXTBuilder<'a> {
    inner: CommandBufferInheritanceConditionalRenderingInfoEXT,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsCommandBufferInheritanceInfo
    for CommandBufferInheritanceConditionalRenderingInfoEXTBuilder<'_>
{
}
unsafe impl ExtendsCommandBufferInheritanceInfo
    for CommandBufferInheritanceConditionalRenderingInfoEXT
{
}
impl<'a> ::std::ops::Deref for CommandBufferInheritanceConditionalRenderingInfoEXTBuilder<'a> {
    type Target = CommandBufferInheritanceConditionalRenderingInfoEXT;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for CommandBufferInheritanceConditionalRenderingInfoEXTBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> CommandBufferInheritanceConditionalRenderingInfoEXTBuilder<'a> {
    pub fn conditional_rendering_enable(
        mut self,
        conditional_rendering_enable: bool,
    ) -> CommandBufferInheritanceConditionalRenderingInfoEXTBuilder<'a> {
        self.inner.conditional_rendering_enable = conditional_rendering_enable.into();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> CommandBufferInheritanceConditionalRenderingInfoEXT {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkExternalFormatANDROID.html>"]
pub struct ExternalFormatANDROID {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub external_format: u64,
}
impl ::std::default::Default for ExternalFormatANDROID {
    fn default() -> ExternalFormatANDROID {
        ExternalFormatANDROID {
            s_type: StructureType::EXTERNAL_FORMAT_ANDROID,
            p_next: ::std::ptr::null_mut(),
            external_format: u64::default(),
        }
    }
}
impl ExternalFormatANDROID {
    pub fn builder<'a>() -> ExternalFormatANDROIDBuilder<'a> {
        ExternalFormatANDROIDBuilder {
            inner: ExternalFormatANDROID::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct ExternalFormatANDROIDBuilder<'a> {
    inner: ExternalFormatANDROID,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsImageCreateInfo for ExternalFormatANDROIDBuilder<'_> {}
unsafe impl ExtendsImageCreateInfo for ExternalFormatANDROID {}
unsafe impl ExtendsSamplerYcbcrConversionCreateInfo for ExternalFormatANDROIDBuilder<'_> {}
unsafe impl ExtendsSamplerYcbcrConversionCreateInfo for ExternalFormatANDROID {}
impl<'a> ::std::ops::Deref for ExternalFormatANDROIDBuilder<'a> {
    type Target = ExternalFormatANDROID;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for ExternalFormatANDROIDBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> ExternalFormatANDROIDBuilder<'a> {
    pub fn external_format(mut self, external_format: u64) -> ExternalFormatANDROIDBuilder<'a> {
        self.inner.external_format = external_format;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> ExternalFormatANDROID {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDevice8BitStorageFeatures.html>"]
pub struct PhysicalDevice8BitStorageFeatures {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub storage_buffer8_bit_access: Bool32,
    pub uniform_and_storage_buffer8_bit_access: Bool32,
    pub storage_push_constant8: Bool32,
}
impl ::std::default::Default for PhysicalDevice8BitStorageFeatures {
    fn default() -> PhysicalDevice8BitStorageFeatures {
        PhysicalDevice8BitStorageFeatures {
            s_type: StructureType::PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES,
            p_next: ::std::ptr::null_mut(),
            storage_buffer8_bit_access: Bool32::default(),
            uniform_and_storage_buffer8_bit_access: Bool32::default(),
            storage_push_constant8: Bool32::default(),
        }
    }
}
impl PhysicalDevice8BitStorageFeatures {
    pub fn builder<'a>() -> PhysicalDevice8BitStorageFeaturesBuilder<'a> {
        PhysicalDevice8BitStorageFeaturesBuilder {
            inner: PhysicalDevice8BitStorageFeatures::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDevice8BitStorageFeaturesBuilder<'a> {
    inner: PhysicalDevice8BitStorageFeatures,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsDeviceCreateInfo for PhysicalDevice8BitStorageFeaturesBuilder<'_> {}
unsafe impl ExtendsDeviceCreateInfo for PhysicalDevice8BitStorageFeatures {}
impl<'a> ::std::ops::Deref for PhysicalDevice8BitStorageFeaturesBuilder<'a> {
    type Target = PhysicalDevice8BitStorageFeatures;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PhysicalDevice8BitStorageFeaturesBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDevice8BitStorageFeaturesBuilder<'a> {
    pub fn storage_buffer8_bit_access(
        mut self,
        storage_buffer8_bit_access: bool,
    ) -> PhysicalDevice8BitStorageFeaturesBuilder<'a> {
        self.inner.storage_buffer8_bit_access = storage_buffer8_bit_access.into();
        self
    }
    pub fn uniform_and_storage_buffer8_bit_access(
        mut self,
        uniform_and_storage_buffer8_bit_access: bool,
    ) -> PhysicalDevice8BitStorageFeaturesBuilder<'a> {
        self.inner.uniform_and_storage_buffer8_bit_access =
            uniform_and_storage_buffer8_bit_access.into();
        self
    }
    pub fn storage_push_constant8(
        mut self,
        storage_push_constant8: bool,
    ) -> PhysicalDevice8BitStorageFeaturesBuilder<'a> {
        self.inner.storage_push_constant8 = storage_push_constant8.into();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDevice8BitStorageFeatures {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceConditionalRenderingFeaturesEXT.html>"]
pub struct PhysicalDeviceConditionalRenderingFeaturesEXT {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub conditional_rendering: Bool32,
    pub inherited_conditional_rendering: Bool32,
}
impl ::std::default::Default for PhysicalDeviceConditionalRenderingFeaturesEXT {
    fn default() -> PhysicalDeviceConditionalRenderingFeaturesEXT {
        PhysicalDeviceConditionalRenderingFeaturesEXT {
            s_type: StructureType::PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT,
            p_next: ::std::ptr::null_mut(),
            conditional_rendering: Bool32::default(),
            inherited_conditional_rendering: Bool32::default(),
        }
    }
}
impl PhysicalDeviceConditionalRenderingFeaturesEXT {
    pub fn builder<'a>() -> PhysicalDeviceConditionalRenderingFeaturesEXTBuilder<'a> {
        PhysicalDeviceConditionalRenderingFeaturesEXTBuilder {
            inner: PhysicalDeviceConditionalRenderingFeaturesEXT::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDeviceConditionalRenderingFeaturesEXTBuilder<'a> {
    inner: PhysicalDeviceConditionalRenderingFeaturesEXT,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceConditionalRenderingFeaturesEXTBuilder<'_> {}
unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceConditionalRenderingFeaturesEXT {}
impl<'a> ::std::ops::Deref for PhysicalDeviceConditionalRenderingFeaturesEXTBuilder<'a> {
    type Target = PhysicalDeviceConditionalRenderingFeaturesEXT;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PhysicalDeviceConditionalRenderingFeaturesEXTBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDeviceConditionalRenderingFeaturesEXTBuilder<'a> {
    pub fn conditional_rendering(
        mut self,
        conditional_rendering: bool,
    ) -> PhysicalDeviceConditionalRenderingFeaturesEXTBuilder<'a> {
        self.inner.conditional_rendering = conditional_rendering.into();
        self
    }
    pub fn inherited_conditional_rendering(
        mut self,
        inherited_conditional_rendering: bool,
    ) -> PhysicalDeviceConditionalRenderingFeaturesEXTBuilder<'a> {
        self.inner.inherited_conditional_rendering = inherited_conditional_rendering.into();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDeviceConditionalRenderingFeaturesEXT {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkanMemoryModelFeatures.html>"]
pub struct PhysicalDeviceVulkanMemoryModelFeatures {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub vulkan_memory_model: Bool32,
    pub vulkan_memory_model_device_scope: Bool32,
    pub vulkan_memory_model_availability_visibility_chains: Bool32,
}
impl ::std::default::Default for PhysicalDeviceVulkanMemoryModelFeatures {
    fn default() -> PhysicalDeviceVulkanMemoryModelFeatures {
        PhysicalDeviceVulkanMemoryModelFeatures {
            s_type: StructureType::PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES,
            p_next: ::std::ptr::null_mut(),
            vulkan_memory_model: Bool32::default(),
            vulkan_memory_model_device_scope: Bool32::default(),
            vulkan_memory_model_availability_visibility_chains: Bool32::default(),
        }
    }
}
impl PhysicalDeviceVulkanMemoryModelFeatures {
    pub fn builder<'a>() -> PhysicalDeviceVulkanMemoryModelFeaturesBuilder<'a> {
        PhysicalDeviceVulkanMemoryModelFeaturesBuilder {
            inner: PhysicalDeviceVulkanMemoryModelFeatures::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDeviceVulkanMemoryModelFeaturesBuilder<'a> {
    inner: PhysicalDeviceVulkanMemoryModelFeatures,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVulkanMemoryModelFeaturesBuilder<'_> {}
unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVulkanMemoryModelFeatures {}
impl<'a> ::std::ops::Deref for PhysicalDeviceVulkanMemoryModelFeaturesBuilder<'a> {
    type Target = PhysicalDeviceVulkanMemoryModelFeatures;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PhysicalDeviceVulkanMemoryModelFeaturesBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDeviceVulkanMemoryModelFeaturesBuilder<'a> {
    pub fn vulkan_memory_model(
        mut self,
        vulkan_memory_model: bool,
    ) -> PhysicalDeviceVulkanMemoryModelFeaturesBuilder<'a> {
        self.inner.vulkan_memory_model = vulkan_memory_model.into();
        self
    }
    pub fn vulkan_memory_model_device_scope(
        mut self,
        vulkan_memory_model_device_scope: bool,
    ) -> PhysicalDeviceVulkanMemoryModelFeaturesBuilder<'a> {
        self.inner.vulkan_memory_model_device_scope = vulkan_memory_model_device_scope.into();
        self
    }
    pub fn vulkan_memory_model_availability_visibility_chains(
        mut self,
        vulkan_memory_model_availability_visibility_chains: bool,
    ) -> PhysicalDeviceVulkanMemoryModelFeaturesBuilder<'a> {
        self.inner
            .vulkan_memory_model_availability_visibility_chains =
            vulkan_memory_model_availability_visibility_chains.into();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDeviceVulkanMemoryModelFeatures {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceShaderAtomicInt64Features.html>"]
pub struct PhysicalDeviceShaderAtomicInt64Features {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub shader_buffer_int64_atomics: Bool32,
    pub shader_shared_int64_atomics: Bool32,
}
impl ::std::default::Default for PhysicalDeviceShaderAtomicInt64Features {
    fn default() -> PhysicalDeviceShaderAtomicInt64Features {
        PhysicalDeviceShaderAtomicInt64Features {
            s_type: StructureType::PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES,
            p_next: ::std::ptr::null_mut(),
            shader_buffer_int64_atomics: Bool32::default(),
            shader_shared_int64_atomics: Bool32::default(),
        }
    }
}
impl PhysicalDeviceShaderAtomicInt64Features {
    pub fn builder<'a>() -> PhysicalDeviceShaderAtomicInt64FeaturesBuilder<'a> {
        PhysicalDeviceShaderAtomicInt64FeaturesBuilder {
            inner: PhysicalDeviceShaderAtomicInt64Features::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDeviceShaderAtomicInt64FeaturesBuilder<'a> {
    inner: PhysicalDeviceShaderAtomicInt64Features,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderAtomicInt64FeaturesBuilder<'_> {}
unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderAtomicInt64Features {}
impl<'a> ::std::ops::Deref for PhysicalDeviceShaderAtomicInt64FeaturesBuilder<'a> {
    type Target = PhysicalDeviceShaderAtomicInt64Features;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderAtomicInt64FeaturesBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDeviceShaderAtomicInt64FeaturesBuilder<'a> {
    pub fn shader_buffer_int64_atomics(
        mut self,
        shader_buffer_int64_atomics: bool,
    ) -> PhysicalDeviceShaderAtomicInt64FeaturesBuilder<'a> {
        self.inner.shader_buffer_int64_atomics = shader_buffer_int64_atomics.into();
        self
    }
    pub fn shader_shared_int64_atomics(
        mut self,
        shader_shared_int64_atomics: bool,
    ) -> PhysicalDeviceShaderAtomicInt64FeaturesBuilder<'a> {
        self.inner.shader_shared_int64_atomics = shader_shared_int64_atomics.into();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDeviceShaderAtomicInt64Features {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT.html>"]
pub struct PhysicalDeviceVertexAttributeDivisorFeaturesEXT {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub vertex_attribute_instance_rate_divisor: Bool32,
    pub vertex_attribute_instance_rate_zero_divisor: Bool32,
}
impl ::std::default::Default for PhysicalDeviceVertexAttributeDivisorFeaturesEXT {
    fn default() -> PhysicalDeviceVertexAttributeDivisorFeaturesEXT {
        PhysicalDeviceVertexAttributeDivisorFeaturesEXT {
            s_type: StructureType::PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT,
            p_next: ::std::ptr::null_mut(),
            vertex_attribute_instance_rate_divisor: Bool32::default(),
            vertex_attribute_instance_rate_zero_divisor: Bool32::default(),
        }
    }
}
impl PhysicalDeviceVertexAttributeDivisorFeaturesEXT {
    pub fn builder<'a>() -> PhysicalDeviceVertexAttributeDivisorFeaturesEXTBuilder<'a> {
        PhysicalDeviceVertexAttributeDivisorFeaturesEXTBuilder {
            inner: PhysicalDeviceVertexAttributeDivisorFeaturesEXT::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDeviceVertexAttributeDivisorFeaturesEXTBuilder<'a> {
    inner: PhysicalDeviceVertexAttributeDivisorFeaturesEXT,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVertexAttributeDivisorFeaturesEXTBuilder<'_> {}
unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVertexAttributeDivisorFeaturesEXT {}
impl<'a> ::std::ops::Deref for PhysicalDeviceVertexAttributeDivisorFeaturesEXTBuilder<'a> {
    type Target = PhysicalDeviceVertexAttributeDivisorFeaturesEXT;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PhysicalDeviceVertexAttributeDivisorFeaturesEXTBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDeviceVertexAttributeDivisorFeaturesEXTBuilder<'a> {
    pub fn vertex_attribute_instance_rate_divisor(
        mut self,
        vertex_attribute_instance_rate_divisor: bool,
    ) -> PhysicalDeviceVertexAttributeDivisorFeaturesEXTBuilder<'a> {
        self.inner.vertex_attribute_instance_rate_divisor =
            vertex_attribute_instance_rate_divisor.into();
        self
    }
    pub fn vertex_attribute_instance_rate_zero_divisor(
        mut self,
        vertex_attribute_instance_rate_zero_divisor: bool,
    ) -> PhysicalDeviceVertexAttributeDivisorFeaturesEXTBuilder<'a> {
        self.inner.vertex_attribute_instance_rate_zero_divisor =
            vertex_attribute_instance_rate_zero_divisor.into();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDeviceVertexAttributeDivisorFeaturesEXT {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkQueueFamilyCheckpointPropertiesNV.html>"]
pub struct QueueFamilyCheckpointPropertiesNV {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub checkpoint_execution_stage_mask: PipelineStageFlags,
}
impl ::std::default::Default for QueueFamilyCheckpointPropertiesNV {
    fn default() -> QueueFamilyCheckpointPropertiesNV {
        QueueFamilyCheckpointPropertiesNV {
            s_type: StructureType::QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV,
            p_next: ::std::ptr::null_mut(),
            checkpoint_execution_stage_mask: PipelineStageFlags::default(),
        }
    }
}
impl QueueFamilyCheckpointPropertiesNV {
    pub fn builder<'a>() -> QueueFamilyCheckpointPropertiesNVBuilder<'a> {
        QueueFamilyCheckpointPropertiesNVBuilder {
            inner: QueueFamilyCheckpointPropertiesNV::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct QueueFamilyCheckpointPropertiesNVBuilder<'a> {
    inner: QueueFamilyCheckpointPropertiesNV,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsQueueFamilyProperties2 for QueueFamilyCheckpointPropertiesNVBuilder<'_> {}
unsafe impl ExtendsQueueFamilyProperties2 for QueueFamilyCheckpointPropertiesNV {}
impl<'a> ::std::ops::Deref for QueueFamilyCheckpointPropertiesNVBuilder<'a> {
    type Target = QueueFamilyCheckpointPropertiesNV;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for QueueFamilyCheckpointPropertiesNVBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> QueueFamilyCheckpointPropertiesNVBuilder<'a> {
    pub fn checkpoint_execution_stage_mask(
        mut self,
        checkpoint_execution_stage_mask: PipelineStageFlags,
    ) -> QueueFamilyCheckpointPropertiesNVBuilder<'a> {
        self.inner.checkpoint_execution_stage_mask = checkpoint_execution_stage_mask;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> QueueFamilyCheckpointPropertiesNV {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCheckpointDataNV.html>"]
pub struct CheckpointDataNV {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub stage: PipelineStageFlags,
    pub p_checkpoint_marker: *mut c_void,
}
impl ::std::default::Default for CheckpointDataNV {
    fn default() -> CheckpointDataNV {
        CheckpointDataNV {
            s_type: StructureType::CHECKPOINT_DATA_NV,
            p_next: ::std::ptr::null_mut(),
            stage: PipelineStageFlags::default(),
            p_checkpoint_marker: ::std::ptr::null_mut(),
        }
    }
}
impl CheckpointDataNV {
    pub fn builder<'a>() -> CheckpointDataNVBuilder<'a> {
        CheckpointDataNVBuilder {
            inner: CheckpointDataNV::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct CheckpointDataNVBuilder<'a> {
    inner: CheckpointDataNV,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsCheckpointDataNV {}
impl<'a> ::std::ops::Deref for CheckpointDataNVBuilder<'a> {
    type Target = CheckpointDataNV;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for CheckpointDataNVBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> CheckpointDataNVBuilder<'a> {
    pub fn stage(mut self, stage: PipelineStageFlags) -> CheckpointDataNVBuilder<'a> {
        self.inner.stage = stage;
        self
    }
    pub fn checkpoint_marker(
        mut self,
        checkpoint_marker: *mut c_void,
    ) -> CheckpointDataNVBuilder<'a> {
        self.inner.p_checkpoint_marker = checkpoint_marker;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsCheckpointDataNV>(
        mut self,
        next: &'a mut T,
    ) -> CheckpointDataNVBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> CheckpointDataNV {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceDepthStencilResolveProperties.html>"]
pub struct PhysicalDeviceDepthStencilResolveProperties {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub supported_depth_resolve_modes: ResolveModeFlags,
    pub supported_stencil_resolve_modes: ResolveModeFlags,
    pub independent_resolve_none: Bool32,
    pub independent_resolve: Bool32,
}
impl ::std::default::Default for PhysicalDeviceDepthStencilResolveProperties {
    fn default() -> PhysicalDeviceDepthStencilResolveProperties {
        PhysicalDeviceDepthStencilResolveProperties {
            s_type: StructureType::PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES,
            p_next: ::std::ptr::null_mut(),
            supported_depth_resolve_modes: ResolveModeFlags::default(),
            supported_stencil_resolve_modes: ResolveModeFlags::default(),
            independent_resolve_none: Bool32::default(),
            independent_resolve: Bool32::default(),
        }
    }
}
impl PhysicalDeviceDepthStencilResolveProperties {
    pub fn builder<'a>() -> PhysicalDeviceDepthStencilResolvePropertiesBuilder<'a> {
        PhysicalDeviceDepthStencilResolvePropertiesBuilder {
            inner: PhysicalDeviceDepthStencilResolveProperties::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDeviceDepthStencilResolvePropertiesBuilder<'a> {
    inner: PhysicalDeviceDepthStencilResolveProperties,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsPhysicalDeviceProperties2
    for PhysicalDeviceDepthStencilResolvePropertiesBuilder<'_>
{
}
unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceDepthStencilResolveProperties {}
impl<'a> ::std::ops::Deref for PhysicalDeviceDepthStencilResolvePropertiesBuilder<'a> {
    type Target = PhysicalDeviceDepthStencilResolveProperties;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PhysicalDeviceDepthStencilResolvePropertiesBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDeviceDepthStencilResolvePropertiesBuilder<'a> {
    pub fn supported_depth_resolve_modes(
        mut self,
        supported_depth_resolve_modes: ResolveModeFlags,
    ) -> PhysicalDeviceDepthStencilResolvePropertiesBuilder<'a> {
        self.inner.supported_depth_resolve_modes = supported_depth_resolve_modes;
        self
    }
    pub fn supported_stencil_resolve_modes(
        mut self,
        supported_stencil_resolve_modes: ResolveModeFlags,
    ) -> PhysicalDeviceDepthStencilResolvePropertiesBuilder<'a> {
        self.inner.supported_stencil_resolve_modes = supported_stencil_resolve_modes;
        self
    }
    pub fn independent_resolve_none(
        mut self,
        independent_resolve_none: bool,
    ) -> PhysicalDeviceDepthStencilResolvePropertiesBuilder<'a> {
        self.inner.independent_resolve_none = independent_resolve_none.into();
        self
    }
    pub fn independent_resolve(
        mut self,
        independent_resolve: bool,
    ) -> PhysicalDeviceDepthStencilResolvePropertiesBuilder<'a> {
        self.inner.independent_resolve = independent_resolve.into();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDeviceDepthStencilResolveProperties {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSubpassDescriptionDepthStencilResolve.html>"]
pub struct SubpassDescriptionDepthStencilResolve {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub depth_resolve_mode: ResolveModeFlags,
    pub stencil_resolve_mode: ResolveModeFlags,
    pub p_depth_stencil_resolve_attachment: *const AttachmentReference2,
}
impl ::std::default::Default for SubpassDescriptionDepthStencilResolve {
    fn default() -> SubpassDescriptionDepthStencilResolve {
        SubpassDescriptionDepthStencilResolve {
            s_type: StructureType::SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE,
            p_next: ::std::ptr::null(),
            depth_resolve_mode: ResolveModeFlags::default(),
            stencil_resolve_mode: ResolveModeFlags::default(),
            p_depth_stencil_resolve_attachment: ::std::ptr::null(),
        }
    }
}
impl SubpassDescriptionDepthStencilResolve {
    pub fn builder<'a>() -> SubpassDescriptionDepthStencilResolveBuilder<'a> {
        SubpassDescriptionDepthStencilResolveBuilder {
            inner: SubpassDescriptionDepthStencilResolve::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct SubpassDescriptionDepthStencilResolveBuilder<'a> {
    inner: SubpassDescriptionDepthStencilResolve,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsSubpassDescription2 for SubpassDescriptionDepthStencilResolveBuilder<'_> {}
unsafe impl ExtendsSubpassDescription2 for SubpassDescriptionDepthStencilResolve {}
impl<'a> ::std::ops::Deref for SubpassDescriptionDepthStencilResolveBuilder<'a> {
    type Target = SubpassDescriptionDepthStencilResolve;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for SubpassDescriptionDepthStencilResolveBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> SubpassDescriptionDepthStencilResolveBuilder<'a> {
    pub fn depth_resolve_mode(
        mut self,
        depth_resolve_mode: ResolveModeFlags,
    ) -> SubpassDescriptionDepthStencilResolveBuilder<'a> {
        self.inner.depth_resolve_mode = depth_resolve_mode;
        self
    }
    pub fn stencil_resolve_mode(
        mut self,
        stencil_resolve_mode: ResolveModeFlags,
    ) -> SubpassDescriptionDepthStencilResolveBuilder<'a> {
        self.inner.stencil_resolve_mode = stencil_resolve_mode;
        self
    }
    pub fn depth_stencil_resolve_attachment(
        mut self,
        depth_stencil_resolve_attachment: &'a AttachmentReference2,
    ) -> SubpassDescriptionDepthStencilResolveBuilder<'a> {
        self.inner.p_depth_stencil_resolve_attachment = depth_stencil_resolve_attachment;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> SubpassDescriptionDepthStencilResolve {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImageViewASTCDecodeModeEXT.html>"]
pub struct ImageViewASTCDecodeModeEXT {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub decode_mode: Format,
}
impl ::std::default::Default for ImageViewASTCDecodeModeEXT {
    fn default() -> ImageViewASTCDecodeModeEXT {
        ImageViewASTCDecodeModeEXT {
            s_type: StructureType::IMAGE_VIEW_ASTC_DECODE_MODE_EXT,
            p_next: ::std::ptr::null(),
            decode_mode: Format::default(),
        }
    }
}
impl ImageViewASTCDecodeModeEXT {
    pub fn builder<'a>() -> ImageViewASTCDecodeModeEXTBuilder<'a> {
        ImageViewASTCDecodeModeEXTBuilder {
            inner: ImageViewASTCDecodeModeEXT::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct ImageViewASTCDecodeModeEXTBuilder<'a> {
    inner: ImageViewASTCDecodeModeEXT,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsImageViewCreateInfo for ImageViewASTCDecodeModeEXTBuilder<'_> {}
unsafe impl ExtendsImageViewCreateInfo for ImageViewASTCDecodeModeEXT {}
impl<'a> ::std::ops::Deref for ImageViewASTCDecodeModeEXTBuilder<'a> {
    type Target = ImageViewASTCDecodeModeEXT;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for ImageViewASTCDecodeModeEXTBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> ImageViewASTCDecodeModeEXTBuilder<'a> {
    pub fn decode_mode(mut self, decode_mode: Format) -> ImageViewASTCDecodeModeEXTBuilder<'a> {
        self.inner.decode_mode = decode_mode;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> ImageViewASTCDecodeModeEXT {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceASTCDecodeFeaturesEXT.html>"]
pub struct PhysicalDeviceASTCDecodeFeaturesEXT {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub decode_mode_shared_exponent: Bool32,
}
impl ::std::default::Default for PhysicalDeviceASTCDecodeFeaturesEXT {
    fn default() -> PhysicalDeviceASTCDecodeFeaturesEXT {
        PhysicalDeviceASTCDecodeFeaturesEXT {
            s_type: StructureType::PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT,
            p_next: ::std::ptr::null_mut(),
            decode_mode_shared_exponent: Bool32::default(),
        }
    }
}
impl PhysicalDeviceASTCDecodeFeaturesEXT {
    pub fn builder<'a>() -> PhysicalDeviceASTCDecodeFeaturesEXTBuilder<'a> {
        PhysicalDeviceASTCDecodeFeaturesEXTBuilder {
            inner: PhysicalDeviceASTCDecodeFeaturesEXT::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDeviceASTCDecodeFeaturesEXTBuilder<'a> {
    inner: PhysicalDeviceASTCDecodeFeaturesEXT,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceASTCDecodeFeaturesEXTBuilder<'_> {}
unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceASTCDecodeFeaturesEXT {}
impl<'a> ::std::ops::Deref for PhysicalDeviceASTCDecodeFeaturesEXTBuilder<'a> {
    type Target = PhysicalDeviceASTCDecodeFeaturesEXT;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PhysicalDeviceASTCDecodeFeaturesEXTBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDeviceASTCDecodeFeaturesEXTBuilder<'a> {
    pub fn decode_mode_shared_exponent(
        mut self,
        decode_mode_shared_exponent: bool,
    ) -> PhysicalDeviceASTCDecodeFeaturesEXTBuilder<'a> {
        self.inner.decode_mode_shared_exponent = decode_mode_shared_exponent.into();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDeviceASTCDecodeFeaturesEXT {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceTransformFeedbackFeaturesEXT.html>"]
pub struct PhysicalDeviceTransformFeedbackFeaturesEXT {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub transform_feedback: Bool32,
    pub geometry_streams: Bool32,
}
impl ::std::default::Default for PhysicalDeviceTransformFeedbackFeaturesEXT {
    fn default() -> PhysicalDeviceTransformFeedbackFeaturesEXT {
        PhysicalDeviceTransformFeedbackFeaturesEXT {
            s_type: StructureType::PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT,
            p_next: ::std::ptr::null_mut(),
            transform_feedback: Bool32::default(),
            geometry_streams: Bool32::default(),
        }
    }
}
impl PhysicalDeviceTransformFeedbackFeaturesEXT {
    pub fn builder<'a>() -> PhysicalDeviceTransformFeedbackFeaturesEXTBuilder<'a> {
        PhysicalDeviceTransformFeedbackFeaturesEXTBuilder {
            inner: PhysicalDeviceTransformFeedbackFeaturesEXT::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDeviceTransformFeedbackFeaturesEXTBuilder<'a> {
    inner: PhysicalDeviceTransformFeedbackFeaturesEXT,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceTransformFeedbackFeaturesEXTBuilder<'_> {}
unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceTransformFeedbackFeaturesEXT {}
impl<'a> ::std::ops::Deref for PhysicalDeviceTransformFeedbackFeaturesEXTBuilder<'a> {
    type Target = PhysicalDeviceTransformFeedbackFeaturesEXT;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PhysicalDeviceTransformFeedbackFeaturesEXTBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDeviceTransformFeedbackFeaturesEXTBuilder<'a> {
    pub fn transform_feedback(
        mut self,
        transform_feedback: bool,
    ) -> PhysicalDeviceTransformFeedbackFeaturesEXTBuilder<'a> {
        self.inner.transform_feedback = transform_feedback.into();
        self
    }
    pub fn geometry_streams(
        mut self,
        geometry_streams: bool,
    ) -> PhysicalDeviceTransformFeedbackFeaturesEXTBuilder<'a> {
        self.inner.geometry_streams = geometry_streams.into();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDeviceTransformFeedbackFeaturesEXT {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceTransformFeedbackPropertiesEXT.html>"]
pub struct PhysicalDeviceTransformFeedbackPropertiesEXT {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub max_transform_feedback_streams: u32,
    pub max_transform_feedback_buffers: u32,
    pub max_transform_feedback_buffer_size: DeviceSize,
    pub max_transform_feedback_stream_data_size: u32,
    pub max_transform_feedback_buffer_data_size: u32,
    pub max_transform_feedback_buffer_data_stride: u32,
    pub transform_feedback_queries: Bool32,
    pub transform_feedback_streams_lines_triangles: Bool32,
    pub transform_feedback_rasterization_stream_select: Bool32,
    pub transform_feedback_draw: Bool32,
}
impl ::std::default::Default for PhysicalDeviceTransformFeedbackPropertiesEXT {
    fn default() -> PhysicalDeviceTransformFeedbackPropertiesEXT {
        PhysicalDeviceTransformFeedbackPropertiesEXT {
            s_type: StructureType::PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT,
            p_next: ::std::ptr::null_mut(),
            max_transform_feedback_streams: u32::default(),
            max_transform_feedback_buffers: u32::default(),
            max_transform_feedback_buffer_size: DeviceSize::default(),
            max_transform_feedback_stream_data_size: u32::default(),
            max_transform_feedback_buffer_data_size: u32::default(),
            max_transform_feedback_buffer_data_stride: u32::default(),
            transform_feedback_queries: Bool32::default(),
            transform_feedback_streams_lines_triangles: Bool32::default(),
            transform_feedback_rasterization_stream_select: Bool32::default(),
            transform_feedback_draw: Bool32::default(),
        }
    }
}
impl PhysicalDeviceTransformFeedbackPropertiesEXT {
    pub fn builder<'a>() -> PhysicalDeviceTransformFeedbackPropertiesEXTBuilder<'a> {
        PhysicalDeviceTransformFeedbackPropertiesEXTBuilder {
            inner: PhysicalDeviceTransformFeedbackPropertiesEXT::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDeviceTransformFeedbackPropertiesEXTBuilder<'a> {
    inner: PhysicalDeviceTransformFeedbackPropertiesEXT,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsPhysicalDeviceProperties2
    for PhysicalDeviceTransformFeedbackPropertiesEXTBuilder<'_>
{
}
unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceTransformFeedbackPropertiesEXT {}
impl<'a> ::std::ops::Deref for PhysicalDeviceTransformFeedbackPropertiesEXTBuilder<'a> {
    type Target = PhysicalDeviceTransformFeedbackPropertiesEXT;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PhysicalDeviceTransformFeedbackPropertiesEXTBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDeviceTransformFeedbackPropertiesEXTBuilder<'a> {
    pub fn max_transform_feedback_streams(
        mut self,
        max_transform_feedback_streams: u32,
    ) -> PhysicalDeviceTransformFeedbackPropertiesEXTBuilder<'a> {
        self.inner.max_transform_feedback_streams = max_transform_feedback_streams;
        self
    }
    pub fn max_transform_feedback_buffers(
        mut self,
        max_transform_feedback_buffers: u32,
    ) -> PhysicalDeviceTransformFeedbackPropertiesEXTBuilder<'a> {
        self.inner.max_transform_feedback_buffers = max_transform_feedback_buffers;
        self
    }
    pub fn max_transform_feedback_buffer_size(
        mut self,
        max_transform_feedback_buffer_size: DeviceSize,
    ) -> PhysicalDeviceTransformFeedbackPropertiesEXTBuilder<'a> {
        self.inner.max_transform_feedback_buffer_size = max_transform_feedback_buffer_size;
        self
    }
    pub fn max_transform_feedback_stream_data_size(
        mut self,
        max_transform_feedback_stream_data_size: u32,
    ) -> PhysicalDeviceTransformFeedbackPropertiesEXTBuilder<'a> {
        self.inner.max_transform_feedback_stream_data_size =
            max_transform_feedback_stream_data_size;
        self
    }
    pub fn max_transform_feedback_buffer_data_size(
        mut self,
        max_transform_feedback_buffer_data_size: u32,
    ) -> PhysicalDeviceTransformFeedbackPropertiesEXTBuilder<'a> {
        self.inner.max_transform_feedback_buffer_data_size =
            max_transform_feedback_buffer_data_size;
        self
    }
    pub fn max_transform_feedback_buffer_data_stride(
        mut self,
        max_transform_feedback_buffer_data_stride: u32,
    ) -> PhysicalDeviceTransformFeedbackPropertiesEXTBuilder<'a> {
        self.inner.max_transform_feedback_buffer_data_stride =
            max_transform_feedback_buffer_data_stride;
        self
    }
    pub fn transform_feedback_queries(
        mut self,
        transform_feedback_queries: bool,
    ) -> PhysicalDeviceTransformFeedbackPropertiesEXTBuilder<'a> {
        self.inner.transform_feedback_queries = transform_feedback_queries.into();
        self
    }
    pub fn transform_feedback_streams_lines_triangles(
        mut self,
        transform_feedback_streams_lines_triangles: bool,
    ) -> PhysicalDeviceTransformFeedbackPropertiesEXTBuilder<'a> {
        self.inner.transform_feedback_streams_lines_triangles =
            transform_feedback_streams_lines_triangles.into();
        self
    }
    pub fn transform_feedback_rasterization_stream_select(
        mut self,
        transform_feedback_rasterization_stream_select: bool,
    ) -> PhysicalDeviceTransformFeedbackPropertiesEXTBuilder<'a> {
        self.inner.transform_feedback_rasterization_stream_select =
            transform_feedback_rasterization_stream_select.into();
        self
    }
    pub fn transform_feedback_draw(
        mut self,
        transform_feedback_draw: bool,
    ) -> PhysicalDeviceTransformFeedbackPropertiesEXTBuilder<'a> {
        self.inner.transform_feedback_draw = transform_feedback_draw.into();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDeviceTransformFeedbackPropertiesEXT {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineRasterizationStateStreamCreateInfoEXT.html>"]
pub struct PipelineRasterizationStateStreamCreateInfoEXT {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub flags: PipelineRasterizationStateStreamCreateFlagsEXT,
    pub rasterization_stream: u32,
}
impl ::std::default::Default for PipelineRasterizationStateStreamCreateInfoEXT {
    fn default() -> PipelineRasterizationStateStreamCreateInfoEXT {
        PipelineRasterizationStateStreamCreateInfoEXT {
            s_type: StructureType::PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT,
            p_next: ::std::ptr::null(),
            flags: PipelineRasterizationStateStreamCreateFlagsEXT::default(),
            rasterization_stream: u32::default(),
        }
    }
}
impl PipelineRasterizationStateStreamCreateInfoEXT {
    pub fn builder<'a>() -> PipelineRasterizationStateStreamCreateInfoEXTBuilder<'a> {
        PipelineRasterizationStateStreamCreateInfoEXTBuilder {
            inner: PipelineRasterizationStateStreamCreateInfoEXT::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PipelineRasterizationStateStreamCreateInfoEXTBuilder<'a> {
    inner: PipelineRasterizationStateStreamCreateInfoEXT,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsPipelineRasterizationStateCreateInfo
    for PipelineRasterizationStateStreamCreateInfoEXTBuilder<'_>
{
}
unsafe impl ExtendsPipelineRasterizationStateCreateInfo
    for PipelineRasterizationStateStreamCreateInfoEXT
{
}
impl<'a> ::std::ops::Deref for PipelineRasterizationStateStreamCreateInfoEXTBuilder<'a> {
    type Target = PipelineRasterizationStateStreamCreateInfoEXT;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PipelineRasterizationStateStreamCreateInfoEXTBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PipelineRasterizationStateStreamCreateInfoEXTBuilder<'a> {
    pub fn flags(
        mut self,
        flags: PipelineRasterizationStateStreamCreateFlagsEXT,
    ) -> PipelineRasterizationStateStreamCreateInfoEXTBuilder<'a> {
        self.inner.flags = flags;
        self
    }
    pub fn rasterization_stream(
        mut self,
        rasterization_stream: u32,
    ) -> PipelineRasterizationStateStreamCreateInfoEXTBuilder<'a> {
        self.inner.rasterization_stream = rasterization_stream;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PipelineRasterizationStateStreamCreateInfoEXT {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV.html>"]
pub struct PhysicalDeviceRepresentativeFragmentTestFeaturesNV {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub representative_fragment_test: Bool32,
}
impl ::std::default::Default for PhysicalDeviceRepresentativeFragmentTestFeaturesNV {
    fn default() -> PhysicalDeviceRepresentativeFragmentTestFeaturesNV {
        PhysicalDeviceRepresentativeFragmentTestFeaturesNV {
            s_type: StructureType::PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV,
            p_next: ::std::ptr::null_mut(),
            representative_fragment_test: Bool32::default(),
        }
    }
}
impl PhysicalDeviceRepresentativeFragmentTestFeaturesNV {
    pub fn builder<'a>() -> PhysicalDeviceRepresentativeFragmentTestFeaturesNVBuilder<'a> {
        PhysicalDeviceRepresentativeFragmentTestFeaturesNVBuilder {
            inner: PhysicalDeviceRepresentativeFragmentTestFeaturesNV::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDeviceRepresentativeFragmentTestFeaturesNVBuilder<'a> {
    inner: PhysicalDeviceRepresentativeFragmentTestFeaturesNV,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsDeviceCreateInfo
    for PhysicalDeviceRepresentativeFragmentTestFeaturesNVBuilder<'_>
{
}
unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRepresentativeFragmentTestFeaturesNV {}
impl<'a> ::std::ops::Deref for PhysicalDeviceRepresentativeFragmentTestFeaturesNVBuilder<'a> {
    type Target = PhysicalDeviceRepresentativeFragmentTestFeaturesNV;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PhysicalDeviceRepresentativeFragmentTestFeaturesNVBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDeviceRepresentativeFragmentTestFeaturesNVBuilder<'a> {
    pub fn representative_fragment_test(
        mut self,
        representative_fragment_test: bool,
    ) -> PhysicalDeviceRepresentativeFragmentTestFeaturesNVBuilder<'a> {
        self.inner.representative_fragment_test = representative_fragment_test.into();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDeviceRepresentativeFragmentTestFeaturesNV {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineRepresentativeFragmentTestStateCreateInfoNV.html>"]
pub struct PipelineRepresentativeFragmentTestStateCreateInfoNV {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub representative_fragment_test_enable: Bool32,
}
impl ::std::default::Default for PipelineRepresentativeFragmentTestStateCreateInfoNV {
    fn default() -> PipelineRepresentativeFragmentTestStateCreateInfoNV {
        PipelineRepresentativeFragmentTestStateCreateInfoNV {
            s_type: StructureType::PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV,
            p_next: ::std::ptr::null(),
            representative_fragment_test_enable: Bool32::default(),
        }
    }
}
impl PipelineRepresentativeFragmentTestStateCreateInfoNV {
    pub fn builder<'a>() -> PipelineRepresentativeFragmentTestStateCreateInfoNVBuilder<'a> {
        PipelineRepresentativeFragmentTestStateCreateInfoNVBuilder {
            inner: PipelineRepresentativeFragmentTestStateCreateInfoNV::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PipelineRepresentativeFragmentTestStateCreateInfoNVBuilder<'a> {
    inner: PipelineRepresentativeFragmentTestStateCreateInfoNV,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsGraphicsPipelineCreateInfo
    for PipelineRepresentativeFragmentTestStateCreateInfoNVBuilder<'_>
{
}
unsafe impl ExtendsGraphicsPipelineCreateInfo
    for PipelineRepresentativeFragmentTestStateCreateInfoNV
{
}
impl<'a> ::std::ops::Deref for PipelineRepresentativeFragmentTestStateCreateInfoNVBuilder<'a> {
    type Target = PipelineRepresentativeFragmentTestStateCreateInfoNV;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PipelineRepresentativeFragmentTestStateCreateInfoNVBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PipelineRepresentativeFragmentTestStateCreateInfoNVBuilder<'a> {
    pub fn representative_fragment_test_enable(
        mut self,
        representative_fragment_test_enable: bool,
    ) -> PipelineRepresentativeFragmentTestStateCreateInfoNVBuilder<'a> {
        self.inner.representative_fragment_test_enable = representative_fragment_test_enable.into();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PipelineRepresentativeFragmentTestStateCreateInfoNV {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceExclusiveScissorFeaturesNV.html>"]
pub struct PhysicalDeviceExclusiveScissorFeaturesNV {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub exclusive_scissor: Bool32,
}
impl ::std::default::Default for PhysicalDeviceExclusiveScissorFeaturesNV {
    fn default() -> PhysicalDeviceExclusiveScissorFeaturesNV {
        PhysicalDeviceExclusiveScissorFeaturesNV {
            s_type: StructureType::PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV,
            p_next: ::std::ptr::null_mut(),
            exclusive_scissor: Bool32::default(),
        }
    }
}
impl PhysicalDeviceExclusiveScissorFeaturesNV {
    pub fn builder<'a>() -> PhysicalDeviceExclusiveScissorFeaturesNVBuilder<'a> {
        PhysicalDeviceExclusiveScissorFeaturesNVBuilder {
            inner: PhysicalDeviceExclusiveScissorFeaturesNV::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDeviceExclusiveScissorFeaturesNVBuilder<'a> {
    inner: PhysicalDeviceExclusiveScissorFeaturesNV,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceExclusiveScissorFeaturesNVBuilder<'_> {}
unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceExclusiveScissorFeaturesNV {}
impl<'a> ::std::ops::Deref for PhysicalDeviceExclusiveScissorFeaturesNVBuilder<'a> {
    type Target = PhysicalDeviceExclusiveScissorFeaturesNV;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PhysicalDeviceExclusiveScissorFeaturesNVBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDeviceExclusiveScissorFeaturesNVBuilder<'a> {
    pub fn exclusive_scissor(
        mut self,
        exclusive_scissor: bool,
    ) -> PhysicalDeviceExclusiveScissorFeaturesNVBuilder<'a> {
        self.inner.exclusive_scissor = exclusive_scissor.into();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDeviceExclusiveScissorFeaturesNV {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineViewportExclusiveScissorStateCreateInfoNV.html>"]
pub struct PipelineViewportExclusiveScissorStateCreateInfoNV {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub exclusive_scissor_count: u32,
    pub p_exclusive_scissors: *const Rect2D,
}
impl ::std::default::Default for PipelineViewportExclusiveScissorStateCreateInfoNV {
    fn default() -> PipelineViewportExclusiveScissorStateCreateInfoNV {
        PipelineViewportExclusiveScissorStateCreateInfoNV {
            s_type: StructureType::PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV,
            p_next: ::std::ptr::null(),
            exclusive_scissor_count: u32::default(),
            p_exclusive_scissors: ::std::ptr::null(),
        }
    }
}
impl PipelineViewportExclusiveScissorStateCreateInfoNV {
    pub fn builder<'a>() -> PipelineViewportExclusiveScissorStateCreateInfoNVBuilder<'a> {
        PipelineViewportExclusiveScissorStateCreateInfoNVBuilder {
            inner: PipelineViewportExclusiveScissorStateCreateInfoNV::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PipelineViewportExclusiveScissorStateCreateInfoNVBuilder<'a> {
    inner: PipelineViewportExclusiveScissorStateCreateInfoNV,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsPipelineViewportStateCreateInfo
    for PipelineViewportExclusiveScissorStateCreateInfoNVBuilder<'_>
{
}
unsafe impl ExtendsPipelineViewportStateCreateInfo
    for PipelineViewportExclusiveScissorStateCreateInfoNV
{
}
impl<'a> ::std::ops::Deref for PipelineViewportExclusiveScissorStateCreateInfoNVBuilder<'a> {
    type Target = PipelineViewportExclusiveScissorStateCreateInfoNV;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PipelineViewportExclusiveScissorStateCreateInfoNVBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PipelineViewportExclusiveScissorStateCreateInfoNVBuilder<'a> {
    pub fn exclusive_scissors(
        mut self,
        exclusive_scissors: &'a [Rect2D],
    ) -> PipelineViewportExclusiveScissorStateCreateInfoNVBuilder<'a> {
        self.inner.exclusive_scissor_count = exclusive_scissors.len() as _;
        self.inner.p_exclusive_scissors = exclusive_scissors.as_ptr();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PipelineViewportExclusiveScissorStateCreateInfoNV {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceCornerSampledImageFeaturesNV.html>"]
pub struct PhysicalDeviceCornerSampledImageFeaturesNV {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub corner_sampled_image: Bool32,
}
impl ::std::default::Default for PhysicalDeviceCornerSampledImageFeaturesNV {
    fn default() -> PhysicalDeviceCornerSampledImageFeaturesNV {
        PhysicalDeviceCornerSampledImageFeaturesNV {
            s_type: StructureType::PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV,
            p_next: ::std::ptr::null_mut(),
            corner_sampled_image: Bool32::default(),
        }
    }
}
impl PhysicalDeviceCornerSampledImageFeaturesNV {
    pub fn builder<'a>() -> PhysicalDeviceCornerSampledImageFeaturesNVBuilder<'a> {
        PhysicalDeviceCornerSampledImageFeaturesNVBuilder {
            inner: PhysicalDeviceCornerSampledImageFeaturesNV::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDeviceCornerSampledImageFeaturesNVBuilder<'a> {
    inner: PhysicalDeviceCornerSampledImageFeaturesNV,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceCornerSampledImageFeaturesNVBuilder<'_> {}
unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceCornerSampledImageFeaturesNV {}
impl<'a> ::std::ops::Deref for PhysicalDeviceCornerSampledImageFeaturesNVBuilder<'a> {
    type Target = PhysicalDeviceCornerSampledImageFeaturesNV;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PhysicalDeviceCornerSampledImageFeaturesNVBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDeviceCornerSampledImageFeaturesNVBuilder<'a> {
    pub fn corner_sampled_image(
        mut self,
        corner_sampled_image: bool,
    ) -> PhysicalDeviceCornerSampledImageFeaturesNVBuilder<'a> {
        self.inner.corner_sampled_image = corner_sampled_image.into();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDeviceCornerSampledImageFeaturesNV {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceComputeShaderDerivativesFeaturesNV.html>"]
pub struct PhysicalDeviceComputeShaderDerivativesFeaturesNV {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub compute_derivative_group_quads: Bool32,
    pub compute_derivative_group_linear: Bool32,
}
impl ::std::default::Default for PhysicalDeviceComputeShaderDerivativesFeaturesNV {
    fn default() -> PhysicalDeviceComputeShaderDerivativesFeaturesNV {
        PhysicalDeviceComputeShaderDerivativesFeaturesNV {
            s_type: StructureType::PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV,
            p_next: ::std::ptr::null_mut(),
            compute_derivative_group_quads: Bool32::default(),
            compute_derivative_group_linear: Bool32::default(),
        }
    }
}
impl PhysicalDeviceComputeShaderDerivativesFeaturesNV {
    pub fn builder<'a>() -> PhysicalDeviceComputeShaderDerivativesFeaturesNVBuilder<'a> {
        PhysicalDeviceComputeShaderDerivativesFeaturesNVBuilder {
            inner: PhysicalDeviceComputeShaderDerivativesFeaturesNV::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDeviceComputeShaderDerivativesFeaturesNVBuilder<'a> {
    inner: PhysicalDeviceComputeShaderDerivativesFeaturesNV,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsDeviceCreateInfo
    for PhysicalDeviceComputeShaderDerivativesFeaturesNVBuilder<'_>
{
}
unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceComputeShaderDerivativesFeaturesNV {}
impl<'a> ::std::ops::Deref for PhysicalDeviceComputeShaderDerivativesFeaturesNVBuilder<'a> {
    type Target = PhysicalDeviceComputeShaderDerivativesFeaturesNV;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PhysicalDeviceComputeShaderDerivativesFeaturesNVBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDeviceComputeShaderDerivativesFeaturesNVBuilder<'a> {
    pub fn compute_derivative_group_quads(
        mut self,
        compute_derivative_group_quads: bool,
    ) -> PhysicalDeviceComputeShaderDerivativesFeaturesNVBuilder<'a> {
        self.inner.compute_derivative_group_quads = compute_derivative_group_quads.into();
        self
    }
    pub fn compute_derivative_group_linear(
        mut self,
        compute_derivative_group_linear: bool,
    ) -> PhysicalDeviceComputeShaderDerivativesFeaturesNVBuilder<'a> {
        self.inner.compute_derivative_group_linear = compute_derivative_group_linear.into();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDeviceComputeShaderDerivativesFeaturesNV {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV.html>"]
pub struct PhysicalDeviceFragmentShaderBarycentricFeaturesNV {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub fragment_shader_barycentric: Bool32,
}
impl ::std::default::Default for PhysicalDeviceFragmentShaderBarycentricFeaturesNV {
    fn default() -> PhysicalDeviceFragmentShaderBarycentricFeaturesNV {
        PhysicalDeviceFragmentShaderBarycentricFeaturesNV {
            s_type: StructureType::PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV,
            p_next: ::std::ptr::null_mut(),
            fragment_shader_barycentric: Bool32::default(),
        }
    }
}
impl PhysicalDeviceFragmentShaderBarycentricFeaturesNV {
    pub fn builder<'a>() -> PhysicalDeviceFragmentShaderBarycentricFeaturesNVBuilder<'a> {
        PhysicalDeviceFragmentShaderBarycentricFeaturesNVBuilder {
            inner: PhysicalDeviceFragmentShaderBarycentricFeaturesNV::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDeviceFragmentShaderBarycentricFeaturesNVBuilder<'a> {
    inner: PhysicalDeviceFragmentShaderBarycentricFeaturesNV,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsDeviceCreateInfo
    for PhysicalDeviceFragmentShaderBarycentricFeaturesNVBuilder<'_>
{
}
unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentShaderBarycentricFeaturesNV {}
impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentShaderBarycentricFeaturesNVBuilder<'a> {
    type Target = PhysicalDeviceFragmentShaderBarycentricFeaturesNV;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentShaderBarycentricFeaturesNVBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDeviceFragmentShaderBarycentricFeaturesNVBuilder<'a> {
    pub fn fragment_shader_barycentric(
        mut self,
        fragment_shader_barycentric: bool,
    ) -> PhysicalDeviceFragmentShaderBarycentricFeaturesNVBuilder<'a> {
        self.inner.fragment_shader_barycentric = fragment_shader_barycentric.into();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDeviceFragmentShaderBarycentricFeaturesNV {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceShaderImageFootprintFeaturesNV.html>"]
pub struct PhysicalDeviceShaderImageFootprintFeaturesNV {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub image_footprint: Bool32,
}
impl ::std::default::Default for PhysicalDeviceShaderImageFootprintFeaturesNV {
    fn default() -> PhysicalDeviceShaderImageFootprintFeaturesNV {
        PhysicalDeviceShaderImageFootprintFeaturesNV {
            s_type: StructureType::PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV,
            p_next: ::std::ptr::null_mut(),
            image_footprint: Bool32::default(),
        }
    }
}
impl PhysicalDeviceShaderImageFootprintFeaturesNV {
    pub fn builder<'a>() -> PhysicalDeviceShaderImageFootprintFeaturesNVBuilder<'a> {
        PhysicalDeviceShaderImageFootprintFeaturesNVBuilder {
            inner: PhysicalDeviceShaderImageFootprintFeaturesNV::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDeviceShaderImageFootprintFeaturesNVBuilder<'a> {
    inner: PhysicalDeviceShaderImageFootprintFeaturesNV,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderImageFootprintFeaturesNVBuilder<'_> {}
unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderImageFootprintFeaturesNV {}
impl<'a> ::std::ops::Deref for PhysicalDeviceShaderImageFootprintFeaturesNVBuilder<'a> {
    type Target = PhysicalDeviceShaderImageFootprintFeaturesNV;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderImageFootprintFeaturesNVBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDeviceShaderImageFootprintFeaturesNVBuilder<'a> {
    pub fn image_footprint(
        mut self,
        image_footprint: bool,
    ) -> PhysicalDeviceShaderImageFootprintFeaturesNVBuilder<'a> {
        self.inner.image_footprint = image_footprint.into();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDeviceShaderImageFootprintFeaturesNV {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV.html>"]
pub struct PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub dedicated_allocation_image_aliasing: Bool32,
}
impl ::std::default::Default for PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV {
    fn default() -> PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV {
        PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV {
            s_type: StructureType::PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV,
            p_next: ::std::ptr::null_mut(),
            dedicated_allocation_image_aliasing: Bool32::default(),
        }
    }
}
impl PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV {
    pub fn builder<'a>() -> PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNVBuilder<'a> {
        PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNVBuilder {
            inner: PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNVBuilder<'a> {
    inner: PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsDeviceCreateInfo
    for PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNVBuilder<'_>
{
}
unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV {}
impl<'a> ::std::ops::Deref for PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNVBuilder<'a> {
    type Target = PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut
    for PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNVBuilder<'a>
{
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNVBuilder<'a> {
    pub fn dedicated_allocation_image_aliasing(
        mut self,
        dedicated_allocation_image_aliasing: bool,
    ) -> PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNVBuilder<'a> {
        self.inner.dedicated_allocation_image_aliasing = dedicated_allocation_image_aliasing.into();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkShadingRatePaletteNV.html>"]
pub struct ShadingRatePaletteNV {
    pub shading_rate_palette_entry_count: u32,
    pub p_shading_rate_palette_entries: *const ShadingRatePaletteEntryNV,
}
impl ::std::default::Default for ShadingRatePaletteNV {
    fn default() -> ShadingRatePaletteNV {
        ShadingRatePaletteNV {
            shading_rate_palette_entry_count: u32::default(),
            p_shading_rate_palette_entries: ::std::ptr::null(),
        }
    }
}
impl ShadingRatePaletteNV {
    pub fn builder<'a>() -> ShadingRatePaletteNVBuilder<'a> {
        ShadingRatePaletteNVBuilder {
            inner: ShadingRatePaletteNV::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct ShadingRatePaletteNVBuilder<'a> {
    inner: ShadingRatePaletteNV,
    marker: ::std::marker::PhantomData<&'a ()>,
}
impl<'a> ::std::ops::Deref for ShadingRatePaletteNVBuilder<'a> {
    type Target = ShadingRatePaletteNV;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for ShadingRatePaletteNVBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> ShadingRatePaletteNVBuilder<'a> {
    pub fn shading_rate_palette_entries(
        mut self,
        shading_rate_palette_entries: &'a [ShadingRatePaletteEntryNV],
    ) -> ShadingRatePaletteNVBuilder<'a> {
        self.inner.shading_rate_palette_entry_count = shading_rate_palette_entries.len() as _;
        self.inner.p_shading_rate_palette_entries = shading_rate_palette_entries.as_ptr();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> ShadingRatePaletteNV {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineViewportShadingRateImageStateCreateInfoNV.html>"]
pub struct PipelineViewportShadingRateImageStateCreateInfoNV {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub shading_rate_image_enable: Bool32,
    pub viewport_count: u32,
    pub p_shading_rate_palettes: *const ShadingRatePaletteNV,
}
impl ::std::default::Default for PipelineViewportShadingRateImageStateCreateInfoNV {
    fn default() -> PipelineViewportShadingRateImageStateCreateInfoNV {
        PipelineViewportShadingRateImageStateCreateInfoNV {
            s_type: StructureType::PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV,
            p_next: ::std::ptr::null(),
            shading_rate_image_enable: Bool32::default(),
            viewport_count: u32::default(),
            p_shading_rate_palettes: ::std::ptr::null(),
        }
    }
}
impl PipelineViewportShadingRateImageStateCreateInfoNV {
    pub fn builder<'a>() -> PipelineViewportShadingRateImageStateCreateInfoNVBuilder<'a> {
        PipelineViewportShadingRateImageStateCreateInfoNVBuilder {
            inner: PipelineViewportShadingRateImageStateCreateInfoNV::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PipelineViewportShadingRateImageStateCreateInfoNVBuilder<'a> {
    inner: PipelineViewportShadingRateImageStateCreateInfoNV,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsPipelineViewportStateCreateInfo
    for PipelineViewportShadingRateImageStateCreateInfoNVBuilder<'_>
{
}
unsafe impl ExtendsPipelineViewportStateCreateInfo
    for PipelineViewportShadingRateImageStateCreateInfoNV
{
}
impl<'a> ::std::ops::Deref for PipelineViewportShadingRateImageStateCreateInfoNVBuilder<'a> {
    type Target = PipelineViewportShadingRateImageStateCreateInfoNV;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PipelineViewportShadingRateImageStateCreateInfoNVBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PipelineViewportShadingRateImageStateCreateInfoNVBuilder<'a> {
    pub fn shading_rate_image_enable(
        mut self,
        shading_rate_image_enable: bool,
    ) -> PipelineViewportShadingRateImageStateCreateInfoNVBuilder<'a> {
        self.inner.shading_rate_image_enable = shading_rate_image_enable.into();
        self
    }
    pub fn shading_rate_palettes(
        mut self,
        shading_rate_palettes: &'a [ShadingRatePaletteNV],
    ) -> PipelineViewportShadingRateImageStateCreateInfoNVBuilder<'a> {
        self.inner.viewport_count = shading_rate_palettes.len() as _;
        self.inner.p_shading_rate_palettes = shading_rate_palettes.as_ptr();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PipelineViewportShadingRateImageStateCreateInfoNV {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceShadingRateImageFeaturesNV.html>"]
pub struct PhysicalDeviceShadingRateImageFeaturesNV {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub shading_rate_image: Bool32,
    pub shading_rate_coarse_sample_order: Bool32,
}
impl ::std::default::Default for PhysicalDeviceShadingRateImageFeaturesNV {
    fn default() -> PhysicalDeviceShadingRateImageFeaturesNV {
        PhysicalDeviceShadingRateImageFeaturesNV {
            s_type: StructureType::PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV,
            p_next: ::std::ptr::null_mut(),
            shading_rate_image: Bool32::default(),
            shading_rate_coarse_sample_order: Bool32::default(),
        }
    }
}
impl PhysicalDeviceShadingRateImageFeaturesNV {
    pub fn builder<'a>() -> PhysicalDeviceShadingRateImageFeaturesNVBuilder<'a> {
        PhysicalDeviceShadingRateImageFeaturesNVBuilder {
            inner: PhysicalDeviceShadingRateImageFeaturesNV::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDeviceShadingRateImageFeaturesNVBuilder<'a> {
    inner: PhysicalDeviceShadingRateImageFeaturesNV,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShadingRateImageFeaturesNVBuilder<'_> {}
unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShadingRateImageFeaturesNV {}
impl<'a> ::std::ops::Deref for PhysicalDeviceShadingRateImageFeaturesNVBuilder<'a> {
    type Target = PhysicalDeviceShadingRateImageFeaturesNV;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PhysicalDeviceShadingRateImageFeaturesNVBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDeviceShadingRateImageFeaturesNVBuilder<'a> {
    pub fn shading_rate_image(
        mut self,
        shading_rate_image: bool,
    ) -> PhysicalDeviceShadingRateImageFeaturesNVBuilder<'a> {
        self.inner.shading_rate_image = shading_rate_image.into();
        self
    }
    pub fn shading_rate_coarse_sample_order(
        mut self,
        shading_rate_coarse_sample_order: bool,
    ) -> PhysicalDeviceShadingRateImageFeaturesNVBuilder<'a> {
        self.inner.shading_rate_coarse_sample_order = shading_rate_coarse_sample_order.into();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDeviceShadingRateImageFeaturesNV {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceShadingRateImagePropertiesNV.html>"]
pub struct PhysicalDeviceShadingRateImagePropertiesNV {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub shading_rate_texel_size: Extent2D,
    pub shading_rate_palette_size: u32,
    pub shading_rate_max_coarse_samples: u32,
}
impl ::std::default::Default for PhysicalDeviceShadingRateImagePropertiesNV {
    fn default() -> PhysicalDeviceShadingRateImagePropertiesNV {
        PhysicalDeviceShadingRateImagePropertiesNV {
            s_type: StructureType::PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV,
            p_next: ::std::ptr::null_mut(),
            shading_rate_texel_size: Extent2D::default(),
            shading_rate_palette_size: u32::default(),
            shading_rate_max_coarse_samples: u32::default(),
        }
    }
}
impl PhysicalDeviceShadingRateImagePropertiesNV {
    pub fn builder<'a>() -> PhysicalDeviceShadingRateImagePropertiesNVBuilder<'a> {
        PhysicalDeviceShadingRateImagePropertiesNVBuilder {
            inner: PhysicalDeviceShadingRateImagePropertiesNV::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDeviceShadingRateImagePropertiesNVBuilder<'a> {
    inner: PhysicalDeviceShadingRateImagePropertiesNV,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsPhysicalDeviceProperties2
    for PhysicalDeviceShadingRateImagePropertiesNVBuilder<'_>
{
}
unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceShadingRateImagePropertiesNV {}
impl<'a> ::std::ops::Deref for PhysicalDeviceShadingRateImagePropertiesNVBuilder<'a> {
    type Target = PhysicalDeviceShadingRateImagePropertiesNV;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PhysicalDeviceShadingRateImagePropertiesNVBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDeviceShadingRateImagePropertiesNVBuilder<'a> {
    pub fn shading_rate_texel_size(
        mut self,
        shading_rate_texel_size: Extent2D,
    ) -> PhysicalDeviceShadingRateImagePropertiesNVBuilder<'a> {
        self.inner.shading_rate_texel_size = shading_rate_texel_size;
        self
    }
    pub fn shading_rate_palette_size(
        mut self,
        shading_rate_palette_size: u32,
    ) -> PhysicalDeviceShadingRateImagePropertiesNVBuilder<'a> {
        self.inner.shading_rate_palette_size = shading_rate_palette_size;
        self
    }
    pub fn shading_rate_max_coarse_samples(
        mut self,
        shading_rate_max_coarse_samples: u32,
    ) -> PhysicalDeviceShadingRateImagePropertiesNVBuilder<'a> {
        self.inner.shading_rate_max_coarse_samples = shading_rate_max_coarse_samples;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDeviceShadingRateImagePropertiesNV {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Default, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCoarseSampleLocationNV.html>"]
pub struct CoarseSampleLocationNV {
    pub pixel_x: u32,
    pub pixel_y: u32,
    pub sample: u32,
}
impl CoarseSampleLocationNV {
    pub fn builder<'a>() -> CoarseSampleLocationNVBuilder<'a> {
        CoarseSampleLocationNVBuilder {
            inner: CoarseSampleLocationNV::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct CoarseSampleLocationNVBuilder<'a> {
    inner: CoarseSampleLocationNV,
    marker: ::std::marker::PhantomData<&'a ()>,
}
impl<'a> ::std::ops::Deref for CoarseSampleLocationNVBuilder<'a> {
    type Target = CoarseSampleLocationNV;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for CoarseSampleLocationNVBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> CoarseSampleLocationNVBuilder<'a> {
    pub fn pixel_x(mut self, pixel_x: u32) -> CoarseSampleLocationNVBuilder<'a> {
        self.inner.pixel_x = pixel_x;
        self
    }
    pub fn pixel_y(mut self, pixel_y: u32) -> CoarseSampleLocationNVBuilder<'a> {
        self.inner.pixel_y = pixel_y;
        self
    }
    pub fn sample(mut self, sample: u32) -> CoarseSampleLocationNVBuilder<'a> {
        self.inner.sample = sample;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> CoarseSampleLocationNV {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCoarseSampleOrderCustomNV.html>"]
pub struct CoarseSampleOrderCustomNV {
    pub shading_rate: ShadingRatePaletteEntryNV,
    pub sample_count: u32,
    pub sample_location_count: u32,
    pub p_sample_locations: *const CoarseSampleLocationNV,
}
impl ::std::default::Default for CoarseSampleOrderCustomNV {
    fn default() -> CoarseSampleOrderCustomNV {
        CoarseSampleOrderCustomNV {
            shading_rate: ShadingRatePaletteEntryNV::default(),
            sample_count: u32::default(),
            sample_location_count: u32::default(),
            p_sample_locations: ::std::ptr::null(),
        }
    }
}
impl CoarseSampleOrderCustomNV {
    pub fn builder<'a>() -> CoarseSampleOrderCustomNVBuilder<'a> {
        CoarseSampleOrderCustomNVBuilder {
            inner: CoarseSampleOrderCustomNV::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct CoarseSampleOrderCustomNVBuilder<'a> {
    inner: CoarseSampleOrderCustomNV,
    marker: ::std::marker::PhantomData<&'a ()>,
}
impl<'a> ::std::ops::Deref for CoarseSampleOrderCustomNVBuilder<'a> {
    type Target = CoarseSampleOrderCustomNV;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for CoarseSampleOrderCustomNVBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> CoarseSampleOrderCustomNVBuilder<'a> {
    pub fn shading_rate(
        mut self,
        shading_rate: ShadingRatePaletteEntryNV,
    ) -> CoarseSampleOrderCustomNVBuilder<'a> {
        self.inner.shading_rate = shading_rate;
        self
    }
    pub fn sample_count(mut self, sample_count: u32) -> CoarseSampleOrderCustomNVBuilder<'a> {
        self.inner.sample_count = sample_count;
        self
    }
    pub fn sample_locations(
        mut self,
        sample_locations: &'a [CoarseSampleLocationNV],
    ) -> CoarseSampleOrderCustomNVBuilder<'a> {
        self.inner.sample_location_count = sample_locations.len() as _;
        self.inner.p_sample_locations = sample_locations.as_ptr();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> CoarseSampleOrderCustomNV {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineViewportCoarseSampleOrderStateCreateInfoNV.html>"]
pub struct PipelineViewportCoarseSampleOrderStateCreateInfoNV {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub sample_order_type: CoarseSampleOrderTypeNV,
    pub custom_sample_order_count: u32,
    pub p_custom_sample_orders: *const CoarseSampleOrderCustomNV,
}
impl ::std::default::Default for PipelineViewportCoarseSampleOrderStateCreateInfoNV {
    fn default() -> PipelineViewportCoarseSampleOrderStateCreateInfoNV {
        PipelineViewportCoarseSampleOrderStateCreateInfoNV {
            s_type: StructureType::PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV,
            p_next: ::std::ptr::null(),
            sample_order_type: CoarseSampleOrderTypeNV::default(),
            custom_sample_order_count: u32::default(),
            p_custom_sample_orders: ::std::ptr::null(),
        }
    }
}
impl PipelineViewportCoarseSampleOrderStateCreateInfoNV {
    pub fn builder<'a>() -> PipelineViewportCoarseSampleOrderStateCreateInfoNVBuilder<'a> {
        PipelineViewportCoarseSampleOrderStateCreateInfoNVBuilder {
            inner: PipelineViewportCoarseSampleOrderStateCreateInfoNV::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PipelineViewportCoarseSampleOrderStateCreateInfoNVBuilder<'a> {
    inner: PipelineViewportCoarseSampleOrderStateCreateInfoNV,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsPipelineViewportStateCreateInfo
    for PipelineViewportCoarseSampleOrderStateCreateInfoNVBuilder<'_>
{
}
unsafe impl ExtendsPipelineViewportStateCreateInfo
    for PipelineViewportCoarseSampleOrderStateCreateInfoNV
{
}
impl<'a> ::std::ops::Deref for PipelineViewportCoarseSampleOrderStateCreateInfoNVBuilder<'a> {
    type Target = PipelineViewportCoarseSampleOrderStateCreateInfoNV;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PipelineViewportCoarseSampleOrderStateCreateInfoNVBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PipelineViewportCoarseSampleOrderStateCreateInfoNVBuilder<'a> {
    pub fn sample_order_type(
        mut self,
        sample_order_type: CoarseSampleOrderTypeNV,
    ) -> PipelineViewportCoarseSampleOrderStateCreateInfoNVBuilder<'a> {
        self.inner.sample_order_type = sample_order_type;
        self
    }
    pub fn custom_sample_orders(
        mut self,
        custom_sample_orders: &'a [CoarseSampleOrderCustomNV],
    ) -> PipelineViewportCoarseSampleOrderStateCreateInfoNVBuilder<'a> {
        self.inner.custom_sample_order_count = custom_sample_orders.len() as _;
        self.inner.p_custom_sample_orders = custom_sample_orders.as_ptr();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PipelineViewportCoarseSampleOrderStateCreateInfoNV {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceMeshShaderFeaturesNV.html>"]
pub struct PhysicalDeviceMeshShaderFeaturesNV {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub task_shader: Bool32,
    pub mesh_shader: Bool32,
}
impl ::std::default::Default for PhysicalDeviceMeshShaderFeaturesNV {
    fn default() -> PhysicalDeviceMeshShaderFeaturesNV {
        PhysicalDeviceMeshShaderFeaturesNV {
            s_type: StructureType::PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV,
            p_next: ::std::ptr::null_mut(),
            task_shader: Bool32::default(),
            mesh_shader: Bool32::default(),
        }
    }
}
impl PhysicalDeviceMeshShaderFeaturesNV {
    pub fn builder<'a>() -> PhysicalDeviceMeshShaderFeaturesNVBuilder<'a> {
        PhysicalDeviceMeshShaderFeaturesNVBuilder {
            inner: PhysicalDeviceMeshShaderFeaturesNV::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDeviceMeshShaderFeaturesNVBuilder<'a> {
    inner: PhysicalDeviceMeshShaderFeaturesNV,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMeshShaderFeaturesNVBuilder<'_> {}
unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMeshShaderFeaturesNV {}
impl<'a> ::std::ops::Deref for PhysicalDeviceMeshShaderFeaturesNVBuilder<'a> {
    type Target = PhysicalDeviceMeshShaderFeaturesNV;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PhysicalDeviceMeshShaderFeaturesNVBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDeviceMeshShaderFeaturesNVBuilder<'a> {
    pub fn task_shader(
        mut self,
        task_shader: bool,
    ) -> PhysicalDeviceMeshShaderFeaturesNVBuilder<'a> {
        self.inner.task_shader = task_shader.into();
        self
    }
    pub fn mesh_shader(
        mut self,
        mesh_shader: bool,
    ) -> PhysicalDeviceMeshShaderFeaturesNVBuilder<'a> {
        self.inner.mesh_shader = mesh_shader.into();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDeviceMeshShaderFeaturesNV {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceMeshShaderPropertiesNV.html>"]
pub struct PhysicalDeviceMeshShaderPropertiesNV {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub max_draw_mesh_tasks_count: u32,
    pub max_task_work_group_invocations: u32,
    pub max_task_work_group_size: [u32; 3],
    pub max_task_total_memory_size: u32,
    pub max_task_output_count: u32,
    pub max_mesh_work_group_invocations: u32,
    pub max_mesh_work_group_size: [u32; 3],
    pub max_mesh_total_memory_size: u32,
    pub max_mesh_output_vertices: u32,
    pub max_mesh_output_primitives: u32,
    pub max_mesh_multiview_view_count: u32,
    pub mesh_output_per_vertex_granularity: u32,
    pub mesh_output_per_primitive_granularity: u32,
}
impl ::std::default::Default for PhysicalDeviceMeshShaderPropertiesNV {
    fn default() -> PhysicalDeviceMeshShaderPropertiesNV {
        PhysicalDeviceMeshShaderPropertiesNV {
            s_type: StructureType::PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV,
            p_next: ::std::ptr::null_mut(),
            max_draw_mesh_tasks_count: u32::default(),
            max_task_work_group_invocations: u32::default(),
            max_task_work_group_size: unsafe { ::std::mem::zeroed() },
            max_task_total_memory_size: u32::default(),
            max_task_output_count: u32::default(),
            max_mesh_work_group_invocations: u32::default(),
            max_mesh_work_group_size: unsafe { ::std::mem::zeroed() },
            max_mesh_total_memory_size: u32::default(),
            max_mesh_output_vertices: u32::default(),
            max_mesh_output_primitives: u32::default(),
            max_mesh_multiview_view_count: u32::default(),
            mesh_output_per_vertex_granularity: u32::default(),
            mesh_output_per_primitive_granularity: u32::default(),
        }
    }
}
impl PhysicalDeviceMeshShaderPropertiesNV {
    pub fn builder<'a>() -> PhysicalDeviceMeshShaderPropertiesNVBuilder<'a> {
        PhysicalDeviceMeshShaderPropertiesNVBuilder {
            inner: PhysicalDeviceMeshShaderPropertiesNV::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDeviceMeshShaderPropertiesNVBuilder<'a> {
    inner: PhysicalDeviceMeshShaderPropertiesNV,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMeshShaderPropertiesNVBuilder<'_> {}
unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMeshShaderPropertiesNV {}
impl<'a> ::std::ops::Deref for PhysicalDeviceMeshShaderPropertiesNVBuilder<'a> {
    type Target = PhysicalDeviceMeshShaderPropertiesNV;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PhysicalDeviceMeshShaderPropertiesNVBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDeviceMeshShaderPropertiesNVBuilder<'a> {
    pub fn max_draw_mesh_tasks_count(
        mut self,
        max_draw_mesh_tasks_count: u32,
    ) -> PhysicalDeviceMeshShaderPropertiesNVBuilder<'a> {
        self.inner.max_draw_mesh_tasks_count = max_draw_mesh_tasks_count;
        self
    }
    pub fn max_task_work_group_invocations(
        mut self,
        max_task_work_group_invocations: u32,
    ) -> PhysicalDeviceMeshShaderPropertiesNVBuilder<'a> {
        self.inner.max_task_work_group_invocations = max_task_work_group_invocations;
        self
    }
    pub fn max_task_work_group_size(
        mut self,
        max_task_work_group_size: [u32; 3],
    ) -> PhysicalDeviceMeshShaderPropertiesNVBuilder<'a> {
        self.inner.max_task_work_group_size = max_task_work_group_size;
        self
    }
    pub fn max_task_total_memory_size(
        mut self,
        max_task_total_memory_size: u32,
    ) -> PhysicalDeviceMeshShaderPropertiesNVBuilder<'a> {
        self.inner.max_task_total_memory_size = max_task_total_memory_size;
        self
    }
    pub fn max_task_output_count(
        mut self,
        max_task_output_count: u32,
    ) -> PhysicalDeviceMeshShaderPropertiesNVBuilder<'a> {
        self.inner.max_task_output_count = max_task_output_count;
        self
    }
    pub fn max_mesh_work_group_invocations(
        mut self,
        max_mesh_work_group_invocations: u32,
    ) -> PhysicalDeviceMeshShaderPropertiesNVBuilder<'a> {
        self.inner.max_mesh_work_group_invocations = max_mesh_work_group_invocations;
        self
    }
    pub fn max_mesh_work_group_size(
        mut self,
        max_mesh_work_group_size: [u32; 3],
    ) -> PhysicalDeviceMeshShaderPropertiesNVBuilder<'a> {
        self.inner.max_mesh_work_group_size = max_mesh_work_group_size;
        self
    }
    pub fn max_mesh_total_memory_size(
        mut self,
        max_mesh_total_memory_size: u32,
    ) -> PhysicalDeviceMeshShaderPropertiesNVBuilder<'a> {
        self.inner.max_mesh_total_memory_size = max_mesh_total_memory_size;
        self
    }
    pub fn max_mesh_output_vertices(
        mut self,
        max_mesh_output_vertices: u32,
    ) -> PhysicalDeviceMeshShaderPropertiesNVBuilder<'a> {
        self.inner.max_mesh_output_vertices = max_mesh_output_vertices;
        self
    }
    pub fn max_mesh_output_primitives(
        mut self,
        max_mesh_output_primitives: u32,
    ) -> PhysicalDeviceMeshShaderPropertiesNVBuilder<'a> {
        self.inner.max_mesh_output_primitives = max_mesh_output_primitives;
        self
    }
    pub fn max_mesh_multiview_view_count(
        mut self,
        max_mesh_multiview_view_count: u32,
    ) -> PhysicalDeviceMeshShaderPropertiesNVBuilder<'a> {
        self.inner.max_mesh_multiview_view_count = max_mesh_multiview_view_count;
        self
    }
    pub fn mesh_output_per_vertex_granularity(
        mut self,
        mesh_output_per_vertex_granularity: u32,
    ) -> PhysicalDeviceMeshShaderPropertiesNVBuilder<'a> {
        self.inner.mesh_output_per_vertex_granularity = mesh_output_per_vertex_granularity;
        self
    }
    pub fn mesh_output_per_primitive_granularity(
        mut self,
        mesh_output_per_primitive_granularity: u32,
    ) -> PhysicalDeviceMeshShaderPropertiesNVBuilder<'a> {
        self.inner.mesh_output_per_primitive_granularity = mesh_output_per_primitive_granularity;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDeviceMeshShaderPropertiesNV {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Default, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDrawMeshTasksIndirectCommandNV.html>"]
pub struct DrawMeshTasksIndirectCommandNV {
    pub task_count: u32,
    pub first_task: u32,
}
impl DrawMeshTasksIndirectCommandNV {
    pub fn builder<'a>() -> DrawMeshTasksIndirectCommandNVBuilder<'a> {
        DrawMeshTasksIndirectCommandNVBuilder {
            inner: DrawMeshTasksIndirectCommandNV::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct DrawMeshTasksIndirectCommandNVBuilder<'a> {
    inner: DrawMeshTasksIndirectCommandNV,
    marker: ::std::marker::PhantomData<&'a ()>,
}
impl<'a> ::std::ops::Deref for DrawMeshTasksIndirectCommandNVBuilder<'a> {
    type Target = DrawMeshTasksIndirectCommandNV;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for DrawMeshTasksIndirectCommandNVBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> DrawMeshTasksIndirectCommandNVBuilder<'a> {
    pub fn task_count(mut self, task_count: u32) -> DrawMeshTasksIndirectCommandNVBuilder<'a> {
        self.inner.task_count = task_count;
        self
    }
    pub fn first_task(mut self, first_task: u32) -> DrawMeshTasksIndirectCommandNVBuilder<'a> {
        self.inner.first_task = first_task;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> DrawMeshTasksIndirectCommandNV {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkRayTracingShaderGroupCreateInfoNV.html>"]
pub struct RayTracingShaderGroupCreateInfoNV {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub ty: RayTracingShaderGroupTypeKHR,
    pub general_shader: u32,
    pub closest_hit_shader: u32,
    pub any_hit_shader: u32,
    pub intersection_shader: u32,
}
impl ::std::default::Default for RayTracingShaderGroupCreateInfoNV {
    fn default() -> RayTracingShaderGroupCreateInfoNV {
        RayTracingShaderGroupCreateInfoNV {
            s_type: StructureType::RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV,
            p_next: ::std::ptr::null(),
            ty: RayTracingShaderGroupTypeKHR::default(),
            general_shader: u32::default(),
            closest_hit_shader: u32::default(),
            any_hit_shader: u32::default(),
            intersection_shader: u32::default(),
        }
    }
}
impl RayTracingShaderGroupCreateInfoNV {
    pub fn builder<'a>() -> RayTracingShaderGroupCreateInfoNVBuilder<'a> {
        RayTracingShaderGroupCreateInfoNVBuilder {
            inner: RayTracingShaderGroupCreateInfoNV::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct RayTracingShaderGroupCreateInfoNVBuilder<'a> {
    inner: RayTracingShaderGroupCreateInfoNV,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsRayTracingShaderGroupCreateInfoNV {}
impl<'a> ::std::ops::Deref for RayTracingShaderGroupCreateInfoNVBuilder<'a> {
    type Target = RayTracingShaderGroupCreateInfoNV;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for RayTracingShaderGroupCreateInfoNVBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> RayTracingShaderGroupCreateInfoNVBuilder<'a> {
    pub fn ty(
        mut self,
        ty: RayTracingShaderGroupTypeKHR,
    ) -> RayTracingShaderGroupCreateInfoNVBuilder<'a> {
        self.inner.ty = ty;
        self
    }
    pub fn general_shader(
        mut self,
        general_shader: u32,
    ) -> RayTracingShaderGroupCreateInfoNVBuilder<'a> {
        self.inner.general_shader = general_shader;
        self
    }
    pub fn closest_hit_shader(
        mut self,
        closest_hit_shader: u32,
    ) -> RayTracingShaderGroupCreateInfoNVBuilder<'a> {
        self.inner.closest_hit_shader = closest_hit_shader;
        self
    }
    pub fn any_hit_shader(
        mut self,
        any_hit_shader: u32,
    ) -> RayTracingShaderGroupCreateInfoNVBuilder<'a> {
        self.inner.any_hit_shader = any_hit_shader;
        self
    }
    pub fn intersection_shader(
        mut self,
        intersection_shader: u32,
    ) -> RayTracingShaderGroupCreateInfoNVBuilder<'a> {
        self.inner.intersection_shader = intersection_shader;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsRayTracingShaderGroupCreateInfoNV>(
        mut self,
        next: &'a mut T,
    ) -> RayTracingShaderGroupCreateInfoNVBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> RayTracingShaderGroupCreateInfoNV {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkRayTracingShaderGroupCreateInfoKHR.html>"]
pub struct RayTracingShaderGroupCreateInfoKHR {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub ty: RayTracingShaderGroupTypeKHR,
    pub general_shader: u32,
    pub closest_hit_shader: u32,
    pub any_hit_shader: u32,
    pub intersection_shader: u32,
    pub p_shader_group_capture_replay_handle: *const c_void,
}
impl ::std::default::Default for RayTracingShaderGroupCreateInfoKHR {
    fn default() -> RayTracingShaderGroupCreateInfoKHR {
        RayTracingShaderGroupCreateInfoKHR {
            s_type: StructureType::RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR,
            p_next: ::std::ptr::null(),
            ty: RayTracingShaderGroupTypeKHR::default(),
            general_shader: u32::default(),
            closest_hit_shader: u32::default(),
            any_hit_shader: u32::default(),
            intersection_shader: u32::default(),
            p_shader_group_capture_replay_handle: ::std::ptr::null(),
        }
    }
}
impl RayTracingShaderGroupCreateInfoKHR {
    pub fn builder<'a>() -> RayTracingShaderGroupCreateInfoKHRBuilder<'a> {
        RayTracingShaderGroupCreateInfoKHRBuilder {
            inner: RayTracingShaderGroupCreateInfoKHR::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct RayTracingShaderGroupCreateInfoKHRBuilder<'a> {
    inner: RayTracingShaderGroupCreateInfoKHR,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsRayTracingShaderGroupCreateInfoKHR {}
impl<'a> ::std::ops::Deref for RayTracingShaderGroupCreateInfoKHRBuilder<'a> {
    type Target = RayTracingShaderGroupCreateInfoKHR;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for RayTracingShaderGroupCreateInfoKHRBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> RayTracingShaderGroupCreateInfoKHRBuilder<'a> {
    pub fn ty(
        mut self,
        ty: RayTracingShaderGroupTypeKHR,
    ) -> RayTracingShaderGroupCreateInfoKHRBuilder<'a> {
        self.inner.ty = ty;
        self
    }
    pub fn general_shader(
        mut self,
        general_shader: u32,
    ) -> RayTracingShaderGroupCreateInfoKHRBuilder<'a> {
        self.inner.general_shader = general_shader;
        self
    }
    pub fn closest_hit_shader(
        mut self,
        closest_hit_shader: u32,
    ) -> RayTracingShaderGroupCreateInfoKHRBuilder<'a> {
        self.inner.closest_hit_shader = closest_hit_shader;
        self
    }
    pub fn any_hit_shader(
        mut self,
        any_hit_shader: u32,
    ) -> RayTracingShaderGroupCreateInfoKHRBuilder<'a> {
        self.inner.any_hit_shader = any_hit_shader;
        self
    }
    pub fn intersection_shader(
        mut self,
        intersection_shader: u32,
    ) -> RayTracingShaderGroupCreateInfoKHRBuilder<'a> {
        self.inner.intersection_shader = intersection_shader;
        self
    }
    pub fn shader_group_capture_replay_handle(
        mut self,
        shader_group_capture_replay_handle: &'a c_void,
    ) -> RayTracingShaderGroupCreateInfoKHRBuilder<'a> {
        self.inner.p_shader_group_capture_replay_handle = shader_group_capture_replay_handle;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsRayTracingShaderGroupCreateInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> RayTracingShaderGroupCreateInfoKHRBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> RayTracingShaderGroupCreateInfoKHR {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkRayTracingPipelineCreateInfoNV.html>"]
pub struct RayTracingPipelineCreateInfoNV {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub flags: PipelineCreateFlags,
    pub stage_count: u32,
    pub p_stages: *const PipelineShaderStageCreateInfo,
    pub group_count: u32,
    pub p_groups: *const RayTracingShaderGroupCreateInfoNV,
    pub max_recursion_depth: u32,
    pub layout: PipelineLayout,
    pub base_pipeline_handle: Pipeline,
    pub base_pipeline_index: i32,
}
impl ::std::default::Default for RayTracingPipelineCreateInfoNV {
    fn default() -> RayTracingPipelineCreateInfoNV {
        RayTracingPipelineCreateInfoNV {
            s_type: StructureType::RAY_TRACING_PIPELINE_CREATE_INFO_NV,
            p_next: ::std::ptr::null(),
            flags: PipelineCreateFlags::default(),
            stage_count: u32::default(),
            p_stages: ::std::ptr::null(),
            group_count: u32::default(),
            p_groups: ::std::ptr::null(),
            max_recursion_depth: u32::default(),
            layout: PipelineLayout::default(),
            base_pipeline_handle: Pipeline::default(),
            base_pipeline_index: i32::default(),
        }
    }
}
impl RayTracingPipelineCreateInfoNV {
    pub fn builder<'a>() -> RayTracingPipelineCreateInfoNVBuilder<'a> {
        RayTracingPipelineCreateInfoNVBuilder {
            inner: RayTracingPipelineCreateInfoNV::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct RayTracingPipelineCreateInfoNVBuilder<'a> {
    inner: RayTracingPipelineCreateInfoNV,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsRayTracingPipelineCreateInfoNV {}
impl<'a> ::std::ops::Deref for RayTracingPipelineCreateInfoNVBuilder<'a> {
    type Target = RayTracingPipelineCreateInfoNV;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for RayTracingPipelineCreateInfoNVBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> RayTracingPipelineCreateInfoNVBuilder<'a> {
    pub fn flags(
        mut self,
        flags: PipelineCreateFlags,
    ) -> RayTracingPipelineCreateInfoNVBuilder<'a> {
        self.inner.flags = flags;
        self
    }
    pub fn stages(
        mut self,
        stages: &'a [PipelineShaderStageCreateInfo],
    ) -> RayTracingPipelineCreateInfoNVBuilder<'a> {
        self.inner.stage_count = stages.len() as _;
        self.inner.p_stages = stages.as_ptr();
        self
    }
    pub fn groups(
        mut self,
        groups: &'a [RayTracingShaderGroupCreateInfoNV],
    ) -> RayTracingPipelineCreateInfoNVBuilder<'a> {
        self.inner.group_count = groups.len() as _;
        self.inner.p_groups = groups.as_ptr();
        self
    }
    pub fn max_recursion_depth(
        mut self,
        max_recursion_depth: u32,
    ) -> RayTracingPipelineCreateInfoNVBuilder<'a> {
        self.inner.max_recursion_depth = max_recursion_depth;
        self
    }
    pub fn layout(mut self, layout: PipelineLayout) -> RayTracingPipelineCreateInfoNVBuilder<'a> {
        self.inner.layout = layout;
        self
    }
    pub fn base_pipeline_handle(
        mut self,
        base_pipeline_handle: Pipeline,
    ) -> RayTracingPipelineCreateInfoNVBuilder<'a> {
        self.inner.base_pipeline_handle = base_pipeline_handle;
        self
    }
    pub fn base_pipeline_index(
        mut self,
        base_pipeline_index: i32,
    ) -> RayTracingPipelineCreateInfoNVBuilder<'a> {
        self.inner.base_pipeline_index = base_pipeline_index;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsRayTracingPipelineCreateInfoNV>(
        mut self,
        next: &'a mut T,
    ) -> RayTracingPipelineCreateInfoNVBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> RayTracingPipelineCreateInfoNV {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkRayTracingPipelineCreateInfoKHR.html>"]
pub struct RayTracingPipelineCreateInfoKHR {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub flags: PipelineCreateFlags,
    pub stage_count: u32,
    pub p_stages: *const PipelineShaderStageCreateInfo,
    pub group_count: u32,
    pub p_groups: *const RayTracingShaderGroupCreateInfoKHR,
    pub max_recursion_depth: u32,
    pub libraries: PipelineLibraryCreateInfoKHR,
    pub p_library_interface: *const RayTracingPipelineInterfaceCreateInfoKHR,
    pub layout: PipelineLayout,
    pub base_pipeline_handle: Pipeline,
    pub base_pipeline_index: i32,
}
impl ::std::default::Default for RayTracingPipelineCreateInfoKHR {
    fn default() -> RayTracingPipelineCreateInfoKHR {
        RayTracingPipelineCreateInfoKHR {
            s_type: StructureType::RAY_TRACING_PIPELINE_CREATE_INFO_KHR,
            p_next: ::std::ptr::null(),
            flags: PipelineCreateFlags::default(),
            stage_count: u32::default(),
            p_stages: ::std::ptr::null(),
            group_count: u32::default(),
            p_groups: ::std::ptr::null(),
            max_recursion_depth: u32::default(),
            libraries: PipelineLibraryCreateInfoKHR::default(),
            p_library_interface: ::std::ptr::null(),
            layout: PipelineLayout::default(),
            base_pipeline_handle: Pipeline::default(),
            base_pipeline_index: i32::default(),
        }
    }
}
impl RayTracingPipelineCreateInfoKHR {
    pub fn builder<'a>() -> RayTracingPipelineCreateInfoKHRBuilder<'a> {
        RayTracingPipelineCreateInfoKHRBuilder {
            inner: RayTracingPipelineCreateInfoKHR::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct RayTracingPipelineCreateInfoKHRBuilder<'a> {
    inner: RayTracingPipelineCreateInfoKHR,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsRayTracingPipelineCreateInfoKHR {}
impl<'a> ::std::ops::Deref for RayTracingPipelineCreateInfoKHRBuilder<'a> {
    type Target = RayTracingPipelineCreateInfoKHR;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for RayTracingPipelineCreateInfoKHRBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> RayTracingPipelineCreateInfoKHRBuilder<'a> {
    pub fn flags(
        mut self,
        flags: PipelineCreateFlags,
    ) -> RayTracingPipelineCreateInfoKHRBuilder<'a> {
        self.inner.flags = flags;
        self
    }
    pub fn stages(
        mut self,
        stages: &'a [PipelineShaderStageCreateInfo],
    ) -> RayTracingPipelineCreateInfoKHRBuilder<'a> {
        self.inner.stage_count = stages.len() as _;
        self.inner.p_stages = stages.as_ptr();
        self
    }
    pub fn groups(
        mut self,
        groups: &'a [RayTracingShaderGroupCreateInfoKHR],
    ) -> RayTracingPipelineCreateInfoKHRBuilder<'a> {
        self.inner.group_count = groups.len() as _;
        self.inner.p_groups = groups.as_ptr();
        self
    }
    pub fn max_recursion_depth(
        mut self,
        max_recursion_depth: u32,
    ) -> RayTracingPipelineCreateInfoKHRBuilder<'a> {
        self.inner.max_recursion_depth = max_recursion_depth;
        self
    }
    pub fn libraries(
        mut self,
        libraries: PipelineLibraryCreateInfoKHR,
    ) -> RayTracingPipelineCreateInfoKHRBuilder<'a> {
        self.inner.libraries = libraries;
        self
    }
    pub fn library_interface(
        mut self,
        library_interface: &'a RayTracingPipelineInterfaceCreateInfoKHR,
    ) -> RayTracingPipelineCreateInfoKHRBuilder<'a> {
        self.inner.p_library_interface = library_interface;
        self
    }
    pub fn layout(mut self, layout: PipelineLayout) -> RayTracingPipelineCreateInfoKHRBuilder<'a> {
        self.inner.layout = layout;
        self
    }
    pub fn base_pipeline_handle(
        mut self,
        base_pipeline_handle: Pipeline,
    ) -> RayTracingPipelineCreateInfoKHRBuilder<'a> {
        self.inner.base_pipeline_handle = base_pipeline_handle;
        self
    }
    pub fn base_pipeline_index(
        mut self,
        base_pipeline_index: i32,
    ) -> RayTracingPipelineCreateInfoKHRBuilder<'a> {
        self.inner.base_pipeline_index = base_pipeline_index;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsRayTracingPipelineCreateInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> RayTracingPipelineCreateInfoKHRBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> RayTracingPipelineCreateInfoKHR {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkGeometryTrianglesNV.html>"]
pub struct GeometryTrianglesNV {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub vertex_data: Buffer,
    pub vertex_offset: DeviceSize,
    pub vertex_count: u32,
    pub vertex_stride: DeviceSize,
    pub vertex_format: Format,
    pub index_data: Buffer,
    pub index_offset: DeviceSize,
    pub index_count: u32,
    pub index_type: IndexType,
    pub transform_data: Buffer,
    pub transform_offset: DeviceSize,
}
impl ::std::default::Default for GeometryTrianglesNV {
    fn default() -> GeometryTrianglesNV {
        GeometryTrianglesNV {
            s_type: StructureType::GEOMETRY_TRIANGLES_NV,
            p_next: ::std::ptr::null(),
            vertex_data: Buffer::default(),
            vertex_offset: DeviceSize::default(),
            vertex_count: u32::default(),
            vertex_stride: DeviceSize::default(),
            vertex_format: Format::default(),
            index_data: Buffer::default(),
            index_offset: DeviceSize::default(),
            index_count: u32::default(),
            index_type: IndexType::default(),
            transform_data: Buffer::default(),
            transform_offset: DeviceSize::default(),
        }
    }
}
impl GeometryTrianglesNV {
    pub fn builder<'a>() -> GeometryTrianglesNVBuilder<'a> {
        GeometryTrianglesNVBuilder {
            inner: GeometryTrianglesNV::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct GeometryTrianglesNVBuilder<'a> {
    inner: GeometryTrianglesNV,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsGeometryTrianglesNV {}
impl<'a> ::std::ops::Deref for GeometryTrianglesNVBuilder<'a> {
    type Target = GeometryTrianglesNV;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for GeometryTrianglesNVBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> GeometryTrianglesNVBuilder<'a> {
    pub fn vertex_data(mut self, vertex_data: Buffer) -> GeometryTrianglesNVBuilder<'a> {
        self.inner.vertex_data = vertex_data;
        self
    }
    pub fn vertex_offset(mut self, vertex_offset: DeviceSize) -> GeometryTrianglesNVBuilder<'a> {
        self.inner.vertex_offset = vertex_offset;
        self
    }
    pub fn vertex_count(mut self, vertex_count: u32) -> GeometryTrianglesNVBuilder<'a> {
        self.inner.vertex_count = vertex_count;
        self
    }
    pub fn vertex_stride(mut self, vertex_stride: DeviceSize) -> GeometryTrianglesNVBuilder<'a> {
        self.inner.vertex_stride = vertex_stride;
        self
    }
    pub fn vertex_format(mut self, vertex_format: Format) -> GeometryTrianglesNVBuilder<'a> {
        self.inner.vertex_format = vertex_format;
        self
    }
    pub fn index_data(mut self, index_data: Buffer) -> GeometryTrianglesNVBuilder<'a> {
        self.inner.index_data = index_data;
        self
    }
    pub fn index_offset(mut self, index_offset: DeviceSize) -> GeometryTrianglesNVBuilder<'a> {
        self.inner.index_offset = index_offset;
        self
    }
    pub fn index_count(mut self, index_count: u32) -> GeometryTrianglesNVBuilder<'a> {
        self.inner.index_count = index_count;
        self
    }
    pub fn index_type(mut self, index_type: IndexType) -> GeometryTrianglesNVBuilder<'a> {
        self.inner.index_type = index_type;
        self
    }
    pub fn transform_data(mut self, transform_data: Buffer) -> GeometryTrianglesNVBuilder<'a> {
        self.inner.transform_data = transform_data;
        self
    }
    pub fn transform_offset(
        mut self,
        transform_offset: DeviceSize,
    ) -> GeometryTrianglesNVBuilder<'a> {
        self.inner.transform_offset = transform_offset;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsGeometryTrianglesNV>(
        mut self,
        next: &'a mut T,
    ) -> GeometryTrianglesNVBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> GeometryTrianglesNV {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkGeometryAABBNV.html>"]
pub struct GeometryAABBNV {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub aabb_data: Buffer,
    pub num_aab_bs: u32,
    pub stride: u32,
    pub offset: DeviceSize,
}
impl ::std::default::Default for GeometryAABBNV {
    fn default() -> GeometryAABBNV {
        GeometryAABBNV {
            s_type: StructureType::GEOMETRY_AABB_NV,
            p_next: ::std::ptr::null(),
            aabb_data: Buffer::default(),
            num_aab_bs: u32::default(),
            stride: u32::default(),
            offset: DeviceSize::default(),
        }
    }
}
impl GeometryAABBNV {
    pub fn builder<'a>() -> GeometryAABBNVBuilder<'a> {
        GeometryAABBNVBuilder {
            inner: GeometryAABBNV::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct GeometryAABBNVBuilder<'a> {
    inner: GeometryAABBNV,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsGeometryAABBNV {}
impl<'a> ::std::ops::Deref for GeometryAABBNVBuilder<'a> {
    type Target = GeometryAABBNV;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for GeometryAABBNVBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> GeometryAABBNVBuilder<'a> {
    pub fn aabb_data(mut self, aabb_data: Buffer) -> GeometryAABBNVBuilder<'a> {
        self.inner.aabb_data = aabb_data;
        self
    }
    pub fn num_aab_bs(mut self, num_aab_bs: u32) -> GeometryAABBNVBuilder<'a> {
        self.inner.num_aab_bs = num_aab_bs;
        self
    }
    pub fn stride(mut self, stride: u32) -> GeometryAABBNVBuilder<'a> {
        self.inner.stride = stride;
        self
    }
    pub fn offset(mut self, offset: DeviceSize) -> GeometryAABBNVBuilder<'a> {
        self.inner.offset = offset;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsGeometryAABBNV>(
        mut self,
        next: &'a mut T,
    ) -> GeometryAABBNVBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> GeometryAABBNV {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Default, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkGeometryDataNV.html>"]
pub struct GeometryDataNV {
    pub triangles: GeometryTrianglesNV,
    pub aabbs: GeometryAABBNV,
}
impl GeometryDataNV {
    pub fn builder<'a>() -> GeometryDataNVBuilder<'a> {
        GeometryDataNVBuilder {
            inner: GeometryDataNV::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct GeometryDataNVBuilder<'a> {
    inner: GeometryDataNV,
    marker: ::std::marker::PhantomData<&'a ()>,
}
impl<'a> ::std::ops::Deref for GeometryDataNVBuilder<'a> {
    type Target = GeometryDataNV;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for GeometryDataNVBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> GeometryDataNVBuilder<'a> {
    pub fn triangles(mut self, triangles: GeometryTrianglesNV) -> GeometryDataNVBuilder<'a> {
        self.inner.triangles = triangles;
        self
    }
    pub fn aabbs(mut self, aabbs: GeometryAABBNV) -> GeometryDataNVBuilder<'a> {
        self.inner.aabbs = aabbs;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> GeometryDataNV {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkGeometryNV.html>"]
pub struct GeometryNV {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub geometry_type: GeometryTypeKHR,
    pub geometry: GeometryDataNV,
    pub flags: GeometryFlagsKHR,
}
impl ::std::default::Default for GeometryNV {
    fn default() -> GeometryNV {
        GeometryNV {
            s_type: StructureType::GEOMETRY_NV,
            p_next: ::std::ptr::null(),
            geometry_type: GeometryTypeKHR::default(),
            geometry: GeometryDataNV::default(),
            flags: GeometryFlagsKHR::default(),
        }
    }
}
impl GeometryNV {
    pub fn builder<'a>() -> GeometryNVBuilder<'a> {
        GeometryNVBuilder {
            inner: GeometryNV::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct GeometryNVBuilder<'a> {
    inner: GeometryNV,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsGeometryNV {}
impl<'a> ::std::ops::Deref for GeometryNVBuilder<'a> {
    type Target = GeometryNV;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for GeometryNVBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> GeometryNVBuilder<'a> {
    pub fn geometry_type(mut self, geometry_type: GeometryTypeKHR) -> GeometryNVBuilder<'a> {
        self.inner.geometry_type = geometry_type;
        self
    }
    pub fn geometry(mut self, geometry: GeometryDataNV) -> GeometryNVBuilder<'a> {
        self.inner.geometry = geometry;
        self
    }
    pub fn flags(mut self, flags: GeometryFlagsKHR) -> GeometryNVBuilder<'a> {
        self.inner.flags = flags;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsGeometryNV>(mut self, next: &'a mut T) -> GeometryNVBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> GeometryNV {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAccelerationStructureInfoNV.html>"]
pub struct AccelerationStructureInfoNV {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub ty: AccelerationStructureTypeNV,
    pub flags: BuildAccelerationStructureFlagsNV,
    pub instance_count: u32,
    pub geometry_count: u32,
    pub p_geometries: *const GeometryNV,
}
impl ::std::default::Default for AccelerationStructureInfoNV {
    fn default() -> AccelerationStructureInfoNV {
        AccelerationStructureInfoNV {
            s_type: StructureType::ACCELERATION_STRUCTURE_INFO_NV,
            p_next: ::std::ptr::null(),
            ty: AccelerationStructureTypeNV::default(),
            flags: BuildAccelerationStructureFlagsNV::default(),
            instance_count: u32::default(),
            geometry_count: u32::default(),
            p_geometries: ::std::ptr::null(),
        }
    }
}
impl AccelerationStructureInfoNV {
    pub fn builder<'a>() -> AccelerationStructureInfoNVBuilder<'a> {
        AccelerationStructureInfoNVBuilder {
            inner: AccelerationStructureInfoNV::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct AccelerationStructureInfoNVBuilder<'a> {
    inner: AccelerationStructureInfoNV,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsAccelerationStructureInfoNV {}
impl<'a> ::std::ops::Deref for AccelerationStructureInfoNVBuilder<'a> {
    type Target = AccelerationStructureInfoNV;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for AccelerationStructureInfoNVBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> AccelerationStructureInfoNVBuilder<'a> {
    pub fn ty(mut self, ty: AccelerationStructureTypeNV) -> AccelerationStructureInfoNVBuilder<'a> {
        self.inner.ty = ty;
        self
    }
    pub fn flags(
        mut self,
        flags: BuildAccelerationStructureFlagsNV,
    ) -> AccelerationStructureInfoNVBuilder<'a> {
        self.inner.flags = flags;
        self
    }
    pub fn instance_count(mut self, instance_count: u32) -> AccelerationStructureInfoNVBuilder<'a> {
        self.inner.instance_count = instance_count;
        self
    }
    pub fn geometries(
        mut self,
        geometries: &'a [GeometryNV],
    ) -> AccelerationStructureInfoNVBuilder<'a> {
        self.inner.geometry_count = geometries.len() as _;
        self.inner.p_geometries = geometries.as_ptr();
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsAccelerationStructureInfoNV>(
        mut self,
        next: &'a mut T,
    ) -> AccelerationStructureInfoNVBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> AccelerationStructureInfoNV {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAccelerationStructureCreateInfoNV.html>"]
pub struct AccelerationStructureCreateInfoNV {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub compacted_size: DeviceSize,
    pub info: AccelerationStructureInfoNV,
}
impl ::std::default::Default for AccelerationStructureCreateInfoNV {
    fn default() -> AccelerationStructureCreateInfoNV {
        AccelerationStructureCreateInfoNV {
            s_type: StructureType::ACCELERATION_STRUCTURE_CREATE_INFO_NV,
            p_next: ::std::ptr::null(),
            compacted_size: DeviceSize::default(),
            info: AccelerationStructureInfoNV::default(),
        }
    }
}
impl AccelerationStructureCreateInfoNV {
    pub fn builder<'a>() -> AccelerationStructureCreateInfoNVBuilder<'a> {
        AccelerationStructureCreateInfoNVBuilder {
            inner: AccelerationStructureCreateInfoNV::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct AccelerationStructureCreateInfoNVBuilder<'a> {
    inner: AccelerationStructureCreateInfoNV,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsAccelerationStructureCreateInfoNV {}
impl<'a> ::std::ops::Deref for AccelerationStructureCreateInfoNVBuilder<'a> {
    type Target = AccelerationStructureCreateInfoNV;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for AccelerationStructureCreateInfoNVBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> AccelerationStructureCreateInfoNVBuilder<'a> {
    pub fn compacted_size(
        mut self,
        compacted_size: DeviceSize,
    ) -> AccelerationStructureCreateInfoNVBuilder<'a> {
        self.inner.compacted_size = compacted_size;
        self
    }
    pub fn info(
        mut self,
        info: AccelerationStructureInfoNV,
    ) -> AccelerationStructureCreateInfoNVBuilder<'a> {
        self.inner.info = info;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsAccelerationStructureCreateInfoNV>(
        mut self,
        next: &'a mut T,
    ) -> AccelerationStructureCreateInfoNVBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> AccelerationStructureCreateInfoNV {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkBindAccelerationStructureMemoryInfoKHR.html>"]
pub struct BindAccelerationStructureMemoryInfoKHR {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub acceleration_structure: AccelerationStructureKHR,
    pub memory: DeviceMemory,
    pub memory_offset: DeviceSize,
    pub device_index_count: u32,
    pub p_device_indices: *const u32,
}
impl ::std::default::Default for BindAccelerationStructureMemoryInfoKHR {
    fn default() -> BindAccelerationStructureMemoryInfoKHR {
        BindAccelerationStructureMemoryInfoKHR {
            s_type: StructureType::BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_KHR,
            p_next: ::std::ptr::null(),
            acceleration_structure: AccelerationStructureKHR::default(),
            memory: DeviceMemory::default(),
            memory_offset: DeviceSize::default(),
            device_index_count: u32::default(),
            p_device_indices: ::std::ptr::null(),
        }
    }
}
impl BindAccelerationStructureMemoryInfoKHR {
    pub fn builder<'a>() -> BindAccelerationStructureMemoryInfoKHRBuilder<'a> {
        BindAccelerationStructureMemoryInfoKHRBuilder {
            inner: BindAccelerationStructureMemoryInfoKHR::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct BindAccelerationStructureMemoryInfoKHRBuilder<'a> {
    inner: BindAccelerationStructureMemoryInfoKHR,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsBindAccelerationStructureMemoryInfoKHR {}
impl<'a> ::std::ops::Deref for BindAccelerationStructureMemoryInfoKHRBuilder<'a> {
    type Target = BindAccelerationStructureMemoryInfoKHR;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for BindAccelerationStructureMemoryInfoKHRBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> BindAccelerationStructureMemoryInfoKHRBuilder<'a> {
    pub fn acceleration_structure(
        mut self,
        acceleration_structure: AccelerationStructureKHR,
    ) -> BindAccelerationStructureMemoryInfoKHRBuilder<'a> {
        self.inner.acceleration_structure = acceleration_structure;
        self
    }
    pub fn memory(
        mut self,
        memory: DeviceMemory,
    ) -> BindAccelerationStructureMemoryInfoKHRBuilder<'a> {
        self.inner.memory = memory;
        self
    }
    pub fn memory_offset(
        mut self,
        memory_offset: DeviceSize,
    ) -> BindAccelerationStructureMemoryInfoKHRBuilder<'a> {
        self.inner.memory_offset = memory_offset;
        self
    }
    pub fn device_indices(
        mut self,
        device_indices: &'a [u32],
    ) -> BindAccelerationStructureMemoryInfoKHRBuilder<'a> {
        self.inner.device_index_count = device_indices.len() as _;
        self.inner.p_device_indices = device_indices.as_ptr();
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsBindAccelerationStructureMemoryInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> BindAccelerationStructureMemoryInfoKHRBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> BindAccelerationStructureMemoryInfoKHR {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkWriteDescriptorSetAccelerationStructureKHR.html>"]
pub struct WriteDescriptorSetAccelerationStructureKHR {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub acceleration_structure_count: u32,
    pub p_acceleration_structures: *const AccelerationStructureKHR,
}
impl ::std::default::Default for WriteDescriptorSetAccelerationStructureKHR {
    fn default() -> WriteDescriptorSetAccelerationStructureKHR {
        WriteDescriptorSetAccelerationStructureKHR {
            s_type: StructureType::WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR,
            p_next: ::std::ptr::null(),
            acceleration_structure_count: u32::default(),
            p_acceleration_structures: ::std::ptr::null(),
        }
    }
}
impl WriteDescriptorSetAccelerationStructureKHR {
    pub fn builder<'a>() -> WriteDescriptorSetAccelerationStructureKHRBuilder<'a> {
        WriteDescriptorSetAccelerationStructureKHRBuilder {
            inner: WriteDescriptorSetAccelerationStructureKHR::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct WriteDescriptorSetAccelerationStructureKHRBuilder<'a> {
    inner: WriteDescriptorSetAccelerationStructureKHR,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsWriteDescriptorSet for WriteDescriptorSetAccelerationStructureKHRBuilder<'_> {}
unsafe impl ExtendsWriteDescriptorSet for WriteDescriptorSetAccelerationStructureKHR {}
impl<'a> ::std::ops::Deref for WriteDescriptorSetAccelerationStructureKHRBuilder<'a> {
    type Target = WriteDescriptorSetAccelerationStructureKHR;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for WriteDescriptorSetAccelerationStructureKHRBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> WriteDescriptorSetAccelerationStructureKHRBuilder<'a> {
    pub fn acceleration_structures(
        mut self,
        acceleration_structures: &'a [AccelerationStructureKHR],
    ) -> WriteDescriptorSetAccelerationStructureKHRBuilder<'a> {
        self.inner.acceleration_structure_count = acceleration_structures.len() as _;
        self.inner.p_acceleration_structures = acceleration_structures.as_ptr();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> WriteDescriptorSetAccelerationStructureKHR {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAccelerationStructureMemoryRequirementsInfoKHR.html>"]
pub struct AccelerationStructureMemoryRequirementsInfoKHR {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub ty: AccelerationStructureMemoryRequirementsTypeKHR,
    pub build_type: AccelerationStructureBuildTypeKHR,
    pub acceleration_structure: AccelerationStructureKHR,
}
impl ::std::default::Default for AccelerationStructureMemoryRequirementsInfoKHR {
    fn default() -> AccelerationStructureMemoryRequirementsInfoKHR {
        AccelerationStructureMemoryRequirementsInfoKHR {
            s_type: StructureType::ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_KHR,
            p_next: ::std::ptr::null(),
            ty: AccelerationStructureMemoryRequirementsTypeKHR::default(),
            build_type: AccelerationStructureBuildTypeKHR::default(),
            acceleration_structure: AccelerationStructureKHR::default(),
        }
    }
}
impl AccelerationStructureMemoryRequirementsInfoKHR {
    pub fn builder<'a>() -> AccelerationStructureMemoryRequirementsInfoKHRBuilder<'a> {
        AccelerationStructureMemoryRequirementsInfoKHRBuilder {
            inner: AccelerationStructureMemoryRequirementsInfoKHR::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct AccelerationStructureMemoryRequirementsInfoKHRBuilder<'a> {
    inner: AccelerationStructureMemoryRequirementsInfoKHR,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsAccelerationStructureMemoryRequirementsInfoKHR {}
impl<'a> ::std::ops::Deref for AccelerationStructureMemoryRequirementsInfoKHRBuilder<'a> {
    type Target = AccelerationStructureMemoryRequirementsInfoKHR;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for AccelerationStructureMemoryRequirementsInfoKHRBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> AccelerationStructureMemoryRequirementsInfoKHRBuilder<'a> {
    pub fn ty(
        mut self,
        ty: AccelerationStructureMemoryRequirementsTypeKHR,
    ) -> AccelerationStructureMemoryRequirementsInfoKHRBuilder<'a> {
        self.inner.ty = ty;
        self
    }
    pub fn build_type(
        mut self,
        build_type: AccelerationStructureBuildTypeKHR,
    ) -> AccelerationStructureMemoryRequirementsInfoKHRBuilder<'a> {
        self.inner.build_type = build_type;
        self
    }
    pub fn acceleration_structure(
        mut self,
        acceleration_structure: AccelerationStructureKHR,
    ) -> AccelerationStructureMemoryRequirementsInfoKHRBuilder<'a> {
        self.inner.acceleration_structure = acceleration_structure;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsAccelerationStructureMemoryRequirementsInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> AccelerationStructureMemoryRequirementsInfoKHRBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> AccelerationStructureMemoryRequirementsInfoKHR {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAccelerationStructureMemoryRequirementsInfoNV.html>"]
pub struct AccelerationStructureMemoryRequirementsInfoNV {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub ty: AccelerationStructureMemoryRequirementsTypeNV,
    pub acceleration_structure: AccelerationStructureNV,
}
impl ::std::default::Default for AccelerationStructureMemoryRequirementsInfoNV {
    fn default() -> AccelerationStructureMemoryRequirementsInfoNV {
        AccelerationStructureMemoryRequirementsInfoNV {
            s_type: StructureType::ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV,
            p_next: ::std::ptr::null(),
            ty: AccelerationStructureMemoryRequirementsTypeNV::default(),
            acceleration_structure: AccelerationStructureNV::default(),
        }
    }
}
impl AccelerationStructureMemoryRequirementsInfoNV {
    pub fn builder<'a>() -> AccelerationStructureMemoryRequirementsInfoNVBuilder<'a> {
        AccelerationStructureMemoryRequirementsInfoNVBuilder {
            inner: AccelerationStructureMemoryRequirementsInfoNV::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct AccelerationStructureMemoryRequirementsInfoNVBuilder<'a> {
    inner: AccelerationStructureMemoryRequirementsInfoNV,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsAccelerationStructureMemoryRequirementsInfoNV {}
impl<'a> ::std::ops::Deref for AccelerationStructureMemoryRequirementsInfoNVBuilder<'a> {
    type Target = AccelerationStructureMemoryRequirementsInfoNV;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for AccelerationStructureMemoryRequirementsInfoNVBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> AccelerationStructureMemoryRequirementsInfoNVBuilder<'a> {
    pub fn ty(
        mut self,
        ty: AccelerationStructureMemoryRequirementsTypeNV,
    ) -> AccelerationStructureMemoryRequirementsInfoNVBuilder<'a> {
        self.inner.ty = ty;
        self
    }
    pub fn acceleration_structure(
        mut self,
        acceleration_structure: AccelerationStructureNV,
    ) -> AccelerationStructureMemoryRequirementsInfoNVBuilder<'a> {
        self.inner.acceleration_structure = acceleration_structure;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsAccelerationStructureMemoryRequirementsInfoNV>(
        mut self,
        next: &'a mut T,
    ) -> AccelerationStructureMemoryRequirementsInfoNVBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> AccelerationStructureMemoryRequirementsInfoNV {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceRayTracingFeaturesKHR.html>"]
pub struct PhysicalDeviceRayTracingFeaturesKHR {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub ray_tracing: Bool32,
    pub ray_tracing_shader_group_handle_capture_replay: Bool32,
    pub ray_tracing_shader_group_handle_capture_replay_mixed: Bool32,
    pub ray_tracing_acceleration_structure_capture_replay: Bool32,
    pub ray_tracing_indirect_trace_rays: Bool32,
    pub ray_tracing_indirect_acceleration_structure_build: Bool32,
    pub ray_tracing_host_acceleration_structure_commands: Bool32,
    pub ray_query: Bool32,
    pub ray_tracing_primitive_culling: Bool32,
}
impl ::std::default::Default for PhysicalDeviceRayTracingFeaturesKHR {
    fn default() -> PhysicalDeviceRayTracingFeaturesKHR {
        PhysicalDeviceRayTracingFeaturesKHR {
            s_type: StructureType::PHYSICAL_DEVICE_RAY_TRACING_FEATURES_KHR,
            p_next: ::std::ptr::null_mut(),
            ray_tracing: Bool32::default(),
            ray_tracing_shader_group_handle_capture_replay: Bool32::default(),
            ray_tracing_shader_group_handle_capture_replay_mixed: Bool32::default(),
            ray_tracing_acceleration_structure_capture_replay: Bool32::default(),
            ray_tracing_indirect_trace_rays: Bool32::default(),
            ray_tracing_indirect_acceleration_structure_build: Bool32::default(),
            ray_tracing_host_acceleration_structure_commands: Bool32::default(),
            ray_query: Bool32::default(),
            ray_tracing_primitive_culling: Bool32::default(),
        }
    }
}
impl PhysicalDeviceRayTracingFeaturesKHR {
    pub fn builder<'a>() -> PhysicalDeviceRayTracingFeaturesKHRBuilder<'a> {
        PhysicalDeviceRayTracingFeaturesKHRBuilder {
            inner: PhysicalDeviceRayTracingFeaturesKHR::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDeviceRayTracingFeaturesKHRBuilder<'a> {
    inner: PhysicalDeviceRayTracingFeaturesKHR,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRayTracingFeaturesKHRBuilder<'_> {}
unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRayTracingFeaturesKHR {}
impl<'a> ::std::ops::Deref for PhysicalDeviceRayTracingFeaturesKHRBuilder<'a> {
    type Target = PhysicalDeviceRayTracingFeaturesKHR;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PhysicalDeviceRayTracingFeaturesKHRBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDeviceRayTracingFeaturesKHRBuilder<'a> {
    pub fn ray_tracing(
        mut self,
        ray_tracing: bool,
    ) -> PhysicalDeviceRayTracingFeaturesKHRBuilder<'a> {
        self.inner.ray_tracing = ray_tracing.into();
        self
    }
    pub fn ray_tracing_shader_group_handle_capture_replay(
        mut self,
        ray_tracing_shader_group_handle_capture_replay: bool,
    ) -> PhysicalDeviceRayTracingFeaturesKHRBuilder<'a> {
        self.inner.ray_tracing_shader_group_handle_capture_replay =
            ray_tracing_shader_group_handle_capture_replay.into();
        self
    }
    pub fn ray_tracing_shader_group_handle_capture_replay_mixed(
        mut self,
        ray_tracing_shader_group_handle_capture_replay_mixed: bool,
    ) -> PhysicalDeviceRayTracingFeaturesKHRBuilder<'a> {
        self.inner
            .ray_tracing_shader_group_handle_capture_replay_mixed =
            ray_tracing_shader_group_handle_capture_replay_mixed.into();
        self
    }
    pub fn ray_tracing_acceleration_structure_capture_replay(
        mut self,
        ray_tracing_acceleration_structure_capture_replay: bool,
    ) -> PhysicalDeviceRayTracingFeaturesKHRBuilder<'a> {
        self.inner.ray_tracing_acceleration_structure_capture_replay =
            ray_tracing_acceleration_structure_capture_replay.into();
        self
    }
    pub fn ray_tracing_indirect_trace_rays(
        mut self,
        ray_tracing_indirect_trace_rays: bool,
    ) -> PhysicalDeviceRayTracingFeaturesKHRBuilder<'a> {
        self.inner.ray_tracing_indirect_trace_rays = ray_tracing_indirect_trace_rays.into();
        self
    }
    pub fn ray_tracing_indirect_acceleration_structure_build(
        mut self,
        ray_tracing_indirect_acceleration_structure_build: bool,
    ) -> PhysicalDeviceRayTracingFeaturesKHRBuilder<'a> {
        self.inner.ray_tracing_indirect_acceleration_structure_build =
            ray_tracing_indirect_acceleration_structure_build.into();
        self
    }
    pub fn ray_tracing_host_acceleration_structure_commands(
        mut self,
        ray_tracing_host_acceleration_structure_commands: bool,
    ) -> PhysicalDeviceRayTracingFeaturesKHRBuilder<'a> {
        self.inner.ray_tracing_host_acceleration_structure_commands =
            ray_tracing_host_acceleration_structure_commands.into();
        self
    }
    pub fn ray_query(mut self, ray_query: bool) -> PhysicalDeviceRayTracingFeaturesKHRBuilder<'a> {
        self.inner.ray_query = ray_query.into();
        self
    }
    pub fn ray_tracing_primitive_culling(
        mut self,
        ray_tracing_primitive_culling: bool,
    ) -> PhysicalDeviceRayTracingFeaturesKHRBuilder<'a> {
        self.inner.ray_tracing_primitive_culling = ray_tracing_primitive_culling.into();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDeviceRayTracingFeaturesKHR {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceRayTracingPropertiesKHR.html>"]
pub struct PhysicalDeviceRayTracingPropertiesKHR {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub shader_group_handle_size: u32,
    pub max_recursion_depth: u32,
    pub max_shader_group_stride: u32,
    pub shader_group_base_alignment: u32,
    pub max_geometry_count: u64,
    pub max_instance_count: u64,
    pub max_primitive_count: u64,
    pub max_descriptor_set_acceleration_structures: u32,
    pub shader_group_handle_capture_replay_size: u32,
}
impl ::std::default::Default for PhysicalDeviceRayTracingPropertiesKHR {
    fn default() -> PhysicalDeviceRayTracingPropertiesKHR {
        PhysicalDeviceRayTracingPropertiesKHR {
            s_type: StructureType::PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_KHR,
            p_next: ::std::ptr::null_mut(),
            shader_group_handle_size: u32::default(),
            max_recursion_depth: u32::default(),
            max_shader_group_stride: u32::default(),
            shader_group_base_alignment: u32::default(),
            max_geometry_count: u64::default(),
            max_instance_count: u64::default(),
            max_primitive_count: u64::default(),
            max_descriptor_set_acceleration_structures: u32::default(),
            shader_group_handle_capture_replay_size: u32::default(),
        }
    }
}
impl PhysicalDeviceRayTracingPropertiesKHR {
    pub fn builder<'a>() -> PhysicalDeviceRayTracingPropertiesKHRBuilder<'a> {
        PhysicalDeviceRayTracingPropertiesKHRBuilder {
            inner: PhysicalDeviceRayTracingPropertiesKHR::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDeviceRayTracingPropertiesKHRBuilder<'a> {
    inner: PhysicalDeviceRayTracingPropertiesKHR,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceRayTracingPropertiesKHRBuilder<'_> {}
unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceRayTracingPropertiesKHR {}
impl<'a> ::std::ops::Deref for PhysicalDeviceRayTracingPropertiesKHRBuilder<'a> {
    type Target = PhysicalDeviceRayTracingPropertiesKHR;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PhysicalDeviceRayTracingPropertiesKHRBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDeviceRayTracingPropertiesKHRBuilder<'a> {
    pub fn shader_group_handle_size(
        mut self,
        shader_group_handle_size: u32,
    ) -> PhysicalDeviceRayTracingPropertiesKHRBuilder<'a> {
        self.inner.shader_group_handle_size = shader_group_handle_size;
        self
    }
    pub fn max_recursion_depth(
        mut self,
        max_recursion_depth: u32,
    ) -> PhysicalDeviceRayTracingPropertiesKHRBuilder<'a> {
        self.inner.max_recursion_depth = max_recursion_depth;
        self
    }
    pub fn max_shader_group_stride(
        mut self,
        max_shader_group_stride: u32,
    ) -> PhysicalDeviceRayTracingPropertiesKHRBuilder<'a> {
        self.inner.max_shader_group_stride = max_shader_group_stride;
        self
    }
    pub fn shader_group_base_alignment(
        mut self,
        shader_group_base_alignment: u32,
    ) -> PhysicalDeviceRayTracingPropertiesKHRBuilder<'a> {
        self.inner.shader_group_base_alignment = shader_group_base_alignment;
        self
    }
    pub fn max_geometry_count(
        mut self,
        max_geometry_count: u64,
    ) -> PhysicalDeviceRayTracingPropertiesKHRBuilder<'a> {
        self.inner.max_geometry_count = max_geometry_count;
        self
    }
    pub fn max_instance_count(
        mut self,
        max_instance_count: u64,
    ) -> PhysicalDeviceRayTracingPropertiesKHRBuilder<'a> {
        self.inner.max_instance_count = max_instance_count;
        self
    }
    pub fn max_primitive_count(
        mut self,
        max_primitive_count: u64,
    ) -> PhysicalDeviceRayTracingPropertiesKHRBuilder<'a> {
        self.inner.max_primitive_count = max_primitive_count;
        self
    }
    pub fn max_descriptor_set_acceleration_structures(
        mut self,
        max_descriptor_set_acceleration_structures: u32,
    ) -> PhysicalDeviceRayTracingPropertiesKHRBuilder<'a> {
        self.inner.max_descriptor_set_acceleration_structures =
            max_descriptor_set_acceleration_structures;
        self
    }
    pub fn shader_group_handle_capture_replay_size(
        mut self,
        shader_group_handle_capture_replay_size: u32,
    ) -> PhysicalDeviceRayTracingPropertiesKHRBuilder<'a> {
        self.inner.shader_group_handle_capture_replay_size =
            shader_group_handle_capture_replay_size;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDeviceRayTracingPropertiesKHR {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceRayTracingPropertiesNV.html>"]
pub struct PhysicalDeviceRayTracingPropertiesNV {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub shader_group_handle_size: u32,
    pub max_recursion_depth: u32,
    pub max_shader_group_stride: u32,
    pub shader_group_base_alignment: u32,
    pub max_geometry_count: u64,
    pub max_instance_count: u64,
    pub max_triangle_count: u64,
    pub max_descriptor_set_acceleration_structures: u32,
}
impl ::std::default::Default for PhysicalDeviceRayTracingPropertiesNV {
    fn default() -> PhysicalDeviceRayTracingPropertiesNV {
        PhysicalDeviceRayTracingPropertiesNV {
            s_type: StructureType::PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV,
            p_next: ::std::ptr::null_mut(),
            shader_group_handle_size: u32::default(),
            max_recursion_depth: u32::default(),
            max_shader_group_stride: u32::default(),
            shader_group_base_alignment: u32::default(),
            max_geometry_count: u64::default(),
            max_instance_count: u64::default(),
            max_triangle_count: u64::default(),
            max_descriptor_set_acceleration_structures: u32::default(),
        }
    }
}
impl PhysicalDeviceRayTracingPropertiesNV {
    pub fn builder<'a>() -> PhysicalDeviceRayTracingPropertiesNVBuilder<'a> {
        PhysicalDeviceRayTracingPropertiesNVBuilder {
            inner: PhysicalDeviceRayTracingPropertiesNV::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDeviceRayTracingPropertiesNVBuilder<'a> {
    inner: PhysicalDeviceRayTracingPropertiesNV,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceRayTracingPropertiesNVBuilder<'_> {}
unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceRayTracingPropertiesNV {}
impl<'a> ::std::ops::Deref for PhysicalDeviceRayTracingPropertiesNVBuilder<'a> {
    type Target = PhysicalDeviceRayTracingPropertiesNV;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PhysicalDeviceRayTracingPropertiesNVBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDeviceRayTracingPropertiesNVBuilder<'a> {
    pub fn shader_group_handle_size(
        mut self,
        shader_group_handle_size: u32,
    ) -> PhysicalDeviceRayTracingPropertiesNVBuilder<'a> {
        self.inner.shader_group_handle_size = shader_group_handle_size;
        self
    }
    pub fn max_recursion_depth(
        mut self,
        max_recursion_depth: u32,
    ) -> PhysicalDeviceRayTracingPropertiesNVBuilder<'a> {
        self.inner.max_recursion_depth = max_recursion_depth;
        self
    }
    pub fn max_shader_group_stride(
        mut self,
        max_shader_group_stride: u32,
    ) -> PhysicalDeviceRayTracingPropertiesNVBuilder<'a> {
        self.inner.max_shader_group_stride = max_shader_group_stride;
        self
    }
    pub fn shader_group_base_alignment(
        mut self,
        shader_group_base_alignment: u32,
    ) -> PhysicalDeviceRayTracingPropertiesNVBuilder<'a> {
        self.inner.shader_group_base_alignment = shader_group_base_alignment;
        self
    }
    pub fn max_geometry_count(
        mut self,
        max_geometry_count: u64,
    ) -> PhysicalDeviceRayTracingPropertiesNVBuilder<'a> {
        self.inner.max_geometry_count = max_geometry_count;
        self
    }
    pub fn max_instance_count(
        mut self,
        max_instance_count: u64,
    ) -> PhysicalDeviceRayTracingPropertiesNVBuilder<'a> {
        self.inner.max_instance_count = max_instance_count;
        self
    }
    pub fn max_triangle_count(
        mut self,
        max_triangle_count: u64,
    ) -> PhysicalDeviceRayTracingPropertiesNVBuilder<'a> {
        self.inner.max_triangle_count = max_triangle_count;
        self
    }
    pub fn max_descriptor_set_acceleration_structures(
        mut self,
        max_descriptor_set_acceleration_structures: u32,
    ) -> PhysicalDeviceRayTracingPropertiesNVBuilder<'a> {
        self.inner.max_descriptor_set_acceleration_structures =
            max_descriptor_set_acceleration_structures;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDeviceRayTracingPropertiesNV {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Default, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkStridedBufferRegionKHR.html>"]
pub struct StridedBufferRegionKHR {
    pub buffer: Buffer,
    pub offset: DeviceSize,
    pub stride: DeviceSize,
    pub size: DeviceSize,
}
impl StridedBufferRegionKHR {
    pub fn builder<'a>() -> StridedBufferRegionKHRBuilder<'a> {
        StridedBufferRegionKHRBuilder {
            inner: StridedBufferRegionKHR::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct StridedBufferRegionKHRBuilder<'a> {
    inner: StridedBufferRegionKHR,
    marker: ::std::marker::PhantomData<&'a ()>,
}
impl<'a> ::std::ops::Deref for StridedBufferRegionKHRBuilder<'a> {
    type Target = StridedBufferRegionKHR;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for StridedBufferRegionKHRBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> StridedBufferRegionKHRBuilder<'a> {
    pub fn buffer(mut self, buffer: Buffer) -> StridedBufferRegionKHRBuilder<'a> {
        self.inner.buffer = buffer;
        self
    }
    pub fn offset(mut self, offset: DeviceSize) -> StridedBufferRegionKHRBuilder<'a> {
        self.inner.offset = offset;
        self
    }
    pub fn stride(mut self, stride: DeviceSize) -> StridedBufferRegionKHRBuilder<'a> {
        self.inner.stride = stride;
        self
    }
    pub fn size(mut self, size: DeviceSize) -> StridedBufferRegionKHRBuilder<'a> {
        self.inner.size = size;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> StridedBufferRegionKHR {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Default, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkTraceRaysIndirectCommandKHR.html>"]
pub struct TraceRaysIndirectCommandKHR {
    pub width: u32,
    pub height: u32,
    pub depth: u32,
}
impl TraceRaysIndirectCommandKHR {
    pub fn builder<'a>() -> TraceRaysIndirectCommandKHRBuilder<'a> {
        TraceRaysIndirectCommandKHRBuilder {
            inner: TraceRaysIndirectCommandKHR::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct TraceRaysIndirectCommandKHRBuilder<'a> {
    inner: TraceRaysIndirectCommandKHR,
    marker: ::std::marker::PhantomData<&'a ()>,
}
impl<'a> ::std::ops::Deref for TraceRaysIndirectCommandKHRBuilder<'a> {
    type Target = TraceRaysIndirectCommandKHR;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for TraceRaysIndirectCommandKHRBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> TraceRaysIndirectCommandKHRBuilder<'a> {
    pub fn width(mut self, width: u32) -> TraceRaysIndirectCommandKHRBuilder<'a> {
        self.inner.width = width;
        self
    }
    pub fn height(mut self, height: u32) -> TraceRaysIndirectCommandKHRBuilder<'a> {
        self.inner.height = height;
        self
    }
    pub fn depth(mut self, depth: u32) -> TraceRaysIndirectCommandKHRBuilder<'a> {
        self.inner.depth = depth;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> TraceRaysIndirectCommandKHR {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDrmFormatModifierPropertiesListEXT.html>"]
pub struct DrmFormatModifierPropertiesListEXT {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub drm_format_modifier_count: u32,
    pub p_drm_format_modifier_properties: *mut DrmFormatModifierPropertiesEXT,
}
impl ::std::default::Default for DrmFormatModifierPropertiesListEXT {
    fn default() -> DrmFormatModifierPropertiesListEXT {
        DrmFormatModifierPropertiesListEXT {
            s_type: StructureType::DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT,
            p_next: ::std::ptr::null_mut(),
            drm_format_modifier_count: u32::default(),
            p_drm_format_modifier_properties: ::std::ptr::null_mut(),
        }
    }
}
impl DrmFormatModifierPropertiesListEXT {
    pub fn builder<'a>() -> DrmFormatModifierPropertiesListEXTBuilder<'a> {
        DrmFormatModifierPropertiesListEXTBuilder {
            inner: DrmFormatModifierPropertiesListEXT::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct DrmFormatModifierPropertiesListEXTBuilder<'a> {
    inner: DrmFormatModifierPropertiesListEXT,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsFormatProperties2 for DrmFormatModifierPropertiesListEXTBuilder<'_> {}
unsafe impl ExtendsFormatProperties2 for DrmFormatModifierPropertiesListEXT {}
impl<'a> ::std::ops::Deref for DrmFormatModifierPropertiesListEXTBuilder<'a> {
    type Target = DrmFormatModifierPropertiesListEXT;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for DrmFormatModifierPropertiesListEXTBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> DrmFormatModifierPropertiesListEXTBuilder<'a> {
    pub fn drm_format_modifier_properties(
        mut self,
        drm_format_modifier_properties: &'a mut [DrmFormatModifierPropertiesEXT],
    ) -> DrmFormatModifierPropertiesListEXTBuilder<'a> {
        self.inner.drm_format_modifier_count = drm_format_modifier_properties.len() as _;
        self.inner.p_drm_format_modifier_properties = drm_format_modifier_properties.as_mut_ptr();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> DrmFormatModifierPropertiesListEXT {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Default, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDrmFormatModifierPropertiesEXT.html>"]
pub struct DrmFormatModifierPropertiesEXT {
    pub drm_format_modifier: u64,
    pub drm_format_modifier_plane_count: u32,
    pub drm_format_modifier_tiling_features: FormatFeatureFlags,
}
impl DrmFormatModifierPropertiesEXT {
    pub fn builder<'a>() -> DrmFormatModifierPropertiesEXTBuilder<'a> {
        DrmFormatModifierPropertiesEXTBuilder {
            inner: DrmFormatModifierPropertiesEXT::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct DrmFormatModifierPropertiesEXTBuilder<'a> {
    inner: DrmFormatModifierPropertiesEXT,
    marker: ::std::marker::PhantomData<&'a ()>,
}
impl<'a> ::std::ops::Deref for DrmFormatModifierPropertiesEXTBuilder<'a> {
    type Target = DrmFormatModifierPropertiesEXT;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for DrmFormatModifierPropertiesEXTBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> DrmFormatModifierPropertiesEXTBuilder<'a> {
    pub fn drm_format_modifier(
        mut self,
        drm_format_modifier: u64,
    ) -> DrmFormatModifierPropertiesEXTBuilder<'a> {
        self.inner.drm_format_modifier = drm_format_modifier;
        self
    }
    pub fn drm_format_modifier_plane_count(
        mut self,
        drm_format_modifier_plane_count: u32,
    ) -> DrmFormatModifierPropertiesEXTBuilder<'a> {
        self.inner.drm_format_modifier_plane_count = drm_format_modifier_plane_count;
        self
    }
    pub fn drm_format_modifier_tiling_features(
        mut self,
        drm_format_modifier_tiling_features: FormatFeatureFlags,
    ) -> DrmFormatModifierPropertiesEXTBuilder<'a> {
        self.inner.drm_format_modifier_tiling_features = drm_format_modifier_tiling_features;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> DrmFormatModifierPropertiesEXT {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceImageDrmFormatModifierInfoEXT.html>"]
pub struct PhysicalDeviceImageDrmFormatModifierInfoEXT {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub drm_format_modifier: u64,
    pub sharing_mode: SharingMode,
    pub queue_family_index_count: u32,
    pub p_queue_family_indices: *const u32,
}
impl ::std::default::Default for PhysicalDeviceImageDrmFormatModifierInfoEXT {
    fn default() -> PhysicalDeviceImageDrmFormatModifierInfoEXT {
        PhysicalDeviceImageDrmFormatModifierInfoEXT {
            s_type: StructureType::PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT,
            p_next: ::std::ptr::null(),
            drm_format_modifier: u64::default(),
            sharing_mode: SharingMode::default(),
            queue_family_index_count: u32::default(),
            p_queue_family_indices: ::std::ptr::null(),
        }
    }
}
impl PhysicalDeviceImageDrmFormatModifierInfoEXT {
    pub fn builder<'a>() -> PhysicalDeviceImageDrmFormatModifierInfoEXTBuilder<'a> {
        PhysicalDeviceImageDrmFormatModifierInfoEXTBuilder {
            inner: PhysicalDeviceImageDrmFormatModifierInfoEXT::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDeviceImageDrmFormatModifierInfoEXTBuilder<'a> {
    inner: PhysicalDeviceImageDrmFormatModifierInfoEXT,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsPhysicalDeviceImageFormatInfo2
    for PhysicalDeviceImageDrmFormatModifierInfoEXTBuilder<'_>
{
}
unsafe impl ExtendsPhysicalDeviceImageFormatInfo2 for PhysicalDeviceImageDrmFormatModifierInfoEXT {}
impl<'a> ::std::ops::Deref for PhysicalDeviceImageDrmFormatModifierInfoEXTBuilder<'a> {
    type Target = PhysicalDeviceImageDrmFormatModifierInfoEXT;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PhysicalDeviceImageDrmFormatModifierInfoEXTBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDeviceImageDrmFormatModifierInfoEXTBuilder<'a> {
    pub fn drm_format_modifier(
        mut self,
        drm_format_modifier: u64,
    ) -> PhysicalDeviceImageDrmFormatModifierInfoEXTBuilder<'a> {
        self.inner.drm_format_modifier = drm_format_modifier;
        self
    }
    pub fn sharing_mode(
        mut self,
        sharing_mode: SharingMode,
    ) -> PhysicalDeviceImageDrmFormatModifierInfoEXTBuilder<'a> {
        self.inner.sharing_mode = sharing_mode;
        self
    }
    pub fn queue_family_indices(
        mut self,
        queue_family_indices: &'a [u32],
    ) -> PhysicalDeviceImageDrmFormatModifierInfoEXTBuilder<'a> {
        self.inner.queue_family_index_count = queue_family_indices.len() as _;
        self.inner.p_queue_family_indices = queue_family_indices.as_ptr();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDeviceImageDrmFormatModifierInfoEXT {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImageDrmFormatModifierListCreateInfoEXT.html>"]
pub struct ImageDrmFormatModifierListCreateInfoEXT {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub drm_format_modifier_count: u32,
    pub p_drm_format_modifiers: *const u64,
}
impl ::std::default::Default for ImageDrmFormatModifierListCreateInfoEXT {
    fn default() -> ImageDrmFormatModifierListCreateInfoEXT {
        ImageDrmFormatModifierListCreateInfoEXT {
            s_type: StructureType::IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT,
            p_next: ::std::ptr::null(),
            drm_format_modifier_count: u32::default(),
            p_drm_format_modifiers: ::std::ptr::null(),
        }
    }
}
impl ImageDrmFormatModifierListCreateInfoEXT {
    pub fn builder<'a>() -> ImageDrmFormatModifierListCreateInfoEXTBuilder<'a> {
        ImageDrmFormatModifierListCreateInfoEXTBuilder {
            inner: ImageDrmFormatModifierListCreateInfoEXT::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct ImageDrmFormatModifierListCreateInfoEXTBuilder<'a> {
    inner: ImageDrmFormatModifierListCreateInfoEXT,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsImageCreateInfo for ImageDrmFormatModifierListCreateInfoEXTBuilder<'_> {}
unsafe impl ExtendsImageCreateInfo for ImageDrmFormatModifierListCreateInfoEXT {}
impl<'a> ::std::ops::Deref for ImageDrmFormatModifierListCreateInfoEXTBuilder<'a> {
    type Target = ImageDrmFormatModifierListCreateInfoEXT;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for ImageDrmFormatModifierListCreateInfoEXTBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> ImageDrmFormatModifierListCreateInfoEXTBuilder<'a> {
    pub fn drm_format_modifiers(
        mut self,
        drm_format_modifiers: &'a [u64],
    ) -> ImageDrmFormatModifierListCreateInfoEXTBuilder<'a> {
        self.inner.drm_format_modifier_count = drm_format_modifiers.len() as _;
        self.inner.p_drm_format_modifiers = drm_format_modifiers.as_ptr();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> ImageDrmFormatModifierListCreateInfoEXT {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImageDrmFormatModifierExplicitCreateInfoEXT.html>"]
pub struct ImageDrmFormatModifierExplicitCreateInfoEXT {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub drm_format_modifier: u64,
    pub drm_format_modifier_plane_count: u32,
    pub p_plane_layouts: *const SubresourceLayout,
}
impl ::std::default::Default for ImageDrmFormatModifierExplicitCreateInfoEXT {
    fn default() -> ImageDrmFormatModifierExplicitCreateInfoEXT {
        ImageDrmFormatModifierExplicitCreateInfoEXT {
            s_type: StructureType::IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT,
            p_next: ::std::ptr::null(),
            drm_format_modifier: u64::default(),
            drm_format_modifier_plane_count: u32::default(),
            p_plane_layouts: ::std::ptr::null(),
        }
    }
}
impl ImageDrmFormatModifierExplicitCreateInfoEXT {
    pub fn builder<'a>() -> ImageDrmFormatModifierExplicitCreateInfoEXTBuilder<'a> {
        ImageDrmFormatModifierExplicitCreateInfoEXTBuilder {
            inner: ImageDrmFormatModifierExplicitCreateInfoEXT::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct ImageDrmFormatModifierExplicitCreateInfoEXTBuilder<'a> {
    inner: ImageDrmFormatModifierExplicitCreateInfoEXT,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsImageCreateInfo for ImageDrmFormatModifierExplicitCreateInfoEXTBuilder<'_> {}
unsafe impl ExtendsImageCreateInfo for ImageDrmFormatModifierExplicitCreateInfoEXT {}
impl<'a> ::std::ops::Deref for ImageDrmFormatModifierExplicitCreateInfoEXTBuilder<'a> {
    type Target = ImageDrmFormatModifierExplicitCreateInfoEXT;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for ImageDrmFormatModifierExplicitCreateInfoEXTBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> ImageDrmFormatModifierExplicitCreateInfoEXTBuilder<'a> {
    pub fn drm_format_modifier(
        mut self,
        drm_format_modifier: u64,
    ) -> ImageDrmFormatModifierExplicitCreateInfoEXTBuilder<'a> {
        self.inner.drm_format_modifier = drm_format_modifier;
        self
    }
    pub fn plane_layouts(
        mut self,
        plane_layouts: &'a [SubresourceLayout],
    ) -> ImageDrmFormatModifierExplicitCreateInfoEXTBuilder<'a> {
        self.inner.drm_format_modifier_plane_count = plane_layouts.len() as _;
        self.inner.p_plane_layouts = plane_layouts.as_ptr();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> ImageDrmFormatModifierExplicitCreateInfoEXT {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImageDrmFormatModifierPropertiesEXT.html>"]
pub struct ImageDrmFormatModifierPropertiesEXT {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub drm_format_modifier: u64,
}
impl ::std::default::Default for ImageDrmFormatModifierPropertiesEXT {
    fn default() -> ImageDrmFormatModifierPropertiesEXT {
        ImageDrmFormatModifierPropertiesEXT {
            s_type: StructureType::IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT,
            p_next: ::std::ptr::null_mut(),
            drm_format_modifier: u64::default(),
        }
    }
}
impl ImageDrmFormatModifierPropertiesEXT {
    pub fn builder<'a>() -> ImageDrmFormatModifierPropertiesEXTBuilder<'a> {
        ImageDrmFormatModifierPropertiesEXTBuilder {
            inner: ImageDrmFormatModifierPropertiesEXT::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct ImageDrmFormatModifierPropertiesEXTBuilder<'a> {
    inner: ImageDrmFormatModifierPropertiesEXT,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsImageDrmFormatModifierPropertiesEXT {}
impl<'a> ::std::ops::Deref for ImageDrmFormatModifierPropertiesEXTBuilder<'a> {
    type Target = ImageDrmFormatModifierPropertiesEXT;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for ImageDrmFormatModifierPropertiesEXTBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> ImageDrmFormatModifierPropertiesEXTBuilder<'a> {
    pub fn drm_format_modifier(
        mut self,
        drm_format_modifier: u64,
    ) -> ImageDrmFormatModifierPropertiesEXTBuilder<'a> {
        self.inner.drm_format_modifier = drm_format_modifier;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsImageDrmFormatModifierPropertiesEXT>(
        mut self,
        next: &'a mut T,
    ) -> ImageDrmFormatModifierPropertiesEXTBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> ImageDrmFormatModifierPropertiesEXT {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImageStencilUsageCreateInfo.html>"]
pub struct ImageStencilUsageCreateInfo {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub stencil_usage: ImageUsageFlags,
}
impl ::std::default::Default for ImageStencilUsageCreateInfo {
    fn default() -> ImageStencilUsageCreateInfo {
        ImageStencilUsageCreateInfo {
            s_type: StructureType::IMAGE_STENCIL_USAGE_CREATE_INFO,
            p_next: ::std::ptr::null(),
            stencil_usage: ImageUsageFlags::default(),
        }
    }
}
impl ImageStencilUsageCreateInfo {
    pub fn builder<'a>() -> ImageStencilUsageCreateInfoBuilder<'a> {
        ImageStencilUsageCreateInfoBuilder {
            inner: ImageStencilUsageCreateInfo::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct ImageStencilUsageCreateInfoBuilder<'a> {
    inner: ImageStencilUsageCreateInfo,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsImageCreateInfo for ImageStencilUsageCreateInfoBuilder<'_> {}
unsafe impl ExtendsImageCreateInfo for ImageStencilUsageCreateInfo {}
unsafe impl ExtendsPhysicalDeviceImageFormatInfo2 for ImageStencilUsageCreateInfoBuilder<'_> {}
unsafe impl ExtendsPhysicalDeviceImageFormatInfo2 for ImageStencilUsageCreateInfo {}
impl<'a> ::std::ops::Deref for ImageStencilUsageCreateInfoBuilder<'a> {
    type Target = ImageStencilUsageCreateInfo;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for ImageStencilUsageCreateInfoBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> ImageStencilUsageCreateInfoBuilder<'a> {
    pub fn stencil_usage(
        mut self,
        stencil_usage: ImageUsageFlags,
    ) -> ImageStencilUsageCreateInfoBuilder<'a> {
        self.inner.stencil_usage = stencil_usage;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> ImageStencilUsageCreateInfo {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDeviceMemoryOverallocationCreateInfoAMD.html>"]
pub struct DeviceMemoryOverallocationCreateInfoAMD {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub overallocation_behavior: MemoryOverallocationBehaviorAMD,
}
impl ::std::default::Default for DeviceMemoryOverallocationCreateInfoAMD {
    fn default() -> DeviceMemoryOverallocationCreateInfoAMD {
        DeviceMemoryOverallocationCreateInfoAMD {
            s_type: StructureType::DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD,
            p_next: ::std::ptr::null(),
            overallocation_behavior: MemoryOverallocationBehaviorAMD::default(),
        }
    }
}
impl DeviceMemoryOverallocationCreateInfoAMD {
    pub fn builder<'a>() -> DeviceMemoryOverallocationCreateInfoAMDBuilder<'a> {
        DeviceMemoryOverallocationCreateInfoAMDBuilder {
            inner: DeviceMemoryOverallocationCreateInfoAMD::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct DeviceMemoryOverallocationCreateInfoAMDBuilder<'a> {
    inner: DeviceMemoryOverallocationCreateInfoAMD,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsDeviceCreateInfo for DeviceMemoryOverallocationCreateInfoAMDBuilder<'_> {}
unsafe impl ExtendsDeviceCreateInfo for DeviceMemoryOverallocationCreateInfoAMD {}
impl<'a> ::std::ops::Deref for DeviceMemoryOverallocationCreateInfoAMDBuilder<'a> {
    type Target = DeviceMemoryOverallocationCreateInfoAMD;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for DeviceMemoryOverallocationCreateInfoAMDBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> DeviceMemoryOverallocationCreateInfoAMDBuilder<'a> {
    pub fn overallocation_behavior(
        mut self,
        overallocation_behavior: MemoryOverallocationBehaviorAMD,
    ) -> DeviceMemoryOverallocationCreateInfoAMDBuilder<'a> {
        self.inner.overallocation_behavior = overallocation_behavior;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> DeviceMemoryOverallocationCreateInfoAMD {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFragmentDensityMapFeaturesEXT.html>"]
pub struct PhysicalDeviceFragmentDensityMapFeaturesEXT {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub fragment_density_map: Bool32,
    pub fragment_density_map_dynamic: Bool32,
    pub fragment_density_map_non_subsampled_images: Bool32,
}
impl ::std::default::Default for PhysicalDeviceFragmentDensityMapFeaturesEXT {
    fn default() -> PhysicalDeviceFragmentDensityMapFeaturesEXT {
        PhysicalDeviceFragmentDensityMapFeaturesEXT {
            s_type: StructureType::PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT,
            p_next: ::std::ptr::null_mut(),
            fragment_density_map: Bool32::default(),
            fragment_density_map_dynamic: Bool32::default(),
            fragment_density_map_non_subsampled_images: Bool32::default(),
        }
    }
}
impl PhysicalDeviceFragmentDensityMapFeaturesEXT {
    pub fn builder<'a>() -> PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder<'a> {
        PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder {
            inner: PhysicalDeviceFragmentDensityMapFeaturesEXT::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder<'a> {
    inner: PhysicalDeviceFragmentDensityMapFeaturesEXT,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder<'_> {}
unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentDensityMapFeaturesEXT {}
impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder<'a> {
    type Target = PhysicalDeviceFragmentDensityMapFeaturesEXT;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder<'a> {
    pub fn fragment_density_map(
        mut self,
        fragment_density_map: bool,
    ) -> PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder<'a> {
        self.inner.fragment_density_map = fragment_density_map.into();
        self
    }
    pub fn fragment_density_map_dynamic(
        mut self,
        fragment_density_map_dynamic: bool,
    ) -> PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder<'a> {
        self.inner.fragment_density_map_dynamic = fragment_density_map_dynamic.into();
        self
    }
    pub fn fragment_density_map_non_subsampled_images(
        mut self,
        fragment_density_map_non_subsampled_images: bool,
    ) -> PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder<'a> {
        self.inner.fragment_density_map_non_subsampled_images =
            fragment_density_map_non_subsampled_images.into();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDeviceFragmentDensityMapFeaturesEXT {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFragmentDensityMapPropertiesEXT.html>"]
pub struct PhysicalDeviceFragmentDensityMapPropertiesEXT {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub min_fragment_density_texel_size: Extent2D,
    pub max_fragment_density_texel_size: Extent2D,
    pub fragment_density_invocations: Bool32,
}
impl ::std::default::Default for PhysicalDeviceFragmentDensityMapPropertiesEXT {
    fn default() -> PhysicalDeviceFragmentDensityMapPropertiesEXT {
        PhysicalDeviceFragmentDensityMapPropertiesEXT {
            s_type: StructureType::PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT,
            p_next: ::std::ptr::null_mut(),
            min_fragment_density_texel_size: Extent2D::default(),
            max_fragment_density_texel_size: Extent2D::default(),
            fragment_density_invocations: Bool32::default(),
        }
    }
}
impl PhysicalDeviceFragmentDensityMapPropertiesEXT {
    pub fn builder<'a>() -> PhysicalDeviceFragmentDensityMapPropertiesEXTBuilder<'a> {
        PhysicalDeviceFragmentDensityMapPropertiesEXTBuilder {
            inner: PhysicalDeviceFragmentDensityMapPropertiesEXT::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDeviceFragmentDensityMapPropertiesEXTBuilder<'a> {
    inner: PhysicalDeviceFragmentDensityMapPropertiesEXT,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsPhysicalDeviceProperties2
    for PhysicalDeviceFragmentDensityMapPropertiesEXTBuilder<'_>
{
}
unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceFragmentDensityMapPropertiesEXT {}
impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentDensityMapPropertiesEXTBuilder<'a> {
    type Target = PhysicalDeviceFragmentDensityMapPropertiesEXT;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentDensityMapPropertiesEXTBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDeviceFragmentDensityMapPropertiesEXTBuilder<'a> {
    pub fn min_fragment_density_texel_size(
        mut self,
        min_fragment_density_texel_size: Extent2D,
    ) -> PhysicalDeviceFragmentDensityMapPropertiesEXTBuilder<'a> {
        self.inner.min_fragment_density_texel_size = min_fragment_density_texel_size;
        self
    }
    pub fn max_fragment_density_texel_size(
        mut self,
        max_fragment_density_texel_size: Extent2D,
    ) -> PhysicalDeviceFragmentDensityMapPropertiesEXTBuilder<'a> {
        self.inner.max_fragment_density_texel_size = max_fragment_density_texel_size;
        self
    }
    pub fn fragment_density_invocations(
        mut self,
        fragment_density_invocations: bool,
    ) -> PhysicalDeviceFragmentDensityMapPropertiesEXTBuilder<'a> {
        self.inner.fragment_density_invocations = fragment_density_invocations.into();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDeviceFragmentDensityMapPropertiesEXT {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkRenderPassFragmentDensityMapCreateInfoEXT.html>"]
pub struct RenderPassFragmentDensityMapCreateInfoEXT {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub fragment_density_map_attachment: AttachmentReference,
}
impl ::std::default::Default for RenderPassFragmentDensityMapCreateInfoEXT {
    fn default() -> RenderPassFragmentDensityMapCreateInfoEXT {
        RenderPassFragmentDensityMapCreateInfoEXT {
            s_type: StructureType::RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT,
            p_next: ::std::ptr::null(),
            fragment_density_map_attachment: AttachmentReference::default(),
        }
    }
}
impl RenderPassFragmentDensityMapCreateInfoEXT {
    pub fn builder<'a>() -> RenderPassFragmentDensityMapCreateInfoEXTBuilder<'a> {
        RenderPassFragmentDensityMapCreateInfoEXTBuilder {
            inner: RenderPassFragmentDensityMapCreateInfoEXT::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct RenderPassFragmentDensityMapCreateInfoEXTBuilder<'a> {
    inner: RenderPassFragmentDensityMapCreateInfoEXT,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsRenderPassCreateInfo for RenderPassFragmentDensityMapCreateInfoEXTBuilder<'_> {}
unsafe impl ExtendsRenderPassCreateInfo for RenderPassFragmentDensityMapCreateInfoEXT {}
unsafe impl ExtendsRenderPassCreateInfo2 for RenderPassFragmentDensityMapCreateInfoEXTBuilder<'_> {}
unsafe impl ExtendsRenderPassCreateInfo2 for RenderPassFragmentDensityMapCreateInfoEXT {}
impl<'a> ::std::ops::Deref for RenderPassFragmentDensityMapCreateInfoEXTBuilder<'a> {
    type Target = RenderPassFragmentDensityMapCreateInfoEXT;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for RenderPassFragmentDensityMapCreateInfoEXTBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> RenderPassFragmentDensityMapCreateInfoEXTBuilder<'a> {
    pub fn fragment_density_map_attachment(
        mut self,
        fragment_density_map_attachment: AttachmentReference,
    ) -> RenderPassFragmentDensityMapCreateInfoEXTBuilder<'a> {
        self.inner.fragment_density_map_attachment = fragment_density_map_attachment;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> RenderPassFragmentDensityMapCreateInfoEXT {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceScalarBlockLayoutFeatures.html>"]
pub struct PhysicalDeviceScalarBlockLayoutFeatures {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub scalar_block_layout: Bool32,
}
impl ::std::default::Default for PhysicalDeviceScalarBlockLayoutFeatures {
    fn default() -> PhysicalDeviceScalarBlockLayoutFeatures {
        PhysicalDeviceScalarBlockLayoutFeatures {
            s_type: StructureType::PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES,
            p_next: ::std::ptr::null_mut(),
            scalar_block_layout: Bool32::default(),
        }
    }
}
impl PhysicalDeviceScalarBlockLayoutFeatures {
    pub fn builder<'a>() -> PhysicalDeviceScalarBlockLayoutFeaturesBuilder<'a> {
        PhysicalDeviceScalarBlockLayoutFeaturesBuilder {
            inner: PhysicalDeviceScalarBlockLayoutFeatures::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDeviceScalarBlockLayoutFeaturesBuilder<'a> {
    inner: PhysicalDeviceScalarBlockLayoutFeatures,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceScalarBlockLayoutFeaturesBuilder<'_> {}
unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceScalarBlockLayoutFeatures {}
impl<'a> ::std::ops::Deref for PhysicalDeviceScalarBlockLayoutFeaturesBuilder<'a> {
    type Target = PhysicalDeviceScalarBlockLayoutFeatures;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PhysicalDeviceScalarBlockLayoutFeaturesBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDeviceScalarBlockLayoutFeaturesBuilder<'a> {
    pub fn scalar_block_layout(
        mut self,
        scalar_block_layout: bool,
    ) -> PhysicalDeviceScalarBlockLayoutFeaturesBuilder<'a> {
        self.inner.scalar_block_layout = scalar_block_layout.into();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDeviceScalarBlockLayoutFeatures {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSurfaceProtectedCapabilitiesKHR.html>"]
pub struct SurfaceProtectedCapabilitiesKHR {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub supports_protected: Bool32,
}
impl ::std::default::Default for SurfaceProtectedCapabilitiesKHR {
    fn default() -> SurfaceProtectedCapabilitiesKHR {
        SurfaceProtectedCapabilitiesKHR {
            s_type: StructureType::SURFACE_PROTECTED_CAPABILITIES_KHR,
            p_next: ::std::ptr::null(),
            supports_protected: Bool32::default(),
        }
    }
}
impl SurfaceProtectedCapabilitiesKHR {
    pub fn builder<'a>() -> SurfaceProtectedCapabilitiesKHRBuilder<'a> {
        SurfaceProtectedCapabilitiesKHRBuilder {
            inner: SurfaceProtectedCapabilitiesKHR::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct SurfaceProtectedCapabilitiesKHRBuilder<'a> {
    inner: SurfaceProtectedCapabilitiesKHR,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsSurfaceCapabilities2KHR for SurfaceProtectedCapabilitiesKHRBuilder<'_> {}
unsafe impl ExtendsSurfaceCapabilities2KHR for SurfaceProtectedCapabilitiesKHR {}
impl<'a> ::std::ops::Deref for SurfaceProtectedCapabilitiesKHRBuilder<'a> {
    type Target = SurfaceProtectedCapabilitiesKHR;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for SurfaceProtectedCapabilitiesKHRBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> SurfaceProtectedCapabilitiesKHRBuilder<'a> {
    pub fn supports_protected(
        mut self,
        supports_protected: bool,
    ) -> SurfaceProtectedCapabilitiesKHRBuilder<'a> {
        self.inner.supports_protected = supports_protected.into();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> SurfaceProtectedCapabilitiesKHR {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceUniformBufferStandardLayoutFeatures.html>"]
pub struct PhysicalDeviceUniformBufferStandardLayoutFeatures {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub uniform_buffer_standard_layout: Bool32,
}
impl ::std::default::Default for PhysicalDeviceUniformBufferStandardLayoutFeatures {
    fn default() -> PhysicalDeviceUniformBufferStandardLayoutFeatures {
        PhysicalDeviceUniformBufferStandardLayoutFeatures {
            s_type: StructureType::PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES,
            p_next: ::std::ptr::null_mut(),
            uniform_buffer_standard_layout: Bool32::default(),
        }
    }
}
impl PhysicalDeviceUniformBufferStandardLayoutFeatures {
    pub fn builder<'a>() -> PhysicalDeviceUniformBufferStandardLayoutFeaturesBuilder<'a> {
        PhysicalDeviceUniformBufferStandardLayoutFeaturesBuilder {
            inner: PhysicalDeviceUniformBufferStandardLayoutFeatures::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDeviceUniformBufferStandardLayoutFeaturesBuilder<'a> {
    inner: PhysicalDeviceUniformBufferStandardLayoutFeatures,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsDeviceCreateInfo
    for PhysicalDeviceUniformBufferStandardLayoutFeaturesBuilder<'_>
{
}
unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceUniformBufferStandardLayoutFeatures {}
impl<'a> ::std::ops::Deref for PhysicalDeviceUniformBufferStandardLayoutFeaturesBuilder<'a> {
    type Target = PhysicalDeviceUniformBufferStandardLayoutFeatures;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PhysicalDeviceUniformBufferStandardLayoutFeaturesBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDeviceUniformBufferStandardLayoutFeaturesBuilder<'a> {
    pub fn uniform_buffer_standard_layout(
        mut self,
        uniform_buffer_standard_layout: bool,
    ) -> PhysicalDeviceUniformBufferStandardLayoutFeaturesBuilder<'a> {
        self.inner.uniform_buffer_standard_layout = uniform_buffer_standard_layout.into();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDeviceUniformBufferStandardLayoutFeatures {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceDepthClipEnableFeaturesEXT.html>"]
pub struct PhysicalDeviceDepthClipEnableFeaturesEXT {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub depth_clip_enable: Bool32,
}
impl ::std::default::Default for PhysicalDeviceDepthClipEnableFeaturesEXT {
    fn default() -> PhysicalDeviceDepthClipEnableFeaturesEXT {
        PhysicalDeviceDepthClipEnableFeaturesEXT {
            s_type: StructureType::PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT,
            p_next: ::std::ptr::null_mut(),
            depth_clip_enable: Bool32::default(),
        }
    }
}
impl PhysicalDeviceDepthClipEnableFeaturesEXT {
    pub fn builder<'a>() -> PhysicalDeviceDepthClipEnableFeaturesEXTBuilder<'a> {
        PhysicalDeviceDepthClipEnableFeaturesEXTBuilder {
            inner: PhysicalDeviceDepthClipEnableFeaturesEXT::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDeviceDepthClipEnableFeaturesEXTBuilder<'a> {
    inner: PhysicalDeviceDepthClipEnableFeaturesEXT,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDepthClipEnableFeaturesEXTBuilder<'_> {}
unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDepthClipEnableFeaturesEXT {}
impl<'a> ::std::ops::Deref for PhysicalDeviceDepthClipEnableFeaturesEXTBuilder<'a> {
    type Target = PhysicalDeviceDepthClipEnableFeaturesEXT;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PhysicalDeviceDepthClipEnableFeaturesEXTBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDeviceDepthClipEnableFeaturesEXTBuilder<'a> {
    pub fn depth_clip_enable(
        mut self,
        depth_clip_enable: bool,
    ) -> PhysicalDeviceDepthClipEnableFeaturesEXTBuilder<'a> {
        self.inner.depth_clip_enable = depth_clip_enable.into();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDeviceDepthClipEnableFeaturesEXT {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineRasterizationDepthClipStateCreateInfoEXT.html>"]
pub struct PipelineRasterizationDepthClipStateCreateInfoEXT {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub flags: PipelineRasterizationDepthClipStateCreateFlagsEXT,
    pub depth_clip_enable: Bool32,
}
impl ::std::default::Default for PipelineRasterizationDepthClipStateCreateInfoEXT {
    fn default() -> PipelineRasterizationDepthClipStateCreateInfoEXT {
        PipelineRasterizationDepthClipStateCreateInfoEXT {
            s_type: StructureType::PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT,
            p_next: ::std::ptr::null(),
            flags: PipelineRasterizationDepthClipStateCreateFlagsEXT::default(),
            depth_clip_enable: Bool32::default(),
        }
    }
}
impl PipelineRasterizationDepthClipStateCreateInfoEXT {
    pub fn builder<'a>() -> PipelineRasterizationDepthClipStateCreateInfoEXTBuilder<'a> {
        PipelineRasterizationDepthClipStateCreateInfoEXTBuilder {
            inner: PipelineRasterizationDepthClipStateCreateInfoEXT::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PipelineRasterizationDepthClipStateCreateInfoEXTBuilder<'a> {
    inner: PipelineRasterizationDepthClipStateCreateInfoEXT,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsPipelineRasterizationStateCreateInfo
    for PipelineRasterizationDepthClipStateCreateInfoEXTBuilder<'_>
{
}
unsafe impl ExtendsPipelineRasterizationStateCreateInfo
    for PipelineRasterizationDepthClipStateCreateInfoEXT
{
}
impl<'a> ::std::ops::Deref for PipelineRasterizationDepthClipStateCreateInfoEXTBuilder<'a> {
    type Target = PipelineRasterizationDepthClipStateCreateInfoEXT;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PipelineRasterizationDepthClipStateCreateInfoEXTBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PipelineRasterizationDepthClipStateCreateInfoEXTBuilder<'a> {
    pub fn flags(
        mut self,
        flags: PipelineRasterizationDepthClipStateCreateFlagsEXT,
    ) -> PipelineRasterizationDepthClipStateCreateInfoEXTBuilder<'a> {
        self.inner.flags = flags;
        self
    }
    pub fn depth_clip_enable(
        mut self,
        depth_clip_enable: bool,
    ) -> PipelineRasterizationDepthClipStateCreateInfoEXTBuilder<'a> {
        self.inner.depth_clip_enable = depth_clip_enable.into();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PipelineRasterizationDepthClipStateCreateInfoEXT {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceMemoryBudgetPropertiesEXT.html>"]
pub struct PhysicalDeviceMemoryBudgetPropertiesEXT {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub heap_budget: [DeviceSize; MAX_MEMORY_HEAPS],
    pub heap_usage: [DeviceSize; MAX_MEMORY_HEAPS],
}
impl ::std::default::Default for PhysicalDeviceMemoryBudgetPropertiesEXT {
    fn default() -> PhysicalDeviceMemoryBudgetPropertiesEXT {
        PhysicalDeviceMemoryBudgetPropertiesEXT {
            s_type: StructureType::PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT,
            p_next: ::std::ptr::null_mut(),
            heap_budget: unsafe { ::std::mem::zeroed() },
            heap_usage: unsafe { ::std::mem::zeroed() },
        }
    }
}
impl PhysicalDeviceMemoryBudgetPropertiesEXT {
    pub fn builder<'a>() -> PhysicalDeviceMemoryBudgetPropertiesEXTBuilder<'a> {
        PhysicalDeviceMemoryBudgetPropertiesEXTBuilder {
            inner: PhysicalDeviceMemoryBudgetPropertiesEXT::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDeviceMemoryBudgetPropertiesEXTBuilder<'a> {
    inner: PhysicalDeviceMemoryBudgetPropertiesEXT,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsPhysicalDeviceMemoryProperties2
    for PhysicalDeviceMemoryBudgetPropertiesEXTBuilder<'_>
{
}
unsafe impl ExtendsPhysicalDeviceMemoryProperties2 for PhysicalDeviceMemoryBudgetPropertiesEXT {}
impl<'a> ::std::ops::Deref for PhysicalDeviceMemoryBudgetPropertiesEXTBuilder<'a> {
    type Target = PhysicalDeviceMemoryBudgetPropertiesEXT;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PhysicalDeviceMemoryBudgetPropertiesEXTBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDeviceMemoryBudgetPropertiesEXTBuilder<'a> {
    pub fn heap_budget(
        mut self,
        heap_budget: [DeviceSize; MAX_MEMORY_HEAPS],
    ) -> PhysicalDeviceMemoryBudgetPropertiesEXTBuilder<'a> {
        self.inner.heap_budget = heap_budget;
        self
    }
    pub fn heap_usage(
        mut self,
        heap_usage: [DeviceSize; MAX_MEMORY_HEAPS],
    ) -> PhysicalDeviceMemoryBudgetPropertiesEXTBuilder<'a> {
        self.inner.heap_usage = heap_usage;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDeviceMemoryBudgetPropertiesEXT {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceMemoryPriorityFeaturesEXT.html>"]
pub struct PhysicalDeviceMemoryPriorityFeaturesEXT {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub memory_priority: Bool32,
}
impl ::std::default::Default for PhysicalDeviceMemoryPriorityFeaturesEXT {
    fn default() -> PhysicalDeviceMemoryPriorityFeaturesEXT {
        PhysicalDeviceMemoryPriorityFeaturesEXT {
            s_type: StructureType::PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT,
            p_next: ::std::ptr::null_mut(),
            memory_priority: Bool32::default(),
        }
    }
}
impl PhysicalDeviceMemoryPriorityFeaturesEXT {
    pub fn builder<'a>() -> PhysicalDeviceMemoryPriorityFeaturesEXTBuilder<'a> {
        PhysicalDeviceMemoryPriorityFeaturesEXTBuilder {
            inner: PhysicalDeviceMemoryPriorityFeaturesEXT::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDeviceMemoryPriorityFeaturesEXTBuilder<'a> {
    inner: PhysicalDeviceMemoryPriorityFeaturesEXT,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMemoryPriorityFeaturesEXTBuilder<'_> {}
unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMemoryPriorityFeaturesEXT {}
impl<'a> ::std::ops::Deref for PhysicalDeviceMemoryPriorityFeaturesEXTBuilder<'a> {
    type Target = PhysicalDeviceMemoryPriorityFeaturesEXT;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PhysicalDeviceMemoryPriorityFeaturesEXTBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDeviceMemoryPriorityFeaturesEXTBuilder<'a> {
    pub fn memory_priority(
        mut self,
        memory_priority: bool,
    ) -> PhysicalDeviceMemoryPriorityFeaturesEXTBuilder<'a> {
        self.inner.memory_priority = memory_priority.into();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDeviceMemoryPriorityFeaturesEXT {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkMemoryPriorityAllocateInfoEXT.html>"]
pub struct MemoryPriorityAllocateInfoEXT {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub priority: f32,
}
impl ::std::default::Default for MemoryPriorityAllocateInfoEXT {
    fn default() -> MemoryPriorityAllocateInfoEXT {
        MemoryPriorityAllocateInfoEXT {
            s_type: StructureType::MEMORY_PRIORITY_ALLOCATE_INFO_EXT,
            p_next: ::std::ptr::null(),
            priority: f32::default(),
        }
    }
}
impl MemoryPriorityAllocateInfoEXT {
    pub fn builder<'a>() -> MemoryPriorityAllocateInfoEXTBuilder<'a> {
        MemoryPriorityAllocateInfoEXTBuilder {
            inner: MemoryPriorityAllocateInfoEXT::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct MemoryPriorityAllocateInfoEXTBuilder<'a> {
    inner: MemoryPriorityAllocateInfoEXT,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsMemoryAllocateInfo for MemoryPriorityAllocateInfoEXTBuilder<'_> {}
unsafe impl ExtendsMemoryAllocateInfo for MemoryPriorityAllocateInfoEXT {}
impl<'a> ::std::ops::Deref for MemoryPriorityAllocateInfoEXTBuilder<'a> {
    type Target = MemoryPriorityAllocateInfoEXT;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for MemoryPriorityAllocateInfoEXTBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> MemoryPriorityAllocateInfoEXTBuilder<'a> {
    pub fn priority(mut self, priority: f32) -> MemoryPriorityAllocateInfoEXTBuilder<'a> {
        self.inner.priority = priority;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> MemoryPriorityAllocateInfoEXT {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceBufferDeviceAddressFeatures.html>"]
pub struct PhysicalDeviceBufferDeviceAddressFeatures {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub buffer_device_address: Bool32,
    pub buffer_device_address_capture_replay: Bool32,
    pub buffer_device_address_multi_device: Bool32,
}
impl ::std::default::Default for PhysicalDeviceBufferDeviceAddressFeatures {
    fn default() -> PhysicalDeviceBufferDeviceAddressFeatures {
        PhysicalDeviceBufferDeviceAddressFeatures {
            s_type: StructureType::PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES,
            p_next: ::std::ptr::null_mut(),
            buffer_device_address: Bool32::default(),
            buffer_device_address_capture_replay: Bool32::default(),
            buffer_device_address_multi_device: Bool32::default(),
        }
    }
}
impl PhysicalDeviceBufferDeviceAddressFeatures {
    pub fn builder<'a>() -> PhysicalDeviceBufferDeviceAddressFeaturesBuilder<'a> {
        PhysicalDeviceBufferDeviceAddressFeaturesBuilder {
            inner: PhysicalDeviceBufferDeviceAddressFeatures::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDeviceBufferDeviceAddressFeaturesBuilder<'a> {
    inner: PhysicalDeviceBufferDeviceAddressFeatures,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceBufferDeviceAddressFeaturesBuilder<'_> {}
unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceBufferDeviceAddressFeatures {}
impl<'a> ::std::ops::Deref for PhysicalDeviceBufferDeviceAddressFeaturesBuilder<'a> {
    type Target = PhysicalDeviceBufferDeviceAddressFeatures;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PhysicalDeviceBufferDeviceAddressFeaturesBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDeviceBufferDeviceAddressFeaturesBuilder<'a> {
    pub fn buffer_device_address(
        mut self,
        buffer_device_address: bool,
    ) -> PhysicalDeviceBufferDeviceAddressFeaturesBuilder<'a> {
        self.inner.buffer_device_address = buffer_device_address.into();
        self
    }
    pub fn buffer_device_address_capture_replay(
        mut self,
        buffer_device_address_capture_replay: bool,
    ) -> PhysicalDeviceBufferDeviceAddressFeaturesBuilder<'a> {
        self.inner.buffer_device_address_capture_replay =
            buffer_device_address_capture_replay.into();
        self
    }
    pub fn buffer_device_address_multi_device(
        mut self,
        buffer_device_address_multi_device: bool,
    ) -> PhysicalDeviceBufferDeviceAddressFeaturesBuilder<'a> {
        self.inner.buffer_device_address_multi_device = buffer_device_address_multi_device.into();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDeviceBufferDeviceAddressFeatures {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceBufferDeviceAddressFeaturesEXT.html>"]
pub struct PhysicalDeviceBufferDeviceAddressFeaturesEXT {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub buffer_device_address: Bool32,
    pub buffer_device_address_capture_replay: Bool32,
    pub buffer_device_address_multi_device: Bool32,
}
impl ::std::default::Default for PhysicalDeviceBufferDeviceAddressFeaturesEXT {
    fn default() -> PhysicalDeviceBufferDeviceAddressFeaturesEXT {
        PhysicalDeviceBufferDeviceAddressFeaturesEXT {
            s_type: StructureType::PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT,
            p_next: ::std::ptr::null_mut(),
            buffer_device_address: Bool32::default(),
            buffer_device_address_capture_replay: Bool32::default(),
            buffer_device_address_multi_device: Bool32::default(),
        }
    }
}
impl PhysicalDeviceBufferDeviceAddressFeaturesEXT {
    pub fn builder<'a>() -> PhysicalDeviceBufferDeviceAddressFeaturesEXTBuilder<'a> {
        PhysicalDeviceBufferDeviceAddressFeaturesEXTBuilder {
            inner: PhysicalDeviceBufferDeviceAddressFeaturesEXT::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDeviceBufferDeviceAddressFeaturesEXTBuilder<'a> {
    inner: PhysicalDeviceBufferDeviceAddressFeaturesEXT,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceBufferDeviceAddressFeaturesEXTBuilder<'_> {}
unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceBufferDeviceAddressFeaturesEXT {}
impl<'a> ::std::ops::Deref for PhysicalDeviceBufferDeviceAddressFeaturesEXTBuilder<'a> {
    type Target = PhysicalDeviceBufferDeviceAddressFeaturesEXT;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PhysicalDeviceBufferDeviceAddressFeaturesEXTBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDeviceBufferDeviceAddressFeaturesEXTBuilder<'a> {
    pub fn buffer_device_address(
        mut self,
        buffer_device_address: bool,
    ) -> PhysicalDeviceBufferDeviceAddressFeaturesEXTBuilder<'a> {
        self.inner.buffer_device_address = buffer_device_address.into();
        self
    }
    pub fn buffer_device_address_capture_replay(
        mut self,
        buffer_device_address_capture_replay: bool,
    ) -> PhysicalDeviceBufferDeviceAddressFeaturesEXTBuilder<'a> {
        self.inner.buffer_device_address_capture_replay =
            buffer_device_address_capture_replay.into();
        self
    }
    pub fn buffer_device_address_multi_device(
        mut self,
        buffer_device_address_multi_device: bool,
    ) -> PhysicalDeviceBufferDeviceAddressFeaturesEXTBuilder<'a> {
        self.inner.buffer_device_address_multi_device = buffer_device_address_multi_device.into();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDeviceBufferDeviceAddressFeaturesEXT {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkBufferDeviceAddressInfo.html>"]
pub struct BufferDeviceAddressInfo {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub buffer: Buffer,
}
impl ::std::default::Default for BufferDeviceAddressInfo {
    fn default() -> BufferDeviceAddressInfo {
        BufferDeviceAddressInfo {
            s_type: StructureType::BUFFER_DEVICE_ADDRESS_INFO,
            p_next: ::std::ptr::null(),
            buffer: Buffer::default(),
        }
    }
}
impl BufferDeviceAddressInfo {
    pub fn builder<'a>() -> BufferDeviceAddressInfoBuilder<'a> {
        BufferDeviceAddressInfoBuilder {
            inner: BufferDeviceAddressInfo::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct BufferDeviceAddressInfoBuilder<'a> {
    inner: BufferDeviceAddressInfo,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsBufferDeviceAddressInfo {}
impl<'a> ::std::ops::Deref for BufferDeviceAddressInfoBuilder<'a> {
    type Target = BufferDeviceAddressInfo;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for BufferDeviceAddressInfoBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> BufferDeviceAddressInfoBuilder<'a> {
    pub fn buffer(mut self, buffer: Buffer) -> BufferDeviceAddressInfoBuilder<'a> {
        self.inner.buffer = buffer;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsBufferDeviceAddressInfo>(
        mut self,
        next: &'a mut T,
    ) -> BufferDeviceAddressInfoBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> BufferDeviceAddressInfo {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkBufferOpaqueCaptureAddressCreateInfo.html>"]
pub struct BufferOpaqueCaptureAddressCreateInfo {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub opaque_capture_address: u64,
}
impl ::std::default::Default for BufferOpaqueCaptureAddressCreateInfo {
    fn default() -> BufferOpaqueCaptureAddressCreateInfo {
        BufferOpaqueCaptureAddressCreateInfo {
            s_type: StructureType::BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO,
            p_next: ::std::ptr::null(),
            opaque_capture_address: u64::default(),
        }
    }
}
impl BufferOpaqueCaptureAddressCreateInfo {
    pub fn builder<'a>() -> BufferOpaqueCaptureAddressCreateInfoBuilder<'a> {
        BufferOpaqueCaptureAddressCreateInfoBuilder {
            inner: BufferOpaqueCaptureAddressCreateInfo::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct BufferOpaqueCaptureAddressCreateInfoBuilder<'a> {
    inner: BufferOpaqueCaptureAddressCreateInfo,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsBufferCreateInfo for BufferOpaqueCaptureAddressCreateInfoBuilder<'_> {}
unsafe impl ExtendsBufferCreateInfo for BufferOpaqueCaptureAddressCreateInfo {}
impl<'a> ::std::ops::Deref for BufferOpaqueCaptureAddressCreateInfoBuilder<'a> {
    type Target = BufferOpaqueCaptureAddressCreateInfo;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for BufferOpaqueCaptureAddressCreateInfoBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> BufferOpaqueCaptureAddressCreateInfoBuilder<'a> {
    pub fn opaque_capture_address(
        mut self,
        opaque_capture_address: u64,
    ) -> BufferOpaqueCaptureAddressCreateInfoBuilder<'a> {
        self.inner.opaque_capture_address = opaque_capture_address;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> BufferOpaqueCaptureAddressCreateInfo {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkBufferDeviceAddressCreateInfoEXT.html>"]
pub struct BufferDeviceAddressCreateInfoEXT {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub device_address: DeviceAddress,
}
impl ::std::default::Default for BufferDeviceAddressCreateInfoEXT {
    fn default() -> BufferDeviceAddressCreateInfoEXT {
        BufferDeviceAddressCreateInfoEXT {
            s_type: StructureType::BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT,
            p_next: ::std::ptr::null(),
            device_address: DeviceAddress::default(),
        }
    }
}
impl BufferDeviceAddressCreateInfoEXT {
    pub fn builder<'a>() -> BufferDeviceAddressCreateInfoEXTBuilder<'a> {
        BufferDeviceAddressCreateInfoEXTBuilder {
            inner: BufferDeviceAddressCreateInfoEXT::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct BufferDeviceAddressCreateInfoEXTBuilder<'a> {
    inner: BufferDeviceAddressCreateInfoEXT,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsBufferCreateInfo for BufferDeviceAddressCreateInfoEXTBuilder<'_> {}
unsafe impl ExtendsBufferCreateInfo for BufferDeviceAddressCreateInfoEXT {}
impl<'a> ::std::ops::Deref for BufferDeviceAddressCreateInfoEXTBuilder<'a> {
    type Target = BufferDeviceAddressCreateInfoEXT;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for BufferDeviceAddressCreateInfoEXTBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> BufferDeviceAddressCreateInfoEXTBuilder<'a> {
    pub fn device_address(
        mut self,
        device_address: DeviceAddress,
    ) -> BufferDeviceAddressCreateInfoEXTBuilder<'a> {
        self.inner.device_address = device_address;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> BufferDeviceAddressCreateInfoEXT {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceImageViewImageFormatInfoEXT.html>"]
pub struct PhysicalDeviceImageViewImageFormatInfoEXT {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub image_view_type: ImageViewType,
}
impl ::std::default::Default for PhysicalDeviceImageViewImageFormatInfoEXT {
    fn default() -> PhysicalDeviceImageViewImageFormatInfoEXT {
        PhysicalDeviceImageViewImageFormatInfoEXT {
            s_type: StructureType::PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT,
            p_next: ::std::ptr::null_mut(),
            image_view_type: ImageViewType::default(),
        }
    }
}
impl PhysicalDeviceImageViewImageFormatInfoEXT {
    pub fn builder<'a>() -> PhysicalDeviceImageViewImageFormatInfoEXTBuilder<'a> {
        PhysicalDeviceImageViewImageFormatInfoEXTBuilder {
            inner: PhysicalDeviceImageViewImageFormatInfoEXT::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDeviceImageViewImageFormatInfoEXTBuilder<'a> {
    inner: PhysicalDeviceImageViewImageFormatInfoEXT,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsPhysicalDeviceImageFormatInfo2
    for PhysicalDeviceImageViewImageFormatInfoEXTBuilder<'_>
{
}
unsafe impl ExtendsPhysicalDeviceImageFormatInfo2 for PhysicalDeviceImageViewImageFormatInfoEXT {}
impl<'a> ::std::ops::Deref for PhysicalDeviceImageViewImageFormatInfoEXTBuilder<'a> {
    type Target = PhysicalDeviceImageViewImageFormatInfoEXT;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PhysicalDeviceImageViewImageFormatInfoEXTBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDeviceImageViewImageFormatInfoEXTBuilder<'a> {
    pub fn image_view_type(
        mut self,
        image_view_type: ImageViewType,
    ) -> PhysicalDeviceImageViewImageFormatInfoEXTBuilder<'a> {
        self.inner.image_view_type = image_view_type;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDeviceImageViewImageFormatInfoEXT {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkFilterCubicImageViewImageFormatPropertiesEXT.html>"]
pub struct FilterCubicImageViewImageFormatPropertiesEXT {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub filter_cubic: Bool32,
    pub filter_cubic_minmax: Bool32,
}
impl ::std::default::Default for FilterCubicImageViewImageFormatPropertiesEXT {
    fn default() -> FilterCubicImageViewImageFormatPropertiesEXT {
        FilterCubicImageViewImageFormatPropertiesEXT {
            s_type: StructureType::FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT,
            p_next: ::std::ptr::null_mut(),
            filter_cubic: Bool32::default(),
            filter_cubic_minmax: Bool32::default(),
        }
    }
}
impl FilterCubicImageViewImageFormatPropertiesEXT {
    pub fn builder<'a>() -> FilterCubicImageViewImageFormatPropertiesEXTBuilder<'a> {
        FilterCubicImageViewImageFormatPropertiesEXTBuilder {
            inner: FilterCubicImageViewImageFormatPropertiesEXT::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct FilterCubicImageViewImageFormatPropertiesEXTBuilder<'a> {
    inner: FilterCubicImageViewImageFormatPropertiesEXT,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsImageFormatProperties2
    for FilterCubicImageViewImageFormatPropertiesEXTBuilder<'_>
{
}
unsafe impl ExtendsImageFormatProperties2 for FilterCubicImageViewImageFormatPropertiesEXT {}
impl<'a> ::std::ops::Deref for FilterCubicImageViewImageFormatPropertiesEXTBuilder<'a> {
    type Target = FilterCubicImageViewImageFormatPropertiesEXT;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for FilterCubicImageViewImageFormatPropertiesEXTBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> FilterCubicImageViewImageFormatPropertiesEXTBuilder<'a> {
    pub fn filter_cubic(
        mut self,
        filter_cubic: bool,
    ) -> FilterCubicImageViewImageFormatPropertiesEXTBuilder<'a> {
        self.inner.filter_cubic = filter_cubic.into();
        self
    }
    pub fn filter_cubic_minmax(
        mut self,
        filter_cubic_minmax: bool,
    ) -> FilterCubicImageViewImageFormatPropertiesEXTBuilder<'a> {
        self.inner.filter_cubic_minmax = filter_cubic_minmax.into();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> FilterCubicImageViewImageFormatPropertiesEXT {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceImagelessFramebufferFeatures.html>"]
pub struct PhysicalDeviceImagelessFramebufferFeatures {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub imageless_framebuffer: Bool32,
}
impl ::std::default::Default for PhysicalDeviceImagelessFramebufferFeatures {
    fn default() -> PhysicalDeviceImagelessFramebufferFeatures {
        PhysicalDeviceImagelessFramebufferFeatures {
            s_type: StructureType::PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES,
            p_next: ::std::ptr::null_mut(),
            imageless_framebuffer: Bool32::default(),
        }
    }
}
impl PhysicalDeviceImagelessFramebufferFeatures {
    pub fn builder<'a>() -> PhysicalDeviceImagelessFramebufferFeaturesBuilder<'a> {
        PhysicalDeviceImagelessFramebufferFeaturesBuilder {
            inner: PhysicalDeviceImagelessFramebufferFeatures::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDeviceImagelessFramebufferFeaturesBuilder<'a> {
    inner: PhysicalDeviceImagelessFramebufferFeatures,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceImagelessFramebufferFeaturesBuilder<'_> {}
unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceImagelessFramebufferFeatures {}
impl<'a> ::std::ops::Deref for PhysicalDeviceImagelessFramebufferFeaturesBuilder<'a> {
    type Target = PhysicalDeviceImagelessFramebufferFeatures;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PhysicalDeviceImagelessFramebufferFeaturesBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDeviceImagelessFramebufferFeaturesBuilder<'a> {
    pub fn imageless_framebuffer(
        mut self,
        imageless_framebuffer: bool,
    ) -> PhysicalDeviceImagelessFramebufferFeaturesBuilder<'a> {
        self.inner.imageless_framebuffer = imageless_framebuffer.into();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDeviceImagelessFramebufferFeatures {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkFramebufferAttachmentsCreateInfo.html>"]
pub struct FramebufferAttachmentsCreateInfo {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub attachment_image_info_count: u32,
    pub p_attachment_image_infos: *const FramebufferAttachmentImageInfo,
}
impl ::std::default::Default for FramebufferAttachmentsCreateInfo {
    fn default() -> FramebufferAttachmentsCreateInfo {
        FramebufferAttachmentsCreateInfo {
            s_type: StructureType::FRAMEBUFFER_ATTACHMENTS_CREATE_INFO,
            p_next: ::std::ptr::null(),
            attachment_image_info_count: u32::default(),
            p_attachment_image_infos: ::std::ptr::null(),
        }
    }
}
impl FramebufferAttachmentsCreateInfo {
    pub fn builder<'a>() -> FramebufferAttachmentsCreateInfoBuilder<'a> {
        FramebufferAttachmentsCreateInfoBuilder {
            inner: FramebufferAttachmentsCreateInfo::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct FramebufferAttachmentsCreateInfoBuilder<'a> {
    inner: FramebufferAttachmentsCreateInfo,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsFramebufferCreateInfo for FramebufferAttachmentsCreateInfoBuilder<'_> {}
unsafe impl ExtendsFramebufferCreateInfo for FramebufferAttachmentsCreateInfo {}
impl<'a> ::std::ops::Deref for FramebufferAttachmentsCreateInfoBuilder<'a> {
    type Target = FramebufferAttachmentsCreateInfo;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for FramebufferAttachmentsCreateInfoBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> FramebufferAttachmentsCreateInfoBuilder<'a> {
    pub fn attachment_image_infos(
        mut self,
        attachment_image_infos: &'a [FramebufferAttachmentImageInfo],
    ) -> FramebufferAttachmentsCreateInfoBuilder<'a> {
        self.inner.attachment_image_info_count = attachment_image_infos.len() as _;
        self.inner.p_attachment_image_infos = attachment_image_infos.as_ptr();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> FramebufferAttachmentsCreateInfo {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkFramebufferAttachmentImageInfo.html>"]
pub struct FramebufferAttachmentImageInfo {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub flags: ImageCreateFlags,
    pub usage: ImageUsageFlags,
    pub width: u32,
    pub height: u32,
    pub layer_count: u32,
    pub view_format_count: u32,
    pub p_view_formats: *const Format,
}
impl ::std::default::Default for FramebufferAttachmentImageInfo {
    fn default() -> FramebufferAttachmentImageInfo {
        FramebufferAttachmentImageInfo {
            s_type: StructureType::FRAMEBUFFER_ATTACHMENT_IMAGE_INFO,
            p_next: ::std::ptr::null(),
            flags: ImageCreateFlags::default(),
            usage: ImageUsageFlags::default(),
            width: u32::default(),
            height: u32::default(),
            layer_count: u32::default(),
            view_format_count: u32::default(),
            p_view_formats: ::std::ptr::null(),
        }
    }
}
impl FramebufferAttachmentImageInfo {
    pub fn builder<'a>() -> FramebufferAttachmentImageInfoBuilder<'a> {
        FramebufferAttachmentImageInfoBuilder {
            inner: FramebufferAttachmentImageInfo::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct FramebufferAttachmentImageInfoBuilder<'a> {
    inner: FramebufferAttachmentImageInfo,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsFramebufferAttachmentImageInfo {}
impl<'a> ::std::ops::Deref for FramebufferAttachmentImageInfoBuilder<'a> {
    type Target = FramebufferAttachmentImageInfo;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for FramebufferAttachmentImageInfoBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> FramebufferAttachmentImageInfoBuilder<'a> {
    pub fn flags(mut self, flags: ImageCreateFlags) -> FramebufferAttachmentImageInfoBuilder<'a> {
        self.inner.flags = flags;
        self
    }
    pub fn usage(mut self, usage: ImageUsageFlags) -> FramebufferAttachmentImageInfoBuilder<'a> {
        self.inner.usage = usage;
        self
    }
    pub fn width(mut self, width: u32) -> FramebufferAttachmentImageInfoBuilder<'a> {
        self.inner.width = width;
        self
    }
    pub fn height(mut self, height: u32) -> FramebufferAttachmentImageInfoBuilder<'a> {
        self.inner.height = height;
        self
    }
    pub fn layer_count(mut self, layer_count: u32) -> FramebufferAttachmentImageInfoBuilder<'a> {
        self.inner.layer_count = layer_count;
        self
    }
    pub fn view_formats(
        mut self,
        view_formats: &'a [Format],
    ) -> FramebufferAttachmentImageInfoBuilder<'a> {
        self.inner.view_format_count = view_formats.len() as _;
        self.inner.p_view_formats = view_formats.as_ptr();
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsFramebufferAttachmentImageInfo>(
        mut self,
        next: &'a mut T,
    ) -> FramebufferAttachmentImageInfoBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> FramebufferAttachmentImageInfo {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkRenderPassAttachmentBeginInfo.html>"]
pub struct RenderPassAttachmentBeginInfo {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub attachment_count: u32,
    pub p_attachments: *const ImageView,
}
impl ::std::default::Default for RenderPassAttachmentBeginInfo {
    fn default() -> RenderPassAttachmentBeginInfo {
        RenderPassAttachmentBeginInfo {
            s_type: StructureType::RENDER_PASS_ATTACHMENT_BEGIN_INFO,
            p_next: ::std::ptr::null(),
            attachment_count: u32::default(),
            p_attachments: ::std::ptr::null(),
        }
    }
}
impl RenderPassAttachmentBeginInfo {
    pub fn builder<'a>() -> RenderPassAttachmentBeginInfoBuilder<'a> {
        RenderPassAttachmentBeginInfoBuilder {
            inner: RenderPassAttachmentBeginInfo::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct RenderPassAttachmentBeginInfoBuilder<'a> {
    inner: RenderPassAttachmentBeginInfo,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsRenderPassBeginInfo for RenderPassAttachmentBeginInfoBuilder<'_> {}
unsafe impl ExtendsRenderPassBeginInfo for RenderPassAttachmentBeginInfo {}
impl<'a> ::std::ops::Deref for RenderPassAttachmentBeginInfoBuilder<'a> {
    type Target = RenderPassAttachmentBeginInfo;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for RenderPassAttachmentBeginInfoBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> RenderPassAttachmentBeginInfoBuilder<'a> {
    pub fn attachments(
        mut self,
        attachments: &'a [ImageView],
    ) -> RenderPassAttachmentBeginInfoBuilder<'a> {
        self.inner.attachment_count = attachments.len() as _;
        self.inner.p_attachments = attachments.as_ptr();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> RenderPassAttachmentBeginInfo {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT.html>"]
pub struct PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub texture_compression_astc_hdr: Bool32,
}
impl ::std::default::Default for PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT {
    fn default() -> PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT {
        PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT {
            s_type: StructureType::PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT,
            p_next: ::std::ptr::null_mut(),
            texture_compression_astc_hdr: Bool32::default(),
        }
    }
}
impl PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT {
    pub fn builder<'a>() -> PhysicalDeviceTextureCompressionASTCHDRFeaturesEXTBuilder<'a> {
        PhysicalDeviceTextureCompressionASTCHDRFeaturesEXTBuilder {
            inner: PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDeviceTextureCompressionASTCHDRFeaturesEXTBuilder<'a> {
    inner: PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsDeviceCreateInfo
    for PhysicalDeviceTextureCompressionASTCHDRFeaturesEXTBuilder<'_>
{
}
unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT {}
impl<'a> ::std::ops::Deref for PhysicalDeviceTextureCompressionASTCHDRFeaturesEXTBuilder<'a> {
    type Target = PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PhysicalDeviceTextureCompressionASTCHDRFeaturesEXTBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDeviceTextureCompressionASTCHDRFeaturesEXTBuilder<'a> {
    pub fn texture_compression_astc_hdr(
        mut self,
        texture_compression_astc_hdr: bool,
    ) -> PhysicalDeviceTextureCompressionASTCHDRFeaturesEXTBuilder<'a> {
        self.inner.texture_compression_astc_hdr = texture_compression_astc_hdr.into();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceCooperativeMatrixFeaturesNV.html>"]
pub struct PhysicalDeviceCooperativeMatrixFeaturesNV {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub cooperative_matrix: Bool32,
    pub cooperative_matrix_robust_buffer_access: Bool32,
}
impl ::std::default::Default for PhysicalDeviceCooperativeMatrixFeaturesNV {
    fn default() -> PhysicalDeviceCooperativeMatrixFeaturesNV {
        PhysicalDeviceCooperativeMatrixFeaturesNV {
            s_type: StructureType::PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV,
            p_next: ::std::ptr::null_mut(),
            cooperative_matrix: Bool32::default(),
            cooperative_matrix_robust_buffer_access: Bool32::default(),
        }
    }
}
impl PhysicalDeviceCooperativeMatrixFeaturesNV {
    pub fn builder<'a>() -> PhysicalDeviceCooperativeMatrixFeaturesNVBuilder<'a> {
        PhysicalDeviceCooperativeMatrixFeaturesNVBuilder {
            inner: PhysicalDeviceCooperativeMatrixFeaturesNV::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDeviceCooperativeMatrixFeaturesNVBuilder<'a> {
    inner: PhysicalDeviceCooperativeMatrixFeaturesNV,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceCooperativeMatrixFeaturesNVBuilder<'_> {}
unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceCooperativeMatrixFeaturesNV {}
impl<'a> ::std::ops::Deref for PhysicalDeviceCooperativeMatrixFeaturesNVBuilder<'a> {
    type Target = PhysicalDeviceCooperativeMatrixFeaturesNV;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PhysicalDeviceCooperativeMatrixFeaturesNVBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDeviceCooperativeMatrixFeaturesNVBuilder<'a> {
    pub fn cooperative_matrix(
        mut self,
        cooperative_matrix: bool,
    ) -> PhysicalDeviceCooperativeMatrixFeaturesNVBuilder<'a> {
        self.inner.cooperative_matrix = cooperative_matrix.into();
        self
    }
    pub fn cooperative_matrix_robust_buffer_access(
        mut self,
        cooperative_matrix_robust_buffer_access: bool,
    ) -> PhysicalDeviceCooperativeMatrixFeaturesNVBuilder<'a> {
        self.inner.cooperative_matrix_robust_buffer_access =
            cooperative_matrix_robust_buffer_access.into();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDeviceCooperativeMatrixFeaturesNV {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceCooperativeMatrixPropertiesNV.html>"]
pub struct PhysicalDeviceCooperativeMatrixPropertiesNV {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub cooperative_matrix_supported_stages: ShaderStageFlags,
}
impl ::std::default::Default for PhysicalDeviceCooperativeMatrixPropertiesNV {
    fn default() -> PhysicalDeviceCooperativeMatrixPropertiesNV {
        PhysicalDeviceCooperativeMatrixPropertiesNV {
            s_type: StructureType::PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV,
            p_next: ::std::ptr::null_mut(),
            cooperative_matrix_supported_stages: ShaderStageFlags::default(),
        }
    }
}
impl PhysicalDeviceCooperativeMatrixPropertiesNV {
    pub fn builder<'a>() -> PhysicalDeviceCooperativeMatrixPropertiesNVBuilder<'a> {
        PhysicalDeviceCooperativeMatrixPropertiesNVBuilder {
            inner: PhysicalDeviceCooperativeMatrixPropertiesNV::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDeviceCooperativeMatrixPropertiesNVBuilder<'a> {
    inner: PhysicalDeviceCooperativeMatrixPropertiesNV,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsPhysicalDeviceProperties2
    for PhysicalDeviceCooperativeMatrixPropertiesNVBuilder<'_>
{
}
unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceCooperativeMatrixPropertiesNV {}
impl<'a> ::std::ops::Deref for PhysicalDeviceCooperativeMatrixPropertiesNVBuilder<'a> {
    type Target = PhysicalDeviceCooperativeMatrixPropertiesNV;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PhysicalDeviceCooperativeMatrixPropertiesNVBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDeviceCooperativeMatrixPropertiesNVBuilder<'a> {
    pub fn cooperative_matrix_supported_stages(
        mut self,
        cooperative_matrix_supported_stages: ShaderStageFlags,
    ) -> PhysicalDeviceCooperativeMatrixPropertiesNVBuilder<'a> {
        self.inner.cooperative_matrix_supported_stages = cooperative_matrix_supported_stages;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDeviceCooperativeMatrixPropertiesNV {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCooperativeMatrixPropertiesNV.html>"]
pub struct CooperativeMatrixPropertiesNV {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub m_size: u32,
    pub n_size: u32,
    pub k_size: u32,
    pub a_type: ComponentTypeNV,
    pub b_type: ComponentTypeNV,
    pub c_type: ComponentTypeNV,
    pub d_type: ComponentTypeNV,
    pub scope: ScopeNV,
}
impl ::std::default::Default for CooperativeMatrixPropertiesNV {
    fn default() -> CooperativeMatrixPropertiesNV {
        CooperativeMatrixPropertiesNV {
            s_type: StructureType::COOPERATIVE_MATRIX_PROPERTIES_NV,
            p_next: ::std::ptr::null_mut(),
            m_size: u32::default(),
            n_size: u32::default(),
            k_size: u32::default(),
            a_type: ComponentTypeNV::default(),
            b_type: ComponentTypeNV::default(),
            c_type: ComponentTypeNV::default(),
            d_type: ComponentTypeNV::default(),
            scope: ScopeNV::default(),
        }
    }
}
impl CooperativeMatrixPropertiesNV {
    pub fn builder<'a>() -> CooperativeMatrixPropertiesNVBuilder<'a> {
        CooperativeMatrixPropertiesNVBuilder {
            inner: CooperativeMatrixPropertiesNV::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct CooperativeMatrixPropertiesNVBuilder<'a> {
    inner: CooperativeMatrixPropertiesNV,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsCooperativeMatrixPropertiesNV {}
impl<'a> ::std::ops::Deref for CooperativeMatrixPropertiesNVBuilder<'a> {
    type Target = CooperativeMatrixPropertiesNV;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for CooperativeMatrixPropertiesNVBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> CooperativeMatrixPropertiesNVBuilder<'a> {
    pub fn m_size(mut self, m_size: u32) -> CooperativeMatrixPropertiesNVBuilder<'a> {
        self.inner.m_size = m_size;
        self
    }
    pub fn n_size(mut self, n_size: u32) -> CooperativeMatrixPropertiesNVBuilder<'a> {
        self.inner.n_size = n_size;
        self
    }
    pub fn k_size(mut self, k_size: u32) -> CooperativeMatrixPropertiesNVBuilder<'a> {
        self.inner.k_size = k_size;
        self
    }
    pub fn a_type(mut self, a_type: ComponentTypeNV) -> CooperativeMatrixPropertiesNVBuilder<'a> {
        self.inner.a_type = a_type;
        self
    }
    pub fn b_type(mut self, b_type: ComponentTypeNV) -> CooperativeMatrixPropertiesNVBuilder<'a> {
        self.inner.b_type = b_type;
        self
    }
    pub fn c_type(mut self, c_type: ComponentTypeNV) -> CooperativeMatrixPropertiesNVBuilder<'a> {
        self.inner.c_type = c_type;
        self
    }
    pub fn d_type(mut self, d_type: ComponentTypeNV) -> CooperativeMatrixPropertiesNVBuilder<'a> {
        self.inner.d_type = d_type;
        self
    }
    pub fn scope(mut self, scope: ScopeNV) -> CooperativeMatrixPropertiesNVBuilder<'a> {
        self.inner.scope = scope;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsCooperativeMatrixPropertiesNV>(
        mut self,
        next: &'a mut T,
    ) -> CooperativeMatrixPropertiesNVBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> CooperativeMatrixPropertiesNV {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceYcbcrImageArraysFeaturesEXT.html>"]
pub struct PhysicalDeviceYcbcrImageArraysFeaturesEXT {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub ycbcr_image_arrays: Bool32,
}
impl ::std::default::Default for PhysicalDeviceYcbcrImageArraysFeaturesEXT {
    fn default() -> PhysicalDeviceYcbcrImageArraysFeaturesEXT {
        PhysicalDeviceYcbcrImageArraysFeaturesEXT {
            s_type: StructureType::PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT,
            p_next: ::std::ptr::null_mut(),
            ycbcr_image_arrays: Bool32::default(),
        }
    }
}
impl PhysicalDeviceYcbcrImageArraysFeaturesEXT {
    pub fn builder<'a>() -> PhysicalDeviceYcbcrImageArraysFeaturesEXTBuilder<'a> {
        PhysicalDeviceYcbcrImageArraysFeaturesEXTBuilder {
            inner: PhysicalDeviceYcbcrImageArraysFeaturesEXT::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDeviceYcbcrImageArraysFeaturesEXTBuilder<'a> {
    inner: PhysicalDeviceYcbcrImageArraysFeaturesEXT,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceYcbcrImageArraysFeaturesEXTBuilder<'_> {}
unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceYcbcrImageArraysFeaturesEXT {}
impl<'a> ::std::ops::Deref for PhysicalDeviceYcbcrImageArraysFeaturesEXTBuilder<'a> {
    type Target = PhysicalDeviceYcbcrImageArraysFeaturesEXT;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PhysicalDeviceYcbcrImageArraysFeaturesEXTBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDeviceYcbcrImageArraysFeaturesEXTBuilder<'a> {
    pub fn ycbcr_image_arrays(
        mut self,
        ycbcr_image_arrays: bool,
    ) -> PhysicalDeviceYcbcrImageArraysFeaturesEXTBuilder<'a> {
        self.inner.ycbcr_image_arrays = ycbcr_image_arrays.into();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDeviceYcbcrImageArraysFeaturesEXT {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImageViewHandleInfoNVX.html>"]
pub struct ImageViewHandleInfoNVX {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub image_view: ImageView,
    pub descriptor_type: DescriptorType,
    pub sampler: Sampler,
}
impl ::std::default::Default for ImageViewHandleInfoNVX {
    fn default() -> ImageViewHandleInfoNVX {
        ImageViewHandleInfoNVX {
            s_type: StructureType::IMAGE_VIEW_HANDLE_INFO_NVX,
            p_next: ::std::ptr::null(),
            image_view: ImageView::default(),
            descriptor_type: DescriptorType::default(),
            sampler: Sampler::default(),
        }
    }
}
impl ImageViewHandleInfoNVX {
    pub fn builder<'a>() -> ImageViewHandleInfoNVXBuilder<'a> {
        ImageViewHandleInfoNVXBuilder {
            inner: ImageViewHandleInfoNVX::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct ImageViewHandleInfoNVXBuilder<'a> {
    inner: ImageViewHandleInfoNVX,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsImageViewHandleInfoNVX {}
impl<'a> ::std::ops::Deref for ImageViewHandleInfoNVXBuilder<'a> {
    type Target = ImageViewHandleInfoNVX;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for ImageViewHandleInfoNVXBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> ImageViewHandleInfoNVXBuilder<'a> {
    pub fn image_view(mut self, image_view: ImageView) -> ImageViewHandleInfoNVXBuilder<'a> {
        self.inner.image_view = image_view;
        self
    }
    pub fn descriptor_type(
        mut self,
        descriptor_type: DescriptorType,
    ) -> ImageViewHandleInfoNVXBuilder<'a> {
        self.inner.descriptor_type = descriptor_type;
        self
    }
    pub fn sampler(mut self, sampler: Sampler) -> ImageViewHandleInfoNVXBuilder<'a> {
        self.inner.sampler = sampler;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsImageViewHandleInfoNVX>(
        mut self,
        next: &'a mut T,
    ) -> ImageViewHandleInfoNVXBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> ImageViewHandleInfoNVX {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPresentFrameTokenGGP.html>"]
pub struct PresentFrameTokenGGP {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub frame_token: GgpFrameToken,
}
impl ::std::default::Default for PresentFrameTokenGGP {
    fn default() -> PresentFrameTokenGGP {
        PresentFrameTokenGGP {
            s_type: StructureType::PRESENT_FRAME_TOKEN_GGP,
            p_next: ::std::ptr::null(),
            frame_token: GgpFrameToken::default(),
        }
    }
}
impl PresentFrameTokenGGP {
    pub fn builder<'a>() -> PresentFrameTokenGGPBuilder<'a> {
        PresentFrameTokenGGPBuilder {
            inner: PresentFrameTokenGGP::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PresentFrameTokenGGPBuilder<'a> {
    inner: PresentFrameTokenGGP,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsPresentInfoKHR for PresentFrameTokenGGPBuilder<'_> {}
unsafe impl ExtendsPresentInfoKHR for PresentFrameTokenGGP {}
impl<'a> ::std::ops::Deref for PresentFrameTokenGGPBuilder<'a> {
    type Target = PresentFrameTokenGGP;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PresentFrameTokenGGPBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PresentFrameTokenGGPBuilder<'a> {
    pub fn frame_token(mut self, frame_token: GgpFrameToken) -> PresentFrameTokenGGPBuilder<'a> {
        self.inner.frame_token = frame_token;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PresentFrameTokenGGP {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Default, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineCreationFeedbackEXT.html>"]
pub struct PipelineCreationFeedbackEXT {
    pub flags: PipelineCreationFeedbackFlagsEXT,
    pub duration: u64,
}
impl PipelineCreationFeedbackEXT {
    pub fn builder<'a>() -> PipelineCreationFeedbackEXTBuilder<'a> {
        PipelineCreationFeedbackEXTBuilder {
            inner: PipelineCreationFeedbackEXT::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PipelineCreationFeedbackEXTBuilder<'a> {
    inner: PipelineCreationFeedbackEXT,
    marker: ::std::marker::PhantomData<&'a ()>,
}
impl<'a> ::std::ops::Deref for PipelineCreationFeedbackEXTBuilder<'a> {
    type Target = PipelineCreationFeedbackEXT;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PipelineCreationFeedbackEXTBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PipelineCreationFeedbackEXTBuilder<'a> {
    pub fn flags(
        mut self,
        flags: PipelineCreationFeedbackFlagsEXT,
    ) -> PipelineCreationFeedbackEXTBuilder<'a> {
        self.inner.flags = flags;
        self
    }
    pub fn duration(mut self, duration: u64) -> PipelineCreationFeedbackEXTBuilder<'a> {
        self.inner.duration = duration;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PipelineCreationFeedbackEXT {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineCreationFeedbackCreateInfoEXT.html>"]
pub struct PipelineCreationFeedbackCreateInfoEXT {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub p_pipeline_creation_feedback: *mut PipelineCreationFeedbackEXT,
    pub pipeline_stage_creation_feedback_count: u32,
    pub p_pipeline_stage_creation_feedbacks: *mut PipelineCreationFeedbackEXT,
}
impl ::std::default::Default for PipelineCreationFeedbackCreateInfoEXT {
    fn default() -> PipelineCreationFeedbackCreateInfoEXT {
        PipelineCreationFeedbackCreateInfoEXT {
            s_type: StructureType::PIPELINE_CREATION_FEEDBACK_CREATE_INFO_EXT,
            p_next: ::std::ptr::null(),
            p_pipeline_creation_feedback: ::std::ptr::null_mut(),
            pipeline_stage_creation_feedback_count: u32::default(),
            p_pipeline_stage_creation_feedbacks: ::std::ptr::null_mut(),
        }
    }
}
impl PipelineCreationFeedbackCreateInfoEXT {
    pub fn builder<'a>() -> PipelineCreationFeedbackCreateInfoEXTBuilder<'a> {
        PipelineCreationFeedbackCreateInfoEXTBuilder {
            inner: PipelineCreationFeedbackCreateInfoEXT::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PipelineCreationFeedbackCreateInfoEXTBuilder<'a> {
    inner: PipelineCreationFeedbackCreateInfoEXT,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsGraphicsPipelineCreateInfo for PipelineCreationFeedbackCreateInfoEXTBuilder<'_> {}
unsafe impl ExtendsGraphicsPipelineCreateInfo for PipelineCreationFeedbackCreateInfoEXT {}
unsafe impl ExtendsComputePipelineCreateInfo for PipelineCreationFeedbackCreateInfoEXTBuilder<'_> {}
unsafe impl ExtendsComputePipelineCreateInfo for PipelineCreationFeedbackCreateInfoEXT {}
unsafe impl ExtendsRayTracingPipelineCreateInfoNV
    for PipelineCreationFeedbackCreateInfoEXTBuilder<'_>
{
}
unsafe impl ExtendsRayTracingPipelineCreateInfoNV for PipelineCreationFeedbackCreateInfoEXT {}
unsafe impl ExtendsRayTracingPipelineCreateInfoKHR
    for PipelineCreationFeedbackCreateInfoEXTBuilder<'_>
{
}
unsafe impl ExtendsRayTracingPipelineCreateInfoKHR for PipelineCreationFeedbackCreateInfoEXT {}
impl<'a> ::std::ops::Deref for PipelineCreationFeedbackCreateInfoEXTBuilder<'a> {
    type Target = PipelineCreationFeedbackCreateInfoEXT;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PipelineCreationFeedbackCreateInfoEXTBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PipelineCreationFeedbackCreateInfoEXTBuilder<'a> {
    pub fn pipeline_creation_feedback(
        mut self,
        pipeline_creation_feedback: *mut PipelineCreationFeedbackEXT,
    ) -> PipelineCreationFeedbackCreateInfoEXTBuilder<'a> {
        self.inner.p_pipeline_creation_feedback = pipeline_creation_feedback;
        self
    }
    pub fn pipeline_stage_creation_feedbacks(
        mut self,
        pipeline_stage_creation_feedbacks: &'a mut [PipelineCreationFeedbackEXT],
    ) -> PipelineCreationFeedbackCreateInfoEXTBuilder<'a> {
        self.inner.pipeline_stage_creation_feedback_count =
            pipeline_stage_creation_feedbacks.len() as _;
        self.inner.p_pipeline_stage_creation_feedbacks =
            pipeline_stage_creation_feedbacks.as_mut_ptr();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PipelineCreationFeedbackCreateInfoEXT {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSurfaceFullScreenExclusiveInfoEXT.html>"]
pub struct SurfaceFullScreenExclusiveInfoEXT {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub full_screen_exclusive: FullScreenExclusiveEXT,
}
impl ::std::default::Default for SurfaceFullScreenExclusiveInfoEXT {
    fn default() -> SurfaceFullScreenExclusiveInfoEXT {
        SurfaceFullScreenExclusiveInfoEXT {
            s_type: StructureType::SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT,
            p_next: ::std::ptr::null_mut(),
            full_screen_exclusive: FullScreenExclusiveEXT::default(),
        }
    }
}
impl SurfaceFullScreenExclusiveInfoEXT {
    pub fn builder<'a>() -> SurfaceFullScreenExclusiveInfoEXTBuilder<'a> {
        SurfaceFullScreenExclusiveInfoEXTBuilder {
            inner: SurfaceFullScreenExclusiveInfoEXT::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct SurfaceFullScreenExclusiveInfoEXTBuilder<'a> {
    inner: SurfaceFullScreenExclusiveInfoEXT,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsPhysicalDeviceSurfaceInfo2KHR for SurfaceFullScreenExclusiveInfoEXTBuilder<'_> {}
unsafe impl ExtendsPhysicalDeviceSurfaceInfo2KHR for SurfaceFullScreenExclusiveInfoEXT {}
unsafe impl ExtendsSwapchainCreateInfoKHR for SurfaceFullScreenExclusiveInfoEXTBuilder<'_> {}
unsafe impl ExtendsSwapchainCreateInfoKHR for SurfaceFullScreenExclusiveInfoEXT {}
impl<'a> ::std::ops::Deref for SurfaceFullScreenExclusiveInfoEXTBuilder<'a> {
    type Target = SurfaceFullScreenExclusiveInfoEXT;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for SurfaceFullScreenExclusiveInfoEXTBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> SurfaceFullScreenExclusiveInfoEXTBuilder<'a> {
    pub fn full_screen_exclusive(
        mut self,
        full_screen_exclusive: FullScreenExclusiveEXT,
    ) -> SurfaceFullScreenExclusiveInfoEXTBuilder<'a> {
        self.inner.full_screen_exclusive = full_screen_exclusive;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> SurfaceFullScreenExclusiveInfoEXT {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSurfaceFullScreenExclusiveWin32InfoEXT.html>"]
pub struct SurfaceFullScreenExclusiveWin32InfoEXT {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub hmonitor: HMONITOR,
}
impl ::std::default::Default for SurfaceFullScreenExclusiveWin32InfoEXT {
    fn default() -> SurfaceFullScreenExclusiveWin32InfoEXT {
        SurfaceFullScreenExclusiveWin32InfoEXT {
            s_type: StructureType::SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT,
            p_next: ::std::ptr::null(),
            hmonitor: unsafe { ::std::mem::zeroed() },
        }
    }
}
impl SurfaceFullScreenExclusiveWin32InfoEXT {
    pub fn builder<'a>() -> SurfaceFullScreenExclusiveWin32InfoEXTBuilder<'a> {
        SurfaceFullScreenExclusiveWin32InfoEXTBuilder {
            inner: SurfaceFullScreenExclusiveWin32InfoEXT::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct SurfaceFullScreenExclusiveWin32InfoEXTBuilder<'a> {
    inner: SurfaceFullScreenExclusiveWin32InfoEXT,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsPhysicalDeviceSurfaceInfo2KHR
    for SurfaceFullScreenExclusiveWin32InfoEXTBuilder<'_>
{
}
unsafe impl ExtendsPhysicalDeviceSurfaceInfo2KHR for SurfaceFullScreenExclusiveWin32InfoEXT {}
unsafe impl ExtendsSwapchainCreateInfoKHR for SurfaceFullScreenExclusiveWin32InfoEXTBuilder<'_> {}
unsafe impl ExtendsSwapchainCreateInfoKHR for SurfaceFullScreenExclusiveWin32InfoEXT {}
impl<'a> ::std::ops::Deref for SurfaceFullScreenExclusiveWin32InfoEXTBuilder<'a> {
    type Target = SurfaceFullScreenExclusiveWin32InfoEXT;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for SurfaceFullScreenExclusiveWin32InfoEXTBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> SurfaceFullScreenExclusiveWin32InfoEXTBuilder<'a> {
    pub fn hmonitor(
        mut self,
        hmonitor: HMONITOR,
    ) -> SurfaceFullScreenExclusiveWin32InfoEXTBuilder<'a> {
        self.inner.hmonitor = hmonitor;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> SurfaceFullScreenExclusiveWin32InfoEXT {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSurfaceCapabilitiesFullScreenExclusiveEXT.html>"]
pub struct SurfaceCapabilitiesFullScreenExclusiveEXT {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub full_screen_exclusive_supported: Bool32,
}
impl ::std::default::Default for SurfaceCapabilitiesFullScreenExclusiveEXT {
    fn default() -> SurfaceCapabilitiesFullScreenExclusiveEXT {
        SurfaceCapabilitiesFullScreenExclusiveEXT {
            s_type: StructureType::SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT,
            p_next: ::std::ptr::null_mut(),
            full_screen_exclusive_supported: Bool32::default(),
        }
    }
}
impl SurfaceCapabilitiesFullScreenExclusiveEXT {
    pub fn builder<'a>() -> SurfaceCapabilitiesFullScreenExclusiveEXTBuilder<'a> {
        SurfaceCapabilitiesFullScreenExclusiveEXTBuilder {
            inner: SurfaceCapabilitiesFullScreenExclusiveEXT::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct SurfaceCapabilitiesFullScreenExclusiveEXTBuilder<'a> {
    inner: SurfaceCapabilitiesFullScreenExclusiveEXT,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsSurfaceCapabilities2KHR
    for SurfaceCapabilitiesFullScreenExclusiveEXTBuilder<'_>
{
}
unsafe impl ExtendsSurfaceCapabilities2KHR for SurfaceCapabilitiesFullScreenExclusiveEXT {}
impl<'a> ::std::ops::Deref for SurfaceCapabilitiesFullScreenExclusiveEXTBuilder<'a> {
    type Target = SurfaceCapabilitiesFullScreenExclusiveEXT;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for SurfaceCapabilitiesFullScreenExclusiveEXTBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> SurfaceCapabilitiesFullScreenExclusiveEXTBuilder<'a> {
    pub fn full_screen_exclusive_supported(
        mut self,
        full_screen_exclusive_supported: bool,
    ) -> SurfaceCapabilitiesFullScreenExclusiveEXTBuilder<'a> {
        self.inner.full_screen_exclusive_supported = full_screen_exclusive_supported.into();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> SurfaceCapabilitiesFullScreenExclusiveEXT {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDevicePerformanceQueryFeaturesKHR.html>"]
pub struct PhysicalDevicePerformanceQueryFeaturesKHR {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub performance_counter_query_pools: Bool32,
    pub performance_counter_multiple_query_pools: Bool32,
}
impl ::std::default::Default for PhysicalDevicePerformanceQueryFeaturesKHR {
    fn default() -> PhysicalDevicePerformanceQueryFeaturesKHR {
        PhysicalDevicePerformanceQueryFeaturesKHR {
            s_type: StructureType::PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR,
            p_next: ::std::ptr::null_mut(),
            performance_counter_query_pools: Bool32::default(),
            performance_counter_multiple_query_pools: Bool32::default(),
        }
    }
}
impl PhysicalDevicePerformanceQueryFeaturesKHR {
    pub fn builder<'a>() -> PhysicalDevicePerformanceQueryFeaturesKHRBuilder<'a> {
        PhysicalDevicePerformanceQueryFeaturesKHRBuilder {
            inner: PhysicalDevicePerformanceQueryFeaturesKHR::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDevicePerformanceQueryFeaturesKHRBuilder<'a> {
    inner: PhysicalDevicePerformanceQueryFeaturesKHR,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePerformanceQueryFeaturesKHRBuilder<'_> {}
unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePerformanceQueryFeaturesKHR {}
impl<'a> ::std::ops::Deref for PhysicalDevicePerformanceQueryFeaturesKHRBuilder<'a> {
    type Target = PhysicalDevicePerformanceQueryFeaturesKHR;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PhysicalDevicePerformanceQueryFeaturesKHRBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDevicePerformanceQueryFeaturesKHRBuilder<'a> {
    pub fn performance_counter_query_pools(
        mut self,
        performance_counter_query_pools: bool,
    ) -> PhysicalDevicePerformanceQueryFeaturesKHRBuilder<'a> {
        self.inner.performance_counter_query_pools = performance_counter_query_pools.into();
        self
    }
    pub fn performance_counter_multiple_query_pools(
        mut self,
        performance_counter_multiple_query_pools: bool,
    ) -> PhysicalDevicePerformanceQueryFeaturesKHRBuilder<'a> {
        self.inner.performance_counter_multiple_query_pools =
            performance_counter_multiple_query_pools.into();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDevicePerformanceQueryFeaturesKHR {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDevicePerformanceQueryPropertiesKHR.html>"]
pub struct PhysicalDevicePerformanceQueryPropertiesKHR {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub allow_command_buffer_query_copies: Bool32,
}
impl ::std::default::Default for PhysicalDevicePerformanceQueryPropertiesKHR {
    fn default() -> PhysicalDevicePerformanceQueryPropertiesKHR {
        PhysicalDevicePerformanceQueryPropertiesKHR {
            s_type: StructureType::PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR,
            p_next: ::std::ptr::null_mut(),
            allow_command_buffer_query_copies: Bool32::default(),
        }
    }
}
impl PhysicalDevicePerformanceQueryPropertiesKHR {
    pub fn builder<'a>() -> PhysicalDevicePerformanceQueryPropertiesKHRBuilder<'a> {
        PhysicalDevicePerformanceQueryPropertiesKHRBuilder {
            inner: PhysicalDevicePerformanceQueryPropertiesKHR::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDevicePerformanceQueryPropertiesKHRBuilder<'a> {
    inner: PhysicalDevicePerformanceQueryPropertiesKHR,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsPhysicalDeviceProperties2
    for PhysicalDevicePerformanceQueryPropertiesKHRBuilder<'_>
{
}
unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDevicePerformanceQueryPropertiesKHR {}
impl<'a> ::std::ops::Deref for PhysicalDevicePerformanceQueryPropertiesKHRBuilder<'a> {
    type Target = PhysicalDevicePerformanceQueryPropertiesKHR;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PhysicalDevicePerformanceQueryPropertiesKHRBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDevicePerformanceQueryPropertiesKHRBuilder<'a> {
    pub fn allow_command_buffer_query_copies(
        mut self,
        allow_command_buffer_query_copies: bool,
    ) -> PhysicalDevicePerformanceQueryPropertiesKHRBuilder<'a> {
        self.inner.allow_command_buffer_query_copies = allow_command_buffer_query_copies.into();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDevicePerformanceQueryPropertiesKHR {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPerformanceCounterKHR.html>"]
pub struct PerformanceCounterKHR {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub unit: PerformanceCounterUnitKHR,
    pub scope: PerformanceCounterScopeKHR,
    pub storage: PerformanceCounterStorageKHR,
    pub uuid: [u8; UUID_SIZE],
}
impl ::std::default::Default for PerformanceCounterKHR {
    fn default() -> PerformanceCounterKHR {
        PerformanceCounterKHR {
            s_type: StructureType::PERFORMANCE_COUNTER_KHR,
            p_next: ::std::ptr::null(),
            unit: PerformanceCounterUnitKHR::default(),
            scope: PerformanceCounterScopeKHR::default(),
            storage: PerformanceCounterStorageKHR::default(),
            uuid: unsafe { ::std::mem::zeroed() },
        }
    }
}
impl PerformanceCounterKHR {
    pub fn builder<'a>() -> PerformanceCounterKHRBuilder<'a> {
        PerformanceCounterKHRBuilder {
            inner: PerformanceCounterKHR::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PerformanceCounterKHRBuilder<'a> {
    inner: PerformanceCounterKHR,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsPerformanceCounterKHR {}
impl<'a> ::std::ops::Deref for PerformanceCounterKHRBuilder<'a> {
    type Target = PerformanceCounterKHR;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PerformanceCounterKHRBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PerformanceCounterKHRBuilder<'a> {
    pub fn unit(mut self, unit: PerformanceCounterUnitKHR) -> PerformanceCounterKHRBuilder<'a> {
        self.inner.unit = unit;
        self
    }
    pub fn scope(mut self, scope: PerformanceCounterScopeKHR) -> PerformanceCounterKHRBuilder<'a> {
        self.inner.scope = scope;
        self
    }
    pub fn storage(
        mut self,
        storage: PerformanceCounterStorageKHR,
    ) -> PerformanceCounterKHRBuilder<'a> {
        self.inner.storage = storage;
        self
    }
    pub fn uuid(mut self, uuid: [u8; UUID_SIZE]) -> PerformanceCounterKHRBuilder<'a> {
        self.inner.uuid = uuid;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsPerformanceCounterKHR>(
        mut self,
        next: &'a mut T,
    ) -> PerformanceCounterKHRBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PerformanceCounterKHR {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPerformanceCounterDescriptionKHR.html>"]
pub struct PerformanceCounterDescriptionKHR {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub flags: PerformanceCounterDescriptionFlagsKHR,
    pub name: [c_char; MAX_DESCRIPTION_SIZE],
    pub category: [c_char; MAX_DESCRIPTION_SIZE],
    pub description: [c_char; MAX_DESCRIPTION_SIZE],
}
impl fmt::Debug for PerformanceCounterDescriptionKHR {
    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
        fmt.debug_struct("PerformanceCounterDescriptionKHR")
            .field("s_type", &self.s_type)
            .field("p_next", &self.p_next)
            .field("flags", &self.flags)
            .field("name", &unsafe {
                ::std::ffi::CStr::from_ptr(self.name.as_ptr() as *const c_char)
            })
            .field("category", &unsafe {
                ::std::ffi::CStr::from_ptr(self.category.as_ptr() as *const c_char)
            })
            .field("description", &unsafe {
                ::std::ffi::CStr::from_ptr(self.description.as_ptr() as *const c_char)
            })
            .finish()
    }
}
impl ::std::default::Default for PerformanceCounterDescriptionKHR {
    fn default() -> PerformanceCounterDescriptionKHR {
        PerformanceCounterDescriptionKHR {
            s_type: StructureType::PERFORMANCE_COUNTER_DESCRIPTION_KHR,
            p_next: ::std::ptr::null(),
            flags: PerformanceCounterDescriptionFlagsKHR::default(),
            name: unsafe { ::std::mem::zeroed() },
            category: unsafe { ::std::mem::zeroed() },
            description: unsafe { ::std::mem::zeroed() },
        }
    }
}
impl PerformanceCounterDescriptionKHR {
    pub fn builder<'a>() -> PerformanceCounterDescriptionKHRBuilder<'a> {
        PerformanceCounterDescriptionKHRBuilder {
            inner: PerformanceCounterDescriptionKHR::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PerformanceCounterDescriptionKHRBuilder<'a> {
    inner: PerformanceCounterDescriptionKHR,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsPerformanceCounterDescriptionKHR {}
impl<'a> ::std::ops::Deref for PerformanceCounterDescriptionKHRBuilder<'a> {
    type Target = PerformanceCounterDescriptionKHR;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PerformanceCounterDescriptionKHRBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PerformanceCounterDescriptionKHRBuilder<'a> {
    pub fn flags(
        mut self,
        flags: PerformanceCounterDescriptionFlagsKHR,
    ) -> PerformanceCounterDescriptionKHRBuilder<'a> {
        self.inner.flags = flags;
        self
    }
    pub fn name(
        mut self,
        name: [c_char; MAX_DESCRIPTION_SIZE],
    ) -> PerformanceCounterDescriptionKHRBuilder<'a> {
        self.inner.name = name;
        self
    }
    pub fn category(
        mut self,
        category: [c_char; MAX_DESCRIPTION_SIZE],
    ) -> PerformanceCounterDescriptionKHRBuilder<'a> {
        self.inner.category = category;
        self
    }
    pub fn description(
        mut self,
        description: [c_char; MAX_DESCRIPTION_SIZE],
    ) -> PerformanceCounterDescriptionKHRBuilder<'a> {
        self.inner.description = description;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsPerformanceCounterDescriptionKHR>(
        mut self,
        next: &'a mut T,
    ) -> PerformanceCounterDescriptionKHRBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PerformanceCounterDescriptionKHR {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkQueryPoolPerformanceCreateInfoKHR.html>"]
pub struct QueryPoolPerformanceCreateInfoKHR {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub queue_family_index: u32,
    pub counter_index_count: u32,
    pub p_counter_indices: *const u32,
}
impl ::std::default::Default for QueryPoolPerformanceCreateInfoKHR {
    fn default() -> QueryPoolPerformanceCreateInfoKHR {
        QueryPoolPerformanceCreateInfoKHR {
            s_type: StructureType::QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR,
            p_next: ::std::ptr::null(),
            queue_family_index: u32::default(),
            counter_index_count: u32::default(),
            p_counter_indices: ::std::ptr::null(),
        }
    }
}
impl QueryPoolPerformanceCreateInfoKHR {
    pub fn builder<'a>() -> QueryPoolPerformanceCreateInfoKHRBuilder<'a> {
        QueryPoolPerformanceCreateInfoKHRBuilder {
            inner: QueryPoolPerformanceCreateInfoKHR::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct QueryPoolPerformanceCreateInfoKHRBuilder<'a> {
    inner: QueryPoolPerformanceCreateInfoKHR,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsQueryPoolCreateInfo for QueryPoolPerformanceCreateInfoKHRBuilder<'_> {}
unsafe impl ExtendsQueryPoolCreateInfo for QueryPoolPerformanceCreateInfoKHR {}
impl<'a> ::std::ops::Deref for QueryPoolPerformanceCreateInfoKHRBuilder<'a> {
    type Target = QueryPoolPerformanceCreateInfoKHR;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for QueryPoolPerformanceCreateInfoKHRBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> QueryPoolPerformanceCreateInfoKHRBuilder<'a> {
    pub fn queue_family_index(
        mut self,
        queue_family_index: u32,
    ) -> QueryPoolPerformanceCreateInfoKHRBuilder<'a> {
        self.inner.queue_family_index = queue_family_index;
        self
    }
    pub fn counter_indices(
        mut self,
        counter_indices: &'a [u32],
    ) -> QueryPoolPerformanceCreateInfoKHRBuilder<'a> {
        self.inner.counter_index_count = counter_indices.len() as _;
        self.inner.p_counter_indices = counter_indices.as_ptr();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> QueryPoolPerformanceCreateInfoKHR {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPerformanceCounterResultKHR.html>"]
pub union PerformanceCounterResultKHR {
    pub int32: i32,
    pub int64: i64,
    pub uint32: u32,
    pub uint64: u64,
    pub float32: f32,
    pub float64: f64,
}
impl ::std::default::Default for PerformanceCounterResultKHR {
    fn default() -> PerformanceCounterResultKHR {
        unsafe { ::std::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAcquireProfilingLockInfoKHR.html>"]
pub struct AcquireProfilingLockInfoKHR {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub flags: AcquireProfilingLockFlagsKHR,
    pub timeout: u64,
}
impl ::std::default::Default for AcquireProfilingLockInfoKHR {
    fn default() -> AcquireProfilingLockInfoKHR {
        AcquireProfilingLockInfoKHR {
            s_type: StructureType::ACQUIRE_PROFILING_LOCK_INFO_KHR,
            p_next: ::std::ptr::null(),
            flags: AcquireProfilingLockFlagsKHR::default(),
            timeout: u64::default(),
        }
    }
}
impl AcquireProfilingLockInfoKHR {
    pub fn builder<'a>() -> AcquireProfilingLockInfoKHRBuilder<'a> {
        AcquireProfilingLockInfoKHRBuilder {
            inner: AcquireProfilingLockInfoKHR::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct AcquireProfilingLockInfoKHRBuilder<'a> {
    inner: AcquireProfilingLockInfoKHR,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsAcquireProfilingLockInfoKHR {}
impl<'a> ::std::ops::Deref for AcquireProfilingLockInfoKHRBuilder<'a> {
    type Target = AcquireProfilingLockInfoKHR;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for AcquireProfilingLockInfoKHRBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> AcquireProfilingLockInfoKHRBuilder<'a> {
    pub fn flags(
        mut self,
        flags: AcquireProfilingLockFlagsKHR,
    ) -> AcquireProfilingLockInfoKHRBuilder<'a> {
        self.inner.flags = flags;
        self
    }
    pub fn timeout(mut self, timeout: u64) -> AcquireProfilingLockInfoKHRBuilder<'a> {
        self.inner.timeout = timeout;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsAcquireProfilingLockInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> AcquireProfilingLockInfoKHRBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> AcquireProfilingLockInfoKHR {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPerformanceQuerySubmitInfoKHR.html>"]
pub struct PerformanceQuerySubmitInfoKHR {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub counter_pass_index: u32,
}
impl ::std::default::Default for PerformanceQuerySubmitInfoKHR {
    fn default() -> PerformanceQuerySubmitInfoKHR {
        PerformanceQuerySubmitInfoKHR {
            s_type: StructureType::PERFORMANCE_QUERY_SUBMIT_INFO_KHR,
            p_next: ::std::ptr::null(),
            counter_pass_index: u32::default(),
        }
    }
}
impl PerformanceQuerySubmitInfoKHR {
    pub fn builder<'a>() -> PerformanceQuerySubmitInfoKHRBuilder<'a> {
        PerformanceQuerySubmitInfoKHRBuilder {
            inner: PerformanceQuerySubmitInfoKHR::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PerformanceQuerySubmitInfoKHRBuilder<'a> {
    inner: PerformanceQuerySubmitInfoKHR,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsSubmitInfo for PerformanceQuerySubmitInfoKHRBuilder<'_> {}
unsafe impl ExtendsSubmitInfo for PerformanceQuerySubmitInfoKHR {}
impl<'a> ::std::ops::Deref for PerformanceQuerySubmitInfoKHRBuilder<'a> {
    type Target = PerformanceQuerySubmitInfoKHR;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PerformanceQuerySubmitInfoKHRBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PerformanceQuerySubmitInfoKHRBuilder<'a> {
    pub fn counter_pass_index(
        mut self,
        counter_pass_index: u32,
    ) -> PerformanceQuerySubmitInfoKHRBuilder<'a> {
        self.inner.counter_pass_index = counter_pass_index;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PerformanceQuerySubmitInfoKHR {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkHeadlessSurfaceCreateInfoEXT.html>"]
pub struct HeadlessSurfaceCreateInfoEXT {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub flags: HeadlessSurfaceCreateFlagsEXT,
}
impl ::std::default::Default for HeadlessSurfaceCreateInfoEXT {
    fn default() -> HeadlessSurfaceCreateInfoEXT {
        HeadlessSurfaceCreateInfoEXT {
            s_type: StructureType::HEADLESS_SURFACE_CREATE_INFO_EXT,
            p_next: ::std::ptr::null(),
            flags: HeadlessSurfaceCreateFlagsEXT::default(),
        }
    }
}
impl HeadlessSurfaceCreateInfoEXT {
    pub fn builder<'a>() -> HeadlessSurfaceCreateInfoEXTBuilder<'a> {
        HeadlessSurfaceCreateInfoEXTBuilder {
            inner: HeadlessSurfaceCreateInfoEXT::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct HeadlessSurfaceCreateInfoEXTBuilder<'a> {
    inner: HeadlessSurfaceCreateInfoEXT,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsHeadlessSurfaceCreateInfoEXT {}
impl<'a> ::std::ops::Deref for HeadlessSurfaceCreateInfoEXTBuilder<'a> {
    type Target = HeadlessSurfaceCreateInfoEXT;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for HeadlessSurfaceCreateInfoEXTBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> HeadlessSurfaceCreateInfoEXTBuilder<'a> {
    pub fn flags(
        mut self,
        flags: HeadlessSurfaceCreateFlagsEXT,
    ) -> HeadlessSurfaceCreateInfoEXTBuilder<'a> {
        self.inner.flags = flags;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsHeadlessSurfaceCreateInfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> HeadlessSurfaceCreateInfoEXTBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> HeadlessSurfaceCreateInfoEXT {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceCoverageReductionModeFeaturesNV.html>"]
pub struct PhysicalDeviceCoverageReductionModeFeaturesNV {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub coverage_reduction_mode: Bool32,
}
impl ::std::default::Default for PhysicalDeviceCoverageReductionModeFeaturesNV {
    fn default() -> PhysicalDeviceCoverageReductionModeFeaturesNV {
        PhysicalDeviceCoverageReductionModeFeaturesNV {
            s_type: StructureType::PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV,
            p_next: ::std::ptr::null_mut(),
            coverage_reduction_mode: Bool32::default(),
        }
    }
}
impl PhysicalDeviceCoverageReductionModeFeaturesNV {
    pub fn builder<'a>() -> PhysicalDeviceCoverageReductionModeFeaturesNVBuilder<'a> {
        PhysicalDeviceCoverageReductionModeFeaturesNVBuilder {
            inner: PhysicalDeviceCoverageReductionModeFeaturesNV::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDeviceCoverageReductionModeFeaturesNVBuilder<'a> {
    inner: PhysicalDeviceCoverageReductionModeFeaturesNV,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceCoverageReductionModeFeaturesNVBuilder<'_> {}
unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceCoverageReductionModeFeaturesNV {}
impl<'a> ::std::ops::Deref for PhysicalDeviceCoverageReductionModeFeaturesNVBuilder<'a> {
    type Target = PhysicalDeviceCoverageReductionModeFeaturesNV;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PhysicalDeviceCoverageReductionModeFeaturesNVBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDeviceCoverageReductionModeFeaturesNVBuilder<'a> {
    pub fn coverage_reduction_mode(
        mut self,
        coverage_reduction_mode: bool,
    ) -> PhysicalDeviceCoverageReductionModeFeaturesNVBuilder<'a> {
        self.inner.coverage_reduction_mode = coverage_reduction_mode.into();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDeviceCoverageReductionModeFeaturesNV {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineCoverageReductionStateCreateInfoNV.html>"]
pub struct PipelineCoverageReductionStateCreateInfoNV {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub flags: PipelineCoverageReductionStateCreateFlagsNV,
    pub coverage_reduction_mode: CoverageReductionModeNV,
}
impl ::std::default::Default for PipelineCoverageReductionStateCreateInfoNV {
    fn default() -> PipelineCoverageReductionStateCreateInfoNV {
        PipelineCoverageReductionStateCreateInfoNV {
            s_type: StructureType::PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV,
            p_next: ::std::ptr::null(),
            flags: PipelineCoverageReductionStateCreateFlagsNV::default(),
            coverage_reduction_mode: CoverageReductionModeNV::default(),
        }
    }
}
impl PipelineCoverageReductionStateCreateInfoNV {
    pub fn builder<'a>() -> PipelineCoverageReductionStateCreateInfoNVBuilder<'a> {
        PipelineCoverageReductionStateCreateInfoNVBuilder {
            inner: PipelineCoverageReductionStateCreateInfoNV::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PipelineCoverageReductionStateCreateInfoNVBuilder<'a> {
    inner: PipelineCoverageReductionStateCreateInfoNV,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsPipelineMultisampleStateCreateInfo
    for PipelineCoverageReductionStateCreateInfoNVBuilder<'_>
{
}
unsafe impl ExtendsPipelineMultisampleStateCreateInfo
    for PipelineCoverageReductionStateCreateInfoNV
{
}
impl<'a> ::std::ops::Deref for PipelineCoverageReductionStateCreateInfoNVBuilder<'a> {
    type Target = PipelineCoverageReductionStateCreateInfoNV;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PipelineCoverageReductionStateCreateInfoNVBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PipelineCoverageReductionStateCreateInfoNVBuilder<'a> {
    pub fn flags(
        mut self,
        flags: PipelineCoverageReductionStateCreateFlagsNV,
    ) -> PipelineCoverageReductionStateCreateInfoNVBuilder<'a> {
        self.inner.flags = flags;
        self
    }
    pub fn coverage_reduction_mode(
        mut self,
        coverage_reduction_mode: CoverageReductionModeNV,
    ) -> PipelineCoverageReductionStateCreateInfoNVBuilder<'a> {
        self.inner.coverage_reduction_mode = coverage_reduction_mode;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PipelineCoverageReductionStateCreateInfoNV {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkFramebufferMixedSamplesCombinationNV.html>"]
pub struct FramebufferMixedSamplesCombinationNV {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub coverage_reduction_mode: CoverageReductionModeNV,
    pub rasterization_samples: SampleCountFlags,
    pub depth_stencil_samples: SampleCountFlags,
    pub color_samples: SampleCountFlags,
}
impl ::std::default::Default for FramebufferMixedSamplesCombinationNV {
    fn default() -> FramebufferMixedSamplesCombinationNV {
        FramebufferMixedSamplesCombinationNV {
            s_type: StructureType::FRAMEBUFFER_MIXED_SAMPLES_COMBINATION_NV,
            p_next: ::std::ptr::null_mut(),
            coverage_reduction_mode: CoverageReductionModeNV::default(),
            rasterization_samples: SampleCountFlags::default(),
            depth_stencil_samples: SampleCountFlags::default(),
            color_samples: SampleCountFlags::default(),
        }
    }
}
impl FramebufferMixedSamplesCombinationNV {
    pub fn builder<'a>() -> FramebufferMixedSamplesCombinationNVBuilder<'a> {
        FramebufferMixedSamplesCombinationNVBuilder {
            inner: FramebufferMixedSamplesCombinationNV::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct FramebufferMixedSamplesCombinationNVBuilder<'a> {
    inner: FramebufferMixedSamplesCombinationNV,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsFramebufferMixedSamplesCombinationNV {}
impl<'a> ::std::ops::Deref for FramebufferMixedSamplesCombinationNVBuilder<'a> {
    type Target = FramebufferMixedSamplesCombinationNV;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for FramebufferMixedSamplesCombinationNVBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> FramebufferMixedSamplesCombinationNVBuilder<'a> {
    pub fn coverage_reduction_mode(
        mut self,
        coverage_reduction_mode: CoverageReductionModeNV,
    ) -> FramebufferMixedSamplesCombinationNVBuilder<'a> {
        self.inner.coverage_reduction_mode = coverage_reduction_mode;
        self
    }
    pub fn rasterization_samples(
        mut self,
        rasterization_samples: SampleCountFlags,
    ) -> FramebufferMixedSamplesCombinationNVBuilder<'a> {
        self.inner.rasterization_samples = rasterization_samples;
        self
    }
    pub fn depth_stencil_samples(
        mut self,
        depth_stencil_samples: SampleCountFlags,
    ) -> FramebufferMixedSamplesCombinationNVBuilder<'a> {
        self.inner.depth_stencil_samples = depth_stencil_samples;
        self
    }
    pub fn color_samples(
        mut self,
        color_samples: SampleCountFlags,
    ) -> FramebufferMixedSamplesCombinationNVBuilder<'a> {
        self.inner.color_samples = color_samples;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsFramebufferMixedSamplesCombinationNV>(
        mut self,
        next: &'a mut T,
    ) -> FramebufferMixedSamplesCombinationNVBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> FramebufferMixedSamplesCombinationNV {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL.html>"]
pub struct PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub shader_integer_functions2: Bool32,
}
impl ::std::default::Default for PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL {
    fn default() -> PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL {
        PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL {
            s_type: StructureType::PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL,
            p_next: ::std::ptr::null_mut(),
            shader_integer_functions2: Bool32::default(),
        }
    }
}
impl PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL {
    pub fn builder<'a>() -> PhysicalDeviceShaderIntegerFunctions2FeaturesINTELBuilder<'a> {
        PhysicalDeviceShaderIntegerFunctions2FeaturesINTELBuilder {
            inner: PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDeviceShaderIntegerFunctions2FeaturesINTELBuilder<'a> {
    inner: PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsDeviceCreateInfo
    for PhysicalDeviceShaderIntegerFunctions2FeaturesINTELBuilder<'_>
{
}
unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL {}
impl<'a> ::std::ops::Deref for PhysicalDeviceShaderIntegerFunctions2FeaturesINTELBuilder<'a> {
    type Target = PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderIntegerFunctions2FeaturesINTELBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDeviceShaderIntegerFunctions2FeaturesINTELBuilder<'a> {
    pub fn shader_integer_functions2(
        mut self,
        shader_integer_functions2: bool,
    ) -> PhysicalDeviceShaderIntegerFunctions2FeaturesINTELBuilder<'a> {
        self.inner.shader_integer_functions2 = shader_integer_functions2.into();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPerformanceValueDataINTEL.html>"]
pub union PerformanceValueDataINTEL {
    pub value32: u32,
    pub value64: u64,
    pub value_float: f32,
    pub value_bool: Bool32,
    pub value_string: *const c_char,
}
impl ::std::default::Default for PerformanceValueDataINTEL {
    fn default() -> PerformanceValueDataINTEL {
        unsafe { ::std::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Copy, Clone, Default)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPerformanceValueINTEL.html>"]
pub struct PerformanceValueINTEL {
    pub ty: PerformanceValueTypeINTEL,
    pub data: PerformanceValueDataINTEL,
}
impl fmt::Debug for PerformanceValueINTEL {
    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
        fmt.debug_struct("PerformanceValueINTEL")
            .field("ty", &self.ty)
            .field("data", &"union")
            .finish()
    }
}
impl PerformanceValueINTEL {
    pub fn builder<'a>() -> PerformanceValueINTELBuilder<'a> {
        PerformanceValueINTELBuilder {
            inner: PerformanceValueINTEL::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PerformanceValueINTELBuilder<'a> {
    inner: PerformanceValueINTEL,
    marker: ::std::marker::PhantomData<&'a ()>,
}
impl<'a> ::std::ops::Deref for PerformanceValueINTELBuilder<'a> {
    type Target = PerformanceValueINTEL;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PerformanceValueINTELBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PerformanceValueINTELBuilder<'a> {
    pub fn ty(mut self, ty: PerformanceValueTypeINTEL) -> PerformanceValueINTELBuilder<'a> {
        self.inner.ty = ty;
        self
    }
    pub fn data(mut self, data: PerformanceValueDataINTEL) -> PerformanceValueINTELBuilder<'a> {
        self.inner.data = data;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PerformanceValueINTEL {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkInitializePerformanceApiInfoINTEL.html>"]
pub struct InitializePerformanceApiInfoINTEL {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub p_user_data: *mut c_void,
}
impl ::std::default::Default for InitializePerformanceApiInfoINTEL {
    fn default() -> InitializePerformanceApiInfoINTEL {
        InitializePerformanceApiInfoINTEL {
            s_type: StructureType::INITIALIZE_PERFORMANCE_API_INFO_INTEL,
            p_next: ::std::ptr::null(),
            p_user_data: ::std::ptr::null_mut(),
        }
    }
}
impl InitializePerformanceApiInfoINTEL {
    pub fn builder<'a>() -> InitializePerformanceApiInfoINTELBuilder<'a> {
        InitializePerformanceApiInfoINTELBuilder {
            inner: InitializePerformanceApiInfoINTEL::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct InitializePerformanceApiInfoINTELBuilder<'a> {
    inner: InitializePerformanceApiInfoINTEL,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsInitializePerformanceApiInfoINTEL {}
impl<'a> ::std::ops::Deref for InitializePerformanceApiInfoINTELBuilder<'a> {
    type Target = InitializePerformanceApiInfoINTEL;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for InitializePerformanceApiInfoINTELBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> InitializePerformanceApiInfoINTELBuilder<'a> {
    pub fn user_data(
        mut self,
        user_data: *mut c_void,
    ) -> InitializePerformanceApiInfoINTELBuilder<'a> {
        self.inner.p_user_data = user_data;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsInitializePerformanceApiInfoINTEL>(
        mut self,
        next: &'a mut T,
    ) -> InitializePerformanceApiInfoINTELBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> InitializePerformanceApiInfoINTEL {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkQueryPoolPerformanceQueryCreateInfoINTEL.html>"]
pub struct QueryPoolPerformanceQueryCreateInfoINTEL {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub performance_counters_sampling: QueryPoolSamplingModeINTEL,
}
impl ::std::default::Default for QueryPoolPerformanceQueryCreateInfoINTEL {
    fn default() -> QueryPoolPerformanceQueryCreateInfoINTEL {
        QueryPoolPerformanceQueryCreateInfoINTEL {
            s_type: StructureType::QUERY_POOL_CREATE_INFO_INTEL,
            p_next: ::std::ptr::null(),
            performance_counters_sampling: QueryPoolSamplingModeINTEL::default(),
        }
    }
}
impl QueryPoolPerformanceQueryCreateInfoINTEL {
    pub fn builder<'a>() -> QueryPoolPerformanceQueryCreateInfoINTELBuilder<'a> {
        QueryPoolPerformanceQueryCreateInfoINTELBuilder {
            inner: QueryPoolPerformanceQueryCreateInfoINTEL::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct QueryPoolPerformanceQueryCreateInfoINTELBuilder<'a> {
    inner: QueryPoolPerformanceQueryCreateInfoINTEL,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsQueryPoolCreateInfo for QueryPoolPerformanceQueryCreateInfoINTELBuilder<'_> {}
unsafe impl ExtendsQueryPoolCreateInfo for QueryPoolPerformanceQueryCreateInfoINTEL {}
impl<'a> ::std::ops::Deref for QueryPoolPerformanceQueryCreateInfoINTELBuilder<'a> {
    type Target = QueryPoolPerformanceQueryCreateInfoINTEL;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for QueryPoolPerformanceQueryCreateInfoINTELBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> QueryPoolPerformanceQueryCreateInfoINTELBuilder<'a> {
    pub fn performance_counters_sampling(
        mut self,
        performance_counters_sampling: QueryPoolSamplingModeINTEL,
    ) -> QueryPoolPerformanceQueryCreateInfoINTELBuilder<'a> {
        self.inner.performance_counters_sampling = performance_counters_sampling;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> QueryPoolPerformanceQueryCreateInfoINTEL {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPerformanceMarkerInfoINTEL.html>"]
pub struct PerformanceMarkerInfoINTEL {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub marker: u64,
}
impl ::std::default::Default for PerformanceMarkerInfoINTEL {
    fn default() -> PerformanceMarkerInfoINTEL {
        PerformanceMarkerInfoINTEL {
            s_type: StructureType::PERFORMANCE_MARKER_INFO_INTEL,
            p_next: ::std::ptr::null(),
            marker: u64::default(),
        }
    }
}
impl PerformanceMarkerInfoINTEL {
    pub fn builder<'a>() -> PerformanceMarkerInfoINTELBuilder<'a> {
        PerformanceMarkerInfoINTELBuilder {
            inner: PerformanceMarkerInfoINTEL::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PerformanceMarkerInfoINTELBuilder<'a> {
    inner: PerformanceMarkerInfoINTEL,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsPerformanceMarkerInfoINTEL {}
impl<'a> ::std::ops::Deref for PerformanceMarkerInfoINTELBuilder<'a> {
    type Target = PerformanceMarkerInfoINTEL;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PerformanceMarkerInfoINTELBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PerformanceMarkerInfoINTELBuilder<'a> {
    pub fn marker(mut self, marker: u64) -> PerformanceMarkerInfoINTELBuilder<'a> {
        self.inner.marker = marker;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsPerformanceMarkerInfoINTEL>(
        mut self,
        next: &'a mut T,
    ) -> PerformanceMarkerInfoINTELBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PerformanceMarkerInfoINTEL {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPerformanceStreamMarkerInfoINTEL.html>"]
pub struct PerformanceStreamMarkerInfoINTEL {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub marker: u32,
}
impl ::std::default::Default for PerformanceStreamMarkerInfoINTEL {
    fn default() -> PerformanceStreamMarkerInfoINTEL {
        PerformanceStreamMarkerInfoINTEL {
            s_type: StructureType::PERFORMANCE_STREAM_MARKER_INFO_INTEL,
            p_next: ::std::ptr::null(),
            marker: u32::default(),
        }
    }
}
impl PerformanceStreamMarkerInfoINTEL {
    pub fn builder<'a>() -> PerformanceStreamMarkerInfoINTELBuilder<'a> {
        PerformanceStreamMarkerInfoINTELBuilder {
            inner: PerformanceStreamMarkerInfoINTEL::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PerformanceStreamMarkerInfoINTELBuilder<'a> {
    inner: PerformanceStreamMarkerInfoINTEL,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsPerformanceStreamMarkerInfoINTEL {}
impl<'a> ::std::ops::Deref for PerformanceStreamMarkerInfoINTELBuilder<'a> {
    type Target = PerformanceStreamMarkerInfoINTEL;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PerformanceStreamMarkerInfoINTELBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PerformanceStreamMarkerInfoINTELBuilder<'a> {
    pub fn marker(mut self, marker: u32) -> PerformanceStreamMarkerInfoINTELBuilder<'a> {
        self.inner.marker = marker;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsPerformanceStreamMarkerInfoINTEL>(
        mut self,
        next: &'a mut T,
    ) -> PerformanceStreamMarkerInfoINTELBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PerformanceStreamMarkerInfoINTEL {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPerformanceOverrideInfoINTEL.html>"]
pub struct PerformanceOverrideInfoINTEL {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub ty: PerformanceOverrideTypeINTEL,
    pub enable: Bool32,
    pub parameter: u64,
}
impl ::std::default::Default for PerformanceOverrideInfoINTEL {
    fn default() -> PerformanceOverrideInfoINTEL {
        PerformanceOverrideInfoINTEL {
            s_type: StructureType::PERFORMANCE_OVERRIDE_INFO_INTEL,
            p_next: ::std::ptr::null(),
            ty: PerformanceOverrideTypeINTEL::default(),
            enable: Bool32::default(),
            parameter: u64::default(),
        }
    }
}
impl PerformanceOverrideInfoINTEL {
    pub fn builder<'a>() -> PerformanceOverrideInfoINTELBuilder<'a> {
        PerformanceOverrideInfoINTELBuilder {
            inner: PerformanceOverrideInfoINTEL::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PerformanceOverrideInfoINTELBuilder<'a> {
    inner: PerformanceOverrideInfoINTEL,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsPerformanceOverrideInfoINTEL {}
impl<'a> ::std::ops::Deref for PerformanceOverrideInfoINTELBuilder<'a> {
    type Target = PerformanceOverrideInfoINTEL;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PerformanceOverrideInfoINTELBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PerformanceOverrideInfoINTELBuilder<'a> {
    pub fn ty(
        mut self,
        ty: PerformanceOverrideTypeINTEL,
    ) -> PerformanceOverrideInfoINTELBuilder<'a> {
        self.inner.ty = ty;
        self
    }
    pub fn enable(mut self, enable: bool) -> PerformanceOverrideInfoINTELBuilder<'a> {
        self.inner.enable = enable.into();
        self
    }
    pub fn parameter(mut self, parameter: u64) -> PerformanceOverrideInfoINTELBuilder<'a> {
        self.inner.parameter = parameter;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsPerformanceOverrideInfoINTEL>(
        mut self,
        next: &'a mut T,
    ) -> PerformanceOverrideInfoINTELBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PerformanceOverrideInfoINTEL {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPerformanceConfigurationAcquireInfoINTEL.html>"]
pub struct PerformanceConfigurationAcquireInfoINTEL {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub ty: PerformanceConfigurationTypeINTEL,
}
impl ::std::default::Default for PerformanceConfigurationAcquireInfoINTEL {
    fn default() -> PerformanceConfigurationAcquireInfoINTEL {
        PerformanceConfigurationAcquireInfoINTEL {
            s_type: StructureType::PERFORMANCE_CONFIGURATION_ACQUIRE_INFO_INTEL,
            p_next: ::std::ptr::null(),
            ty: PerformanceConfigurationTypeINTEL::default(),
        }
    }
}
impl PerformanceConfigurationAcquireInfoINTEL {
    pub fn builder<'a>() -> PerformanceConfigurationAcquireInfoINTELBuilder<'a> {
        PerformanceConfigurationAcquireInfoINTELBuilder {
            inner: PerformanceConfigurationAcquireInfoINTEL::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PerformanceConfigurationAcquireInfoINTELBuilder<'a> {
    inner: PerformanceConfigurationAcquireInfoINTEL,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsPerformanceConfigurationAcquireInfoINTEL {}
impl<'a> ::std::ops::Deref for PerformanceConfigurationAcquireInfoINTELBuilder<'a> {
    type Target = PerformanceConfigurationAcquireInfoINTEL;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PerformanceConfigurationAcquireInfoINTELBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PerformanceConfigurationAcquireInfoINTELBuilder<'a> {
    pub fn ty(
        mut self,
        ty: PerformanceConfigurationTypeINTEL,
    ) -> PerformanceConfigurationAcquireInfoINTELBuilder<'a> {
        self.inner.ty = ty;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsPerformanceConfigurationAcquireInfoINTEL>(
        mut self,
        next: &'a mut T,
    ) -> PerformanceConfigurationAcquireInfoINTELBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PerformanceConfigurationAcquireInfoINTEL {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceShaderClockFeaturesKHR.html>"]
pub struct PhysicalDeviceShaderClockFeaturesKHR {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub shader_subgroup_clock: Bool32,
    pub shader_device_clock: Bool32,
}
impl ::std::default::Default for PhysicalDeviceShaderClockFeaturesKHR {
    fn default() -> PhysicalDeviceShaderClockFeaturesKHR {
        PhysicalDeviceShaderClockFeaturesKHR {
            s_type: StructureType::PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR,
            p_next: ::std::ptr::null_mut(),
            shader_subgroup_clock: Bool32::default(),
            shader_device_clock: Bool32::default(),
        }
    }
}
impl PhysicalDeviceShaderClockFeaturesKHR {
    pub fn builder<'a>() -> PhysicalDeviceShaderClockFeaturesKHRBuilder<'a> {
        PhysicalDeviceShaderClockFeaturesKHRBuilder {
            inner: PhysicalDeviceShaderClockFeaturesKHR::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDeviceShaderClockFeaturesKHRBuilder<'a> {
    inner: PhysicalDeviceShaderClockFeaturesKHR,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderClockFeaturesKHRBuilder<'_> {}
unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderClockFeaturesKHR {}
impl<'a> ::std::ops::Deref for PhysicalDeviceShaderClockFeaturesKHRBuilder<'a> {
    type Target = PhysicalDeviceShaderClockFeaturesKHR;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderClockFeaturesKHRBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDeviceShaderClockFeaturesKHRBuilder<'a> {
    pub fn shader_subgroup_clock(
        mut self,
        shader_subgroup_clock: bool,
    ) -> PhysicalDeviceShaderClockFeaturesKHRBuilder<'a> {
        self.inner.shader_subgroup_clock = shader_subgroup_clock.into();
        self
    }
    pub fn shader_device_clock(
        mut self,
        shader_device_clock: bool,
    ) -> PhysicalDeviceShaderClockFeaturesKHRBuilder<'a> {
        self.inner.shader_device_clock = shader_device_clock.into();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDeviceShaderClockFeaturesKHR {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceIndexTypeUint8FeaturesEXT.html>"]
pub struct PhysicalDeviceIndexTypeUint8FeaturesEXT {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub index_type_uint8: Bool32,
}
impl ::std::default::Default for PhysicalDeviceIndexTypeUint8FeaturesEXT {
    fn default() -> PhysicalDeviceIndexTypeUint8FeaturesEXT {
        PhysicalDeviceIndexTypeUint8FeaturesEXT {
            s_type: StructureType::PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT,
            p_next: ::std::ptr::null_mut(),
            index_type_uint8: Bool32::default(),
        }
    }
}
impl PhysicalDeviceIndexTypeUint8FeaturesEXT {
    pub fn builder<'a>() -> PhysicalDeviceIndexTypeUint8FeaturesEXTBuilder<'a> {
        PhysicalDeviceIndexTypeUint8FeaturesEXTBuilder {
            inner: PhysicalDeviceIndexTypeUint8FeaturesEXT::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDeviceIndexTypeUint8FeaturesEXTBuilder<'a> {
    inner: PhysicalDeviceIndexTypeUint8FeaturesEXT,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceIndexTypeUint8FeaturesEXTBuilder<'_> {}
unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceIndexTypeUint8FeaturesEXT {}
impl<'a> ::std::ops::Deref for PhysicalDeviceIndexTypeUint8FeaturesEXTBuilder<'a> {
    type Target = PhysicalDeviceIndexTypeUint8FeaturesEXT;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PhysicalDeviceIndexTypeUint8FeaturesEXTBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDeviceIndexTypeUint8FeaturesEXTBuilder<'a> {
    pub fn index_type_uint8(
        mut self,
        index_type_uint8: bool,
    ) -> PhysicalDeviceIndexTypeUint8FeaturesEXTBuilder<'a> {
        self.inner.index_type_uint8 = index_type_uint8.into();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDeviceIndexTypeUint8FeaturesEXT {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceShaderSMBuiltinsPropertiesNV.html>"]
pub struct PhysicalDeviceShaderSMBuiltinsPropertiesNV {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub shader_sm_count: u32,
    pub shader_warps_per_sm: u32,
}
impl ::std::default::Default for PhysicalDeviceShaderSMBuiltinsPropertiesNV {
    fn default() -> PhysicalDeviceShaderSMBuiltinsPropertiesNV {
        PhysicalDeviceShaderSMBuiltinsPropertiesNV {
            s_type: StructureType::PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV,
            p_next: ::std::ptr::null_mut(),
            shader_sm_count: u32::default(),
            shader_warps_per_sm: u32::default(),
        }
    }
}
impl PhysicalDeviceShaderSMBuiltinsPropertiesNV {
    pub fn builder<'a>() -> PhysicalDeviceShaderSMBuiltinsPropertiesNVBuilder<'a> {
        PhysicalDeviceShaderSMBuiltinsPropertiesNVBuilder {
            inner: PhysicalDeviceShaderSMBuiltinsPropertiesNV::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDeviceShaderSMBuiltinsPropertiesNVBuilder<'a> {
    inner: PhysicalDeviceShaderSMBuiltinsPropertiesNV,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsPhysicalDeviceProperties2
    for PhysicalDeviceShaderSMBuiltinsPropertiesNVBuilder<'_>
{
}
unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceShaderSMBuiltinsPropertiesNV {}
impl<'a> ::std::ops::Deref for PhysicalDeviceShaderSMBuiltinsPropertiesNVBuilder<'a> {
    type Target = PhysicalDeviceShaderSMBuiltinsPropertiesNV;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderSMBuiltinsPropertiesNVBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDeviceShaderSMBuiltinsPropertiesNVBuilder<'a> {
    pub fn shader_sm_count(
        mut self,
        shader_sm_count: u32,
    ) -> PhysicalDeviceShaderSMBuiltinsPropertiesNVBuilder<'a> {
        self.inner.shader_sm_count = shader_sm_count;
        self
    }
    pub fn shader_warps_per_sm(
        mut self,
        shader_warps_per_sm: u32,
    ) -> PhysicalDeviceShaderSMBuiltinsPropertiesNVBuilder<'a> {
        self.inner.shader_warps_per_sm = shader_warps_per_sm;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDeviceShaderSMBuiltinsPropertiesNV {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceShaderSMBuiltinsFeaturesNV.html>"]
pub struct PhysicalDeviceShaderSMBuiltinsFeaturesNV {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub shader_sm_builtins: Bool32,
}
impl ::std::default::Default for PhysicalDeviceShaderSMBuiltinsFeaturesNV {
    fn default() -> PhysicalDeviceShaderSMBuiltinsFeaturesNV {
        PhysicalDeviceShaderSMBuiltinsFeaturesNV {
            s_type: StructureType::PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV,
            p_next: ::std::ptr::null_mut(),
            shader_sm_builtins: Bool32::default(),
        }
    }
}
impl PhysicalDeviceShaderSMBuiltinsFeaturesNV {
    pub fn builder<'a>() -> PhysicalDeviceShaderSMBuiltinsFeaturesNVBuilder<'a> {
        PhysicalDeviceShaderSMBuiltinsFeaturesNVBuilder {
            inner: PhysicalDeviceShaderSMBuiltinsFeaturesNV::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDeviceShaderSMBuiltinsFeaturesNVBuilder<'a> {
    inner: PhysicalDeviceShaderSMBuiltinsFeaturesNV,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderSMBuiltinsFeaturesNVBuilder<'_> {}
unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderSMBuiltinsFeaturesNV {}
impl<'a> ::std::ops::Deref for PhysicalDeviceShaderSMBuiltinsFeaturesNVBuilder<'a> {
    type Target = PhysicalDeviceShaderSMBuiltinsFeaturesNV;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderSMBuiltinsFeaturesNVBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDeviceShaderSMBuiltinsFeaturesNVBuilder<'a> {
    pub fn shader_sm_builtins(
        mut self,
        shader_sm_builtins: bool,
    ) -> PhysicalDeviceShaderSMBuiltinsFeaturesNVBuilder<'a> {
        self.inner.shader_sm_builtins = shader_sm_builtins.into();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDeviceShaderSMBuiltinsFeaturesNV {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT.html>"]
pub struct PhysicalDeviceFragmentShaderInterlockFeaturesEXT {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub fragment_shader_sample_interlock: Bool32,
    pub fragment_shader_pixel_interlock: Bool32,
    pub fragment_shader_shading_rate_interlock: Bool32,
}
impl ::std::default::Default for PhysicalDeviceFragmentShaderInterlockFeaturesEXT {
    fn default() -> PhysicalDeviceFragmentShaderInterlockFeaturesEXT {
        PhysicalDeviceFragmentShaderInterlockFeaturesEXT {
            s_type: StructureType::PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT,
            p_next: ::std::ptr::null_mut(),
            fragment_shader_sample_interlock: Bool32::default(),
            fragment_shader_pixel_interlock: Bool32::default(),
            fragment_shader_shading_rate_interlock: Bool32::default(),
        }
    }
}
impl PhysicalDeviceFragmentShaderInterlockFeaturesEXT {
    pub fn builder<'a>() -> PhysicalDeviceFragmentShaderInterlockFeaturesEXTBuilder<'a> {
        PhysicalDeviceFragmentShaderInterlockFeaturesEXTBuilder {
            inner: PhysicalDeviceFragmentShaderInterlockFeaturesEXT::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDeviceFragmentShaderInterlockFeaturesEXTBuilder<'a> {
    inner: PhysicalDeviceFragmentShaderInterlockFeaturesEXT,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsDeviceCreateInfo
    for PhysicalDeviceFragmentShaderInterlockFeaturesEXTBuilder<'_>
{
}
unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentShaderInterlockFeaturesEXT {}
impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentShaderInterlockFeaturesEXTBuilder<'a> {
    type Target = PhysicalDeviceFragmentShaderInterlockFeaturesEXT;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentShaderInterlockFeaturesEXTBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDeviceFragmentShaderInterlockFeaturesEXTBuilder<'a> {
    pub fn fragment_shader_sample_interlock(
        mut self,
        fragment_shader_sample_interlock: bool,
    ) -> PhysicalDeviceFragmentShaderInterlockFeaturesEXTBuilder<'a> {
        self.inner.fragment_shader_sample_interlock = fragment_shader_sample_interlock.into();
        self
    }
    pub fn fragment_shader_pixel_interlock(
        mut self,
        fragment_shader_pixel_interlock: bool,
    ) -> PhysicalDeviceFragmentShaderInterlockFeaturesEXTBuilder<'a> {
        self.inner.fragment_shader_pixel_interlock = fragment_shader_pixel_interlock.into();
        self
    }
    pub fn fragment_shader_shading_rate_interlock(
        mut self,
        fragment_shader_shading_rate_interlock: bool,
    ) -> PhysicalDeviceFragmentShaderInterlockFeaturesEXTBuilder<'a> {
        self.inner.fragment_shader_shading_rate_interlock =
            fragment_shader_shading_rate_interlock.into();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDeviceFragmentShaderInterlockFeaturesEXT {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures.html>"]
pub struct PhysicalDeviceSeparateDepthStencilLayoutsFeatures {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub separate_depth_stencil_layouts: Bool32,
}
impl ::std::default::Default for PhysicalDeviceSeparateDepthStencilLayoutsFeatures {
    fn default() -> PhysicalDeviceSeparateDepthStencilLayoutsFeatures {
        PhysicalDeviceSeparateDepthStencilLayoutsFeatures {
            s_type: StructureType::PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES,
            p_next: ::std::ptr::null_mut(),
            separate_depth_stencil_layouts: Bool32::default(),
        }
    }
}
impl PhysicalDeviceSeparateDepthStencilLayoutsFeatures {
    pub fn builder<'a>() -> PhysicalDeviceSeparateDepthStencilLayoutsFeaturesBuilder<'a> {
        PhysicalDeviceSeparateDepthStencilLayoutsFeaturesBuilder {
            inner: PhysicalDeviceSeparateDepthStencilLayoutsFeatures::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDeviceSeparateDepthStencilLayoutsFeaturesBuilder<'a> {
    inner: PhysicalDeviceSeparateDepthStencilLayoutsFeatures,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsDeviceCreateInfo
    for PhysicalDeviceSeparateDepthStencilLayoutsFeaturesBuilder<'_>
{
}
unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceSeparateDepthStencilLayoutsFeatures {}
impl<'a> ::std::ops::Deref for PhysicalDeviceSeparateDepthStencilLayoutsFeaturesBuilder<'a> {
    type Target = PhysicalDeviceSeparateDepthStencilLayoutsFeatures;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PhysicalDeviceSeparateDepthStencilLayoutsFeaturesBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDeviceSeparateDepthStencilLayoutsFeaturesBuilder<'a> {
    pub fn separate_depth_stencil_layouts(
        mut self,
        separate_depth_stencil_layouts: bool,
    ) -> PhysicalDeviceSeparateDepthStencilLayoutsFeaturesBuilder<'a> {
        self.inner.separate_depth_stencil_layouts = separate_depth_stencil_layouts.into();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDeviceSeparateDepthStencilLayoutsFeatures {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAttachmentReferenceStencilLayout.html>"]
pub struct AttachmentReferenceStencilLayout {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub stencil_layout: ImageLayout,
}
impl ::std::default::Default for AttachmentReferenceStencilLayout {
    fn default() -> AttachmentReferenceStencilLayout {
        AttachmentReferenceStencilLayout {
            s_type: StructureType::ATTACHMENT_REFERENCE_STENCIL_LAYOUT,
            p_next: ::std::ptr::null_mut(),
            stencil_layout: ImageLayout::default(),
        }
    }
}
impl AttachmentReferenceStencilLayout {
    pub fn builder<'a>() -> AttachmentReferenceStencilLayoutBuilder<'a> {
        AttachmentReferenceStencilLayoutBuilder {
            inner: AttachmentReferenceStencilLayout::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct AttachmentReferenceStencilLayoutBuilder<'a> {
    inner: AttachmentReferenceStencilLayout,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsAttachmentReference2 for AttachmentReferenceStencilLayoutBuilder<'_> {}
unsafe impl ExtendsAttachmentReference2 for AttachmentReferenceStencilLayout {}
impl<'a> ::std::ops::Deref for AttachmentReferenceStencilLayoutBuilder<'a> {
    type Target = AttachmentReferenceStencilLayout;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for AttachmentReferenceStencilLayoutBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> AttachmentReferenceStencilLayoutBuilder<'a> {
    pub fn stencil_layout(
        mut self,
        stencil_layout: ImageLayout,
    ) -> AttachmentReferenceStencilLayoutBuilder<'a> {
        self.inner.stencil_layout = stencil_layout;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> AttachmentReferenceStencilLayout {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAttachmentDescriptionStencilLayout.html>"]
pub struct AttachmentDescriptionStencilLayout {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub stencil_initial_layout: ImageLayout,
    pub stencil_final_layout: ImageLayout,
}
impl ::std::default::Default for AttachmentDescriptionStencilLayout {
    fn default() -> AttachmentDescriptionStencilLayout {
        AttachmentDescriptionStencilLayout {
            s_type: StructureType::ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT,
            p_next: ::std::ptr::null_mut(),
            stencil_initial_layout: ImageLayout::default(),
            stencil_final_layout: ImageLayout::default(),
        }
    }
}
impl AttachmentDescriptionStencilLayout {
    pub fn builder<'a>() -> AttachmentDescriptionStencilLayoutBuilder<'a> {
        AttachmentDescriptionStencilLayoutBuilder {
            inner: AttachmentDescriptionStencilLayout::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct AttachmentDescriptionStencilLayoutBuilder<'a> {
    inner: AttachmentDescriptionStencilLayout,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsAttachmentDescription2 for AttachmentDescriptionStencilLayoutBuilder<'_> {}
unsafe impl ExtendsAttachmentDescription2 for AttachmentDescriptionStencilLayout {}
impl<'a> ::std::ops::Deref for AttachmentDescriptionStencilLayoutBuilder<'a> {
    type Target = AttachmentDescriptionStencilLayout;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for AttachmentDescriptionStencilLayoutBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> AttachmentDescriptionStencilLayoutBuilder<'a> {
    pub fn stencil_initial_layout(
        mut self,
        stencil_initial_layout: ImageLayout,
    ) -> AttachmentDescriptionStencilLayoutBuilder<'a> {
        self.inner.stencil_initial_layout = stencil_initial_layout;
        self
    }
    pub fn stencil_final_layout(
        mut self,
        stencil_final_layout: ImageLayout,
    ) -> AttachmentDescriptionStencilLayoutBuilder<'a> {
        self.inner.stencil_final_layout = stencil_final_layout;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> AttachmentDescriptionStencilLayout {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR.html>"]
pub struct PhysicalDevicePipelineExecutablePropertiesFeaturesKHR {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub pipeline_executable_info: Bool32,
}
impl ::std::default::Default for PhysicalDevicePipelineExecutablePropertiesFeaturesKHR {
    fn default() -> PhysicalDevicePipelineExecutablePropertiesFeaturesKHR {
        PhysicalDevicePipelineExecutablePropertiesFeaturesKHR {
            s_type: StructureType::PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR,
            p_next: ::std::ptr::null_mut(),
            pipeline_executable_info: Bool32::default(),
        }
    }
}
impl PhysicalDevicePipelineExecutablePropertiesFeaturesKHR {
    pub fn builder<'a>() -> PhysicalDevicePipelineExecutablePropertiesFeaturesKHRBuilder<'a> {
        PhysicalDevicePipelineExecutablePropertiesFeaturesKHRBuilder {
            inner: PhysicalDevicePipelineExecutablePropertiesFeaturesKHR::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDevicePipelineExecutablePropertiesFeaturesKHRBuilder<'a> {
    inner: PhysicalDevicePipelineExecutablePropertiesFeaturesKHR,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsDeviceCreateInfo
    for PhysicalDevicePipelineExecutablePropertiesFeaturesKHRBuilder<'_>
{
}
unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePipelineExecutablePropertiesFeaturesKHR {}
impl<'a> ::std::ops::Deref for PhysicalDevicePipelineExecutablePropertiesFeaturesKHRBuilder<'a> {
    type Target = PhysicalDevicePipelineExecutablePropertiesFeaturesKHR;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PhysicalDevicePipelineExecutablePropertiesFeaturesKHRBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDevicePipelineExecutablePropertiesFeaturesKHRBuilder<'a> {
    pub fn pipeline_executable_info(
        mut self,
        pipeline_executable_info: bool,
    ) -> PhysicalDevicePipelineExecutablePropertiesFeaturesKHRBuilder<'a> {
        self.inner.pipeline_executable_info = pipeline_executable_info.into();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDevicePipelineExecutablePropertiesFeaturesKHR {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineInfoKHR.html>"]
pub struct PipelineInfoKHR {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub pipeline: Pipeline,
}
impl ::std::default::Default for PipelineInfoKHR {
    fn default() -> PipelineInfoKHR {
        PipelineInfoKHR {
            s_type: StructureType::PIPELINE_INFO_KHR,
            p_next: ::std::ptr::null(),
            pipeline: Pipeline::default(),
        }
    }
}
impl PipelineInfoKHR {
    pub fn builder<'a>() -> PipelineInfoKHRBuilder<'a> {
        PipelineInfoKHRBuilder {
            inner: PipelineInfoKHR::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PipelineInfoKHRBuilder<'a> {
    inner: PipelineInfoKHR,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsPipelineInfoKHR {}
impl<'a> ::std::ops::Deref for PipelineInfoKHRBuilder<'a> {
    type Target = PipelineInfoKHR;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PipelineInfoKHRBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PipelineInfoKHRBuilder<'a> {
    pub fn pipeline(mut self, pipeline: Pipeline) -> PipelineInfoKHRBuilder<'a> {
        self.inner.pipeline = pipeline;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsPipelineInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> PipelineInfoKHRBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PipelineInfoKHR {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineExecutablePropertiesKHR.html>"]
pub struct PipelineExecutablePropertiesKHR {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub stages: ShaderStageFlags,
    pub name: [c_char; MAX_DESCRIPTION_SIZE],
    pub description: [c_char; MAX_DESCRIPTION_SIZE],
    pub subgroup_size: u32,
}
impl fmt::Debug for PipelineExecutablePropertiesKHR {
    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
        fmt.debug_struct("PipelineExecutablePropertiesKHR")
            .field("s_type", &self.s_type)
            .field("p_next", &self.p_next)
            .field("stages", &self.stages)
            .field("name", &unsafe {
                ::std::ffi::CStr::from_ptr(self.name.as_ptr() as *const c_char)
            })
            .field("description", &unsafe {
                ::std::ffi::CStr::from_ptr(self.description.as_ptr() as *const c_char)
            })
            .field("subgroup_size", &self.subgroup_size)
            .finish()
    }
}
impl ::std::default::Default for PipelineExecutablePropertiesKHR {
    fn default() -> PipelineExecutablePropertiesKHR {
        PipelineExecutablePropertiesKHR {
            s_type: StructureType::PIPELINE_EXECUTABLE_PROPERTIES_KHR,
            p_next: ::std::ptr::null_mut(),
            stages: ShaderStageFlags::default(),
            name: unsafe { ::std::mem::zeroed() },
            description: unsafe { ::std::mem::zeroed() },
            subgroup_size: u32::default(),
        }
    }
}
impl PipelineExecutablePropertiesKHR {
    pub fn builder<'a>() -> PipelineExecutablePropertiesKHRBuilder<'a> {
        PipelineExecutablePropertiesKHRBuilder {
            inner: PipelineExecutablePropertiesKHR::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PipelineExecutablePropertiesKHRBuilder<'a> {
    inner: PipelineExecutablePropertiesKHR,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsPipelineExecutablePropertiesKHR {}
impl<'a> ::std::ops::Deref for PipelineExecutablePropertiesKHRBuilder<'a> {
    type Target = PipelineExecutablePropertiesKHR;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PipelineExecutablePropertiesKHRBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PipelineExecutablePropertiesKHRBuilder<'a> {
    pub fn stages(
        mut self,
        stages: ShaderStageFlags,
    ) -> PipelineExecutablePropertiesKHRBuilder<'a> {
        self.inner.stages = stages;
        self
    }
    pub fn name(
        mut self,
        name: [c_char; MAX_DESCRIPTION_SIZE],
    ) -> PipelineExecutablePropertiesKHRBuilder<'a> {
        self.inner.name = name;
        self
    }
    pub fn description(
        mut self,
        description: [c_char; MAX_DESCRIPTION_SIZE],
    ) -> PipelineExecutablePropertiesKHRBuilder<'a> {
        self.inner.description = description;
        self
    }
    pub fn subgroup_size(
        mut self,
        subgroup_size: u32,
    ) -> PipelineExecutablePropertiesKHRBuilder<'a> {
        self.inner.subgroup_size = subgroup_size;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsPipelineExecutablePropertiesKHR>(
        mut self,
        next: &'a mut T,
    ) -> PipelineExecutablePropertiesKHRBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PipelineExecutablePropertiesKHR {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineExecutableInfoKHR.html>"]
pub struct PipelineExecutableInfoKHR {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub pipeline: Pipeline,
    pub executable_index: u32,
}
impl ::std::default::Default for PipelineExecutableInfoKHR {
    fn default() -> PipelineExecutableInfoKHR {
        PipelineExecutableInfoKHR {
            s_type: StructureType::PIPELINE_EXECUTABLE_INFO_KHR,
            p_next: ::std::ptr::null(),
            pipeline: Pipeline::default(),
            executable_index: u32::default(),
        }
    }
}
impl PipelineExecutableInfoKHR {
    pub fn builder<'a>() -> PipelineExecutableInfoKHRBuilder<'a> {
        PipelineExecutableInfoKHRBuilder {
            inner: PipelineExecutableInfoKHR::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PipelineExecutableInfoKHRBuilder<'a> {
    inner: PipelineExecutableInfoKHR,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsPipelineExecutableInfoKHR {}
impl<'a> ::std::ops::Deref for PipelineExecutableInfoKHRBuilder<'a> {
    type Target = PipelineExecutableInfoKHR;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PipelineExecutableInfoKHRBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PipelineExecutableInfoKHRBuilder<'a> {
    pub fn pipeline(mut self, pipeline: Pipeline) -> PipelineExecutableInfoKHRBuilder<'a> {
        self.inner.pipeline = pipeline;
        self
    }
    pub fn executable_index(
        mut self,
        executable_index: u32,
    ) -> PipelineExecutableInfoKHRBuilder<'a> {
        self.inner.executable_index = executable_index;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsPipelineExecutableInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> PipelineExecutableInfoKHRBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PipelineExecutableInfoKHR {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineExecutableStatisticValueKHR.html>"]
pub union PipelineExecutableStatisticValueKHR {
    pub b32: Bool32,
    pub i64: i64,
    pub u64: u64,
    pub f64: f64,
}
impl ::std::default::Default for PipelineExecutableStatisticValueKHR {
    fn default() -> PipelineExecutableStatisticValueKHR {
        unsafe { ::std::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineExecutableStatisticKHR.html>"]
pub struct PipelineExecutableStatisticKHR {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub name: [c_char; MAX_DESCRIPTION_SIZE],
    pub description: [c_char; MAX_DESCRIPTION_SIZE],
    pub format: PipelineExecutableStatisticFormatKHR,
    pub value: PipelineExecutableStatisticValueKHR,
}
impl fmt::Debug for PipelineExecutableStatisticKHR {
    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
        fmt.debug_struct("PipelineExecutableStatisticKHR")
            .field("s_type", &self.s_type)
            .field("p_next", &self.p_next)
            .field("name", &unsafe {
                ::std::ffi::CStr::from_ptr(self.name.as_ptr() as *const c_char)
            })
            .field("description", &unsafe {
                ::std::ffi::CStr::from_ptr(self.description.as_ptr() as *const c_char)
            })
            .field("format", &self.format)
            .field("value", &"union")
            .finish()
    }
}
impl ::std::default::Default for PipelineExecutableStatisticKHR {
    fn default() -> PipelineExecutableStatisticKHR {
        PipelineExecutableStatisticKHR {
            s_type: StructureType::PIPELINE_EXECUTABLE_STATISTIC_KHR,
            p_next: ::std::ptr::null_mut(),
            name: unsafe { ::std::mem::zeroed() },
            description: unsafe { ::std::mem::zeroed() },
            format: PipelineExecutableStatisticFormatKHR::default(),
            value: PipelineExecutableStatisticValueKHR::default(),
        }
    }
}
impl PipelineExecutableStatisticKHR {
    pub fn builder<'a>() -> PipelineExecutableStatisticKHRBuilder<'a> {
        PipelineExecutableStatisticKHRBuilder {
            inner: PipelineExecutableStatisticKHR::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PipelineExecutableStatisticKHRBuilder<'a> {
    inner: PipelineExecutableStatisticKHR,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsPipelineExecutableStatisticKHR {}
impl<'a> ::std::ops::Deref for PipelineExecutableStatisticKHRBuilder<'a> {
    type Target = PipelineExecutableStatisticKHR;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PipelineExecutableStatisticKHRBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PipelineExecutableStatisticKHRBuilder<'a> {
    pub fn name(
        mut self,
        name: [c_char; MAX_DESCRIPTION_SIZE],
    ) -> PipelineExecutableStatisticKHRBuilder<'a> {
        self.inner.name = name;
        self
    }
    pub fn description(
        mut self,
        description: [c_char; MAX_DESCRIPTION_SIZE],
    ) -> PipelineExecutableStatisticKHRBuilder<'a> {
        self.inner.description = description;
        self
    }
    pub fn format(
        mut self,
        format: PipelineExecutableStatisticFormatKHR,
    ) -> PipelineExecutableStatisticKHRBuilder<'a> {
        self.inner.format = format;
        self
    }
    pub fn value(
        mut self,
        value: PipelineExecutableStatisticValueKHR,
    ) -> PipelineExecutableStatisticKHRBuilder<'a> {
        self.inner.value = value;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsPipelineExecutableStatisticKHR>(
        mut self,
        next: &'a mut T,
    ) -> PipelineExecutableStatisticKHRBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PipelineExecutableStatisticKHR {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineExecutableInternalRepresentationKHR.html>"]
pub struct PipelineExecutableInternalRepresentationKHR {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub name: [c_char; MAX_DESCRIPTION_SIZE],
    pub description: [c_char; MAX_DESCRIPTION_SIZE],
    pub is_text: Bool32,
    pub data_size: usize,
    pub p_data: *mut c_void,
}
impl fmt::Debug for PipelineExecutableInternalRepresentationKHR {
    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
        fmt.debug_struct("PipelineExecutableInternalRepresentationKHR")
            .field("s_type", &self.s_type)
            .field("p_next", &self.p_next)
            .field("name", &unsafe {
                ::std::ffi::CStr::from_ptr(self.name.as_ptr() as *const c_char)
            })
            .field("description", &unsafe {
                ::std::ffi::CStr::from_ptr(self.description.as_ptr() as *const c_char)
            })
            .field("is_text", &self.is_text)
            .field("data_size", &self.data_size)
            .field("p_data", &self.p_data)
            .finish()
    }
}
impl ::std::default::Default for PipelineExecutableInternalRepresentationKHR {
    fn default() -> PipelineExecutableInternalRepresentationKHR {
        PipelineExecutableInternalRepresentationKHR {
            s_type: StructureType::PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR,
            p_next: ::std::ptr::null_mut(),
            name: unsafe { ::std::mem::zeroed() },
            description: unsafe { ::std::mem::zeroed() },
            is_text: Bool32::default(),
            data_size: usize::default(),
            p_data: ::std::ptr::null_mut(),
        }
    }
}
impl PipelineExecutableInternalRepresentationKHR {
    pub fn builder<'a>() -> PipelineExecutableInternalRepresentationKHRBuilder<'a> {
        PipelineExecutableInternalRepresentationKHRBuilder {
            inner: PipelineExecutableInternalRepresentationKHR::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PipelineExecutableInternalRepresentationKHRBuilder<'a> {
    inner: PipelineExecutableInternalRepresentationKHR,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsPipelineExecutableInternalRepresentationKHR {}
impl<'a> ::std::ops::Deref for PipelineExecutableInternalRepresentationKHRBuilder<'a> {
    type Target = PipelineExecutableInternalRepresentationKHR;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PipelineExecutableInternalRepresentationKHRBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PipelineExecutableInternalRepresentationKHRBuilder<'a> {
    pub fn name(
        mut self,
        name: [c_char; MAX_DESCRIPTION_SIZE],
    ) -> PipelineExecutableInternalRepresentationKHRBuilder<'a> {
        self.inner.name = name;
        self
    }
    pub fn description(
        mut self,
        description: [c_char; MAX_DESCRIPTION_SIZE],
    ) -> PipelineExecutableInternalRepresentationKHRBuilder<'a> {
        self.inner.description = description;
        self
    }
    pub fn is_text(
        mut self,
        is_text: bool,
    ) -> PipelineExecutableInternalRepresentationKHRBuilder<'a> {
        self.inner.is_text = is_text.into();
        self
    }
    pub fn data(
        mut self,
        data: &'a mut [u8],
    ) -> PipelineExecutableInternalRepresentationKHRBuilder<'a> {
        self.inner.data_size = data.len() as _;
        self.inner.p_data = data.as_mut_ptr() as *mut c_void;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsPipelineExecutableInternalRepresentationKHR>(
        mut self,
        next: &'a mut T,
    ) -> PipelineExecutableInternalRepresentationKHRBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PipelineExecutableInternalRepresentationKHR {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT.html>"]
pub struct PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub shader_demote_to_helper_invocation: Bool32,
}
impl ::std::default::Default for PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT {
    fn default() -> PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT {
        PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT {
            s_type: StructureType::PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT,
            p_next: ::std::ptr::null_mut(),
            shader_demote_to_helper_invocation: Bool32::default(),
        }
    }
}
impl PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT {
    pub fn builder<'a>() -> PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXTBuilder<'a> {
        PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXTBuilder {
            inner: PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXTBuilder<'a> {
    inner: PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsDeviceCreateInfo
    for PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXTBuilder<'_>
{
}
unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT {}
impl<'a> ::std::ops::Deref for PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXTBuilder<'a> {
    type Target = PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut
    for PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXTBuilder<'a>
{
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXTBuilder<'a> {
    pub fn shader_demote_to_helper_invocation(
        mut self,
        shader_demote_to_helper_invocation: bool,
    ) -> PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXTBuilder<'a> {
        self.inner.shader_demote_to_helper_invocation = shader_demote_to_helper_invocation.into();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT.html>"]
pub struct PhysicalDeviceTexelBufferAlignmentFeaturesEXT {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub texel_buffer_alignment: Bool32,
}
impl ::std::default::Default for PhysicalDeviceTexelBufferAlignmentFeaturesEXT {
    fn default() -> PhysicalDeviceTexelBufferAlignmentFeaturesEXT {
        PhysicalDeviceTexelBufferAlignmentFeaturesEXT {
            s_type: StructureType::PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT,
            p_next: ::std::ptr::null_mut(),
            texel_buffer_alignment: Bool32::default(),
        }
    }
}
impl PhysicalDeviceTexelBufferAlignmentFeaturesEXT {
    pub fn builder<'a>() -> PhysicalDeviceTexelBufferAlignmentFeaturesEXTBuilder<'a> {
        PhysicalDeviceTexelBufferAlignmentFeaturesEXTBuilder {
            inner: PhysicalDeviceTexelBufferAlignmentFeaturesEXT::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDeviceTexelBufferAlignmentFeaturesEXTBuilder<'a> {
    inner: PhysicalDeviceTexelBufferAlignmentFeaturesEXT,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceTexelBufferAlignmentFeaturesEXTBuilder<'_> {}
unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceTexelBufferAlignmentFeaturesEXT {}
impl<'a> ::std::ops::Deref for PhysicalDeviceTexelBufferAlignmentFeaturesEXTBuilder<'a> {
    type Target = PhysicalDeviceTexelBufferAlignmentFeaturesEXT;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PhysicalDeviceTexelBufferAlignmentFeaturesEXTBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDeviceTexelBufferAlignmentFeaturesEXTBuilder<'a> {
    pub fn texel_buffer_alignment(
        mut self,
        texel_buffer_alignment: bool,
    ) -> PhysicalDeviceTexelBufferAlignmentFeaturesEXTBuilder<'a> {
        self.inner.texel_buffer_alignment = texel_buffer_alignment.into();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDeviceTexelBufferAlignmentFeaturesEXT {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT.html>"]
pub struct PhysicalDeviceTexelBufferAlignmentPropertiesEXT {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub storage_texel_buffer_offset_alignment_bytes: DeviceSize,
    pub storage_texel_buffer_offset_single_texel_alignment: Bool32,
    pub uniform_texel_buffer_offset_alignment_bytes: DeviceSize,
    pub uniform_texel_buffer_offset_single_texel_alignment: Bool32,
}
impl ::std::default::Default for PhysicalDeviceTexelBufferAlignmentPropertiesEXT {
    fn default() -> PhysicalDeviceTexelBufferAlignmentPropertiesEXT {
        PhysicalDeviceTexelBufferAlignmentPropertiesEXT {
            s_type: StructureType::PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT,
            p_next: ::std::ptr::null_mut(),
            storage_texel_buffer_offset_alignment_bytes: DeviceSize::default(),
            storage_texel_buffer_offset_single_texel_alignment: Bool32::default(),
            uniform_texel_buffer_offset_alignment_bytes: DeviceSize::default(),
            uniform_texel_buffer_offset_single_texel_alignment: Bool32::default(),
        }
    }
}
impl PhysicalDeviceTexelBufferAlignmentPropertiesEXT {
    pub fn builder<'a>() -> PhysicalDeviceTexelBufferAlignmentPropertiesEXTBuilder<'a> {
        PhysicalDeviceTexelBufferAlignmentPropertiesEXTBuilder {
            inner: PhysicalDeviceTexelBufferAlignmentPropertiesEXT::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDeviceTexelBufferAlignmentPropertiesEXTBuilder<'a> {
    inner: PhysicalDeviceTexelBufferAlignmentPropertiesEXT,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsPhysicalDeviceProperties2
    for PhysicalDeviceTexelBufferAlignmentPropertiesEXTBuilder<'_>
{
}
unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceTexelBufferAlignmentPropertiesEXT {}
impl<'a> ::std::ops::Deref for PhysicalDeviceTexelBufferAlignmentPropertiesEXTBuilder<'a> {
    type Target = PhysicalDeviceTexelBufferAlignmentPropertiesEXT;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PhysicalDeviceTexelBufferAlignmentPropertiesEXTBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDeviceTexelBufferAlignmentPropertiesEXTBuilder<'a> {
    pub fn storage_texel_buffer_offset_alignment_bytes(
        mut self,
        storage_texel_buffer_offset_alignment_bytes: DeviceSize,
    ) -> PhysicalDeviceTexelBufferAlignmentPropertiesEXTBuilder<'a> {
        self.inner.storage_texel_buffer_offset_alignment_bytes =
            storage_texel_buffer_offset_alignment_bytes;
        self
    }
    pub fn storage_texel_buffer_offset_single_texel_alignment(
        mut self,
        storage_texel_buffer_offset_single_texel_alignment: bool,
    ) -> PhysicalDeviceTexelBufferAlignmentPropertiesEXTBuilder<'a> {
        self.inner
            .storage_texel_buffer_offset_single_texel_alignment =
            storage_texel_buffer_offset_single_texel_alignment.into();
        self
    }
    pub fn uniform_texel_buffer_offset_alignment_bytes(
        mut self,
        uniform_texel_buffer_offset_alignment_bytes: DeviceSize,
    ) -> PhysicalDeviceTexelBufferAlignmentPropertiesEXTBuilder<'a> {
        self.inner.uniform_texel_buffer_offset_alignment_bytes =
            uniform_texel_buffer_offset_alignment_bytes;
        self
    }
    pub fn uniform_texel_buffer_offset_single_texel_alignment(
        mut self,
        uniform_texel_buffer_offset_single_texel_alignment: bool,
    ) -> PhysicalDeviceTexelBufferAlignmentPropertiesEXTBuilder<'a> {
        self.inner
            .uniform_texel_buffer_offset_single_texel_alignment =
            uniform_texel_buffer_offset_single_texel_alignment.into();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDeviceTexelBufferAlignmentPropertiesEXT {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceSubgroupSizeControlFeaturesEXT.html>"]
pub struct PhysicalDeviceSubgroupSizeControlFeaturesEXT {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub subgroup_size_control: Bool32,
    pub compute_full_subgroups: Bool32,
}
impl ::std::default::Default for PhysicalDeviceSubgroupSizeControlFeaturesEXT {
    fn default() -> PhysicalDeviceSubgroupSizeControlFeaturesEXT {
        PhysicalDeviceSubgroupSizeControlFeaturesEXT {
            s_type: StructureType::PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT,
            p_next: ::std::ptr::null_mut(),
            subgroup_size_control: Bool32::default(),
            compute_full_subgroups: Bool32::default(),
        }
    }
}
impl PhysicalDeviceSubgroupSizeControlFeaturesEXT {
    pub fn builder<'a>() -> PhysicalDeviceSubgroupSizeControlFeaturesEXTBuilder<'a> {
        PhysicalDeviceSubgroupSizeControlFeaturesEXTBuilder {
            inner: PhysicalDeviceSubgroupSizeControlFeaturesEXT::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDeviceSubgroupSizeControlFeaturesEXTBuilder<'a> {
    inner: PhysicalDeviceSubgroupSizeControlFeaturesEXT,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceSubgroupSizeControlFeaturesEXTBuilder<'_> {}
unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceSubgroupSizeControlFeaturesEXT {}
impl<'a> ::std::ops::Deref for PhysicalDeviceSubgroupSizeControlFeaturesEXTBuilder<'a> {
    type Target = PhysicalDeviceSubgroupSizeControlFeaturesEXT;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PhysicalDeviceSubgroupSizeControlFeaturesEXTBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDeviceSubgroupSizeControlFeaturesEXTBuilder<'a> {
    pub fn subgroup_size_control(
        mut self,
        subgroup_size_control: bool,
    ) -> PhysicalDeviceSubgroupSizeControlFeaturesEXTBuilder<'a> {
        self.inner.subgroup_size_control = subgroup_size_control.into();
        self
    }
    pub fn compute_full_subgroups(
        mut self,
        compute_full_subgroups: bool,
    ) -> PhysicalDeviceSubgroupSizeControlFeaturesEXTBuilder<'a> {
        self.inner.compute_full_subgroups = compute_full_subgroups.into();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDeviceSubgroupSizeControlFeaturesEXT {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceSubgroupSizeControlPropertiesEXT.html>"]
pub struct PhysicalDeviceSubgroupSizeControlPropertiesEXT {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub min_subgroup_size: u32,
    pub max_subgroup_size: u32,
    pub max_compute_workgroup_subgroups: u32,
    pub required_subgroup_size_stages: ShaderStageFlags,
}
impl ::std::default::Default for PhysicalDeviceSubgroupSizeControlPropertiesEXT {
    fn default() -> PhysicalDeviceSubgroupSizeControlPropertiesEXT {
        PhysicalDeviceSubgroupSizeControlPropertiesEXT {
            s_type: StructureType::PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT,
            p_next: ::std::ptr::null_mut(),
            min_subgroup_size: u32::default(),
            max_subgroup_size: u32::default(),
            max_compute_workgroup_subgroups: u32::default(),
            required_subgroup_size_stages: ShaderStageFlags::default(),
        }
    }
}
impl PhysicalDeviceSubgroupSizeControlPropertiesEXT {
    pub fn builder<'a>() -> PhysicalDeviceSubgroupSizeControlPropertiesEXTBuilder<'a> {
        PhysicalDeviceSubgroupSizeControlPropertiesEXTBuilder {
            inner: PhysicalDeviceSubgroupSizeControlPropertiesEXT::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDeviceSubgroupSizeControlPropertiesEXTBuilder<'a> {
    inner: PhysicalDeviceSubgroupSizeControlPropertiesEXT,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsPhysicalDeviceProperties2
    for PhysicalDeviceSubgroupSizeControlPropertiesEXTBuilder<'_>
{
}
unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceSubgroupSizeControlPropertiesEXT {}
impl<'a> ::std::ops::Deref for PhysicalDeviceSubgroupSizeControlPropertiesEXTBuilder<'a> {
    type Target = PhysicalDeviceSubgroupSizeControlPropertiesEXT;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PhysicalDeviceSubgroupSizeControlPropertiesEXTBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDeviceSubgroupSizeControlPropertiesEXTBuilder<'a> {
    pub fn min_subgroup_size(
        mut self,
        min_subgroup_size: u32,
    ) -> PhysicalDeviceSubgroupSizeControlPropertiesEXTBuilder<'a> {
        self.inner.min_subgroup_size = min_subgroup_size;
        self
    }
    pub fn max_subgroup_size(
        mut self,
        max_subgroup_size: u32,
    ) -> PhysicalDeviceSubgroupSizeControlPropertiesEXTBuilder<'a> {
        self.inner.max_subgroup_size = max_subgroup_size;
        self
    }
    pub fn max_compute_workgroup_subgroups(
        mut self,
        max_compute_workgroup_subgroups: u32,
    ) -> PhysicalDeviceSubgroupSizeControlPropertiesEXTBuilder<'a> {
        self.inner.max_compute_workgroup_subgroups = max_compute_workgroup_subgroups;
        self
    }
    pub fn required_subgroup_size_stages(
        mut self,
        required_subgroup_size_stages: ShaderStageFlags,
    ) -> PhysicalDeviceSubgroupSizeControlPropertiesEXTBuilder<'a> {
        self.inner.required_subgroup_size_stages = required_subgroup_size_stages;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDeviceSubgroupSizeControlPropertiesEXT {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT.html>"]
pub struct PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub required_subgroup_size: u32,
}
impl ::std::default::Default for PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT {
    fn default() -> PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT {
        PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT {
            s_type: StructureType::PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT,
            p_next: ::std::ptr::null_mut(),
            required_subgroup_size: u32::default(),
        }
    }
}
impl PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT {
    pub fn builder<'a>() -> PipelineShaderStageRequiredSubgroupSizeCreateInfoEXTBuilder<'a> {
        PipelineShaderStageRequiredSubgroupSizeCreateInfoEXTBuilder {
            inner: PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PipelineShaderStageRequiredSubgroupSizeCreateInfoEXTBuilder<'a> {
    inner: PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsPipelineShaderStageCreateInfo
    for PipelineShaderStageRequiredSubgroupSizeCreateInfoEXTBuilder<'_>
{
}
unsafe impl ExtendsPipelineShaderStageCreateInfo
    for PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT
{
}
impl<'a> ::std::ops::Deref for PipelineShaderStageRequiredSubgroupSizeCreateInfoEXTBuilder<'a> {
    type Target = PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PipelineShaderStageRequiredSubgroupSizeCreateInfoEXTBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PipelineShaderStageRequiredSubgroupSizeCreateInfoEXTBuilder<'a> {
    pub fn required_subgroup_size(
        mut self,
        required_subgroup_size: u32,
    ) -> PipelineShaderStageRequiredSubgroupSizeCreateInfoEXTBuilder<'a> {
        self.inner.required_subgroup_size = required_subgroup_size;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkMemoryOpaqueCaptureAddressAllocateInfo.html>"]
pub struct MemoryOpaqueCaptureAddressAllocateInfo {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub opaque_capture_address: u64,
}
impl ::std::default::Default for MemoryOpaqueCaptureAddressAllocateInfo {
    fn default() -> MemoryOpaqueCaptureAddressAllocateInfo {
        MemoryOpaqueCaptureAddressAllocateInfo {
            s_type: StructureType::MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO,
            p_next: ::std::ptr::null(),
            opaque_capture_address: u64::default(),
        }
    }
}
impl MemoryOpaqueCaptureAddressAllocateInfo {
    pub fn builder<'a>() -> MemoryOpaqueCaptureAddressAllocateInfoBuilder<'a> {
        MemoryOpaqueCaptureAddressAllocateInfoBuilder {
            inner: MemoryOpaqueCaptureAddressAllocateInfo::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct MemoryOpaqueCaptureAddressAllocateInfoBuilder<'a> {
    inner: MemoryOpaqueCaptureAddressAllocateInfo,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsMemoryAllocateInfo for MemoryOpaqueCaptureAddressAllocateInfoBuilder<'_> {}
unsafe impl ExtendsMemoryAllocateInfo for MemoryOpaqueCaptureAddressAllocateInfo {}
impl<'a> ::std::ops::Deref for MemoryOpaqueCaptureAddressAllocateInfoBuilder<'a> {
    type Target = MemoryOpaqueCaptureAddressAllocateInfo;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for MemoryOpaqueCaptureAddressAllocateInfoBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> MemoryOpaqueCaptureAddressAllocateInfoBuilder<'a> {
    pub fn opaque_capture_address(
        mut self,
        opaque_capture_address: u64,
    ) -> MemoryOpaqueCaptureAddressAllocateInfoBuilder<'a> {
        self.inner.opaque_capture_address = opaque_capture_address;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> MemoryOpaqueCaptureAddressAllocateInfo {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDeviceMemoryOpaqueCaptureAddressInfo.html>"]
pub struct DeviceMemoryOpaqueCaptureAddressInfo {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub memory: DeviceMemory,
}
impl ::std::default::Default for DeviceMemoryOpaqueCaptureAddressInfo {
    fn default() -> DeviceMemoryOpaqueCaptureAddressInfo {
        DeviceMemoryOpaqueCaptureAddressInfo {
            s_type: StructureType::DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO,
            p_next: ::std::ptr::null(),
            memory: DeviceMemory::default(),
        }
    }
}
impl DeviceMemoryOpaqueCaptureAddressInfo {
    pub fn builder<'a>() -> DeviceMemoryOpaqueCaptureAddressInfoBuilder<'a> {
        DeviceMemoryOpaqueCaptureAddressInfoBuilder {
            inner: DeviceMemoryOpaqueCaptureAddressInfo::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct DeviceMemoryOpaqueCaptureAddressInfoBuilder<'a> {
    inner: DeviceMemoryOpaqueCaptureAddressInfo,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsDeviceMemoryOpaqueCaptureAddressInfo {}
impl<'a> ::std::ops::Deref for DeviceMemoryOpaqueCaptureAddressInfoBuilder<'a> {
    type Target = DeviceMemoryOpaqueCaptureAddressInfo;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for DeviceMemoryOpaqueCaptureAddressInfoBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> DeviceMemoryOpaqueCaptureAddressInfoBuilder<'a> {
    pub fn memory(
        mut self,
        memory: DeviceMemory,
    ) -> DeviceMemoryOpaqueCaptureAddressInfoBuilder<'a> {
        self.inner.memory = memory;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsDeviceMemoryOpaqueCaptureAddressInfo>(
        mut self,
        next: &'a mut T,
    ) -> DeviceMemoryOpaqueCaptureAddressInfoBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> DeviceMemoryOpaqueCaptureAddressInfo {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLineRasterizationFeaturesEXT.html>"]
pub struct PhysicalDeviceLineRasterizationFeaturesEXT {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub rectangular_lines: Bool32,
    pub bresenham_lines: Bool32,
    pub smooth_lines: Bool32,
    pub stippled_rectangular_lines: Bool32,
    pub stippled_bresenham_lines: Bool32,
    pub stippled_smooth_lines: Bool32,
}
impl ::std::default::Default for PhysicalDeviceLineRasterizationFeaturesEXT {
    fn default() -> PhysicalDeviceLineRasterizationFeaturesEXT {
        PhysicalDeviceLineRasterizationFeaturesEXT {
            s_type: StructureType::PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT,
            p_next: ::std::ptr::null_mut(),
            rectangular_lines: Bool32::default(),
            bresenham_lines: Bool32::default(),
            smooth_lines: Bool32::default(),
            stippled_rectangular_lines: Bool32::default(),
            stippled_bresenham_lines: Bool32::default(),
            stippled_smooth_lines: Bool32::default(),
        }
    }
}
impl PhysicalDeviceLineRasterizationFeaturesEXT {
    pub fn builder<'a>() -> PhysicalDeviceLineRasterizationFeaturesEXTBuilder<'a> {
        PhysicalDeviceLineRasterizationFeaturesEXTBuilder {
            inner: PhysicalDeviceLineRasterizationFeaturesEXT::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDeviceLineRasterizationFeaturesEXTBuilder<'a> {
    inner: PhysicalDeviceLineRasterizationFeaturesEXT,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceLineRasterizationFeaturesEXTBuilder<'_> {}
unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceLineRasterizationFeaturesEXT {}
impl<'a> ::std::ops::Deref for PhysicalDeviceLineRasterizationFeaturesEXTBuilder<'a> {
    type Target = PhysicalDeviceLineRasterizationFeaturesEXT;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PhysicalDeviceLineRasterizationFeaturesEXTBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDeviceLineRasterizationFeaturesEXTBuilder<'a> {
    pub fn rectangular_lines(
        mut self,
        rectangular_lines: bool,
    ) -> PhysicalDeviceLineRasterizationFeaturesEXTBuilder<'a> {
        self.inner.rectangular_lines = rectangular_lines.into();
        self
    }
    pub fn bresenham_lines(
        mut self,
        bresenham_lines: bool,
    ) -> PhysicalDeviceLineRasterizationFeaturesEXTBuilder<'a> {
        self.inner.bresenham_lines = bresenham_lines.into();
        self
    }
    pub fn smooth_lines(
        mut self,
        smooth_lines: bool,
    ) -> PhysicalDeviceLineRasterizationFeaturesEXTBuilder<'a> {
        self.inner.smooth_lines = smooth_lines.into();
        self
    }
    pub fn stippled_rectangular_lines(
        mut self,
        stippled_rectangular_lines: bool,
    ) -> PhysicalDeviceLineRasterizationFeaturesEXTBuilder<'a> {
        self.inner.stippled_rectangular_lines = stippled_rectangular_lines.into();
        self
    }
    pub fn stippled_bresenham_lines(
        mut self,
        stippled_bresenham_lines: bool,
    ) -> PhysicalDeviceLineRasterizationFeaturesEXTBuilder<'a> {
        self.inner.stippled_bresenham_lines = stippled_bresenham_lines.into();
        self
    }
    pub fn stippled_smooth_lines(
        mut self,
        stippled_smooth_lines: bool,
    ) -> PhysicalDeviceLineRasterizationFeaturesEXTBuilder<'a> {
        self.inner.stippled_smooth_lines = stippled_smooth_lines.into();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDeviceLineRasterizationFeaturesEXT {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLineRasterizationPropertiesEXT.html>"]
pub struct PhysicalDeviceLineRasterizationPropertiesEXT {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub line_sub_pixel_precision_bits: u32,
}
impl ::std::default::Default for PhysicalDeviceLineRasterizationPropertiesEXT {
    fn default() -> PhysicalDeviceLineRasterizationPropertiesEXT {
        PhysicalDeviceLineRasterizationPropertiesEXT {
            s_type: StructureType::PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT,
            p_next: ::std::ptr::null_mut(),
            line_sub_pixel_precision_bits: u32::default(),
        }
    }
}
impl PhysicalDeviceLineRasterizationPropertiesEXT {
    pub fn builder<'a>() -> PhysicalDeviceLineRasterizationPropertiesEXTBuilder<'a> {
        PhysicalDeviceLineRasterizationPropertiesEXTBuilder {
            inner: PhysicalDeviceLineRasterizationPropertiesEXT::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDeviceLineRasterizationPropertiesEXTBuilder<'a> {
    inner: PhysicalDeviceLineRasterizationPropertiesEXT,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsPhysicalDeviceProperties2
    for PhysicalDeviceLineRasterizationPropertiesEXTBuilder<'_>
{
}
unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceLineRasterizationPropertiesEXT {}
impl<'a> ::std::ops::Deref for PhysicalDeviceLineRasterizationPropertiesEXTBuilder<'a> {
    type Target = PhysicalDeviceLineRasterizationPropertiesEXT;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PhysicalDeviceLineRasterizationPropertiesEXTBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDeviceLineRasterizationPropertiesEXTBuilder<'a> {
    pub fn line_sub_pixel_precision_bits(
        mut self,
        line_sub_pixel_precision_bits: u32,
    ) -> PhysicalDeviceLineRasterizationPropertiesEXTBuilder<'a> {
        self.inner.line_sub_pixel_precision_bits = line_sub_pixel_precision_bits;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDeviceLineRasterizationPropertiesEXT {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineRasterizationLineStateCreateInfoEXT.html>"]
pub struct PipelineRasterizationLineStateCreateInfoEXT {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub line_rasterization_mode: LineRasterizationModeEXT,
    pub stippled_line_enable: Bool32,
    pub line_stipple_factor: u32,
    pub line_stipple_pattern: u16,
}
impl ::std::default::Default for PipelineRasterizationLineStateCreateInfoEXT {
    fn default() -> PipelineRasterizationLineStateCreateInfoEXT {
        PipelineRasterizationLineStateCreateInfoEXT {
            s_type: StructureType::PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT,
            p_next: ::std::ptr::null(),
            line_rasterization_mode: LineRasterizationModeEXT::default(),
            stippled_line_enable: Bool32::default(),
            line_stipple_factor: u32::default(),
            line_stipple_pattern: u16::default(),
        }
    }
}
impl PipelineRasterizationLineStateCreateInfoEXT {
    pub fn builder<'a>() -> PipelineRasterizationLineStateCreateInfoEXTBuilder<'a> {
        PipelineRasterizationLineStateCreateInfoEXTBuilder {
            inner: PipelineRasterizationLineStateCreateInfoEXT::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PipelineRasterizationLineStateCreateInfoEXTBuilder<'a> {
    inner: PipelineRasterizationLineStateCreateInfoEXT,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsPipelineRasterizationStateCreateInfo
    for PipelineRasterizationLineStateCreateInfoEXTBuilder<'_>
{
}
unsafe impl ExtendsPipelineRasterizationStateCreateInfo
    for PipelineRasterizationLineStateCreateInfoEXT
{
}
impl<'a> ::std::ops::Deref for PipelineRasterizationLineStateCreateInfoEXTBuilder<'a> {
    type Target = PipelineRasterizationLineStateCreateInfoEXT;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PipelineRasterizationLineStateCreateInfoEXTBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PipelineRasterizationLineStateCreateInfoEXTBuilder<'a> {
    pub fn line_rasterization_mode(
        mut self,
        line_rasterization_mode: LineRasterizationModeEXT,
    ) -> PipelineRasterizationLineStateCreateInfoEXTBuilder<'a> {
        self.inner.line_rasterization_mode = line_rasterization_mode;
        self
    }
    pub fn stippled_line_enable(
        mut self,
        stippled_line_enable: bool,
    ) -> PipelineRasterizationLineStateCreateInfoEXTBuilder<'a> {
        self.inner.stippled_line_enable = stippled_line_enable.into();
        self
    }
    pub fn line_stipple_factor(
        mut self,
        line_stipple_factor: u32,
    ) -> PipelineRasterizationLineStateCreateInfoEXTBuilder<'a> {
        self.inner.line_stipple_factor = line_stipple_factor;
        self
    }
    pub fn line_stipple_pattern(
        mut self,
        line_stipple_pattern: u16,
    ) -> PipelineRasterizationLineStateCreateInfoEXTBuilder<'a> {
        self.inner.line_stipple_pattern = line_stipple_pattern;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PipelineRasterizationLineStateCreateInfoEXT {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT.html>"]
pub struct PhysicalDevicePipelineCreationCacheControlFeaturesEXT {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub pipeline_creation_cache_control: Bool32,
}
impl ::std::default::Default for PhysicalDevicePipelineCreationCacheControlFeaturesEXT {
    fn default() -> PhysicalDevicePipelineCreationCacheControlFeaturesEXT {
        PhysicalDevicePipelineCreationCacheControlFeaturesEXT {
            s_type: StructureType::PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES_EXT,
            p_next: ::std::ptr::null_mut(),
            pipeline_creation_cache_control: Bool32::default(),
        }
    }
}
impl PhysicalDevicePipelineCreationCacheControlFeaturesEXT {
    pub fn builder<'a>() -> PhysicalDevicePipelineCreationCacheControlFeaturesEXTBuilder<'a> {
        PhysicalDevicePipelineCreationCacheControlFeaturesEXTBuilder {
            inner: PhysicalDevicePipelineCreationCacheControlFeaturesEXT::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDevicePipelineCreationCacheControlFeaturesEXTBuilder<'a> {
    inner: PhysicalDevicePipelineCreationCacheControlFeaturesEXT,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsDeviceCreateInfo
    for PhysicalDevicePipelineCreationCacheControlFeaturesEXTBuilder<'_>
{
}
unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePipelineCreationCacheControlFeaturesEXT {}
impl<'a> ::std::ops::Deref for PhysicalDevicePipelineCreationCacheControlFeaturesEXTBuilder<'a> {
    type Target = PhysicalDevicePipelineCreationCacheControlFeaturesEXT;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PhysicalDevicePipelineCreationCacheControlFeaturesEXTBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDevicePipelineCreationCacheControlFeaturesEXTBuilder<'a> {
    pub fn pipeline_creation_cache_control(
        mut self,
        pipeline_creation_cache_control: bool,
    ) -> PhysicalDevicePipelineCreationCacheControlFeaturesEXTBuilder<'a> {
        self.inner.pipeline_creation_cache_control = pipeline_creation_cache_control.into();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDevicePipelineCreationCacheControlFeaturesEXT {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan11Features.html>"]
pub struct PhysicalDeviceVulkan11Features {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub storage_buffer16_bit_access: Bool32,
    pub uniform_and_storage_buffer16_bit_access: Bool32,
    pub storage_push_constant16: Bool32,
    pub storage_input_output16: Bool32,
    pub multiview: Bool32,
    pub multiview_geometry_shader: Bool32,
    pub multiview_tessellation_shader: Bool32,
    pub variable_pointers_storage_buffer: Bool32,
    pub variable_pointers: Bool32,
    pub protected_memory: Bool32,
    pub sampler_ycbcr_conversion: Bool32,
    pub shader_draw_parameters: Bool32,
}
impl ::std::default::Default for PhysicalDeviceVulkan11Features {
    fn default() -> PhysicalDeviceVulkan11Features {
        PhysicalDeviceVulkan11Features {
            s_type: StructureType::PHYSICAL_DEVICE_VULKAN_1_1_FEATURES,
            p_next: ::std::ptr::null_mut(),
            storage_buffer16_bit_access: Bool32::default(),
            uniform_and_storage_buffer16_bit_access: Bool32::default(),
            storage_push_constant16: Bool32::default(),
            storage_input_output16: Bool32::default(),
            multiview: Bool32::default(),
            multiview_geometry_shader: Bool32::default(),
            multiview_tessellation_shader: Bool32::default(),
            variable_pointers_storage_buffer: Bool32::default(),
            variable_pointers: Bool32::default(),
            protected_memory: Bool32::default(),
            sampler_ycbcr_conversion: Bool32::default(),
            shader_draw_parameters: Bool32::default(),
        }
    }
}
impl PhysicalDeviceVulkan11Features {
    pub fn builder<'a>() -> PhysicalDeviceVulkan11FeaturesBuilder<'a> {
        PhysicalDeviceVulkan11FeaturesBuilder {
            inner: PhysicalDeviceVulkan11Features::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDeviceVulkan11FeaturesBuilder<'a> {
    inner: PhysicalDeviceVulkan11Features,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVulkan11FeaturesBuilder<'_> {}
unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVulkan11Features {}
impl<'a> ::std::ops::Deref for PhysicalDeviceVulkan11FeaturesBuilder<'a> {
    type Target = PhysicalDeviceVulkan11Features;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PhysicalDeviceVulkan11FeaturesBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDeviceVulkan11FeaturesBuilder<'a> {
    pub fn storage_buffer16_bit_access(
        mut self,
        storage_buffer16_bit_access: bool,
    ) -> PhysicalDeviceVulkan11FeaturesBuilder<'a> {
        self.inner.storage_buffer16_bit_access = storage_buffer16_bit_access.into();
        self
    }
    pub fn uniform_and_storage_buffer16_bit_access(
        mut self,
        uniform_and_storage_buffer16_bit_access: bool,
    ) -> PhysicalDeviceVulkan11FeaturesBuilder<'a> {
        self.inner.uniform_and_storage_buffer16_bit_access =
            uniform_and_storage_buffer16_bit_access.into();
        self
    }
    pub fn storage_push_constant16(
        mut self,
        storage_push_constant16: bool,
    ) -> PhysicalDeviceVulkan11FeaturesBuilder<'a> {
        self.inner.storage_push_constant16 = storage_push_constant16.into();
        self
    }
    pub fn storage_input_output16(
        mut self,
        storage_input_output16: bool,
    ) -> PhysicalDeviceVulkan11FeaturesBuilder<'a> {
        self.inner.storage_input_output16 = storage_input_output16.into();
        self
    }
    pub fn multiview(mut self, multiview: bool) -> PhysicalDeviceVulkan11FeaturesBuilder<'a> {
        self.inner.multiview = multiview.into();
        self
    }
    pub fn multiview_geometry_shader(
        mut self,
        multiview_geometry_shader: bool,
    ) -> PhysicalDeviceVulkan11FeaturesBuilder<'a> {
        self.inner.multiview_geometry_shader = multiview_geometry_shader.into();
        self
    }
    pub fn multiview_tessellation_shader(
        mut self,
        multiview_tessellation_shader: bool,
    ) -> PhysicalDeviceVulkan11FeaturesBuilder<'a> {
        self.inner.multiview_tessellation_shader = multiview_tessellation_shader.into();
        self
    }
    pub fn variable_pointers_storage_buffer(
        mut self,
        variable_pointers_storage_buffer: bool,
    ) -> PhysicalDeviceVulkan11FeaturesBuilder<'a> {
        self.inner.variable_pointers_storage_buffer = variable_pointers_storage_buffer.into();
        self
    }
    pub fn variable_pointers(
        mut self,
        variable_pointers: bool,
    ) -> PhysicalDeviceVulkan11FeaturesBuilder<'a> {
        self.inner.variable_pointers = variable_pointers.into();
        self
    }
    pub fn protected_memory(
        mut self,
        protected_memory: bool,
    ) -> PhysicalDeviceVulkan11FeaturesBuilder<'a> {
        self.inner.protected_memory = protected_memory.into();
        self
    }
    pub fn sampler_ycbcr_conversion(
        mut self,
        sampler_ycbcr_conversion: bool,
    ) -> PhysicalDeviceVulkan11FeaturesBuilder<'a> {
        self.inner.sampler_ycbcr_conversion = sampler_ycbcr_conversion.into();
        self
    }
    pub fn shader_draw_parameters(
        mut self,
        shader_draw_parameters: bool,
    ) -> PhysicalDeviceVulkan11FeaturesBuilder<'a> {
        self.inner.shader_draw_parameters = shader_draw_parameters.into();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDeviceVulkan11Features {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan11Properties.html>"]
pub struct PhysicalDeviceVulkan11Properties {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub device_uuid: [u8; UUID_SIZE],
    pub driver_uuid: [u8; UUID_SIZE],
    pub device_luid: [u8; LUID_SIZE],
    pub device_node_mask: u32,
    pub device_luid_valid: Bool32,
    pub subgroup_size: u32,
    pub subgroup_supported_stages: ShaderStageFlags,
    pub subgroup_supported_operations: SubgroupFeatureFlags,
    pub subgroup_quad_operations_in_all_stages: Bool32,
    pub point_clipping_behavior: PointClippingBehavior,
    pub max_multiview_view_count: u32,
    pub max_multiview_instance_index: u32,
    pub protected_no_fault: Bool32,
    pub max_per_set_descriptors: u32,
    pub max_memory_allocation_size: DeviceSize,
}
impl ::std::default::Default for PhysicalDeviceVulkan11Properties {
    fn default() -> PhysicalDeviceVulkan11Properties {
        PhysicalDeviceVulkan11Properties {
            s_type: StructureType::PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES,
            p_next: ::std::ptr::null_mut(),
            device_uuid: unsafe { ::std::mem::zeroed() },
            driver_uuid: unsafe { ::std::mem::zeroed() },
            device_luid: unsafe { ::std::mem::zeroed() },
            device_node_mask: u32::default(),
            device_luid_valid: Bool32::default(),
            subgroup_size: u32::default(),
            subgroup_supported_stages: ShaderStageFlags::default(),
            subgroup_supported_operations: SubgroupFeatureFlags::default(),
            subgroup_quad_operations_in_all_stages: Bool32::default(),
            point_clipping_behavior: PointClippingBehavior::default(),
            max_multiview_view_count: u32::default(),
            max_multiview_instance_index: u32::default(),
            protected_no_fault: Bool32::default(),
            max_per_set_descriptors: u32::default(),
            max_memory_allocation_size: DeviceSize::default(),
        }
    }
}
impl PhysicalDeviceVulkan11Properties {
    pub fn builder<'a>() -> PhysicalDeviceVulkan11PropertiesBuilder<'a> {
        PhysicalDeviceVulkan11PropertiesBuilder {
            inner: PhysicalDeviceVulkan11Properties::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDeviceVulkan11PropertiesBuilder<'a> {
    inner: PhysicalDeviceVulkan11Properties,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceVulkan11PropertiesBuilder<'_> {}
unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceVulkan11Properties {}
impl<'a> ::std::ops::Deref for PhysicalDeviceVulkan11PropertiesBuilder<'a> {
    type Target = PhysicalDeviceVulkan11Properties;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PhysicalDeviceVulkan11PropertiesBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDeviceVulkan11PropertiesBuilder<'a> {
    pub fn device_uuid(
        mut self,
        device_uuid: [u8; UUID_SIZE],
    ) -> PhysicalDeviceVulkan11PropertiesBuilder<'a> {
        self.inner.device_uuid = device_uuid;
        self
    }
    pub fn driver_uuid(
        mut self,
        driver_uuid: [u8; UUID_SIZE],
    ) -> PhysicalDeviceVulkan11PropertiesBuilder<'a> {
        self.inner.driver_uuid = driver_uuid;
        self
    }
    pub fn device_luid(
        mut self,
        device_luid: [u8; LUID_SIZE],
    ) -> PhysicalDeviceVulkan11PropertiesBuilder<'a> {
        self.inner.device_luid = device_luid;
        self
    }
    pub fn device_node_mask(
        mut self,
        device_node_mask: u32,
    ) -> PhysicalDeviceVulkan11PropertiesBuilder<'a> {
        self.inner.device_node_mask = device_node_mask;
        self
    }
    pub fn device_luid_valid(
        mut self,
        device_luid_valid: bool,
    ) -> PhysicalDeviceVulkan11PropertiesBuilder<'a> {
        self.inner.device_luid_valid = device_luid_valid.into();
        self
    }
    pub fn subgroup_size(
        mut self,
        subgroup_size: u32,
    ) -> PhysicalDeviceVulkan11PropertiesBuilder<'a> {
        self.inner.subgroup_size = subgroup_size;
        self
    }
    pub fn subgroup_supported_stages(
        mut self,
        subgroup_supported_stages: ShaderStageFlags,
    ) -> PhysicalDeviceVulkan11PropertiesBuilder<'a> {
        self.inner.subgroup_supported_stages = subgroup_supported_stages;
        self
    }
    pub fn subgroup_supported_operations(
        mut self,
        subgroup_supported_operations: SubgroupFeatureFlags,
    ) -> PhysicalDeviceVulkan11PropertiesBuilder<'a> {
        self.inner.subgroup_supported_operations = subgroup_supported_operations;
        self
    }
    pub fn subgroup_quad_operations_in_all_stages(
        mut self,
        subgroup_quad_operations_in_all_stages: bool,
    ) -> PhysicalDeviceVulkan11PropertiesBuilder<'a> {
        self.inner.subgroup_quad_operations_in_all_stages =
            subgroup_quad_operations_in_all_stages.into();
        self
    }
    pub fn point_clipping_behavior(
        mut self,
        point_clipping_behavior: PointClippingBehavior,
    ) -> PhysicalDeviceVulkan11PropertiesBuilder<'a> {
        self.inner.point_clipping_behavior = point_clipping_behavior;
        self
    }
    pub fn max_multiview_view_count(
        mut self,
        max_multiview_view_count: u32,
    ) -> PhysicalDeviceVulkan11PropertiesBuilder<'a> {
        self.inner.max_multiview_view_count = max_multiview_view_count;
        self
    }
    pub fn max_multiview_instance_index(
        mut self,
        max_multiview_instance_index: u32,
    ) -> PhysicalDeviceVulkan11PropertiesBuilder<'a> {
        self.inner.max_multiview_instance_index = max_multiview_instance_index;
        self
    }
    pub fn protected_no_fault(
        mut self,
        protected_no_fault: bool,
    ) -> PhysicalDeviceVulkan11PropertiesBuilder<'a> {
        self.inner.protected_no_fault = protected_no_fault.into();
        self
    }
    pub fn max_per_set_descriptors(
        mut self,
        max_per_set_descriptors: u32,
    ) -> PhysicalDeviceVulkan11PropertiesBuilder<'a> {
        self.inner.max_per_set_descriptors = max_per_set_descriptors;
        self
    }
    pub fn max_memory_allocation_size(
        mut self,
        max_memory_allocation_size: DeviceSize,
    ) -> PhysicalDeviceVulkan11PropertiesBuilder<'a> {
        self.inner.max_memory_allocation_size = max_memory_allocation_size;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDeviceVulkan11Properties {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan12Features.html>"]
pub struct PhysicalDeviceVulkan12Features {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub sampler_mirror_clamp_to_edge: Bool32,
    pub draw_indirect_count: Bool32,
    pub storage_buffer8_bit_access: Bool32,
    pub uniform_and_storage_buffer8_bit_access: Bool32,
    pub storage_push_constant8: Bool32,
    pub shader_buffer_int64_atomics: Bool32,
    pub shader_shared_int64_atomics: Bool32,
    pub shader_float16: Bool32,
    pub shader_int8: Bool32,
    pub descriptor_indexing: Bool32,
    pub shader_input_attachment_array_dynamic_indexing: Bool32,
    pub shader_uniform_texel_buffer_array_dynamic_indexing: Bool32,
    pub shader_storage_texel_buffer_array_dynamic_indexing: Bool32,
    pub shader_uniform_buffer_array_non_uniform_indexing: Bool32,
    pub shader_sampled_image_array_non_uniform_indexing: Bool32,
    pub shader_storage_buffer_array_non_uniform_indexing: Bool32,
    pub shader_storage_image_array_non_uniform_indexing: Bool32,
    pub shader_input_attachment_array_non_uniform_indexing: Bool32,
    pub shader_uniform_texel_buffer_array_non_uniform_indexing: Bool32,
    pub shader_storage_texel_buffer_array_non_uniform_indexing: Bool32,
    pub descriptor_binding_uniform_buffer_update_after_bind: Bool32,
    pub descriptor_binding_sampled_image_update_after_bind: Bool32,
    pub descriptor_binding_storage_image_update_after_bind: Bool32,
    pub descriptor_binding_storage_buffer_update_after_bind: Bool32,
    pub descriptor_binding_uniform_texel_buffer_update_after_bind: Bool32,
    pub descriptor_binding_storage_texel_buffer_update_after_bind: Bool32,
    pub descriptor_binding_update_unused_while_pending: Bool32,
    pub descriptor_binding_partially_bound: Bool32,
    pub descriptor_binding_variable_descriptor_count: Bool32,
    pub runtime_descriptor_array: Bool32,
    pub sampler_filter_minmax: Bool32,
    pub scalar_block_layout: Bool32,
    pub imageless_framebuffer: Bool32,
    pub uniform_buffer_standard_layout: Bool32,
    pub shader_subgroup_extended_types: Bool32,
    pub separate_depth_stencil_layouts: Bool32,
    pub host_query_reset: Bool32,
    pub timeline_semaphore: Bool32,
    pub buffer_device_address: Bool32,
    pub buffer_device_address_capture_replay: Bool32,
    pub buffer_device_address_multi_device: Bool32,
    pub vulkan_memory_model: Bool32,
    pub vulkan_memory_model_device_scope: Bool32,
    pub vulkan_memory_model_availability_visibility_chains: Bool32,
    pub shader_output_viewport_index: Bool32,
    pub shader_output_layer: Bool32,
    pub subgroup_broadcast_dynamic_id: Bool32,
}
impl ::std::default::Default for PhysicalDeviceVulkan12Features {
    fn default() -> PhysicalDeviceVulkan12Features {
        PhysicalDeviceVulkan12Features {
            s_type: StructureType::PHYSICAL_DEVICE_VULKAN_1_2_FEATURES,
            p_next: ::std::ptr::null_mut(),
            sampler_mirror_clamp_to_edge: Bool32::default(),
            draw_indirect_count: Bool32::default(),
            storage_buffer8_bit_access: Bool32::default(),
            uniform_and_storage_buffer8_bit_access: Bool32::default(),
            storage_push_constant8: Bool32::default(),
            shader_buffer_int64_atomics: Bool32::default(),
            shader_shared_int64_atomics: Bool32::default(),
            shader_float16: Bool32::default(),
            shader_int8: Bool32::default(),
            descriptor_indexing: Bool32::default(),
            shader_input_attachment_array_dynamic_indexing: Bool32::default(),
            shader_uniform_texel_buffer_array_dynamic_indexing: Bool32::default(),
            shader_storage_texel_buffer_array_dynamic_indexing: Bool32::default(),
            shader_uniform_buffer_array_non_uniform_indexing: Bool32::default(),
            shader_sampled_image_array_non_uniform_indexing: Bool32::default(),
            shader_storage_buffer_array_non_uniform_indexing: Bool32::default(),
            shader_storage_image_array_non_uniform_indexing: Bool32::default(),
            shader_input_attachment_array_non_uniform_indexing: Bool32::default(),
            shader_uniform_texel_buffer_array_non_uniform_indexing: Bool32::default(),
            shader_storage_texel_buffer_array_non_uniform_indexing: Bool32::default(),
            descriptor_binding_uniform_buffer_update_after_bind: Bool32::default(),
            descriptor_binding_sampled_image_update_after_bind: Bool32::default(),
            descriptor_binding_storage_image_update_after_bind: Bool32::default(),
            descriptor_binding_storage_buffer_update_after_bind: Bool32::default(),
            descriptor_binding_uniform_texel_buffer_update_after_bind: Bool32::default(),
            descriptor_binding_storage_texel_buffer_update_after_bind: Bool32::default(),
            descriptor_binding_update_unused_while_pending: Bool32::default(),
            descriptor_binding_partially_bound: Bool32::default(),
            descriptor_binding_variable_descriptor_count: Bool32::default(),
            runtime_descriptor_array: Bool32::default(),
            sampler_filter_minmax: Bool32::default(),
            scalar_block_layout: Bool32::default(),
            imageless_framebuffer: Bool32::default(),
            uniform_buffer_standard_layout: Bool32::default(),
            shader_subgroup_extended_types: Bool32::default(),
            separate_depth_stencil_layouts: Bool32::default(),
            host_query_reset: Bool32::default(),
            timeline_semaphore: Bool32::default(),
            buffer_device_address: Bool32::default(),
            buffer_device_address_capture_replay: Bool32::default(),
            buffer_device_address_multi_device: Bool32::default(),
            vulkan_memory_model: Bool32::default(),
            vulkan_memory_model_device_scope: Bool32::default(),
            vulkan_memory_model_availability_visibility_chains: Bool32::default(),
            shader_output_viewport_index: Bool32::default(),
            shader_output_layer: Bool32::default(),
            subgroup_broadcast_dynamic_id: Bool32::default(),
        }
    }
}
impl PhysicalDeviceVulkan12Features {
    pub fn builder<'a>() -> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
        PhysicalDeviceVulkan12FeaturesBuilder {
            inner: PhysicalDeviceVulkan12Features::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDeviceVulkan12FeaturesBuilder<'a> {
    inner: PhysicalDeviceVulkan12Features,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVulkan12FeaturesBuilder<'_> {}
unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVulkan12Features {}
impl<'a> ::std::ops::Deref for PhysicalDeviceVulkan12FeaturesBuilder<'a> {
    type Target = PhysicalDeviceVulkan12Features;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PhysicalDeviceVulkan12FeaturesBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
    pub fn sampler_mirror_clamp_to_edge(
        mut self,
        sampler_mirror_clamp_to_edge: bool,
    ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
        self.inner.sampler_mirror_clamp_to_edge = sampler_mirror_clamp_to_edge.into();
        self
    }
    pub fn draw_indirect_count(
        mut self,
        draw_indirect_count: bool,
    ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
        self.inner.draw_indirect_count = draw_indirect_count.into();
        self
    }
    pub fn storage_buffer8_bit_access(
        mut self,
        storage_buffer8_bit_access: bool,
    ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
        self.inner.storage_buffer8_bit_access = storage_buffer8_bit_access.into();
        self
    }
    pub fn uniform_and_storage_buffer8_bit_access(
        mut self,
        uniform_and_storage_buffer8_bit_access: bool,
    ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
        self.inner.uniform_and_storage_buffer8_bit_access =
            uniform_and_storage_buffer8_bit_access.into();
        self
    }
    pub fn storage_push_constant8(
        mut self,
        storage_push_constant8: bool,
    ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
        self.inner.storage_push_constant8 = storage_push_constant8.into();
        self
    }
    pub fn shader_buffer_int64_atomics(
        mut self,
        shader_buffer_int64_atomics: bool,
    ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
        self.inner.shader_buffer_int64_atomics = shader_buffer_int64_atomics.into();
        self
    }
    pub fn shader_shared_int64_atomics(
        mut self,
        shader_shared_int64_atomics: bool,
    ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
        self.inner.shader_shared_int64_atomics = shader_shared_int64_atomics.into();
        self
    }
    pub fn shader_float16(
        mut self,
        shader_float16: bool,
    ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
        self.inner.shader_float16 = shader_float16.into();
        self
    }
    pub fn shader_int8(mut self, shader_int8: bool) -> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
        self.inner.shader_int8 = shader_int8.into();
        self
    }
    pub fn descriptor_indexing(
        mut self,
        descriptor_indexing: bool,
    ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
        self.inner.descriptor_indexing = descriptor_indexing.into();
        self
    }
    pub fn shader_input_attachment_array_dynamic_indexing(
        mut self,
        shader_input_attachment_array_dynamic_indexing: bool,
    ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
        self.inner.shader_input_attachment_array_dynamic_indexing =
            shader_input_attachment_array_dynamic_indexing.into();
        self
    }
    pub fn shader_uniform_texel_buffer_array_dynamic_indexing(
        mut self,
        shader_uniform_texel_buffer_array_dynamic_indexing: bool,
    ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
        self.inner
            .shader_uniform_texel_buffer_array_dynamic_indexing =
            shader_uniform_texel_buffer_array_dynamic_indexing.into();
        self
    }
    pub fn shader_storage_texel_buffer_array_dynamic_indexing(
        mut self,
        shader_storage_texel_buffer_array_dynamic_indexing: bool,
    ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
        self.inner
            .shader_storage_texel_buffer_array_dynamic_indexing =
            shader_storage_texel_buffer_array_dynamic_indexing.into();
        self
    }
    pub fn shader_uniform_buffer_array_non_uniform_indexing(
        mut self,
        shader_uniform_buffer_array_non_uniform_indexing: bool,
    ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
        self.inner.shader_uniform_buffer_array_non_uniform_indexing =
            shader_uniform_buffer_array_non_uniform_indexing.into();
        self
    }
    pub fn shader_sampled_image_array_non_uniform_indexing(
        mut self,
        shader_sampled_image_array_non_uniform_indexing: bool,
    ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
        self.inner.shader_sampled_image_array_non_uniform_indexing =
            shader_sampled_image_array_non_uniform_indexing.into();
        self
    }
    pub fn shader_storage_buffer_array_non_uniform_indexing(
        mut self,
        shader_storage_buffer_array_non_uniform_indexing: bool,
    ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
        self.inner.shader_storage_buffer_array_non_uniform_indexing =
            shader_storage_buffer_array_non_uniform_indexing.into();
        self
    }
    pub fn shader_storage_image_array_non_uniform_indexing(
        mut self,
        shader_storage_image_array_non_uniform_indexing: bool,
    ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
        self.inner.shader_storage_image_array_non_uniform_indexing =
            shader_storage_image_array_non_uniform_indexing.into();
        self
    }
    pub fn shader_input_attachment_array_non_uniform_indexing(
        mut self,
        shader_input_attachment_array_non_uniform_indexing: bool,
    ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
        self.inner
            .shader_input_attachment_array_non_uniform_indexing =
            shader_input_attachment_array_non_uniform_indexing.into();
        self
    }
    pub fn shader_uniform_texel_buffer_array_non_uniform_indexing(
        mut self,
        shader_uniform_texel_buffer_array_non_uniform_indexing: bool,
    ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
        self.inner
            .shader_uniform_texel_buffer_array_non_uniform_indexing =
            shader_uniform_texel_buffer_array_non_uniform_indexing.into();
        self
    }
    pub fn shader_storage_texel_buffer_array_non_uniform_indexing(
        mut self,
        shader_storage_texel_buffer_array_non_uniform_indexing: bool,
    ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
        self.inner
            .shader_storage_texel_buffer_array_non_uniform_indexing =
            shader_storage_texel_buffer_array_non_uniform_indexing.into();
        self
    }
    pub fn descriptor_binding_uniform_buffer_update_after_bind(
        mut self,
        descriptor_binding_uniform_buffer_update_after_bind: bool,
    ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
        self.inner
            .descriptor_binding_uniform_buffer_update_after_bind =
            descriptor_binding_uniform_buffer_update_after_bind.into();
        self
    }
    pub fn descriptor_binding_sampled_image_update_after_bind(
        mut self,
        descriptor_binding_sampled_image_update_after_bind: bool,
    ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
        self.inner
            .descriptor_binding_sampled_image_update_after_bind =
            descriptor_binding_sampled_image_update_after_bind.into();
        self
    }
    pub fn descriptor_binding_storage_image_update_after_bind(
        mut self,
        descriptor_binding_storage_image_update_after_bind: bool,
    ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
        self.inner
            .descriptor_binding_storage_image_update_after_bind =
            descriptor_binding_storage_image_update_after_bind.into();
        self
    }
    pub fn descriptor_binding_storage_buffer_update_after_bind(
        mut self,
        descriptor_binding_storage_buffer_update_after_bind: bool,
    ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
        self.inner
            .descriptor_binding_storage_buffer_update_after_bind =
            descriptor_binding_storage_buffer_update_after_bind.into();
        self
    }
    pub fn descriptor_binding_uniform_texel_buffer_update_after_bind(
        mut self,
        descriptor_binding_uniform_texel_buffer_update_after_bind: bool,
    ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
        self.inner
            .descriptor_binding_uniform_texel_buffer_update_after_bind =
            descriptor_binding_uniform_texel_buffer_update_after_bind.into();
        self
    }
    pub fn descriptor_binding_storage_texel_buffer_update_after_bind(
        mut self,
        descriptor_binding_storage_texel_buffer_update_after_bind: bool,
    ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
        self.inner
            .descriptor_binding_storage_texel_buffer_update_after_bind =
            descriptor_binding_storage_texel_buffer_update_after_bind.into();
        self
    }
    pub fn descriptor_binding_update_unused_while_pending(
        mut self,
        descriptor_binding_update_unused_while_pending: bool,
    ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
        self.inner.descriptor_binding_update_unused_while_pending =
            descriptor_binding_update_unused_while_pending.into();
        self
    }
    pub fn descriptor_binding_partially_bound(
        mut self,
        descriptor_binding_partially_bound: bool,
    ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
        self.inner.descriptor_binding_partially_bound = descriptor_binding_partially_bound.into();
        self
    }
    pub fn descriptor_binding_variable_descriptor_count(
        mut self,
        descriptor_binding_variable_descriptor_count: bool,
    ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
        self.inner.descriptor_binding_variable_descriptor_count =
            descriptor_binding_variable_descriptor_count.into();
        self
    }
    pub fn runtime_descriptor_array(
        mut self,
        runtime_descriptor_array: bool,
    ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
        self.inner.runtime_descriptor_array = runtime_descriptor_array.into();
        self
    }
    pub fn sampler_filter_minmax(
        mut self,
        sampler_filter_minmax: bool,
    ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
        self.inner.sampler_filter_minmax = sampler_filter_minmax.into();
        self
    }
    pub fn scalar_block_layout(
        mut self,
        scalar_block_layout: bool,
    ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
        self.inner.scalar_block_layout = scalar_block_layout.into();
        self
    }
    pub fn imageless_framebuffer(
        mut self,
        imageless_framebuffer: bool,
    ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
        self.inner.imageless_framebuffer = imageless_framebuffer.into();
        self
    }
    pub fn uniform_buffer_standard_layout(
        mut self,
        uniform_buffer_standard_layout: bool,
    ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
        self.inner.uniform_buffer_standard_layout = uniform_buffer_standard_layout.into();
        self
    }
    pub fn shader_subgroup_extended_types(
        mut self,
        shader_subgroup_extended_types: bool,
    ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
        self.inner.shader_subgroup_extended_types = shader_subgroup_extended_types.into();
        self
    }
    pub fn separate_depth_stencil_layouts(
        mut self,
        separate_depth_stencil_layouts: bool,
    ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
        self.inner.separate_depth_stencil_layouts = separate_depth_stencil_layouts.into();
        self
    }
    pub fn host_query_reset(
        mut self,
        host_query_reset: bool,
    ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
        self.inner.host_query_reset = host_query_reset.into();
        self
    }
    pub fn timeline_semaphore(
        mut self,
        timeline_semaphore: bool,
    ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
        self.inner.timeline_semaphore = timeline_semaphore.into();
        self
    }
    pub fn buffer_device_address(
        mut self,
        buffer_device_address: bool,
    ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
        self.inner.buffer_device_address = buffer_device_address.into();
        self
    }
    pub fn buffer_device_address_capture_replay(
        mut self,
        buffer_device_address_capture_replay: bool,
    ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
        self.inner.buffer_device_address_capture_replay =
            buffer_device_address_capture_replay.into();
        self
    }
    pub fn buffer_device_address_multi_device(
        mut self,
        buffer_device_address_multi_device: bool,
    ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
        self.inner.buffer_device_address_multi_device = buffer_device_address_multi_device.into();
        self
    }
    pub fn vulkan_memory_model(
        mut self,
        vulkan_memory_model: bool,
    ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
        self.inner.vulkan_memory_model = vulkan_memory_model.into();
        self
    }
    pub fn vulkan_memory_model_device_scope(
        mut self,
        vulkan_memory_model_device_scope: bool,
    ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
        self.inner.vulkan_memory_model_device_scope = vulkan_memory_model_device_scope.into();
        self
    }
    pub fn vulkan_memory_model_availability_visibility_chains(
        mut self,
        vulkan_memory_model_availability_visibility_chains: bool,
    ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
        self.inner
            .vulkan_memory_model_availability_visibility_chains =
            vulkan_memory_model_availability_visibility_chains.into();
        self
    }
    pub fn shader_output_viewport_index(
        mut self,
        shader_output_viewport_index: bool,
    ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
        self.inner.shader_output_viewport_index = shader_output_viewport_index.into();
        self
    }
    pub fn shader_output_layer(
        mut self,
        shader_output_layer: bool,
    ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
        self.inner.shader_output_layer = shader_output_layer.into();
        self
    }
    pub fn subgroup_broadcast_dynamic_id(
        mut self,
        subgroup_broadcast_dynamic_id: bool,
    ) -> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
        self.inner.subgroup_broadcast_dynamic_id = subgroup_broadcast_dynamic_id.into();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDeviceVulkan12Features {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan12Properties.html>"]
pub struct PhysicalDeviceVulkan12Properties {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub driver_id: DriverId,
    pub driver_name: [c_char; MAX_DRIVER_NAME_SIZE],
    pub driver_info: [c_char; MAX_DRIVER_INFO_SIZE],
    pub conformance_version: ConformanceVersion,
    pub denorm_behavior_independence: ShaderFloatControlsIndependence,
    pub rounding_mode_independence: ShaderFloatControlsIndependence,
    pub shader_signed_zero_inf_nan_preserve_float16: Bool32,
    pub shader_signed_zero_inf_nan_preserve_float32: Bool32,
    pub shader_signed_zero_inf_nan_preserve_float64: Bool32,
    pub shader_denorm_preserve_float16: Bool32,
    pub shader_denorm_preserve_float32: Bool32,
    pub shader_denorm_preserve_float64: Bool32,
    pub shader_denorm_flush_to_zero_float16: Bool32,
    pub shader_denorm_flush_to_zero_float32: Bool32,
    pub shader_denorm_flush_to_zero_float64: Bool32,
    pub shader_rounding_mode_rte_float16: Bool32,
    pub shader_rounding_mode_rte_float32: Bool32,
    pub shader_rounding_mode_rte_float64: Bool32,
    pub shader_rounding_mode_rtz_float16: Bool32,
    pub shader_rounding_mode_rtz_float32: Bool32,
    pub shader_rounding_mode_rtz_float64: Bool32,
    pub max_update_after_bind_descriptors_in_all_pools: u32,
    pub shader_uniform_buffer_array_non_uniform_indexing_native: Bool32,
    pub shader_sampled_image_array_non_uniform_indexing_native: Bool32,
    pub shader_storage_buffer_array_non_uniform_indexing_native: Bool32,
    pub shader_storage_image_array_non_uniform_indexing_native: Bool32,
    pub shader_input_attachment_array_non_uniform_indexing_native: Bool32,
    pub robust_buffer_access_update_after_bind: Bool32,
    pub quad_divergent_implicit_lod: Bool32,
    pub max_per_stage_descriptor_update_after_bind_samplers: u32,
    pub max_per_stage_descriptor_update_after_bind_uniform_buffers: u32,
    pub max_per_stage_descriptor_update_after_bind_storage_buffers: u32,
    pub max_per_stage_descriptor_update_after_bind_sampled_images: u32,
    pub max_per_stage_descriptor_update_after_bind_storage_images: u32,
    pub max_per_stage_descriptor_update_after_bind_input_attachments: u32,
    pub max_per_stage_update_after_bind_resources: u32,
    pub max_descriptor_set_update_after_bind_samplers: u32,
    pub max_descriptor_set_update_after_bind_uniform_buffers: u32,
    pub max_descriptor_set_update_after_bind_uniform_buffers_dynamic: u32,
    pub max_descriptor_set_update_after_bind_storage_buffers: u32,
    pub max_descriptor_set_update_after_bind_storage_buffers_dynamic: u32,
    pub max_descriptor_set_update_after_bind_sampled_images: u32,
    pub max_descriptor_set_update_after_bind_storage_images: u32,
    pub max_descriptor_set_update_after_bind_input_attachments: u32,
    pub supported_depth_resolve_modes: ResolveModeFlags,
    pub supported_stencil_resolve_modes: ResolveModeFlags,
    pub independent_resolve_none: Bool32,
    pub independent_resolve: Bool32,
    pub filter_minmax_single_component_formats: Bool32,
    pub filter_minmax_image_component_mapping: Bool32,
    pub max_timeline_semaphore_value_difference: u64,
    pub framebuffer_integer_color_sample_counts: SampleCountFlags,
}
impl fmt::Debug for PhysicalDeviceVulkan12Properties {
    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
        fmt.debug_struct("PhysicalDeviceVulkan12Properties")
            .field("s_type", &self.s_type)
            .field("p_next", &self.p_next)
            .field("driver_id", &self.driver_id)
            .field("driver_name", &unsafe {
                ::std::ffi::CStr::from_ptr(self.driver_name.as_ptr() as *const c_char)
            })
            .field("driver_info", &unsafe {
                ::std::ffi::CStr::from_ptr(self.driver_info.as_ptr() as *const c_char)
            })
            .field("conformance_version", &self.conformance_version)
            .field(
                "denorm_behavior_independence",
                &self.denorm_behavior_independence,
            )
            .field(
                "rounding_mode_independence",
                &self.rounding_mode_independence,
            )
            .field(
                "shader_signed_zero_inf_nan_preserve_float16",
                &self.shader_signed_zero_inf_nan_preserve_float16,
            )
            .field(
                "shader_signed_zero_inf_nan_preserve_float32",
                &self.shader_signed_zero_inf_nan_preserve_float32,
            )
            .field(
                "shader_signed_zero_inf_nan_preserve_float64",
                &self.shader_signed_zero_inf_nan_preserve_float64,
            )
            .field(
                "shader_denorm_preserve_float16",
                &self.shader_denorm_preserve_float16,
            )
            .field(
                "shader_denorm_preserve_float32",
                &self.shader_denorm_preserve_float32,
            )
            .field(
                "shader_denorm_preserve_float64",
                &self.shader_denorm_preserve_float64,
            )
            .field(
                "shader_denorm_flush_to_zero_float16",
                &self.shader_denorm_flush_to_zero_float16,
            )
            .field(
                "shader_denorm_flush_to_zero_float32",
                &self.shader_denorm_flush_to_zero_float32,
            )
            .field(
                "shader_denorm_flush_to_zero_float64",
                &self.shader_denorm_flush_to_zero_float64,
            )
            .field(
                "shader_rounding_mode_rte_float16",
                &self.shader_rounding_mode_rte_float16,
            )
            .field(
                "shader_rounding_mode_rte_float32",
                &self.shader_rounding_mode_rte_float32,
            )
            .field(
                "shader_rounding_mode_rte_float64",
                &self.shader_rounding_mode_rte_float64,
            )
            .field(
                "shader_rounding_mode_rtz_float16",
                &self.shader_rounding_mode_rtz_float16,
            )
            .field(
                "shader_rounding_mode_rtz_float32",
                &self.shader_rounding_mode_rtz_float32,
            )
            .field(
                "shader_rounding_mode_rtz_float64",
                &self.shader_rounding_mode_rtz_float64,
            )
            .field(
                "max_update_after_bind_descriptors_in_all_pools",
                &self.max_update_after_bind_descriptors_in_all_pools,
            )
            .field(
                "shader_uniform_buffer_array_non_uniform_indexing_native",
                &self.shader_uniform_buffer_array_non_uniform_indexing_native,
            )
            .field(
                "shader_sampled_image_array_non_uniform_indexing_native",
                &self.shader_sampled_image_array_non_uniform_indexing_native,
            )
            .field(
                "shader_storage_buffer_array_non_uniform_indexing_native",
                &self.shader_storage_buffer_array_non_uniform_indexing_native,
            )
            .field(
                "shader_storage_image_array_non_uniform_indexing_native",
                &self.shader_storage_image_array_non_uniform_indexing_native,
            )
            .field(
                "shader_input_attachment_array_non_uniform_indexing_native",
                &self.shader_input_attachment_array_non_uniform_indexing_native,
            )
            .field(
                "robust_buffer_access_update_after_bind",
                &self.robust_buffer_access_update_after_bind,
            )
            .field(
                "quad_divergent_implicit_lod",
                &self.quad_divergent_implicit_lod,
            )
            .field(
                "max_per_stage_descriptor_update_after_bind_samplers",
                &self.max_per_stage_descriptor_update_after_bind_samplers,
            )
            .field(
                "max_per_stage_descriptor_update_after_bind_uniform_buffers",
                &self.max_per_stage_descriptor_update_after_bind_uniform_buffers,
            )
            .field(
                "max_per_stage_descriptor_update_after_bind_storage_buffers",
                &self.max_per_stage_descriptor_update_after_bind_storage_buffers,
            )
            .field(
                "max_per_stage_descriptor_update_after_bind_sampled_images",
                &self.max_per_stage_descriptor_update_after_bind_sampled_images,
            )
            .field(
                "max_per_stage_descriptor_update_after_bind_storage_images",
                &self.max_per_stage_descriptor_update_after_bind_storage_images,
            )
            .field(
                "max_per_stage_descriptor_update_after_bind_input_attachments",
                &self.max_per_stage_descriptor_update_after_bind_input_attachments,
            )
            .field(
                "max_per_stage_update_after_bind_resources",
                &self.max_per_stage_update_after_bind_resources,
            )
            .field(
                "max_descriptor_set_update_after_bind_samplers",
                &self.max_descriptor_set_update_after_bind_samplers,
            )
            .field(
                "max_descriptor_set_update_after_bind_uniform_buffers",
                &self.max_descriptor_set_update_after_bind_uniform_buffers,
            )
            .field(
                "max_descriptor_set_update_after_bind_uniform_buffers_dynamic",
                &self.max_descriptor_set_update_after_bind_uniform_buffers_dynamic,
            )
            .field(
                "max_descriptor_set_update_after_bind_storage_buffers",
                &self.max_descriptor_set_update_after_bind_storage_buffers,
            )
            .field(
                "max_descriptor_set_update_after_bind_storage_buffers_dynamic",
                &self.max_descriptor_set_update_after_bind_storage_buffers_dynamic,
            )
            .field(
                "max_descriptor_set_update_after_bind_sampled_images",
                &self.max_descriptor_set_update_after_bind_sampled_images,
            )
            .field(
                "max_descriptor_set_update_after_bind_storage_images",
                &self.max_descriptor_set_update_after_bind_storage_images,
            )
            .field(
                "max_descriptor_set_update_after_bind_input_attachments",
                &self.max_descriptor_set_update_after_bind_input_attachments,
            )
            .field(
                "supported_depth_resolve_modes",
                &self.supported_depth_resolve_modes,
            )
            .field(
                "supported_stencil_resolve_modes",
                &self.supported_stencil_resolve_modes,
            )
            .field("independent_resolve_none", &self.independent_resolve_none)
            .field("independent_resolve", &self.independent_resolve)
            .field(
                "filter_minmax_single_component_formats",
                &self.filter_minmax_single_component_formats,
            )
            .field(
                "filter_minmax_image_component_mapping",
                &self.filter_minmax_image_component_mapping,
            )
            .field(
                "max_timeline_semaphore_value_difference",
                &self.max_timeline_semaphore_value_difference,
            )
            .field(
                "framebuffer_integer_color_sample_counts",
                &self.framebuffer_integer_color_sample_counts,
            )
            .finish()
    }
}
impl ::std::default::Default for PhysicalDeviceVulkan12Properties {
    fn default() -> PhysicalDeviceVulkan12Properties {
        PhysicalDeviceVulkan12Properties {
            s_type: StructureType::PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES,
            p_next: ::std::ptr::null_mut(),
            driver_id: DriverId::default(),
            driver_name: unsafe { ::std::mem::zeroed() },
            driver_info: unsafe { ::std::mem::zeroed() },
            conformance_version: ConformanceVersion::default(),
            denorm_behavior_independence: ShaderFloatControlsIndependence::default(),
            rounding_mode_independence: ShaderFloatControlsIndependence::default(),
            shader_signed_zero_inf_nan_preserve_float16: Bool32::default(),
            shader_signed_zero_inf_nan_preserve_float32: Bool32::default(),
            shader_signed_zero_inf_nan_preserve_float64: Bool32::default(),
            shader_denorm_preserve_float16: Bool32::default(),
            shader_denorm_preserve_float32: Bool32::default(),
            shader_denorm_preserve_float64: Bool32::default(),
            shader_denorm_flush_to_zero_float16: Bool32::default(),
            shader_denorm_flush_to_zero_float32: Bool32::default(),
            shader_denorm_flush_to_zero_float64: Bool32::default(),
            shader_rounding_mode_rte_float16: Bool32::default(),
            shader_rounding_mode_rte_float32: Bool32::default(),
            shader_rounding_mode_rte_float64: Bool32::default(),
            shader_rounding_mode_rtz_float16: Bool32::default(),
            shader_rounding_mode_rtz_float32: Bool32::default(),
            shader_rounding_mode_rtz_float64: Bool32::default(),
            max_update_after_bind_descriptors_in_all_pools: u32::default(),
            shader_uniform_buffer_array_non_uniform_indexing_native: Bool32::default(),
            shader_sampled_image_array_non_uniform_indexing_native: Bool32::default(),
            shader_storage_buffer_array_non_uniform_indexing_native: Bool32::default(),
            shader_storage_image_array_non_uniform_indexing_native: Bool32::default(),
            shader_input_attachment_array_non_uniform_indexing_native: Bool32::default(),
            robust_buffer_access_update_after_bind: Bool32::default(),
            quad_divergent_implicit_lod: Bool32::default(),
            max_per_stage_descriptor_update_after_bind_samplers: u32::default(),
            max_per_stage_descriptor_update_after_bind_uniform_buffers: u32::default(),
            max_per_stage_descriptor_update_after_bind_storage_buffers: u32::default(),
            max_per_stage_descriptor_update_after_bind_sampled_images: u32::default(),
            max_per_stage_descriptor_update_after_bind_storage_images: u32::default(),
            max_per_stage_descriptor_update_after_bind_input_attachments: u32::default(),
            max_per_stage_update_after_bind_resources: u32::default(),
            max_descriptor_set_update_after_bind_samplers: u32::default(),
            max_descriptor_set_update_after_bind_uniform_buffers: u32::default(),
            max_descriptor_set_update_after_bind_uniform_buffers_dynamic: u32::default(),
            max_descriptor_set_update_after_bind_storage_buffers: u32::default(),
            max_descriptor_set_update_after_bind_storage_buffers_dynamic: u32::default(),
            max_descriptor_set_update_after_bind_sampled_images: u32::default(),
            max_descriptor_set_update_after_bind_storage_images: u32::default(),
            max_descriptor_set_update_after_bind_input_attachments: u32::default(),
            supported_depth_resolve_modes: ResolveModeFlags::default(),
            supported_stencil_resolve_modes: ResolveModeFlags::default(),
            independent_resolve_none: Bool32::default(),
            independent_resolve: Bool32::default(),
            filter_minmax_single_component_formats: Bool32::default(),
            filter_minmax_image_component_mapping: Bool32::default(),
            max_timeline_semaphore_value_difference: u64::default(),
            framebuffer_integer_color_sample_counts: SampleCountFlags::default(),
        }
    }
}
impl PhysicalDeviceVulkan12Properties {
    pub fn builder<'a>() -> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
        PhysicalDeviceVulkan12PropertiesBuilder {
            inner: PhysicalDeviceVulkan12Properties::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDeviceVulkan12PropertiesBuilder<'a> {
    inner: PhysicalDeviceVulkan12Properties,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceVulkan12PropertiesBuilder<'_> {}
unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceVulkan12Properties {}
impl<'a> ::std::ops::Deref for PhysicalDeviceVulkan12PropertiesBuilder<'a> {
    type Target = PhysicalDeviceVulkan12Properties;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PhysicalDeviceVulkan12PropertiesBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
    pub fn driver_id(mut self, driver_id: DriverId) -> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
        self.inner.driver_id = driver_id;
        self
    }
    pub fn driver_name(
        mut self,
        driver_name: [c_char; MAX_DRIVER_NAME_SIZE],
    ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
        self.inner.driver_name = driver_name;
        self
    }
    pub fn driver_info(
        mut self,
        driver_info: [c_char; MAX_DRIVER_INFO_SIZE],
    ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
        self.inner.driver_info = driver_info;
        self
    }
    pub fn conformance_version(
        mut self,
        conformance_version: ConformanceVersion,
    ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
        self.inner.conformance_version = conformance_version;
        self
    }
    pub fn denorm_behavior_independence(
        mut self,
        denorm_behavior_independence: ShaderFloatControlsIndependence,
    ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
        self.inner.denorm_behavior_independence = denorm_behavior_independence;
        self
    }
    pub fn rounding_mode_independence(
        mut self,
        rounding_mode_independence: ShaderFloatControlsIndependence,
    ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
        self.inner.rounding_mode_independence = rounding_mode_independence;
        self
    }
    pub fn shader_signed_zero_inf_nan_preserve_float16(
        mut self,
        shader_signed_zero_inf_nan_preserve_float16: bool,
    ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
        self.inner.shader_signed_zero_inf_nan_preserve_float16 =
            shader_signed_zero_inf_nan_preserve_float16.into();
        self
    }
    pub fn shader_signed_zero_inf_nan_preserve_float32(
        mut self,
        shader_signed_zero_inf_nan_preserve_float32: bool,
    ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
        self.inner.shader_signed_zero_inf_nan_preserve_float32 =
            shader_signed_zero_inf_nan_preserve_float32.into();
        self
    }
    pub fn shader_signed_zero_inf_nan_preserve_float64(
        mut self,
        shader_signed_zero_inf_nan_preserve_float64: bool,
    ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
        self.inner.shader_signed_zero_inf_nan_preserve_float64 =
            shader_signed_zero_inf_nan_preserve_float64.into();
        self
    }
    pub fn shader_denorm_preserve_float16(
        mut self,
        shader_denorm_preserve_float16: bool,
    ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
        self.inner.shader_denorm_preserve_float16 = shader_denorm_preserve_float16.into();
        self
    }
    pub fn shader_denorm_preserve_float32(
        mut self,
        shader_denorm_preserve_float32: bool,
    ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
        self.inner.shader_denorm_preserve_float32 = shader_denorm_preserve_float32.into();
        self
    }
    pub fn shader_denorm_preserve_float64(
        mut self,
        shader_denorm_preserve_float64: bool,
    ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
        self.inner.shader_denorm_preserve_float64 = shader_denorm_preserve_float64.into();
        self
    }
    pub fn shader_denorm_flush_to_zero_float16(
        mut self,
        shader_denorm_flush_to_zero_float16: bool,
    ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
        self.inner.shader_denorm_flush_to_zero_float16 = shader_denorm_flush_to_zero_float16.into();
        self
    }
    pub fn shader_denorm_flush_to_zero_float32(
        mut self,
        shader_denorm_flush_to_zero_float32: bool,
    ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
        self.inner.shader_denorm_flush_to_zero_float32 = shader_denorm_flush_to_zero_float32.into();
        self
    }
    pub fn shader_denorm_flush_to_zero_float64(
        mut self,
        shader_denorm_flush_to_zero_float64: bool,
    ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
        self.inner.shader_denorm_flush_to_zero_float64 = shader_denorm_flush_to_zero_float64.into();
        self
    }
    pub fn shader_rounding_mode_rte_float16(
        mut self,
        shader_rounding_mode_rte_float16: bool,
    ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
        self.inner.shader_rounding_mode_rte_float16 = shader_rounding_mode_rte_float16.into();
        self
    }
    pub fn shader_rounding_mode_rte_float32(
        mut self,
        shader_rounding_mode_rte_float32: bool,
    ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
        self.inner.shader_rounding_mode_rte_float32 = shader_rounding_mode_rte_float32.into();
        self
    }
    pub fn shader_rounding_mode_rte_float64(
        mut self,
        shader_rounding_mode_rte_float64: bool,
    ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
        self.inner.shader_rounding_mode_rte_float64 = shader_rounding_mode_rte_float64.into();
        self
    }
    pub fn shader_rounding_mode_rtz_float16(
        mut self,
        shader_rounding_mode_rtz_float16: bool,
    ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
        self.inner.shader_rounding_mode_rtz_float16 = shader_rounding_mode_rtz_float16.into();
        self
    }
    pub fn shader_rounding_mode_rtz_float32(
        mut self,
        shader_rounding_mode_rtz_float32: bool,
    ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
        self.inner.shader_rounding_mode_rtz_float32 = shader_rounding_mode_rtz_float32.into();
        self
    }
    pub fn shader_rounding_mode_rtz_float64(
        mut self,
        shader_rounding_mode_rtz_float64: bool,
    ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
        self.inner.shader_rounding_mode_rtz_float64 = shader_rounding_mode_rtz_float64.into();
        self
    }
    pub fn max_update_after_bind_descriptors_in_all_pools(
        mut self,
        max_update_after_bind_descriptors_in_all_pools: u32,
    ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
        self.inner.max_update_after_bind_descriptors_in_all_pools =
            max_update_after_bind_descriptors_in_all_pools;
        self
    }
    pub fn shader_uniform_buffer_array_non_uniform_indexing_native(
        mut self,
        shader_uniform_buffer_array_non_uniform_indexing_native: bool,
    ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
        self.inner
            .shader_uniform_buffer_array_non_uniform_indexing_native =
            shader_uniform_buffer_array_non_uniform_indexing_native.into();
        self
    }
    pub fn shader_sampled_image_array_non_uniform_indexing_native(
        mut self,
        shader_sampled_image_array_non_uniform_indexing_native: bool,
    ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
        self.inner
            .shader_sampled_image_array_non_uniform_indexing_native =
            shader_sampled_image_array_non_uniform_indexing_native.into();
        self
    }
    pub fn shader_storage_buffer_array_non_uniform_indexing_native(
        mut self,
        shader_storage_buffer_array_non_uniform_indexing_native: bool,
    ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
        self.inner
            .shader_storage_buffer_array_non_uniform_indexing_native =
            shader_storage_buffer_array_non_uniform_indexing_native.into();
        self
    }
    pub fn shader_storage_image_array_non_uniform_indexing_native(
        mut self,
        shader_storage_image_array_non_uniform_indexing_native: bool,
    ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
        self.inner
            .shader_storage_image_array_non_uniform_indexing_native =
            shader_storage_image_array_non_uniform_indexing_native.into();
        self
    }
    pub fn shader_input_attachment_array_non_uniform_indexing_native(
        mut self,
        shader_input_attachment_array_non_uniform_indexing_native: bool,
    ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
        self.inner
            .shader_input_attachment_array_non_uniform_indexing_native =
            shader_input_attachment_array_non_uniform_indexing_native.into();
        self
    }
    pub fn robust_buffer_access_update_after_bind(
        mut self,
        robust_buffer_access_update_after_bind: bool,
    ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
        self.inner.robust_buffer_access_update_after_bind =
            robust_buffer_access_update_after_bind.into();
        self
    }
    pub fn quad_divergent_implicit_lod(
        mut self,
        quad_divergent_implicit_lod: bool,
    ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
        self.inner.quad_divergent_implicit_lod = quad_divergent_implicit_lod.into();
        self
    }
    pub fn max_per_stage_descriptor_update_after_bind_samplers(
        mut self,
        max_per_stage_descriptor_update_after_bind_samplers: u32,
    ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
        self.inner
            .max_per_stage_descriptor_update_after_bind_samplers =
            max_per_stage_descriptor_update_after_bind_samplers;
        self
    }
    pub fn max_per_stage_descriptor_update_after_bind_uniform_buffers(
        mut self,
        max_per_stage_descriptor_update_after_bind_uniform_buffers: u32,
    ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
        self.inner
            .max_per_stage_descriptor_update_after_bind_uniform_buffers =
            max_per_stage_descriptor_update_after_bind_uniform_buffers;
        self
    }
    pub fn max_per_stage_descriptor_update_after_bind_storage_buffers(
        mut self,
        max_per_stage_descriptor_update_after_bind_storage_buffers: u32,
    ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
        self.inner
            .max_per_stage_descriptor_update_after_bind_storage_buffers =
            max_per_stage_descriptor_update_after_bind_storage_buffers;
        self
    }
    pub fn max_per_stage_descriptor_update_after_bind_sampled_images(
        mut self,
        max_per_stage_descriptor_update_after_bind_sampled_images: u32,
    ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
        self.inner
            .max_per_stage_descriptor_update_after_bind_sampled_images =
            max_per_stage_descriptor_update_after_bind_sampled_images;
        self
    }
    pub fn max_per_stage_descriptor_update_after_bind_storage_images(
        mut self,
        max_per_stage_descriptor_update_after_bind_storage_images: u32,
    ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
        self.inner
            .max_per_stage_descriptor_update_after_bind_storage_images =
            max_per_stage_descriptor_update_after_bind_storage_images;
        self
    }
    pub fn max_per_stage_descriptor_update_after_bind_input_attachments(
        mut self,
        max_per_stage_descriptor_update_after_bind_input_attachments: u32,
    ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
        self.inner
            .max_per_stage_descriptor_update_after_bind_input_attachments =
            max_per_stage_descriptor_update_after_bind_input_attachments;
        self
    }
    pub fn max_per_stage_update_after_bind_resources(
        mut self,
        max_per_stage_update_after_bind_resources: u32,
    ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
        self.inner.max_per_stage_update_after_bind_resources =
            max_per_stage_update_after_bind_resources;
        self
    }
    pub fn max_descriptor_set_update_after_bind_samplers(
        mut self,
        max_descriptor_set_update_after_bind_samplers: u32,
    ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
        self.inner.max_descriptor_set_update_after_bind_samplers =
            max_descriptor_set_update_after_bind_samplers;
        self
    }
    pub fn max_descriptor_set_update_after_bind_uniform_buffers(
        mut self,
        max_descriptor_set_update_after_bind_uniform_buffers: u32,
    ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
        self.inner
            .max_descriptor_set_update_after_bind_uniform_buffers =
            max_descriptor_set_update_after_bind_uniform_buffers;
        self
    }
    pub fn max_descriptor_set_update_after_bind_uniform_buffers_dynamic(
        mut self,
        max_descriptor_set_update_after_bind_uniform_buffers_dynamic: u32,
    ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
        self.inner
            .max_descriptor_set_update_after_bind_uniform_buffers_dynamic =
            max_descriptor_set_update_after_bind_uniform_buffers_dynamic;
        self
    }
    pub fn max_descriptor_set_update_after_bind_storage_buffers(
        mut self,
        max_descriptor_set_update_after_bind_storage_buffers: u32,
    ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
        self.inner
            .max_descriptor_set_update_after_bind_storage_buffers =
            max_descriptor_set_update_after_bind_storage_buffers;
        self
    }
    pub fn max_descriptor_set_update_after_bind_storage_buffers_dynamic(
        mut self,
        max_descriptor_set_update_after_bind_storage_buffers_dynamic: u32,
    ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
        self.inner
            .max_descriptor_set_update_after_bind_storage_buffers_dynamic =
            max_descriptor_set_update_after_bind_storage_buffers_dynamic;
        self
    }
    pub fn max_descriptor_set_update_after_bind_sampled_images(
        mut self,
        max_descriptor_set_update_after_bind_sampled_images: u32,
    ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
        self.inner
            .max_descriptor_set_update_after_bind_sampled_images =
            max_descriptor_set_update_after_bind_sampled_images;
        self
    }
    pub fn max_descriptor_set_update_after_bind_storage_images(
        mut self,
        max_descriptor_set_update_after_bind_storage_images: u32,
    ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
        self.inner
            .max_descriptor_set_update_after_bind_storage_images =
            max_descriptor_set_update_after_bind_storage_images;
        self
    }
    pub fn max_descriptor_set_update_after_bind_input_attachments(
        mut self,
        max_descriptor_set_update_after_bind_input_attachments: u32,
    ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
        self.inner
            .max_descriptor_set_update_after_bind_input_attachments =
            max_descriptor_set_update_after_bind_input_attachments;
        self
    }
    pub fn supported_depth_resolve_modes(
        mut self,
        supported_depth_resolve_modes: ResolveModeFlags,
    ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
        self.inner.supported_depth_resolve_modes = supported_depth_resolve_modes;
        self
    }
    pub fn supported_stencil_resolve_modes(
        mut self,
        supported_stencil_resolve_modes: ResolveModeFlags,
    ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
        self.inner.supported_stencil_resolve_modes = supported_stencil_resolve_modes;
        self
    }
    pub fn independent_resolve_none(
        mut self,
        independent_resolve_none: bool,
    ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
        self.inner.independent_resolve_none = independent_resolve_none.into();
        self
    }
    pub fn independent_resolve(
        mut self,
        independent_resolve: bool,
    ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
        self.inner.independent_resolve = independent_resolve.into();
        self
    }
    pub fn filter_minmax_single_component_formats(
        mut self,
        filter_minmax_single_component_formats: bool,
    ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
        self.inner.filter_minmax_single_component_formats =
            filter_minmax_single_component_formats.into();
        self
    }
    pub fn filter_minmax_image_component_mapping(
        mut self,
        filter_minmax_image_component_mapping: bool,
    ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
        self.inner.filter_minmax_image_component_mapping =
            filter_minmax_image_component_mapping.into();
        self
    }
    pub fn max_timeline_semaphore_value_difference(
        mut self,
        max_timeline_semaphore_value_difference: u64,
    ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
        self.inner.max_timeline_semaphore_value_difference =
            max_timeline_semaphore_value_difference;
        self
    }
    pub fn framebuffer_integer_color_sample_counts(
        mut self,
        framebuffer_integer_color_sample_counts: SampleCountFlags,
    ) -> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
        self.inner.framebuffer_integer_color_sample_counts =
            framebuffer_integer_color_sample_counts;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDeviceVulkan12Properties {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineCompilerControlCreateInfoAMD.html>"]
pub struct PipelineCompilerControlCreateInfoAMD {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub compiler_control_flags: PipelineCompilerControlFlagsAMD,
}
impl ::std::default::Default for PipelineCompilerControlCreateInfoAMD {
    fn default() -> PipelineCompilerControlCreateInfoAMD {
        PipelineCompilerControlCreateInfoAMD {
            s_type: StructureType::PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD,
            p_next: ::std::ptr::null(),
            compiler_control_flags: PipelineCompilerControlFlagsAMD::default(),
        }
    }
}
impl PipelineCompilerControlCreateInfoAMD {
    pub fn builder<'a>() -> PipelineCompilerControlCreateInfoAMDBuilder<'a> {
        PipelineCompilerControlCreateInfoAMDBuilder {
            inner: PipelineCompilerControlCreateInfoAMD::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PipelineCompilerControlCreateInfoAMDBuilder<'a> {
    inner: PipelineCompilerControlCreateInfoAMD,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsGraphicsPipelineCreateInfo for PipelineCompilerControlCreateInfoAMDBuilder<'_> {}
unsafe impl ExtendsGraphicsPipelineCreateInfo for PipelineCompilerControlCreateInfoAMD {}
unsafe impl ExtendsComputePipelineCreateInfo for PipelineCompilerControlCreateInfoAMDBuilder<'_> {}
unsafe impl ExtendsComputePipelineCreateInfo for PipelineCompilerControlCreateInfoAMD {}
impl<'a> ::std::ops::Deref for PipelineCompilerControlCreateInfoAMDBuilder<'a> {
    type Target = PipelineCompilerControlCreateInfoAMD;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PipelineCompilerControlCreateInfoAMDBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PipelineCompilerControlCreateInfoAMDBuilder<'a> {
    pub fn compiler_control_flags(
        mut self,
        compiler_control_flags: PipelineCompilerControlFlagsAMD,
    ) -> PipelineCompilerControlCreateInfoAMDBuilder<'a> {
        self.inner.compiler_control_flags = compiler_control_flags;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PipelineCompilerControlCreateInfoAMD {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceCoherentMemoryFeaturesAMD.html>"]
pub struct PhysicalDeviceCoherentMemoryFeaturesAMD {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub device_coherent_memory: Bool32,
}
impl ::std::default::Default for PhysicalDeviceCoherentMemoryFeaturesAMD {
    fn default() -> PhysicalDeviceCoherentMemoryFeaturesAMD {
        PhysicalDeviceCoherentMemoryFeaturesAMD {
            s_type: StructureType::PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD,
            p_next: ::std::ptr::null_mut(),
            device_coherent_memory: Bool32::default(),
        }
    }
}
impl PhysicalDeviceCoherentMemoryFeaturesAMD {
    pub fn builder<'a>() -> PhysicalDeviceCoherentMemoryFeaturesAMDBuilder<'a> {
        PhysicalDeviceCoherentMemoryFeaturesAMDBuilder {
            inner: PhysicalDeviceCoherentMemoryFeaturesAMD::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDeviceCoherentMemoryFeaturesAMDBuilder<'a> {
    inner: PhysicalDeviceCoherentMemoryFeaturesAMD,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceCoherentMemoryFeaturesAMDBuilder<'_> {}
unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceCoherentMemoryFeaturesAMD {}
impl<'a> ::std::ops::Deref for PhysicalDeviceCoherentMemoryFeaturesAMDBuilder<'a> {
    type Target = PhysicalDeviceCoherentMemoryFeaturesAMD;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PhysicalDeviceCoherentMemoryFeaturesAMDBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDeviceCoherentMemoryFeaturesAMDBuilder<'a> {
    pub fn device_coherent_memory(
        mut self,
        device_coherent_memory: bool,
    ) -> PhysicalDeviceCoherentMemoryFeaturesAMDBuilder<'a> {
        self.inner.device_coherent_memory = device_coherent_memory.into();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDeviceCoherentMemoryFeaturesAMD {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceToolPropertiesEXT.html>"]
pub struct PhysicalDeviceToolPropertiesEXT {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub name: [c_char; MAX_EXTENSION_NAME_SIZE],
    pub version: [c_char; MAX_EXTENSION_NAME_SIZE],
    pub purposes: ToolPurposeFlagsEXT,
    pub description: [c_char; MAX_DESCRIPTION_SIZE],
    pub layer: [c_char; MAX_EXTENSION_NAME_SIZE],
}
impl fmt::Debug for PhysicalDeviceToolPropertiesEXT {
    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
        fmt.debug_struct("PhysicalDeviceToolPropertiesEXT")
            .field("s_type", &self.s_type)
            .field("p_next", &self.p_next)
            .field("name", &unsafe {
                ::std::ffi::CStr::from_ptr(self.name.as_ptr() as *const c_char)
            })
            .field("version", &unsafe {
                ::std::ffi::CStr::from_ptr(self.version.as_ptr() as *const c_char)
            })
            .field("purposes", &self.purposes)
            .field("description", &unsafe {
                ::std::ffi::CStr::from_ptr(self.description.as_ptr() as *const c_char)
            })
            .field("layer", &unsafe {
                ::std::ffi::CStr::from_ptr(self.layer.as_ptr() as *const c_char)
            })
            .finish()
    }
}
impl ::std::default::Default for PhysicalDeviceToolPropertiesEXT {
    fn default() -> PhysicalDeviceToolPropertiesEXT {
        PhysicalDeviceToolPropertiesEXT {
            s_type: StructureType::PHYSICAL_DEVICE_TOOL_PROPERTIES_EXT,
            p_next: ::std::ptr::null_mut(),
            name: unsafe { ::std::mem::zeroed() },
            version: unsafe { ::std::mem::zeroed() },
            purposes: ToolPurposeFlagsEXT::default(),
            description: unsafe { ::std::mem::zeroed() },
            layer: unsafe { ::std::mem::zeroed() },
        }
    }
}
impl PhysicalDeviceToolPropertiesEXT {
    pub fn builder<'a>() -> PhysicalDeviceToolPropertiesEXTBuilder<'a> {
        PhysicalDeviceToolPropertiesEXTBuilder {
            inner: PhysicalDeviceToolPropertiesEXT::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDeviceToolPropertiesEXTBuilder<'a> {
    inner: PhysicalDeviceToolPropertiesEXT,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsPhysicalDeviceToolPropertiesEXT {}
impl<'a> ::std::ops::Deref for PhysicalDeviceToolPropertiesEXTBuilder<'a> {
    type Target = PhysicalDeviceToolPropertiesEXT;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PhysicalDeviceToolPropertiesEXTBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDeviceToolPropertiesEXTBuilder<'a> {
    pub fn name(
        mut self,
        name: [c_char; MAX_EXTENSION_NAME_SIZE],
    ) -> PhysicalDeviceToolPropertiesEXTBuilder<'a> {
        self.inner.name = name;
        self
    }
    pub fn version(
        mut self,
        version: [c_char; MAX_EXTENSION_NAME_SIZE],
    ) -> PhysicalDeviceToolPropertiesEXTBuilder<'a> {
        self.inner.version = version;
        self
    }
    pub fn purposes(
        mut self,
        purposes: ToolPurposeFlagsEXT,
    ) -> PhysicalDeviceToolPropertiesEXTBuilder<'a> {
        self.inner.purposes = purposes;
        self
    }
    pub fn description(
        mut self,
        description: [c_char; MAX_DESCRIPTION_SIZE],
    ) -> PhysicalDeviceToolPropertiesEXTBuilder<'a> {
        self.inner.description = description;
        self
    }
    pub fn layer(
        mut self,
        layer: [c_char; MAX_EXTENSION_NAME_SIZE],
    ) -> PhysicalDeviceToolPropertiesEXTBuilder<'a> {
        self.inner.layer = layer;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsPhysicalDeviceToolPropertiesEXT>(
        mut self,
        next: &'a mut T,
    ) -> PhysicalDeviceToolPropertiesEXTBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDeviceToolPropertiesEXT {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDeviceOrHostAddressKHR.html>"]
pub union DeviceOrHostAddressKHR {
    pub device_address: DeviceAddress,
    pub host_address: *mut c_void,
}
impl ::std::default::Default for DeviceOrHostAddressKHR {
    fn default() -> DeviceOrHostAddressKHR {
        unsafe { ::std::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDeviceOrHostAddressConstKHR.html>"]
pub union DeviceOrHostAddressConstKHR {
    pub device_address: DeviceAddress,
    pub host_address: *const c_void,
}
impl ::std::default::Default for DeviceOrHostAddressConstKHR {
    fn default() -> DeviceOrHostAddressConstKHR {
        unsafe { ::std::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAccelerationStructureGeometryTrianglesDataKHR.html>"]
pub struct AccelerationStructureGeometryTrianglesDataKHR {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub vertex_format: Format,
    pub vertex_data: DeviceOrHostAddressConstKHR,
    pub vertex_stride: DeviceSize,
    pub index_type: IndexType,
    pub index_data: DeviceOrHostAddressConstKHR,
    pub transform_data: DeviceOrHostAddressConstKHR,
}
impl fmt::Debug for AccelerationStructureGeometryTrianglesDataKHR {
    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
        fmt.debug_struct("AccelerationStructureGeometryTrianglesDataKHR")
            .field("s_type", &self.s_type)
            .field("p_next", &self.p_next)
            .field("vertex_format", &self.vertex_format)
            .field("vertex_data", &"union")
            .field("vertex_stride", &self.vertex_stride)
            .field("index_type", &self.index_type)
            .field("index_data", &"union")
            .field("transform_data", &"union")
            .finish()
    }
}
impl ::std::default::Default for AccelerationStructureGeometryTrianglesDataKHR {
    fn default() -> AccelerationStructureGeometryTrianglesDataKHR {
        AccelerationStructureGeometryTrianglesDataKHR {
            s_type: StructureType::ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR,
            p_next: ::std::ptr::null(),
            vertex_format: Format::default(),
            vertex_data: DeviceOrHostAddressConstKHR::default(),
            vertex_stride: DeviceSize::default(),
            index_type: IndexType::default(),
            index_data: DeviceOrHostAddressConstKHR::default(),
            transform_data: DeviceOrHostAddressConstKHR::default(),
        }
    }
}
impl AccelerationStructureGeometryTrianglesDataKHR {
    pub fn builder<'a>() -> AccelerationStructureGeometryTrianglesDataKHRBuilder<'a> {
        AccelerationStructureGeometryTrianglesDataKHRBuilder {
            inner: AccelerationStructureGeometryTrianglesDataKHR::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct AccelerationStructureGeometryTrianglesDataKHRBuilder<'a> {
    inner: AccelerationStructureGeometryTrianglesDataKHR,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsAccelerationStructureGeometryTrianglesDataKHR {}
impl<'a> ::std::ops::Deref for AccelerationStructureGeometryTrianglesDataKHRBuilder<'a> {
    type Target = AccelerationStructureGeometryTrianglesDataKHR;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for AccelerationStructureGeometryTrianglesDataKHRBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> AccelerationStructureGeometryTrianglesDataKHRBuilder<'a> {
    pub fn vertex_format(
        mut self,
        vertex_format: Format,
    ) -> AccelerationStructureGeometryTrianglesDataKHRBuilder<'a> {
        self.inner.vertex_format = vertex_format;
        self
    }
    pub fn vertex_data(
        mut self,
        vertex_data: DeviceOrHostAddressConstKHR,
    ) -> AccelerationStructureGeometryTrianglesDataKHRBuilder<'a> {
        self.inner.vertex_data = vertex_data;
        self
    }
    pub fn vertex_stride(
        mut self,
        vertex_stride: DeviceSize,
    ) -> AccelerationStructureGeometryTrianglesDataKHRBuilder<'a> {
        self.inner.vertex_stride = vertex_stride;
        self
    }
    pub fn index_type(
        mut self,
        index_type: IndexType,
    ) -> AccelerationStructureGeometryTrianglesDataKHRBuilder<'a> {
        self.inner.index_type = index_type;
        self
    }
    pub fn index_data(
        mut self,
        index_data: DeviceOrHostAddressConstKHR,
    ) -> AccelerationStructureGeometryTrianglesDataKHRBuilder<'a> {
        self.inner.index_data = index_data;
        self
    }
    pub fn transform_data(
        mut self,
        transform_data: DeviceOrHostAddressConstKHR,
    ) -> AccelerationStructureGeometryTrianglesDataKHRBuilder<'a> {
        self.inner.transform_data = transform_data;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsAccelerationStructureGeometryTrianglesDataKHR>(
        mut self,
        next: &'a mut T,
    ) -> AccelerationStructureGeometryTrianglesDataKHRBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> AccelerationStructureGeometryTrianglesDataKHR {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAccelerationStructureGeometryAabbsDataKHR.html>"]
pub struct AccelerationStructureGeometryAabbsDataKHR {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub data: DeviceOrHostAddressConstKHR,
    pub stride: DeviceSize,
}
impl fmt::Debug for AccelerationStructureGeometryAabbsDataKHR {
    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
        fmt.debug_struct("AccelerationStructureGeometryAabbsDataKHR")
            .field("s_type", &self.s_type)
            .field("p_next", &self.p_next)
            .field("data", &"union")
            .field("stride", &self.stride)
            .finish()
    }
}
impl ::std::default::Default for AccelerationStructureGeometryAabbsDataKHR {
    fn default() -> AccelerationStructureGeometryAabbsDataKHR {
        AccelerationStructureGeometryAabbsDataKHR {
            s_type: StructureType::ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR,
            p_next: ::std::ptr::null(),
            data: DeviceOrHostAddressConstKHR::default(),
            stride: DeviceSize::default(),
        }
    }
}
impl AccelerationStructureGeometryAabbsDataKHR {
    pub fn builder<'a>() -> AccelerationStructureGeometryAabbsDataKHRBuilder<'a> {
        AccelerationStructureGeometryAabbsDataKHRBuilder {
            inner: AccelerationStructureGeometryAabbsDataKHR::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct AccelerationStructureGeometryAabbsDataKHRBuilder<'a> {
    inner: AccelerationStructureGeometryAabbsDataKHR,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsAccelerationStructureGeometryAabbsDataKHR {}
impl<'a> ::std::ops::Deref for AccelerationStructureGeometryAabbsDataKHRBuilder<'a> {
    type Target = AccelerationStructureGeometryAabbsDataKHR;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for AccelerationStructureGeometryAabbsDataKHRBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> AccelerationStructureGeometryAabbsDataKHRBuilder<'a> {
    pub fn data(
        mut self,
        data: DeviceOrHostAddressConstKHR,
    ) -> AccelerationStructureGeometryAabbsDataKHRBuilder<'a> {
        self.inner.data = data;
        self
    }
    pub fn stride(
        mut self,
        stride: DeviceSize,
    ) -> AccelerationStructureGeometryAabbsDataKHRBuilder<'a> {
        self.inner.stride = stride;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsAccelerationStructureGeometryAabbsDataKHR>(
        mut self,
        next: &'a mut T,
    ) -> AccelerationStructureGeometryAabbsDataKHRBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> AccelerationStructureGeometryAabbsDataKHR {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAccelerationStructureGeometryInstancesDataKHR.html>"]
pub struct AccelerationStructureGeometryInstancesDataKHR {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub array_of_pointers: Bool32,
    pub data: DeviceOrHostAddressConstKHR,
}
impl fmt::Debug for AccelerationStructureGeometryInstancesDataKHR {
    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
        fmt.debug_struct("AccelerationStructureGeometryInstancesDataKHR")
            .field("s_type", &self.s_type)
            .field("p_next", &self.p_next)
            .field("array_of_pointers", &self.array_of_pointers)
            .field("data", &"union")
            .finish()
    }
}
impl ::std::default::Default for AccelerationStructureGeometryInstancesDataKHR {
    fn default() -> AccelerationStructureGeometryInstancesDataKHR {
        AccelerationStructureGeometryInstancesDataKHR {
            s_type: StructureType::ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR,
            p_next: ::std::ptr::null(),
            array_of_pointers: Bool32::default(),
            data: DeviceOrHostAddressConstKHR::default(),
        }
    }
}
impl AccelerationStructureGeometryInstancesDataKHR {
    pub fn builder<'a>() -> AccelerationStructureGeometryInstancesDataKHRBuilder<'a> {
        AccelerationStructureGeometryInstancesDataKHRBuilder {
            inner: AccelerationStructureGeometryInstancesDataKHR::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct AccelerationStructureGeometryInstancesDataKHRBuilder<'a> {
    inner: AccelerationStructureGeometryInstancesDataKHR,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsAccelerationStructureGeometryInstancesDataKHR {}
impl<'a> ::std::ops::Deref for AccelerationStructureGeometryInstancesDataKHRBuilder<'a> {
    type Target = AccelerationStructureGeometryInstancesDataKHR;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for AccelerationStructureGeometryInstancesDataKHRBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> AccelerationStructureGeometryInstancesDataKHRBuilder<'a> {
    pub fn array_of_pointers(
        mut self,
        array_of_pointers: bool,
    ) -> AccelerationStructureGeometryInstancesDataKHRBuilder<'a> {
        self.inner.array_of_pointers = array_of_pointers.into();
        self
    }
    pub fn data(
        mut self,
        data: DeviceOrHostAddressConstKHR,
    ) -> AccelerationStructureGeometryInstancesDataKHRBuilder<'a> {
        self.inner.data = data;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsAccelerationStructureGeometryInstancesDataKHR>(
        mut self,
        next: &'a mut T,
    ) -> AccelerationStructureGeometryInstancesDataKHRBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> AccelerationStructureGeometryInstancesDataKHR {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAccelerationStructureGeometryDataKHR.html>"]
pub union AccelerationStructureGeometryDataKHR {
    pub triangles: AccelerationStructureGeometryTrianglesDataKHR,
    pub aabbs: AccelerationStructureGeometryAabbsDataKHR,
    pub instances: AccelerationStructureGeometryInstancesDataKHR,
}
impl ::std::default::Default for AccelerationStructureGeometryDataKHR {
    fn default() -> AccelerationStructureGeometryDataKHR {
        unsafe { ::std::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAccelerationStructureGeometryKHR.html>"]
pub struct AccelerationStructureGeometryKHR {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub geometry_type: GeometryTypeKHR,
    pub geometry: AccelerationStructureGeometryDataKHR,
    pub flags: GeometryFlagsKHR,
}
impl fmt::Debug for AccelerationStructureGeometryKHR {
    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
        fmt.debug_struct("AccelerationStructureGeometryKHR")
            .field("s_type", &self.s_type)
            .field("p_next", &self.p_next)
            .field("geometry_type", &self.geometry_type)
            .field("geometry", &"union")
            .field("flags", &self.flags)
            .finish()
    }
}
impl ::std::default::Default for AccelerationStructureGeometryKHR {
    fn default() -> AccelerationStructureGeometryKHR {
        AccelerationStructureGeometryKHR {
            s_type: StructureType::ACCELERATION_STRUCTURE_GEOMETRY_KHR,
            p_next: ::std::ptr::null(),
            geometry_type: GeometryTypeKHR::default(),
            geometry: AccelerationStructureGeometryDataKHR::default(),
            flags: GeometryFlagsKHR::default(),
        }
    }
}
impl AccelerationStructureGeometryKHR {
    pub fn builder<'a>() -> AccelerationStructureGeometryKHRBuilder<'a> {
        AccelerationStructureGeometryKHRBuilder {
            inner: AccelerationStructureGeometryKHR::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct AccelerationStructureGeometryKHRBuilder<'a> {
    inner: AccelerationStructureGeometryKHR,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsAccelerationStructureGeometryKHR {}
impl<'a> ::std::ops::Deref for AccelerationStructureGeometryKHRBuilder<'a> {
    type Target = AccelerationStructureGeometryKHR;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for AccelerationStructureGeometryKHRBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> AccelerationStructureGeometryKHRBuilder<'a> {
    pub fn geometry_type(
        mut self,
        geometry_type: GeometryTypeKHR,
    ) -> AccelerationStructureGeometryKHRBuilder<'a> {
        self.inner.geometry_type = geometry_type;
        self
    }
    pub fn geometry(
        mut self,
        geometry: AccelerationStructureGeometryDataKHR,
    ) -> AccelerationStructureGeometryKHRBuilder<'a> {
        self.inner.geometry = geometry;
        self
    }
    pub fn flags(mut self, flags: GeometryFlagsKHR) -> AccelerationStructureGeometryKHRBuilder<'a> {
        self.inner.flags = flags;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsAccelerationStructureGeometryKHR>(
        mut self,
        next: &'a mut T,
    ) -> AccelerationStructureGeometryKHRBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> AccelerationStructureGeometryKHR {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAccelerationStructureBuildGeometryInfoKHR.html>"]
pub struct AccelerationStructureBuildGeometryInfoKHR {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub ty: AccelerationStructureTypeKHR,
    pub flags: BuildAccelerationStructureFlagsKHR,
    pub update: Bool32,
    pub src_acceleration_structure: AccelerationStructureKHR,
    pub dst_acceleration_structure: AccelerationStructureKHR,
    pub geometry_array_of_pointers: Bool32,
    pub geometry_count: u32,
    pub pp_geometries: *const *const AccelerationStructureGeometryKHR,
    pub scratch_data: DeviceOrHostAddressKHR,
}
impl fmt::Debug for AccelerationStructureBuildGeometryInfoKHR {
    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
        fmt.debug_struct("AccelerationStructureBuildGeometryInfoKHR")
            .field("s_type", &self.s_type)
            .field("p_next", &self.p_next)
            .field("ty", &self.ty)
            .field("flags", &self.flags)
            .field("update", &self.update)
            .field(
                "src_acceleration_structure",
                &self.src_acceleration_structure,
            )
            .field(
                "dst_acceleration_structure",
                &self.dst_acceleration_structure,
            )
            .field(
                "geometry_array_of_pointers",
                &self.geometry_array_of_pointers,
            )
            .field("geometry_count", &self.geometry_count)
            .field("pp_geometries", &self.pp_geometries)
            .field("scratch_data", &"union")
            .finish()
    }
}
impl ::std::default::Default for AccelerationStructureBuildGeometryInfoKHR {
    fn default() -> AccelerationStructureBuildGeometryInfoKHR {
        AccelerationStructureBuildGeometryInfoKHR {
            s_type: StructureType::ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR,
            p_next: ::std::ptr::null(),
            ty: AccelerationStructureTypeKHR::default(),
            flags: BuildAccelerationStructureFlagsKHR::default(),
            update: Bool32::default(),
            src_acceleration_structure: AccelerationStructureKHR::default(),
            dst_acceleration_structure: AccelerationStructureKHR::default(),
            geometry_array_of_pointers: Bool32::default(),
            geometry_count: u32::default(),
            pp_geometries: ::std::ptr::null(),
            scratch_data: DeviceOrHostAddressKHR::default(),
        }
    }
}
impl AccelerationStructureBuildGeometryInfoKHR {
    pub fn builder<'a>() -> AccelerationStructureBuildGeometryInfoKHRBuilder<'a> {
        AccelerationStructureBuildGeometryInfoKHRBuilder {
            inner: AccelerationStructureBuildGeometryInfoKHR::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct AccelerationStructureBuildGeometryInfoKHRBuilder<'a> {
    inner: AccelerationStructureBuildGeometryInfoKHR,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsAccelerationStructureBuildGeometryInfoKHR {}
impl<'a> ::std::ops::Deref for AccelerationStructureBuildGeometryInfoKHRBuilder<'a> {
    type Target = AccelerationStructureBuildGeometryInfoKHR;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for AccelerationStructureBuildGeometryInfoKHRBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> AccelerationStructureBuildGeometryInfoKHRBuilder<'a> {
    pub fn ty(
        mut self,
        ty: AccelerationStructureTypeKHR,
    ) -> AccelerationStructureBuildGeometryInfoKHRBuilder<'a> {
        self.inner.ty = ty;
        self
    }
    pub fn flags(
        mut self,
        flags: BuildAccelerationStructureFlagsKHR,
    ) -> AccelerationStructureBuildGeometryInfoKHRBuilder<'a> {
        self.inner.flags = flags;
        self
    }
    pub fn update(mut self, update: bool) -> AccelerationStructureBuildGeometryInfoKHRBuilder<'a> {
        self.inner.update = update.into();
        self
    }
    pub fn src_acceleration_structure(
        mut self,
        src_acceleration_structure: AccelerationStructureKHR,
    ) -> AccelerationStructureBuildGeometryInfoKHRBuilder<'a> {
        self.inner.src_acceleration_structure = src_acceleration_structure;
        self
    }
    pub fn dst_acceleration_structure(
        mut self,
        dst_acceleration_structure: AccelerationStructureKHR,
    ) -> AccelerationStructureBuildGeometryInfoKHRBuilder<'a> {
        self.inner.dst_acceleration_structure = dst_acceleration_structure;
        self
    }
    pub fn geometry_array_of_pointers(
        mut self,
        geometry_array_of_pointers: bool,
    ) -> AccelerationStructureBuildGeometryInfoKHRBuilder<'a> {
        self.inner.geometry_array_of_pointers = geometry_array_of_pointers.into();
        self
    }
    pub fn geometry_count(
        mut self,
        geometry_count: u32,
    ) -> AccelerationStructureBuildGeometryInfoKHRBuilder<'a> {
        self.inner.geometry_count = geometry_count;
        self
    }
    pub fn geometries(
        mut self,
        geometries: &'a *const AccelerationStructureGeometryKHR,
    ) -> AccelerationStructureBuildGeometryInfoKHRBuilder<'a> {
        self.inner.pp_geometries = geometries;
        self
    }
    pub fn scratch_data(
        mut self,
        scratch_data: DeviceOrHostAddressKHR,
    ) -> AccelerationStructureBuildGeometryInfoKHRBuilder<'a> {
        self.inner.scratch_data = scratch_data;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsAccelerationStructureBuildGeometryInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> AccelerationStructureBuildGeometryInfoKHRBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> AccelerationStructureBuildGeometryInfoKHR {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Default, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAccelerationStructureBuildOffsetInfoKHR.html>"]
pub struct AccelerationStructureBuildOffsetInfoKHR {
    pub primitive_count: u32,
    pub primitive_offset: u32,
    pub first_vertex: u32,
    pub transform_offset: u32,
}
impl AccelerationStructureBuildOffsetInfoKHR {
    pub fn builder<'a>() -> AccelerationStructureBuildOffsetInfoKHRBuilder<'a> {
        AccelerationStructureBuildOffsetInfoKHRBuilder {
            inner: AccelerationStructureBuildOffsetInfoKHR::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct AccelerationStructureBuildOffsetInfoKHRBuilder<'a> {
    inner: AccelerationStructureBuildOffsetInfoKHR,
    marker: ::std::marker::PhantomData<&'a ()>,
}
impl<'a> ::std::ops::Deref for AccelerationStructureBuildOffsetInfoKHRBuilder<'a> {
    type Target = AccelerationStructureBuildOffsetInfoKHR;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for AccelerationStructureBuildOffsetInfoKHRBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> AccelerationStructureBuildOffsetInfoKHRBuilder<'a> {
    pub fn primitive_count(
        mut self,
        primitive_count: u32,
    ) -> AccelerationStructureBuildOffsetInfoKHRBuilder<'a> {
        self.inner.primitive_count = primitive_count;
        self
    }
    pub fn primitive_offset(
        mut self,
        primitive_offset: u32,
    ) -> AccelerationStructureBuildOffsetInfoKHRBuilder<'a> {
        self.inner.primitive_offset = primitive_offset;
        self
    }
    pub fn first_vertex(
        mut self,
        first_vertex: u32,
    ) -> AccelerationStructureBuildOffsetInfoKHRBuilder<'a> {
        self.inner.first_vertex = first_vertex;
        self
    }
    pub fn transform_offset(
        mut self,
        transform_offset: u32,
    ) -> AccelerationStructureBuildOffsetInfoKHRBuilder<'a> {
        self.inner.transform_offset = transform_offset;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> AccelerationStructureBuildOffsetInfoKHR {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAccelerationStructureCreateGeometryTypeInfoKHR.html>"]
pub struct AccelerationStructureCreateGeometryTypeInfoKHR {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub geometry_type: GeometryTypeKHR,
    pub max_primitive_count: u32,
    pub index_type: IndexType,
    pub max_vertex_count: u32,
    pub vertex_format: Format,
    pub allows_transforms: Bool32,
}
impl ::std::default::Default for AccelerationStructureCreateGeometryTypeInfoKHR {
    fn default() -> AccelerationStructureCreateGeometryTypeInfoKHR {
        AccelerationStructureCreateGeometryTypeInfoKHR {
            s_type: StructureType::ACCELERATION_STRUCTURE_CREATE_GEOMETRY_TYPE_INFO_KHR,
            p_next: ::std::ptr::null(),
            geometry_type: GeometryTypeKHR::default(),
            max_primitive_count: u32::default(),
            index_type: IndexType::default(),
            max_vertex_count: u32::default(),
            vertex_format: Format::default(),
            allows_transforms: Bool32::default(),
        }
    }
}
impl AccelerationStructureCreateGeometryTypeInfoKHR {
    pub fn builder<'a>() -> AccelerationStructureCreateGeometryTypeInfoKHRBuilder<'a> {
        AccelerationStructureCreateGeometryTypeInfoKHRBuilder {
            inner: AccelerationStructureCreateGeometryTypeInfoKHR::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct AccelerationStructureCreateGeometryTypeInfoKHRBuilder<'a> {
    inner: AccelerationStructureCreateGeometryTypeInfoKHR,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsAccelerationStructureCreateGeometryTypeInfoKHR {}
impl<'a> ::std::ops::Deref for AccelerationStructureCreateGeometryTypeInfoKHRBuilder<'a> {
    type Target = AccelerationStructureCreateGeometryTypeInfoKHR;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for AccelerationStructureCreateGeometryTypeInfoKHRBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> AccelerationStructureCreateGeometryTypeInfoKHRBuilder<'a> {
    pub fn geometry_type(
        mut self,
        geometry_type: GeometryTypeKHR,
    ) -> AccelerationStructureCreateGeometryTypeInfoKHRBuilder<'a> {
        self.inner.geometry_type = geometry_type;
        self
    }
    pub fn max_primitive_count(
        mut self,
        max_primitive_count: u32,
    ) -> AccelerationStructureCreateGeometryTypeInfoKHRBuilder<'a> {
        self.inner.max_primitive_count = max_primitive_count;
        self
    }
    pub fn index_type(
        mut self,
        index_type: IndexType,
    ) -> AccelerationStructureCreateGeometryTypeInfoKHRBuilder<'a> {
        self.inner.index_type = index_type;
        self
    }
    pub fn max_vertex_count(
        mut self,
        max_vertex_count: u32,
    ) -> AccelerationStructureCreateGeometryTypeInfoKHRBuilder<'a> {
        self.inner.max_vertex_count = max_vertex_count;
        self
    }
    pub fn vertex_format(
        mut self,
        vertex_format: Format,
    ) -> AccelerationStructureCreateGeometryTypeInfoKHRBuilder<'a> {
        self.inner.vertex_format = vertex_format;
        self
    }
    pub fn allows_transforms(
        mut self,
        allows_transforms: bool,
    ) -> AccelerationStructureCreateGeometryTypeInfoKHRBuilder<'a> {
        self.inner.allows_transforms = allows_transforms.into();
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsAccelerationStructureCreateGeometryTypeInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> AccelerationStructureCreateGeometryTypeInfoKHRBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> AccelerationStructureCreateGeometryTypeInfoKHR {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAccelerationStructureCreateInfoKHR.html>"]
pub struct AccelerationStructureCreateInfoKHR {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub compacted_size: DeviceSize,
    pub ty: AccelerationStructureTypeKHR,
    pub flags: BuildAccelerationStructureFlagsKHR,
    pub max_geometry_count: u32,
    pub p_geometry_infos: *const AccelerationStructureCreateGeometryTypeInfoKHR,
    pub device_address: DeviceAddress,
}
impl ::std::default::Default for AccelerationStructureCreateInfoKHR {
    fn default() -> AccelerationStructureCreateInfoKHR {
        AccelerationStructureCreateInfoKHR {
            s_type: StructureType::ACCELERATION_STRUCTURE_CREATE_INFO_KHR,
            p_next: ::std::ptr::null(),
            compacted_size: DeviceSize::default(),
            ty: AccelerationStructureTypeKHR::default(),
            flags: BuildAccelerationStructureFlagsKHR::default(),
            max_geometry_count: u32::default(),
            p_geometry_infos: ::std::ptr::null(),
            device_address: DeviceAddress::default(),
        }
    }
}
impl AccelerationStructureCreateInfoKHR {
    pub fn builder<'a>() -> AccelerationStructureCreateInfoKHRBuilder<'a> {
        AccelerationStructureCreateInfoKHRBuilder {
            inner: AccelerationStructureCreateInfoKHR::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct AccelerationStructureCreateInfoKHRBuilder<'a> {
    inner: AccelerationStructureCreateInfoKHR,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsAccelerationStructureCreateInfoKHR {}
impl<'a> ::std::ops::Deref for AccelerationStructureCreateInfoKHRBuilder<'a> {
    type Target = AccelerationStructureCreateInfoKHR;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for AccelerationStructureCreateInfoKHRBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> AccelerationStructureCreateInfoKHRBuilder<'a> {
    pub fn compacted_size(
        mut self,
        compacted_size: DeviceSize,
    ) -> AccelerationStructureCreateInfoKHRBuilder<'a> {
        self.inner.compacted_size = compacted_size;
        self
    }
    pub fn ty(
        mut self,
        ty: AccelerationStructureTypeKHR,
    ) -> AccelerationStructureCreateInfoKHRBuilder<'a> {
        self.inner.ty = ty;
        self
    }
    pub fn flags(
        mut self,
        flags: BuildAccelerationStructureFlagsKHR,
    ) -> AccelerationStructureCreateInfoKHRBuilder<'a> {
        self.inner.flags = flags;
        self
    }
    pub fn geometry_infos(
        mut self,
        geometry_infos: &'a [AccelerationStructureCreateGeometryTypeInfoKHR],
    ) -> AccelerationStructureCreateInfoKHRBuilder<'a> {
        self.inner.max_geometry_count = geometry_infos.len() as _;
        self.inner.p_geometry_infos = geometry_infos.as_ptr();
        self
    }
    pub fn device_address(
        mut self,
        device_address: DeviceAddress,
    ) -> AccelerationStructureCreateInfoKHRBuilder<'a> {
        self.inner.device_address = device_address;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsAccelerationStructureCreateInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> AccelerationStructureCreateInfoKHRBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> AccelerationStructureCreateInfoKHR {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Default, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAabbPositionsKHR.html>"]
pub struct AabbPositionsKHR {
    pub min_x: f32,
    pub min_y: f32,
    pub min_z: f32,
    pub max_x: f32,
    pub max_y: f32,
    pub max_z: f32,
}
impl AabbPositionsKHR {
    pub fn builder<'a>() -> AabbPositionsKHRBuilder<'a> {
        AabbPositionsKHRBuilder {
            inner: AabbPositionsKHR::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct AabbPositionsKHRBuilder<'a> {
    inner: AabbPositionsKHR,
    marker: ::std::marker::PhantomData<&'a ()>,
}
impl<'a> ::std::ops::Deref for AabbPositionsKHRBuilder<'a> {
    type Target = AabbPositionsKHR;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for AabbPositionsKHRBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> AabbPositionsKHRBuilder<'a> {
    pub fn min_x(mut self, min_x: f32) -> AabbPositionsKHRBuilder<'a> {
        self.inner.min_x = min_x;
        self
    }
    pub fn min_y(mut self, min_y: f32) -> AabbPositionsKHRBuilder<'a> {
        self.inner.min_y = min_y;
        self
    }
    pub fn min_z(mut self, min_z: f32) -> AabbPositionsKHRBuilder<'a> {
        self.inner.min_z = min_z;
        self
    }
    pub fn max_x(mut self, max_x: f32) -> AabbPositionsKHRBuilder<'a> {
        self.inner.max_x = max_x;
        self
    }
    pub fn max_y(mut self, max_y: f32) -> AabbPositionsKHRBuilder<'a> {
        self.inner.max_y = max_y;
        self
    }
    pub fn max_z(mut self, max_z: f32) -> AabbPositionsKHRBuilder<'a> {
        self.inner.max_z = max_z;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> AabbPositionsKHR {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct TransformMatrixKHR {
    pub matrix: [f32; 12],
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct AccelerationStructureInstanceKHR {
    pub transform: TransformMatrixKHR,
    pub instance_custom_index_and_mask: u32,
    pub instance_shader_binding_table_record_offset_and_flags: u32,
    pub acceleration_structure_reference: u64,
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAccelerationStructureDeviceAddressInfoKHR.html>"]
pub struct AccelerationStructureDeviceAddressInfoKHR {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub acceleration_structure: AccelerationStructureKHR,
}
impl ::std::default::Default for AccelerationStructureDeviceAddressInfoKHR {
    fn default() -> AccelerationStructureDeviceAddressInfoKHR {
        AccelerationStructureDeviceAddressInfoKHR {
            s_type: StructureType::ACCELERATION_STRUCTURE_DEVICE_ADDRESS_INFO_KHR,
            p_next: ::std::ptr::null(),
            acceleration_structure: AccelerationStructureKHR::default(),
        }
    }
}
impl AccelerationStructureDeviceAddressInfoKHR {
    pub fn builder<'a>() -> AccelerationStructureDeviceAddressInfoKHRBuilder<'a> {
        AccelerationStructureDeviceAddressInfoKHRBuilder {
            inner: AccelerationStructureDeviceAddressInfoKHR::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct AccelerationStructureDeviceAddressInfoKHRBuilder<'a> {
    inner: AccelerationStructureDeviceAddressInfoKHR,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsAccelerationStructureDeviceAddressInfoKHR {}
impl<'a> ::std::ops::Deref for AccelerationStructureDeviceAddressInfoKHRBuilder<'a> {
    type Target = AccelerationStructureDeviceAddressInfoKHR;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for AccelerationStructureDeviceAddressInfoKHRBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> AccelerationStructureDeviceAddressInfoKHRBuilder<'a> {
    pub fn acceleration_structure(
        mut self,
        acceleration_structure: AccelerationStructureKHR,
    ) -> AccelerationStructureDeviceAddressInfoKHRBuilder<'a> {
        self.inner.acceleration_structure = acceleration_structure;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsAccelerationStructureDeviceAddressInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> AccelerationStructureDeviceAddressInfoKHRBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> AccelerationStructureDeviceAddressInfoKHR {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAccelerationStructureVersionKHR.html>"]
pub struct AccelerationStructureVersionKHR {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub version_data: *const u8,
}
impl ::std::default::Default for AccelerationStructureVersionKHR {
    fn default() -> AccelerationStructureVersionKHR {
        AccelerationStructureVersionKHR {
            s_type: StructureType::ACCELERATION_STRUCTURE_VERSION_KHR,
            p_next: ::std::ptr::null(),
            version_data: ::std::ptr::null(),
        }
    }
}
impl AccelerationStructureVersionKHR {
    pub fn builder<'a>() -> AccelerationStructureVersionKHRBuilder<'a> {
        AccelerationStructureVersionKHRBuilder {
            inner: AccelerationStructureVersionKHR::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct AccelerationStructureVersionKHRBuilder<'a> {
    inner: AccelerationStructureVersionKHR,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsAccelerationStructureVersionKHR {}
impl<'a> ::std::ops::Deref for AccelerationStructureVersionKHRBuilder<'a> {
    type Target = AccelerationStructureVersionKHR;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for AccelerationStructureVersionKHRBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> AccelerationStructureVersionKHRBuilder<'a> {
    pub fn version_data(
        mut self,
        version_data: *const u8,
    ) -> AccelerationStructureVersionKHRBuilder<'a> {
        self.inner.version_data = version_data;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsAccelerationStructureVersionKHR>(
        mut self,
        next: &'a mut T,
    ) -> AccelerationStructureVersionKHRBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> AccelerationStructureVersionKHR {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCopyAccelerationStructureInfoKHR.html>"]
pub struct CopyAccelerationStructureInfoKHR {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub src: AccelerationStructureKHR,
    pub dst: AccelerationStructureKHR,
    pub mode: CopyAccelerationStructureModeKHR,
}
impl ::std::default::Default for CopyAccelerationStructureInfoKHR {
    fn default() -> CopyAccelerationStructureInfoKHR {
        CopyAccelerationStructureInfoKHR {
            s_type: StructureType::COPY_ACCELERATION_STRUCTURE_INFO_KHR,
            p_next: ::std::ptr::null(),
            src: AccelerationStructureKHR::default(),
            dst: AccelerationStructureKHR::default(),
            mode: CopyAccelerationStructureModeKHR::default(),
        }
    }
}
impl CopyAccelerationStructureInfoKHR {
    pub fn builder<'a>() -> CopyAccelerationStructureInfoKHRBuilder<'a> {
        CopyAccelerationStructureInfoKHRBuilder {
            inner: CopyAccelerationStructureInfoKHR::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct CopyAccelerationStructureInfoKHRBuilder<'a> {
    inner: CopyAccelerationStructureInfoKHR,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsCopyAccelerationStructureInfoKHR {}
impl<'a> ::std::ops::Deref for CopyAccelerationStructureInfoKHRBuilder<'a> {
    type Target = CopyAccelerationStructureInfoKHR;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for CopyAccelerationStructureInfoKHRBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> CopyAccelerationStructureInfoKHRBuilder<'a> {
    pub fn src(
        mut self,
        src: AccelerationStructureKHR,
    ) -> CopyAccelerationStructureInfoKHRBuilder<'a> {
        self.inner.src = src;
        self
    }
    pub fn dst(
        mut self,
        dst: AccelerationStructureKHR,
    ) -> CopyAccelerationStructureInfoKHRBuilder<'a> {
        self.inner.dst = dst;
        self
    }
    pub fn mode(
        mut self,
        mode: CopyAccelerationStructureModeKHR,
    ) -> CopyAccelerationStructureInfoKHRBuilder<'a> {
        self.inner.mode = mode;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsCopyAccelerationStructureInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> CopyAccelerationStructureInfoKHRBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> CopyAccelerationStructureInfoKHR {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCopyAccelerationStructureToMemoryInfoKHR.html>"]
pub struct CopyAccelerationStructureToMemoryInfoKHR {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub src: AccelerationStructureKHR,
    pub dst: DeviceOrHostAddressKHR,
    pub mode: CopyAccelerationStructureModeKHR,
}
impl fmt::Debug for CopyAccelerationStructureToMemoryInfoKHR {
    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
        fmt.debug_struct("CopyAccelerationStructureToMemoryInfoKHR")
            .field("s_type", &self.s_type)
            .field("p_next", &self.p_next)
            .field("src", &self.src)
            .field("dst", &"union")
            .field("mode", &self.mode)
            .finish()
    }
}
impl ::std::default::Default for CopyAccelerationStructureToMemoryInfoKHR {
    fn default() -> CopyAccelerationStructureToMemoryInfoKHR {
        CopyAccelerationStructureToMemoryInfoKHR {
            s_type: StructureType::COPY_ACCELERATION_STRUCTURE_TO_MEMORY_INFO_KHR,
            p_next: ::std::ptr::null(),
            src: AccelerationStructureKHR::default(),
            dst: DeviceOrHostAddressKHR::default(),
            mode: CopyAccelerationStructureModeKHR::default(),
        }
    }
}
impl CopyAccelerationStructureToMemoryInfoKHR {
    pub fn builder<'a>() -> CopyAccelerationStructureToMemoryInfoKHRBuilder<'a> {
        CopyAccelerationStructureToMemoryInfoKHRBuilder {
            inner: CopyAccelerationStructureToMemoryInfoKHR::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct CopyAccelerationStructureToMemoryInfoKHRBuilder<'a> {
    inner: CopyAccelerationStructureToMemoryInfoKHR,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsCopyAccelerationStructureToMemoryInfoKHR {}
impl<'a> ::std::ops::Deref for CopyAccelerationStructureToMemoryInfoKHRBuilder<'a> {
    type Target = CopyAccelerationStructureToMemoryInfoKHR;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for CopyAccelerationStructureToMemoryInfoKHRBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> CopyAccelerationStructureToMemoryInfoKHRBuilder<'a> {
    pub fn src(
        mut self,
        src: AccelerationStructureKHR,
    ) -> CopyAccelerationStructureToMemoryInfoKHRBuilder<'a> {
        self.inner.src = src;
        self
    }
    pub fn dst(
        mut self,
        dst: DeviceOrHostAddressKHR,
    ) -> CopyAccelerationStructureToMemoryInfoKHRBuilder<'a> {
        self.inner.dst = dst;
        self
    }
    pub fn mode(
        mut self,
        mode: CopyAccelerationStructureModeKHR,
    ) -> CopyAccelerationStructureToMemoryInfoKHRBuilder<'a> {
        self.inner.mode = mode;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsCopyAccelerationStructureToMemoryInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> CopyAccelerationStructureToMemoryInfoKHRBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> CopyAccelerationStructureToMemoryInfoKHR {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCopyMemoryToAccelerationStructureInfoKHR.html>"]
pub struct CopyMemoryToAccelerationStructureInfoKHR {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub src: DeviceOrHostAddressConstKHR,
    pub dst: AccelerationStructureKHR,
    pub mode: CopyAccelerationStructureModeKHR,
}
impl fmt::Debug for CopyMemoryToAccelerationStructureInfoKHR {
    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
        fmt.debug_struct("CopyMemoryToAccelerationStructureInfoKHR")
            .field("s_type", &self.s_type)
            .field("p_next", &self.p_next)
            .field("src", &"union")
            .field("dst", &self.dst)
            .field("mode", &self.mode)
            .finish()
    }
}
impl ::std::default::Default for CopyMemoryToAccelerationStructureInfoKHR {
    fn default() -> CopyMemoryToAccelerationStructureInfoKHR {
        CopyMemoryToAccelerationStructureInfoKHR {
            s_type: StructureType::COPY_MEMORY_TO_ACCELERATION_STRUCTURE_INFO_KHR,
            p_next: ::std::ptr::null(),
            src: DeviceOrHostAddressConstKHR::default(),
            dst: AccelerationStructureKHR::default(),
            mode: CopyAccelerationStructureModeKHR::default(),
        }
    }
}
impl CopyMemoryToAccelerationStructureInfoKHR {
    pub fn builder<'a>() -> CopyMemoryToAccelerationStructureInfoKHRBuilder<'a> {
        CopyMemoryToAccelerationStructureInfoKHRBuilder {
            inner: CopyMemoryToAccelerationStructureInfoKHR::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct CopyMemoryToAccelerationStructureInfoKHRBuilder<'a> {
    inner: CopyMemoryToAccelerationStructureInfoKHR,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsCopyMemoryToAccelerationStructureInfoKHR {}
impl<'a> ::std::ops::Deref for CopyMemoryToAccelerationStructureInfoKHRBuilder<'a> {
    type Target = CopyMemoryToAccelerationStructureInfoKHR;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for CopyMemoryToAccelerationStructureInfoKHRBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> CopyMemoryToAccelerationStructureInfoKHRBuilder<'a> {
    pub fn src(
        mut self,
        src: DeviceOrHostAddressConstKHR,
    ) -> CopyMemoryToAccelerationStructureInfoKHRBuilder<'a> {
        self.inner.src = src;
        self
    }
    pub fn dst(
        mut self,
        dst: AccelerationStructureKHR,
    ) -> CopyMemoryToAccelerationStructureInfoKHRBuilder<'a> {
        self.inner.dst = dst;
        self
    }
    pub fn mode(
        mut self,
        mode: CopyAccelerationStructureModeKHR,
    ) -> CopyMemoryToAccelerationStructureInfoKHRBuilder<'a> {
        self.inner.mode = mode;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsCopyMemoryToAccelerationStructureInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> CopyMemoryToAccelerationStructureInfoKHRBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> CopyMemoryToAccelerationStructureInfoKHR {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkRayTracingPipelineInterfaceCreateInfoKHR.html>"]
pub struct RayTracingPipelineInterfaceCreateInfoKHR {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub max_payload_size: u32,
    pub max_attribute_size: u32,
    pub max_callable_size: u32,
}
impl ::std::default::Default for RayTracingPipelineInterfaceCreateInfoKHR {
    fn default() -> RayTracingPipelineInterfaceCreateInfoKHR {
        RayTracingPipelineInterfaceCreateInfoKHR {
            s_type: StructureType::RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO_KHR,
            p_next: ::std::ptr::null(),
            max_payload_size: u32::default(),
            max_attribute_size: u32::default(),
            max_callable_size: u32::default(),
        }
    }
}
impl RayTracingPipelineInterfaceCreateInfoKHR {
    pub fn builder<'a>() -> RayTracingPipelineInterfaceCreateInfoKHRBuilder<'a> {
        RayTracingPipelineInterfaceCreateInfoKHRBuilder {
            inner: RayTracingPipelineInterfaceCreateInfoKHR::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct RayTracingPipelineInterfaceCreateInfoKHRBuilder<'a> {
    inner: RayTracingPipelineInterfaceCreateInfoKHR,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsRayTracingPipelineInterfaceCreateInfoKHR {}
impl<'a> ::std::ops::Deref for RayTracingPipelineInterfaceCreateInfoKHRBuilder<'a> {
    type Target = RayTracingPipelineInterfaceCreateInfoKHR;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for RayTracingPipelineInterfaceCreateInfoKHRBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> RayTracingPipelineInterfaceCreateInfoKHRBuilder<'a> {
    pub fn max_payload_size(
        mut self,
        max_payload_size: u32,
    ) -> RayTracingPipelineInterfaceCreateInfoKHRBuilder<'a> {
        self.inner.max_payload_size = max_payload_size;
        self
    }
    pub fn max_attribute_size(
        mut self,
        max_attribute_size: u32,
    ) -> RayTracingPipelineInterfaceCreateInfoKHRBuilder<'a> {
        self.inner.max_attribute_size = max_attribute_size;
        self
    }
    pub fn max_callable_size(
        mut self,
        max_callable_size: u32,
    ) -> RayTracingPipelineInterfaceCreateInfoKHRBuilder<'a> {
        self.inner.max_callable_size = max_callable_size;
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsRayTracingPipelineInterfaceCreateInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> RayTracingPipelineInterfaceCreateInfoKHRBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> RayTracingPipelineInterfaceCreateInfoKHR {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDeferredOperationInfoKHR.html>"]
pub struct DeferredOperationInfoKHR {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub operation_handle: DeferredOperationKHR,
}
impl ::std::default::Default for DeferredOperationInfoKHR {
    fn default() -> DeferredOperationInfoKHR {
        DeferredOperationInfoKHR {
            s_type: StructureType::DEFERRED_OPERATION_INFO_KHR,
            p_next: ::std::ptr::null(),
            operation_handle: DeferredOperationKHR::default(),
        }
    }
}
impl DeferredOperationInfoKHR {
    pub fn builder<'a>() -> DeferredOperationInfoKHRBuilder<'a> {
        DeferredOperationInfoKHRBuilder {
            inner: DeferredOperationInfoKHR::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct DeferredOperationInfoKHRBuilder<'a> {
    inner: DeferredOperationInfoKHR,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsRayTracingPipelineCreateInfoKHR for DeferredOperationInfoKHRBuilder<'_> {}
unsafe impl ExtendsRayTracingPipelineCreateInfoKHR for DeferredOperationInfoKHR {}
unsafe impl ExtendsAccelerationStructureBuildGeometryInfoKHR
    for DeferredOperationInfoKHRBuilder<'_>
{
}
unsafe impl ExtendsAccelerationStructureBuildGeometryInfoKHR for DeferredOperationInfoKHR {}
unsafe impl ExtendsCopyAccelerationStructureInfoKHR for DeferredOperationInfoKHRBuilder<'_> {}
unsafe impl ExtendsCopyAccelerationStructureInfoKHR for DeferredOperationInfoKHR {}
unsafe impl ExtendsCopyMemoryToAccelerationStructureInfoKHR
    for DeferredOperationInfoKHRBuilder<'_>
{
}
unsafe impl ExtendsCopyMemoryToAccelerationStructureInfoKHR for DeferredOperationInfoKHR {}
unsafe impl ExtendsCopyAccelerationStructureToMemoryInfoKHR
    for DeferredOperationInfoKHRBuilder<'_>
{
}
unsafe impl ExtendsCopyAccelerationStructureToMemoryInfoKHR for DeferredOperationInfoKHR {}
impl<'a> ::std::ops::Deref for DeferredOperationInfoKHRBuilder<'a> {
    type Target = DeferredOperationInfoKHR;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for DeferredOperationInfoKHRBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> DeferredOperationInfoKHRBuilder<'a> {
    pub fn operation_handle(
        mut self,
        operation_handle: DeferredOperationKHR,
    ) -> DeferredOperationInfoKHRBuilder<'a> {
        self.inner.operation_handle = operation_handle;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> DeferredOperationInfoKHR {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineLibraryCreateInfoKHR.html>"]
pub struct PipelineLibraryCreateInfoKHR {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub library_count: u32,
    pub p_libraries: *const Pipeline,
}
impl ::std::default::Default for PipelineLibraryCreateInfoKHR {
    fn default() -> PipelineLibraryCreateInfoKHR {
        PipelineLibraryCreateInfoKHR {
            s_type: StructureType::PIPELINE_LIBRARY_CREATE_INFO_KHR,
            p_next: ::std::ptr::null(),
            library_count: u32::default(),
            p_libraries: ::std::ptr::null(),
        }
    }
}
impl PipelineLibraryCreateInfoKHR {
    pub fn builder<'a>() -> PipelineLibraryCreateInfoKHRBuilder<'a> {
        PipelineLibraryCreateInfoKHRBuilder {
            inner: PipelineLibraryCreateInfoKHR::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PipelineLibraryCreateInfoKHRBuilder<'a> {
    inner: PipelineLibraryCreateInfoKHR,
    marker: ::std::marker::PhantomData<&'a ()>,
}
pub unsafe trait ExtendsPipelineLibraryCreateInfoKHR {}
impl<'a> ::std::ops::Deref for PipelineLibraryCreateInfoKHRBuilder<'a> {
    type Target = PipelineLibraryCreateInfoKHR;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PipelineLibraryCreateInfoKHRBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PipelineLibraryCreateInfoKHRBuilder<'a> {
    pub fn libraries(
        mut self,
        libraries: &'a [Pipeline],
    ) -> PipelineLibraryCreateInfoKHRBuilder<'a> {
        self.inner.library_count = libraries.len() as _;
        self.inner.p_libraries = libraries.as_ptr();
        self
    }
    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
    #[doc = r" valid extension structs can be pushed into the chain."]
    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
    #[doc = r" chain will look like `A -> D -> B -> C`."]
    pub fn push_next<T: ExtendsPipelineLibraryCreateInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> PipelineLibraryCreateInfoKHRBuilder<'a> {
        unsafe {
            let next_ptr = next as *mut T as *mut BaseOutStructure;
            let last_next = ptr_chain_iter(next).last().unwrap();
            (*last_next).p_next = self.inner.p_next as _;
            self.inner.p_next = next_ptr as _;
        }
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PipelineLibraryCreateInfoKHR {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkRenderPassTransformBeginInfoQCOM.html>"]
pub struct RenderPassTransformBeginInfoQCOM {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub transform: SurfaceTransformFlagsKHR,
}
impl ::std::default::Default for RenderPassTransformBeginInfoQCOM {
    fn default() -> RenderPassTransformBeginInfoQCOM {
        RenderPassTransformBeginInfoQCOM {
            s_type: StructureType::RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM,
            p_next: ::std::ptr::null_mut(),
            transform: SurfaceTransformFlagsKHR::default(),
        }
    }
}
impl RenderPassTransformBeginInfoQCOM {
    pub fn builder<'a>() -> RenderPassTransformBeginInfoQCOMBuilder<'a> {
        RenderPassTransformBeginInfoQCOMBuilder {
            inner: RenderPassTransformBeginInfoQCOM::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct RenderPassTransformBeginInfoQCOMBuilder<'a> {
    inner: RenderPassTransformBeginInfoQCOM,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsRenderPassBeginInfo for RenderPassTransformBeginInfoQCOMBuilder<'_> {}
unsafe impl ExtendsRenderPassBeginInfo for RenderPassTransformBeginInfoQCOM {}
impl<'a> ::std::ops::Deref for RenderPassTransformBeginInfoQCOMBuilder<'a> {
    type Target = RenderPassTransformBeginInfoQCOM;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for RenderPassTransformBeginInfoQCOMBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> RenderPassTransformBeginInfoQCOMBuilder<'a> {
    pub fn transform(
        mut self,
        transform: SurfaceTransformFlagsKHR,
    ) -> RenderPassTransformBeginInfoQCOMBuilder<'a> {
        self.inner.transform = transform;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> RenderPassTransformBeginInfoQCOM {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCommandBufferInheritanceRenderPassTransformInfoQCOM.html>"]
pub struct CommandBufferInheritanceRenderPassTransformInfoQCOM {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub transform: SurfaceTransformFlagsKHR,
    pub render_area: Rect2D,
}
impl ::std::default::Default for CommandBufferInheritanceRenderPassTransformInfoQCOM {
    fn default() -> CommandBufferInheritanceRenderPassTransformInfoQCOM {
        CommandBufferInheritanceRenderPassTransformInfoQCOM {
            s_type: StructureType::COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM,
            p_next: ::std::ptr::null_mut(),
            transform: SurfaceTransformFlagsKHR::default(),
            render_area: Rect2D::default(),
        }
    }
}
impl CommandBufferInheritanceRenderPassTransformInfoQCOM {
    pub fn builder<'a>() -> CommandBufferInheritanceRenderPassTransformInfoQCOMBuilder<'a> {
        CommandBufferInheritanceRenderPassTransformInfoQCOMBuilder {
            inner: CommandBufferInheritanceRenderPassTransformInfoQCOM::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct CommandBufferInheritanceRenderPassTransformInfoQCOMBuilder<'a> {
    inner: CommandBufferInheritanceRenderPassTransformInfoQCOM,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsCommandBufferInheritanceInfo
    for CommandBufferInheritanceRenderPassTransformInfoQCOMBuilder<'_>
{
}
unsafe impl ExtendsCommandBufferInheritanceInfo
    for CommandBufferInheritanceRenderPassTransformInfoQCOM
{
}
impl<'a> ::std::ops::Deref for CommandBufferInheritanceRenderPassTransformInfoQCOMBuilder<'a> {
    type Target = CommandBufferInheritanceRenderPassTransformInfoQCOM;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for CommandBufferInheritanceRenderPassTransformInfoQCOMBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> CommandBufferInheritanceRenderPassTransformInfoQCOMBuilder<'a> {
    pub fn transform(
        mut self,
        transform: SurfaceTransformFlagsKHR,
    ) -> CommandBufferInheritanceRenderPassTransformInfoQCOMBuilder<'a> {
        self.inner.transform = transform;
        self
    }
    pub fn render_area(
        mut self,
        render_area: Rect2D,
    ) -> CommandBufferInheritanceRenderPassTransformInfoQCOMBuilder<'a> {
        self.inner.render_area = render_area;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> CommandBufferInheritanceRenderPassTransformInfoQCOM {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceDiagnosticsConfigFeaturesNV.html>"]
pub struct PhysicalDeviceDiagnosticsConfigFeaturesNV {
    pub s_type: StructureType,
    pub p_next: *mut c_void,
    pub diagnostics_config: Bool32,
}
impl ::std::default::Default for PhysicalDeviceDiagnosticsConfigFeaturesNV {
    fn default() -> PhysicalDeviceDiagnosticsConfigFeaturesNV {
        PhysicalDeviceDiagnosticsConfigFeaturesNV {
            s_type: StructureType::PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV,
            p_next: ::std::ptr::null_mut(),
            diagnostics_config: Bool32::default(),
        }
    }
}
impl PhysicalDeviceDiagnosticsConfigFeaturesNV {
    pub fn builder<'a>() -> PhysicalDeviceDiagnosticsConfigFeaturesNVBuilder<'a> {
        PhysicalDeviceDiagnosticsConfigFeaturesNVBuilder {
            inner: PhysicalDeviceDiagnosticsConfigFeaturesNV::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct PhysicalDeviceDiagnosticsConfigFeaturesNVBuilder<'a> {
    inner: PhysicalDeviceDiagnosticsConfigFeaturesNV,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDiagnosticsConfigFeaturesNVBuilder<'_> {}
unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDiagnosticsConfigFeaturesNV {}
impl<'a> ::std::ops::Deref for PhysicalDeviceDiagnosticsConfigFeaturesNVBuilder<'a> {
    type Target = PhysicalDeviceDiagnosticsConfigFeaturesNV;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for PhysicalDeviceDiagnosticsConfigFeaturesNVBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> PhysicalDeviceDiagnosticsConfigFeaturesNVBuilder<'a> {
    pub fn diagnostics_config(
        mut self,
        diagnostics_config: bool,
    ) -> PhysicalDeviceDiagnosticsConfigFeaturesNVBuilder<'a> {
        self.inner.diagnostics_config = diagnostics_config.into();
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> PhysicalDeviceDiagnosticsConfigFeaturesNV {
        self.inner
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDeviceDiagnosticsConfigCreateInfoNV.html>"]
pub struct DeviceDiagnosticsConfigCreateInfoNV {
    pub s_type: StructureType,
    pub p_next: *const c_void,
    pub flags: DeviceDiagnosticsConfigFlagsNV,
}
impl ::std::default::Default for DeviceDiagnosticsConfigCreateInfoNV {
    fn default() -> DeviceDiagnosticsConfigCreateInfoNV {
        DeviceDiagnosticsConfigCreateInfoNV {
            s_type: StructureType::DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV,
            p_next: ::std::ptr::null(),
            flags: DeviceDiagnosticsConfigFlagsNV::default(),
        }
    }
}
impl DeviceDiagnosticsConfigCreateInfoNV {
    pub fn builder<'a>() -> DeviceDiagnosticsConfigCreateInfoNVBuilder<'a> {
        DeviceDiagnosticsConfigCreateInfoNVBuilder {
            inner: DeviceDiagnosticsConfigCreateInfoNV::default(),
            marker: ::std::marker::PhantomData,
        }
    }
}
#[repr(transparent)]
pub struct DeviceDiagnosticsConfigCreateInfoNVBuilder<'a> {
    inner: DeviceDiagnosticsConfigCreateInfoNV,
    marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsDeviceCreateInfo for DeviceDiagnosticsConfigCreateInfoNVBuilder<'_> {}
unsafe impl ExtendsDeviceCreateInfo for DeviceDiagnosticsConfigCreateInfoNV {}
impl<'a> ::std::ops::Deref for DeviceDiagnosticsConfigCreateInfoNVBuilder<'a> {
    type Target = DeviceDiagnosticsConfigCreateInfoNV;
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> ::std::ops::DerefMut for DeviceDiagnosticsConfigCreateInfoNVBuilder<'a> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
impl<'a> DeviceDiagnosticsConfigCreateInfoNVBuilder<'a> {
    pub fn flags(
        mut self,
        flags: DeviceDiagnosticsConfigFlagsNV,
    ) -> DeviceDiagnosticsConfigCreateInfoNVBuilder<'a> {
        self.inner.flags = flags;
        self
    }
    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
    pub fn build(self) -> DeviceDiagnosticsConfigCreateInfoNV {
        self.inner
    }
}