From 3947675aaa5abd7611071a0c5771756fd74951c7 Mon Sep 17 00:00:00 2001 From: Marijn Suijten Date: Tue, 9 Nov 2021 22:42:14 +0100 Subject: [PATCH] Update Vulkan-Headers to 1.2.198 (#477) * Update Vulkan-Headers to 1.2.192 * Update Vulkan-Headers to 1.2.193 * Update Vulkan-Headers to 1.2.194 * Update Vulkan-Headers to 1.2.195 Includes the new VK_EXT_rgba10x6_formats, VK_KHR_format_feature_flags2 and VK_KHR_maintenance4 extensions. * Update Vulkan-Headers to 1.2.196 Includes Vulkan-Headers fixup commit with the missing h265 encode header. * Update Vulkan-Headers to 1.2.197 * Update Vulkan-Headers to 1.2.198 --- ash/src/vk/aliases.rs | 1 + ash/src/vk/bitflags.rs | 102 ++ ash/src/vk/const_debugs.rs | 238 ++- ash/src/vk/definitions.rs | 2999 +++++++++++++++++++++++++++++++++++- ash/src/vk/enums.rs | 6 + ash/src/vk/extensions.rs | 942 ++++++++++- ash/src/vk/native.rs | 1754 ++++++++++++++++++--- generator/Vulkan-Headers | 2 +- generator/src/lib.rs | 10 +- 9 files changed, 5733 insertions(+), 321 deletions(-) diff --git a/ash/src/vk/aliases.rs b/ash/src/vk/aliases.rs index be39302..8ef4b1c 100644 --- a/ash/src/vk/aliases.rs +++ b/ash/src/vk/aliases.rs @@ -164,3 +164,4 @@ pub type DeviceMemoryOpaqueCaptureAddressInfoKHR = DeviceMemoryOpaqueCaptureAddr pub type AabbPositionsNV = AabbPositionsKHR; pub type TransformMatrixNV = TransformMatrixKHR; pub type AccelerationStructureInstanceNV = AccelerationStructureInstanceKHR; +pub type AttachmentSampleCountInfoNV = AttachmentSampleCountInfoAMD; diff --git a/ash/src/vk/bitflags.rs b/ash/src/vk/bitflags.rs index ee8737f..728e330 100644 --- a/ash/src/vk/bitflags.rs +++ b/ash/src/vk/bitflags.rs @@ -1221,3 +1221,105 @@ impl VideoEncodeH264CreateFlagsEXT { pub const DEFAULT: Self = Self(0); pub const RESERVED_0: Self = Self(0b1); } +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct ImageFormatConstraintsFlagsFUCHSIA(pub(crate) Flags); +vk_bitflags_wrapped!(ImageFormatConstraintsFlagsFUCHSIA, 0b0, Flags); +impl ImageFormatConstraintsFlagsFUCHSIA {} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct ImageConstraintsInfoFlagsFUCHSIA(pub(crate) Flags); +vk_bitflags_wrapped!(ImageConstraintsInfoFlagsFUCHSIA, 0b1_1111, Flags); +impl ImageConstraintsInfoFlagsFUCHSIA { + pub const CPU_READ_RARELY: Self = Self(0b1); + pub const CPU_READ_OFTEN: Self = Self(0b10); + pub const CPU_WRITE_RARELY: Self = Self(0b100); + pub const CPU_WRITE_OFTEN: Self = Self(0b1000); + pub const PROTECTED_OPTIONAL: Self = Self(0b1_0000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct FormatFeatureFlags2KHR(pub(crate) Flags64); +vk_bitflags_wrapped!( + FormatFeatureFlags2KHR, + 0b11_1000_0000_1111_1111_1111_1111_1111_1111, + Flags64 +); +impl FormatFeatureFlags2KHR { + pub const SAMPLED_IMAGE: Self = Self(0b1); + pub const STORAGE_IMAGE: Self = Self(0b10); + pub const STORAGE_IMAGE_ATOMIC: Self = Self(0b100); + pub const UNIFORM_TEXEL_BUFFER: Self = Self(0b1000); + pub const STORAGE_TEXEL_BUFFER: Self = Self(0b1_0000); + pub const STORAGE_TEXEL_BUFFER_ATOMIC: Self = Self(0b10_0000); + pub const VERTEX_BUFFER: Self = Self(0b100_0000); + pub const COLOR_ATTACHMENT: Self = Self(0b1000_0000); + pub const COLOR_ATTACHMENT_BLEND: Self = Self(0b1_0000_0000); + pub const DEPTH_STENCIL_ATTACHMENT: Self = Self(0b10_0000_0000); + pub const BLIT_SRC: Self = Self(0b100_0000_0000); + pub const BLIT_DST: Self = Self(0b1000_0000_0000); + pub const SAMPLED_IMAGE_FILTER_LINEAR: Self = Self(0b1_0000_0000_0000); + pub const SAMPLED_IMAGE_FILTER_CUBIC_EXT: Self = Self(0b10_0000_0000_0000); + pub const TRANSFER_SRC: Self = Self(0b100_0000_0000_0000); + pub const TRANSFER_DST: Self = Self(0b1000_0000_0000_0000); + pub const SAMPLED_IMAGE_FILTER_MINMAX: Self = Self(0b1_0000_0000_0000_0000); + pub const MIDPOINT_CHROMA_SAMPLES: Self = Self(0b10_0000_0000_0000_0000); + pub const SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER: Self = Self(0b100_0000_0000_0000_0000); + pub const SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER: Self = + Self(0b1000_0000_0000_0000_0000); + pub const SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT: Self = + Self(0b1_0000_0000_0000_0000_0000); + pub const SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE: Self = + Self(0b10_0000_0000_0000_0000_0000); + pub const DISJOINT: Self = Self(0b100_0000_0000_0000_0000_0000); + pub const COSITED_CHROMA_SAMPLES: Self = Self(0b1000_0000_0000_0000_0000_0000); + pub const STORAGE_READ_WITHOUT_FORMAT: Self = Self(0b1000_0000_0000_0000_0000_0000_0000_0000); + pub const STORAGE_WRITE_WITHOUT_FORMAT: Self = + Self(0b1_0000_0000_0000_0000_0000_0000_0000_0000); + pub const SAMPLED_IMAGE_DEPTH_COMPARISON: Self = + Self(0b10_0000_0000_0000_0000_0000_0000_0000_0000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct VideoEncodeH265InputModeFlagsEXT(pub(crate) Flags); +vk_bitflags_wrapped!(VideoEncodeH265InputModeFlagsEXT, 0b111, Flags); +impl VideoEncodeH265InputModeFlagsEXT { + pub const FRAME: Self = Self(0b1); + pub const SLICE: Self = Self(0b10); + pub const NON_VCL: Self = Self(0b100); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct VideoEncodeH265OutputModeFlagsEXT(pub(crate) Flags); +vk_bitflags_wrapped!(VideoEncodeH265OutputModeFlagsEXT, 0b111, Flags); +impl VideoEncodeH265OutputModeFlagsEXT { + pub const FRAME: Self = Self(0b1); + pub const SLICE: Self = Self(0b10); + pub const NON_VCL: Self = Self(0b100); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct VideoEncodeH265CtbSizeFlagsEXT(pub(crate) Flags); +vk_bitflags_wrapped!(VideoEncodeH265CtbSizeFlagsEXT, 0b1111, Flags); +impl VideoEncodeH265CtbSizeFlagsEXT { + pub const TYPE_8: Self = Self(0b1); + pub const TYPE_16: Self = Self(0b10); + pub const TYPE_32: Self = Self(0b100); + pub const TYPE_64: Self = Self(0b1000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct RenderingFlagsKHR(pub(crate) Flags); +vk_bitflags_wrapped!(RenderingFlagsKHR, 0b111, Flags); +impl RenderingFlagsKHR { + pub const CONTENTS_SECONDARY_COMMAND_BUFFERS: Self = Self(0b1); + pub const SUSPENDING: Self = Self(0b10); + pub const RESUMING: Self = Self(0b100); +} diff --git a/ash/src/vk/const_debugs.rs b/ash/src/vk/const_debugs.rs index b4b9219..0fc2401 100644 --- a/ash/src/vk/const_debugs.rs +++ b/ash/src/vk/const_debugs.rs @@ -325,6 +325,7 @@ impl fmt::Debug for AccessFlags2KHR { AccessFlags2KHR::INVOCATION_MASK_READ_HUAWEI.0, "INVOCATION_MASK_READ_HUAWEI", ), + (AccessFlags2KHR::RESERVED_387.0, "RESERVED_387"), ]; debug_flags(f, KNOWN, self.0) } @@ -368,7 +369,7 @@ impl fmt::Debug for AttachmentStoreOp { let name = match *self { Self::STORE => Some("STORE"), Self::DONT_CARE => Some("DONT_CARE"), - Self::NONE_EXT => Some("NONE_EXT"), + Self::NONE_KHR => Some("NONE_KHR"), _ => None, }; if let Some(x) = name { @@ -513,6 +514,7 @@ impl fmt::Debug for BufferCreateFlags { (BufferCreateFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), (BufferCreateFlags::SPARSE_RESIDENCY.0, "SPARSE_RESIDENCY"), (BufferCreateFlags::SPARSE_ALIASED.0, "SPARSE_ALIASED"), + (BufferCreateFlags::RESERVED_5_AMD.0, "RESERVED_5_AMD"), (BufferCreateFlags::PROTECTED.0, "PROTECTED"), ( BufferCreateFlags::DEVICE_ADDRESS_CAPTURE_REPLAY.0, @@ -581,6 +583,8 @@ impl fmt::Debug for BufferUsageFlags { BufferUsageFlags::VIDEO_ENCODE_SRC_KHR.0, "VIDEO_ENCODE_SRC_KHR", ), + (BufferUsageFlags::RESERVED_21_AMD.0, "RESERVED_21_AMD"), + (BufferUsageFlags::RESERVED_22_AMD.0, "RESERVED_22_AMD"), ( BufferUsageFlags::SHADER_DEVICE_ADDRESS.0, "SHADER_DEVICE_ADDRESS", @@ -983,6 +987,7 @@ impl fmt::Debug for DebugReportObjectTypeEXT { Self::CU_FUNCTION_NVX => Some("CU_FUNCTION_NVX"), Self::ACCELERATION_STRUCTURE_KHR => Some("ACCELERATION_STRUCTURE_KHR"), Self::ACCELERATION_STRUCTURE_NV => Some("ACCELERATION_STRUCTURE_NV"), + Self::BUFFER_COLLECTION_FUCHSIA => Some("BUFFER_COLLECTION_FUCHSIA"), _ => None, }; if let Some(x) = name { @@ -1088,6 +1093,10 @@ impl fmt::Debug for DescriptorSetLayoutCreateFlags { DescriptorSetLayoutCreateFlags::PUSH_DESCRIPTOR_KHR.0, "PUSH_DESCRIPTOR_KHR", ), + ( + DescriptorSetLayoutCreateFlags::RESERVED_4_AMD.0, + "RESERVED_4_AMD", + ), ( DescriptorSetLayoutCreateFlags::RESERVED_3_AMD.0, "RESERVED_3_AMD", @@ -1326,6 +1335,9 @@ impl fmt::Debug for DriverId { Self::COREAVI_PROPRIETARY => Some("COREAVI_PROPRIETARY"), Self::JUICE_PROPRIETARY => Some("JUICE_PROPRIETARY"), Self::VERISILICON_PROPRIETARY => Some("VERISILICON_PROPRIETARY"), + Self::MESA_TURNIP => Some("MESA_TURNIP"), + Self::MESA_V3DV => Some("MESA_V3DV"), + Self::MESA_PANVK => Some("MESA_PANVK"), _ => None, }; if let Some(x) = name { @@ -1922,6 +1934,12 @@ impl fmt::Debug for FormatFeatureFlags { debug_flags(f, KNOWN, self.0) } } +impl fmt::Debug for FormatFeatureFlags2KHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN : & [(Flags64 , & str)] = & [(FormatFeatureFlags2KHR :: SAMPLED_IMAGE . 0 , "SAMPLED_IMAGE") , (FormatFeatureFlags2KHR :: STORAGE_IMAGE . 0 , "STORAGE_IMAGE") , (FormatFeatureFlags2KHR :: STORAGE_IMAGE_ATOMIC . 0 , "STORAGE_IMAGE_ATOMIC") , (FormatFeatureFlags2KHR :: UNIFORM_TEXEL_BUFFER . 0 , "UNIFORM_TEXEL_BUFFER") , (FormatFeatureFlags2KHR :: STORAGE_TEXEL_BUFFER . 0 , "STORAGE_TEXEL_BUFFER") , (FormatFeatureFlags2KHR :: STORAGE_TEXEL_BUFFER_ATOMIC . 0 , "STORAGE_TEXEL_BUFFER_ATOMIC") , (FormatFeatureFlags2KHR :: VERTEX_BUFFER . 0 , "VERTEX_BUFFER") , (FormatFeatureFlags2KHR :: COLOR_ATTACHMENT . 0 , "COLOR_ATTACHMENT") , (FormatFeatureFlags2KHR :: COLOR_ATTACHMENT_BLEND . 0 , "COLOR_ATTACHMENT_BLEND") , (FormatFeatureFlags2KHR :: DEPTH_STENCIL_ATTACHMENT . 0 , "DEPTH_STENCIL_ATTACHMENT") , (FormatFeatureFlags2KHR :: BLIT_SRC . 0 , "BLIT_SRC") , (FormatFeatureFlags2KHR :: BLIT_DST . 0 , "BLIT_DST") , (FormatFeatureFlags2KHR :: SAMPLED_IMAGE_FILTER_LINEAR . 0 , "SAMPLED_IMAGE_FILTER_LINEAR") , (FormatFeatureFlags2KHR :: SAMPLED_IMAGE_FILTER_CUBIC_EXT . 0 , "SAMPLED_IMAGE_FILTER_CUBIC_EXT") , (FormatFeatureFlags2KHR :: TRANSFER_SRC . 0 , "TRANSFER_SRC") , (FormatFeatureFlags2KHR :: TRANSFER_DST . 0 , "TRANSFER_DST") , (FormatFeatureFlags2KHR :: SAMPLED_IMAGE_FILTER_MINMAX . 0 , "SAMPLED_IMAGE_FILTER_MINMAX") , (FormatFeatureFlags2KHR :: MIDPOINT_CHROMA_SAMPLES . 0 , "MIDPOINT_CHROMA_SAMPLES") , (FormatFeatureFlags2KHR :: SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER") , (FormatFeatureFlags2KHR :: SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER") , (FormatFeatureFlags2KHR :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT") , (FormatFeatureFlags2KHR :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE") , (FormatFeatureFlags2KHR :: DISJOINT . 0 , "DISJOINT") , (FormatFeatureFlags2KHR :: COSITED_CHROMA_SAMPLES . 0 , "COSITED_CHROMA_SAMPLES") , (FormatFeatureFlags2KHR :: STORAGE_READ_WITHOUT_FORMAT . 0 , "STORAGE_READ_WITHOUT_FORMAT") , (FormatFeatureFlags2KHR :: STORAGE_WRITE_WITHOUT_FORMAT . 0 , "STORAGE_WRITE_WITHOUT_FORMAT") , (FormatFeatureFlags2KHR :: SAMPLED_IMAGE_DEPTH_COMPARISON . 0 , "SAMPLED_IMAGE_DEPTH_COMPARISON") , (FormatFeatureFlags2KHR :: VIDEO_DECODE_OUTPUT . 0 , "VIDEO_DECODE_OUTPUT") , (FormatFeatureFlags2KHR :: VIDEO_DECODE_DPB . 0 , "VIDEO_DECODE_DPB") , (FormatFeatureFlags2KHR :: ACCELERATION_STRUCTURE_VERTEX_BUFFER . 0 , "ACCELERATION_STRUCTURE_VERTEX_BUFFER") , (FormatFeatureFlags2KHR :: FRAGMENT_DENSITY_MAP_EXT . 0 , "FRAGMENT_DENSITY_MAP_EXT") , (FormatFeatureFlags2KHR :: FRAGMENT_SHADING_RATE_ATTACHMENT . 0 , "FRAGMENT_SHADING_RATE_ATTACHMENT") , (FormatFeatureFlags2KHR :: VIDEO_ENCODE_INPUT . 0 , "VIDEO_ENCODE_INPUT") , (FormatFeatureFlags2KHR :: VIDEO_ENCODE_DPB . 0 , "VIDEO_ENCODE_DPB")] ; + debug_flags(f, KNOWN, self.0) + } +} impl fmt::Debug for FragmentShadingRateCombinerOpKHR { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -2090,6 +2108,33 @@ impl fmt::Debug for ImageAspectFlags { debug_flags(f, KNOWN, self.0) } } +impl fmt::Debug for ImageConstraintsInfoFlagsFUCHSIA { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ImageConstraintsInfoFlagsFUCHSIA::CPU_READ_RARELY.0, + "CPU_READ_RARELY", + ), + ( + ImageConstraintsInfoFlagsFUCHSIA::CPU_READ_OFTEN.0, + "CPU_READ_OFTEN", + ), + ( + ImageConstraintsInfoFlagsFUCHSIA::CPU_WRITE_RARELY.0, + "CPU_WRITE_RARELY", + ), + ( + ImageConstraintsInfoFlagsFUCHSIA::CPU_WRITE_OFTEN.0, + "CPU_WRITE_OFTEN", + ), + ( + ImageConstraintsInfoFlagsFUCHSIA::PROTECTED_OPTIONAL.0, + "PROTECTED_OPTIONAL", + ), + ]; + debug_flags(f, KNOWN, self.0) + } +} impl fmt::Debug for ImageCreateFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ @@ -2104,6 +2149,9 @@ impl fmt::Debug for ImageCreateFlags { "SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_EXT", ), (ImageCreateFlags::SUBSAMPLED_EXT.0, "SUBSAMPLED_EXT"), + (ImageCreateFlags::RESERVED_16_AMD.0, "RESERVED_16_AMD"), + (ImageCreateFlags::RESERVED_394_EXT.0, "RESERVED_394_EXT"), + (ImageCreateFlags::RESERVED_426_QCOM.0, "RESERVED_426_QCOM"), (ImageCreateFlags::ALIAS.0, "ALIAS"), ( ImageCreateFlags::SPLIT_INSTANCE_BIND_REGIONS.0, @@ -2124,6 +2172,12 @@ impl fmt::Debug for ImageCreateFlags { debug_flags(f, KNOWN, self.0) } } +impl fmt::Debug for ImageFormatConstraintsFlagsFUCHSIA { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} impl fmt::Debug for ImageLayout { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -2548,6 +2602,7 @@ impl fmt::Debug for ObjectType { Self::DEFERRED_OPERATION_KHR => Some("DEFERRED_OPERATION_KHR"), Self::INDIRECT_COMMANDS_LAYOUT_NV => Some("INDIRECT_COMMANDS_LAYOUT_NV"), Self::PRIVATE_DATA_SLOT_EXT => Some("PRIVATE_DATA_SLOT_EXT"), + Self::BUFFER_COLLECTION_FUCHSIA => Some("BUFFER_COLLECTION_FUCHSIA"), Self::SAMPLER_YCBCR_CONVERSION => Some("SAMPLER_YCBCR_CONVERSION"), Self::DESCRIPTOR_UPDATE_TEMPLATE => Some("DESCRIPTOR_UPDATE_TEMPLATE"), _ => None, @@ -2802,8 +2857,14 @@ impl fmt::Debug for PipelineCreateFlags { "ALLOW_DERIVATIVES", ), (PipelineCreateFlags::DERIVATIVE.0, "DERIVATIVE"), - (PipelineCreateFlags::RESERVED_21_AMD.0, "RESERVED_21_AMD"), - (PipelineCreateFlags::RESERVED_22_AMD.0, "RESERVED_22_AMD"), + ( + PipelineCreateFlags::RASTERIZATION_STATE_FRAGMENT_SHADING_RATE_ATTACHMENT_KHR.0, + "RASTERIZATION_STATE_FRAGMENT_SHADING_RATE_ATTACHMENT_KHR", + ), + ( + PipelineCreateFlags::RASTERIZATION_STATE_FRAGMENT_DENSITY_MAP_ATTACHMENT_EXT.0, + "RASTERIZATION_STATE_FRAGMENT_DENSITY_MAP_ATTACHMENT_EXT", + ), ( PipelineCreateFlags::RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_KHR.0, "RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_KHR", @@ -2927,10 +2988,16 @@ impl fmt::Debug for PipelineInputAssemblyStateCreateFlags { } impl fmt::Debug for PipelineLayoutCreateFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[( - PipelineLayoutCreateFlags::RESERVED_0_AMD.0, - "RESERVED_0_AMD", - )]; + const KNOWN: &[(Flags, &str)] = &[ + ( + PipelineLayoutCreateFlags::RESERVED_0_AMD.0, + "RESERVED_0_AMD", + ), + ( + PipelineLayoutCreateFlags::RESERVED_1_AMD.0, + "RESERVED_1_AMD", + ), + ]; debug_flags(f, KNOWN, self.0) } } @@ -3146,6 +3213,7 @@ impl fmt::Debug for PipelineStageFlags2KHR { PipelineStageFlags2KHR::INVOCATION_MASK_HUAWEI.0, "INVOCATION_MASK_HUAWEI", ), + (PipelineStageFlags2KHR::RESERVED_387.0, "RESERVED_387"), ]; debug_flags(f, KNOWN, self.0) } @@ -3467,6 +3535,19 @@ impl fmt::Debug for RenderPassCreateFlags { debug_flags(f, KNOWN, self.0) } } +impl fmt::Debug for RenderingFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + RenderingFlagsKHR::CONTENTS_SECONDARY_COMMAND_BUFFERS.0, + "CONTENTS_SECONDARY_COMMAND_BUFFERS", + ), + (RenderingFlagsKHR::SUSPENDING.0, "SUSPENDING"), + (RenderingFlagsKHR::RESUMING.0, "RESUMING"), + ]; + debug_flags(f, KNOWN, self.0) + } +} impl fmt::Debug for ResolveModeFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ @@ -3574,6 +3655,7 @@ impl fmt::Debug for SamplerCreateFlags { SamplerCreateFlags::SUBSAMPLED_COARSE_RECONSTRUCTION_EXT.0, "SUBSAMPLED_COARSE_RECONSTRUCTION_EXT", ), + (SamplerCreateFlags::RESERVED_3_AMD.0, "RESERVED_3_AMD"), (SamplerCreateFlags::RESERVED_2_EXT.0, "RESERVED_2_EXT"), ]; debug_flags(f, KNOWN, self.0) @@ -4056,6 +4138,30 @@ impl fmt::Debug for StructureType { Some("VIDEO_ENCODE_H264_EMIT_PICTURE_PARAMETERS_EXT") } Self::VIDEO_ENCODE_H264_PROFILE_EXT => Some("VIDEO_ENCODE_H264_PROFILE_EXT"), + Self::VIDEO_ENCODE_H265_CAPABILITIES_EXT => Some("VIDEO_ENCODE_H265_CAPABILITIES_EXT"), + Self::VIDEO_ENCODE_H265_SESSION_CREATE_INFO_EXT => { + Some("VIDEO_ENCODE_H265_SESSION_CREATE_INFO_EXT") + } + Self::VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT => { + Some("VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT") + } + Self::VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT => { + Some("VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT") + } + Self::VIDEO_ENCODE_H265_VCL_FRAME_INFO_EXT => { + Some("VIDEO_ENCODE_H265_VCL_FRAME_INFO_EXT") + } + Self::VIDEO_ENCODE_H265_DPB_SLOT_INFO_EXT => { + Some("VIDEO_ENCODE_H265_DPB_SLOT_INFO_EXT") + } + Self::VIDEO_ENCODE_H265_NALU_SLICE_EXT => Some("VIDEO_ENCODE_H265_NALU_SLICE_EXT"), + Self::VIDEO_ENCODE_H265_EMIT_PICTURE_PARAMETERS_EXT => { + Some("VIDEO_ENCODE_H265_EMIT_PICTURE_PARAMETERS_EXT") + } + Self::VIDEO_ENCODE_H265_PROFILE_EXT => Some("VIDEO_ENCODE_H265_PROFILE_EXT"), + Self::VIDEO_ENCODE_H265_REFERENCE_LISTS_EXT => { + Some("VIDEO_ENCODE_H265_REFERENCE_LISTS_EXT") + } Self::VIDEO_DECODE_H264_CAPABILITIES_EXT => Some("VIDEO_DECODE_H264_CAPABILITIES_EXT"), Self::VIDEO_DECODE_H264_SESSION_CREATE_INFO_EXT => { Some("VIDEO_DECODE_H264_SESSION_CREATE_INFO_EXT") @@ -4075,6 +4181,25 @@ impl fmt::Debug for StructureType { Self::TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD => { Some("TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD") } + Self::RENDERING_INFO_KHR => Some("RENDERING_INFO_KHR"), + Self::RENDERING_ATTACHMENT_INFO_KHR => Some("RENDERING_ATTACHMENT_INFO_KHR"), + Self::PIPELINE_RENDERING_CREATE_INFO_KHR => Some("PIPELINE_RENDERING_CREATE_INFO_KHR"), + Self::PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES_KHR => { + Some("PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES_KHR") + } + Self::COMMAND_BUFFER_INHERITANCE_RENDERING_INFO_KHR => { + Some("COMMAND_BUFFER_INHERITANCE_RENDERING_INFO_KHR") + } + Self::RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR => { + Some("RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR") + } + Self::RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT => { + Some("RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT") + } + Self::ATTACHMENT_SAMPLE_COUNT_INFO_AMD => Some("ATTACHMENT_SAMPLE_COUNT_INFO_AMD"), + Self::MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX => { + Some("MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX") + } Self::STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP => { Some("STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP") } @@ -4230,6 +4355,9 @@ impl fmt::Debug for StructureType { Some("MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID") } Self::EXTERNAL_FORMAT_ANDROID => Some("EXTERNAL_FORMAT_ANDROID"), + Self::ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID => { + Some("ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID") + } Self::PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT => { Some("PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT") } @@ -4352,6 +4480,9 @@ impl fmt::Debug for StructureType { Self::IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT => { Some("IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT") } + Self::DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT => { + Some("DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT") + } Self::VALIDATION_CACHE_CREATE_INFO_EXT => Some("VALIDATION_CACHE_CREATE_INFO_EXT"), Self::SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT => { Some("SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT") @@ -4821,6 +4952,9 @@ impl fmt::Debug for StructureType { Self::PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT => { Some("PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT") } + Self::PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT") + } Self::DIRECTFB_SURFACE_CREATE_INFO_EXT => Some("DIRECTFB_SURFACE_CREATE_INFO_EXT"), Self::PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE => { Some("PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE") @@ -4841,6 +4975,7 @@ impl fmt::Debug for StructureType { Self::PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT => { Some("PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT") } + Self::FORMAT_PROPERTIES_3_KHR => Some("FORMAT_PROPERTIES_3_KHR"), Self::IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA => { Some("IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA") } @@ -4856,6 +4991,30 @@ impl fmt::Debug for StructureType { Self::SEMAPHORE_GET_ZIRCON_HANDLE_INFO_FUCHSIA => { Some("SEMAPHORE_GET_ZIRCON_HANDLE_INFO_FUCHSIA") } + Self::BUFFER_COLLECTION_CREATE_INFO_FUCHSIA => { + Some("BUFFER_COLLECTION_CREATE_INFO_FUCHSIA") + } + Self::IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA => { + Some("IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA") + } + Self::BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA => { + Some("BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA") + } + Self::BUFFER_COLLECTION_PROPERTIES_FUCHSIA => { + Some("BUFFER_COLLECTION_PROPERTIES_FUCHSIA") + } + Self::BUFFER_CONSTRAINTS_INFO_FUCHSIA => Some("BUFFER_CONSTRAINTS_INFO_FUCHSIA"), + Self::BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA => { + Some("BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA") + } + Self::IMAGE_CONSTRAINTS_INFO_FUCHSIA => Some("IMAGE_CONSTRAINTS_INFO_FUCHSIA"), + Self::IMAGE_FORMAT_CONSTRAINTS_INFO_FUCHSIA => { + Some("IMAGE_FORMAT_CONSTRAINTS_INFO_FUCHSIA") + } + Self::SYSMEM_COLOR_SPACE_FUCHSIA => Some("SYSMEM_COLOR_SPACE_FUCHSIA"), + Self::BUFFER_COLLECTION_CONSTRAINTS_INFO_FUCHSIA => { + Some("BUFFER_COLLECTION_CONSTRAINTS_INFO_FUCHSIA") + } Self::SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI => { Some("SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI") } @@ -4894,9 +5053,27 @@ impl fmt::Debug for StructureType { Self::PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT => { Some("PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT") } + Self::PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT") + } + Self::SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT => { + Some("SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT") + } Self::PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT => { Some("PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT") } + Self::PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES_KHR => { + Some("PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES_KHR") + } + Self::PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES_KHR => { + Some("PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES_KHR") + } + Self::DEVICE_BUFFER_MEMORY_REQUIREMENTS_KHR => { + Some("DEVICE_BUFFER_MEMORY_REQUIREMENTS_KHR") + } + Self::DEVICE_IMAGE_MEMORY_REQUIREMENTS_KHR => { + Some("DEVICE_IMAGE_MEMORY_REQUIREMENTS_KHR") + } Self::PHYSICAL_DEVICE_SUBGROUP_PROPERTIES => { Some("PHYSICAL_DEVICE_SUBGROUP_PROPERTIES") } @@ -5469,6 +5646,10 @@ impl fmt::Debug for VideoCodecOperationFlagsKHR { VideoCodecOperationFlagsKHR::ENCODE_H264_EXT.0, "ENCODE_H264_EXT", ), + ( + VideoCodecOperationFlagsKHR::ENCODE_H265_EXT.0, + "ENCODE_H265_EXT", + ), ( VideoCodecOperationFlagsKHR::DECODE_H264_EXT.0, "DECODE_H264_EXT", @@ -5634,6 +5815,49 @@ impl fmt::Debug for VideoEncodeH264OutputModeFlagsEXT { debug_flags(f, KNOWN, self.0) } } +impl fmt::Debug for VideoEncodeH265CapabilityFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for VideoEncodeH265CreateFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for VideoEncodeH265CtbSizeFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (VideoEncodeH265CtbSizeFlagsEXT::TYPE_8.0, "TYPE_8"), + (VideoEncodeH265CtbSizeFlagsEXT::TYPE_16.0, "TYPE_16"), + (VideoEncodeH265CtbSizeFlagsEXT::TYPE_32.0, "TYPE_32"), + (VideoEncodeH265CtbSizeFlagsEXT::TYPE_64.0, "TYPE_64"), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for VideoEncodeH265InputModeFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (VideoEncodeH265InputModeFlagsEXT::FRAME.0, "FRAME"), + (VideoEncodeH265InputModeFlagsEXT::SLICE.0, "SLICE"), + (VideoEncodeH265InputModeFlagsEXT::NON_VCL.0, "NON_VCL"), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for VideoEncodeH265OutputModeFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (VideoEncodeH265OutputModeFlagsEXT::FRAME.0, "FRAME"), + (VideoEncodeH265OutputModeFlagsEXT::SLICE.0, "SLICE"), + (VideoEncodeH265OutputModeFlagsEXT::NON_VCL.0, "NON_VCL"), + ]; + debug_flags(f, KNOWN, self.0) + } +} impl fmt::Debug for VideoEncodeRateControlFlagsKHR { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ diff --git a/ash/src/vk/definitions.rs b/ash/src/vk/definitions.rs index 9e29f46..ee27c7a 100644 --- a/ash/src/vk/definitions.rs +++ b/ash/src/vk/definitions.rs @@ -54,7 +54,7 @@ pub const API_VERSION_1_0: u32 = make_api_version(0, 1, 0, 0); pub const API_VERSION_1_1: u32 = make_api_version(0, 1, 1, 0); #[doc = ""] pub const API_VERSION_1_2: u32 = make_api_version(0, 1, 2, 0); -pub const HEADER_VERSION: u32 = 191u32; +pub const HEADER_VERSION: u32 = 198u32; #[doc = ""] pub const HEADER_VERSION_COMPLETE: u32 = make_api_version(0, 1, 2, HEADER_VERSION); #[doc = ""] @@ -332,6 +332,16 @@ vk_bitflags_wrapped!(VideoDecodeH264CreateFlagsEXT, 0b0, Flags); #[doc = ""] pub struct VideoDecodeH265CreateFlagsEXT(pub(crate) Flags); vk_bitflags_wrapped!(VideoDecodeH265CreateFlagsEXT, 0b0, Flags); +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct VideoEncodeH265CapabilityFlagsEXT(pub(crate) Flags); +vk_bitflags_wrapped!(VideoEncodeH265CapabilityFlagsEXT, 0b0, Flags); +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct VideoEncodeH265CreateFlagsEXT(pub(crate) Flags); +vk_bitflags_wrapped!(VideoEncodeH265CreateFlagsEXT, 0b0, Flags); define_handle!( Instance, INSTANCE, @@ -425,6 +435,7 @@ handle_nondispatchable ! (ValidationCacheEXT , VALIDATION_CACHE_EXT , doc = " { } unsafe impl ExtendsRenderPassBeginInfo for DeviceGroupRenderPassBeginInfoBuilder<'_> {} unsafe impl ExtendsRenderPassBeginInfo for DeviceGroupRenderPassBeginInfo {} +unsafe impl ExtendsRenderingInfoKHR for DeviceGroupRenderPassBeginInfoBuilder<'_> {} +unsafe impl ExtendsRenderingInfoKHR for DeviceGroupRenderPassBeginInfo {} impl<'a> ::std::ops::Deref for DeviceGroupRenderPassBeginInfoBuilder<'a> { type Target = DeviceGroupRenderPassBeginInfo; fn deref(&self) -> &Self::Target { @@ -20871,6 +20884,59 @@ impl<'a> BufferMemoryRequirementsInfo2Builder<'a> { } #[repr(C)] #[derive(Copy, Clone, Debug)] +#[doc = ""] +pub struct DeviceBufferMemoryRequirementsKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub p_create_info: *const BufferCreateInfo, +} +impl ::std::default::Default for DeviceBufferMemoryRequirementsKHR { + fn default() -> Self { + Self { + s_type: StructureType::DEVICE_BUFFER_MEMORY_REQUIREMENTS_KHR, + p_next: ::std::ptr::null(), + p_create_info: ::std::ptr::null(), + } + } +} +impl DeviceBufferMemoryRequirementsKHR { + pub fn builder<'a>() -> DeviceBufferMemoryRequirementsKHRBuilder<'a> { + DeviceBufferMemoryRequirementsKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DeviceBufferMemoryRequirementsKHRBuilder<'a> { + inner: DeviceBufferMemoryRequirementsKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DeviceBufferMemoryRequirementsKHRBuilder<'a> { + type Target = DeviceBufferMemoryRequirementsKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DeviceBufferMemoryRequirementsKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DeviceBufferMemoryRequirementsKHRBuilder<'a> { + pub fn create_info(mut self, create_info: &'a BufferCreateInfo) -> Self { + self.inner.p_create_info = create_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) -> DeviceBufferMemoryRequirementsKHR { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] #[doc = ""] pub struct ImageMemoryRequirementsInfo2 { pub s_type: StructureType, @@ -20992,6 +21058,65 @@ impl<'a> ImageSparseMemoryRequirementsInfo2Builder<'a> { } #[repr(C)] #[derive(Copy, Clone, Debug)] +#[doc = ""] +pub struct DeviceImageMemoryRequirementsKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub p_create_info: *const ImageCreateInfo, + pub plane_aspect: ImageAspectFlags, +} +impl ::std::default::Default for DeviceImageMemoryRequirementsKHR { + fn default() -> Self { + Self { + s_type: StructureType::DEVICE_IMAGE_MEMORY_REQUIREMENTS_KHR, + p_next: ::std::ptr::null(), + p_create_info: ::std::ptr::null(), + plane_aspect: ImageAspectFlags::default(), + } + } +} +impl DeviceImageMemoryRequirementsKHR { + pub fn builder<'a>() -> DeviceImageMemoryRequirementsKHRBuilder<'a> { + DeviceImageMemoryRequirementsKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DeviceImageMemoryRequirementsKHRBuilder<'a> { + inner: DeviceImageMemoryRequirementsKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DeviceImageMemoryRequirementsKHRBuilder<'a> { + type Target = DeviceImageMemoryRequirementsKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DeviceImageMemoryRequirementsKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DeviceImageMemoryRequirementsKHRBuilder<'a> { + pub fn create_info(mut self, create_info: &'a ImageCreateInfo) -> Self { + self.inner.p_create_info = create_info; + self + } + pub fn plane_aspect(mut self, plane_aspect: ImageAspectFlags) -> Self { + 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) -> DeviceImageMemoryRequirementsKHR { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] #[doc = ""] pub struct MemoryRequirements2 { pub s_type: StructureType, @@ -23791,6 +23916,121 @@ impl<'a> PhysicalDeviceMaintenance3PropertiesBuilder<'a> { } #[repr(C)] #[derive(Copy, Clone, Debug)] +#[doc = ""] +pub struct PhysicalDeviceMaintenance4FeaturesKHR { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub maintenance4: Bool32, +} +impl ::std::default::Default for PhysicalDeviceMaintenance4FeaturesKHR { + fn default() -> Self { + Self { + s_type: StructureType::PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES_KHR, + p_next: ::std::ptr::null_mut(), + maintenance4: Bool32::default(), + } + } +} +impl PhysicalDeviceMaintenance4FeaturesKHR { + pub fn builder<'a>() -> PhysicalDeviceMaintenance4FeaturesKHRBuilder<'a> { + PhysicalDeviceMaintenance4FeaturesKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceMaintenance4FeaturesKHRBuilder<'a> { + inner: PhysicalDeviceMaintenance4FeaturesKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMaintenance4FeaturesKHRBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMaintenance4FeaturesKHR {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMaintenance4FeaturesKHRBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMaintenance4FeaturesKHR {} +impl<'a> ::std::ops::Deref for PhysicalDeviceMaintenance4FeaturesKHRBuilder<'a> { + type Target = PhysicalDeviceMaintenance4FeaturesKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceMaintenance4FeaturesKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceMaintenance4FeaturesKHRBuilder<'a> { + pub fn maintenance4(mut self, maintenance4: bool) -> Self { + self.inner.maintenance4 = maintenance4.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) -> PhysicalDeviceMaintenance4FeaturesKHR { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = ""] +pub struct PhysicalDeviceMaintenance4PropertiesKHR { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub max_buffer_size: DeviceSize, +} +impl ::std::default::Default for PhysicalDeviceMaintenance4PropertiesKHR { + fn default() -> Self { + Self { + s_type: StructureType::PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES_KHR, + p_next: ::std::ptr::null_mut(), + max_buffer_size: DeviceSize::default(), + } + } +} +impl PhysicalDeviceMaintenance4PropertiesKHR { + pub fn builder<'a>() -> PhysicalDeviceMaintenance4PropertiesKHRBuilder<'a> { + PhysicalDeviceMaintenance4PropertiesKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceMaintenance4PropertiesKHRBuilder<'a> { + inner: PhysicalDeviceMaintenance4PropertiesKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceMaintenance4PropertiesKHRBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMaintenance4PropertiesKHR {} +impl<'a> ::std::ops::Deref for PhysicalDeviceMaintenance4PropertiesKHRBuilder<'a> { + type Target = PhysicalDeviceMaintenance4PropertiesKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceMaintenance4PropertiesKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceMaintenance4PropertiesKHRBuilder<'a> { + pub fn max_buffer_size(mut self, max_buffer_size: DeviceSize) -> Self { + self.inner.max_buffer_size = max_buffer_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) -> PhysicalDeviceMaintenance4PropertiesKHR { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] #[doc = ""] pub struct DescriptorSetLayoutSupport { pub s_type: StructureType, @@ -40951,6 +41191,139 @@ impl<'a> PhysicalDeviceCustomBorderColorFeaturesEXTBuilder<'a> { } } #[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = ""] +pub struct SamplerBorderColorComponentMappingCreateInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub components: ComponentMapping, + pub srgb: Bool32, +} +impl ::std::default::Default for SamplerBorderColorComponentMappingCreateInfoEXT { + fn default() -> Self { + Self { + s_type: StructureType::SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT, + p_next: ::std::ptr::null(), + components: ComponentMapping::default(), + srgb: Bool32::default(), + } + } +} +impl SamplerBorderColorComponentMappingCreateInfoEXT { + pub fn builder<'a>() -> SamplerBorderColorComponentMappingCreateInfoEXTBuilder<'a> { + SamplerBorderColorComponentMappingCreateInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SamplerBorderColorComponentMappingCreateInfoEXTBuilder<'a> { + inner: SamplerBorderColorComponentMappingCreateInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsSamplerCreateInfo + for SamplerBorderColorComponentMappingCreateInfoEXTBuilder<'_> +{ +} +unsafe impl ExtendsSamplerCreateInfo for SamplerBorderColorComponentMappingCreateInfoEXT {} +impl<'a> ::std::ops::Deref for SamplerBorderColorComponentMappingCreateInfoEXTBuilder<'a> { + type Target = SamplerBorderColorComponentMappingCreateInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SamplerBorderColorComponentMappingCreateInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SamplerBorderColorComponentMappingCreateInfoEXTBuilder<'a> { + pub fn components(mut self, components: ComponentMapping) -> Self { + self.inner.components = components; + self + } + pub fn srgb(mut self, srgb: bool) -> Self { + self.inner.srgb = srgb.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) -> SamplerBorderColorComponentMappingCreateInfoEXT { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = ""] +pub struct PhysicalDeviceBorderColorSwizzleFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub border_color_swizzle: Bool32, + pub border_color_swizzle_from_image: Bool32, +} +impl ::std::default::Default for PhysicalDeviceBorderColorSwizzleFeaturesEXT { + fn default() -> Self { + Self { + s_type: StructureType::PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT, + p_next: ::std::ptr::null_mut(), + border_color_swizzle: Bool32::default(), + border_color_swizzle_from_image: Bool32::default(), + } + } +} +impl PhysicalDeviceBorderColorSwizzleFeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceBorderColorSwizzleFeaturesEXTBuilder<'a> { + PhysicalDeviceBorderColorSwizzleFeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceBorderColorSwizzleFeaturesEXTBuilder<'a> { + inner: PhysicalDeviceBorderColorSwizzleFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceBorderColorSwizzleFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceBorderColorSwizzleFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceBorderColorSwizzleFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceBorderColorSwizzleFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceBorderColorSwizzleFeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceBorderColorSwizzleFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceBorderColorSwizzleFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceBorderColorSwizzleFeaturesEXTBuilder<'a> { + pub fn border_color_swizzle(mut self, border_color_swizzle: bool) -> Self { + self.inner.border_color_swizzle = border_color_swizzle.into(); + self + } + pub fn border_color_swizzle_from_image( + mut self, + border_color_swizzle_from_image: bool, + ) -> Self { + self.inner.border_color_swizzle_from_image = border_color_swizzle_from_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) -> PhysicalDeviceBorderColorSwizzleFeaturesEXT { + self.inner + } +} +#[repr(C)] #[derive(Copy, Clone)] #[doc = ""] pub union DeviceOrHostAddressKHR { @@ -47380,6 +47753,16 @@ pub struct VideoDecodeH264ProfileEXTBuilder<'a> { } unsafe impl ExtendsVideoProfileKHR for VideoDecodeH264ProfileEXTBuilder<'_> {} unsafe impl ExtendsVideoProfileKHR for VideoDecodeH264ProfileEXT {} +unsafe impl ExtendsQueryPoolCreateInfo for VideoDecodeH264ProfileEXTBuilder<'_> {} +unsafe impl ExtendsQueryPoolCreateInfo for VideoDecodeH264ProfileEXT {} +unsafe impl ExtendsFormatProperties2 for VideoDecodeH264ProfileEXTBuilder<'_> {} +unsafe impl ExtendsFormatProperties2 for VideoDecodeH264ProfileEXT {} +unsafe impl ExtendsImageCreateInfo for VideoDecodeH264ProfileEXTBuilder<'_> {} +unsafe impl ExtendsImageCreateInfo for VideoDecodeH264ProfileEXT {} +unsafe impl ExtendsImageViewCreateInfo for VideoDecodeH264ProfileEXTBuilder<'_> {} +unsafe impl ExtendsImageViewCreateInfo for VideoDecodeH264ProfileEXT {} +unsafe impl ExtendsBufferCreateInfo for VideoDecodeH264ProfileEXTBuilder<'_> {} +unsafe impl ExtendsBufferCreateInfo for VideoDecodeH264ProfileEXT {} impl<'a> ::std::ops::Deref for VideoDecodeH264ProfileEXTBuilder<'a> { type Target = VideoDecodeH264ProfileEXT; fn deref(&self) -> &Self::Target { @@ -47908,6 +48291,16 @@ pub struct VideoDecodeH265ProfileEXTBuilder<'a> { } unsafe impl ExtendsVideoProfileKHR for VideoDecodeH265ProfileEXTBuilder<'_> {} unsafe impl ExtendsVideoProfileKHR for VideoDecodeH265ProfileEXT {} +unsafe impl ExtendsQueryPoolCreateInfo for VideoDecodeH265ProfileEXTBuilder<'_> {} +unsafe impl ExtendsQueryPoolCreateInfo for VideoDecodeH265ProfileEXT {} +unsafe impl ExtendsFormatProperties2 for VideoDecodeH265ProfileEXTBuilder<'_> {} +unsafe impl ExtendsFormatProperties2 for VideoDecodeH265ProfileEXT {} +unsafe impl ExtendsImageCreateInfo for VideoDecodeH265ProfileEXTBuilder<'_> {} +unsafe impl ExtendsImageCreateInfo for VideoDecodeH265ProfileEXT {} +unsafe impl ExtendsImageViewCreateInfo for VideoDecodeH265ProfileEXTBuilder<'_> {} +unsafe impl ExtendsImageViewCreateInfo for VideoDecodeH265ProfileEXT {} +unsafe impl ExtendsBufferCreateInfo for VideoDecodeH265ProfileEXTBuilder<'_> {} +unsafe impl ExtendsBufferCreateInfo for VideoDecodeH265ProfileEXT {} impl<'a> ::std::ops::Deref for VideoDecodeH265ProfileEXTBuilder<'a> { type Target = VideoDecodeH265ProfileEXT; fn deref(&self) -> &Self::Target { @@ -49606,6 +49999,16 @@ pub struct VideoEncodeH264ProfileEXTBuilder<'a> { } unsafe impl ExtendsVideoProfileKHR for VideoEncodeH264ProfileEXTBuilder<'_> {} unsafe impl ExtendsVideoProfileKHR for VideoEncodeH264ProfileEXT {} +unsafe impl ExtendsQueryPoolCreateInfo for VideoEncodeH264ProfileEXTBuilder<'_> {} +unsafe impl ExtendsQueryPoolCreateInfo for VideoEncodeH264ProfileEXT {} +unsafe impl ExtendsFormatProperties2 for VideoEncodeH264ProfileEXTBuilder<'_> {} +unsafe impl ExtendsFormatProperties2 for VideoEncodeH264ProfileEXT {} +unsafe impl ExtendsImageCreateInfo for VideoEncodeH264ProfileEXTBuilder<'_> {} +unsafe impl ExtendsImageCreateInfo for VideoEncodeH264ProfileEXT {} +unsafe impl ExtendsImageViewCreateInfo for VideoEncodeH264ProfileEXTBuilder<'_> {} +unsafe impl ExtendsImageViewCreateInfo for VideoEncodeH264ProfileEXT {} +unsafe impl ExtendsBufferCreateInfo for VideoEncodeH264ProfileEXTBuilder<'_> {} +unsafe impl ExtendsBufferCreateInfo for VideoEncodeH264ProfileEXT {} impl<'a> ::std::ops::Deref for VideoEncodeH264ProfileEXTBuilder<'a> { type Target = VideoEncodeH264ProfileEXT; fn deref(&self) -> &Self::Target { @@ -49732,6 +50135,785 @@ impl<'a> VideoEncodeH264NaluSliceEXTBuilder<'a> { } #[repr(C)] #[derive(Copy, Clone, Debug)] +#[doc = ""] +pub struct VideoEncodeH265CapabilitiesEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: VideoEncodeH265CapabilityFlagsEXT, + pub input_mode_flags: VideoEncodeH265InputModeFlagsEXT, + pub output_mode_flags: VideoEncodeH265OutputModeFlagsEXT, + pub ctb_sizes: VideoEncodeH265CtbSizeFlagsEXT, + pub input_image_data_alignment: Extent2D, + pub max_num_l0_reference_for_p: u8, + pub max_num_l0_reference_for_b: u8, + pub max_num_l1_reference: u8, + pub max_num_sub_layers: u8, + pub quality_level_count: u8, + pub std_extension_version: ExtensionProperties, +} +impl ::std::default::Default for VideoEncodeH265CapabilitiesEXT { + fn default() -> Self { + Self { + s_type: StructureType::VIDEO_ENCODE_H265_CAPABILITIES_EXT, + p_next: ::std::ptr::null(), + flags: VideoEncodeH265CapabilityFlagsEXT::default(), + input_mode_flags: VideoEncodeH265InputModeFlagsEXT::default(), + output_mode_flags: VideoEncodeH265OutputModeFlagsEXT::default(), + ctb_sizes: VideoEncodeH265CtbSizeFlagsEXT::default(), + input_image_data_alignment: Extent2D::default(), + max_num_l0_reference_for_p: u8::default(), + max_num_l0_reference_for_b: u8::default(), + max_num_l1_reference: u8::default(), + max_num_sub_layers: u8::default(), + quality_level_count: u8::default(), + std_extension_version: ExtensionProperties::default(), + } + } +} +impl VideoEncodeH265CapabilitiesEXT { + pub fn builder<'a>() -> VideoEncodeH265CapabilitiesEXTBuilder<'a> { + VideoEncodeH265CapabilitiesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoEncodeH265CapabilitiesEXTBuilder<'a> { + inner: VideoEncodeH265CapabilitiesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsVideoCapabilitiesKHR for VideoEncodeH265CapabilitiesEXTBuilder<'_> {} +unsafe impl ExtendsVideoCapabilitiesKHR for VideoEncodeH265CapabilitiesEXT {} +impl<'a> ::std::ops::Deref for VideoEncodeH265CapabilitiesEXTBuilder<'a> { + type Target = VideoEncodeH265CapabilitiesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoEncodeH265CapabilitiesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoEncodeH265CapabilitiesEXTBuilder<'a> { + pub fn flags(mut self, flags: VideoEncodeH265CapabilityFlagsEXT) -> Self { + self.inner.flags = flags; + self + } + pub fn input_mode_flags(mut self, input_mode_flags: VideoEncodeH265InputModeFlagsEXT) -> Self { + self.inner.input_mode_flags = input_mode_flags; + self + } + pub fn output_mode_flags( + mut self, + output_mode_flags: VideoEncodeH265OutputModeFlagsEXT, + ) -> Self { + self.inner.output_mode_flags = output_mode_flags; + self + } + pub fn ctb_sizes(mut self, ctb_sizes: VideoEncodeH265CtbSizeFlagsEXT) -> Self { + self.inner.ctb_sizes = ctb_sizes; + self + } + pub fn input_image_data_alignment(mut self, input_image_data_alignment: Extent2D) -> Self { + self.inner.input_image_data_alignment = input_image_data_alignment; + self + } + pub fn max_num_l0_reference_for_p(mut self, max_num_l0_reference_for_p: u8) -> Self { + self.inner.max_num_l0_reference_for_p = max_num_l0_reference_for_p; + self + } + pub fn max_num_l0_reference_for_b(mut self, max_num_l0_reference_for_b: u8) -> Self { + self.inner.max_num_l0_reference_for_b = max_num_l0_reference_for_b; + self + } + pub fn max_num_l1_reference(mut self, max_num_l1_reference: u8) -> Self { + self.inner.max_num_l1_reference = max_num_l1_reference; + self + } + pub fn max_num_sub_layers(mut self, max_num_sub_layers: u8) -> Self { + self.inner.max_num_sub_layers = max_num_sub_layers; + self + } + pub fn quality_level_count(mut self, quality_level_count: u8) -> Self { + self.inner.quality_level_count = quality_level_count; + self + } + pub fn std_extension_version(mut self, std_extension_version: ExtensionProperties) -> Self { + self.inner.std_extension_version = std_extension_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) -> VideoEncodeH265CapabilitiesEXT { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = ""] +pub struct VideoEncodeH265SessionCreateInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: VideoEncodeH265CreateFlagsEXT, + pub p_std_extension_version: *const ExtensionProperties, +} +impl ::std::default::Default for VideoEncodeH265SessionCreateInfoEXT { + fn default() -> Self { + Self { + s_type: StructureType::VIDEO_ENCODE_H265_SESSION_CREATE_INFO_EXT, + p_next: ::std::ptr::null(), + flags: VideoEncodeH265CreateFlagsEXT::default(), + p_std_extension_version: ::std::ptr::null(), + } + } +} +impl VideoEncodeH265SessionCreateInfoEXT { + pub fn builder<'a>() -> VideoEncodeH265SessionCreateInfoEXTBuilder<'a> { + VideoEncodeH265SessionCreateInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoEncodeH265SessionCreateInfoEXTBuilder<'a> { + inner: VideoEncodeH265SessionCreateInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsVideoSessionCreateInfoKHR for VideoEncodeH265SessionCreateInfoEXTBuilder<'_> {} +unsafe impl ExtendsVideoSessionCreateInfoKHR for VideoEncodeH265SessionCreateInfoEXT {} +impl<'a> ::std::ops::Deref for VideoEncodeH265SessionCreateInfoEXTBuilder<'a> { + type Target = VideoEncodeH265SessionCreateInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoEncodeH265SessionCreateInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoEncodeH265SessionCreateInfoEXTBuilder<'a> { + pub fn flags(mut self, flags: VideoEncodeH265CreateFlagsEXT) -> Self { + self.inner.flags = flags; + self + } + pub fn std_extension_version(mut self, std_extension_version: &'a ExtensionProperties) -> Self { + self.inner.p_std_extension_version = std_extension_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) -> VideoEncodeH265SessionCreateInfoEXT { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = ""] +pub struct VideoEncodeH265SessionParametersAddInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub vps_std_count: u32, + pub p_vps_std: *const StdVideoH265VideoParameterSet, + pub sps_std_count: u32, + pub p_sps_std: *const StdVideoH265SequenceParameterSet, + pub pps_std_count: u32, + pub p_pps_std: *const StdVideoH265PictureParameterSet, +} +impl ::std::default::Default for VideoEncodeH265SessionParametersAddInfoEXT { + fn default() -> Self { + Self { + s_type: StructureType::VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT, + p_next: ::std::ptr::null(), + vps_std_count: u32::default(), + p_vps_std: ::std::ptr::null(), + sps_std_count: u32::default(), + p_sps_std: ::std::ptr::null(), + pps_std_count: u32::default(), + p_pps_std: ::std::ptr::null(), + } + } +} +impl VideoEncodeH265SessionParametersAddInfoEXT { + pub fn builder<'a>() -> VideoEncodeH265SessionParametersAddInfoEXTBuilder<'a> { + VideoEncodeH265SessionParametersAddInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoEncodeH265SessionParametersAddInfoEXTBuilder<'a> { + inner: VideoEncodeH265SessionParametersAddInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsVideoSessionParametersUpdateInfoKHR + for VideoEncodeH265SessionParametersAddInfoEXTBuilder<'_> +{ +} +unsafe impl ExtendsVideoSessionParametersUpdateInfoKHR + for VideoEncodeH265SessionParametersAddInfoEXT +{ +} +impl<'a> ::std::ops::Deref for VideoEncodeH265SessionParametersAddInfoEXTBuilder<'a> { + type Target = VideoEncodeH265SessionParametersAddInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoEncodeH265SessionParametersAddInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoEncodeH265SessionParametersAddInfoEXTBuilder<'a> { + pub fn vps_std(mut self, vps_std: &'a [StdVideoH265VideoParameterSet]) -> Self { + self.inner.vps_std_count = vps_std.len() as _; + self.inner.p_vps_std = vps_std.as_ptr(); + self + } + pub fn sps_std(mut self, sps_std: &'a [StdVideoH265SequenceParameterSet]) -> Self { + self.inner.sps_std_count = sps_std.len() as _; + self.inner.p_sps_std = sps_std.as_ptr(); + self + } + pub fn pps_std(mut self, pps_std: &'a [StdVideoH265PictureParameterSet]) -> Self { + self.inner.pps_std_count = pps_std.len() as _; + self.inner.p_pps_std = pps_std.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) -> VideoEncodeH265SessionParametersAddInfoEXT { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = ""] +pub struct VideoEncodeH265SessionParametersCreateInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub max_vps_std_count: u32, + pub max_sps_std_count: u32, + pub max_pps_std_count: u32, + pub p_parameters_add_info: *const VideoEncodeH265SessionParametersAddInfoEXT, +} +impl ::std::default::Default for VideoEncodeH265SessionParametersCreateInfoEXT { + fn default() -> Self { + Self { + s_type: StructureType::VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT, + p_next: ::std::ptr::null(), + max_vps_std_count: u32::default(), + max_sps_std_count: u32::default(), + max_pps_std_count: u32::default(), + p_parameters_add_info: ::std::ptr::null(), + } + } +} +impl VideoEncodeH265SessionParametersCreateInfoEXT { + pub fn builder<'a>() -> VideoEncodeH265SessionParametersCreateInfoEXTBuilder<'a> { + VideoEncodeH265SessionParametersCreateInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoEncodeH265SessionParametersCreateInfoEXTBuilder<'a> { + inner: VideoEncodeH265SessionParametersCreateInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsVideoSessionParametersCreateInfoKHR + for VideoEncodeH265SessionParametersCreateInfoEXTBuilder<'_> +{ +} +unsafe impl ExtendsVideoSessionParametersCreateInfoKHR + for VideoEncodeH265SessionParametersCreateInfoEXT +{ +} +impl<'a> ::std::ops::Deref for VideoEncodeH265SessionParametersCreateInfoEXTBuilder<'a> { + type Target = VideoEncodeH265SessionParametersCreateInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoEncodeH265SessionParametersCreateInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoEncodeH265SessionParametersCreateInfoEXTBuilder<'a> { + pub fn max_vps_std_count(mut self, max_vps_std_count: u32) -> Self { + self.inner.max_vps_std_count = max_vps_std_count; + self + } + pub fn max_sps_std_count(mut self, max_sps_std_count: u32) -> Self { + self.inner.max_sps_std_count = max_sps_std_count; + self + } + pub fn max_pps_std_count(mut self, max_pps_std_count: u32) -> Self { + self.inner.max_pps_std_count = max_pps_std_count; + self + } + pub fn parameters_add_info( + mut self, + parameters_add_info: &'a VideoEncodeH265SessionParametersAddInfoEXT, + ) -> Self { + self.inner.p_parameters_add_info = parameters_add_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) -> VideoEncodeH265SessionParametersCreateInfoEXT { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = ""] +pub struct VideoEncodeH265VclFrameInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub p_reference_final_lists: *const VideoEncodeH265ReferenceListsEXT, + pub nalu_slice_entry_count: u32, + pub p_nalu_slice_entries: *const VideoEncodeH265NaluSliceEXT, + pub p_current_picture_info: *const StdVideoEncodeH265PictureInfo, +} +impl ::std::default::Default for VideoEncodeH265VclFrameInfoEXT { + fn default() -> Self { + Self { + s_type: StructureType::VIDEO_ENCODE_H265_VCL_FRAME_INFO_EXT, + p_next: ::std::ptr::null(), + p_reference_final_lists: ::std::ptr::null(), + nalu_slice_entry_count: u32::default(), + p_nalu_slice_entries: ::std::ptr::null(), + p_current_picture_info: ::std::ptr::null(), + } + } +} +impl VideoEncodeH265VclFrameInfoEXT { + pub fn builder<'a>() -> VideoEncodeH265VclFrameInfoEXTBuilder<'a> { + VideoEncodeH265VclFrameInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoEncodeH265VclFrameInfoEXTBuilder<'a> { + inner: VideoEncodeH265VclFrameInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsVideoEncodeInfoKHR for VideoEncodeH265VclFrameInfoEXTBuilder<'_> {} +unsafe impl ExtendsVideoEncodeInfoKHR for VideoEncodeH265VclFrameInfoEXT {} +impl<'a> ::std::ops::Deref for VideoEncodeH265VclFrameInfoEXTBuilder<'a> { + type Target = VideoEncodeH265VclFrameInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoEncodeH265VclFrameInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoEncodeH265VclFrameInfoEXTBuilder<'a> { + pub fn reference_final_lists( + mut self, + reference_final_lists: &'a VideoEncodeH265ReferenceListsEXT, + ) -> Self { + self.inner.p_reference_final_lists = reference_final_lists; + self + } + pub fn nalu_slice_entries( + mut self, + nalu_slice_entries: &'a [VideoEncodeH265NaluSliceEXT], + ) -> Self { + self.inner.nalu_slice_entry_count = nalu_slice_entries.len() as _; + self.inner.p_nalu_slice_entries = nalu_slice_entries.as_ptr(); + self + } + pub fn current_picture_info( + mut self, + current_picture_info: &'a StdVideoEncodeH265PictureInfo, + ) -> Self { + self.inner.p_current_picture_info = current_picture_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) -> VideoEncodeH265VclFrameInfoEXT { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = ""] +pub struct VideoEncodeH265EmitPictureParametersEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub vps_id: u8, + pub sps_id: u8, + pub emit_vps_enable: Bool32, + pub emit_sps_enable: Bool32, + pub pps_id_entry_count: u32, + pub pps_id_entries: *const u8, +} +impl ::std::default::Default for VideoEncodeH265EmitPictureParametersEXT { + fn default() -> Self { + Self { + s_type: StructureType::VIDEO_ENCODE_H265_EMIT_PICTURE_PARAMETERS_EXT, + p_next: ::std::ptr::null(), + vps_id: u8::default(), + sps_id: u8::default(), + emit_vps_enable: Bool32::default(), + emit_sps_enable: Bool32::default(), + pps_id_entry_count: u32::default(), + pps_id_entries: ::std::ptr::null(), + } + } +} +impl VideoEncodeH265EmitPictureParametersEXT { + pub fn builder<'a>() -> VideoEncodeH265EmitPictureParametersEXTBuilder<'a> { + VideoEncodeH265EmitPictureParametersEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoEncodeH265EmitPictureParametersEXTBuilder<'a> { + inner: VideoEncodeH265EmitPictureParametersEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsVideoEncodeInfoKHR for VideoEncodeH265EmitPictureParametersEXTBuilder<'_> {} +unsafe impl ExtendsVideoEncodeInfoKHR for VideoEncodeH265EmitPictureParametersEXT {} +impl<'a> ::std::ops::Deref for VideoEncodeH265EmitPictureParametersEXTBuilder<'a> { + type Target = VideoEncodeH265EmitPictureParametersEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoEncodeH265EmitPictureParametersEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoEncodeH265EmitPictureParametersEXTBuilder<'a> { + pub fn vps_id(mut self, vps_id: u8) -> Self { + self.inner.vps_id = vps_id; + self + } + pub fn sps_id(mut self, sps_id: u8) -> Self { + self.inner.sps_id = sps_id; + self + } + pub fn emit_vps_enable(mut self, emit_vps_enable: bool) -> Self { + self.inner.emit_vps_enable = emit_vps_enable.into(); + self + } + pub fn emit_sps_enable(mut self, emit_sps_enable: bool) -> Self { + self.inner.emit_sps_enable = emit_sps_enable.into(); + self + } + pub fn pps_id_entries(mut self, pps_id_entries: &'a [u8]) -> Self { + self.inner.pps_id_entry_count = pps_id_entries.len() as _; + self.inner.pps_id_entries = pps_id_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) -> VideoEncodeH265EmitPictureParametersEXT { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = ""] +pub struct VideoEncodeH265NaluSliceEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub ctb_count: u32, + pub p_reference_final_lists: *const VideoEncodeH265ReferenceListsEXT, + pub p_slice_header_std: *const StdVideoEncodeH265SliceHeader, +} +impl ::std::default::Default for VideoEncodeH265NaluSliceEXT { + fn default() -> Self { + Self { + s_type: StructureType::VIDEO_ENCODE_H265_NALU_SLICE_EXT, + p_next: ::std::ptr::null(), + ctb_count: u32::default(), + p_reference_final_lists: ::std::ptr::null(), + p_slice_header_std: ::std::ptr::null(), + } + } +} +impl VideoEncodeH265NaluSliceEXT { + pub fn builder<'a>() -> VideoEncodeH265NaluSliceEXTBuilder<'a> { + VideoEncodeH265NaluSliceEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoEncodeH265NaluSliceEXTBuilder<'a> { + inner: VideoEncodeH265NaluSliceEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for VideoEncodeH265NaluSliceEXTBuilder<'a> { + type Target = VideoEncodeH265NaluSliceEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoEncodeH265NaluSliceEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoEncodeH265NaluSliceEXTBuilder<'a> { + pub fn ctb_count(mut self, ctb_count: u32) -> Self { + self.inner.ctb_count = ctb_count; + self + } + pub fn reference_final_lists( + mut self, + reference_final_lists: &'a VideoEncodeH265ReferenceListsEXT, + ) -> Self { + self.inner.p_reference_final_lists = reference_final_lists; + self + } + pub fn slice_header_std(mut self, slice_header_std: &'a StdVideoEncodeH265SliceHeader) -> Self { + self.inner.p_slice_header_std = slice_header_std; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoEncodeH265NaluSliceEXT { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = ""] +pub struct VideoEncodeH265ProfileEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub std_profile_idc: StdVideoH265ProfileIdc, +} +impl ::std::default::Default for VideoEncodeH265ProfileEXT { + fn default() -> Self { + Self { + s_type: StructureType::VIDEO_ENCODE_H265_PROFILE_EXT, + p_next: ::std::ptr::null(), + std_profile_idc: StdVideoH265ProfileIdc::default(), + } + } +} +impl VideoEncodeH265ProfileEXT { + pub fn builder<'a>() -> VideoEncodeH265ProfileEXTBuilder<'a> { + VideoEncodeH265ProfileEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoEncodeH265ProfileEXTBuilder<'a> { + inner: VideoEncodeH265ProfileEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsVideoProfileKHR for VideoEncodeH265ProfileEXTBuilder<'_> {} +unsafe impl ExtendsVideoProfileKHR for VideoEncodeH265ProfileEXT {} +unsafe impl ExtendsQueryPoolCreateInfo for VideoEncodeH265ProfileEXTBuilder<'_> {} +unsafe impl ExtendsQueryPoolCreateInfo for VideoEncodeH265ProfileEXT {} +unsafe impl ExtendsFormatProperties2 for VideoEncodeH265ProfileEXTBuilder<'_> {} +unsafe impl ExtendsFormatProperties2 for VideoEncodeH265ProfileEXT {} +unsafe impl ExtendsImageCreateInfo for VideoEncodeH265ProfileEXTBuilder<'_> {} +unsafe impl ExtendsImageCreateInfo for VideoEncodeH265ProfileEXT {} +unsafe impl ExtendsImageViewCreateInfo for VideoEncodeH265ProfileEXTBuilder<'_> {} +unsafe impl ExtendsImageViewCreateInfo for VideoEncodeH265ProfileEXT {} +unsafe impl ExtendsBufferCreateInfo for VideoEncodeH265ProfileEXTBuilder<'_> {} +unsafe impl ExtendsBufferCreateInfo for VideoEncodeH265ProfileEXT {} +impl<'a> ::std::ops::Deref for VideoEncodeH265ProfileEXTBuilder<'a> { + type Target = VideoEncodeH265ProfileEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoEncodeH265ProfileEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoEncodeH265ProfileEXTBuilder<'a> { + pub fn std_profile_idc(mut self, std_profile_idc: StdVideoH265ProfileIdc) -> Self { + self.inner.std_profile_idc = std_profile_idc; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoEncodeH265ProfileEXT { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = ""] +pub struct VideoEncodeH265DpbSlotInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub slot_index: i8, + pub p_std_reference_info: *const StdVideoEncodeH265ReferenceInfo, +} +impl ::std::default::Default for VideoEncodeH265DpbSlotInfoEXT { + fn default() -> Self { + Self { + s_type: StructureType::VIDEO_ENCODE_H265_DPB_SLOT_INFO_EXT, + p_next: ::std::ptr::null(), + slot_index: i8::default(), + p_std_reference_info: ::std::ptr::null(), + } + } +} +impl VideoEncodeH265DpbSlotInfoEXT { + pub fn builder<'a>() -> VideoEncodeH265DpbSlotInfoEXTBuilder<'a> { + VideoEncodeH265DpbSlotInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoEncodeH265DpbSlotInfoEXTBuilder<'a> { + inner: VideoEncodeH265DpbSlotInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for VideoEncodeH265DpbSlotInfoEXTBuilder<'a> { + type Target = VideoEncodeH265DpbSlotInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoEncodeH265DpbSlotInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoEncodeH265DpbSlotInfoEXTBuilder<'a> { + pub fn slot_index(mut self, slot_index: i8) -> Self { + self.inner.slot_index = slot_index; + self + } + pub fn std_reference_info( + mut self, + std_reference_info: &'a StdVideoEncodeH265ReferenceInfo, + ) -> Self { + self.inner.p_std_reference_info = std_reference_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) -> VideoEncodeH265DpbSlotInfoEXT { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = ""] +pub struct VideoEncodeH265ReferenceListsEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub reference_list0_entry_count: u8, + pub p_reference_list0_entries: *const VideoEncodeH265DpbSlotInfoEXT, + pub reference_list1_entry_count: u8, + pub p_reference_list1_entries: *const VideoEncodeH265DpbSlotInfoEXT, + pub p_reference_modifications: *const StdVideoEncodeH265ReferenceModifications, +} +impl ::std::default::Default for VideoEncodeH265ReferenceListsEXT { + fn default() -> Self { + Self { + s_type: StructureType::VIDEO_ENCODE_H265_REFERENCE_LISTS_EXT, + p_next: ::std::ptr::null(), + reference_list0_entry_count: u8::default(), + p_reference_list0_entries: ::std::ptr::null(), + reference_list1_entry_count: u8::default(), + p_reference_list1_entries: ::std::ptr::null(), + p_reference_modifications: ::std::ptr::null(), + } + } +} +impl VideoEncodeH265ReferenceListsEXT { + pub fn builder<'a>() -> VideoEncodeH265ReferenceListsEXTBuilder<'a> { + VideoEncodeH265ReferenceListsEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoEncodeH265ReferenceListsEXTBuilder<'a> { + inner: VideoEncodeH265ReferenceListsEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for VideoEncodeH265ReferenceListsEXTBuilder<'a> { + type Target = VideoEncodeH265ReferenceListsEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoEncodeH265ReferenceListsEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoEncodeH265ReferenceListsEXTBuilder<'a> { + pub fn reference_list0_entries( + mut self, + reference_list0_entries: &'a [VideoEncodeH265DpbSlotInfoEXT], + ) -> Self { + self.inner.reference_list0_entry_count = reference_list0_entries.len() as _; + self.inner.p_reference_list0_entries = reference_list0_entries.as_ptr(); + self + } + pub fn reference_list1_entries( + mut self, + reference_list1_entries: &'a [VideoEncodeH265DpbSlotInfoEXT], + ) -> Self { + self.inner.reference_list1_entry_count = reference_list1_entries.len() as _; + self.inner.p_reference_list1_entries = reference_list1_entries.as_ptr(); + self + } + pub fn reference_modifications( + mut self, + reference_modifications: &'a StdVideoEncodeH265ReferenceModifications, + ) -> Self { + self.inner.p_reference_modifications = reference_modifications; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoEncodeH265ReferenceListsEXT { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] #[doc = ""] pub struct PhysicalDeviceInheritedViewportScissorFeaturesNV { pub s_type: StructureType, @@ -50169,12 +51351,9 @@ impl<'a> ::std::ops::DerefMut for CuModuleCreateInfoNVXBuilder<'a> { } } impl<'a> CuModuleCreateInfoNVXBuilder<'a> { - pub fn data_size(mut self, data_size: usize) -> Self { - self.inner.data_size = data_size; - self - } - pub fn data(mut self, data: *const c_void) -> Self { - self.inner.p_data = data; + pub fn data(mut self, data: &'a [u8]) -> Self { + 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"] @@ -51328,3 +52507,1809 @@ impl<'a> MemoryGetRemoteAddressInfoNVBuilder<'a> { self.inner } } +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = ""] +pub struct ImportMemoryBufferCollectionFUCHSIA { + pub s_type: StructureType, + pub p_next: *const c_void, + pub collection: BufferCollectionFUCHSIA, + pub index: u32, +} +impl ::std::default::Default for ImportMemoryBufferCollectionFUCHSIA { + fn default() -> Self { + Self { + s_type: StructureType::IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA, + p_next: ::std::ptr::null(), + collection: BufferCollectionFUCHSIA::default(), + index: u32::default(), + } + } +} +impl ImportMemoryBufferCollectionFUCHSIA { + pub fn builder<'a>() -> ImportMemoryBufferCollectionFUCHSIABuilder<'a> { + ImportMemoryBufferCollectionFUCHSIABuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImportMemoryBufferCollectionFUCHSIABuilder<'a> { + inner: ImportMemoryBufferCollectionFUCHSIA, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryBufferCollectionFUCHSIABuilder<'_> {} +unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryBufferCollectionFUCHSIA {} +impl<'a> ::std::ops::Deref for ImportMemoryBufferCollectionFUCHSIABuilder<'a> { + type Target = ImportMemoryBufferCollectionFUCHSIA; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImportMemoryBufferCollectionFUCHSIABuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImportMemoryBufferCollectionFUCHSIABuilder<'a> { + pub fn collection(mut self, collection: BufferCollectionFUCHSIA) -> Self { + self.inner.collection = collection; + self + } + pub fn index(mut self, index: u32) -> Self { + self.inner.index = 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) -> ImportMemoryBufferCollectionFUCHSIA { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = ""] +pub struct BufferCollectionImageCreateInfoFUCHSIA { + pub s_type: StructureType, + pub p_next: *const c_void, + pub collection: BufferCollectionFUCHSIA, + pub index: u32, +} +impl ::std::default::Default for BufferCollectionImageCreateInfoFUCHSIA { + fn default() -> Self { + Self { + s_type: StructureType::BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA, + p_next: ::std::ptr::null(), + collection: BufferCollectionFUCHSIA::default(), + index: u32::default(), + } + } +} +impl BufferCollectionImageCreateInfoFUCHSIA { + pub fn builder<'a>() -> BufferCollectionImageCreateInfoFUCHSIABuilder<'a> { + BufferCollectionImageCreateInfoFUCHSIABuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct BufferCollectionImageCreateInfoFUCHSIABuilder<'a> { + inner: BufferCollectionImageCreateInfoFUCHSIA, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsImageCreateInfo for BufferCollectionImageCreateInfoFUCHSIABuilder<'_> {} +unsafe impl ExtendsImageCreateInfo for BufferCollectionImageCreateInfoFUCHSIA {} +impl<'a> ::std::ops::Deref for BufferCollectionImageCreateInfoFUCHSIABuilder<'a> { + type Target = BufferCollectionImageCreateInfoFUCHSIA; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for BufferCollectionImageCreateInfoFUCHSIABuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> BufferCollectionImageCreateInfoFUCHSIABuilder<'a> { + pub fn collection(mut self, collection: BufferCollectionFUCHSIA) -> Self { + self.inner.collection = collection; + self + } + pub fn index(mut self, index: u32) -> Self { + self.inner.index = 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) -> BufferCollectionImageCreateInfoFUCHSIA { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = ""] +pub struct BufferCollectionBufferCreateInfoFUCHSIA { + pub s_type: StructureType, + pub p_next: *const c_void, + pub collection: BufferCollectionFUCHSIA, + pub index: u32, +} +impl ::std::default::Default for BufferCollectionBufferCreateInfoFUCHSIA { + fn default() -> Self { + Self { + s_type: StructureType::BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA, + p_next: ::std::ptr::null(), + collection: BufferCollectionFUCHSIA::default(), + index: u32::default(), + } + } +} +impl BufferCollectionBufferCreateInfoFUCHSIA { + pub fn builder<'a>() -> BufferCollectionBufferCreateInfoFUCHSIABuilder<'a> { + BufferCollectionBufferCreateInfoFUCHSIABuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct BufferCollectionBufferCreateInfoFUCHSIABuilder<'a> { + inner: BufferCollectionBufferCreateInfoFUCHSIA, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsBufferCreateInfo for BufferCollectionBufferCreateInfoFUCHSIABuilder<'_> {} +unsafe impl ExtendsBufferCreateInfo for BufferCollectionBufferCreateInfoFUCHSIA {} +impl<'a> ::std::ops::Deref for BufferCollectionBufferCreateInfoFUCHSIABuilder<'a> { + type Target = BufferCollectionBufferCreateInfoFUCHSIA; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for BufferCollectionBufferCreateInfoFUCHSIABuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> BufferCollectionBufferCreateInfoFUCHSIABuilder<'a> { + pub fn collection(mut self, collection: BufferCollectionFUCHSIA) -> Self { + self.inner.collection = collection; + self + } + pub fn index(mut self, index: u32) -> Self { + self.inner.index = 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) -> BufferCollectionBufferCreateInfoFUCHSIA { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = ""] +pub struct BufferCollectionCreateInfoFUCHSIA { + pub s_type: StructureType, + pub p_next: *const c_void, + pub collection_token: zx_handle_t, +} +impl ::std::default::Default for BufferCollectionCreateInfoFUCHSIA { + fn default() -> Self { + Self { + s_type: StructureType::BUFFER_COLLECTION_CREATE_INFO_FUCHSIA, + p_next: ::std::ptr::null(), + collection_token: zx_handle_t::default(), + } + } +} +impl BufferCollectionCreateInfoFUCHSIA { + pub fn builder<'a>() -> BufferCollectionCreateInfoFUCHSIABuilder<'a> { + BufferCollectionCreateInfoFUCHSIABuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct BufferCollectionCreateInfoFUCHSIABuilder<'a> { + inner: BufferCollectionCreateInfoFUCHSIA, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for BufferCollectionCreateInfoFUCHSIABuilder<'a> { + type Target = BufferCollectionCreateInfoFUCHSIA; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for BufferCollectionCreateInfoFUCHSIABuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> BufferCollectionCreateInfoFUCHSIABuilder<'a> { + pub fn collection_token(mut self, collection_token: zx_handle_t) -> Self { + self.inner.collection_token = collection_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) -> BufferCollectionCreateInfoFUCHSIA { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = ""] +pub struct BufferCollectionPropertiesFUCHSIA { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub memory_type_bits: u32, + pub buffer_count: u32, + pub create_info_index: u32, + pub sysmem_pixel_format: u64, + pub format_features: FormatFeatureFlags, + pub sysmem_color_space_index: SysmemColorSpaceFUCHSIA, + 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 BufferCollectionPropertiesFUCHSIA { + fn default() -> Self { + Self { + s_type: StructureType::BUFFER_COLLECTION_PROPERTIES_FUCHSIA, + p_next: ::std::ptr::null_mut(), + memory_type_bits: u32::default(), + buffer_count: u32::default(), + create_info_index: u32::default(), + sysmem_pixel_format: u64::default(), + format_features: FormatFeatureFlags::default(), + sysmem_color_space_index: SysmemColorSpaceFUCHSIA::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 BufferCollectionPropertiesFUCHSIA { + pub fn builder<'a>() -> BufferCollectionPropertiesFUCHSIABuilder<'a> { + BufferCollectionPropertiesFUCHSIABuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct BufferCollectionPropertiesFUCHSIABuilder<'a> { + inner: BufferCollectionPropertiesFUCHSIA, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for BufferCollectionPropertiesFUCHSIABuilder<'a> { + type Target = BufferCollectionPropertiesFUCHSIA; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for BufferCollectionPropertiesFUCHSIABuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> BufferCollectionPropertiesFUCHSIABuilder<'a> { + pub fn memory_type_bits(mut self, memory_type_bits: u32) -> Self { + self.inner.memory_type_bits = memory_type_bits; + self + } + pub fn buffer_count(mut self, buffer_count: u32) -> Self { + self.inner.buffer_count = buffer_count; + self + } + pub fn create_info_index(mut self, create_info_index: u32) -> Self { + self.inner.create_info_index = create_info_index; + self + } + pub fn sysmem_pixel_format(mut self, sysmem_pixel_format: u64) -> Self { + self.inner.sysmem_pixel_format = sysmem_pixel_format; + self + } + pub fn format_features(mut self, format_features: FormatFeatureFlags) -> Self { + self.inner.format_features = format_features; + self + } + pub fn sysmem_color_space_index( + mut self, + sysmem_color_space_index: SysmemColorSpaceFUCHSIA, + ) -> Self { + self.inner.sysmem_color_space_index = sysmem_color_space_index; + self + } + pub fn sampler_ycbcr_conversion_components( + mut self, + sampler_ycbcr_conversion_components: ComponentMapping, + ) -> Self { + self.inner.sampler_ycbcr_conversion_components = sampler_ycbcr_conversion_components; + self + } + pub fn suggested_ycbcr_model( + mut self, + suggested_ycbcr_model: SamplerYcbcrModelConversion, + ) -> Self { + self.inner.suggested_ycbcr_model = suggested_ycbcr_model; + self + } + pub fn suggested_ycbcr_range(mut self, suggested_ycbcr_range: SamplerYcbcrRange) -> Self { + self.inner.suggested_ycbcr_range = suggested_ycbcr_range; + self + } + pub fn suggested_x_chroma_offset(mut self, suggested_x_chroma_offset: ChromaLocation) -> Self { + self.inner.suggested_x_chroma_offset = suggested_x_chroma_offset; + self + } + pub fn suggested_y_chroma_offset(mut self, suggested_y_chroma_offset: ChromaLocation) -> Self { + 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) -> BufferCollectionPropertiesFUCHSIA { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = ""] +pub struct BufferConstraintsInfoFUCHSIA { + pub s_type: StructureType, + pub p_next: *const c_void, + pub create_info: BufferCreateInfo, + pub required_format_features: FormatFeatureFlags, + pub buffer_collection_constraints: BufferCollectionConstraintsInfoFUCHSIA, +} +impl ::std::default::Default for BufferConstraintsInfoFUCHSIA { + fn default() -> Self { + Self { + s_type: StructureType::BUFFER_CONSTRAINTS_INFO_FUCHSIA, + p_next: ::std::ptr::null(), + create_info: BufferCreateInfo::default(), + required_format_features: FormatFeatureFlags::default(), + buffer_collection_constraints: BufferCollectionConstraintsInfoFUCHSIA::default(), + } + } +} +impl BufferConstraintsInfoFUCHSIA { + pub fn builder<'a>() -> BufferConstraintsInfoFUCHSIABuilder<'a> { + BufferConstraintsInfoFUCHSIABuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct BufferConstraintsInfoFUCHSIABuilder<'a> { + inner: BufferConstraintsInfoFUCHSIA, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for BufferConstraintsInfoFUCHSIABuilder<'a> { + type Target = BufferConstraintsInfoFUCHSIA; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for BufferConstraintsInfoFUCHSIABuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> BufferConstraintsInfoFUCHSIABuilder<'a> { + pub fn create_info(mut self, create_info: BufferCreateInfo) -> Self { + self.inner.create_info = create_info; + self + } + pub fn required_format_features( + mut self, + required_format_features: FormatFeatureFlags, + ) -> Self { + self.inner.required_format_features = required_format_features; + self + } + pub fn buffer_collection_constraints( + mut self, + buffer_collection_constraints: BufferCollectionConstraintsInfoFUCHSIA, + ) -> Self { + self.inner.buffer_collection_constraints = buffer_collection_constraints; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> BufferConstraintsInfoFUCHSIA { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = ""] +pub struct SysmemColorSpaceFUCHSIA { + pub s_type: StructureType, + pub p_next: *const c_void, + pub color_space: u32, +} +impl ::std::default::Default for SysmemColorSpaceFUCHSIA { + fn default() -> Self { + Self { + s_type: StructureType::SYSMEM_COLOR_SPACE_FUCHSIA, + p_next: ::std::ptr::null(), + color_space: u32::default(), + } + } +} +impl SysmemColorSpaceFUCHSIA { + pub fn builder<'a>() -> SysmemColorSpaceFUCHSIABuilder<'a> { + SysmemColorSpaceFUCHSIABuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SysmemColorSpaceFUCHSIABuilder<'a> { + inner: SysmemColorSpaceFUCHSIA, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for SysmemColorSpaceFUCHSIABuilder<'a> { + type Target = SysmemColorSpaceFUCHSIA; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SysmemColorSpaceFUCHSIABuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SysmemColorSpaceFUCHSIABuilder<'a> { + pub fn color_space(mut self, color_space: u32) -> Self { + 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) -> SysmemColorSpaceFUCHSIA { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = ""] +pub struct ImageFormatConstraintsInfoFUCHSIA { + pub s_type: StructureType, + pub p_next: *const c_void, + pub image_create_info: ImageCreateInfo, + pub required_format_features: FormatFeatureFlags, + pub flags: ImageFormatConstraintsFlagsFUCHSIA, + pub sysmem_pixel_format: u64, + pub color_space_count: u32, + pub p_color_spaces: *const SysmemColorSpaceFUCHSIA, +} +impl ::std::default::Default for ImageFormatConstraintsInfoFUCHSIA { + fn default() -> Self { + Self { + s_type: StructureType::IMAGE_FORMAT_CONSTRAINTS_INFO_FUCHSIA, + p_next: ::std::ptr::null(), + image_create_info: ImageCreateInfo::default(), + required_format_features: FormatFeatureFlags::default(), + flags: ImageFormatConstraintsFlagsFUCHSIA::default(), + sysmem_pixel_format: u64::default(), + color_space_count: u32::default(), + p_color_spaces: ::std::ptr::null(), + } + } +} +impl ImageFormatConstraintsInfoFUCHSIA { + pub fn builder<'a>() -> ImageFormatConstraintsInfoFUCHSIABuilder<'a> { + ImageFormatConstraintsInfoFUCHSIABuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImageFormatConstraintsInfoFUCHSIABuilder<'a> { + inner: ImageFormatConstraintsInfoFUCHSIA, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ImageFormatConstraintsInfoFUCHSIABuilder<'a> { + type Target = ImageFormatConstraintsInfoFUCHSIA; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImageFormatConstraintsInfoFUCHSIABuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImageFormatConstraintsInfoFUCHSIABuilder<'a> { + pub fn image_create_info(mut self, image_create_info: ImageCreateInfo) -> Self { + self.inner.image_create_info = image_create_info; + self + } + pub fn required_format_features( + mut self, + required_format_features: FormatFeatureFlags, + ) -> Self { + self.inner.required_format_features = required_format_features; + self + } + pub fn flags(mut self, flags: ImageFormatConstraintsFlagsFUCHSIA) -> Self { + self.inner.flags = flags; + self + } + pub fn sysmem_pixel_format(mut self, sysmem_pixel_format: u64) -> Self { + self.inner.sysmem_pixel_format = sysmem_pixel_format; + self + } + pub fn color_space_count(mut self, color_space_count: u32) -> Self { + self.inner.color_space_count = color_space_count; + self + } + pub fn color_spaces(mut self, color_spaces: &'a SysmemColorSpaceFUCHSIA) -> Self { + self.inner.p_color_spaces = color_spaces; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImageFormatConstraintsInfoFUCHSIA { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = ""] +pub struct ImageConstraintsInfoFUCHSIA { + pub s_type: StructureType, + pub p_next: *const c_void, + pub format_constraints_count: u32, + pub p_format_constraints: *const ImageFormatConstraintsInfoFUCHSIA, + pub buffer_collection_constraints: BufferCollectionConstraintsInfoFUCHSIA, + pub flags: ImageConstraintsInfoFlagsFUCHSIA, +} +impl ::std::default::Default for ImageConstraintsInfoFUCHSIA { + fn default() -> Self { + Self { + s_type: StructureType::IMAGE_CONSTRAINTS_INFO_FUCHSIA, + p_next: ::std::ptr::null(), + format_constraints_count: u32::default(), + p_format_constraints: ::std::ptr::null(), + buffer_collection_constraints: BufferCollectionConstraintsInfoFUCHSIA::default(), + flags: ImageConstraintsInfoFlagsFUCHSIA::default(), + } + } +} +impl ImageConstraintsInfoFUCHSIA { + pub fn builder<'a>() -> ImageConstraintsInfoFUCHSIABuilder<'a> { + ImageConstraintsInfoFUCHSIABuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImageConstraintsInfoFUCHSIABuilder<'a> { + inner: ImageConstraintsInfoFUCHSIA, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ImageConstraintsInfoFUCHSIABuilder<'a> { + type Target = ImageConstraintsInfoFUCHSIA; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImageConstraintsInfoFUCHSIABuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImageConstraintsInfoFUCHSIABuilder<'a> { + pub fn format_constraints( + mut self, + format_constraints: &'a [ImageFormatConstraintsInfoFUCHSIA], + ) -> Self { + self.inner.format_constraints_count = format_constraints.len() as _; + self.inner.p_format_constraints = format_constraints.as_ptr(); + self + } + pub fn buffer_collection_constraints( + mut self, + buffer_collection_constraints: BufferCollectionConstraintsInfoFUCHSIA, + ) -> Self { + self.inner.buffer_collection_constraints = buffer_collection_constraints; + self + } + pub fn flags(mut self, flags: ImageConstraintsInfoFlagsFUCHSIA) -> Self { + 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) -> ImageConstraintsInfoFUCHSIA { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = ""] +pub struct BufferCollectionConstraintsInfoFUCHSIA { + pub s_type: StructureType, + pub p_next: *const c_void, + pub min_buffer_count: u32, + pub max_buffer_count: u32, + pub min_buffer_count_for_camping: u32, + pub min_buffer_count_for_dedicated_slack: u32, + pub min_buffer_count_for_shared_slack: u32, +} +impl ::std::default::Default for BufferCollectionConstraintsInfoFUCHSIA { + fn default() -> Self { + Self { + s_type: StructureType::BUFFER_COLLECTION_CONSTRAINTS_INFO_FUCHSIA, + p_next: ::std::ptr::null(), + min_buffer_count: u32::default(), + max_buffer_count: u32::default(), + min_buffer_count_for_camping: u32::default(), + min_buffer_count_for_dedicated_slack: u32::default(), + min_buffer_count_for_shared_slack: u32::default(), + } + } +} +impl BufferCollectionConstraintsInfoFUCHSIA { + pub fn builder<'a>() -> BufferCollectionConstraintsInfoFUCHSIABuilder<'a> { + BufferCollectionConstraintsInfoFUCHSIABuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct BufferCollectionConstraintsInfoFUCHSIABuilder<'a> { + inner: BufferCollectionConstraintsInfoFUCHSIA, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for BufferCollectionConstraintsInfoFUCHSIABuilder<'a> { + type Target = BufferCollectionConstraintsInfoFUCHSIA; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for BufferCollectionConstraintsInfoFUCHSIABuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> BufferCollectionConstraintsInfoFUCHSIABuilder<'a> { + pub fn min_buffer_count(mut self, min_buffer_count: u32) -> Self { + self.inner.min_buffer_count = min_buffer_count; + self + } + pub fn max_buffer_count(mut self, max_buffer_count: u32) -> Self { + self.inner.max_buffer_count = max_buffer_count; + self + } + pub fn min_buffer_count_for_camping(mut self, min_buffer_count_for_camping: u32) -> Self { + self.inner.min_buffer_count_for_camping = min_buffer_count_for_camping; + self + } + pub fn min_buffer_count_for_dedicated_slack( + mut self, + min_buffer_count_for_dedicated_slack: u32, + ) -> Self { + self.inner.min_buffer_count_for_dedicated_slack = min_buffer_count_for_dedicated_slack; + self + } + pub fn min_buffer_count_for_shared_slack( + mut self, + min_buffer_count_for_shared_slack: u32, + ) -> Self { + self.inner.min_buffer_count_for_shared_slack = min_buffer_count_for_shared_slack; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> BufferCollectionConstraintsInfoFUCHSIA { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = ""] +pub struct PhysicalDeviceRGBA10X6FormatsFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub format_rgba10x6_without_y_cb_cr_sampler: Bool32, +} +impl ::std::default::Default for PhysicalDeviceRGBA10X6FormatsFeaturesEXT { + fn default() -> Self { + Self { + s_type: StructureType::PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT, + p_next: ::std::ptr::null_mut(), + format_rgba10x6_without_y_cb_cr_sampler: Bool32::default(), + } + } +} +impl PhysicalDeviceRGBA10X6FormatsFeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceRGBA10X6FormatsFeaturesEXTBuilder<'a> { + PhysicalDeviceRGBA10X6FormatsFeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceRGBA10X6FormatsFeaturesEXTBuilder<'a> { + inner: PhysicalDeviceRGBA10X6FormatsFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceRGBA10X6FormatsFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceRGBA10X6FormatsFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRGBA10X6FormatsFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRGBA10X6FormatsFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceRGBA10X6FormatsFeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceRGBA10X6FormatsFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceRGBA10X6FormatsFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceRGBA10X6FormatsFeaturesEXTBuilder<'a> { + pub fn format_rgba10x6_without_y_cb_cr_sampler( + mut self, + format_rgba10x6_without_y_cb_cr_sampler: bool, + ) -> Self { + self.inner.format_rgba10x6_without_y_cb_cr_sampler = + format_rgba10x6_without_y_cb_cr_sampler.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) -> PhysicalDeviceRGBA10X6FormatsFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = ""] +pub struct FormatProperties3KHR { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub linear_tiling_features: FormatFeatureFlags2KHR, + pub optimal_tiling_features: FormatFeatureFlags2KHR, + pub buffer_features: FormatFeatureFlags2KHR, +} +impl ::std::default::Default for FormatProperties3KHR { + fn default() -> Self { + Self { + s_type: StructureType::FORMAT_PROPERTIES_3_KHR, + p_next: ::std::ptr::null_mut(), + linear_tiling_features: FormatFeatureFlags2KHR::default(), + optimal_tiling_features: FormatFeatureFlags2KHR::default(), + buffer_features: FormatFeatureFlags2KHR::default(), + } + } +} +impl FormatProperties3KHR { + pub fn builder<'a>() -> FormatProperties3KHRBuilder<'a> { + FormatProperties3KHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct FormatProperties3KHRBuilder<'a> { + inner: FormatProperties3KHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsFormatProperties2 for FormatProperties3KHRBuilder<'_> {} +unsafe impl ExtendsFormatProperties2 for FormatProperties3KHR {} +impl<'a> ::std::ops::Deref for FormatProperties3KHRBuilder<'a> { + type Target = FormatProperties3KHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for FormatProperties3KHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> FormatProperties3KHRBuilder<'a> { + pub fn linear_tiling_features( + mut self, + linear_tiling_features: FormatFeatureFlags2KHR, + ) -> Self { + self.inner.linear_tiling_features = linear_tiling_features; + self + } + pub fn optimal_tiling_features( + mut self, + optimal_tiling_features: FormatFeatureFlags2KHR, + ) -> Self { + self.inner.optimal_tiling_features = optimal_tiling_features; + self + } + pub fn buffer_features(mut self, buffer_features: FormatFeatureFlags2KHR) -> Self { + 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) -> FormatProperties3KHR { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = ""] +pub struct DrmFormatModifierPropertiesList2EXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub drm_format_modifier_count: u32, + pub p_drm_format_modifier_properties: *mut DrmFormatModifierProperties2EXT, +} +impl ::std::default::Default for DrmFormatModifierPropertiesList2EXT { + fn default() -> Self { + Self { + s_type: StructureType::DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT, + p_next: ::std::ptr::null_mut(), + drm_format_modifier_count: u32::default(), + p_drm_format_modifier_properties: ::std::ptr::null_mut(), + } + } +} +impl DrmFormatModifierPropertiesList2EXT { + pub fn builder<'a>() -> DrmFormatModifierPropertiesList2EXTBuilder<'a> { + DrmFormatModifierPropertiesList2EXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DrmFormatModifierPropertiesList2EXTBuilder<'a> { + inner: DrmFormatModifierPropertiesList2EXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsFormatProperties2 for DrmFormatModifierPropertiesList2EXTBuilder<'_> {} +unsafe impl ExtendsFormatProperties2 for DrmFormatModifierPropertiesList2EXT {} +impl<'a> ::std::ops::Deref for DrmFormatModifierPropertiesList2EXTBuilder<'a> { + type Target = DrmFormatModifierPropertiesList2EXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DrmFormatModifierPropertiesList2EXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DrmFormatModifierPropertiesList2EXTBuilder<'a> { + pub fn drm_format_modifier_properties( + mut self, + drm_format_modifier_properties: &'a mut [DrmFormatModifierProperties2EXT], + ) -> Self { + 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) -> DrmFormatModifierPropertiesList2EXT { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Default, Debug)] +#[doc = ""] +pub struct DrmFormatModifierProperties2EXT { + pub drm_format_modifier: u64, + pub drm_format_modifier_plane_count: u32, + pub drm_format_modifier_tiling_features: FormatFeatureFlags2KHR, +} +impl DrmFormatModifierProperties2EXT { + pub fn builder<'a>() -> DrmFormatModifierProperties2EXTBuilder<'a> { + DrmFormatModifierProperties2EXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DrmFormatModifierProperties2EXTBuilder<'a> { + inner: DrmFormatModifierProperties2EXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DrmFormatModifierProperties2EXTBuilder<'a> { + type Target = DrmFormatModifierProperties2EXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DrmFormatModifierProperties2EXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DrmFormatModifierProperties2EXTBuilder<'a> { + pub fn drm_format_modifier(mut self, drm_format_modifier: u64) -> Self { + self.inner.drm_format_modifier = drm_format_modifier; + self + } + pub fn drm_format_modifier_plane_count(mut self, drm_format_modifier_plane_count: u32) -> Self { + 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: FormatFeatureFlags2KHR, + ) -> Self { + 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) -> DrmFormatModifierProperties2EXT { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = ""] +pub struct AndroidHardwareBufferFormatProperties2ANDROID { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub format: Format, + pub external_format: u64, + pub format_features: FormatFeatureFlags2KHR, + 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 AndroidHardwareBufferFormatProperties2ANDROID { + fn default() -> Self { + Self { + s_type: StructureType::ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID, + p_next: ::std::ptr::null_mut(), + format: Format::default(), + external_format: u64::default(), + format_features: FormatFeatureFlags2KHR::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 AndroidHardwareBufferFormatProperties2ANDROID { + pub fn builder<'a>() -> AndroidHardwareBufferFormatProperties2ANDROIDBuilder<'a> { + AndroidHardwareBufferFormatProperties2ANDROIDBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct AndroidHardwareBufferFormatProperties2ANDROIDBuilder<'a> { + inner: AndroidHardwareBufferFormatProperties2ANDROID, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsAndroidHardwareBufferPropertiesANDROID + for AndroidHardwareBufferFormatProperties2ANDROIDBuilder<'_> +{ +} +unsafe impl ExtendsAndroidHardwareBufferPropertiesANDROID + for AndroidHardwareBufferFormatProperties2ANDROID +{ +} +impl<'a> ::std::ops::Deref for AndroidHardwareBufferFormatProperties2ANDROIDBuilder<'a> { + type Target = AndroidHardwareBufferFormatProperties2ANDROID; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for AndroidHardwareBufferFormatProperties2ANDROIDBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> AndroidHardwareBufferFormatProperties2ANDROIDBuilder<'a> { + pub fn format(mut self, format: Format) -> Self { + self.inner.format = format; + self + } + pub fn external_format(mut self, external_format: u64) -> Self { + self.inner.external_format = external_format; + self + } + pub fn format_features(mut self, format_features: FormatFeatureFlags2KHR) -> Self { + self.inner.format_features = format_features; + self + } + pub fn sampler_ycbcr_conversion_components( + mut self, + sampler_ycbcr_conversion_components: ComponentMapping, + ) -> Self { + self.inner.sampler_ycbcr_conversion_components = sampler_ycbcr_conversion_components; + self + } + pub fn suggested_ycbcr_model( + mut self, + suggested_ycbcr_model: SamplerYcbcrModelConversion, + ) -> Self { + self.inner.suggested_ycbcr_model = suggested_ycbcr_model; + self + } + pub fn suggested_ycbcr_range(mut self, suggested_ycbcr_range: SamplerYcbcrRange) -> Self { + self.inner.suggested_ycbcr_range = suggested_ycbcr_range; + self + } + pub fn suggested_x_chroma_offset(mut self, suggested_x_chroma_offset: ChromaLocation) -> Self { + self.inner.suggested_x_chroma_offset = suggested_x_chroma_offset; + self + } + pub fn suggested_y_chroma_offset(mut self, suggested_y_chroma_offset: ChromaLocation) -> Self { + 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) -> AndroidHardwareBufferFormatProperties2ANDROID { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = ""] +pub struct PipelineRenderingCreateInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub view_mask: u32, + pub color_attachment_count: u32, + pub p_color_attachment_formats: *const Format, + pub depth_attachment_format: Format, + pub stencil_attachment_format: Format, +} +impl ::std::default::Default for PipelineRenderingCreateInfoKHR { + fn default() -> Self { + Self { + s_type: StructureType::PIPELINE_RENDERING_CREATE_INFO_KHR, + p_next: ::std::ptr::null(), + view_mask: u32::default(), + color_attachment_count: u32::default(), + p_color_attachment_formats: ::std::ptr::null(), + depth_attachment_format: Format::default(), + stencil_attachment_format: Format::default(), + } + } +} +impl PipelineRenderingCreateInfoKHR { + pub fn builder<'a>() -> PipelineRenderingCreateInfoKHRBuilder<'a> { + PipelineRenderingCreateInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PipelineRenderingCreateInfoKHRBuilder<'a> { + inner: PipelineRenderingCreateInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsGraphicsPipelineCreateInfo for PipelineRenderingCreateInfoKHRBuilder<'_> {} +unsafe impl ExtendsGraphicsPipelineCreateInfo for PipelineRenderingCreateInfoKHR {} +impl<'a> ::std::ops::Deref for PipelineRenderingCreateInfoKHRBuilder<'a> { + type Target = PipelineRenderingCreateInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PipelineRenderingCreateInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PipelineRenderingCreateInfoKHRBuilder<'a> { + pub fn view_mask(mut self, view_mask: u32) -> Self { + self.inner.view_mask = view_mask; + self + } + pub fn color_attachment_formats(mut self, color_attachment_formats: &'a [Format]) -> Self { + self.inner.color_attachment_count = color_attachment_formats.len() as _; + self.inner.p_color_attachment_formats = color_attachment_formats.as_ptr(); + self + } + pub fn depth_attachment_format(mut self, depth_attachment_format: Format) -> Self { + self.inner.depth_attachment_format = depth_attachment_format; + self + } + pub fn stencil_attachment_format(mut self, stencil_attachment_format: Format) -> Self { + self.inner.stencil_attachment_format = stencil_attachment_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) -> PipelineRenderingCreateInfoKHR { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = ""] +pub struct RenderingInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: RenderingFlagsKHR, + pub render_area: Rect2D, + pub layer_count: u32, + pub view_mask: u32, + pub color_attachment_count: u32, + pub p_color_attachments: *const RenderingAttachmentInfoKHR, + pub p_depth_attachment: *const RenderingAttachmentInfoKHR, + pub p_stencil_attachment: *const RenderingAttachmentInfoKHR, +} +impl ::std::default::Default for RenderingInfoKHR { + fn default() -> Self { + Self { + s_type: StructureType::RENDERING_INFO_KHR, + p_next: ::std::ptr::null(), + flags: RenderingFlagsKHR::default(), + render_area: Rect2D::default(), + layer_count: u32::default(), + view_mask: u32::default(), + color_attachment_count: u32::default(), + p_color_attachments: ::std::ptr::null(), + p_depth_attachment: ::std::ptr::null(), + p_stencil_attachment: ::std::ptr::null(), + } + } +} +impl RenderingInfoKHR { + pub fn builder<'a>() -> RenderingInfoKHRBuilder<'a> { + RenderingInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct RenderingInfoKHRBuilder<'a> { + inner: RenderingInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsRenderingInfoKHR {} +impl<'a> ::std::ops::Deref for RenderingInfoKHRBuilder<'a> { + type Target = RenderingInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for RenderingInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> RenderingInfoKHRBuilder<'a> { + pub fn flags(mut self, flags: RenderingFlagsKHR) -> Self { + self.inner.flags = flags; + self + } + pub fn render_area(mut self, render_area: Rect2D) -> Self { + self.inner.render_area = render_area; + self + } + pub fn layer_count(mut self, layer_count: u32) -> Self { + self.inner.layer_count = layer_count; + self + } + pub fn view_mask(mut self, view_mask: u32) -> Self { + self.inner.view_mask = view_mask; + self + } + pub fn color_attachments( + mut self, + color_attachments: &'a [RenderingAttachmentInfoKHR], + ) -> Self { + self.inner.color_attachment_count = color_attachments.len() as _; + self.inner.p_color_attachments = color_attachments.as_ptr(); + self + } + pub fn depth_attachment(mut self, depth_attachment: &'a RenderingAttachmentInfoKHR) -> Self { + self.inner.p_depth_attachment = depth_attachment; + self + } + pub fn stencil_attachment( + mut self, + stencil_attachment: &'a RenderingAttachmentInfoKHR, + ) -> Self { + self.inner.p_stencil_attachment = stencil_attachment; + 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(mut self, next: &'a mut T) -> Self { + 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) -> RenderingInfoKHR { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct RenderingAttachmentInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub image_view: ImageView, + pub image_layout: ImageLayout, + pub resolve_mode: ResolveModeFlags, + pub resolve_image_view: ImageView, + pub resolve_image_layout: ImageLayout, + pub load_op: AttachmentLoadOp, + pub store_op: AttachmentStoreOp, + pub clear_value: ClearValue, +} +impl fmt::Debug for RenderingAttachmentInfoKHR { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fmt.debug_struct("RenderingAttachmentInfoKHR") + .field("s_type", &self.s_type) + .field("p_next", &self.p_next) + .field("image_view", &self.image_view) + .field("image_layout", &self.image_layout) + .field("resolve_mode", &self.resolve_mode) + .field("resolve_image_view", &self.resolve_image_view) + .field("resolve_image_layout", &self.resolve_image_layout) + .field("load_op", &self.load_op) + .field("store_op", &self.store_op) + .field("clear_value", &"union") + .finish() + } +} +impl ::std::default::Default for RenderingAttachmentInfoKHR { + fn default() -> Self { + Self { + s_type: StructureType::RENDERING_ATTACHMENT_INFO_KHR, + p_next: ::std::ptr::null(), + image_view: ImageView::default(), + image_layout: ImageLayout::default(), + resolve_mode: ResolveModeFlags::default(), + resolve_image_view: ImageView::default(), + resolve_image_layout: ImageLayout::default(), + load_op: AttachmentLoadOp::default(), + store_op: AttachmentStoreOp::default(), + clear_value: ClearValue::default(), + } + } +} +impl RenderingAttachmentInfoKHR { + pub fn builder<'a>() -> RenderingAttachmentInfoKHRBuilder<'a> { + RenderingAttachmentInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct RenderingAttachmentInfoKHRBuilder<'a> { + inner: RenderingAttachmentInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for RenderingAttachmentInfoKHRBuilder<'a> { + type Target = RenderingAttachmentInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for RenderingAttachmentInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> RenderingAttachmentInfoKHRBuilder<'a> { + pub fn image_view(mut self, image_view: ImageView) -> Self { + self.inner.image_view = image_view; + self + } + pub fn image_layout(mut self, image_layout: ImageLayout) -> Self { + self.inner.image_layout = image_layout; + self + } + pub fn resolve_mode(mut self, resolve_mode: ResolveModeFlags) -> Self { + self.inner.resolve_mode = resolve_mode; + self + } + pub fn resolve_image_view(mut self, resolve_image_view: ImageView) -> Self { + self.inner.resolve_image_view = resolve_image_view; + self + } + pub fn resolve_image_layout(mut self, resolve_image_layout: ImageLayout) -> Self { + self.inner.resolve_image_layout = resolve_image_layout; + self + } + pub fn load_op(mut self, load_op: AttachmentLoadOp) -> Self { + self.inner.load_op = load_op; + self + } + pub fn store_op(mut self, store_op: AttachmentStoreOp) -> Self { + self.inner.store_op = store_op; + self + } + pub fn clear_value(mut self, clear_value: ClearValue) -> Self { + 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) -> RenderingAttachmentInfoKHR { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = ""] +pub struct RenderingFragmentShadingRateAttachmentInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub image_view: ImageView, + pub image_layout: ImageLayout, + pub shading_rate_attachment_texel_size: Extent2D, +} +impl ::std::default::Default for RenderingFragmentShadingRateAttachmentInfoKHR { + fn default() -> Self { + Self { + s_type: StructureType::RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR, + p_next: ::std::ptr::null(), + image_view: ImageView::default(), + image_layout: ImageLayout::default(), + shading_rate_attachment_texel_size: Extent2D::default(), + } + } +} +impl RenderingFragmentShadingRateAttachmentInfoKHR { + pub fn builder<'a>() -> RenderingFragmentShadingRateAttachmentInfoKHRBuilder<'a> { + RenderingFragmentShadingRateAttachmentInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct RenderingFragmentShadingRateAttachmentInfoKHRBuilder<'a> { + inner: RenderingFragmentShadingRateAttachmentInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsRenderingInfoKHR for RenderingFragmentShadingRateAttachmentInfoKHRBuilder<'_> {} +unsafe impl ExtendsRenderingInfoKHR for RenderingFragmentShadingRateAttachmentInfoKHR {} +impl<'a> ::std::ops::Deref for RenderingFragmentShadingRateAttachmentInfoKHRBuilder<'a> { + type Target = RenderingFragmentShadingRateAttachmentInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for RenderingFragmentShadingRateAttachmentInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> RenderingFragmentShadingRateAttachmentInfoKHRBuilder<'a> { + pub fn image_view(mut self, image_view: ImageView) -> Self { + self.inner.image_view = image_view; + self + } + pub fn image_layout(mut self, image_layout: ImageLayout) -> Self { + self.inner.image_layout = image_layout; + self + } + pub fn shading_rate_attachment_texel_size( + mut self, + shading_rate_attachment_texel_size: Extent2D, + ) -> Self { + self.inner.shading_rate_attachment_texel_size = shading_rate_attachment_texel_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) -> RenderingFragmentShadingRateAttachmentInfoKHR { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = ""] +pub struct RenderingFragmentDensityMapAttachmentInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub image_view: ImageView, + pub image_layout: ImageLayout, +} +impl ::std::default::Default for RenderingFragmentDensityMapAttachmentInfoEXT { + fn default() -> Self { + Self { + s_type: StructureType::RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT, + p_next: ::std::ptr::null(), + image_view: ImageView::default(), + image_layout: ImageLayout::default(), + } + } +} +impl RenderingFragmentDensityMapAttachmentInfoEXT { + pub fn builder<'a>() -> RenderingFragmentDensityMapAttachmentInfoEXTBuilder<'a> { + RenderingFragmentDensityMapAttachmentInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct RenderingFragmentDensityMapAttachmentInfoEXTBuilder<'a> { + inner: RenderingFragmentDensityMapAttachmentInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsRenderingInfoKHR for RenderingFragmentDensityMapAttachmentInfoEXTBuilder<'_> {} +unsafe impl ExtendsRenderingInfoKHR for RenderingFragmentDensityMapAttachmentInfoEXT {} +impl<'a> ::std::ops::Deref for RenderingFragmentDensityMapAttachmentInfoEXTBuilder<'a> { + type Target = RenderingFragmentDensityMapAttachmentInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for RenderingFragmentDensityMapAttachmentInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> RenderingFragmentDensityMapAttachmentInfoEXTBuilder<'a> { + pub fn image_view(mut self, image_view: ImageView) -> Self { + self.inner.image_view = image_view; + self + } + pub fn image_layout(mut self, image_layout: ImageLayout) -> Self { + 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) -> RenderingFragmentDensityMapAttachmentInfoEXT { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = ""] +pub struct PhysicalDeviceDynamicRenderingFeaturesKHR { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub dynamic_rendering: Bool32, +} +impl ::std::default::Default for PhysicalDeviceDynamicRenderingFeaturesKHR { + fn default() -> Self { + Self { + s_type: StructureType::PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES_KHR, + p_next: ::std::ptr::null_mut(), + dynamic_rendering: Bool32::default(), + } + } +} +impl PhysicalDeviceDynamicRenderingFeaturesKHR { + pub fn builder<'a>() -> PhysicalDeviceDynamicRenderingFeaturesKHRBuilder<'a> { + PhysicalDeviceDynamicRenderingFeaturesKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceDynamicRenderingFeaturesKHRBuilder<'a> { + inner: PhysicalDeviceDynamicRenderingFeaturesKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceDynamicRenderingFeaturesKHRBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDynamicRenderingFeaturesKHR {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDynamicRenderingFeaturesKHRBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDynamicRenderingFeaturesKHR {} +impl<'a> ::std::ops::Deref for PhysicalDeviceDynamicRenderingFeaturesKHRBuilder<'a> { + type Target = PhysicalDeviceDynamicRenderingFeaturesKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceDynamicRenderingFeaturesKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceDynamicRenderingFeaturesKHRBuilder<'a> { + pub fn dynamic_rendering(mut self, dynamic_rendering: bool) -> Self { + self.inner.dynamic_rendering = dynamic_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) -> PhysicalDeviceDynamicRenderingFeaturesKHR { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = ""] +pub struct CommandBufferInheritanceRenderingInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: RenderingFlagsKHR, + pub view_mask: u32, + pub color_attachment_count: u32, + pub p_color_attachment_formats: *const Format, + pub depth_attachment_format: Format, + pub stencil_attachment_format: Format, + pub rasterization_samples: SampleCountFlags, +} +impl ::std::default::Default for CommandBufferInheritanceRenderingInfoKHR { + fn default() -> Self { + Self { + s_type: StructureType::COMMAND_BUFFER_INHERITANCE_RENDERING_INFO_KHR, + p_next: ::std::ptr::null(), + flags: RenderingFlagsKHR::default(), + view_mask: u32::default(), + color_attachment_count: u32::default(), + p_color_attachment_formats: ::std::ptr::null(), + depth_attachment_format: Format::default(), + stencil_attachment_format: Format::default(), + rasterization_samples: SampleCountFlags::default(), + } + } +} +impl CommandBufferInheritanceRenderingInfoKHR { + pub fn builder<'a>() -> CommandBufferInheritanceRenderingInfoKHRBuilder<'a> { + CommandBufferInheritanceRenderingInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct CommandBufferInheritanceRenderingInfoKHRBuilder<'a> { + inner: CommandBufferInheritanceRenderingInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsCommandBufferInheritanceInfo + for CommandBufferInheritanceRenderingInfoKHRBuilder<'_> +{ +} +unsafe impl ExtendsCommandBufferInheritanceInfo for CommandBufferInheritanceRenderingInfoKHR {} +impl<'a> ::std::ops::Deref for CommandBufferInheritanceRenderingInfoKHRBuilder<'a> { + type Target = CommandBufferInheritanceRenderingInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for CommandBufferInheritanceRenderingInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> CommandBufferInheritanceRenderingInfoKHRBuilder<'a> { + pub fn flags(mut self, flags: RenderingFlagsKHR) -> Self { + self.inner.flags = flags; + self + } + pub fn view_mask(mut self, view_mask: u32) -> Self { + self.inner.view_mask = view_mask; + self + } + pub fn color_attachment_formats(mut self, color_attachment_formats: &'a [Format]) -> Self { + self.inner.color_attachment_count = color_attachment_formats.len() as _; + self.inner.p_color_attachment_formats = color_attachment_formats.as_ptr(); + self + } + pub fn depth_attachment_format(mut self, depth_attachment_format: Format) -> Self { + self.inner.depth_attachment_format = depth_attachment_format; + self + } + pub fn stencil_attachment_format(mut self, stencil_attachment_format: Format) -> Self { + self.inner.stencil_attachment_format = stencil_attachment_format; + self + } + pub fn rasterization_samples(mut self, rasterization_samples: SampleCountFlags) -> Self { + self.inner.rasterization_samples = rasterization_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) -> CommandBufferInheritanceRenderingInfoKHR { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = ""] +pub struct AttachmentSampleCountInfoAMD { + pub s_type: StructureType, + pub p_next: *const c_void, + pub color_attachment_count: u32, + pub p_color_attachment_samples: *const SampleCountFlags, + pub depth_stencil_attachment_samples: SampleCountFlags, +} +impl ::std::default::Default for AttachmentSampleCountInfoAMD { + fn default() -> Self { + Self { + s_type: StructureType::ATTACHMENT_SAMPLE_COUNT_INFO_AMD, + p_next: ::std::ptr::null(), + color_attachment_count: u32::default(), + p_color_attachment_samples: ::std::ptr::null(), + depth_stencil_attachment_samples: SampleCountFlags::default(), + } + } +} +impl AttachmentSampleCountInfoAMD { + pub fn builder<'a>() -> AttachmentSampleCountInfoAMDBuilder<'a> { + AttachmentSampleCountInfoAMDBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct AttachmentSampleCountInfoAMDBuilder<'a> { + inner: AttachmentSampleCountInfoAMD, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsCommandBufferInheritanceInfo for AttachmentSampleCountInfoAMDBuilder<'_> {} +unsafe impl ExtendsCommandBufferInheritanceInfo for AttachmentSampleCountInfoAMD {} +unsafe impl ExtendsGraphicsPipelineCreateInfo for AttachmentSampleCountInfoAMDBuilder<'_> {} +unsafe impl ExtendsGraphicsPipelineCreateInfo for AttachmentSampleCountInfoAMD {} +impl<'a> ::std::ops::Deref for AttachmentSampleCountInfoAMDBuilder<'a> { + type Target = AttachmentSampleCountInfoAMD; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for AttachmentSampleCountInfoAMDBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> AttachmentSampleCountInfoAMDBuilder<'a> { + pub fn color_attachment_samples( + mut self, + color_attachment_samples: &'a [SampleCountFlags], + ) -> Self { + self.inner.color_attachment_count = color_attachment_samples.len() as _; + self.inner.p_color_attachment_samples = color_attachment_samples.as_ptr(); + self + } + pub fn depth_stencil_attachment_samples( + mut self, + depth_stencil_attachment_samples: SampleCountFlags, + ) -> Self { + self.inner.depth_stencil_attachment_samples = depth_stencil_attachment_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) -> AttachmentSampleCountInfoAMD { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = ""] +pub struct MultiviewPerViewAttributesInfoNVX { + pub s_type: StructureType, + pub p_next: *const c_void, + pub per_view_attributes: Bool32, + pub per_view_attributes_position_x_only: Bool32, +} +impl ::std::default::Default for MultiviewPerViewAttributesInfoNVX { + fn default() -> Self { + Self { + s_type: StructureType::MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX, + p_next: ::std::ptr::null(), + per_view_attributes: Bool32::default(), + per_view_attributes_position_x_only: Bool32::default(), + } + } +} +impl MultiviewPerViewAttributesInfoNVX { + pub fn builder<'a>() -> MultiviewPerViewAttributesInfoNVXBuilder<'a> { + MultiviewPerViewAttributesInfoNVXBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct MultiviewPerViewAttributesInfoNVXBuilder<'a> { + inner: MultiviewPerViewAttributesInfoNVX, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsCommandBufferInheritanceInfo for MultiviewPerViewAttributesInfoNVXBuilder<'_> {} +unsafe impl ExtendsCommandBufferInheritanceInfo for MultiviewPerViewAttributesInfoNVX {} +unsafe impl ExtendsGraphicsPipelineCreateInfo for MultiviewPerViewAttributesInfoNVXBuilder<'_> {} +unsafe impl ExtendsGraphicsPipelineCreateInfo for MultiviewPerViewAttributesInfoNVX {} +unsafe impl ExtendsRenderingInfoKHR for MultiviewPerViewAttributesInfoNVXBuilder<'_> {} +unsafe impl ExtendsRenderingInfoKHR for MultiviewPerViewAttributesInfoNVX {} +impl<'a> ::std::ops::Deref for MultiviewPerViewAttributesInfoNVXBuilder<'a> { + type Target = MultiviewPerViewAttributesInfoNVX; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for MultiviewPerViewAttributesInfoNVXBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> MultiviewPerViewAttributesInfoNVXBuilder<'a> { + pub fn per_view_attributes(mut self, per_view_attributes: bool) -> Self { + self.inner.per_view_attributes = per_view_attributes.into(); + self + } + pub fn per_view_attributes_position_x_only( + mut self, + per_view_attributes_position_x_only: bool, + ) -> Self { + self.inner.per_view_attributes_position_x_only = per_view_attributes_position_x_only.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) -> MultiviewPerViewAttributesInfoNVX { + self.inner + } +} diff --git a/ash/src/vk/enums.rs b/ash/src/vk/enums.rs index 8457d18..d266c0b 100644 --- a/ash/src/vk/enums.rs +++ b/ash/src/vk/enums.rs @@ -1657,6 +1657,12 @@ impl DriverId { pub const JUICE_PROPRIETARY: Self = Self(16); #[doc = "Verisilicon, Inc."] pub const VERISILICON_PROPRIETARY: Self = Self(17); + #[doc = "Mesa open source project"] + pub const MESA_TURNIP: Self = Self(18); + #[doc = "Mesa open source project"] + pub const MESA_V3DV: Self = Self(19); + #[doc = "Mesa open source project"] + pub const MESA_PANVK: Self = Self(20); } #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(transparent)] diff --git a/ash/src/vk/extensions.rs b/ash/src/vk/extensions.rs index ac9e76d..c40f82b 100644 --- a/ash/src/vk/extensions.rs +++ b/ash/src/vk/extensions.rs @@ -2970,7 +2970,7 @@ impl KhrVideoDecodeQueueFn { ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_video_decode_queue\0") .expect("Wrong extension string") } - pub const SPEC_VERSION: u32 = 1u32; + pub const SPEC_VERSION: u32 = 2u32; } #[allow(non_camel_case_types)] pub type PFN_vkCmdDecodeVideoKHR = unsafe extern "system" fn( @@ -3076,6 +3076,14 @@ impl ImageLayout { impl ImageLayout { pub const VIDEO_DECODE_DPB_KHR: Self = Self(1_000_024_002); } +#[doc = "Generated from 'VK_KHR_video_decode_queue'"] +impl FormatFeatureFlags2KHR { + pub const VIDEO_DECODE_OUTPUT: Self = Self(0b10_0000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_KHR_video_decode_queue'"] +impl FormatFeatureFlags2KHR { + pub const VIDEO_DECODE_DPB: Self = Self(0b100_0000_0000_0000_0000_0000_0000); +} impl AmdGcnShaderFn { pub fn name() -> &'static ::std::ffi::CStr { ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_gcn_shader\0") @@ -4131,7 +4139,7 @@ impl ExtVideoEncodeH265Fn { ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_video_encode_h265\0") .expect("Wrong extension string") } - pub const SPEC_VERSION: u32 = 0u32; + pub const SPEC_VERSION: u32 = 2u32; } #[derive(Clone)] pub struct ExtVideoEncodeH265Fn {} @@ -4145,6 +4153,50 @@ impl ExtVideoEncodeH265Fn { Self {} } } +#[doc = "Generated from 'VK_EXT_video_encode_h265'"] +impl StructureType { + pub const VIDEO_ENCODE_H265_CAPABILITIES_EXT: Self = Self(1_000_039_000); +} +#[doc = "Generated from 'VK_EXT_video_encode_h265'"] +impl StructureType { + pub const VIDEO_ENCODE_H265_SESSION_CREATE_INFO_EXT: Self = Self(1_000_039_001); +} +#[doc = "Generated from 'VK_EXT_video_encode_h265'"] +impl StructureType { + pub const VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT: Self = Self(1_000_039_002); +} +#[doc = "Generated from 'VK_EXT_video_encode_h265'"] +impl StructureType { + pub const VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT: Self = Self(1_000_039_003); +} +#[doc = "Generated from 'VK_EXT_video_encode_h265'"] +impl StructureType { + pub const VIDEO_ENCODE_H265_VCL_FRAME_INFO_EXT: Self = Self(1_000_039_004); +} +#[doc = "Generated from 'VK_EXT_video_encode_h265'"] +impl StructureType { + pub const VIDEO_ENCODE_H265_DPB_SLOT_INFO_EXT: Self = Self(1_000_039_005); +} +#[doc = "Generated from 'VK_EXT_video_encode_h265'"] +impl StructureType { + pub const VIDEO_ENCODE_H265_NALU_SLICE_EXT: Self = Self(1_000_039_006); +} +#[doc = "Generated from 'VK_EXT_video_encode_h265'"] +impl StructureType { + pub const VIDEO_ENCODE_H265_EMIT_PICTURE_PARAMETERS_EXT: Self = Self(1_000_039_007); +} +#[doc = "Generated from 'VK_EXT_video_encode_h265'"] +impl StructureType { + pub const VIDEO_ENCODE_H265_PROFILE_EXT: Self = Self(1_000_039_008); +} +#[doc = "Generated from 'VK_EXT_video_encode_h265'"] +impl StructureType { + pub const VIDEO_ENCODE_H265_REFERENCE_LISTS_EXT: Self = Self(1_000_039_009); +} +#[doc = "Generated from 'VK_EXT_video_encode_h265'"] +impl VideoCodecOperationFlagsKHR { + pub const ENCODE_H265_EXT: Self = Self(0b10_0000_0000_0000_0000); +} impl ExtVideoDecodeH264Fn { pub fn name() -> &'static ::std::ffi::CStr { ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_video_decode_h264\0") @@ -4312,32 +4364,136 @@ impl AmdExtension44Fn { Self {} } } -impl AmdExtension45Fn { +impl KhrDynamicRenderingFn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_extension_45\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_dynamic_rendering\0") .expect("Wrong extension string") } - pub const SPEC_VERSION: u32 = 0u32; + pub const SPEC_VERSION: u32 = 1u32; } +#[allow(non_camel_case_types)] +pub type PFN_vkCmdBeginRenderingKHR = unsafe extern "system" fn( + command_buffer: CommandBuffer, + p_rendering_info: *const RenderingInfoKHR, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdEndRenderingKHR = unsafe extern "system" fn(command_buffer: CommandBuffer); #[derive(Clone)] -pub struct AmdExtension45Fn {} -unsafe impl Send for AmdExtension45Fn {} -unsafe impl Sync for AmdExtension45Fn {} -impl AmdExtension45Fn { +pub struct KhrDynamicRenderingFn { + pub cmd_begin_rendering_khr: PFN_vkCmdBeginRenderingKHR, + pub cmd_end_rendering_khr: PFN_vkCmdEndRenderingKHR, +} +unsafe impl Send for KhrDynamicRenderingFn {} +unsafe impl Sync for KhrDynamicRenderingFn {} +impl KhrDynamicRenderingFn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - Self {} + Self { + cmd_begin_rendering_khr: unsafe { + unsafe extern "system" fn cmd_begin_rendering_khr( + _command_buffer: CommandBuffer, + _p_rendering_info: *const RenderingInfoKHR, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_begin_rendering_khr) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdBeginRenderingKHR\0"); + let val = _f(cname); + if val.is_null() { + cmd_begin_rendering_khr + } else { + ::std::mem::transmute(val) + } + }, + cmd_end_rendering_khr: unsafe { + unsafe extern "system" fn cmd_end_rendering_khr(_command_buffer: CommandBuffer) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_end_rendering_khr) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdEndRenderingKHR\0"); + let val = _f(cname); + if val.is_null() { + cmd_end_rendering_khr + } else { + ::std::mem::transmute(val) + } + }, + } + } + #[doc = ""] + pub unsafe fn cmd_begin_rendering_khr( + &self, + command_buffer: CommandBuffer, + p_rendering_info: *const RenderingInfoKHR, + ) { + (self.cmd_begin_rendering_khr)(command_buffer, p_rendering_info) + } + #[doc = ""] + pub unsafe fn cmd_end_rendering_khr(&self, command_buffer: CommandBuffer) { + (self.cmd_end_rendering_khr)(command_buffer) } } -#[doc = "Generated from 'VK_AMD_extension_45'"] -impl PipelineCreateFlags { - pub const RESERVED_21_AMD: Self = Self(0b10_0000_0000_0000_0000_0000); +#[doc = "Generated from 'VK_KHR_dynamic_rendering'"] +impl StructureType { + pub const RENDERING_INFO_KHR: Self = Self(1_000_044_000); } -#[doc = "Generated from 'VK_AMD_extension_45'"] +#[doc = "Generated from 'VK_KHR_dynamic_rendering'"] +impl StructureType { + pub const RENDERING_ATTACHMENT_INFO_KHR: Self = Self(1_000_044_001); +} +#[doc = "Generated from 'VK_KHR_dynamic_rendering'"] +impl StructureType { + pub const PIPELINE_RENDERING_CREATE_INFO_KHR: Self = Self(1_000_044_002); +} +#[doc = "Generated from 'VK_KHR_dynamic_rendering'"] +impl StructureType { + pub const PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES_KHR: Self = Self(1_000_044_003); +} +#[doc = "Generated from 'VK_KHR_dynamic_rendering'"] +impl StructureType { + pub const COMMAND_BUFFER_INHERITANCE_RENDERING_INFO_KHR: Self = Self(1_000_044_004); +} +#[doc = "Generated from 'VK_KHR_dynamic_rendering'"] +impl AttachmentStoreOp { + pub const NONE_KHR: Self = Self(1_000_301_000); +} +#[doc = "Generated from 'VK_KHR_dynamic_rendering'"] impl PipelineCreateFlags { - pub const RESERVED_22_AMD: Self = Self(0b100_0000_0000_0000_0000_0000); + pub const RASTERIZATION_STATE_FRAGMENT_SHADING_RATE_ATTACHMENT_KHR: Self = + Self(0b10_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_KHR_dynamic_rendering'"] +impl StructureType { + pub const RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR: Self = Self(1_000_044_006); +} +#[doc = "Generated from 'VK_KHR_dynamic_rendering'"] +impl PipelineCreateFlags { + pub const RASTERIZATION_STATE_FRAGMENT_DENSITY_MAP_ATTACHMENT_EXT: Self = + Self(0b100_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_KHR_dynamic_rendering'"] +impl StructureType { + pub const RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT: Self = Self(1_000_044_007); +} +#[doc = "Generated from 'VK_KHR_dynamic_rendering'"] +impl StructureType { + pub const ATTACHMENT_SAMPLE_COUNT_INFO_AMD: Self = Self(1_000_044_008); +} +#[doc = "Generated from 'VK_KHR_dynamic_rendering'"] +impl StructureType { + pub const ATTACHMENT_SAMPLE_COUNT_INFO_NV: Self = Self::ATTACHMENT_SAMPLE_COUNT_INFO_AMD; +} +#[doc = "Generated from 'VK_KHR_dynamic_rendering'"] +impl StructureType { + pub const MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX: Self = Self(1_000_044_009); } impl AmdExtension46Fn { pub fn name() -> &'static ::std::ffi::CStr { @@ -10210,7 +10366,7 @@ impl AndroidExternalMemoryAndroidHardwareBufferFn { ) .expect("Wrong extension string") } - pub const SPEC_VERSION: u32 = 3u32; + pub const SPEC_VERSION: u32 = 4u32; } #[allow(non_camel_case_types)] pub type PFN_vkGetAndroidHardwareBufferPropertiesANDROID = unsafe extern "system" fn( @@ -10329,6 +10485,10 @@ impl StructureType { impl StructureType { pub const EXTERNAL_FORMAT_ANDROID: Self = Self(1_000_129_005); } +#[doc = "Generated from 'VK_ANDROID_external_memory_android_hardware_buffer'"] +impl StructureType { + pub const ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID: Self = Self(1_000_129_006); +} impl ExtSamplerFilterMinmaxFn { pub fn name() -> &'static ::std::ffi::CStr { ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_sampler_filter_minmax\0") @@ -11198,7 +11358,7 @@ impl KhrAccelerationStructureFn { ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_acceleration_structure\0") .expect("Wrong extension string") } - pub const SPEC_VERSION: u32 = 12u32; + pub const SPEC_VERSION: u32 = 13u32; } #[allow(non_camel_case_types)] pub type PFN_vkCreateAccelerationStructureKHR = unsafe extern "system" fn( @@ -12008,6 +12168,11 @@ impl BufferUsageFlags { impl BufferUsageFlags { pub const ACCELERATION_STRUCTURE_STORAGE_KHR: Self = Self(0b1_0000_0000_0000_0000_0000); } +#[doc = "Generated from 'VK_KHR_acceleration_structure'"] +impl FormatFeatureFlags2KHR { + pub const ACCELERATION_STRUCTURE_VERTEX_BUFFER: Self = + Self(0b10_0000_0000_0000_0000_0000_0000_0000); +} impl KhrRayTracingPipelineFn { pub fn name() -> &'static ::std::ffi::CStr { ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_ray_tracing_pipeline\0") @@ -13082,7 +13247,7 @@ impl ExtImageDrmFormatModifierFn { ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_image_drm_format_modifier\0") .expect("Wrong extension string") } - pub const SPEC_VERSION: u32 = 1u32; + pub const SPEC_VERSION: u32 = 2u32; } #[allow(non_camel_case_types)] pub type PFN_vkGetImageDrmFormatModifierPropertiesEXT = unsafe extern "system" fn( @@ -13179,6 +13344,10 @@ impl ImageAspectFlags { impl ImageAspectFlags { pub const MEMORY_PLANE_3_EXT: Self = Self(0b100_0000_0000); } +#[doc = "Generated from 'VK_EXT_image_drm_format_modifier'"] +impl StructureType { + pub const DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT: Self = Self(1_000_158_006); +} impl ExtExtension160Fn { pub fn name() -> &'static ::std::ffi::CStr { ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_extension_160\0") @@ -17026,7 +17195,7 @@ impl ExtFragmentDensityMapFn { ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_fragment_density_map\0") .expect("Wrong extension string") } - pub const SPEC_VERSION: u32 = 1u32; + pub const SPEC_VERSION: u32 = 2u32; } #[derive(Clone)] pub struct ExtFragmentDensityMapFn {} @@ -17088,6 +17257,10 @@ impl SamplerCreateFlags { impl SamplerCreateFlags { pub const SUBSAMPLED_COARSE_RECONSTRUCTION_EXT: Self = Self(0b10); } +#[doc = "Generated from 'VK_EXT_fragment_density_map'"] +impl FormatFeatureFlags2KHR { + pub const FRAGMENT_DENSITY_MAP_EXT: Self = Self(0b1_0000_0000_0000_0000_0000_0000); +} impl ExtExtension220Fn { pub fn name() -> &'static ::std::ffi::CStr { ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_extension_220\0") @@ -17256,7 +17429,7 @@ impl KhrFragmentShadingRateFn { ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_fragment_shading_rate\0") .expect("Wrong extension string") } - pub const SPEC_VERSION: u32 = 1u32; + pub const SPEC_VERSION: u32 = 2u32; } #[allow(non_camel_case_types)] pub type PFN_vkGetPhysicalDeviceFragmentShadingRatesKHR = unsafe extern "system" fn( @@ -17397,6 +17570,11 @@ impl FormatFeatureFlags { pub const FRAGMENT_SHADING_RATE_ATTACHMENT_KHR: Self = Self(0b100_0000_0000_0000_0000_0000_0000_0000); } +#[doc = "Generated from 'VK_KHR_fragment_shading_rate'"] +impl FormatFeatureFlags2KHR { + pub const FRAGMENT_SHADING_RATE_ATTACHMENT: Self = + Self(0b100_0000_0000_0000_0000_0000_0000_0000); +} impl AmdShaderCoreProperties2Fn { pub fn name() -> &'static ::std::ffi::CStr { ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_shader_core_properties2\0") @@ -21280,7 +21458,7 @@ impl KhrVideoEncodeQueueFn { ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_video_encode_queue\0") .expect("Wrong extension string") } - pub const SPEC_VERSION: u32 = 2u32; + pub const SPEC_VERSION: u32 = 3u32; } #[allow(non_camel_case_types)] pub type PFN_vkCmdEncodeVideoKHR = unsafe extern "system" fn( @@ -21394,6 +21572,14 @@ impl ImageLayout { impl QueryType { pub const VIDEO_ENCODESTREAM_BUFFER_RANGE_KHR: Self = Self(1_000_299_000); } +#[doc = "Generated from 'VK_KHR_video_encode_queue'"] +impl FormatFeatureFlags2KHR { + pub const VIDEO_ENCODE_INPUT: Self = Self(0b1000_0000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_KHR_video_encode_queue'"] +impl FormatFeatureFlags2KHR { + pub const VIDEO_ENCODE_DPB: Self = Self(0b1_0000_0000_0000_0000_0000_0000_0000); +} impl NvDeviceDiagnosticsConfigFn { pub fn name() -> &'static ::std::ffi::CStr { ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_device_diagnostics_config\0") @@ -21442,7 +21628,7 @@ impl QcomRenderPassStoreOpsFn { } #[doc = "Generated from 'VK_QCOM_render_pass_store_ops'"] impl AttachmentStoreOp { - pub const NONE_QCOM: Self = Self::NONE_EXT; + pub const NONE_QCOM: Self = Self::NONE_KHR; } impl QcomExtension303Fn { pub fn name() -> &'static ::std::ffi::CStr { @@ -22188,6 +22374,30 @@ impl AmdExtension317Fn { Self {} } } +#[doc = "Generated from 'VK_AMD_extension_317'"] +impl DescriptorSetLayoutCreateFlags { + pub const RESERVED_4_AMD: Self = Self(0b1_0000); +} +#[doc = "Generated from 'VK_AMD_extension_317'"] +impl BufferUsageFlags { + pub const RESERVED_21_AMD: Self = Self(0b10_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_AMD_extension_317'"] +impl BufferUsageFlags { + pub const RESERVED_22_AMD: Self = Self(0b100_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_AMD_extension_317'"] +impl BufferCreateFlags { + pub const RESERVED_5_AMD: Self = Self(0b10_0000); +} +#[doc = "Generated from 'VK_AMD_extension_317'"] +impl ImageCreateFlags { + pub const RESERVED_16_AMD: Self = Self(0b1_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_AMD_extension_317'"] +impl SamplerCreateFlags { + pub const RESERVED_3_AMD: Self = Self(0b1000); +} impl AmdExtension318Fn { pub fn name() -> &'static ::std::ffi::CStr { ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_extension_318\0") @@ -22280,6 +22490,10 @@ impl PipelineCreateFlags { impl PipelineCreateFlags { pub const RESERVED_10_AMD: Self = Self(0b100_0000_0000); } +#[doc = "Generated from 'VK_AMD_extension_321'"] +impl PipelineLayoutCreateFlags { + pub const RESERVED_1_AMD: Self = Self(0b10); +} impl AmdExtension322Fn { pub fn name() -> &'static ::std::ffi::CStr { ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_extension_322\0") @@ -23100,18 +23314,18 @@ impl ArmExtension344Fn { Self {} } } -impl ArmExtension345Fn { +impl ExtRgba10x6FormatsFn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_ARM_extension_345\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_rgba10x6_formats\0") .expect("Wrong extension string") } - pub const SPEC_VERSION: u32 = 0u32; + pub const SPEC_VERSION: u32 = 1u32; } #[derive(Clone)] -pub struct ArmExtension345Fn {} -unsafe impl Send for ArmExtension345Fn {} -unsafe impl Sync for ArmExtension345Fn {} -impl ArmExtension345Fn { +pub struct ExtRgba10x6FormatsFn {} +unsafe impl Send for ExtRgba10x6FormatsFn {} +unsafe impl Sync for ExtRgba10x6FormatsFn {} +impl ExtRgba10x6FormatsFn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, @@ -23119,6 +23333,10 @@ impl ArmExtension345Fn { Self {} } } +#[doc = "Generated from 'VK_EXT_rgba10x6_formats'"] +impl StructureType { + pub const PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT: Self = Self(1_000_344_000); +} impl NvAcquireWinrtDisplayFn { pub fn name() -> &'static ::std::ffi::CStr { ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_acquire_winrt_display\0") @@ -23616,18 +23834,18 @@ impl ExtExtension360Fn { Self {} } } -impl KhrExtension361Fn { +impl KhrFormatFeatureFlags2Fn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_extension_361\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_format_feature_flags2\0") .expect("Wrong extension string") } - pub const SPEC_VERSION: u32 = 0u32; + pub const SPEC_VERSION: u32 = 1u32; } #[derive(Clone)] -pub struct KhrExtension361Fn {} -unsafe impl Send for KhrExtension361Fn {} -unsafe impl Sync for KhrExtension361Fn {} -impl KhrExtension361Fn { +pub struct KhrFormatFeatureFlags2Fn {} +unsafe impl Send for KhrFormatFeatureFlags2Fn {} +unsafe impl Sync for KhrFormatFeatureFlags2Fn {} +impl KhrFormatFeatureFlags2Fn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, @@ -23635,6 +23853,10 @@ impl KhrExtension361Fn { Self {} } } +#[doc = "Generated from 'VK_KHR_format_feature_flags2'"] +impl StructureType { + pub const FORMAT_PROPERTIES_3_KHR: Self = Self(1_000_360_000); +} impl ExtExtension362Fn { pub fn name() -> &'static ::std::ffi::CStr { ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_extension_362\0") @@ -23919,24 +24141,272 @@ impl StructureType { impl ExternalSemaphoreHandleTypeFlags { pub const ZIRCON_EVENT_FUCHSIA: Self = Self(0b1000_0000); } -impl FuchsiaExtension367Fn { +impl FuchsiaBufferCollectionFn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_FUCHSIA_extension_367\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_FUCHSIA_buffer_collection\0") .expect("Wrong extension string") } - pub const SPEC_VERSION: u32 = 0u32; + pub const SPEC_VERSION: u32 = 2u32; } +#[allow(non_camel_case_types)] +pub type PFN_vkCreateBufferCollectionFUCHSIA = unsafe extern "system" fn( + device: Device, + p_create_info: *const BufferCollectionCreateInfoFUCHSIA, + p_allocator: *const AllocationCallbacks, + p_collection: *mut BufferCollectionFUCHSIA, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkSetBufferCollectionImageConstraintsFUCHSIA = unsafe extern "system" fn( + device: Device, + collection: BufferCollectionFUCHSIA, + p_image_constraints_info: *const ImageConstraintsInfoFUCHSIA, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkSetBufferCollectionBufferConstraintsFUCHSIA = unsafe extern "system" fn( + device: Device, + collection: BufferCollectionFUCHSIA, + p_buffer_constraints_info: *const BufferConstraintsInfoFUCHSIA, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkDestroyBufferCollectionFUCHSIA = unsafe extern "system" fn( + device: Device, + collection: BufferCollectionFUCHSIA, + p_allocator: *const AllocationCallbacks, +); +#[allow(non_camel_case_types)] +pub type PFN_vkGetBufferCollectionPropertiesFUCHSIA = unsafe extern "system" fn( + device: Device, + collection: BufferCollectionFUCHSIA, + p_properties: *mut BufferCollectionPropertiesFUCHSIA, +) -> Result; #[derive(Clone)] -pub struct FuchsiaExtension367Fn {} -unsafe impl Send for FuchsiaExtension367Fn {} -unsafe impl Sync for FuchsiaExtension367Fn {} -impl FuchsiaExtension367Fn { +pub struct FuchsiaBufferCollectionFn { + pub create_buffer_collection_fuchsia: PFN_vkCreateBufferCollectionFUCHSIA, + pub set_buffer_collection_image_constraints_fuchsia: + PFN_vkSetBufferCollectionImageConstraintsFUCHSIA, + pub set_buffer_collection_buffer_constraints_fuchsia: + PFN_vkSetBufferCollectionBufferConstraintsFUCHSIA, + pub destroy_buffer_collection_fuchsia: PFN_vkDestroyBufferCollectionFUCHSIA, + pub get_buffer_collection_properties_fuchsia: PFN_vkGetBufferCollectionPropertiesFUCHSIA, +} +unsafe impl Send for FuchsiaBufferCollectionFn {} +unsafe impl Sync for FuchsiaBufferCollectionFn {} +impl FuchsiaBufferCollectionFn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - Self {} + Self { + create_buffer_collection_fuchsia: unsafe { + unsafe extern "system" fn create_buffer_collection_fuchsia( + _device: Device, + _p_create_info: *const BufferCollectionCreateInfoFUCHSIA, + _p_allocator: *const AllocationCallbacks, + _p_collection: *mut BufferCollectionFUCHSIA, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(create_buffer_collection_fuchsia) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCreateBufferCollectionFUCHSIA\0", + ); + let val = _f(cname); + if val.is_null() { + create_buffer_collection_fuchsia + } else { + ::std::mem::transmute(val) + } + }, + set_buffer_collection_image_constraints_fuchsia: unsafe { + unsafe extern "system" fn set_buffer_collection_image_constraints_fuchsia( + _device: Device, + _collection: BufferCollectionFUCHSIA, + _p_image_constraints_info: *const ImageConstraintsInfoFUCHSIA, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(set_buffer_collection_image_constraints_fuchsia) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkSetBufferCollectionImageConstraintsFUCHSIA\0", + ); + let val = _f(cname); + if val.is_null() { + set_buffer_collection_image_constraints_fuchsia + } else { + ::std::mem::transmute(val) + } + }, + set_buffer_collection_buffer_constraints_fuchsia: unsafe { + unsafe extern "system" fn set_buffer_collection_buffer_constraints_fuchsia( + _device: Device, + _collection: BufferCollectionFUCHSIA, + _p_buffer_constraints_info: *const BufferConstraintsInfoFUCHSIA, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(set_buffer_collection_buffer_constraints_fuchsia) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkSetBufferCollectionBufferConstraintsFUCHSIA\0", + ); + let val = _f(cname); + if val.is_null() { + set_buffer_collection_buffer_constraints_fuchsia + } else { + ::std::mem::transmute(val) + } + }, + destroy_buffer_collection_fuchsia: unsafe { + unsafe extern "system" fn destroy_buffer_collection_fuchsia( + _device: Device, + _collection: BufferCollectionFUCHSIA, + _p_allocator: *const AllocationCallbacks, + ) { + panic!(concat!( + "Unable to load ", + stringify!(destroy_buffer_collection_fuchsia) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkDestroyBufferCollectionFUCHSIA\0", + ); + let val = _f(cname); + if val.is_null() { + destroy_buffer_collection_fuchsia + } else { + ::std::mem::transmute(val) + } + }, + get_buffer_collection_properties_fuchsia: unsafe { + unsafe extern "system" fn get_buffer_collection_properties_fuchsia( + _device: Device, + _collection: BufferCollectionFUCHSIA, + _p_properties: *mut BufferCollectionPropertiesFUCHSIA, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_buffer_collection_properties_fuchsia) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetBufferCollectionPropertiesFUCHSIA\0", + ); + let val = _f(cname); + if val.is_null() { + get_buffer_collection_properties_fuchsia + } else { + ::std::mem::transmute(val) + } + }, + } } + #[doc = ""] + pub unsafe fn create_buffer_collection_fuchsia( + &self, + device: Device, + p_create_info: *const BufferCollectionCreateInfoFUCHSIA, + p_allocator: *const AllocationCallbacks, + p_collection: *mut BufferCollectionFUCHSIA, + ) -> Result { + (self.create_buffer_collection_fuchsia)(device, p_create_info, p_allocator, p_collection) + } + #[doc = ""] + pub unsafe fn set_buffer_collection_image_constraints_fuchsia( + &self, + device: Device, + collection: BufferCollectionFUCHSIA, + p_image_constraints_info: *const ImageConstraintsInfoFUCHSIA, + ) -> Result { + (self.set_buffer_collection_image_constraints_fuchsia)( + device, + collection, + p_image_constraints_info, + ) + } + #[doc = ""] + pub unsafe fn set_buffer_collection_buffer_constraints_fuchsia( + &self, + device: Device, + collection: BufferCollectionFUCHSIA, + p_buffer_constraints_info: *const BufferConstraintsInfoFUCHSIA, + ) -> Result { + (self.set_buffer_collection_buffer_constraints_fuchsia)( + device, + collection, + p_buffer_constraints_info, + ) + } + #[doc = ""] + pub unsafe fn destroy_buffer_collection_fuchsia( + &self, + device: Device, + collection: BufferCollectionFUCHSIA, + p_allocator: *const AllocationCallbacks, + ) { + (self.destroy_buffer_collection_fuchsia)(device, collection, p_allocator) + } + #[doc = ""] + pub unsafe fn get_buffer_collection_properties_fuchsia( + &self, + device: Device, + collection: BufferCollectionFUCHSIA, + p_properties: *mut BufferCollectionPropertiesFUCHSIA, + ) -> Result { + (self.get_buffer_collection_properties_fuchsia)(device, collection, p_properties) + } +} +#[doc = "Generated from 'VK_FUCHSIA_buffer_collection'"] +impl StructureType { + pub const BUFFER_COLLECTION_CREATE_INFO_FUCHSIA: Self = Self(1_000_366_000); +} +#[doc = "Generated from 'VK_FUCHSIA_buffer_collection'"] +impl ObjectType { + pub const BUFFER_COLLECTION_FUCHSIA: Self = Self(1_000_366_000); +} +#[doc = "Generated from 'VK_FUCHSIA_buffer_collection'"] +impl DebugReportObjectTypeEXT { + pub const BUFFER_COLLECTION_FUCHSIA: Self = Self(1_000_366_000); +} +#[doc = "Generated from 'VK_FUCHSIA_buffer_collection'"] +impl StructureType { + pub const IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA: Self = Self(1_000_366_001); +} +#[doc = "Generated from 'VK_FUCHSIA_buffer_collection'"] +impl StructureType { + pub const BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA: Self = Self(1_000_366_002); +} +#[doc = "Generated from 'VK_FUCHSIA_buffer_collection'"] +impl StructureType { + pub const BUFFER_COLLECTION_PROPERTIES_FUCHSIA: Self = Self(1_000_366_003); +} +#[doc = "Generated from 'VK_FUCHSIA_buffer_collection'"] +impl StructureType { + pub const BUFFER_CONSTRAINTS_INFO_FUCHSIA: Self = Self(1_000_366_004); +} +#[doc = "Generated from 'VK_FUCHSIA_buffer_collection'"] +impl StructureType { + pub const BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA: Self = Self(1_000_366_005); +} +#[doc = "Generated from 'VK_FUCHSIA_buffer_collection'"] +impl StructureType { + pub const IMAGE_CONSTRAINTS_INFO_FUCHSIA: Self = Self(1_000_366_006); +} +#[doc = "Generated from 'VK_FUCHSIA_buffer_collection'"] +impl StructureType { + pub const IMAGE_FORMAT_CONSTRAINTS_INFO_FUCHSIA: Self = Self(1_000_366_007); +} +#[doc = "Generated from 'VK_FUCHSIA_buffer_collection'"] +impl StructureType { + pub const SYSMEM_COLOR_SPACE_FUCHSIA: Self = Self(1_000_366_008); +} +#[doc = "Generated from 'VK_FUCHSIA_buffer_collection'"] +impl StructureType { + pub const BUFFER_COLLECTION_CONSTRAINTS_INFO_FUCHSIA: Self = Self(1_000_366_009); } impl FuchsiaExtension368Fn { pub fn name() -> &'static ::std::ffi::CStr { @@ -24868,6 +25338,14 @@ impl KhrExtension387Fn { Self {} } } +#[doc = "Generated from 'VK_KHR_extension_387'"] +impl PipelineStageFlags2KHR { + pub const RESERVED_387: Self = Self(0b1_0000_0000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_KHR_extension_387'"] +impl AccessFlags2KHR { + pub const RESERVED_387: Self = Self(0b1_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000); +} impl ExtExtension388Fn { pub fn name() -> &'static ::std::ffi::CStr { ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_extension_388\0") @@ -25123,6 +25601,10 @@ impl ExtExtension394Fn { Self {} } } +#[doc = "Generated from 'VK_EXT_extension_394'"] +impl ImageCreateFlags { + pub const RESERVED_394_EXT: Self = Self(0b10_0000_0000_0000_0000); +} impl KhrExtension395Fn { pub fn name() -> &'static ::std::ffi::CStr { ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_extension_395\0") @@ -25262,7 +25744,7 @@ impl AttachmentLoadOp { } #[doc = "Generated from 'VK_EXT_load_store_op_none'"] impl AttachmentStoreOp { - pub const NONE_EXT: Self = Self(1_000_301_000); + pub const NONE_EXT: Self = Self::NONE_KHR; } impl FbExtension402Fn { pub fn name() -> &'static ::std::ffi::CStr { @@ -25454,18 +25936,18 @@ impl GgpExtension411Fn { Self {} } } -impl NvExtension412Fn { +impl ExtBorderColorSwizzleFn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_extension_412\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_border_color_swizzle\0") .expect("Wrong extension string") } - pub const SPEC_VERSION: u32 = 0u32; + pub const SPEC_VERSION: u32 = 1u32; } #[derive(Clone)] -pub struct NvExtension412Fn {} -unsafe impl Send for NvExtension412Fn {} -unsafe impl Sync for NvExtension412Fn {} -impl NvExtension412Fn { +pub struct ExtBorderColorSwizzleFn {} +unsafe impl Send for ExtBorderColorSwizzleFn {} +unsafe impl Sync for ExtBorderColorSwizzleFn {} +impl ExtBorderColorSwizzleFn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, @@ -25473,6 +25955,14 @@ impl NvExtension412Fn { Self {} } } +#[doc = "Generated from 'VK_EXT_border_color_swizzle'"] +impl StructureType { + pub const PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT: Self = Self(1_000_411_000); +} +#[doc = "Generated from 'VK_EXT_border_color_swizzle'"] +impl StructureType { + pub const SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT: Self = Self(1_000_411_001); +} impl ExtPageableDeviceLocalMemoryFn { pub fn name() -> &'static ::std::ffi::CStr { ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_pageable_device_local_memory\0") @@ -25532,24 +26022,162 @@ impl ExtPageableDeviceLocalMemoryFn { impl StructureType { pub const PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT: Self = Self(1_000_412_000); } -impl NvExtension414Fn { +impl KhrMaintenance4Fn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_extension_414\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_maintenance4\0") .expect("Wrong extension string") } - pub const SPEC_VERSION: u32 = 0u32; + pub const SPEC_VERSION: u32 = 1u32; } +#[allow(non_camel_case_types)] +pub type PFN_vkGetDeviceBufferMemoryRequirementsKHR = unsafe extern "system" fn( + device: Device, + p_info: *const DeviceBufferMemoryRequirementsKHR, + p_memory_requirements: *mut MemoryRequirements2, +); +#[allow(non_camel_case_types)] +pub type PFN_vkGetDeviceImageMemoryRequirementsKHR = unsafe extern "system" fn( + device: Device, + p_info: *const DeviceImageMemoryRequirementsKHR, + p_memory_requirements: *mut MemoryRequirements2, +); +#[allow(non_camel_case_types)] +pub type PFN_vkGetDeviceImageSparseMemoryRequirementsKHR = unsafe extern "system" fn( + device: Device, + p_info: *const DeviceImageMemoryRequirementsKHR, + p_sparse_memory_requirement_count: *mut u32, + p_sparse_memory_requirements: *mut SparseImageMemoryRequirements2, +); #[derive(Clone)] -pub struct NvExtension414Fn {} -unsafe impl Send for NvExtension414Fn {} -unsafe impl Sync for NvExtension414Fn {} -impl NvExtension414Fn { +pub struct KhrMaintenance4Fn { + pub get_device_buffer_memory_requirements_khr: PFN_vkGetDeviceBufferMemoryRequirementsKHR, + pub get_device_image_memory_requirements_khr: PFN_vkGetDeviceImageMemoryRequirementsKHR, + pub get_device_image_sparse_memory_requirements_khr: + PFN_vkGetDeviceImageSparseMemoryRequirementsKHR, +} +unsafe impl Send for KhrMaintenance4Fn {} +unsafe impl Sync for KhrMaintenance4Fn {} +impl KhrMaintenance4Fn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - Self {} + Self { + get_device_buffer_memory_requirements_khr: unsafe { + unsafe extern "system" fn get_device_buffer_memory_requirements_khr( + _device: Device, + _p_info: *const DeviceBufferMemoryRequirementsKHR, + _p_memory_requirements: *mut MemoryRequirements2, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_device_buffer_memory_requirements_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetDeviceBufferMemoryRequirementsKHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_device_buffer_memory_requirements_khr + } else { + ::std::mem::transmute(val) + } + }, + get_device_image_memory_requirements_khr: unsafe { + unsafe extern "system" fn get_device_image_memory_requirements_khr( + _device: Device, + _p_info: *const DeviceImageMemoryRequirementsKHR, + _p_memory_requirements: *mut MemoryRequirements2, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_device_image_memory_requirements_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetDeviceImageMemoryRequirementsKHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_device_image_memory_requirements_khr + } else { + ::std::mem::transmute(val) + } + }, + get_device_image_sparse_memory_requirements_khr: unsafe { + unsafe extern "system" fn get_device_image_sparse_memory_requirements_khr( + _device: Device, + _p_info: *const DeviceImageMemoryRequirementsKHR, + _p_sparse_memory_requirement_count: *mut u32, + _p_sparse_memory_requirements: *mut SparseImageMemoryRequirements2, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_device_image_sparse_memory_requirements_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetDeviceImageSparseMemoryRequirementsKHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_device_image_sparse_memory_requirements_khr + } else { + ::std::mem::transmute(val) + } + }, + } } + #[doc = ""] + pub unsafe fn get_device_buffer_memory_requirements_khr( + &self, + device: Device, + p_info: *const DeviceBufferMemoryRequirementsKHR, + p_memory_requirements: *mut MemoryRequirements2, + ) { + (self.get_device_buffer_memory_requirements_khr)(device, p_info, p_memory_requirements) + } + #[doc = ""] + pub unsafe fn get_device_image_memory_requirements_khr( + &self, + device: Device, + p_info: *const DeviceImageMemoryRequirementsKHR, + p_memory_requirements: *mut MemoryRequirements2, + ) { + (self.get_device_image_memory_requirements_khr)(device, p_info, p_memory_requirements) + } + #[doc = ""] + pub unsafe fn get_device_image_sparse_memory_requirements_khr( + &self, + device: Device, + p_info: *const DeviceImageMemoryRequirementsKHR, + p_sparse_memory_requirement_count: *mut u32, + p_sparse_memory_requirements: *mut SparseImageMemoryRequirements2, + ) { + (self.get_device_image_sparse_memory_requirements_khr)( + device, + p_info, + p_sparse_memory_requirement_count, + p_sparse_memory_requirements, + ) + } +} +#[doc = "Generated from 'VK_KHR_maintenance4'"] +impl StructureType { + pub const PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES_KHR: Self = Self(1_000_413_000); +} +#[doc = "Generated from 'VK_KHR_maintenance4'"] +impl StructureType { + pub const PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES_KHR: Self = Self(1_000_413_001); +} +#[doc = "Generated from 'VK_KHR_maintenance4'"] +impl StructureType { + pub const DEVICE_BUFFER_MEMORY_REQUIREMENTS_KHR: Self = Self(1_000_413_002); +} +#[doc = "Generated from 'VK_KHR_maintenance4'"] +impl StructureType { + pub const DEVICE_IMAGE_MEMORY_REQUIREMENTS_KHR: Self = Self(1_000_413_003); } impl HuaweiExtension415Fn { pub fn name() -> &'static ::std::ffi::CStr { @@ -25726,3 +26354,197 @@ impl ExtDisableCubeMapWrapFn { impl SamplerCreateFlags { pub const RESERVED_2_EXT: Self = Self(0b100); } +impl ArmExtension424Fn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_ARM_extension_424\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ArmExtension424Fn {} +unsafe impl Send for ArmExtension424Fn {} +unsafe impl Sync for ArmExtension424Fn {} +impl ArmExtension424Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ArmExtension425Fn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_ARM_extension_425\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ArmExtension425Fn {} +unsafe impl Send for ArmExtension425Fn {} +unsafe impl Sync for ArmExtension425Fn {} +impl ArmExtension425Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl QcomExtension426Fn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_QCOM_extension_426\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct QcomExtension426Fn {} +unsafe impl Send for QcomExtension426Fn {} +unsafe impl Sync for QcomExtension426Fn {} +impl QcomExtension426Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_QCOM_extension_426'"] +impl ImageCreateFlags { + pub const RESERVED_426_QCOM: Self = Self(0b1000_0000_0000_0000); +} +impl NvExtension427Fn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_extension_427\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct NvExtension427Fn {} +unsafe impl Send for NvExtension427Fn {} +unsafe impl Sync for NvExtension427Fn {} +impl NvExtension427Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl NvExtension428Fn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_extension_428\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct NvExtension428Fn {} +unsafe impl Send for NvExtension428Fn {} +unsafe impl Sync for NvExtension428Fn {} +impl NvExtension428Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl NvExtension429Fn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_extension_429\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct NvExtension429Fn {} +unsafe impl Send for NvExtension429Fn {} +unsafe impl Sync for NvExtension429Fn {} +impl NvExtension429Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl NvExtension430Fn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_extension_430\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct NvExtension430Fn {} +unsafe impl Send for NvExtension430Fn {} +unsafe impl Sync for NvExtension430Fn {} +impl NvExtension430Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl NvExtension431Fn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_extension_431\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct NvExtension431Fn {} +unsafe impl Send for NvExtension431Fn {} +unsafe impl Sync for NvExtension431Fn {} +impl NvExtension431Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl NvExtension432Fn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_extension_432\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct NvExtension432Fn {} +unsafe impl Send for NvExtension432Fn {} +unsafe impl Sync for NvExtension432Fn {} +impl NvExtension432Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl NvExtension433Fn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_extension_433\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct NvExtension433Fn {} +unsafe impl Send for NvExtension433Fn {} +unsafe impl Sync for NvExtension433Fn {} +impl NvExtension433Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} diff --git a/ash/src/vk/native.rs b/ash/src/vk/native.rs index f8d2bca..cd03182 100644 --- a/ash/src/vk/native.rs +++ b/ash/src/vk/native.rs @@ -89,142 +89,145 @@ pub type __int32_t = ::std::os::raw::c_int; pub type __uint32_t = ::std::os::raw::c_uint; pub type __int64_t = ::std::os::raw::c_long; pub type __uint64_t = ::std::os::raw::c_ulong; -pub const StdVideoH264ChromaFormatIdc_std_video_h264_chroma_format_idc_monochrome: +pub const StdVideoH264ChromaFormatIdc_STD_VIDEO_H264_CHROMA_FORMAT_IDC_MONOCHROME: StdVideoH264ChromaFormatIdc = 0; -pub const StdVideoH264ChromaFormatIdc_std_video_h264_chroma_format_idc_420: +pub const StdVideoH264ChromaFormatIdc_STD_VIDEO_H264_CHROMA_FORMAT_IDC_420: StdVideoH264ChromaFormatIdc = 1; -pub const StdVideoH264ChromaFormatIdc_std_video_h264_chroma_format_idc_422: +pub const StdVideoH264ChromaFormatIdc_STD_VIDEO_H264_CHROMA_FORMAT_IDC_422: StdVideoH264ChromaFormatIdc = 2; -pub const StdVideoH264ChromaFormatIdc_std_video_h264_chroma_format_idc_444: +pub const StdVideoH264ChromaFormatIdc_STD_VIDEO_H264_CHROMA_FORMAT_IDC_444: StdVideoH264ChromaFormatIdc = 3; +pub const StdVideoH264ChromaFormatIdc_STD_VIDEO_H264_CHROMA_FORMAT_IDC_INVALID: + StdVideoH264ChromaFormatIdc = 2147483647; pub type StdVideoH264ChromaFormatIdc = ::std::os::raw::c_uint; -pub const StdVideoH264ProfileIdc_std_video_h264_profile_idc_baseline: StdVideoH264ProfileIdc = 66; -pub const StdVideoH264ProfileIdc_std_video_h264_profile_idc_main: StdVideoH264ProfileIdc = 77; -pub const StdVideoH264ProfileIdc_std_video_h264_profile_idc_high: StdVideoH264ProfileIdc = 100; -pub const StdVideoH264ProfileIdc_std_video_h264_profile_idc_high_444_predictive: +pub const StdVideoH264ProfileIdc_STD_VIDEO_H264_PROFILE_IDC_BASELINE: StdVideoH264ProfileIdc = 66; +pub const StdVideoH264ProfileIdc_STD_VIDEO_H264_PROFILE_IDC_MAIN: StdVideoH264ProfileIdc = 77; +pub const StdVideoH264ProfileIdc_STD_VIDEO_H264_PROFILE_IDC_HIGH: StdVideoH264ProfileIdc = 100; +pub const StdVideoH264ProfileIdc_STD_VIDEO_H264_PROFILE_IDC_HIGH_444_PREDICTIVE: StdVideoH264ProfileIdc = 244; -pub const StdVideoH264ProfileIdc_std_video_h264_profile_idc_invalid: StdVideoH264ProfileIdc = +pub const StdVideoH264ProfileIdc_STD_VIDEO_H264_PROFILE_IDC_INVALID: StdVideoH264ProfileIdc = 2147483647; pub type StdVideoH264ProfileIdc = ::std::os::raw::c_uint; -pub const StdVideoH264Level_std_video_h264_level_1_0: StdVideoH264Level = 0; -pub const StdVideoH264Level_std_video_h264_level_1_1: StdVideoH264Level = 1; -pub const StdVideoH264Level_std_video_h264_level_1_2: StdVideoH264Level = 2; -pub const StdVideoH264Level_std_video_h264_level_1_3: StdVideoH264Level = 3; -pub const StdVideoH264Level_std_video_h264_level_2_0: StdVideoH264Level = 4; -pub const StdVideoH264Level_std_video_h264_level_2_1: StdVideoH264Level = 5; -pub const StdVideoH264Level_std_video_h264_level_2_2: StdVideoH264Level = 6; -pub const StdVideoH264Level_std_video_h264_level_3_0: StdVideoH264Level = 7; -pub const StdVideoH264Level_std_video_h264_level_3_1: StdVideoH264Level = 8; -pub const StdVideoH264Level_std_video_h264_level_3_2: StdVideoH264Level = 9; -pub const StdVideoH264Level_std_video_h264_level_4_0: StdVideoH264Level = 10; -pub const StdVideoH264Level_std_video_h264_level_4_1: StdVideoH264Level = 11; -pub const StdVideoH264Level_std_video_h264_level_4_2: StdVideoH264Level = 12; -pub const StdVideoH264Level_std_video_h264_level_5_0: StdVideoH264Level = 13; -pub const StdVideoH264Level_std_video_h264_level_5_1: StdVideoH264Level = 14; -pub const StdVideoH264Level_std_video_h264_level_5_2: StdVideoH264Level = 15; -pub const StdVideoH264Level_std_video_h264_level_6_0: StdVideoH264Level = 16; -pub const StdVideoH264Level_std_video_h264_level_6_1: StdVideoH264Level = 17; -pub const StdVideoH264Level_std_video_h264_level_6_2: StdVideoH264Level = 18; -pub const StdVideoH264Level_std_video_h264_level_invalid: StdVideoH264Level = 2147483647; +pub const StdVideoH264Level_STD_VIDEO_H264_LEVEL_1_0: StdVideoH264Level = 0; +pub const StdVideoH264Level_STD_VIDEO_H264_LEVEL_1_1: StdVideoH264Level = 1; +pub const StdVideoH264Level_STD_VIDEO_H264_LEVEL_1_2: StdVideoH264Level = 2; +pub const StdVideoH264Level_STD_VIDEO_H264_LEVEL_1_3: StdVideoH264Level = 3; +pub const StdVideoH264Level_STD_VIDEO_H264_LEVEL_2_0: StdVideoH264Level = 4; +pub const StdVideoH264Level_STD_VIDEO_H264_LEVEL_2_1: StdVideoH264Level = 5; +pub const StdVideoH264Level_STD_VIDEO_H264_LEVEL_2_2: StdVideoH264Level = 6; +pub const StdVideoH264Level_STD_VIDEO_H264_LEVEL_3_0: StdVideoH264Level = 7; +pub const StdVideoH264Level_STD_VIDEO_H264_LEVEL_3_1: StdVideoH264Level = 8; +pub const StdVideoH264Level_STD_VIDEO_H264_LEVEL_3_2: StdVideoH264Level = 9; +pub const StdVideoH264Level_STD_VIDEO_H264_LEVEL_4_0: StdVideoH264Level = 10; +pub const StdVideoH264Level_STD_VIDEO_H264_LEVEL_4_1: StdVideoH264Level = 11; +pub const StdVideoH264Level_STD_VIDEO_H264_LEVEL_4_2: StdVideoH264Level = 12; +pub const StdVideoH264Level_STD_VIDEO_H264_LEVEL_5_0: StdVideoH264Level = 13; +pub const StdVideoH264Level_STD_VIDEO_H264_LEVEL_5_1: StdVideoH264Level = 14; +pub const StdVideoH264Level_STD_VIDEO_H264_LEVEL_5_2: StdVideoH264Level = 15; +pub const StdVideoH264Level_STD_VIDEO_H264_LEVEL_6_0: StdVideoH264Level = 16; +pub const StdVideoH264Level_STD_VIDEO_H264_LEVEL_6_1: StdVideoH264Level = 17; +pub const StdVideoH264Level_STD_VIDEO_H264_LEVEL_6_2: StdVideoH264Level = 18; +pub const StdVideoH264Level_STD_VIDEO_H264_LEVEL_INVALID: StdVideoH264Level = 2147483647; pub type StdVideoH264Level = ::std::os::raw::c_uint; -pub const StdVideoH264PocType_std_video_h264_poc_type_0: StdVideoH264PocType = 0; -pub const StdVideoH264PocType_std_video_h264_poc_type_1: StdVideoH264PocType = 1; -pub const StdVideoH264PocType_std_video_h264_poc_type_2: StdVideoH264PocType = 2; -pub const StdVideoH264PocType_std_video_h264_poc_type_invalid: StdVideoH264PocType = 2147483647; +pub const StdVideoH264PocType_STD_VIDEO_H264_POC_TYPE_0: StdVideoH264PocType = 0; +pub const StdVideoH264PocType_STD_VIDEO_H264_POC_TYPE_1: StdVideoH264PocType = 1; +pub const StdVideoH264PocType_STD_VIDEO_H264_POC_TYPE_2: StdVideoH264PocType = 2; +pub const StdVideoH264PocType_STD_VIDEO_H264_POC_TYPE_INVALID: StdVideoH264PocType = 2147483647; pub type StdVideoH264PocType = ::std::os::raw::c_uint; -pub const StdVideoH264AspectRatioIdc_std_video_h264_aspect_ratio_idc_unspecified: +pub const StdVideoH264AspectRatioIdc_STD_VIDEO_H264_ASPECT_RATIO_IDC_UNSPECIFIED: StdVideoH264AspectRatioIdc = 0; -pub const StdVideoH264AspectRatioIdc_std_video_h264_aspect_ratio_idc_square: +pub const StdVideoH264AspectRatioIdc_STD_VIDEO_H264_ASPECT_RATIO_IDC_SQUARE: StdVideoH264AspectRatioIdc = 1; -pub const StdVideoH264AspectRatioIdc_std_video_h264_aspect_ratio_idc_12_11: +pub const StdVideoH264AspectRatioIdc_STD_VIDEO_H264_ASPECT_RATIO_IDC_12_11: StdVideoH264AspectRatioIdc = 2; -pub const StdVideoH264AspectRatioIdc_std_video_h264_aspect_ratio_idc_10_11: +pub const StdVideoH264AspectRatioIdc_STD_VIDEO_H264_ASPECT_RATIO_IDC_10_11: StdVideoH264AspectRatioIdc = 3; -pub const StdVideoH264AspectRatioIdc_std_video_h264_aspect_ratio_idc_16_11: +pub const StdVideoH264AspectRatioIdc_STD_VIDEO_H264_ASPECT_RATIO_IDC_16_11: StdVideoH264AspectRatioIdc = 4; -pub const StdVideoH264AspectRatioIdc_std_video_h264_aspect_ratio_idc_40_33: +pub const StdVideoH264AspectRatioIdc_STD_VIDEO_H264_ASPECT_RATIO_IDC_40_33: StdVideoH264AspectRatioIdc = 5; -pub const StdVideoH264AspectRatioIdc_std_video_h264_aspect_ratio_idc_24_11: +pub const StdVideoH264AspectRatioIdc_STD_VIDEO_H264_ASPECT_RATIO_IDC_24_11: StdVideoH264AspectRatioIdc = 6; -pub const StdVideoH264AspectRatioIdc_std_video_h264_aspect_ratio_idc_20_11: +pub const StdVideoH264AspectRatioIdc_STD_VIDEO_H264_ASPECT_RATIO_IDC_20_11: StdVideoH264AspectRatioIdc = 7; -pub const StdVideoH264AspectRatioIdc_std_video_h264_aspect_ratio_idc_32_11: +pub const StdVideoH264AspectRatioIdc_STD_VIDEO_H264_ASPECT_RATIO_IDC_32_11: StdVideoH264AspectRatioIdc = 8; -pub const StdVideoH264AspectRatioIdc_std_video_h264_aspect_ratio_idc_80_33: +pub const StdVideoH264AspectRatioIdc_STD_VIDEO_H264_ASPECT_RATIO_IDC_80_33: StdVideoH264AspectRatioIdc = 9; -pub const StdVideoH264AspectRatioIdc_std_video_h264_aspect_ratio_idc_18_11: +pub const StdVideoH264AspectRatioIdc_STD_VIDEO_H264_ASPECT_RATIO_IDC_18_11: StdVideoH264AspectRatioIdc = 10; -pub const StdVideoH264AspectRatioIdc_std_video_h264_aspect_ratio_idc_15_11: +pub const StdVideoH264AspectRatioIdc_STD_VIDEO_H264_ASPECT_RATIO_IDC_15_11: StdVideoH264AspectRatioIdc = 11; -pub const StdVideoH264AspectRatioIdc_std_video_h264_aspect_ratio_idc_64_33: +pub const StdVideoH264AspectRatioIdc_STD_VIDEO_H264_ASPECT_RATIO_IDC_64_33: StdVideoH264AspectRatioIdc = 12; -pub const StdVideoH264AspectRatioIdc_std_video_h264_aspect_ratio_idc_160_99: +pub const StdVideoH264AspectRatioIdc_STD_VIDEO_H264_ASPECT_RATIO_IDC_160_99: StdVideoH264AspectRatioIdc = 13; -pub const StdVideoH264AspectRatioIdc_std_video_h264_aspect_ratio_idc_4_3: +pub const StdVideoH264AspectRatioIdc_STD_VIDEO_H264_ASPECT_RATIO_IDC_4_3: StdVideoH264AspectRatioIdc = 14; -pub const StdVideoH264AspectRatioIdc_std_video_h264_aspect_ratio_idc_3_2: +pub const StdVideoH264AspectRatioIdc_STD_VIDEO_H264_ASPECT_RATIO_IDC_3_2: StdVideoH264AspectRatioIdc = 15; -pub const StdVideoH264AspectRatioIdc_std_video_h264_aspect_ratio_idc_2_1: +pub const StdVideoH264AspectRatioIdc_STD_VIDEO_H264_ASPECT_RATIO_IDC_2_1: StdVideoH264AspectRatioIdc = 16; -pub const StdVideoH264AspectRatioIdc_std_video_h264_aspect_ratio_idc_extended_sar: +pub const StdVideoH264AspectRatioIdc_STD_VIDEO_H264_ASPECT_RATIO_IDC_EXTENDED_SAR: StdVideoH264AspectRatioIdc = 255; -pub const StdVideoH264AspectRatioIdc_std_video_h264_aspect_ratio_idc_invalid: +pub const StdVideoH264AspectRatioIdc_STD_VIDEO_H264_ASPECT_RATIO_IDC_INVALID: StdVideoH264AspectRatioIdc = 2147483647; pub type StdVideoH264AspectRatioIdc = ::std::os::raw::c_uint; -pub const StdVideoH264WeightedBiPredIdc_std_video_h264_default_weighted_b_slices_prediction_idc: - StdVideoH264WeightedBiPredIdc = 0; -pub const StdVideoH264WeightedBiPredIdc_std_video_h264_explicit_weighted_b_slices_prediction_idc: - StdVideoH264WeightedBiPredIdc = 1; -pub const StdVideoH264WeightedBiPredIdc_std_video_h264_implicit_weighted_b_slices_prediction_idc: - StdVideoH264WeightedBiPredIdc = 2; -pub const StdVideoH264WeightedBiPredIdc_std_video_h264_invalid_weighted_b_slices_prediction_idc: - StdVideoH264WeightedBiPredIdc = 2147483647; -pub type StdVideoH264WeightedBiPredIdc = ::std::os::raw::c_uint; -pub const StdVideoH264ModificationOfPicNumsIdc_std_video_h264_modification_of_pic_nums_idc_short_term_subtract : StdVideoH264ModificationOfPicNumsIdc = 0 ; -pub const StdVideoH264ModificationOfPicNumsIdc_std_video_h264_modification_of_pic_nums_idc_short_term_add : StdVideoH264ModificationOfPicNumsIdc = 1 ; -pub const StdVideoH264ModificationOfPicNumsIdc_std_video_h264_modification_of_pic_nums_idc_long_term : StdVideoH264ModificationOfPicNumsIdc = 2 ; -pub const StdVideoH264ModificationOfPicNumsIdc_std_video_h264_modification_of_pic_nums_idc_end: +pub const StdVideoH264WeightedBipredIdc_STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_DEFAULT: + StdVideoH264WeightedBipredIdc = 0; +pub const StdVideoH264WeightedBipredIdc_STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_EXPLICIT: + StdVideoH264WeightedBipredIdc = 1; +pub const StdVideoH264WeightedBipredIdc_STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_IMPLICIT: + StdVideoH264WeightedBipredIdc = 2; +pub const StdVideoH264WeightedBipredIdc_STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_INVALID: + StdVideoH264WeightedBipredIdc = 2147483647; +pub type StdVideoH264WeightedBipredIdc = ::std::os::raw::c_uint; +pub const StdVideoH264ModificationOfPicNumsIdc_STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_SHORT_TERM_SUBTRACT : StdVideoH264ModificationOfPicNumsIdc = 0 ; +pub const StdVideoH264ModificationOfPicNumsIdc_STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_SHORT_TERM_ADD : StdVideoH264ModificationOfPicNumsIdc = 1 ; +pub const StdVideoH264ModificationOfPicNumsIdc_STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_LONG_TERM : StdVideoH264ModificationOfPicNumsIdc = 2 ; +pub const StdVideoH264ModificationOfPicNumsIdc_STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_END: StdVideoH264ModificationOfPicNumsIdc = 3; -pub const StdVideoH264ModificationOfPicNumsIdc_std_video_h264_modification_of_pic_nums_idc_invalid : StdVideoH264ModificationOfPicNumsIdc = 2147483647 ; +pub const StdVideoH264ModificationOfPicNumsIdc_STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_INVALID : StdVideoH264ModificationOfPicNumsIdc = 2147483647 ; pub type StdVideoH264ModificationOfPicNumsIdc = ::std::os::raw::c_uint; -pub const StdVideoH264MemMgmtControlOp_std_video_h264_mem_mgmt_control_op_end: +pub const StdVideoH264MemMgmtControlOp_STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_END: StdVideoH264MemMgmtControlOp = 0; -pub const StdVideoH264MemMgmtControlOp_std_video_h264_mem_mgmt_control_op_unmark_short_term: +pub const StdVideoH264MemMgmtControlOp_STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_UNMARK_SHORT_TERM: StdVideoH264MemMgmtControlOp = 1; -pub const StdVideoH264MemMgmtControlOp_std_video_h264_mem_mgmt_control_op_unmark_long_term: +pub const StdVideoH264MemMgmtControlOp_STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_UNMARK_LONG_TERM: StdVideoH264MemMgmtControlOp = 2; -pub const StdVideoH264MemMgmtControlOp_std_video_h264_mem_mgmt_control_op_mark_long_term: +pub const StdVideoH264MemMgmtControlOp_STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_MARK_LONG_TERM: StdVideoH264MemMgmtControlOp = 3; -pub const StdVideoH264MemMgmtControlOp_std_video_h264_mem_mgmt_control_op_set_max_long_term_index : StdVideoH264MemMgmtControlOp = 4 ; -pub const StdVideoH264MemMgmtControlOp_std_video_h264_mem_mgmt_control_op_unmark_all: +pub const StdVideoH264MemMgmtControlOp_STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_SET_MAX_LONG_TERM_INDEX : StdVideoH264MemMgmtControlOp = 4 ; +pub const StdVideoH264MemMgmtControlOp_STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_UNMARK_ALL: StdVideoH264MemMgmtControlOp = 5; -pub const StdVideoH264MemMgmtControlOp_std_video_h264_mem_mgmt_control_op_mark_current_as_long_term : StdVideoH264MemMgmtControlOp = 6 ; -pub const StdVideoH264MemMgmtControlOp_std_video_h264_mem_mgmt_control_op_invalid: +pub const StdVideoH264MemMgmtControlOp_STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_MARK_CURRENT_AS_LONG_TERM : StdVideoH264MemMgmtControlOp = 6 ; +pub const StdVideoH264MemMgmtControlOp_STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_INVALID: StdVideoH264MemMgmtControlOp = 2147483647; pub type StdVideoH264MemMgmtControlOp = ::std::os::raw::c_uint; -pub const StdVideoH264CabacInitIdc_std_video_h264_cabac_init_idc_0: StdVideoH264CabacInitIdc = 0; -pub const StdVideoH264CabacInitIdc_std_video_h264_cabac_init_idc_1: StdVideoH264CabacInitIdc = 1; -pub const StdVideoH264CabacInitIdc_std_video_h264_cabac_init_idc_2: StdVideoH264CabacInitIdc = 2; -pub const StdVideoH264CabacInitIdc_std_video_h264_cabac_init_idc_invalid: StdVideoH264CabacInitIdc = +pub const StdVideoH264CabacInitIdc_STD_VIDEO_H264_CABAC_INIT_IDC_0: StdVideoH264CabacInitIdc = 0; +pub const StdVideoH264CabacInitIdc_STD_VIDEO_H264_CABAC_INIT_IDC_1: StdVideoH264CabacInitIdc = 1; +pub const StdVideoH264CabacInitIdc_STD_VIDEO_H264_CABAC_INIT_IDC_2: StdVideoH264CabacInitIdc = 2; +pub const StdVideoH264CabacInitIdc_STD_VIDEO_H264_CABAC_INIT_IDC_INVALID: StdVideoH264CabacInitIdc = 2147483647; pub type StdVideoH264CabacInitIdc = ::std::os::raw::c_uint; -pub const StdVideoH264DisableDeblockingFilterIdc_std_video_h264_disable_deblocking_filter_idc_disabled : StdVideoH264DisableDeblockingFilterIdc = 0 ; -pub const StdVideoH264DisableDeblockingFilterIdc_std_video_h264_disable_deblocking_filter_idc_enabled : StdVideoH264DisableDeblockingFilterIdc = 1 ; -pub const StdVideoH264DisableDeblockingFilterIdc_std_video_h264_disable_deblocking_filter_idc_partial : StdVideoH264DisableDeblockingFilterIdc = 2 ; -pub const StdVideoH264DisableDeblockingFilterIdc_std_video_h264_disable_deblocking_filter_idc_invalid : StdVideoH264DisableDeblockingFilterIdc = 2147483647 ; +pub const StdVideoH264DisableDeblockingFilterIdc_STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_DISABLED : StdVideoH264DisableDeblockingFilterIdc = 0 ; +pub const StdVideoH264DisableDeblockingFilterIdc_STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_ENABLED : StdVideoH264DisableDeblockingFilterIdc = 1 ; +pub const StdVideoH264DisableDeblockingFilterIdc_STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_PARTIAL : StdVideoH264DisableDeblockingFilterIdc = 2 ; +pub const StdVideoH264DisableDeblockingFilterIdc_STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_INVALID : StdVideoH264DisableDeblockingFilterIdc = 2147483647 ; pub type StdVideoH264DisableDeblockingFilterIdc = ::std::os::raw::c_uint; -pub const StdVideoH264PictureType_std_video_h264_picture_type_i: StdVideoH264PictureType = 0; -pub const StdVideoH264PictureType_std_video_h264_picture_type_p: StdVideoH264PictureType = 1; -pub const StdVideoH264PictureType_std_video_h264_picture_type_b: StdVideoH264PictureType = 2; -pub const StdVideoH264PictureType_std_video_h264_picture_type_invalid: StdVideoH264PictureType = - 2147483647; -pub type StdVideoH264PictureType = ::std::os::raw::c_uint; -pub const StdVideoH264SliceType_std_video_h264_slice_type_i: StdVideoH264SliceType = 0; -pub const StdVideoH264SliceType_std_video_h264_slice_type_p: StdVideoH264SliceType = 1; -pub const StdVideoH264SliceType_std_video_h264_slice_type_b: StdVideoH264SliceType = 2; -pub const StdVideoH264SliceType_std_video_h264_slice_type_invalid: StdVideoH264SliceType = +pub const StdVideoH264SliceType_STD_VIDEO_H264_SLICE_TYPE_P: StdVideoH264SliceType = 0; +pub const StdVideoH264SliceType_STD_VIDEO_H264_SLICE_TYPE_B: StdVideoH264SliceType = 1; +pub const StdVideoH264SliceType_STD_VIDEO_H264_SLICE_TYPE_I: StdVideoH264SliceType = 2; +pub const StdVideoH264SliceType_STD_VIDEO_H264_SLICE_TYPE_INVALID: StdVideoH264SliceType = 2147483647; pub type StdVideoH264SliceType = ::std::os::raw::c_uint; +pub const StdVideoH264PictureType_STD_VIDEO_H264_PICTURE_TYPE_P: StdVideoH264PictureType = 0; +pub const StdVideoH264PictureType_STD_VIDEO_H264_PICTURE_TYPE_B: StdVideoH264PictureType = 1; +pub const StdVideoH264PictureType_STD_VIDEO_H264_PICTURE_TYPE_I: StdVideoH264PictureType = 2; +pub const StdVideoH264PictureType_STD_VIDEO_H264_PICTURE_TYPE_IDR: StdVideoH264PictureType = 5; +pub const StdVideoH264PictureType_STD_VIDEO_H264_PICTURE_TYPE_INVALID: StdVideoH264PictureType = + 2147483647; +pub type StdVideoH264PictureType = ::std::os::raw::c_uint; #[repr(C)] #[repr(align(4))] #[derive(Debug, Copy, Clone)] @@ -626,8 +629,8 @@ pub struct StdVideoH264SequenceParameterSetVui { pub matrix_coefficients: u8, pub num_units_in_tick: u32, pub time_scale: u32, - pub hrd_parameters: StdVideoH264HrdParameters, - pub num_reorder_frames: u8, + pub pHrdParameters: *mut StdVideoH264HrdParameters, + pub max_num_reorder_frames: u8, pub max_dec_frame_buffering: u8, pub flags: StdVideoH264SpsVuiFlags, } @@ -635,12 +638,12 @@ pub struct StdVideoH264SequenceParameterSetVui { fn bindgen_test_layout_StdVideoH264SequenceParameterSetVui() { assert_eq!( ::std::mem::size_of::(), - 336usize, + 40usize, concat!("Size of: ", stringify!(StdVideoH264SequenceParameterSetVui)) ); assert_eq!( ::std::mem::align_of::(), - 4usize, + 8usize, concat!( "Alignment of ", stringify!(StdVideoH264SequenceParameterSetVui) @@ -765,28 +768,28 @@ fn bindgen_test_layout_StdVideoH264SequenceParameterSetVui() { ); assert_eq!( unsafe { - &(*(::std::ptr::null::())).hrd_parameters + &(*(::std::ptr::null::())).pHrdParameters as *const _ as usize }, - 20usize, + 24usize, concat!( "Offset of field: ", stringify!(StdVideoH264SequenceParameterSetVui), "::", - stringify!(hrd_parameters) + stringify!(pHrdParameters) ) ); assert_eq!( unsafe { - &(*(::std::ptr::null::())).num_reorder_frames + &(*(::std::ptr::null::())).max_num_reorder_frames as *const _ as usize }, - 328usize, + 32usize, concat!( "Offset of field: ", stringify!(StdVideoH264SequenceParameterSetVui), "::", - stringify!(num_reorder_frames) + stringify!(max_num_reorder_frames) ) ); assert_eq!( @@ -794,7 +797,7 @@ fn bindgen_test_layout_StdVideoH264SequenceParameterSetVui() { &(*(::std::ptr::null::())).max_dec_frame_buffering as *const _ as usize }, - 329usize, + 33usize, concat!( "Offset of field: ", stringify!(StdVideoH264SequenceParameterSetVui), @@ -807,7 +810,7 @@ fn bindgen_test_layout_StdVideoH264SequenceParameterSetVui() { &(*(::std::ptr::null::())).flags as *const _ as usize }, - 332usize, + 36usize, concat!( "Offset of field: ", stringify!(StdVideoH264SequenceParameterSetVui), @@ -821,8 +824,8 @@ fn bindgen_test_layout_StdVideoH264SequenceParameterSetVui() { #[derive(Debug, Copy, Clone)] pub struct StdVideoH264SpsFlags { pub _bitfield_align_1: [u8; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 3usize]>, - pub __bindgen_padding_0: u8, + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>, + pub __bindgen_padding_0: u16, } #[test] fn bindgen_test_layout_StdVideoH264SpsFlags() { @@ -949,11 +952,11 @@ impl StdVideoH264SpsFlags { } } #[inline] - pub fn residual_colour_transform_flag(&self) -> u32 { + pub fn separate_colour_plane_flag(&self) -> u32 { unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u32) } } #[inline] - pub fn set_residual_colour_transform_flag(&mut self, val: u32) { + pub fn set_separate_colour_plane_flag(&mut self, val: u32) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(10usize, 1u8, val as u64) @@ -971,58 +974,47 @@ impl StdVideoH264SpsFlags { } } #[inline] - pub fn first_picture_after_seek_flag(&self) -> u32 { + pub fn qpprime_y_zero_transform_bypass_flag(&self) -> u32 { unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u32) } } #[inline] - pub fn set_first_picture_after_seek_flag(&mut self, val: u32) { + pub fn set_qpprime_y_zero_transform_bypass_flag(&mut self, val: u32) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(12usize, 1u8, val as u64) } } #[inline] - pub fn qpprime_y_zero_transform_bypass_flag(&self) -> u32 { + pub fn frame_cropping_flag(&self) -> u32 { unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u32) } } #[inline] - pub fn set_qpprime_y_zero_transform_bypass_flag(&mut self, val: u32) { + pub fn set_frame_cropping_flag(&mut self, val: u32) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(13usize, 1u8, val as u64) } } #[inline] - pub fn frame_cropping_flag(&self) -> u32 { + pub fn seq_scaling_matrix_present_flag(&self) -> u32 { unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u32) } } #[inline] - pub fn set_frame_cropping_flag(&mut self, val: u32) { + pub fn set_seq_scaling_matrix_present_flag(&mut self, val: u32) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(14usize, 1u8, val as u64) } } #[inline] - pub fn scaling_matrix_present_flag(&self) -> u32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u32) } - } - #[inline] - pub fn set_scaling_matrix_present_flag(&mut self, val: u32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(15usize, 1u8, val as u64) - } - } - #[inline] pub fn vui_parameters_present_flag(&self) -> u32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 1u8) as u32) } + unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u32) } } #[inline] pub fn set_vui_parameters_present_flag(&mut self, val: u32) { unsafe { let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(16usize, 1u8, val as u64) + self._bitfield_1.set(15usize, 1u8, val as u64) } } #[inline] @@ -1037,15 +1029,14 @@ impl StdVideoH264SpsFlags { mb_adaptive_frame_field_flag: u32, frame_mbs_only_flag: u32, delta_pic_order_always_zero_flag: u32, - residual_colour_transform_flag: u32, + separate_colour_plane_flag: u32, gaps_in_frame_num_value_allowed_flag: u32, - first_picture_after_seek_flag: u32, qpprime_y_zero_transform_bypass_flag: u32, frame_cropping_flag: u32, - scaling_matrix_present_flag: u32, + seq_scaling_matrix_present_flag: u32, vui_parameters_present_flag: u32, - ) -> __BindgenBitfieldUnit<[u8; 3usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 3usize]> = Default::default(); + ) -> __BindgenBitfieldUnit<[u8; 2usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> = Default::default(); __bindgen_bitfield_unit.set(0usize, 1u8, { let constraint_set0_flag: u32 = unsafe { ::std::mem::transmute(constraint_set0_flag) }; constraint_set0_flag as u64 @@ -1090,9 +1081,9 @@ impl StdVideoH264SpsFlags { delta_pic_order_always_zero_flag as u64 }); __bindgen_bitfield_unit.set(10usize, 1u8, { - let residual_colour_transform_flag: u32 = - unsafe { ::std::mem::transmute(residual_colour_transform_flag) }; - residual_colour_transform_flag as u64 + let separate_colour_plane_flag: u32 = + unsafe { ::std::mem::transmute(separate_colour_plane_flag) }; + separate_colour_plane_flag as u64 }); __bindgen_bitfield_unit.set(11usize, 1u8, { let gaps_in_frame_num_value_allowed_flag: u32 = @@ -1100,25 +1091,20 @@ impl StdVideoH264SpsFlags { gaps_in_frame_num_value_allowed_flag as u64 }); __bindgen_bitfield_unit.set(12usize, 1u8, { - let first_picture_after_seek_flag: u32 = - unsafe { ::std::mem::transmute(first_picture_after_seek_flag) }; - first_picture_after_seek_flag as u64 - }); - __bindgen_bitfield_unit.set(13usize, 1u8, { let qpprime_y_zero_transform_bypass_flag: u32 = unsafe { ::std::mem::transmute(qpprime_y_zero_transform_bypass_flag) }; qpprime_y_zero_transform_bypass_flag as u64 }); - __bindgen_bitfield_unit.set(14usize, 1u8, { + __bindgen_bitfield_unit.set(13usize, 1u8, { let frame_cropping_flag: u32 = unsafe { ::std::mem::transmute(frame_cropping_flag) }; frame_cropping_flag as u64 }); - __bindgen_bitfield_unit.set(15usize, 1u8, { - let scaling_matrix_present_flag: u32 = - unsafe { ::std::mem::transmute(scaling_matrix_present_flag) }; - scaling_matrix_present_flag as u64 + __bindgen_bitfield_unit.set(14usize, 1u8, { + let seq_scaling_matrix_present_flag: u32 = + unsafe { ::std::mem::transmute(seq_scaling_matrix_present_flag) }; + seq_scaling_matrix_present_flag as u64 }); - __bindgen_bitfield_unit.set(16usize, 1u8, { + __bindgen_bitfield_unit.set(15usize, 1u8, { let vui_parameters_present_flag: u32 = unsafe { ::std::mem::transmute(vui_parameters_present_flag) }; vui_parameters_present_flag as u64 @@ -1198,7 +1184,7 @@ fn bindgen_test_layout_StdVideoH264ScalingLists() { ); } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Debug, Copy, Clone)] pub struct StdVideoH264SequenceParameterSet { pub profile_idc: StdVideoH264ProfileIdc, pub level_idc: StdVideoH264Level, @@ -1220,7 +1206,7 @@ pub struct StdVideoH264SequenceParameterSet { pub frame_crop_top_offset: u32, pub frame_crop_bottom_offset: u32, pub flags: StdVideoH264SpsFlags, - pub offset_for_ref_frame: [i32; 255usize], + pub pOffsetForRefFrame: *mut i32, pub pScalingLists: *mut StdVideoH264ScalingLists, pub pSequenceParameterSetVui: *mut StdVideoH264SequenceParameterSetVui, } @@ -1228,7 +1214,7 @@ pub struct StdVideoH264SequenceParameterSet { fn bindgen_test_layout_StdVideoH264SequenceParameterSet() { assert_eq!( ::std::mem::size_of::(), - 1104usize, + 96usize, concat!("Size of: ", stringify!(StdVideoH264SequenceParameterSet)) ); assert_eq!( @@ -1500,15 +1486,15 @@ fn bindgen_test_layout_StdVideoH264SequenceParameterSet() { ); assert_eq!( unsafe { - &(*(::std::ptr::null::())).offset_for_ref_frame + &(*(::std::ptr::null::())).pOffsetForRefFrame as *const _ as usize }, - 68usize, + 72usize, concat!( "Offset of field: ", stringify!(StdVideoH264SequenceParameterSet), "::", - stringify!(offset_for_ref_frame) + stringify!(pOffsetForRefFrame) ) ); assert_eq!( @@ -1516,7 +1502,7 @@ fn bindgen_test_layout_StdVideoH264SequenceParameterSet() { &(*(::std::ptr::null::())).pScalingLists as *const _ as usize }, - 1088usize, + 80usize, concat!( "Offset of field: ", stringify!(StdVideoH264SequenceParameterSet), @@ -1529,7 +1515,7 @@ fn bindgen_test_layout_StdVideoH264SequenceParameterSet() { &(*(::std::ptr::null::())).pSequenceParameterSetVui as *const _ as usize }, - 1096usize, + 88usize, concat!( "Offset of field: ", stringify!(StdVideoH264SequenceParameterSet), @@ -1649,11 +1635,11 @@ impl StdVideoH264PpsFlags { } } #[inline] - pub fn scaling_matrix_present_flag(&self) -> u32 { + pub fn pic_scaling_matrix_present_flag(&self) -> u32 { unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u32) } } #[inline] - pub fn set_scaling_matrix_present_flag(&mut self, val: u32) { + pub fn set_pic_scaling_matrix_present_flag(&mut self, val: u32) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(8usize, 1u8, val as u64) @@ -1669,7 +1655,7 @@ impl StdVideoH264PpsFlags { weighted_pred_flag: u32, pic_order_present_flag: u32, entropy_coding_mode_flag: u32, - scaling_matrix_present_flag: u32, + pic_scaling_matrix_present_flag: u32, ) -> __BindgenBitfieldUnit<[u8; 2usize]> { let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> = Default::default(); __bindgen_bitfield_unit.set(0usize, 1u8, { @@ -1712,9 +1698,9 @@ impl StdVideoH264PpsFlags { entropy_coding_mode_flag as u64 }); __bindgen_bitfield_unit.set(8usize, 1u8, { - let scaling_matrix_present_flag: u32 = - unsafe { ::std::mem::transmute(scaling_matrix_present_flag) }; - scaling_matrix_present_flag as u64 + let pic_scaling_matrix_present_flag: u32 = + unsafe { ::std::mem::transmute(pic_scaling_matrix_present_flag) }; + pic_scaling_matrix_present_flag as u64 }); __bindgen_bitfield_unit } @@ -1726,7 +1712,7 @@ pub struct StdVideoH264PictureParameterSet { pub pic_parameter_set_id: u8, pub num_ref_idx_l0_default_active_minus1: u8, pub num_ref_idx_l1_default_active_minus1: u8, - pub weighted_bipred_idc: StdVideoH264WeightedBiPredIdc, + pub weighted_bipred_idc: StdVideoH264WeightedBipredIdc, pub pic_init_qp_minus26: i8, pub pic_init_qs_minus26: i8, pub chroma_qp_index_offset: i8, @@ -1937,42 +1923,54 @@ impl StdVideoDecodeH264PictureInfoFlags { } } #[inline] - pub fn bottom_field_flag(&self) -> u32 { + pub fn IdrPicFlag(&self) -> u32 { unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } } #[inline] - pub fn set_bottom_field_flag(&mut self, val: u32) { + pub fn set_IdrPicFlag(&mut self, val: u32) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(2usize, 1u8, val as u64) } } #[inline] - pub fn is_reference(&self) -> u32 { + pub fn bottom_field_flag(&self) -> u32 { unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } } #[inline] - pub fn set_is_reference(&mut self, val: u32) { + pub fn set_bottom_field_flag(&mut self, val: u32) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(3usize, 1u8, val as u64) } } #[inline] - pub fn complementary_field_pair(&self) -> u32 { + pub fn is_reference(&self) -> u32 { unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } } #[inline] - pub fn set_complementary_field_pair(&mut self, val: u32) { + pub fn set_is_reference(&mut self, val: u32) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(4usize, 1u8, val as u64) } } #[inline] + pub fn complementary_field_pair(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) } + } + #[inline] + pub fn set_complementary_field_pair(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(5usize, 1u8, val as u64) + } + } + #[inline] pub fn new_bitfield_1( field_pic_flag: u32, is_intra: u32, + IdrPicFlag: u32, bottom_field_flag: u32, is_reference: u32, complementary_field_pair: u32, @@ -1987,14 +1985,18 @@ impl StdVideoDecodeH264PictureInfoFlags { is_intra as u64 }); __bindgen_bitfield_unit.set(2usize, 1u8, { + let IdrPicFlag: u32 = unsafe { ::std::mem::transmute(IdrPicFlag) }; + IdrPicFlag as u64 + }); + __bindgen_bitfield_unit.set(3usize, 1u8, { let bottom_field_flag: u32 = unsafe { ::std::mem::transmute(bottom_field_flag) }; bottom_field_flag as u64 }); - __bindgen_bitfield_unit.set(3usize, 1u8, { + __bindgen_bitfield_unit.set(4usize, 1u8, { let is_reference: u32 = unsafe { ::std::mem::transmute(is_reference) }; is_reference as u64 }); - __bindgen_bitfield_unit.set(4usize, 1u8, { + __bindgen_bitfield_unit.set(5usize, 1u8, { let complementary_field_pair: u32 = unsafe { ::std::mem::transmute(complementary_field_pair) }; complementary_field_pair as u64 @@ -2614,32 +2616,45 @@ fn bindgen_test_layout_StdVideoDecodeH264Mvc() { ) ); } -pub const StdVideoH265ProfileIdc_std_video_h265_profile_idc_main: StdVideoH265ProfileIdc = 1; -pub const StdVideoH265ProfileIdc_std_video_h265_profile_idc_main_10: StdVideoH265ProfileIdc = 2; -pub const StdVideoH265ProfileIdc_std_video_h265_profile_idc_main_still_picture: +pub const StdVideoH265ProfileIdc_STD_VIDEO_H265_PROFILE_IDC_MAIN: StdVideoH265ProfileIdc = 1; +pub const StdVideoH265ProfileIdc_STD_VIDEO_H265_PROFILE_IDC_MAIN_10: StdVideoH265ProfileIdc = 2; +pub const StdVideoH265ProfileIdc_STD_VIDEO_H265_PROFILE_IDC_MAIN_STILL_PICTURE: StdVideoH265ProfileIdc = 3; -pub const StdVideoH265ProfileIdc_std_video_h265_profile_idc_format_range_extensions: +pub const StdVideoH265ProfileIdc_STD_VIDEO_H265_PROFILE_IDC_FORMAT_RANGE_EXTENSIONS: StdVideoH265ProfileIdc = 4; -pub const StdVideoH265ProfileIdc_std_video_h265_profile_idc_scc_extensions: StdVideoH265ProfileIdc = +pub const StdVideoH265ProfileIdc_STD_VIDEO_H265_PROFILE_IDC_SCC_EXTENSIONS: StdVideoH265ProfileIdc = 9; -pub const StdVideoH265ProfileIdc_std_video_h265_profile_idc_invalid: StdVideoH265ProfileIdc = +pub const StdVideoH265ProfileIdc_STD_VIDEO_H265_PROFILE_IDC_INVALID: StdVideoH265ProfileIdc = 2147483647; pub type StdVideoH265ProfileIdc = ::std::os::raw::c_uint; -pub const StdVideoH265Level_std_video_h265_level_1_0: StdVideoH265Level = 0; -pub const StdVideoH265Level_std_video_h265_level_2_0: StdVideoH265Level = 1; -pub const StdVideoH265Level_std_video_h265_level_2_1: StdVideoH265Level = 2; -pub const StdVideoH265Level_std_video_h265_level_3_0: StdVideoH265Level = 3; -pub const StdVideoH265Level_std_video_h265_level_3_1: StdVideoH265Level = 4; -pub const StdVideoH265Level_std_video_h265_level_4_0: StdVideoH265Level = 5; -pub const StdVideoH265Level_std_video_h265_level_4_1: StdVideoH265Level = 6; -pub const StdVideoH265Level_std_video_h265_level_5_0: StdVideoH265Level = 7; -pub const StdVideoH265Level_std_video_h265_level_5_1: StdVideoH265Level = 8; -pub const StdVideoH265Level_std_video_h265_level_5_2: StdVideoH265Level = 9; -pub const StdVideoH265Level_std_video_h265_level_6_0: StdVideoH265Level = 10; -pub const StdVideoH265Level_std_video_h265_level_6_1: StdVideoH265Level = 11; -pub const StdVideoH265Level_std_video_h265_level_6_2: StdVideoH265Level = 12; -pub const StdVideoH265Level_std_video_h265_level_invalid: StdVideoH265Level = 2147483647; +pub const StdVideoH265Level_STD_VIDEO_H265_LEVEL_1_0: StdVideoH265Level = 0; +pub const StdVideoH265Level_STD_VIDEO_H265_LEVEL_2_0: StdVideoH265Level = 1; +pub const StdVideoH265Level_STD_VIDEO_H265_LEVEL_2_1: StdVideoH265Level = 2; +pub const StdVideoH265Level_STD_VIDEO_H265_LEVEL_3_0: StdVideoH265Level = 3; +pub const StdVideoH265Level_STD_VIDEO_H265_LEVEL_3_1: StdVideoH265Level = 4; +pub const StdVideoH265Level_STD_VIDEO_H265_LEVEL_4_0: StdVideoH265Level = 5; +pub const StdVideoH265Level_STD_VIDEO_H265_LEVEL_4_1: StdVideoH265Level = 6; +pub const StdVideoH265Level_STD_VIDEO_H265_LEVEL_5_0: StdVideoH265Level = 7; +pub const StdVideoH265Level_STD_VIDEO_H265_LEVEL_5_1: StdVideoH265Level = 8; +pub const StdVideoH265Level_STD_VIDEO_H265_LEVEL_5_2: StdVideoH265Level = 9; +pub const StdVideoH265Level_STD_VIDEO_H265_LEVEL_6_0: StdVideoH265Level = 10; +pub const StdVideoH265Level_STD_VIDEO_H265_LEVEL_6_1: StdVideoH265Level = 11; +pub const StdVideoH265Level_STD_VIDEO_H265_LEVEL_6_2: StdVideoH265Level = 12; +pub const StdVideoH265Level_STD_VIDEO_H265_LEVEL_INVALID: StdVideoH265Level = 2147483647; pub type StdVideoH265Level = ::std::os::raw::c_uint; +pub const StdVideoH265SliceType_STD_VIDEO_H265_SLICE_TYPE_B: StdVideoH265SliceType = 0; +pub const StdVideoH265SliceType_STD_VIDEO_H265_SLICE_TYPE_P: StdVideoH265SliceType = 1; +pub const StdVideoH265SliceType_STD_VIDEO_H265_SLICE_TYPE_I: StdVideoH265SliceType = 2; +pub const StdVideoH265SliceType_STD_VIDEO_H265_SLICE_TYPE_INVALID: StdVideoH265SliceType = + 2147483647; +pub type StdVideoH265SliceType = ::std::os::raw::c_uint; +pub const StdVideoH265PictureType_STD_VIDEO_H265_PICTURE_TYPE_P: StdVideoH265PictureType = 0; +pub const StdVideoH265PictureType_STD_VIDEO_H265_PICTURE_TYPE_B: StdVideoH265PictureType = 1; +pub const StdVideoH265PictureType_STD_VIDEO_H265_PICTURE_TYPE_I: StdVideoH265PictureType = 2; +pub const StdVideoH265PictureType_STD_VIDEO_H265_PICTURE_TYPE_IDR: StdVideoH265PictureType = 3; +pub const StdVideoH265PictureType_STD_VIDEO_H265_PICTURE_TYPE_INVALID: StdVideoH265PictureType = + 2147483647; +pub type StdVideoH265PictureType = ::std::os::raw::c_uint; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct StdVideoH265DecPicBufMgr { @@ -2794,10 +2809,7 @@ fn bindgen_test_layout_StdVideoH265SubLayerHrdParameters() { #[derive(Debug, Copy, Clone)] pub struct StdVideoH265HrdFlags { pub _bitfield_align_1: [u8; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, - pub fixed_pic_rate_general_flag: u8, - pub fixed_pic_rate_within_cvs_flag: u8, - pub low_delay_hrd_flag: u8, + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, } #[test] fn bindgen_test_layout_StdVideoH265HrdFlags() { @@ -2811,44 +2823,6 @@ fn bindgen_test_layout_StdVideoH265HrdFlags() { 4usize, concat!("Alignment of ", stringify!(StdVideoH265HrdFlags)) ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).fixed_pic_rate_general_flag as *const _ - as usize - }, - 1usize, - concat!( - "Offset of field: ", - stringify!(StdVideoH265HrdFlags), - "::", - stringify!(fixed_pic_rate_general_flag) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).fixed_pic_rate_within_cvs_flag - as *const _ as usize - }, - 2usize, - concat!( - "Offset of field: ", - stringify!(StdVideoH265HrdFlags), - "::", - stringify!(fixed_pic_rate_within_cvs_flag) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).low_delay_hrd_flag as *const _ as usize - }, - 3usize, - concat!( - "Offset of field: ", - stringify!(StdVideoH265HrdFlags), - "::", - stringify!(low_delay_hrd_flag) - ) - ); } impl StdVideoH265HrdFlags { #[inline] @@ -2896,13 +2870,49 @@ impl StdVideoH265HrdFlags { } } #[inline] + pub fn fixed_pic_rate_general_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 8u8) as u32) } + } + #[inline] + pub fn set_fixed_pic_rate_general_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 8u8, val as u64) + } + } + #[inline] + pub fn fixed_pic_rate_within_cvs_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 8u8) as u32) } + } + #[inline] + pub fn set_fixed_pic_rate_within_cvs_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(12usize, 8u8, val as u64) + } + } + #[inline] + pub fn low_delay_hrd_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(20usize, 8u8) as u32) } + } + #[inline] + pub fn set_low_delay_hrd_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(20usize, 8u8, val as u64) + } + } + #[inline] pub fn new_bitfield_1( nal_hrd_parameters_present_flag: u32, vcl_hrd_parameters_present_flag: u32, sub_pic_hrd_params_present_flag: u32, sub_pic_cpb_params_in_pic_timing_sei_flag: u32, - ) -> __BindgenBitfieldUnit<[u8; 1usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + fixed_pic_rate_general_flag: u32, + fixed_pic_rate_within_cvs_flag: u32, + low_delay_hrd_flag: u32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); __bindgen_bitfield_unit.set(0usize, 1u8, { let nal_hrd_parameters_present_flag: u32 = unsafe { ::std::mem::transmute(nal_hrd_parameters_present_flag) }; @@ -2923,6 +2933,20 @@ impl StdVideoH265HrdFlags { unsafe { ::std::mem::transmute(sub_pic_cpb_params_in_pic_timing_sei_flag) }; sub_pic_cpb_params_in_pic_timing_sei_flag as u64 }); + __bindgen_bitfield_unit.set(4usize, 8u8, { + let fixed_pic_rate_general_flag: u32 = + unsafe { ::std::mem::transmute(fixed_pic_rate_general_flag) }; + fixed_pic_rate_general_flag as u64 + }); + __bindgen_bitfield_unit.set(12usize, 8u8, { + let fixed_pic_rate_within_cvs_flag: u32 = + unsafe { ::std::mem::transmute(fixed_pic_rate_within_cvs_flag) }; + fixed_pic_rate_within_cvs_flag as u64 + }); + __bindgen_bitfield_unit.set(20usize, 8u8, { + let low_delay_hrd_flag: u32 = unsafe { ::std::mem::transmute(low_delay_hrd_flag) }; + low_delay_hrd_flag as u64 + }); __bindgen_bitfield_unit } } @@ -2940,8 +2964,8 @@ pub struct StdVideoH265HrdParameters { pub dpb_output_delay_length_minus1: u8, pub cpb_cnt_minus1: [u8; 7usize], pub elemental_duration_in_tc_minus1: [u16; 7usize], - pub SubLayerHrdParametersNal: [*mut StdVideoH265SubLayerHrdParameters; 7usize], - pub SubLayerHrdParametersVcl: [*mut StdVideoH265SubLayerHrdParameters; 7usize], + pub pSubLayerHrdParametersNal: [*mut StdVideoH265SubLayerHrdParameters; 7usize], + pub pSubLayerHrdParametersVcl: [*mut StdVideoH265SubLayerHrdParameters; 7usize], pub flags: StdVideoH265HrdFlags, } #[test] @@ -3101,7 +3125,7 @@ fn bindgen_test_layout_StdVideoH265HrdParameters() { ); assert_eq!( unsafe { - &(*(::std::ptr::null::())).SubLayerHrdParametersNal + &(*(::std::ptr::null::())).pSubLayerHrdParametersNal as *const _ as usize }, 32usize, @@ -3109,12 +3133,12 @@ fn bindgen_test_layout_StdVideoH265HrdParameters() { "Offset of field: ", stringify!(StdVideoH265HrdParameters), "::", - stringify!(SubLayerHrdParametersNal) + stringify!(pSubLayerHrdParametersNal) ) ); assert_eq!( unsafe { - &(*(::std::ptr::null::())).SubLayerHrdParametersVcl + &(*(::std::ptr::null::())).pSubLayerHrdParametersVcl as *const _ as usize }, 88usize, @@ -3122,7 +3146,7 @@ fn bindgen_test_layout_StdVideoH265HrdParameters() { "Offset of field: ", stringify!(StdVideoH265HrdParameters), "::", - stringify!(SubLayerHrdParametersVcl) + stringify!(pSubLayerHrdParametersVcl) ) ); assert_eq!( @@ -3242,7 +3266,7 @@ pub struct StdVideoH265VideoParameterSet { pub vps_time_scale: u32, pub vps_num_ticks_poc_diff_one_minus1: u32, pub pDecPicBufMgr: *mut StdVideoH265DecPicBufMgr, - pub hrd_parameters: *mut StdVideoH265HrdParameters, + pub pHrdParameters: *mut StdVideoH265HrdParameters, pub flags: StdVideoH265VpsFlags, } #[test] @@ -3337,7 +3361,7 @@ fn bindgen_test_layout_StdVideoH265VideoParameterSet() { ); assert_eq!( unsafe { - &(*(::std::ptr::null::())).hrd_parameters as *const _ + &(*(::std::ptr::null::())).pHrdParameters as *const _ as usize }, 24usize, @@ -3345,7 +3369,7 @@ fn bindgen_test_layout_StdVideoH265VideoParameterSet() { "Offset of field: ", stringify!(StdVideoH265VideoParameterSet), "::", - stringify!(hrd_parameters) + stringify!(pHrdParameters) ) ); assert_eq!( @@ -3813,7 +3837,7 @@ pub struct StdVideoH265SequenceParameterSetVui { pub vui_num_units_in_tick: u32, pub vui_time_scale: u32, pub vui_num_ticks_poc_diff_one_minus1: u32, - pub hrd_parameters: *mut StdVideoH265HrdParameters, + pub pHrdParameters: *mut StdVideoH265HrdParameters, pub min_spatial_segmentation_idc: u16, pub max_bytes_per_pic_denom: u8, pub max_bits_per_min_cu_denom: u8, @@ -4046,7 +4070,7 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSetVui() { ); assert_eq!( unsafe { - &(*(::std::ptr::null::())).hrd_parameters + &(*(::std::ptr::null::())).pHrdParameters as *const _ as usize }, 32usize, @@ -4054,7 +4078,7 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSetVui() { "Offset of field: ", stringify!(StdVideoH265SequenceParameterSetVui), "::", - stringify!(hrd_parameters) + stringify!(pHrdParameters) ) ); assert_eq!( @@ -7437,3 +7461,1243 @@ fn bindgen_test_layout_StdVideoEncodeH264SliceHeader() { ) ); } +#[repr(C)] +#[repr(align(4))] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoEncodeH265SliceHeaderFlags { + pub _bitfield_align_1: [u32; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + pub luma_weight_l0_flag: u16, + pub chroma_weight_l0_flag: u16, + pub luma_weight_l1_flag: u16, + pub chroma_weight_l1_flag: u16, +} +#[test] +fn bindgen_test_layout_StdVideoEncodeH265SliceHeaderFlags() { + assert_eq!( + ::std::mem::size_of::(), + 12usize, + concat!("Size of: ", stringify!(StdVideoEncodeH265SliceHeaderFlags)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(StdVideoEncodeH265SliceHeaderFlags) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).luma_weight_l0_flag + as *const _ as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265SliceHeaderFlags), + "::", + stringify!(luma_weight_l0_flag) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).chroma_weight_l0_flag + as *const _ as usize + }, + 6usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265SliceHeaderFlags), + "::", + stringify!(chroma_weight_l0_flag) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).luma_weight_l1_flag + as *const _ as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265SliceHeaderFlags), + "::", + stringify!(luma_weight_l1_flag) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).chroma_weight_l1_flag + as *const _ as usize + }, + 10usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265SliceHeaderFlags), + "::", + stringify!(chroma_weight_l1_flag) + ) + ); +} +impl StdVideoEncodeH265SliceHeaderFlags { + #[inline] + pub fn first_slice_segment_in_pic_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_first_slice_segment_in_pic_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub fn no_output_of_prior_pics_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_no_output_of_prior_pics_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub fn dependent_slice_segment_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } + } + #[inline] + pub fn set_dependent_slice_segment_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub fn short_term_ref_pic_set_sps_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } + } + #[inline] + pub fn set_short_term_ref_pic_set_sps_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 1u8, val as u64) + } + } + #[inline] + pub fn slice_temporal_mvp_enable_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } + } + #[inline] + pub fn set_slice_temporal_mvp_enable_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 1u8, val as u64) + } + } + #[inline] + pub fn slice_sao_luma_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) } + } + #[inline] + pub fn set_slice_sao_luma_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(5usize, 1u8, val as u64) + } + } + #[inline] + pub fn slice_sao_chroma_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) } + } + #[inline] + pub fn set_slice_sao_chroma_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(6usize, 1u8, val as u64) + } + } + #[inline] + pub fn num_ref_idx_active_override_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) } + } + #[inline] + pub fn set_num_ref_idx_active_override_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(7usize, 1u8, val as u64) + } + } + #[inline] + pub fn mvd_l1_zero_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u32) } + } + #[inline] + pub fn set_mvd_l1_zero_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(8usize, 1u8, val as u64) + } + } + #[inline] + pub fn cabac_init_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u32) } + } + #[inline] + pub fn set_cabac_init_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(9usize, 1u8, val as u64) + } + } + #[inline] + pub fn slice_deblocking_filter_disable_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u32) } + } + #[inline] + pub fn set_slice_deblocking_filter_disable_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(10usize, 1u8, val as u64) + } + } + #[inline] + pub fn collocated_from_l0_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u32) } + } + #[inline] + pub fn set_collocated_from_l0_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(11usize, 1u8, val as u64) + } + } + #[inline] + pub fn slice_loop_filter_across_slices_enabled_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u32) } + } + #[inline] + pub fn set_slice_loop_filter_across_slices_enabled_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(12usize, 1u8, val as u64) + } + } + #[inline] + pub fn bLastSliceInPic(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u32) } + } + #[inline] + pub fn set_bLastSliceInPic(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(13usize, 1u8, val as u64) + } + } + #[inline] + pub fn reservedBits(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 18u8) as u32) } + } + #[inline] + pub fn set_reservedBits(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(14usize, 18u8, val as u64) + } + } + #[inline] + pub fn new_bitfield_1( + first_slice_segment_in_pic_flag: u32, + no_output_of_prior_pics_flag: u32, + dependent_slice_segment_flag: u32, + short_term_ref_pic_set_sps_flag: u32, + slice_temporal_mvp_enable_flag: u32, + slice_sao_luma_flag: u32, + slice_sao_chroma_flag: u32, + num_ref_idx_active_override_flag: u32, + mvd_l1_zero_flag: u32, + cabac_init_flag: u32, + slice_deblocking_filter_disable_flag: u32, + collocated_from_l0_flag: u32, + slice_loop_filter_across_slices_enabled_flag: u32, + bLastSliceInPic: u32, + reservedBits: u32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let first_slice_segment_in_pic_flag: u32 = + unsafe { ::std::mem::transmute(first_slice_segment_in_pic_flag) }; + first_slice_segment_in_pic_flag as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let no_output_of_prior_pics_flag: u32 = + unsafe { ::std::mem::transmute(no_output_of_prior_pics_flag) }; + no_output_of_prior_pics_flag as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let dependent_slice_segment_flag: u32 = + unsafe { ::std::mem::transmute(dependent_slice_segment_flag) }; + dependent_slice_segment_flag as u64 + }); + __bindgen_bitfield_unit.set(3usize, 1u8, { + let short_term_ref_pic_set_sps_flag: u32 = + unsafe { ::std::mem::transmute(short_term_ref_pic_set_sps_flag) }; + short_term_ref_pic_set_sps_flag as u64 + }); + __bindgen_bitfield_unit.set(4usize, 1u8, { + let slice_temporal_mvp_enable_flag: u32 = + unsafe { ::std::mem::transmute(slice_temporal_mvp_enable_flag) }; + slice_temporal_mvp_enable_flag as u64 + }); + __bindgen_bitfield_unit.set(5usize, 1u8, { + let slice_sao_luma_flag: u32 = unsafe { ::std::mem::transmute(slice_sao_luma_flag) }; + slice_sao_luma_flag as u64 + }); + __bindgen_bitfield_unit.set(6usize, 1u8, { + let slice_sao_chroma_flag: u32 = + unsafe { ::std::mem::transmute(slice_sao_chroma_flag) }; + slice_sao_chroma_flag as u64 + }); + __bindgen_bitfield_unit.set(7usize, 1u8, { + let num_ref_idx_active_override_flag: u32 = + unsafe { ::std::mem::transmute(num_ref_idx_active_override_flag) }; + num_ref_idx_active_override_flag as u64 + }); + __bindgen_bitfield_unit.set(8usize, 1u8, { + let mvd_l1_zero_flag: u32 = unsafe { ::std::mem::transmute(mvd_l1_zero_flag) }; + mvd_l1_zero_flag as u64 + }); + __bindgen_bitfield_unit.set(9usize, 1u8, { + let cabac_init_flag: u32 = unsafe { ::std::mem::transmute(cabac_init_flag) }; + cabac_init_flag as u64 + }); + __bindgen_bitfield_unit.set(10usize, 1u8, { + let slice_deblocking_filter_disable_flag: u32 = + unsafe { ::std::mem::transmute(slice_deblocking_filter_disable_flag) }; + slice_deblocking_filter_disable_flag as u64 + }); + __bindgen_bitfield_unit.set(11usize, 1u8, { + let collocated_from_l0_flag: u32 = + unsafe { ::std::mem::transmute(collocated_from_l0_flag) }; + collocated_from_l0_flag as u64 + }); + __bindgen_bitfield_unit.set(12usize, 1u8, { + let slice_loop_filter_across_slices_enabled_flag: u32 = + unsafe { ::std::mem::transmute(slice_loop_filter_across_slices_enabled_flag) }; + slice_loop_filter_across_slices_enabled_flag as u64 + }); + __bindgen_bitfield_unit.set(13usize, 1u8, { + let bLastSliceInPic: u32 = unsafe { ::std::mem::transmute(bLastSliceInPic) }; + bLastSliceInPic as u64 + }); + __bindgen_bitfield_unit.set(14usize, 18u8, { + let reservedBits: u32 = unsafe { ::std::mem::transmute(reservedBits) }; + reservedBits as u64 + }); + __bindgen_bitfield_unit + } +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoEncodeH265SliceHeader { + pub slice_type: StdVideoH265SliceType, + pub slice_pic_parameter_set_id: u8, + pub num_short_term_ref_pic_sets: u8, + pub slice_segment_address: u32, + pub short_term_ref_pic_set_idx: u8, + pub num_long_term_sps: u8, + pub num_long_term_pics: u8, + pub collocated_ref_idx: u8, + pub num_ref_idx_l0_active_minus1: u8, + pub num_ref_idx_l1_active_minus1: u8, + pub luma_log2_weight_denom: u8, + pub delta_chroma_log2_weight_denom: i8, + pub delta_luma_weight_l0: [i8; 15usize], + pub luma_offset_l0: [i8; 15usize], + pub delta_chroma_weight_l0: [[i8; 2usize]; 15usize], + pub delta_chroma_offset_l0: [[i8; 2usize]; 15usize], + pub delta_luma_weight_l1: [i8; 15usize], + pub luma_offset_l1: [i8; 15usize], + pub delta_chroma_weight_l1: [[i8; 2usize]; 15usize], + pub delta_chroma_offset_l1: [[i8; 2usize]; 15usize], + pub MaxNumMergeCand: u8, + pub slice_qp_delta: i8, + pub slice_cb_qp_offset: i8, + pub slice_cr_qp_offset: i8, + pub slice_beta_offset_div2: i8, + pub slice_tc_offset_div2: i8, + pub slice_act_y_qp_offset: i8, + pub slice_act_cb_qp_offset: i8, + pub slice_act_cr_qp_offset: i8, + pub flags: StdVideoEncodeH265SliceHeaderFlags, +} +#[test] +fn bindgen_test_layout_StdVideoEncodeH265SliceHeader() { + assert_eq!( + ::std::mem::size_of::(), + 224usize, + concat!("Size of: ", stringify!(StdVideoEncodeH265SliceHeader)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(StdVideoEncodeH265SliceHeader)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).slice_type as *const _ + as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265SliceHeader), + "::", + stringify!(slice_type) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).slice_pic_parameter_set_id + as *const _ as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265SliceHeader), + "::", + stringify!(slice_pic_parameter_set_id) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).num_short_term_ref_pic_sets + as *const _ as usize + }, + 5usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265SliceHeader), + "::", + stringify!(num_short_term_ref_pic_sets) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).slice_segment_address + as *const _ as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265SliceHeader), + "::", + stringify!(slice_segment_address) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).short_term_ref_pic_set_idx + as *const _ as usize + }, + 12usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265SliceHeader), + "::", + stringify!(short_term_ref_pic_set_idx) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).num_long_term_sps as *const _ + as usize + }, + 13usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265SliceHeader), + "::", + stringify!(num_long_term_sps) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).num_long_term_pics as *const _ + as usize + }, + 14usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265SliceHeader), + "::", + stringify!(num_long_term_pics) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).collocated_ref_idx as *const _ + as usize + }, + 15usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265SliceHeader), + "::", + stringify!(collocated_ref_idx) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).num_ref_idx_l0_active_minus1 + as *const _ as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265SliceHeader), + "::", + stringify!(num_ref_idx_l0_active_minus1) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).num_ref_idx_l1_active_minus1 + as *const _ as usize + }, + 17usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265SliceHeader), + "::", + stringify!(num_ref_idx_l1_active_minus1) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).luma_log2_weight_denom + as *const _ as usize + }, + 18usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265SliceHeader), + "::", + stringify!(luma_log2_weight_denom) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).delta_chroma_log2_weight_denom + as *const _ as usize + }, + 19usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265SliceHeader), + "::", + stringify!(delta_chroma_log2_weight_denom) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).delta_luma_weight_l0 + as *const _ as usize + }, + 20usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265SliceHeader), + "::", + stringify!(delta_luma_weight_l0) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).luma_offset_l0 as *const _ + as usize + }, + 35usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265SliceHeader), + "::", + stringify!(luma_offset_l0) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).delta_chroma_weight_l0 + as *const _ as usize + }, + 50usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265SliceHeader), + "::", + stringify!(delta_chroma_weight_l0) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).delta_chroma_offset_l0 + as *const _ as usize + }, + 80usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265SliceHeader), + "::", + stringify!(delta_chroma_offset_l0) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).delta_luma_weight_l1 + as *const _ as usize + }, + 110usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265SliceHeader), + "::", + stringify!(delta_luma_weight_l1) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).luma_offset_l1 as *const _ + as usize + }, + 125usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265SliceHeader), + "::", + stringify!(luma_offset_l1) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).delta_chroma_weight_l1 + as *const _ as usize + }, + 140usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265SliceHeader), + "::", + stringify!(delta_chroma_weight_l1) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).delta_chroma_offset_l1 + as *const _ as usize + }, + 170usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265SliceHeader), + "::", + stringify!(delta_chroma_offset_l1) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).MaxNumMergeCand as *const _ + as usize + }, + 200usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265SliceHeader), + "::", + stringify!(MaxNumMergeCand) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).slice_qp_delta as *const _ + as usize + }, + 201usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265SliceHeader), + "::", + stringify!(slice_qp_delta) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).slice_cb_qp_offset as *const _ + as usize + }, + 202usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265SliceHeader), + "::", + stringify!(slice_cb_qp_offset) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).slice_cr_qp_offset as *const _ + as usize + }, + 203usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265SliceHeader), + "::", + stringify!(slice_cr_qp_offset) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).slice_beta_offset_div2 + as *const _ as usize + }, + 204usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265SliceHeader), + "::", + stringify!(slice_beta_offset_div2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).slice_tc_offset_div2 + as *const _ as usize + }, + 205usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265SliceHeader), + "::", + stringify!(slice_tc_offset_div2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).slice_act_y_qp_offset + as *const _ as usize + }, + 206usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265SliceHeader), + "::", + stringify!(slice_act_y_qp_offset) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).slice_act_cb_qp_offset + as *const _ as usize + }, + 207usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265SliceHeader), + "::", + stringify!(slice_act_cb_qp_offset) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).slice_act_cr_qp_offset + as *const _ as usize + }, + 208usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265SliceHeader), + "::", + stringify!(slice_act_cr_qp_offset) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).flags as *const _ as usize + }, + 212usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265SliceHeader), + "::", + stringify!(flags) + ) + ); +} +#[repr(C)] +#[repr(align(4))] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoEncodeH265ReferenceModificationFlags { + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, + pub __bindgen_padding_0: [u8; 3usize], +} +#[test] +fn bindgen_test_layout_StdVideoEncodeH265ReferenceModificationFlags() { + assert_eq!( + ::std::mem::size_of::(), + 4usize, + concat!( + "Size of: ", + stringify!(StdVideoEncodeH265ReferenceModificationFlags) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(StdVideoEncodeH265ReferenceModificationFlags) + ) + ); +} +impl StdVideoEncodeH265ReferenceModificationFlags { + #[inline] + pub fn ref_pic_list_modification_flag_l0(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_ref_pic_list_modification_flag_l0(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub fn ref_pic_list_modification_flag_l1(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_ref_pic_list_modification_flag_l1(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub fn new_bitfield_1( + ref_pic_list_modification_flag_l0: u32, + ref_pic_list_modification_flag_l1: u32, + ) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let ref_pic_list_modification_flag_l0: u32 = + unsafe { ::std::mem::transmute(ref_pic_list_modification_flag_l0) }; + ref_pic_list_modification_flag_l0 as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let ref_pic_list_modification_flag_l1: u32 = + unsafe { ::std::mem::transmute(ref_pic_list_modification_flag_l1) }; + ref_pic_list_modification_flag_l1 as u64 + }); + __bindgen_bitfield_unit + } +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoEncodeH265ReferenceModifications { + pub flags: StdVideoEncodeH265ReferenceModificationFlags, + pub referenceList0ModificationsCount: u8, + pub pReferenceList0Modifications: *mut u8, + pub referenceList1ModificationsCount: u8, + pub pReferenceList1Modifications: *mut u8, +} +#[test] +fn bindgen_test_layout_StdVideoEncodeH265ReferenceModifications() { + assert_eq!( + ::std::mem::size_of::(), + 32usize, + concat!( + "Size of: ", + stringify!(StdVideoEncodeH265ReferenceModifications) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!( + "Alignment of ", + stringify!(StdVideoEncodeH265ReferenceModifications) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).flags as *const _ + as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265ReferenceModifications), + "::", + stringify!(flags) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())) + .referenceList0ModificationsCount as *const _ as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265ReferenceModifications), + "::", + stringify!(referenceList0ModificationsCount) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())) + .pReferenceList0Modifications as *const _ as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265ReferenceModifications), + "::", + stringify!(pReferenceList0Modifications) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())) + .referenceList1ModificationsCount as *const _ as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265ReferenceModifications), + "::", + stringify!(referenceList1ModificationsCount) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())) + .pReferenceList1Modifications as *const _ as usize + }, + 24usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265ReferenceModifications), + "::", + stringify!(pReferenceList1Modifications) + ) + ); +} +#[repr(C)] +#[repr(align(4))] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoEncodeH265PictureInfoFlags { + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, + pub __bindgen_padding_0: [u8; 3usize], +} +#[test] +fn bindgen_test_layout_StdVideoEncodeH265PictureInfoFlags() { + assert_eq!( + ::std::mem::size_of::(), + 4usize, + concat!("Size of: ", stringify!(StdVideoEncodeH265PictureInfoFlags)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(StdVideoEncodeH265PictureInfoFlags) + ) + ); +} +impl StdVideoEncodeH265PictureInfoFlags { + #[inline] + pub fn is_reference_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_is_reference_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub fn IrapPicFlag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_IrapPicFlag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub fn long_term_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } + } + #[inline] + pub fn set_long_term_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub fn new_bitfield_1( + is_reference_flag: u32, + IrapPicFlag: u32, + long_term_flag: u32, + ) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let is_reference_flag: u32 = unsafe { ::std::mem::transmute(is_reference_flag) }; + is_reference_flag as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let IrapPicFlag: u32 = unsafe { ::std::mem::transmute(IrapPicFlag) }; + IrapPicFlag as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let long_term_flag: u32 = unsafe { ::std::mem::transmute(long_term_flag) }; + long_term_flag as u64 + }); + __bindgen_bitfield_unit + } +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoEncodeH265PictureInfo { + pub PictureType: StdVideoH265PictureType, + pub sps_video_parameter_set_id: u8, + pub pps_seq_parameter_set_id: u8, + pub PicOrderCntVal: i32, + pub TemporalId: u8, + pub flags: StdVideoEncodeH265PictureInfoFlags, +} +#[test] +fn bindgen_test_layout_StdVideoEncodeH265PictureInfo() { + assert_eq!( + ::std::mem::size_of::(), + 20usize, + concat!("Size of: ", stringify!(StdVideoEncodeH265PictureInfo)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(StdVideoEncodeH265PictureInfo)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).PictureType as *const _ + as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265PictureInfo), + "::", + stringify!(PictureType) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).sps_video_parameter_set_id + as *const _ as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265PictureInfo), + "::", + stringify!(sps_video_parameter_set_id) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).pps_seq_parameter_set_id + as *const _ as usize + }, + 5usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265PictureInfo), + "::", + stringify!(pps_seq_parameter_set_id) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).PicOrderCntVal as *const _ + as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265PictureInfo), + "::", + stringify!(PicOrderCntVal) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).TemporalId as *const _ + as usize + }, + 12usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265PictureInfo), + "::", + stringify!(TemporalId) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).flags as *const _ as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265PictureInfo), + "::", + stringify!(flags) + ) + ); +} +#[repr(C)] +#[repr(align(4))] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoEncodeH265ReferenceInfoFlags { + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, + pub __bindgen_padding_0: [u8; 3usize], +} +#[test] +fn bindgen_test_layout_StdVideoEncodeH265ReferenceInfoFlags() { + assert_eq!( + ::std::mem::size_of::(), + 4usize, + concat!( + "Size of: ", + stringify!(StdVideoEncodeH265ReferenceInfoFlags) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(StdVideoEncodeH265ReferenceInfoFlags) + ) + ); +} +impl StdVideoEncodeH265ReferenceInfoFlags { + #[inline] + pub fn is_long_term(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_is_long_term(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub fn isUsedFlag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_isUsedFlag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub fn new_bitfield_1( + is_long_term: u32, + isUsedFlag: u32, + ) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let is_long_term: u32 = unsafe { ::std::mem::transmute(is_long_term) }; + is_long_term as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let isUsedFlag: u32 = unsafe { ::std::mem::transmute(isUsedFlag) }; + isUsedFlag as u64 + }); + __bindgen_bitfield_unit + } +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoEncodeH265ReferenceInfo { + pub PicOrderCntVal: i32, + pub TemporalId: u8, + pub flags: StdVideoEncodeH265ReferenceInfoFlags, +} +#[test] +fn bindgen_test_layout_StdVideoEncodeH265ReferenceInfo() { + assert_eq!( + ::std::mem::size_of::(), + 12usize, + concat!("Size of: ", stringify!(StdVideoEncodeH265ReferenceInfo)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(StdVideoEncodeH265ReferenceInfo)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).PicOrderCntVal as *const _ + as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265ReferenceInfo), + "::", + stringify!(PicOrderCntVal) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).TemporalId as *const _ + as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265ReferenceInfo), + "::", + stringify!(TemporalId) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).flags as *const _ as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265ReferenceInfo), + "::", + stringify!(flags) + ) + ); +} diff --git a/generator/Vulkan-Headers b/generator/Vulkan-Headers index 4fee3ef..8c1c27d 160000 --- a/generator/Vulkan-Headers +++ b/generator/Vulkan-Headers @@ -1 +1 @@ -Subproject commit 4fee3efc189c83ccd26a9cd8265185c98458c94d +Subproject commit 8c1c27d5a9b9de8a17f500053bd08c7ca6bba19c diff --git a/generator/src/lib.rs b/generator/src/lib.rs index 141cce1..b93869d 100644 --- a/generator/src/lib.rs +++ b/generator/src/lib.rs @@ -1390,7 +1390,7 @@ pub fn variant_ident(enum_name: &str, variant_name: &str) -> Ident { // TODO: Also needs to be more robust, vendor names can be substrings from itself, id:4 // like NVX and NV let vendors = [ - "_NVX", "_KHR", "_EXT", "_NV", "_AMD", "_ANDROID", "_GOOGLE", "_INTEL", + "_NVX", "_KHR", "_EXT", "_NV", "_AMD", "_ANDROID", "_GOOGLE", "_INTEL", "_FUCHSIA", ]; let struct_name = _name.to_shouty_snake_case(); let vendor = vendors @@ -1409,6 +1409,14 @@ pub fn variant_ident(enum_name: &str, variant_name: &str) -> Ident { .unwrap_or_else(|| { if enum_name == "VkResult" || is_enum_variant_with_typo(variant_name) { variant_name.strip_prefix("VK").unwrap() + } else if variant_name + == "VK_PIPELINE_RASTERIZATION_STATE_CREATE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR" + { + "_RASTERIZATION_STATE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR" + } else if variant_name + == "VK_PIPELINE_RASTERIZATION_STATE_CREATE_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT" + { + "_RASTERIZATION_STATE_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT" } else { panic!( "Failed to strip {} prefix from enum variant {}",